• posts projects
  • Fractals

    February 2021

    • WebGL
    • Graphics
    • Math

    Live

    This is a fun little fractal explorer I made over a few days. This uses the mandelbrot and julia sets as base fractals, along with various coloring modes based on iteration or orbit traps.

  • Enku

    January 2021

    • C++
    • Cryptography

    I was bored one weekend, and decided to implement ChaCha20 from scratch (easier than it sounds) to make a tool for encrypting data.

  • Haskell-in-Haskell

    January 2021

    • Haskell
    • Programming Languages
    • Compilers

    This is a compiler for a respectable subset of Haskell, written in Haskell. This features standard data types, pattern matching, as well as lazy evaluation!

    I’m also writing an in-depth series about this compiler

  • KaTeX Playground

    December 2020

    • Typescript
    • React
    • KaTeX

    Live

    I whipped this up over an afternoon. It’s just a little site letting you write math equations interactively thanks to KaTeX.

  • Arbor

    December 2020

    • Rust
    • CLI

    This is a simple replacement for the Unix tree program.

    This will print out the file system hierarchy in tree form, starting from a given path. The program comes with configurable options for depth, Unicode, and color output.

  • Conway

    September 2020

    • Haskell
    • SDL2

    A simple implementation of the classic Cellular Automaton, as an interactive graphical application in Haskell.

  • Reg Viz

    August 2020

    • Haskell
    • Programming Languages

    Reg Viz is a simple CLI tool taking a regular expression, and outputting a representation of the NFA / state machine recognizing that language. This is useful to visualize the correspondance between regular languages and finite state machines.

  • Mooz

    June 2020

    • Typescript
    • React
    • WebRTC

    This is a simple application that lets you start video calls with multiple people, in a peer 2 peer fashion. Unlike applications like zoom, there’s no central server handling connections.

    Read More

  • Musync

    April 2020

    • Go
    • FFmpeg
    • Rest APIs

    This is similar to Populate.

    This is a program that can clone a music library based on its description. It can download albums, split them automatically, and add metadata to these songs, like cover art and names.

    It uses youtube-dl for the downloading, and ffmpeg for the splitting.

  • Poline

    August 2019

    • Rust
    • Programming Languages

    Poline is a little programming language I wrote to learn about implementing Green Threading. The language doesn’t feature much more than string literals, and mechanisms for spawning threads and communicating between them.

    Green Threads allow many logical threads in a program to execute on a limited number of actual OS threads. They can be preempted off if they invoke a blocking operation.

  • Ginkou

    June 2019

    • Rust
    • SQLite

    Ginkou is a program to build up a corpus of searchable sentences. Ginkou can consume Japanese sentences from the command line, or from a text file, parse those sentences into words, and then index those sentences for easy retrieval. Given a word, Ginkou can look up sentences containing that word, even if it’s in a different form, such as a conjugated verb.

  • Persistent-ts

    May 2019

    • Typescript
    • Data Structures

    This is a library providing a handful of persistent data structures for Typescript. This includes immutable collections like linked-lists, and clojure-style vectors. Persistent data structures are immutable, but can efficiently share data between instances, and are thus more efficient than a normal copy-on-write collection when working without mutation.

  • Serve-csv

    April 2019

    • Go
    • REST APIs
    • Backend

    This is a program that can take a folder of CSV files and serve them as a REST API. The program also uses a JSON file for each file, to specify how each column maps to a JSON field. The program is written in Go to make use of the built-in HTTP server.

  • Haze

    April 2019

    • Haskell
    • Networking

    Haze is a complete bittorrent client, capable of downloading any kind of torrent found in the wild. Bittorrent is a peer-to-peer protocol, where a client joins a large swarm of peers in order to download a file of common interest. Haskell was used in order to help manage the concurrency involved in communicating with a large number of peers.

  • Dex

    April 2019

    • Javascript
    • Vue
    • REST APIs

    Live. Dex is a little frontend app for searching and seeing stats about Pokemon, made with Vue. The app wraps around the pokeapi REST API for information about each Pokemon.

  • Ripple

    April 2019

    • Go
    • Concurrency
    • Networking

    Ripple is a program implementing a small decentralised chat protocol, written in Go. The protocol involves participating nodes ferrying messages to eachother in a ring like fashion. New nodes can join the chat by talking to any of the existing nodes in the swarm. Go is used for simple networking and concurrency, as well as to provide both a command line, and a graphical terminal interface. Read More

  • Huffman-rs

    March 2019

    • Rust
    • Compression

    This is a CLI program using Huffman Coding to compress files. The program is written in Rust for efficiency.

  • Bittrickle

    February 2019

    • Rust
    • Networking

    Bittrickle is an implementation of Bittorrent’s UDP tracker protocol. A tracker keeps track of peers participating in a bittorrent swarms, sharing files. Peers communicate with the tracker in order to learn about each other. This implementation uses Rust because of its built-in UDP networking.

  • Cauchy

    January 2019

    • Rust
    • OpenGL

    Cauchy is a program to generate plots of complex functions, written in Rust Cauchy is hardware-accelerated, using OpenGL to generate the plots using the GPU.

  • Darby

    November 2018

    • Haskell
    • SDL

    This is a CLI program to take a folder of songs and play them in a random order. SDL’s audio subsystem is used to play audio files. This program was built to accompany populate, which generates folders filled with songs, ready for consumption by this program.

  • Populate

    November 2018

    • Haskell
    • FFmpeg
    • Rest APIs

    This is a CLI program that can recreate a music library on a new machine by downloading the files from various sources across the web. The program parses a file with a hierarchical description of the library to replicate , and reproduces that structure by consuming the sources described. The program can also split up larger albums (via FFmpeg) into individual songs if necessary.

  • Peerbin

    November 2018

    • Elm
    • Javascript
    • Webtorrent

    Live. This project provides a version of websites like pastebin, or hastebin, except without a central server to store the files; instead users send the files to eachother via webtorrent. Elm is used for the main UI components, and Javascript to glue this code with the webtorrent part.

  • Hax

    October 2018

    • Haskell
    • SDL

    Hax is a bullet hell game, in the same vein as others like Touhou or Ikaruga. The game is written in Haskell, using SDL for handling the drawing logic. The game logic benefits greatly from the use of an entity component system for handling the many entities in the game. Apecs was used to provide the scaffolding for this ECS.

  • Ludus

    September 2018

    • Rust

    Ludus is an emulator for the NES console, written in Rust. The emulator fully emulates, the core CPU, as well as the PPU and APU, and thus full video and audio. The emulator also supports a handful of mappers / cartridge types, and thus many common games such as Mario or Zelda.

  • Alchemy

    January 2018

    • Elixir
    • Concurrency
    • Rest APIs
    • Websocket APIs

    Alchemy is a library over the API for the chat application Discord. The library integrates over Discord’s REST and Websocket APIs in order to help developers write applications for their chat servers. Elixir was used in order to have easy access to the concurrency involved in juggling these various resources.