I like projects that start with a concrete problem: an archive that should open without installing another tool, a decoder with the wrong license for a product, or an embedded language that needs stronger isolation. These are some of the projects I have been building lately.
Go · Archive formats · Compression
xtar — one binary for the archive tools I actually use
A BusyBox-style replacement for tar, cpio, zip, unzip, and 7z, without the usual hunt for a format-specific utility.
Why I built it
Receiving an unfamiliar archive should not mean stopping to install a toolchain. A .7z file, a split ZIP set, or a .cpio.Z archive can each require a different package and a different command-line convention. xtar grew out of that recurring annoyance.
The design
The central rule is simple: the command name controls the syntax; the file’s contents control the format. Invoke it as tar and familiar tar flags still work, but tar -xf archive.zip can extract a ZIP. The other dialects retain their own conventions too, including cpio’s standard-input workflow and 7z’s attached arguments.
Magic-byte detection, rather than a possibly misleading extension, determines how input is read. Output extensions select the container and compression unless flags override them. Path-traversal protections are on by default, and unsupported operations fail explicitly instead of being silently ignored.
xtar is also a practical test of my Pluto compression work: the archive engine uses Pluto’s pure-Go codecs rather than delegating to external programs. Tar and cpio processing streams one member at a time, keeping memory use bounded by the largest member rather than the whole archive.
Go generics · Data structures · Algorithms · Codecs
Pluto — classic algorithms without interface overhead
A standard-library-only collection of generic data structures, algorithms, and compression formats, with thread-safe counterparts where concurrent use matters.
A consistent foundation
Pluto implements the structures I want available when building larger systems: balanced and unbalanced trees, hash tables, priority queues, graphs, tries, sorting and searching, caches, disk-backed indexes, and compression codecs. Generic values stay values; ordering uses built-in operators or a caller-supplied function rather than boxing every element into an interface and dispatching through it.
The project emphasizes explicit behavior and verification. Packages include tests and checked examples, concurrent variants use consistent APIs and snapshot iterators, and the compression work is tested against established implementations and golden files. Pluto now serves as an underlying library for both xtar and Ultima.
What the comparisons showed
I built head-to-head comparisons against the original Java examples from Sedgwick’s Algorithms site, using identical generated workloads and cross-checking results. The measurements were not a uniform “Go beats Java” result. They showed where representation matters: on two five-million-element three-way quicksort workloads, Pluto ran 3.3× and 5.2× faster, with Java’s boxed Integer[] and Comparable calls accounting for much of the difference. Other tests were close, and some favored Java.
The comparison work also uncovered real defects in published reference code. Examples included SplayBST.remove losing nodes, BinomialMinPQ.delMin throwing a null-pointer exception in a normal head-of-list case, and minKey returning the wrong key. I built minimal reproductions and restricted shared benchmarks to operations that worked correctly on both sides. That process was as valuable as the timings: reference code still needs adversarial testing.
heif-go — permissively licensed HEIC decoding in pure Go
A portable HEIC/HEIF still-image decoder with no cgo bridge, C library, Rust component, or external Go dependency.
A licensing and deployment problem
I developed heif-go for Agentic Quartz’s real-estate agent product after running into the licensing and build constraints of the existing Go/C decoder path. Depending on a GNU-licensed C decoder was not a fit for the proprietary product, and the native library also complicated static and cross-platform builds.
The result is an MIT-licensed Go port of the permissively licensed heic-rs implementation, retaining its upstream copyright notice. It provides a goheif-compatible API and integrates with Go’s standard image package, so decoded images can flow directly into JPEG or PNG encoding.
Beyond a container parser
The project includes both the HEIF container parser and the HEVC still-picture decoder. It supports tiled grids, parallel tile decoding and color conversion, image orientation and cropping, EXIF extraction, and auxiliary alpha planes. Bounded allocations and parser checks are part of handling untrusted image files.
The test suite combines real files, reference images, parallel-versus-serial comparisons, truncation cases, fuzz regressions, and race checks. The repository also documents performance honestly: the decoder is portable and correct, while continued optimization remains warranted against the Rust and Go/C references.
gopher-lua — a major upgrade to an established Go VM
A fork that advances Yusuke Inuzuka’s pure-Go Lua 5.1 engine to Lua 5.5.1 and adds a production-oriented host layer for running untrusted scripts.
Compatibility as a testable contract
The original gopher-lua supplied the parser, register VM, code generator, and embedding API. My fork retains that foundation while upgrading the language surface: current instruction encoding, integer/float duality, goto, <const> and <close>, and the newer standard libraries.
Stock C Lua 5.5.1 acts as the behavioral oracle. A differential golden corpus checks output, errors, number formatting, semantics, and observable iteration order. The goal is not merely to accept similar syntax, but to make compatibility measurable.
Designed for a daemon, not just a REPL
The host package adds script caching, warm VM pools, sandboxed globals, Go host functions, memory budgets, deadlines, and explicit termination. Those controls make the engine suitable for Ultima’s Redis-compatible EVAL and SCRIPT support without introducing cgo or a separate interpreter process.
The repository includes a measured performance program rather than a single headline number. Pooling and allocation reductions improve short, repeated server-side scripts, while the documentation also identifies compute-heavy cases where optimized C retains an advantage.
Ultima — a Redis-compatible server with more ways to connect
A pure-Go Redis superset that combines the RESP protocol and command set with gRPC, WebSocket/Protobuf, HTTP management APIs, and a web-based operator interface.
Compatibility first, then a larger surface
Ultima’s starting point is a drop-in Redis alternative: existing clients should be able to connect using the protocol they already understand. RESP2 and negotiated RESP3 support preserve that path, while binary gRPC and WebSocket interfaces give new clients alternatives to RESP parsing.
The architecture replaces Redis’s single-threaded command-execution model with parallel, goroutine-based execution and sharded data structures. Its design target is substantially higher multi-core throughput on common workloads; the project includes benchmark tooling to evaluate that target rather than treating it as assumed.
A connected family of projects
Ultima is where several of my other projects meet. Pluto supplies data structures such as sharded tables, streams, quicklists, and eviction machinery. The upgraded gopher-lua engine supplies sandboxed scripting. Additional work covers persistence, authentication and ACLs, optional TOTP two-factor authentication, client libraries, resumable WebSocket sessions, and an interactive management console.
Glasm — from a language fork to a Lua-to-WebAssembly compiler
A compiler and runtime for executing Lua as WebAssembly inside pure-Go applications, with a freestanding wasm32 runtime and a sandboxed host interface.
More than an interpreter fork
Glasm also began with gopher-lua. It upgraded the language core through successive Lua versions to 5.5.1, then moved beyond interpretation with a Lua-to-WebAssembly compiler. Generated modules target a runtime derived from stock C Lua 5.5.1, and a WebAssembly engine can compile those modules to native code on supported architectures.
This creates a useful engineering tradeoff. Compilation and instantiation cost more up front, while pooled VMs and native numeric paths can pay that cost back on repeated or compute-intensive scripts. The host layer provides memory limits, deadlines, sandboxed globals, and Go host functions around that execution model.
As the work matured, I separated the standalone native Go interpreter into the upgraded gopher-lua project. Glasm remains focused on the Lua-to-WebAssembly compiler and runtime. Both repositories retain credit to Yusuke Inuzuka’s original work.
CleanPaste — a small Mac tool that removes a daily irritation
A menu-bar app that turns copied formatted text into plain text and keeps the last five clips within easy reach.
Copying from a webpage, document, or email often brings along fonts, colors, and links that do not belong at the destination. With cleanup enabled, CleanPaste flattens text on copy or cut while leaving pure file and image copies alone. A menu-bar list makes recent clips easy to restore exactly as they were copied.
The app is intentionally small and local. It remembers its settings, can launch at login, runs on macOS Ventura or later, and builds as a universal Apple Silicon and Intel binary using Apple’s standard tooling.
In this conversation with Jack Knutson, I discussed my path from early programming and Oracle consulting through building and selling a software business, returning to hands-on engineering, and working on blockchain systems. The technical focus was my work on Keep’s distributed threshold random-number generation: Solidity contracts, Go client code, Ethereum events, and geth/abigen.
The interview also covers the experiences outside software that shaped my perspective—living and traveling on sailboats, aviation, outdoor guiding, pottery, and raising my family. It remains a good snapshot of how I think about distributed systems, privacy, product work, and the value of making time for a life beyond the keyboard.