Current

A memory debugger for large C codebases with time-travel replay and inline assembly, IR, and alias inspection at any point in execution. [Talk]

A deterministic simulation testing framework inspired by Antithesis and FoundationDB that runs a distributed system single-threaded under a seeded PRNG with simulated time, network, and disk.

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. Completions, diagnostics, and go-to-definition over the LSP protocol.

A multiplayer terminal text editor with real-time collaborative editing over WebSocket. Multiple clients share a buffer synced via Operational Transformation built from scratch, with persistent sessions and a TUI frontend.

A content-addressed FUSE filesystem in Rust where files are stored as hashed blobs with a local cache layer, with transparent lazy-loading from any backing blob store.

A distributed FUSE filesystem backed by a KV store for file tree metadata and a content-addressed blob store for file data, with eventually consistent semantics.

A minimal hypervisor in ~1,000 lines modelled on bhyve, covering VM exits, virtio device emulation, and the VMX/SVM control loop. Boots a guest kernel on FreeBSD.

A Redis module in Zig that implements a Bloom filter and rate limiter as first-class Redis commands.

A Firecracker-based microVM spawner that brings up isolated VMs on demand over KVM, each with its own network namespace and root filesystem, torn down cleanly after use.

A checkpoint/restore tool using CRIU that captures full process state including memory maps, fd tables, and register state, then restores it exactly, anywhere. Extended to GPU processes for snapshotting device memory including loaded model weights.

A daemonless container runtime in Rust for spawning short-lived isolated workloads without a persistent daemon or image registry. Each container gets its own namespace, cgroup, and lazily-loaded root filesystem.

A sandbox runtime for executing untrusted and agent-generated code in complete isolation. Each process runs in a fresh environment with syscall-level interception, its own network namespace, and no access to host resources or persistent state between runs.

An eBPF-based private networking layer between containers with a WireGuard VPN for cross-host connectivity, TLS relays for tunneled connections, and per-container network namespaces for full isolation.

An HTTP-to-function bridge in Rust that repurposes the ASGI request/response protocol as an internal transport layer, translating inbound HTTP into direct function invocations with sub-second dispatch.

A localhost tunneling tool built on Tokio async I/O with NAT traversal, token-based auth, and structured error handling.

A mini LSM-tree storage engine with a mutable memtable, immutable SSTables flushed from memory, a write-ahead log for durability, bloom filters for point-lookup performance, and leveled compaction to bound read amplification.

A small query engine covering parsing, logical and physical planning, and operator pipelines for scan, filter, project, aggregate, and join, tracing how a query plan turns into actual row-level work.

A Raft consensus implementation with injectable interfaces for time, network, and storage, property-tested with a simulation harness guaranteeing one leader per term, no lost committed entries, and in-order state machine application.

A TLA+ specification for the Raft implementation and simulation harness with safety and liveness properties verified by the model checker. Explores the parallels between TLA+ invariants and ALWAYS assertions in Antithesis.

A property-based testing library inspired by minithesis where TestCase values are drawn from a byte stream, allowing the shrinker to reduce any failure to a minimal reproducer by trimming that stream. Supports stateful model testing.

A coverage-guided fuzzer modelled on libFuzzer/AFL++ that generates inputs, measures edge coverage via instrumentation, and feeds novel-coverage cases back into the corpus. A shrink pass reduces crashing inputs to minimal reproducers.