Current

A memory debugger for large C codebases built on deterministic record-and-replay capturing syscalls, signals, and thread scheduling so any execution replays identically and can be stepped backwards with inline assembly, IR, and alias inspection at any point, plus a compiler-pipeline view that follows a variable from source through optimized IR down to assembly to answer where it went. [Talk]

A distributed workload scheduler that places and manages Docker containers across a GPU fleet, handling task queuing, node health, and resource-aware placement.

A language server for MaPLe, the parallel extension to Standard ML, providing completions, diagnostics, and go-to-definition over the LSP protocol.

A minimal LLM inference library that owns scheduling, metadata planning, and parallelism intentionally omitting forward pass, weight loading, and CUDA graph capture. Favors writing code over configuring hundreds of CLI flags, with the tokenizer, multimodal handling, and admission/retraction heuristics expressed as code.

A cloud storage agent where an LLM turns natural-language requests into safe storage operations over a signed, idempotent HTTP API. Mutations become reviewable revisions that fail closed on state drift and emit hash-chained proof receipts, with the action ledger modeled in TLA+ and Lean. [Code]

A browser-based interactive notebook and cloud IDE for OCaml. It comes with Jupyter-style cells and Replit-style instant, zero-setup environments with first-class native OCaml tooling and libraries. Optimized for cold-start latency, it uses lazy compilation, memory snapshots, and copy-on-write sandboxes to make spinning up a fresh environment feel instant.

A Hydro-inspired framework for OCaml where a distributed system is written as one dataflow program. Streaming operators are pinned to explicit locations, with cross-machine communication type-checked at the boundary, compiled into per-node deployables while the runtime owns networking, serialization, and delivery semantics.

A loom-style permutation tester for multicore OCaml. A controlled scheduler runs a concurrent test under every meaningful thread interleaving, with dynamic partial-order reduction pruning equivalent executions, surfacing data races and memory-ordering bugs that stress testing never hits.

A high-performance Nintendo 3DS emulator that runs both in the browser via WebAssembly and as a native standalone app, targeting constrained computing environments and instant multiplayer support.

A live-streaming service for indie creators that folds in Discord-style community spaces with low-latency video broadcast alongside persistent text channels, voice rooms, and per-creator communities.

A self-hosted video conferencing server aiming for secure, scalable multi-party calls with HD audio and 4K video, screen and content sharing, in-call chat with private messages, reactions and raise-hand, polls, and virtual backgrounds.

A cloud-native rebuild of a video game store as reactive microservices, compiled to GraalVM native images for fast cold starts. Catalog, inventory, and invoicing are independently deployable services talking gRPC internally and REST at the edge, with Kafka events for order and stock updates, circuit breakers, OpenAPI contracts, health checks, and distributed tracing.

An authoritative massively-multiplayer game server in C with a tick-based simulation loop over a custom UDP protocol, spatial partitioning and interest management so each client only receives nearby state, delta-compressed replication, and lag compensation for hundreds of concurrent players.

A Sublime-class text editor in Rust with rope-backed buffers that stay instant on huge files, multiple cursors and selections, fuzzy goto-anything and a command palette, incremental syntax highlighting, and a plugin API.

An interactive shell that treats pipelines as structured data rather than text, with autosuggestions, syntax highlighting, and smart completions working out of the box, plus a themeable prompt and a plugin system for extending commands.

A mailing list manager built with Laravel and backed by SQLite, served behind Apache, handling subscriptions, moderation queues, message archival, and bounce processing over SMTP.

A BitTorrent client in C with bencode parsing, tracker announces, and the peer wire protocol over non-blocking sockets, downloading from many peers at once with rarest-first piece selection, SHA-1 verification of every piece, an endgame mode for the final blocks, and tit-for-tat choking to keep upload slots honest.

An S3-style distributed object store with erasure-coded objects spread across nodes, a signed HTTP API with multipart uploads, placement and rebalancing as nodes join and fail, and background scrubbing that detects and repairs corrupted shards.

A Firecracker-meets-Kubernetes platform in C++. At its core is a minimal KVM virtual machine monitor booting jailed microVMs in milliseconds with a stripped-down virtio device model, driven by a declarative control plane whose scheduler and reconciliation loops converge actual cluster state onto desired state.

A Git-compatible version control system rethought along the lines of Jujutsu. The working copy is itself a commit, every repo mutation lands in an undoable operation log, conflicts are first-class objects that can be committed and resolved later, and descendants rebase automatically when history is rewritten.

