Projects

Here are some of my projects:

Active Development or Completed

Forumity.com

This is a from-scratch forum platform, marrying the sensibilities of traditional community-focused forum platforms (vBulletin, XenForo, phpBB, etc.) with the inter-connectedness of modern news-aggregator platforms (Reddit, Digg, Lemmy, etc.)

I originally started working on this because I wasn’t satisfied with free forum software, and didn’t want to pay for proprietary forum software. But it’s grown in scope since then.

DropdownMenus (Extension for phpBB)

A client requested that I add dropdown menus to their phpBB site, and I built that functionality as a phpBB extension and published it.

Abandoned or On Hiatus

X/Y Game Engine

I’ve been a big fan of Bethesda Game Studios ever since Morrowind came out. Their games all use some derivitive of a 3rd-party engine called Gamebryo (previously known as Netimmerse). I’ve always felt that there was something special about Morrowind/Skyrim/Fallout/etc., but it wasn’t until I started doing a deep dive into the Gamebryo engine that I realized what it was: The engine is heavily based on the idea of a “scene graph”, which is a hierarchical data structure that stores, essentially, the game world. Rendering is done by walking the scene graph (which is a tree data structure) downward toward the leaf nodes, accumulating rotation/scaling/translations as you do the walk, then rendering each leaf node, and then walking back up the tree to build bounding volumes (for collision detection and occlusion culling). This is a very elegant way to do rendering, but it’s very difficult to get good graphical results, because it’s hard to special-case things without making a mess. I think this is why Bethesda games have a very distinct look to them, and why they are so easy to mod. I started writing my own engine based on this idea, but 3d math is very tedious and I got bored of it. I might come back to it someday.

Outro Music Composer

A long time ago, in the early days of personal computers, people started making music files in a format called MIDI. Basically, the file contains a sequence of tracks, which contain notes, and are played with a given instrument (often, a synthesizer chip on your PC). Because the file doesn’t contain the audio itself, and it only invokes samplers/synthesizers on your PC, the files are very small, and also very easy to work with. I used to use a program called Jazz++ to edit/modify/create MIDI files, but it was always very buggy and it’s only gotten worse over the years. I really liked the user interface though, and want to create something similar. Truth be told, I have barely started on this, probably because it’s such a simple project that it’s not that interesting.

The Plain Programming Language

Inspired by the aims of the COBOL language, I wanted to make a language that was more similar to human language, while still being somewhat practical. I also wanted it to be a compiled language, because this was a learning project also, and I wanted to do the while thing, you know? I started brainstorming and came up with:

define procedure fizz-buzz with argument n with type integer
    define variable x with type integer and initial value 1
    repeat while x is less than n
        if x is divisible by 3 and x is divisible by 5 then
            print "fizz-buzz"
        else if x is divisible by 3 then
            print "fizz"
        else if x is divisible by 5 then
            print "buzz"
        else
            print x
        end if
        increment x
    end repeat
end procedure

I’m working on the compiler frontend for this language.

Language-Learning App

I’m completely sold on the concept of spaced repetition. I’ve been using Anki for years, and I’ve memorized a lot of things with it. At some point I switched to Memrise, because it’s more fun and it has a better UI. However, a lot of the courses on Memrise rely on procedurally-generated quizzes, and the system isn’t flexible enough to handle some languages. For example, modern Greek has multiple letters that map to the same sound, but Memrise will happily present you with a sound clip of that sound and ask you to type the letter. It’s maddening! So I want to make my own language learning app, with a more flexible set of rules for generating randomized flashcards. I have a data model and a UI mockup, but I haven’t started coding it yet.

Multimedia Subsystem for Linux (MSX)

The Linux kernel is, despite what many people think, quite fully-featured. With just the kernel and no other standard Linux components, you can basically do anything you want. You have drivers, networking, GPU support, filesystem access. I thought it would be fun to take it a step further and build graphical and multimedia support into the kernel. Unfortunately, the actual GPU and audio interfaces in the kernel are not well-documented, so I’ll have to dig through the source code to figure out how to use them. I did get a simple GUI going with just the framebuffer functions within the kernel. It was really cool to see! Unfortunately, the kernel codebase churns a lot and as I was working on this, a kernel update broke the framebuffer code. I considered that a sign that I should move on to less silly projects.

The Last ‘040

I’m a big fan of the Motorola 68k series of CPUs (who isn’t?!). I was looking at emulators for the 68040 (the last consumer-grade 68k CPU) and I noticed that most of them were intended to be used as appliances, that is, they aren’t really that interesting. I want to be able to pause the emulator and inspect the registers, memory, etc. I want to be able to step through instructions. I want to be able to see the CPU state change in real time. I want a built-in assembler/disassembler, maybe even a built-in C or Pascal compiler. So I just started building a 68040 emulator in C# and WinForms. It’s far from done, but I was able to step through a few instructions and they match what MAME does, so I’m pretty happy with it so far. I called it “The Last ‘040” because it’s the last 68040 emulator you’ll ever need, and I was thinking about the game “The Last v8” (which I never played, but the music is great). Oh, as a bonus, here’s a blog post I wrote about decoding 68040 instructions: Decoding the Extended Addressing Modes of the 68000

Saurian Kernel

I started writing my own x86-64 operating system kernel, with a Windows-like driver interfaces and Windows-style IO Request Packets. This would be a big departure from most hobby operating systems, which closely mimic Unix/Linux. I had some basic things working. Actually, most of the hard parts are handled by UEFI/ACPI: loading files from disk, accepting keyboard input, mapping out available RAM address ranges, enumerating devices, it even comes with a framebuffer per the UEFI standard. I had a lot of fun writing automatic loaders for drivers based on ACPI/PCI device IDs. However, at some point I ran into the most annoying bug in OS dev (improperly mapped virtual memory) and stopped working on it. I probably won’t come back to it, because I don’t think it has a lot of potential. Getting hardware vendors to write drivers for it is a non-starter, and I don’t think there’s a lot of interest in a Windows-like OS that isn’t compatible with Windows.