Code

My code

On this page are some of the personal projects I've undertaken, in a very roughly reverse
chronological order. Most are old and don't reflect my current style and ability. Also, this
actually represents only about half of my personal projects; the rest were lost in a hard-drive
crash several years ago. I've since become a
backup evangelist.

Battle Brothers mod kit, Language: C, License: None (public domain)
This is a simple collection of tools to help decrypt, decompile, recompile, and encrypt script
files for the game Battle Brothers. It was long said that modding the game is impossible, but no longer!

Satellite Network Calculator,
Language: Javascript, License: None (public domain)
This is an interactive calculator that helps design equatorial satellite communication
networks in Kerbal Space Program. It was designed for use with the
RemoteTech mod,
but may be useful with the communication network support added to KSP version 1.2 as well.

taldl, Language: C#, License:
None (public domain)
This is a simple program I whipped up one night to download episodes of This American Life from
the internet. (The website lets you
listen online for free but wants you to pay a dollar per episode to download them.)

ExePatch,
Language: C#, Licence: GPL v2
ExePatch is an assembly IDE designed to simplify the development of binary
patches to executables, such as when creating code mods for video games,
although it should work for many kinds of executable patching needs.

WebDAV server,
Language: C#, Licence: GPL v2
This library implements a flexible, extensible, and quite standards-compliant WebDAV server
built on ASP.NET. The WebDAV server can serve any type of hierarchical data, not only files. It
supports transparent compression, partial transfers, partial updates, locking, editing, dead
properties, strong typing of WebDAV properties, request preconditions, and other features.
Setting up a simple WebDAV server to serve some files only requires adding some lines to your
web.config file; no code needs to be written. If you want to serve another type of data over
WebDAV, it's fairly easy to implement new service providers.

Capitalism 2 Mod Kit,
Language: C#, Size: 218k, License: None (public domain)
This is a mod kit that allows you to edit the game database for Capitalism 2 using a spreadsheet,
and to edit many of the game's graphics. Sad to say, editing the database requires an installation
of Microsoft Excel 2007 or later, but it's very convenient. (Excel isn't required to edit game
images.) It's based on my efforts to reverse engineer the game, described
here. I used
the mod kit to create a mod that
rebalances the game.

Dangerous Waters Mod Utilities,
Language: C#, Size: 79k, License: GPL v2
This is a collection of mod utilities for the game Dangerous Waters. Currently, it only
includes one utility, which allows you to manage the .grp/.ndx archive files used by the game to
extract and alter game assets. It also includes a list of all the command-line arguments
recognized by the game, including ones for debugging. Some details about the file formats and my
reverse engineering effort can be found
here.

pad, Language: C#, Size: 69k, License: GPL v2
This is a simple console application to perform high-speed encryption and decryption of files.
It's named "pad" because it was originally designed for one-time pads, but that's no longer
supported.
It's intended to be used to encrypt and decrypt large files and/or a large number of files
quickly. It can encrypt entire directory trees (or subsets thereof), and a novel feature is
that it can encrypt and decrypt not only file contents but also file and directory names. This
makes it useful for quickly obscuring the contents of a large directory tree. Files are
encrypted and decrypted in place with only very small changes to the file size, so in the great
majority of cases, no additional space must be allocated on the filesystem.
A previous version of this program didn't change the file size at all, but that made it
impossible to use per-file IVs or to detect incorrect decryption keys or passwords. The current
version is much improved in those respects.
A program like GPG would store the ciphertext in a separate file, leaving the plaintext allocated
on disk and plainly visible to simple forensics tools if it was not securely deleted, and taking
up substantial disk space when dealing with large files. GPG would also be slower. That said,
pad is not intended to be a replacement for a sophisticated encryption program like GPG.

Maneubo, Language: C#, Size: 190k, License: GPL v2
Maneubo is a program that was originally intended to provide a kind of virtual maneuvering board.
A maneuvering board is a specialized chart used to plot the motions of craft, compute intercept and
avoidance courses, etc. Maneubo does not provide a true maneuvering board, and in fact I consider them
to be more or less obsolete, but Maneubo dispenses with the chart and automates the calculations,
allowing you to do the same kinds of things much more conveniently. It is intended to be used
along with simulations (e.g. submarine simulations) as an aid, but as it contains the basics of a
general vector-based plotting tool, it might be useful for other things.

