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.

Explore xtar on GitHub

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.

Explore Pluto on GitHub

Go · HEIC/HEIF · HEVC · Image processing

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.

Explore heif-go on GitHub

Go · Lua 5.5.1 · Virtual machines · Sandboxing

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.

Explore the gopher-lua fork on GitHub

Go · Redis compatibility · gRPC · WebSockets

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.

Explore Ultima on GitHub

Go · Lua · WebAssembly · Compilers

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.

Explore Glasm on GitHub

Swift · macOS · Menu-bar utility

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.

Explore CleanPaste on GitHub

Interview · Keep Network · February 22, 2018

Getting to Know the Keep Team: Philip

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.

Read the original interview on Medium