Some software I’ve written in no particular order. This is hard to keep updated because I write software a lot. So for the authoritative list of open source software, see my BitBucket or my much less used GitHub.


Common Lisp

  • QTILITY: My idea of a utility library. Much of my other stuff depends on this.
  • CL-STRING-COMPLETE: A library for computing string completions. The completion object, a “completion tree”, can be added to and whatnot. This is complete in its single feature, but possible future additions include fuzzy completion.
  • CL-GAP-BUFFER: Implementation of gap buffers. Gap buffers are efficient data structures for “local string operations”, i.e., cursor-based line editing.
  • CL-GENERIC-ARITHMETIC: A library which turns most numerical Common Lisp functions into generic functions. I affectionately like saying this library makes Lisp’s slow numerics even slower. Unbeknownst to me, Greg Pfeil wrote something a little more comprehensive, covering just about all of the standard Common Lisp functions in his library LOOM.
  • CL-STOPWATCH: A library for reporting progress and timing, without using threads. Very lightweight. Also includes a timing macro which will compile code before it gets timed.
  • COMPUTABLE-REALS: I did not write the original code for this. Michael Stoll did. However I am maintaining it for Quicklisp. Anyway, this is a library for infinite precision real numbers, which are recomputed if the precision is increased.
  • CL-RAII: Provides a macro WITH which will call a destructor automagically when the object goes out of scope. The destructor is a generic function, dispatching on the class of the object. This library was a toy to show what Lisp can do, and better libraries for this kind of paradigm exist.
  • QSOLVE: An incomplete, work-in-progress library for solving combinatorial, twisty puzzles efficiently.
  • NUMERICL: An incomplete, work-in-progress library for numerical routines. Includes Raymond Toy’s implementation of quad-double precision numbers. Includes a work-in-progress pure Lisp implementation of bignums. Also includes miscellaneous routines such as hypergeometric summation by binary splitting, Chudnovsky’s formula, and a fast implementation of ISQRT which is now a part of SBCL.



  • yetilang: Mostly written by a guy who goes by the name yetifoot, with contributions by me. It is a BASIC-like language and virtual machine. Sports interesting things like garbage collection, lists, closures, and first class functions! I wrote quadlib in it, which heavily uses closures.

Fortran 90/95

  • Ranking: Code that was intended for a version of QSOLVE. This code is essentially ported to QSOLVE. The code can rank different kinds of sets of numbers, such as permutations, multisets, padded permutations, radix-representations, etc.

Miscellaneous Programs

Most of these are direct links to the latest (at the time of speaking) revision of a file. I might forget to update a link of a newer revision exists, so keep that in mind.

Common Lisp


I am a fan of Chicken Scheme, and most of these programs were tested only on Chicken Scheme. Moreover, Chicken Scheme contains some extensions which I may have used.

Most of the following software is here, which is time-independent. It also contains some other random snippets.

  • caddadaddr: Compute arbitrary, $n$th order car and cdr in Scheme, in a portable way. That is, generate $\textrm{c}[\textrm{a}\textrm{d}]^n\textrm{r}$.
  • DEFINE-OBJECT: A simple object definition macro, based on closures.
  • Coroutines: Coroutines, also known as generators, using CALL/CC.
  • Lindenmayer System: A general language simple rewrite rules. Intended for stuff like L-systems, or even ROT13!
  • Rubik’s Cube Scrambler: A program to scramble Rubik’s cubes, allowing one to define arbitrary generators.
  • FOR Loop: A simple FOR-loop for people who like that kind of thing. Example macro use.
  • “Pipe” Function: Sort of like the UNIX pipe. Really just a way to compose functions in postfix-order.
  • Macro Examples: Just some random macro examples.
  • GENSYM: A few ways to write GENSYM in Scheme.
  • Lazy Lists: Lazy, infinite lists in Scheme.
  • String Chunk: Poke around a Scheme string as if it were like C’s FILE, with rewinding, resetting, etc. In other words, treat strings sort of like streams.
  • Word Frequency: Calculate the frequency of words in text files.
  • Counter: Gives an extremely simple use-case of my favorite object in Scheme: closures. More for the educational value.
  • Random Knight Simulation: Move a knight in the Chess sense randomly.


  • Sieves: Fast and memory efficient Sieve of Eratosthenes and Sieve of Atkin. Evolved from bit twiddling code written by Thom Dixon.
  • Symbolic Differentiator: A symbolic differentiator, including expression parsing. Last time I compiled it and ran it, it was segfaulting on some stuff, and I haven’t cared to track down why.
  • Random Map Generator: A random map generator for tile-based, old-school RPG games. It generates a simple board containing walkable areas, hotspots, damaging spots, and passageways. Pretty simple.


  • imgurdl: A script to download porn imgur albums. May not work if imgur’s “API” (page layout) has changed.


  • Kaleidoscope: Code from the LLVM tutorial. I did not write this code, just put it together with a makefile. This code comes from the LLVM tutorial.

Standard ML

More programs really should be written here.