du, Language: C#, Size: 8k,
License: None (public domain)
This is a very simple console application I wrote to help me free up some disk space. It scans a
directory and prints the items that are taking the most space.

IrcLib, Language: C#,
License: GPL v2
This is a simple and easy-to-use IRC client library. It was created as part of the latest
version of HalBot, but can be used for other things.

Battery Charger, Language: C and assembly,
License: GPL v2
I created a NiMH battery charger, and this is the control software for it.

Picture Sorter, Language: C#, License: GPL v2
This is a program that makes it easier to rename, rotate, and resize large numbers of
pictures, generate thumbnails for them, and convert their image formats. It supercedes the
Nails program I developed.

Terrain Generator, Size: 184k, Language: C#,
License: GPL v2
This is a prototype terrain generator that I was writing for use in a clone of the game
Dwarf Fortress. I didn't finish the game, but the terrain generator was pretty nifty.
It's a fractal terrain generator based on coherent noise. It simulates the effects of wind
(including rain shadows) as well as thermal and hydraulic erosion.
See the source code to find all the keyboard commands that control it.

GPG Desktop, Language: C#, License: GPL v2
This is an attempt to make encryption simpler to use for the average person by providing
a front end to the GNU Privacy Guard. The
front end is built on top of my
OpenPGP security and UI libraries.
It provides a powerful key manager, and wizards to walk the user through basic
tasks, such as encryption, signing, decryption, and signature verification.

AdamMil.net libraries,
Language: C#, License: GPL v2
A bunch of things that I've written and found useful. This is a relatively high quality set of
libraries, with good documentation, comments, and unit tests. It covers collections, IO,
artificial intelligence, mathematics, UI, security, and transactions.
Some parts are works in progress. I add things to this every so
often, usually after I've written something for the second or third time and decide to
generalize it so I don't have to write it ever again.

Nails,
Size: 22k, Language: C#, License: GPL v2
I used to have a bash shell script to create thumbnails using
ImageMagick, but I lost it. Since then,
I've been too lazy to do much with pictures because making thumbnails out of them is such a
pain. Finally I whipped together this simple program to automatically create thumbnails from a
bunch of image files. It supports a couple different resize modes and a somewhat flexible
thumbnail naming scheme, and it's simple (if unintuitive) to use. This program has been
superceded by the Picture Sorter program I wrote.

Gene Hackman,
Language: C#, License: GPL v2
Originally called "Bugger", Gene Hackman is a framework for genetic programming. A novel feature
is that it supports an ongoing tournament mode, where programs compete in real time rather than
well-defined and distinct generations. This lends itself to certain problems well, such as those
where programs can interact with each other. It also supports parallelizing the simulation
across multiple threads and compiling it to native code, among other things. I've applied it to
the problem of creatures learning to find food and survive in a simple world, and that
application is included in the source. It presents the world and its inhabitants in a graphical
manner, so you can watch them evolve. It wasn't meant for release, so some of the application
code is messy, but the framework itself is pretty good.

Sudoku solver,
Size: 10k, Language: C#, License: None (public domain)
Although the game Sudoku is all
the rage, I don't like to play it. I don't like to play any game that I feel can be easily
automated -- I'd rather spend the time writing a program to automate it. So here it is, a
program to solve Sudoku puzzles.

C# enscript state file
If you use GNU enscript
to do syntax highlighting, you might be interested in my state file for C# (which lets enscript
highlight C# files). I made this because I wanted to have C# syntax highlighting on my
Subversion server. It's not perfect, but it does the basics.

Flatarity,
Size: 442k, Language: C#, License: GPL v2
Flatarity is a clone of Planarity, with
some added features like selecting multiple vertices, rotating and flipping them, etc. The
latest source is available
here.
I whipped this up in few hours while at work, so the code quality isn't that great.

Jappy, Language: C#, License: GPL v2
Jappy is a Japanese dictionary program I wrote for myself. I have a whole laundry list of
features I mean to implement but probably never well, but it's already pretty useful. It has
word lookup, text translation help, example sentence search, and study helpers. Plus, you can
easily jump between different parts of the program -- highlight some text and right-click to
search on it. Or click to translate Japanese example sentences. Or click a headword to see
example sentences containing it, etc.