Cargo, but for C. Comes with declarative manifests, semver dependency resolution with lockfiles, a registry protocol, isolated per-package builds with cached artifacts, and one command taking a fresh checkout to a linked binary.

A linker with one perverse target: link a multi-gigabyte executable in about a second. Parallel symbol resolution, mmap-driven input handling, concurrent section layout, and careful attention to memory locality, benchmarked continuously against production linkers on real-world binaries.

A build system in the mold of AWS Brazil. Packages declare dependencies against curated, versioned package sets rather than floating versions, builds are hermetic and reproducible, and upgrading a library across thousands of packages becomes a single version-set flip.

A Doom-style 3D engine in Zig. Just comes with some basic BSP-based level traversal, a column renderer drawing textured walls, floors, and sprite billboards, sector lighting, hitscan combat, and data-driven level loading, enough to run a playable shooter demo.

A 3D renderer with hardware-accelerated ray tracing. GPU path tracing distributed across machines in real time, denoising over low-sample frames, and a deep library of materials and physical simulations feeding the scene.

A deterministic network simulator where failure is a first-class value; packets can be dropped, duplicated, reordered, delayed, corrupted, or partitioned at the type level, and the same protocol code runs unmodified over real UDP, the simulator, or a recorded replay, so a bug at 30% loss with clock skew reproduces on every run.

An ELF executable packer that reimplements what the loader does: parsing headers, mapping segments, applying relocations, and resolving symbols against shared libraries to compress binaries and launch them from a self-extracting stub. Paired with an inspector that answers why every byte exists, tracing each instruction back through symbol, relocation, and object file to a source line, with a tiny linker underneath.

An LSM-tree storage engine with a mutable memtable, immutable SSTables, a write-ahead log, checksummed blocks, a block cache, bloom filters, and leveled compaction running concurrently with readers. A fault-injection harness kills the process at arbitrary points mid-write and proves recovery from torn writes and corrupted SSTables, with benchmarks covering random reads, sequential writes, and compaction stalls.

A query engine covering parsing, logical and physical planning, and operator pipelines for scan, filter, project, aggregate, and join. Execution is push-based over a custom allocator with atomic work stealing and cache-local scheduling instead of leaning on an async runtime.

An embedded SQL database in C following the classic SQLite architecture. REPL front end compiling statements for a small virtual machine, a pager managing fixed-size pages persisted to a single file, and tables stored as B-trees walked by cursors.

A distributed edge database built for massive multiplayer workloads, prioritizing deterministic execution and horizontal scale, built in the spirit of Turso and TigerBeetle. A replicated state machine with deterministic, single-threaded transaction processing gives reproducible replay, while data sits close to players at the edge for low-latency reads and writes. Hardened by a Jepsen-style harness that kills nodes mid-commit, partitions the network, fills disks, corrupts segments, and jumps clocks.

A multi-threaded, shared-nothing in-memory data store with a command interface, sharding key ownership across cores to avoid lock contention.

An in-memory key-value store implementing the RESP wire protocol, core data structures, and a single-threaded event loop over epoll.

A columnar data format and a dataframe library built on top of it. Features include dictionary and run-length encodings, zone maps for chunk skipping, vectorized kernels over column batches, and a lazy expression API that optimizes the whole plan before touching data.

A serialization format where the wire layout is the in-memory layout: generated accessors read fields directly out of mapped bytes with no decode step, bounds and alignment validated once up front, and schema evolution handled through explicit field offsets.

A streaming dataflow engine centered on incremental computation. Operators maintain materialized views by consuming deltas instead of recomputing from scratch, with watermarks tracking event-time progress and checkpointed state giving exactly-once results across failures.

An MVP of a modern filesystem in the lineage of ZFS and BTRFS. Has copy-on-write B-trees so no block is ever overwritten in place, checksums on every block with self-healing reads, cheap snapshots and writable clones, and transparent compression.

A userspace NVMe driver that talks to the SSD directly instead of calling read and write. PCIe BAR mapping, submission and completion queues, DMA buffers, and MSI-X interrupts with the LSM-tree storage engine running on top of it and benchmarks against the Linux block layer and SPDK.

A Raft consensus implementation with injectable interfaces for time, network, and storage. Property-tested, and pushed past the core protocol into snapshots, log compaction, membership changes, and backpressure.

