One deterministic, offline-first, dependency-free substrate that builds verifiable tools for every economic actor priced out of modern software.
Geometry of Flows: geometry, flows, and constraints together constitute a system. One substrate serves carbon accounting, weave patterns, and food-safety compliance alike — because all three are the same triple with different parameters.
Three commitments make the substrate different from the software it stands against — each a direct response to extraction, not a feature for its own sake.
Every state is a pure projection of an operation log. The same inputs always produce the same result; any step can be replayed or undone, byte-identical.
Every gesture emits a content-addressed, SHA-256-linked record. Trust isn't vouched for — a forged chain simply fails to verify.
A single HTML file, no framework, no network, no runtime to install. It runs on a phone in a field with no signal and survives offline for decades.
The ideas underneath, shown rather than asserted — from animated diagrams of the core mechanisms to live cards that run the real computation in your browser, to an instrument you operate yourself.
The rotor, vitrify/rehydrate, dark-codon rejection, the routing manifold, the ribosome pipeline, Dragonfly/Mantis, and one grammar with many doors — in motion.
The Ξ conservation law trips Lysis on a real evidence drop; the 5-tuple codon computes its norm and chirality from five sliders.
The geometric product splitting into dot and wedge as you move two vectors; Morton addressing interleaving bits so space becomes memory.
Fold a computation to a 200-byte seed, ship it across a gap, and rehydrate it byte-identical. Plus stigmergic routing, where the path emerges.
Run the formal invariant engines — M1, M3, M5, M6 — against a real evidence chain. Inject a fault and watch the responsible engine catch it.
Every codon is one entry in the real 8×8 geometric product — eight classes of eight, each with a result, a sign, and a computational role.
Every interface a human can have with software is spatial, continuous, or stepwise. Three minimal islands prove one deterministic, reversible substrate expresses them all — then each is dressed into a working surface.
Graph, canvas, and workflow primitives on one op-log runtime. Drag, step, advance — and watch the inspector verify replay equals live state.
The registry's lineage graph: every idea traced to the human work it honors, across nine knowledge families, with a verification manifest per node.
Lay out a parcel; rotate and reflect it. The operations are real geometric algebra — rotor sandwiches and wedge-product area — not canvas tricks.
A compliance ritual that emits a Merkle-linked evidence chain. Tamper with any record and verification breaks at exactly that link. Exports a verifiable file.
Drop an exported evidence file and run the four checks — hashes, links, Merkle root, Ξ — entirely in-browser, no GDC account. The regulator procedure, automated.
Grow, breed, and vitrify organisms (compositions of bio-algorithms) into reproducible rotor springs. Seeded, so the research replays.
A working model of the Cape Fear River, built only from open USGS gauge data. Drainage-area conservation and downstream flow accumulation are checked live — fake a number and the ledger flags the exact station. Seals an evidence bundle.
Eight schematic layouts — toolkit, dashboard, twin viewer, sidecar, paper form — each a projection of the same state, each with an evidence rail.
The conceptual and architectural foundation: how the pieces fit, and the human lineage the whole project honors.
The 5-tuple codon and its single norm; the geometric product as one invertible operation; Morton addressing as routing-free locality.
Every term from the substrate up — Cl(3,0), rotor, codon, evidence, vitrify — grouped by layer, with the domain-outward name noted where one exists.
What you have, how to use it, and why it's different — for an operator. Then the architecture and how to build on it — for a developer.
How the evidence chain works, why it's tamper-evident, and the four checks an auditor can run themselves with a standard SHA-256 tool.
The scientists, philosophers, and knowledge traditions the substrate draws on — including Indigenous knowledge systems, honored as first-class.
The structured citation base. A pattern with a dangling reference is a load error; lineage is enforced, not decorative.
The substrate is built to sit underneath the work people already do — a library they link, a tool they run, a file they open — never a platform they migrate to. It lowers the activation energy for sovereign, verifiable, durable computing without asking anyone to abandon the tools they trust. Like a mitochondrion: it moves in, keeps its own laws, and makes the host more capable while the host stays the host.
The audience is the entire long tail — every economic actor priced out by incumbent lock-in. Not a sympathetic subculture; the whole economy below the hyperscalers. The reach is by drop-in: browser tools that need no install, shared libraries for any language, charged batteries that ship computation as a file, and sidecars for the operators who will never touch a library at all.
The project's own documentation of itself — the inventory, the wiring, and an honest accounting of what isn't finished.
Every module, surface, and document by layer and role — the "what is this" reference for a new collaborator.
The import graph, generated from source: dependency layers, the load-bearing core, and which gate exercises which module.
Ten structural gaps the backlog doesn't capture — the two-hash split, untested cross-impl parity, integrity-not-authenticity, untested scale.
The ten structural gaps converted to tracked items. Three closed this round: identity/signing (Ed25519), M-engine contract agreement, the end-to-end seam.
Why the codon dictionary was rebuilt: it had mislabeled the Cl(3,0) interaction table as the genetic-code codons.