RotationalForce,
Language: C#, License: GPL v2
The Rotational Force Engine is a vector-based 2D game engine I was working on, along with an
editor for it. It's actually pretty fancy, as far as it got anyway. It supports splines,
stroking, dynamic level of detail, mounting and linking objects, nifty object tracking and
camera animation, and, well, lots of features. As usual, though, I never finished it.
But you can check out some screenshots of the editor.

WebCrawl, Language: C#,
License: GPL v2
WebCrawl is a web site spiderer I wrote after being frustrated by httrack, which is supposed to
be the best. Httrack was taking way too much CPU time in the GUI mode, didn't provide good
enough feedback in the console mode, and didn't provide enough control overall. So I wrote a web
crawler backend and a console frontend for it. It can be used much more easily than httrack. It
has a number of features that httrack doesn't, such as rewriting URLs and page content on the
fly with regular expressions or arbitrary processing code, which enables a few interesting and
important scenarios. I use it to mirror sites for offline reading, mainly so that I can ensure
that I still have a copy even if the site gets taken down. New version (May 3rd, 2008) adds a
graphical frontend.

BuLang,
Size: 33k, Language: C#, License: GPL v2
BuLang is a relatively simple programming language that I whipped up over the course of a few
hours to help my girlfriend automate some of her finance homework. I heard that she was
performing bond valuation calculations by hand, which requires hitting hundreds of buttons on
the calculator to get the result. And of course, one mispress would throw the answer off. It
sounded like such a huge pain in the ass that I just had to do something! The language has
specialized constructs like 'sigma', which computes the summation of a sequence (a common
operation in finance). The program provides a text editor and a console window. In the zip file
is the bond valuation function I wrote as an example. Although it was thrown together very
quickly, it's actually pretty clean code, and a potentially useful starting point for the
creation of other little languages.

Space Winds, Language: C#,
License: GPL v2
This was going to be a clone of the old game Solar Winds, but with updated graphics. I
learned some rudimentary 3D modeling for this game, and created a couple ships. The code lets
you fly one of the ships while being attacked by an AI flying the other ship. The part I like
best is that the weapons on the ships are separate entities and can rotate independently. It
just looked cool. :-) Alas, I never finished it.

Halbot, Language: C#,
License: GPL v2
This is a rewrite of Halbot in C#, using my own Markov model
implementation. New version (July 29th, 2010) is completely rewritten, supports RSS feeds,
tracking conversations, and smarter analysis, and contains much cleaner code.

NetLisp, Language: C#, License: GPL v2
NetLisp is the technological successor to Boa. Like Boa, NetLisp works both in an interpreted
and compiled mode (and unlike Boa, the interpretation support is complete), and targets the .NET
framework. However, NetLisp is modeled after Scheme and other LISP languages. It includes three
interfaces -- an embeddable .DLL, a command-line interactive shell/compiler, and a rudimentary
IDE.

Boa, Language: C#, License: GPL v2
Boa is a language similar to Python. It's both interpreted and compiled, targetting the .NET
framework. It includes three interfaces -- an embeddable .DLL, a command-line interactive
shell/compiler, and a rudimentary IDE.

Markov, Size: 29k,
Language: C#, License: GPL v2
A man from Taiwan recently emailed me asking about HalBot. He wanted to
study how it works. Since it's based on MegaHal by Jason Hutchens, it's pretty hard to
understand, since that's how Jason likes his code (you know, job security and all). So I created
a very simple Markov chain implementation. It can use an arbitrary model order, so you can
tweak that and see the effect it has on the output. It's not meant as a replacement for MegaHal,
since it doesn't attempt to make conversation. And it isn't really meant for general
consumption, but I figured I'd share it anyway. Since it's written it C#, it requires the .NET Framework in order to run. Incidentally, the Megahal source has improved
quite a bit since I created HalBot. It's been taken over by somebody who's in the process of
cleaning it up and commenting it.

