I build deterministic developer infrastructure: schema compilers, Git-native provenance systems, replayable runtimes, terminal UI tooling, and agent-safe repo context systems. Most of the work is Rust and TypeScript.

The common thread: software history should be explicit, replayable, and inspectable.

• Bijou — Runnable terminal UI toolkit. Real character grid, layout engine, i18n, deterministic render output.
• Wesley — GraphQL SDL compiler. One schema drives TypeScript, Rust, SQL, manifests, and runtime plans.
• Graft — Context governor for coding agents. Policy-enforced repo reads and structural views.
• Echo — Deterministic application runtime where state is a materialized view over causal history.
• git-warp — Git-native causal history engine for replayable provenance, speculative branches, and canonical history.

mindmap
root((Ecosystem))
Start Here
Bijou
Wesley
Graft
Echo
git-warp
Research
AIΩN Foundation Series
Observer Geometry Series
WARP Drive
Foundations
Continuum
Wesley
Runtimes & Apps
Echo
jedit
git-warp
Think
Xyph
Agent Infrastructure
Graft
blacklight
Libraries
Bijou
Alfred
Nine Lives
git-cas
Tools & Debugging
WARP-TTD
Geordi
Shiplog
METHOD

Most developer systems still inherit the Unix model: processes mutate files, logs are best-effort, and history is whatever someone remembered to record.

That model scales surprisingly far, but it breaks down under concurrency, distribution, and automation. Once humans, services, and agents are all changing state, the basic questions become hard:

• What actually happened?
• Who or what caused it?
• What did each actor see?
• Can we replay, fork, or verify the result?

• Processes become named actors in a shared causal history.
• Files become materialized views over history, not the source of truth.
• State changes become append-only events with verifiable provenance.
• Time is represented by causal structure, not loose wall-clock timestamps.
• Runtimes own admission, ordering, and replay; applications submit intents and consume evidence.

The goal is systems that remember what happened well enough to replay it, not better logs. Don’t hope your editor, planner, and agents are in sync; ask what the shared history allows each of them to see. When an AI agent modifies a codebase, we should not have to guess what context it held or what rules it followed; we should be able to mathematically prove its optic and replay its footprint.

• Continuum defines the shared causal-history protocol.
• Wesley compiles schemas and contracts into code, plans, and runtime artifacts.
• WARP Drive mounts a FUSE-backed POSIX membrane over witnessed causal history, so your legacy tools can participate.
• Echo and git-warp are sibling runtimes over deterministic, replayable history.
• Graft and blacklight are the agent-infrastructure layer.
• Bijou, jedit, Think, and Xyph are interfaces and applications built around the model.
• Alfred, Nine Lives, and git-cas provide supporting resilience and storage infrastructure.
• WARP-TTD, Shiplog, Geordi, and METHOD are tools for debugging, deployment, UI IR, and engineering process.

The implementation work is backed by a formal research layer.

• AIΩN Foundation Series defines the core WARP model: WARP graphs, deterministic state evolution, computational holography, provenance payloads, observer-relative dynamics, and replay ethics.
• Observer Geometry Series formalizes how bounded observers see, compare, and justify claims over shared causal history.
• Governance & Ethics explores rights, safety, and accountability for systems whose histories can be replayed, inspected, or forked.