The following projects contain substantial amounts of open-sourced code and/or design. They are useful stand-alone projects that I use now or have used in the past.


Zap is multiple prototype CMSes that lets you edit locally and deploy your site using git. The guiding principle of ZAP is to keep your content in git. The rest is still being explored. Currently, ZAP is still being prototyped, with two branches that you might find interesting:


This is a fairly complete CMS that provides an in-browser editor powered by AngularJS. Content is stored in your file-system and you are expected to manage it via git. Editing is done locally and a copy of ZAP must also be running on your server in read-only mode to provide search, rendering etc. This version also has fairly good test coverage.

Ultimately, this became overly complicated and unwieldy, with an annoying dependence on Elasticsearch (this was needed even while editing your site offline).


A rewrite that includes some of the lessons I have learned from the master branch. Currently implemented as a static site generator, it reads files from your project folder and assembles the website as you wish. Extra features such as SASS/LESS compilation, GUI editor, search are not implemented and likely will never be. This removes complexity from ZAP and lets tools that are good at those things (Makefiles, gulp.js, your text editor, etc.) handle those parts. Features:

  • very nice error messages for the user
  • explicit over implicit
  • specifically designed to make it easy to host your website through github-pages.

Shake Stick

The Shake Stick is a NIME (New Interface for Musical Expression) implemented in C++ and SuperCollider on a Raspberry Pi B+. This repo contains all of the necessary code and data to run a Shake Stick. This project was produced as part of a directed study with Dr. Abram Hindle at the University of Alberta. You can read a pre-print of the resulting paper on PeerJ.


BackTalk is a programming language designed to provide simple points of configuration or interaction within a larger piece of software. For instance, it could be used to allow a user to add custom behaviour to a button in a WYSIWYG website editor. You can try out BackTalk right now by going through the interactive BackTalk tutorial.

The syntax is designed to be expressive and also natural. It is also very simple, and can be easily remembered. Variables start with a “$” and function calls look like natural language. Here is an example of a small script you could write and execute with BackTalk:

-- this is a comment
with $color as "orange"
set the background color to $color

A more complicated script could look something like this:

with $all_words as (an empty set)

for each $word in the text:
    with $lowered as (convert $word to lowercase)
    add $lowered to $all_words

show message:
    "there are"
    (length of $all_words)
    "words in the text"

Many of the functions in the samples above would be expected to be written by the BackTalk embedder.

The embedder can write functions that execute asynchronously, create loops, modify and access the surrounding scope, and also run whatever JavaScript behaviours are desired. Any function which returns a Promise will pause the BackTalk VM until the promise is resolved. This is done transparently, allowing for complex async behaviours to appear as simple, synchronous scripts.

with $user_info as (GET "/user/3")
with $posts as (GET (attribute "posts_url" of $user_info))

-- let's say this renders the template using the scope Variables
-- set up in the block below it
render template "posts_index.html":
    with $user as $user_info
    with $posts as $posts

As you can see, BackTalk code sometimes looks a bit lispy. The whole project is still a bit rough around the edges, but it uses a PEG to parse the input, has a real AST, and uses a simple VM to run the code. The whole project is written in TypeScript, Microsoft’s static-typed superset of ECMAScript 6, and is well tested.


Cryssake is a simplified C++ build system written in Python. It Understands very basic configurations of C++ executables and libraries. The guiding principle of Cryssake is that by adding structure to the project being built, we can simplify the build system. Unfortunately, C/C++ code tends to have complex requirements from the underlying operating system, available libraries, etc, and structure cannot be enforced in those areas. Ultimately, I determined that this project, though it works well for very simple C++ builds, would need to rapidly grow in complexity to accomodate more complex configurations. At that point I gave up and learned CMake.

Go has a build system that works sort of how I wanted Cryssake to work, but even better. Rust has a similar build system called cargo that is even closer to what I wanted for C++, but also handles packaging/dependencies: nice!


Squick is the evolution of ZAP. While working on ZAP I realised that trying to cram every single thing I might want to do with my website into a general-purpose static site generator is not only too much work, but also no fun at all. There are a few things that I was interested in doing differently (at least from the static site generators I’ve found) and many things that I was interested in doing exactly the same as everyone else.

Making ZAP flexible enough would require a plugin system, which takes quite a bit of work to get right. Making those plugins means wrangling other people’s software (like sass compilers, git, elasticsearch, etc.) which is a pain. So, instead of fighting with other people’s software, I decided to build on other people’s software, by making a simple node module that renders markdown files with templates in a way that is very easy to integrate into gulp. Squick is the result. The templates are rendered (asynchronously) using dust. This website is now built with Squick, along with the following gulp plugins:

  • gulp-sass: to compile the stylesheets
  • gulp-notify: to pop up desktop notifications when continuous, background builds finish or fail
  • gulp-connect: to provide a livereload-enabled webserver
  • gulp-gh-pages to automate deploying to GitHub pages
  • gulp-indexify: to turn /foo/bar.html into /foo/bar/

Overall, I’m very happy with this new system and the workflow it enables!