Smarm, Language: C#,
License: GPL v2
This program is a level editor for the game Swarm. Swarm is being developed by Jim Crawford. The primary impetus behind the editor was that
the levels, bitmap in nature, are too large to be edited in a bitmap editor such as Photoshop (a
single level may be easily be 600 megabytes uncompressed). Thus, the editor presents what
appears to be a single, huge, layered image but which is actually being streamed from thousands
of smaller images in a sparse matrix. The smaller images themselves are stored using a virtual
filesystem which resides inside a single file, because having 20,000 files comprise a single
level is just plain unprofessional, and an awful waste of space, too, when you take cluster size
into account. In addition, the level is drawn at 16x normal size and scaled down for the actual
game. This provides a nice antialiased look to the artwork. The editor allows zooming out up to
1/256th the actual size, because the levels can get really big. The editor also includes object
and polygon editors and a pretty spiffy UI. The code itself is pretty messy, though, as it's a
work in progress and was put together fairly hastily. This project uses the
GameLib library.

Triangle Chase .NET rewrite,
Language: C#, License: GPL v2
Yet another game that'll probably never get finished. This is a rewrite of Triangle Chase using C# and the new GameLib.
It's basically the same game, updated slightly (24-bit graphics instead of 8-bit, for instance).
The majority of its reason for existence is merely to test the new GameLib. The code is a tad
crappy because it was started as an almost direct port of the C++ version, including all the old
design flaws. I've since fixed a few, but many remain.

Chrono .NET rewrite,
Language: C#, License: GPL v2
This is a rewrite of Chrono, a Roguelike engine/game. The design is much
cleaner than the old one, and should be far more easily extensible. The game is written in pure,
portable C# and contains all code except the low-level input/output, which is encapsulated
within a single class. Multiple input/output classes can be created for different front-ends.
Note that some parts of the code have not been fully thought out, yet, so bits of the design
are sure to seem peculiar.

.NET port of AU.Common library,
Language: C#, License: LGPL v2.1
This is a port of the AU.Common ActiveX library to the .NET framework.
It doesn't support the exact same API, but the interface is very similar in functionality. It is
designed to aid in the creation of .NET components and ASP.NET applications, and like AU.Common, it is a work in progress. The source code seems to have been
lost.

Dictionary server library and client,
Size: 10k, Language: Python,
License: GPL v2
This small project is my first Python program. It consists of a Python module that implements
the dictionary protocol described in RFC
2229, and a client program that uses the module. Errors should be caught by the program, but
are not handled elegantly. As it's my first Python program, it was meant to be a learning
experience, not an exercise in good coding style, and it shows. The application allows you to
get definitions of words from various online dictionaries. As an added bonus, if you invoke the
program as "thes", it will connect to server with a thesaurus by default. You can do that by
symlinking "thes" to "dict". (Invoking it as "thes" just modifies some defaults. You could do
the same thing on the command line or with an alias/script). The default server selections
should be fine, but see www.dict.org for a list
of additional servers.

GameLib, Language: C#, License: GPL v2
This is actually the third and a half version of my "game" library. The first version was
intended to be a library that allowed games to be written portably for DOS or Windows. The
second iteration dropped DOS support and focused on providing a lot of functionality for
multimedia/graphical applications running under Windows, including streaming playback of many
video and audio formats, scripting support, and other fancy things. The next version departed
from the game genre and aimed to abstract away the operating system, allowing programs to be
written portably. I got it compiling under Windows and Linux and had plans for other unixes,
including Mac OS X to be supported as well. The game-specific parts weren't done, but the OS
abstraction was working and very useful. Eventually, though, I realized that with mono coming along so nicely, I might as
well build this atop the .NET framework, which would have the added benefit of being
language-agnostic and not tying any potential users to C++ as well as reducing the amount of
work I would have to do.

ActiveX
library to aid in ASP and COM development,
Version: release 4, Language: MSVC++ 7 ATL, License: LGPL v2.1
This ActiveX library is a set of tools to aid in the creation of ASP pages and other COM
objects. It comes from years of experience working with ASP, but is not quite complete. As of
release 4, the library also includes a number of server-side and client-side javascript
libraries. I encourage use, testing, and feedback. I plan to finish this if work permits. Due
to numerous limitations in the compilers that come with Microsoft Visual Studio 6.x, this code
only works with the updated compilers from MSVC++ 7.0 (.NET). These can be downloaded for free
from Microsoft. It also requires the ATL library that comes with MSVC 7. You can use the Code Documentation Helper to generate documentation for this library.

