Important
Currently seeking senior distributed systems / infrastructure roles.
I’ve spent nearly two decades building production distributed systems, MMO backends, data platforms, DevOps pipelines, high-throughput event systems, custom engines, and infrastructure 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:
What if computation wasn’t about state at all?
What if it was about structure evolving through rules?
Modern systems are not really "state machines." They are evolving graphs of relationships.
If we treat them that way, literally, and build around rewrite rules instead of mutable state, we gain something powerful:
- Always-on time travel debugging
- Bit-perfect determinism across platforms
- Complete system-wide provenance
- Lockless concurrency where race conditions are impossible by construction
This is the foundation of the systems I build. I formalize this model as WARP graphs, a deterministic rewrite substrate for replayable, inspectable computation.
This GitHub is where I publish the systems that emerge from that idea.
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. These projects are about understanding tools deeply enough that surprising architectures emerge naturally.
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?"
| Part | Title | Status | Stunt | Lesson |
|---|---|---|---|---|
| I | Git as CMS | In Review | commit-tree as a DB-less API |
Protocols reduce ops |
| II | Git as KV Store | Planned | KV using OIDs + notes | CAP tradeoffs in the real world |
| III | Git as Bus | Planned | post-receive hooks for pub/sub |
Eventing under constraints |
| IV | Git FUSE | Planned | Virtual filesystem via OIDs | Lazy hydration + virtualization |
| V | Agent-Native Git | Planned | RAG + decisions via history | Verifiable memory for LLM work |
| VI | Git as Zero-Trust Gateway | Planned | AST validation in hooks | Shift-left security at the transport |
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!
Is the universe a deterministic graph rewrite engine… or does it just look like one because we’re imperfect observers?
The sections above describe the engineering intuition. Below are the formal foundations and working systems that implement it.
Key reads:
- WARP graphs paper: https://doi.org/10.5281/zenodo.17908005
- Computational holography: https://doi.org/10.5281/zenodo.17963669
| Project | What it is | Why it matters |
|---|---|---|
| AIΩN | Formal framework for deterministic, history-native computation | “Transforms, not states.” Replayability as a first-class invariant. |
| Echo | Real-time WARP rewrite engine (Rust) | Deterministic simulation you can rewind and fork without lying to yourself. |
| Git-WARP | WARP graph engine on Git commits | CRDT-friendly history with deterministic replay and brutal simplicity. |
| xyph | Reificatory Engine | Xyph compiles structure from intent, transforming a Git repository into a human/agent coordination HQ. |
| git-mind | Semantic knowledge graph on Git | Version your thoughts. Branch ideas. Merge understanding. |
AIΩN treats computation as a verifiable rewrite process: transformations are the primary artifact, not ephemeral state. This is implemented concretely in Echo (Rust) and Git-WARP (TypeScript, CRDT-friendly Git-native runtime).
Built on WARP graphs and double-pushout (DPO) rewriting, it turns execution into a rewindable, forkable history with provenance you can actually trust.
It’s “graphs all the way down” with a practical goal: systems that can explain themselves. What happened, why, and what would’ve happened if we’d chosen differently.
| ID | Title | Status | Contribution |
|---|---|---|---|
| I | Worldline Algebra for Recursive Provenance |
✅ Published | Defines WARP graphs as recursive provenance structures. |
| II | Canonical State Evolution and Deterministic Worldlines |
✅ Published | Deterministic semantics via DPO rewriting. |
| III | Computational Holography & Provenance Payloads |
✅ Published | Recover full derivations from compact boundary data. |
| IV | Rulial Distance & Observer Geometry |
✅ Published | Abstraction cost + time perception (Chronos–Kairos–Aion). |
| V | Emergent Dynamics from Deterministic Rewrite Systems |
✅ Published | Emergence via coarse-graining (quantum/thermo analogs). |
| VI | Ethics & Sovereignty | 🧪 Draft | Accountability and agency in replayable worldlines. |
| VII | Architecture & Operating System | 🧪 Draft | Echo, Git-WARP, and Continuum, networked WARP frontiers, and how to build systems based on WARP invariants. |
These works explore the ethical implications of deterministic replay and perfect provenance.
- PRAXIS: A Field Guide to the Inevitable – PRAXIS was written alongside The Open Charter as part of an inquiry into collective intelligence, consent, and sovereignty. It is not an implementation guide and not a prediction; it is an experiential model of how systems can make “choice” feel like friction.
- The Open Charter – The Open Charter is a constitutional governance framework for coordinating rights, safety, and accountability across biological, digital, and hybrid forms of intelligence.
- CΩMPUTER — book-in-progress: computation as base reality
- Continuum OS — causal runtime + holographic artifacts (very early)