A dual formal specification of the Raft implementation. One is a TLA+ model whose safety and liveness invariants such as election safety, log matching, and leader completeness are exhaustively checked by TLC, alongside Lean proofs that discharge the same properties as machine-checked theorems.

A userspace TCP/IP stack speaking through a TUN device. ARP, IPv4, ICMP, and UDP underneath a full TCP implementation with retransmission timers, fast retransmit and SACK, sliding-window flow control, and congestion control, interop-tested against the Linux stack and then ported into the operating system kernel behind a socket API.

A Network Time Protocol implementation that synchronizes the system clock over UDP with offset and round-trip delay estimation and clock discipline.

A DNS resolver that performs iterative resolution from the root servers and parses wire-format records to answer hostname lookups.

A multithreaded web server with a thread-pool executor, HTTP/1.1 request parsing, and static file serving over persistent connections.

A small operating system kernel built from scratch with context switching, paging and virtual memory, user mode across a system-call boundary, a preemptive scheduler, a disk device driver, a file system, and a command-line shell.

A minimal type-1 RISC-V hypervisor that boots Linux-based guests from bare metal. Features trap-and-emulate, two-stage guest memory virtualization, interrupt injection, virtio disk and network devices, and SMP guests, with live migration as the endgame.

A loadable Linux kernel module that grows from a character device with ioctl and mmap interfaces into a PCI driver written straight from the datasheet. Module has BAR mapping, DMA, MSI-X interrupts, and NAPI polling with sysfs attributes for runtime configuration and correct locking across process and interrupt context.

A CPU emulator implementing an instruction set with a fetch-decode-execute loop, a register file, and a memory bus to run compiled binaries.

A friendly OCaml library for asynchronous concurrency and I/O, designed natively around io_uring: the scheduler, buffer management, and task model are built for completion semantics rather than readiness polling. Lightweight fibers run thread-per-core with CPU affinity, a zero-allocation hot path, lock-free cross-core queues, and a zero-copy response path, benchmarked against nginx and haproxy.

One coroutine API implemented three ways: compiler-lowered heap state machines, segmented stacks, and manually switched stacks. Benchmarked on creation, suspension, resumption, memory footprint, cache behavior, and deep recursion, with the generated machine code inspected side by side to show what async actually compiles to.

A library of lock-free concurrency primitives: a left-right map giving readers lock-free access while a writer mutates a second copy, hazard-pointer and epoch-based memory reclamation, an eventually consistent concurrent map with explicit publish, and a cross-process shared-memory arena allocator, each verified under a model checker.

A garbage collector drawing on G1, Shenandoah, and newer research with a region-based heap, concurrent marking with snapshot-at-the-beginning barriers, concurrent evacuation behind load barriers, and pause times that stay flat as the heap grows.

A simdjson-inspired JSON parser for OCaml with a two-stage design that first finds structural characters with SIMD sweeps over raw bytes, then builds a lazy tape for on-demand access, targeting gigabytes per second instead of the usual allocate-as-you-parse approach.

A browser engine written from scratch in Rust, taking a page from raw bytes to pixels: semi-spec-compliant HTML parsing into a live DOM, selector matching and cascade resolution feeding box-model layout, and damage-tracked compositing so scrolls and repaints only touch dirty layers. Scripts run on its own JavaScript VM, where inline caches speed up hot property lookups, a mark-sweep collector manages the heap, and hot functions tier up through a baseline JIT with type specialization and deoptimization.

A tree-walking interpreter for the Monkey programming language, with a lexer, a Pratt parser producing an AST, and an evaluator supporting integers, strings, arrays, hashes, first-class functions, and closures.

A bytecode compiler and stack-based virtual machine for the Monkey programming language. Features a compact instruction set executed with a constant pool, symbol table, and call frames, a JIT tier that profiles hot functions into native code with inline caches and deoptimization, and a self-hosting milestone where the compiler compiles itself and binaries are diffed across bootstrap generations.

A physically-based path tracer built from scratch through the Ray Tracing in One Weekend series: ray-object intersection, a positionable camera with defocus blur, diffuse, metal, and dielectric materials, BVH acceleration, textures and Perlin noise, quads, emissive lights, and volumes, with Monte Carlo integration and importance sampling driving the final renderer.

A cryptographic hardware library written in Hardcaml, describing synthesizable RTL for primitives such as AES, SHA-2/3, and modular arithmetic, with cycle-accurate simulation and testbench-driven verification against reference vectors.