Statistics-based Spam Filtering, Version: 0.87 alpha,
Size: 21k, Language: Emacs Lisp, License: GPL v2
For all of you who are afflicted by spam, run VM for Emacs, and don't have a large collection
of emails to run through one of those other spam filters, you might consider checking out my
implementation of the basic ideas present in the article "A Plan for Spam" by Paul Graham. My
implementation is given as a patch to the VM 7.17 source code, but I also have
patches for older versions: VM-7.14 and VM-7.07. After training it on a couple weeks' worth of
email, it caught about 100% of my spam with no false positives! Note: I now use Bogofilter, with some
custom LISP code to interface it with VM. If you'd like that code, let me
know.

Code Documentation Helper,
Version: 0.91 beta,
Size: 13k, Language: Perl, License: GPL v2
This simple tool aids in the documentation of code by allowing you to specify the documentation
for functions, variables, etc. inline as comments. It can then scan the source tree (or whatever
files you tell it to) and generate HTML documentation. Speaking of documentation, I'll have to
write some so you can figure out how to use it :-) It's not nearly as intelligent as the other
tools out there, but it fits my needs better than most of them, and anyway it was written before
they were. Note: For .NET code, I now use the built-in XML documentation in conjunction
with NDoc. For other types
of source code, I've heard that Doxygen is pretty good.

My Emacs Customizations, Size: 23k, Language: Emacs Lisp,
License: GPL v2
While Emacs may be the
one trueeditor and scientifically proven to be the
bestest editor ever, most of its greatness comes from its extensibility. So, I've hacked some
extra stuff into it, like shift-selection, alt switching, some kill safety, better (for my
style) auto-indentation mode for C/C++ modes, better (imo, again) indentation functions, more
intelligent movement/editing primitives, some new key bindings, and a bunch of other stuff. This
is in flux as I add new features and tweak/fix existing ones. This is my default.el file.

HalBot, Size: 72k, Language: C++
I based this on MegaHal by Jason Hutchens. It's essentially a chat bot that goes onto IRC (a
chat network) and engages in conversation. It can be trained however you wish, and since it
doesn't use any fixed rules, is capable of learning any language... including non-spoken ones.
Sometimes it's pretty damned funny to watch people attempt to converse with it. Usually that's
because it eventually offends them terribly. This wasn't meant to be used by anyone but me, but
has a fairly decent interface, if you don't mind text mode. HalBot has been since
rewritten in C#.

Dvorakish layout, Size: 27k,
Languages: x86 assembly and C, License: None (public domain)
This is a modified keyboard layout, based on Dvorak, which I think is superior for people who
type more punctuation characters than most. I actually said it was "optimized for coding" when I
finished it, but I have no proof to support that claim, and it's really only optimized for the
languages I code in, namely C/C++. Basically, it's good for languages that have lots of
punctuation, and also English text, of course. It's implemented as a TSR for DOS, a .KBD file
for Windows 9x, a .DLL for Windows NT, and various files for *nix loadkeys, loadkmap, and the X
key mapper. New version (June 8th, 2003) updates the xmodmap version to add all the
international keys and fix the bug where under many window managers, the special X key
combinations would fail to work. New version (January 19th, 2006) adds a DLL for 64-bit Windows
NT, cleaner installation for Windows NT (no dealing with Windows File Protection), and the
source code for the 32/64 bit NT DLLs. Also, the size of the NT DLL has been cut down to 1/4th
its previous size. New version (July 24th, 2008) adds another keyboard layout, which is the same
basic Dvorakish layout modified for typing Estonian text. New version (April 11th, 2012) updates
the xmodmap format to work better with modern X windowing systems.

6502 CPU Debugger, Size: 67k,
Language: C++, MFC, License: GPL v2
6502dbg - A debugger for 6502 assembly code. My first (and so far, last) attempt at writing a
debugger. It worked fairly well at the time, but seems to have rotted a bit. There were actually
two incarnations of this project... one in pure C using the Win32 API, and the other in C++,
using the MFC (my first MFC project). I wrote it so a friend could debug some 6502 code
(actually music code for the NES), but just about when this was getting useful, he fixed the bug
and then lost interest, so this was no longer needed.

