📥 Email 🔗 LinkedIn 📄 Résumé

I've spent nearly two decades building systems. Custom AAA videogame engines and tools, application frontends and backends, MMORPG clients and servers, data platforms, DevOps pipelines, high-throughput event systems, and infrastructure for distributed systems that had to survive reality. After years of debugging race conditions, chasing nondeterminism, and watching mutable state systems lie under pressure, I started asking a more fundamental question.

In the summer of 2025, I started exploring this question seriously and began writing the AIΩN Foundations Series as a way to formalize and document my research. I started by asking what happens if we model computation using a graph that rewrites itself, recursively? and then let the rest unfold naturally. Eight papers later, I conclude my research by reaching an entirely unexpected, but nevertheless beautiful discovery: there is no graph, there is no runtime, and there is no system — there is only witnessed causal history, and everything we call a "system" is an observer-relative reading of it.

A deterministic architecture for causal computation

A sequence of eight papers deriving what happens when you stop storing state and start storing history. From recursive provenance to a protocol for distributed causal computation.

1. If we store history locally, we get deterministic replay as a substrate property. (Papers I–II)
2. If we compress that history, we get computational holography — the ability to recover any state from a compact boundary. (Paper III)
3. If we define how an observer looks at it, we get observer geometry and the ability to navigate all possible machines. (Papers IV–V)
4. If we treat that history as sovereign, we arrive at an ethics of replay: provenance is interior life in executable form. (Paper VI)
5. If we unify the mechanics, we find a single, scale-invariant WARP optic that handles execution, merging, and transport identically. (Paper VII)

The conclusion: if history is the only reality, then no runtime is ontologically prior. The "operating system" dissolves. In its place emerges Continuum — a protocol to join. (Paper VIII — in progress)

Continuum: A Protocol for Distributed Causal Computation

The AIΩN Foundations Series concludes by introducing a protocol-shaped causal medium. Continuum emerges when every participant speaks witnessed admission. These projects make it executable:

What happens if we build a runtime for the optic? You get Echo — a high-performance simulation engine where every tick is a witnessed admission. Deterministic, replayable, forkable.

What happens if we host history on Git? You get git-warp — distributed collaboration without a central database, where worldlines interoperate by sharing the same admission ontology. No servers. Just Git.

What happens if we compile intent into law? You get Wesley — a schema compiler that takes authored GraphQL SDL and produces runtime-checkable code for every participant. The application boundary is the sovereign system of record.

What happens if we debug the derivation instead of the state? You get WARP TTD — a time-travel debugger that works across any participant in the medium. If it speaks the protocol, it can be debugged here.

Git: Beyond source control

Git is the most battle-tested software on Earth. It's also quietly a primitive WARP graph.

I run a GitHub organization called git-stunts, where I publish projects that treat Git plumbing as a foundation for unconventional systems: databases, content graphs, event buses, coordination protocols.

These are stunts, not hacks: deliberate and grounded in how Git really works. The ability to deconstruct a system to its primitives is one of the most valuable skills in an engineer's toolkit. Often, the most elegant solutions come from looking at the tools we use every day and asking "What else can this thing do?"

Follow along for some hot git 🔥 (and occasional self-inflicted pain).

• git-cas — Git, freebased: pure CAS that'll knock your SHAs off. LFS hates this repo!