Projects

I’ve built and modded two 3D printers: the VORON Trident and the VORON 0. Building the printers were really fun and rewarding, and being able to 3D print stuff is very useful too.

I built a custom keyboard with 35 keys and an integrated trackball. I’ve also got a completely custom keyboard layout for it:

The Tree-sitter grammar for the Djot markup language gives editors such as Neovim the ability to syntax highlight, conceal, select text semantically, jump between elements, and more.

{#example-attribute}
# Djot is like Markdown

But Djot is _easier_ to parse and has some additional
markup elements.[^footnote]

::: div_class
i. Roman numerals for lists.
i. Lisp-like :symbols: for postprocessing.
i. LaTeX math: $`i^2 = -1`
i. ~superscript~, {+insert+} and {-delete-}, and more...
:::

[^footnote]: But I admit, the difference between Djot and
             the various Markdown flavors isn't *that* large.

If you’re curious about Tree-sitter, make sure to check out the in-depth post Let’s create a Tree-sitter grammar that walks you through the creation of a grammar for a subset of Djot.

I self-published a book! It tries to explain what cryptocurrencies are, what they’re useful for, and why they exist in a very approachable manner. It exists in physical form, as a free eBook and it’s readable online. The book on the website is created with Pollen and Racket.

BitPal is a self-hosted cryptocurrency payment processor It allows you to accept payments online using various cryptocurrencies without a third-party custodian, on your own hardware. It’s developed in Elixir.

I made a custom keyboard layout, designed for a keyboard with 34 keys. It’s been a fun project but it’s also helping me relieve my RSI.

This is a VHDL implementation of the Core Wars 88 standard. Core Wars is a computer game where two programs compete and try to destroy each other.

The programs may look like this:

; This program will copy a DAT instruction to every 4th line in the memory,
; hoping to catch enemy processes and kill them off.
;
; add 4 to the instruction at offset 3 (the DAT)
ADD #4, 3
; copy the instruction at offset 2 to relative location of
; the second field of instruction 2 (+4 lines after DAT the first execution)
MOV 2, @2
; jump back to beginning
JMP -2,0
; if a process tries to execute this line, it dies
DAT #0, #0

See the Core Wars wiki for more info.

This is a collection of algorithms used in competitive programming. There are also slightly hacky commandline submit scripts for kattis and UVa. See my uHunt profile for a list of solved UVa problems.

// Bellman-Ford's algorithm for single source shortest path.
// Return a vector of pair<dist, parent>.
// Take in an adjecency list of type pair<node, weight>.
template<typename T>
vector<pair<T, int>> shortest_path(vector<vector<pair<int, T>>> adj_list, int start);

// Aho-Corasick's string matching algorithm.
// Return a vector of matching positions corresponding to the pattern index.
vector<vector<int>> find(const vector<string> &patterns, string text);