FastLoot, Language: C++ COM
I'm VERY happy with this. Back when I played UO (Ultima Online), which is to say back when it
was actually a good game and not the piece of crap that it is now, I wrote this program that
allowed me to make as much gold in an hour as I normally did in several days of hunting.
Basically, I got all the loot from all monsters killed in my vicinity, as well as all the good
stuff that happened to be on the ground. It was also nice for the randomly spawning regs that
few people took the time to pick up. The encryption algorithm and the packets have changed since
this was written, so it won't work anymore, but will still live on in memory. Ahhh... those
were the days...

Third, Size: 18k, Language: C,
License: None (public domain)
A compiler for a language of my own design, named "Third". It's difficult to code in, but also
pretty fun, much like Brainfuck, but without quite so much masochism involved. Actually it's not
much like Brainfuck at all, since Brainfuck was designed to be simple - exceedingly simple, as a
language that is. Third supports lots of operations, but they're all one character, so you can
make some really compact code. It supports named functions and variables too, as well as
strings. I remember I wrote a Brainfuck interpreter in Third, and then ran a Brainfuck
interpreter written in Brainfuck. It was wild. Unfortunately, I tried to improve the compiler a
year later without first making a backup, and broke it. By the way, this is not representative
of good compiler design by any stretch (or language design, for that matter), but, hey, it works
(or, worked) and was pretty cool back when I wrote it.

Regexp Matcher, Size:2k,
Language: C++, License: None (public domain)
This is a simple regular expression matcher. I just coded it so I could say that I can do it.
It doesn't accept standard regexp syntax, mostly because that would require writing a recursive
parser. And, it could be easily extended to support more regexp constructs (like {} and []), but
I didn't implement very many because that's not the part I was interested in.

GuiLib, Language: C++
GuiLib is a Windowing API, written to run under... uhh... Windows. It was my attempt at creating
a neat object oriented model, sort of like MFC, but less complicated. It was indeed simple to
use, but quite nonpowerful. Or, rather, things got ugly when you decided to do anything outside
the design boundaries, which were rather limited.

Minesweeper, Language: C++
The classic game, written with GuiLib, which means the GUI sucks. It has a "hint" button,
though, which doesn't actually give a hint, but instead attempts to solve the puzzle
programmatically.

Ronx, Size: 102k,
Language: C++, GameLib, License: None (public domain)
Ronx is a graphical dungeon crawl done with vector graphics that I put a ton of work
into, but never finished... like everything else. The code is not too bad, though.

MudTerm, Size: 44k,
Language: C++, MFC, License: None (public domain)
MudTerm is a MUD client, written when I played MUDs. Supports color and all that and is actually
pretty nice, but the feature that was going to set it apart was the fact that it would
automatically map the world for you. I haven't seen any that do that well. But then I realized
it would be difficult to automatically detect the method of changing world areas for all MUDs,
so I stopped "temporarily" to develop a scripting language. I never finished the scripting
language, due to work taking all my time, so I never finished this, either. In retrospect, I
should have embedded Perl or something. The code seems to have rotted a bit.

GSL (General Scripting Language), Language: C++
GSL is the scripting language I was developing for MudTerm. It's similar to javascript but
without a lot of the inconsistencies and nonintuitiveness, and with better support for objects.
It could actually compile various scripting languages into a common language runtime, and then
interpret the runtime.. and you could expose objects to the script and vice versa. Or, that's
what it would have done if I had finished it. I got the parser generator, the parser, the lexer,
and the assembler/disassembler done. Then I got in trouble for dumping too much time into it,
and had to stop to catch up on all the work I hadn't done. I haven't really touched it since,
and the code for the parser is pretty icky.

do, Size: 9k, Language: C,
License: None (public domain)
A damn useful utility that I never use anymore. Essentially, it performs an operation on a bunch
of files/directories, etc. It's good for programs that don't accept wildcards. If you've needed
something like this, you probabably know what I mean. Actually, it's similar in spirit to xargs
but not quite the same (and it's for Windows).

Triangle Chase, Size: 55k,
Language: C++, GameLib, License: GPL v2
Triangle Chase is a damn fun game based on Rocket Chase. It was written with fairly
nice (or so I thought at the time) object oriented code. Unfortunately, the network paradigm had
too many lag optimizations that ended up making the network play frustrating. Still fun, though,
and the closest I've come to a completed game (sadly).

Artificial Intelligence, Language: C++, GameLib
General AI stuff, mostly using genetic algorithms, but also one using a rudimentary neural
network. I intended to write a cool genetic programming program, but didn't have time. AI is
cool stuff.

AdamOS, Size: 38k,
Language: x86 assembly, License: None (public domain)
AdamOS. It has a pretentious name, but that should be allowed, given that it's an operating
system written in 100% assembly. It was coming along quite nicely, until I accidentally restored
a backup instead of creating one, undoing countless hours of work. (I was just getting process
support implemented.) I exclaimed something vulgar, and haven't worked on it since. This is a
very old project, written while 16-bit real mode operating systems were still in common use.
Today, such an operating system would be laughable.

Boids, Size: 5k,
Language: C++, GameLib, License: None (public domain)
Boids is a little program I started whipping up. It basically uses mathematical formulas to give
motion to little creatures (colored triangles, actually). The formulas correspond to actions,
like "seek", "arrive", "flee", etc. It's a neat way to program movement. The code isn't very
clean, though, because I just whipped it up in about 20 minutes on a whim.

BoloBrain, Language: C++, GameLib
A brain (AI) for a nice Windows clone of the famous Mac game, Bolo.

bump, Size: 7.7k,
Language: x86 asm, C, OLD GameLib, License: None (public domain)
bump implements software bump mapping and was written long before most people had even heard of
the term. You could load any 2D image and it would attempt to create a height map (or you could
supply one). Then, you could move the light source with the mouse. It looked pretty damn cool
and with a good height map, it was awesome for making 2D images seem 3D.

Chrono, Size: 31k,
Language: C++, GameLib, License: GPL v2
A roguelike (like nethack), or rather, a roguelike engine.
It's in text mode, as most roguelikes are. I was too lazy to write good
visibility code (instead I wrote short, simple visibility code), and quit
when I actually needed to come up with content.

TabComp, Size: 12k,
Language: x86 assembly, License: None (public domain)
TabComp is a file/directory completion TSR for DOS, written in assembly. I eventually discovered
that the NT command prompt has this built-in (disabled by default, though), so I never finished this.

TelnetSvr, Language: C++
TelnetSvr is a generic text-based server that supports plugins. Basically, you just handle the
text, and TelnetSvr takes care of the network stuff. I began writing this for a friend who
didn't want to deal with network code, but wanted to have some kind of text server for something
or other. He stopped working on whatever it was, so I stopped working on this.

Zirc, Language: C++, MFC
Zirc is chat client designed to make the writers of all other chat clients give up and die.
Essentially it was a fully scriptable (using GSL, above) chat client that supported IRC, ICQ,
AIM, MSN, and all the other chatting protocols. Or it would have been, had I finished it. I
found out that somebody else was already way ahead of me with the protocol support, even though
their actual client really sucked, so I lost motivation.

ZWorldZ, Language: C++, GameLib
ZWorldZ is an online, massively multiplayer game. How many times have you heard that before?
Well, this was going to be a really awesome one -- one that combined all the greatness of the UO
(back when it WAS great) with some of my own ideas, but I never finished it. I got the rendering
engine done, and that was about it. Nice code, though, or so I thought at the time.

Quake Golf, Size: 532k,
Language: Quake C, License: None (public domain)
This was an addon to Quake that implemented golf. The golf "ball" was a bloody, hydrophobic head
that was still alive and liked to bite. Somehow it could jump around and scream too if it got
too scared. You had to move it around with your weapons (or your hands if you didn't mind the
biting) in an attempt to be the first person to knock it through the goal. And you could shoot
it out of other people's hands (or just kill them), of course. The addon also implemented other
things, like objects travelling through teleporters, so if you're just about to kill a guy and
he jumps through a teleporter, just fire a rocket right on through! ;-) He'll never expect that
to teleport in right behind him. Ahhh... this was a really fun mod. Unfortunately, the file I
have available for download is a very old version. The latest version (which had many bugfixes
and some other improvements) has been lost.