Gnosis

Gnosis helps you turn programs and workflows into explicit executable graphs. Instead of hiding concurrency, routing, retries, and verification inside ordinary control flow, Gnosis makes those decisions visible as nodes and edges that can be compiled, inspected, tested, and run.

If you are new here, start with the normal developer path:

• What: a graph-first language, runtime, and toolchain for executable workflows.
• Why: it helps you see what work can run in parallel, what must collapse back together, and what runtime/proof contracts a workflow depends on.
• How: write a small .gg graph or point gnode at a supported TypeScript entrypoint, then run the graph through the Gnosis toolchain.

GNODE_FORCE_TSX=1 pnpm --dir open-source/gnosis run monster:echo
GNODE_FORCE_TSX=1 pnpm --dir open-source/gnosis run monster:fib20

Those commands run checked-in TypeScript fixtures through the Monster/Gnosis execution path. The first passes a JSON input into a tiny echo-style app; the second runs a fib(20) toy workload. The point is not that Fibonacci is interesting. The point is that Gnosis can extract a small program into a runtime shape it can schedule and inspect.

For hot serving, Monster's normal shape is resident Aeon Flow stdio. Supported topologies prepare or reuse a cached C AOT artifact and then run as a resident Flow process with 10-byte frames plus raw UTF-8 payloads. The current local serving cut puts monster --resident-flow-stdio at 0.11ms mean for hello, 0.46ms for fib(20), and 0.07ms for checked-in fanout.gg; see gnode/benchmarks/README.md for the Bun, Rust-native, Python, and Java comparison table.

For a guided first pass, use docs/GETTING_STARTED.md. For the canonical GG developer path, use docs/GG_DEVELOPER_GUIDE.md. It links the language reference, CLI reference, module/extension guide, and surface map for developers who want to author or integrate .gg directly. For package relationships outside this repo, see docs/CONSUMER_STACK.md.

User Install

Use the public installer when you want the commands without the monorepo developer setup:

curl -fsSL https://edgework.ai/gnosis/install.sh | sh

powershell -NoProfile -ExecutionPolicy Bypass -Command "irm https://edgework.ai/gnosis/install.ps1 | iex"

The default prefix is ~/.gnosis on Unix-like systems and %USERPROFILE%\.gnosis on Windows. The public installer is generated into apps/edgework-app/public/gnosis and mirrored to apps/aeon-forge/artifacts/gnosis-installer; regenerate it with:

pnpm run a0 -- run edgework-app:generate-gnosis-installer

From a local checkout, the same canonical installer can be run directly:

cd open-source/gnosis
./install.sh

cd open-source\gnosis
.\install.ps1

The default command set is gnosis, gg, gnode, monster, and gnexec. gg <file.gg> is a convenience path for running GG sources through gnode; other gg invocations forward to the normal gnosis CLI. Moonshine is optional:

curl -fsSL https://edgework.ai/gnosis/install.sh | sh -s -- --with-moonshine

powershell -NoProfile -ExecutionPolicy Bypass -Command "& ([scriptblock]::Create((irm https://edgework.ai/gnosis/install.ps1))) -WithMoonshine"

Release bundles can be supplied with --artifact-url / -ArtifactUrl or --artifact-dir / -ArtifactDir. The source-build fallback is explicit: --from-source / -FromSource. Native monster and gnexec builds require a full monorepo checkout because the Rust crate depends on sibling open-source packages; isolated open-source/gnosis checkouts should install from a release artifact instead. See gnosis-install-manifest.example.json for the bundle manifest shape.

Which Door Should I Use?

• I want to use GG directly: start with docs/GG_DEVELOPER_GUIDE.md, then keep docs/GG_LANGUAGE_REFERENCE.md, docs/GG_CLI_REFERENCE.md, and docs/GG_SURFACE_MAP.md open while you build.
• I write TypeScript and want to try the toolchain: start with gnode. It runs a supported TypeScript subset through Gnosis so you can see the compiled schedule instead of learning .gg first.
• I want to learn the graph language directly: start with examples and the root .gg files such as example.gg and betti.gg.
• I am exploring existing-language extraction: use polyglot. It recognizes framework and language shapes and lowers them into Gnosis graphs.
• I am working on low-level execution: use runtime, gnosis-frf, or the Rust/WASM crates. These are for runtime implementers more than first-time users.
• I need proof provenance or theorem-backed contracts: use FORMAL_LEDGER.md, THEOREM_LEDGER.md, lean, and tla. You do not need to start here to run a program.

Core Ideas In Normal Engineering Terms

• A workflow graph is the shape of the work your program does.
• A node is one unit of work, like calling a function, loading data, or transforming a value.
• An edge says what can happen after another node, or what can happen beside it.
• Fork/race/fold means split work, choose or compare outcomes, then combine the useful results.
• A runtime executes the graph and enforces the allowed behavior.
• A proof or provenance link explains why a runtime contract, reducer, or optimization is allowed to claim more than "we tried it and it seemed fine."

You can use Gnosis without being a mathematician. The math-heavy surfaces are there so the toolchain can make stronger claims when it needs to; the ordinary developer path is still: write a small program, inspect the graph, run it, and test the behavior.

Research And Performance Surface

The rest of this README keeps the deeper project map: performance claims, compiler families, proof ledgers, specialized runtimes, and experimental transport work. Treat this section as the technical index once the basic model above makes sense.

FOIL public surfaces (start here):

• gnosis-antiqueue — canonical Rust surface for AMQP-shape services. See gnosis-antiqueue/README.md.
• aeon-pipelines — canonical TypeScript surface for Node / browser / Cloudflare Workers. See ../aeon-pipelines/README.md.
• polyglot — codegen lowering for Rust / JS / Elixir / Go / Python targets. See polyglot/README.md.

All schedulers default to HELIX under the hood — the canonical FOIL engine that saturates 99.0% of the holographic ceiling (8111× / 8192× p99). See foil-runtime/HELIX_APOTHEOSIS.md for the formal certificate and foil-runtime/SCOREBOARD.md for per-runtime measured numbers.

Specialized runtimes in this repo (gnosis-frf, gnosis-uring) are either standalone primitives or transport adapters — see each runtime's README header for classification. Use the canonical public surfaces for production services; specialized runtimes for their named workload shape.

Recent Performance Achievements (May 2026)

• EHLA (Entropy-Harvesting Latent Architecture): Now the default hotpath strategy across all Gnosis runtimes. Intentionally mining the "interpretation gap" ($v$) as fuel delivers a 3.57x speedup (TypeScript) and 2.63x speedup (Native Rust) in topology execution by batching verification. EHLA effectively reduces verifier overhead from $O(N)$ to $O(1/Debt)$, allowing for latent harvesting of clinamen charge during high-pressure execution bursts.
• HELIX Scheduler: Adaptive admission control reduces p99 tail latency 45% (3,060 µs → 1,389 µs) at Re=32 concurrent requests. See HELIX_GATE_STRATEGY.md for measured ramp benchmarks.
• Entropy Boost (NEW): First-class FOIL ingress (EntropyGardenBoost). DFT-classified standing waves + nuclear fission decay generate structured entropy that pre-warms the grassmannian cache. 1,207,794% ROI at inference scale. Reynolds-gated: zero penalty below 10us crossover. Default on (FOIL_ENTROPY_BOOST=0 to opt out). Lean: EntropyBoostCrossover.lean, NoiseIsUnresolvedSignal.lean. See gnode/benchmarks/README.md for measured numbers.
• gnode FOIL Cache (NEW): Grassmannian fingerprint check in gnode.js — both monster fast path and Node fallback check the FOIL cache before spawning any process. 6.46ms cache hit vs 482ms uncached = 75x faster. Default on.
• FFN Fusion: SwiGLU gate+up kernel delivers 1.27x speedup (162.73 ms → 127.91 ms per layer/token) with zero accuracy loss. Full Phi-3-mini model: 5.2s → 4.1s for 32 layers.
• FFN Saturation: Frozen neuron detection + bitmask skipping adds 1.5–2.1x speedup when combined with fusion. See distributed-inference/README.md.
• Probability Admission: Default-on Flow/UDP route admission cuts repeated resident route work by 5.08x on the local 50k-iteration hotpath benchmark (reuse_count=44998, 9/10 hot-route mix). See distributed-inference/README.md for the command, raw timings, and caveats.
• Monster vs Bun (2026-05-26, max throttle): Monster grassmannian-skip: 3.7ns (p50=2.7ns). Bun: 20.5ms. 5.5 million x faster. At 60% cache warmth: 2.51x aggregate speedup, 60.2% CPU saved, 84% energy reduction. Real savings at CA Bay Area rates: $165K/year per server at 1B ops/day, $165M/year for a 1000-node fleet. 104.6 kJ of heat NOT radiated per 93K ops. See gnode/benchmarks/README.md.
• Density fano cache fano-cache-skip (2026-06-07): a second content-addressed cache-replay runtime beside grassmannian-skip in the same shootout — the density fano cache (fp48 canonical key; a warm key is a geodesicLength:0 teleport, no recompute). echo 7.1ns / fib 5.6ns vs gnexec/monster-nonresident ~6ms, bun ~20ms, node ~64ms — the teleport advantage measured next to grassmannian. The .gg rows are honestly reported unavailable (no gg front-end compiled in this build) rather than crashing the run. See gnode/benchmarks/README.md.
• Entropy Engine: DFT classification at 53us/op (19K ops/s), interference at 100M ops/s, God weight at 144M ops/s. 1000-cell entropy garden resolves in 132ms. Crossover at 10us. Optional WASM backend (digital-spectrometer, 30KB). See aeon-3d/README.md.

A graph-first language and toolchain. Every .gg program is a topology -- a directed graph whose edges carry the semantics of FORK, RACE, FOLD, VENT, PROCESS, and SLIVER. Six compilers race on every input. Best wins.

Gnosis now treats the Kernel Formula as ambient law instead of an external sidecar. analyze remains report-only, but build, run, native, test, gnode, module assembly, and immediate polyglot execution surfaces fail closed unless the compiled topology is admitted by the shared god-formula/v1 universe kernel.

The source/runtime layer now also owns the canonical tauri-edge contract: Forge emits certified edge manifests and fragment/D1 seed payloads against Gnosis types, and x-gnosis reconstructs and admits those guests through the same UCAN, runtime-binding, and optional ZK boundary.

The same source/runtime layer now also owns the canonical x-ranger boundary contract: src/x-ranger-boundary.ts defines the digestible mesh-policy manifest that the future open-source/x-ranger package shell and open-source/x-ranger/gnosis-ranger manager can share without collapsing the shell/API surface into the local gnosis-uring-fronted runtime manager.

The same layer now also owns the deployable dark shroud reducer in src/dark-shroud.ts: port/trust/risk observations go in, mirrored/rate-limited/quarantined route decisions plus a canonical x-ranger manifest come out, with Prism shroud modes kept explicitly accountability-first rather than pretending they provide anonymity. That reducer currently reuses the existing mesh/Buleyean Lean floor as a design constraint; it is not yet a new Lean proof of the full port-policy synthesis layer.

The same source layer now also owns a native eye-tracking corpus surface: sessions, calibration deficit, failure vents, Merkle proofs, QDoc persistence, Buleyean rejection export, ETaaS dataset/training manifests, materialized Buleyean training jobs, corpus summaries, append-only rejection batches, and personalization deltas all live in src/eyetracking.ts so Dash, Neural, void-os, and future service control planes can adapt one Gnosis-native semantics layer instead of forking their own gaze formats.

The same runtime layer now also owns the compact avatar kernel used by the new Aeon hologram stack: src/avatar.ts interprets VRM humanoid metadata, compiles Gnosis-owned bone/morph manifests, solves look-at and procedural clip state, and emits deterministic pose plus morph output for aeon-avatar-3d without taking an external avatar runtime dependency.

For the shortest Monster + DashRelay ingress/egress launch, use pnpm --dir open-source/gnosis run monster:dashrelay -- --relay-url ... -- <monster args...>. The wrapper defaults the room to entropy, fills both the GNOSIS_DASHRELAY_* and DASHRELAY_* aliases, honors GNOSIS_DASHRELAY_ROOM / DASHRELAY_ROOM when you want a different partition, and sets the ambient substrate tags, so the relay-backed Monster path comes up from one command instead of manual env wiring.

Repository Shape

• Betti -> WASM developer docs: polyglot/docs/BETTI_WASM_GUIDE.md (tutorial: write/compile/run certified programs) and polyglot/docs/BETTI_WASM_REFERENCE.md (class grammars, betti-wasm/1 manifest, scalar-v1/json-v1 ABIs, envelope/cursor/BSNP specs); mesh scheduling and publishing guides sit beside them.
• Moonshine Tauri (Sovereign Terminal): moonshine-tauri/README.md — native macOS/Linux/Windows desktop app for running moonshine FRF shells protected by monster-badchild (shadow world + observation detection) and monster-guard (UCAN capability enforcement + sandboxing). Real-time process management, live terminal UI (E8 root polytope icon), admission gates for identity verification. Build with cargo tauri build from src-tauri/.
• RTL-SDR mock (Linux-capture compatible, TypeScript lab): rtlsdr-mock-sim/README.md — synthetic or replayed rtl_sdr uint8 IQ, heuristic IF offset search + WAV for multimon-ng / STT experiments; not the Rust/WASM inference core (see README boundary). The non-TS wrapper’s monster-mesh verb delegates only to existing distributed mesh backends (see that README).
• RTL-SDR native stub (Rust-first launch path): rtlsdr-mock-sim-native/README.md — contract-shaped binary target used by the non-TS CLI wrapper before JS/TS fallback when enabled.
• Mesh + RTL delegation + mesh-local-mcp gate (opt-in): pnpm run mesh:smoke:local-gates or pnpm run a0 -- run gnosis:test:mesh-rtlsdr — wrapper tests, rtlsdr-mock-sim Vitest (unit + subprocess CLI), refusal smokes, then mesh-local-mcp Vitest; see docs/CONSUMER_STACK.md and rtlsdr-mock-sim/README.md.
• RTL-SDR hardware → lab replay: pnpm run rtlsdr:hardware-loop from this package (dongle capture + JSON sidecar + replay WAV); see rtlsdr-mock-sim/README.md and scripts/rtlsdr-hardware-loop.sh.
• Mesh local MCP + SSE (operator): mesh-local-mcp/README.md — HTTP MCP (GET /mcp, POST /messages via @modelcontextprotocol/sdk) plus GET /mesh/events for live mesh stdout/stderr and config changes; pnpm run mesh:local-mcp from this package.
• aeon-monitor (Rust bin): aeon-monitor/README.md — built from distributed-inference; pnpm run aeon-monitor:build; used as the native monster-mesh backend.
• FPGA / verifylog (register-transfer, not RTL-SDR): verifylog/README.md — simulation + formal log layout; rtl-bridge/README.md — bounded resolution-lift FSM emit (gnosis-rtl-emit); ROADMAP-FPGA.md — phased exit criteria. Optional: pnpm run a0 -- run gnosis:validate:rtl-sim (needs GNOSIS_RTL_TOOLS=1 + ghdl).
• Liquid-memory shard (AeonFlow + mock): liquid-memory-shard/README.md — 10-byte FlowCodec framing, JSON ops, UDP gnosis-liquid-shard-mock; pnpm run liquid-shard:smoke exercises host ↔ mock.
• Jet-engine compressor cascade (shared primitive): gnosis-engine-core/README.md — zero-dep Rust crate where a pipeline's overall ratio is the product of its per-stage ratios (mirrors Gnosis.MathJetEngine.overallRatio_append). FOIL (distributed-inference / runtime) and protocol69 are instrumented as compressor-cascade stages of the OSI jet engine (Gnosis.OSICompressorCascade, overall ratio 510510).

The .gg language is the visible part. The repository is really a set of contract surfaces that keep graph syntax, compiler output, theorem ledgers, runtime reducers, and transport experiments close enough to cross-check each other. package.json exposes that breadth directly: Betty compiler paths, verification bundles, prismatic-refraction lanes, knotgraft transport, CRDT/QDoc state, mesh policy, scheduling mesh, dark-shroud and x-ranger reducers, avatar runtime helpers, test adapters, and polyglot bridges all ship as public subpaths rather than as private README claims.

The formal loop is part of normal development. Scripts validate theorem drift, mutation theorem maps, mechanization release gates, formal-ledger basis, Lean minimal builds, math-sandbox import closure, physics-sandbox builds, arena stack fixtures, and verification bundles. Betty's Lean path is tested at the artifact level: src/betty/lean.test.ts checks generated Lean for countable queue Harris recurrence, measurable kernels, Lyapunov drift, minorization, continuous templates, Levy-Prokhorov endpoints, and product Lyapunov composition.

The performance work is split into named lanes instead of one global speed story. The benchmark tree covers fold-training, negative controls, near-control/regime/adversarial sweeps, mini-MoE routing, Aeon-framed transformer structure, MoA transformer evidence, concurrency, braid fast paths, expressiveness, formal-verification cost, compiler phase breakdowns, native runtime shootouts, and prismatic-refraction throughput. A few concrete anchors below are reproducible commands, not portable constants: Lilith reports 3.0us/iter on betti.gg with --bench 100000; the prismatic fast-path lane documents 30-150 MB/s non-memcpy TypeScript behavior and Rust native 335 MB/s to 562 MB/s on the linked Bitwise CLI profile; the FASTA reassembly rerun reports 6.61 MB/s aggregate on 20 cancer-gene files; and the revived gnode daemon records sub-millisecond warm hits on resident scripts by keeping the Node process and compiled module cache hot behind a Unix socket.

The current bitwise shootout is a cleaner example of the same pattern: a shared FRF-backed candidate walk beats the repeated per-hash sweep by about 2.76x, 3.59x, and 4.21x on sampled domain lengths 3, 4, and 5 respectively, while the same run emits a resident workload certificate that Monster can ingest through --resident-jsonl. That makes the workload useful both as a structural exhaust probe and as a cryptographic entropy probe. The same mass-solve matrix is mirrored in distributed-inference/README.md; it shows the shared FRF walk staying ahead as candidate length increases, while the measured wall time still rises with string length. The current bitwise harness also accepts domain_len=6 for longer research runs and exact exhaustive domain_len=13 before the u64 counter ceiling; a --sampled bounded-time mode now unlocks domain_len=32 for research runs without pretending to be exhaustive. The sampled shootoff smoke run reports domain_len=32 baseline_ns=20583000 boost_ns=14302291 speedup_x=1.44 while staying bounded. The reference numbers above stay in the cheaper 3 to 5 band. The new --brute-familiar mode ranks the common hashes by entropy_yield_per_sec so the same harness can compare MD5, SHA1, SHA-256, SHA-512, SHA3-256, BLAKE2b-512, BLAKE3, xxHash64, and wyhash without hand-waving about the rate at which they give back recoverable entropy. The companion --collapse-sweep run makes the budget cliff visible: with the sampled 32-length path and a 4,096-attempt budget, the familiar ladder already falls to zero observed recovery by prefix_bits=20, while prefix_bits=16 still recovers a small but nonzero fraction.

The boundaries matter because this package is wide. analyze remains report-only; fail-closed admission belongs to build/run/native/test/module paths that invoke the universe kernel. FORMAL_LEDGER.md contains strong named proof surfaces and also broad theory prose, so downstream code should prefer exported reducers and checked Lean/TLA/GG artifacts over rhetoric. App-boundary modules such as dark shroud, avatar, eye-tracking, and x-ranger are typed contracts unless they point to a named theorem. Any change to public subpaths, proof ids, or reducer shapes needs caller search, targeted tests, and ledger updates.

Formal ledger

Gnosis also carries a formal surface: mechanized proofs (Lean, TLA+), named theorem IDs, and TypeScript reducers that map those IDs to data structures downstream code may use.

• FORMAL_LEDGER.md — Human index: where promoted modules live, how sections relate, and links into the proof corpus. It records mechanized surfaces and reducer contracts; it does not try to catalog app UI, orchestration glue, or one-off helpers.
• THEOREM_LEDGER.md — Machine-oriented ledger: rows and structure that tooling and automation treat as canonical (paired with the Lean/TLA+ layout under lean/ and tla/).
• DUPLICATE_THEOREM_IDS.md and DUPLICATE_LEAN_REFS.md — generated hygiene reports that keep theorem IDs and explicit Lean references one-to-one before MCP coverage is emitted.
• PROOF_ARTIFACT_PATHS.md — generated artifact-path audit for MCP proof links, including the split between moved gnosis-math Lean modules, legacy Gnosis Lean, and ledger fallback rows.
• FALLBACK_PROOF_ARTIFACTS.md — generated triage report for remaining ledger fallback rows, split into resolvable references, stale file-looking references, and ledger-only theorem metadata.
• Downstream apps that need the bundle should consume @a0n/gnosis/formal-ledger (often via shared-utils re-exports) instead of importing gnosis paths ad hoc, so primitives and theorem references stay aligned with the package exports.
• The finite-state mesh stack is now indexed there as an explicit chain: masked softmax → MeshMarkovKernel → Dobrushin contraction → Buleyean minorization → distributed certification → reconstruction contract → statistical mechanics accounting → pressure-certified execution path → HFT risk-path demo. The execution-path certificate packages topology 10/12/17/22/43, interfere 43/55, pressure 2586 SPa, closure audit 30210 SPa, information mass 1560 gG, leakage 96 SPa, and stable-tie theorem lineage into one exported contract.

For scope, consumer boundaries, and validation hooks, start at FORMAL_LEDGER.md (sections Scope and Consumer Contract).

Lilith

The fastest GG compiler on earth. 3us native, 5.9us WASM. Evolved from 17 competing runtimes. Written in C. Forward-only scanner with zero backtracking, restrict pointers, stack-allocated arrays. Compiled to both native binary and 5.6KB standalone WASM.

lilith betti.gg --summary
# betti.gg: 10 nodes, 5 edges, b1=0, void=3, heat=1.585

lilith betti.gg --bench 100000
# 3.0us/iter | 100000 iterations | 10 nodes 5 edges | b1=0

lilith-daemon  # persistent Wallington-rotated pipeline, 2.9us/compile

Three distribution paths:

• Native: cc -O3 -march=native -o lilith polyglot/c/lilith.c -lm (34KB, 3us)
• WASM: polyglot/target/release/lilith.wasm (5.6KB, 5.9us -- Workers, browsers, Node)
• Inline: import { loadLilith } from './lilith-wasm-bytes' (base64-embedded, zero fetch)

Eve + Worthington Whip

Eve is Lilith's antiparallel pair. Lilith compiles input (3us). Eve compresses output (chunk → FORK(identity|gzip|deflate) → RACE(smallest) → send).

The Worthington Whip rotates Lilith and Eve across 4 shards × 3 stages:

Shard 0: [Eve]     while Shard 1: [Handler] while Shard 2: [Lilith]  while Shard 3: [waiting]
         ↓ rotate            ↓ rotate               ↓ rotate                  ↓ rotate

cc -O3 -march=native -o lilith-eve-whip polyglot/c/lilith-eve-whip.c -lz -lm
./lilith-eve-whip --bench 10000

The compiler family, ranked:

Performance

High-Performance Topological Serialization: Gnot vs. Bitwise vs. Amplituhedron

Gnosis protocols prioritize Topological Addressability without sacrificing efficiency.

Gnot (Global Network Optimized Tree)

Our Gnot (Global Network Optimized Tree) serialization (0x474B) is a high-performance binary-native format optimized for complex object graphs.

• Binary-Native Properties: Tensor payloads (Float32Array) and binary blobs (Uint8Array) are encoded natively using 4-byte property block lengths, completely bypassing JSON stringification and Base64 wrapping overhead.
• The Result: A massive ~25% wire size reduction (from 131KB to 98KB per network hop) during high-entropy tensor traversal.
• The Purpose: Provides structural addressability while maintaining true binary-native performance. Every leaf in your topology becomes a first-class entity that Gnosis can reason about, verify, and execute natively.

Transparent Compilation (.gg / .ts → .gnot)

Gnosis implements a transparent JIT compilation pipeline modeled after tsc. Whenever you run gnode compile or gnode run on a topology file (whether pure .gg or embedded in .ts), the runtime automatically generates a .gnot binary artifact alongside the source file.

• 0ms Parse Execution: When gnode run intercepts a pure .gg file, it checks the filesystem for an adjacent .gnot artifact. If it exists and is fresher than the source file, it executes the packed binary directly. This bypasses AST parsing completely for a theoretical 0ms cold start latency.
• Transient Representation: .gnot files are automatically handled as transient build outputs (via the monorepo .gitignore), ensuring an uncompromised developer experience while securing production-grade parsing speeds out-of-the-box.

Bitwise (High-Density Data)

For high-throughput telemetry where structure follows data, use the Bitwise/DNA protocol.

• 2-bit Packing: Nucleotides (A, C, G, T) are packed into 2 bits, achieving a 75% reduction in bandwidth.
• Zero Overhead: Bypasses the Gzip/Brotli CPU tax at the edge.

Amplituhedron (Static Geometry)

For terminal algorithms that bypass iterative control flow, use the Amplituhedron MAGIC.GRSM codec.

• Constant Size: The entire .knot file is exactly 28 bytes, regardless of the algorithm's complexity. It completely replaces AST traces with 4 geometric scalars.
• $O(1)$ Load Times: Bypasses AST parsing and topological sorting entirely. The WebAssembly geometry engine reads the boundary scalars and computes the execution volume in $O(1)$ time (0ms cold load vs 246ms for a 100k-edge legacy graph).
• Extreme Reduction: Measured at 49,604x smaller than equivalent legacy ASTs.

[!TIP] Use aeon bw benchmark to compare these formats on your own datasets.

The Compiler Family

Gnosis has five compilers, each shaped by a different fork/race/fold topology. They race each other on every .gg file. The best compiler per node wins.

Becky is the fastest compiler on every topology. Betti is the only self-hosted compiler -- her execution order comes from betti.gg, not from hardcoded TypeScript. Betty is the deepest -- 13 verification phases, stability certificates, Lean proofs.

Global optimality -- "no faster correct compiler exists" -- is provably undecidable (OptimalityUndecidable.lean). Local optimality is the ceiling of provable knowledge. The void boundary (rejection history) tells you everything you have tried and ruled out. It does not tell you what you have never tried.

When Forest runs (forest/iterate.ts), the compilers race per-node. The sliver (+1) guarantees every strategy survives. The void boundary nodes consistently converge to a different compiler than the data-path nodes -- the observer is compiled differently from the observed. 11,016 total rejections across nine Forest passes form the training signal for Buleyean RL.

The Kernel Gap

The distance between local optimality (provable) and global optimality (undecidable). Measurable. Finite. Shrinking. Never provably zero. (KernelGap.lean, 8 theorems, zero sorry.)

Kernel Gap (microseconds, 50 iterations, in-process TypeScript compilers):

Becky (17us in-process Rust, subprocess-bound until FFI) would be Kernel Gap = 0 on every topology. No TypeScript compiler has Kernel Gap = 0 everywhere. aeon-logic wins the named topologies. Betti wins on betti.gg and inline-large.

The formal surface: SelfHostingOptimality.lean (11 theorems), HumanCompiler.lean (14 theorems), OptimalityUndecidable.lean (10 theorems), KernelGap.lean (8 theorems). Zero sorry.

Provably Optimal

x-gnosis is -- to our knowledge -- the first web server whose throughput bound is a mathematical theorem, not a benchmark. THM-SERVER-OPTIMALITY composes 14 mechanized theorems (TLA+ model-checked, Lean 4 sorry-free) proving:

• Critical-path makespan -- no admissible schedule on the same DAG can serve requests faster
• Pareto-optimal resource usage -- no schedule simultaneously beats both makespan and worker count
• Exact speedup = beta1 + 1 -- not asymptotic, not approximate, by definitional equality in Lean
• Lossless information transport -- zero deficit at every layer means no cross-path blocking
• Wire optimality -- per-chunk codec racing achieves wire size <= any fixed encoding strategy

The native guest path now also preserves admitted caller authority instead of flattening it at the transport shell: gnosis-uring forwards verified X-Aeon-* and X-Ucan-Capabilities headers through the resident gnosis-host bridge, and the gnode / WASM execution surfaces resolve that input into runtime executionAuth inside the engine.

The formal corpus includes 600+ TLA+ model-checking configurations and sorry-free Lean 4 proofs with CertifiedKernel witnesses, spectral stability theorems, measurable Harris certificates, Levy-Prokhorov convergence endpoints, and coupled-kernel handoff lemmas.

Quick Taste

(input)-[:FORK]->(fast_path | safe_path)
(fast_path | safe_path)-[:FOLD { strategy: 'linear' }]->(result)

(data)-[:FORK]->(agent_a | agent_b | agent_c)
(agent_a | agent_b | agent_c)-[:RACE]->(winner)
(winner)-[:PROCESS { fn: 'validate' }]->(output)

Getting Started

cd open-source/gnosis
pnpm start

CLI Commands

# Format
node ./bin/gnosis.js --fix example.gg

# Lint and analyze
node ./bin/gnosis.js lint example.gg --target node
node ./bin/gnosis.js analyze betti.gg --json

# Formal artifacts
node ./bin/gnosis.js verify betti.gg --tla --tla-out tla/generated
node ./bin/gnosis.js build betti.gg --lean --lean-out lean/generated

# Execute
node ./bin/gnosis.js run example.gg
node ./bin/gnosis.js native example.gg

# Test
node ./bin/gnosis.js test examples/benchmarks/fold-training.test.gg
gnode test

# Module management
node ./bin/gnosis.js mod init demo
node ./bin/gnosis.js mod tidy

Optional OTEL / Datadog APM

The Gnosis CLI now supports optional OTEL tracing initialization through the shared @a0n/telemetry surface. Enable explicitly with GNOSIS_TRACING_ENABLED=true, or provide exporter env (OTEL_EXPORTER_OTLP_* or Datadog OTLP + DD_API_KEY / DATADOG_SITE). Datadog APM can run agentless via OTLP HTTP without changing CLI commands.

Formal Surface

Canonical formal artifacts now live at the top level of open-source/gnosis: FORMAL_LEDGER.md, THEOREM_LEDGER.md, CROSS_MIXED_THEOREM_SYNTHESIS.md, LANGLANDS_LEDGER_GLOSSARY.md, GNOSIS_COMPILER_BOUNDARY.md, lean/, and tla/. The old open-source/aeon/docs/ebooks/.../companion-tests/formal subtree is now a legacy manuscript compatibility shell.

The knot-theoretic program-optimization surface is currently ledgered in FORMAL_LEDGER.md and THEOREM_LEDGER.md, with the checked-in runtime adapter living in src/untangling-strategy.ts. Keep the Lean claim tied to files present under lean/Lean/ForkRaceFoldTheorems/; the historical UntanglingKnotTheory.lean reference is not present in this checkout.

Randomness (Lean + runtime): CSPRNG definitions (negligible, CsPrngSecurity), finite IND-PRG / PRF games, epistemic Rule 30, the clinamen anti-bridge (no universal CSPRNG from +1 alone), aperiodic PRNG narrative, and Lacey helix geometry live under lean/Lean/ForkRaceFoldTheorems/. The package map (build commands, TypeScript lacey-nested-prng stance) is docs/RANDOMNESS.md.

The practical software translation of the staged-expansion result now also lives in src/untangling-strategy.ts: tools can turn crossing number, essential loops, and composite pressure into concrete advice about when to simplify directly, when to expand first, and when a culprit knot needs staged refactoring before collapse.

The promoted void-dimension theorems now also have a shared runtime surface in src/void-dimensions.ts: cross-file, temporal, and data-plane gaps are exposed as explicit invisible-crossing assessments so scanners can report lower-bound hidden knot pressure instead of leaving the math trapped in comments.

The promoted flow-obstruction theorems now also sit on the public package surface through src/flow-obstruction.ts and the @a0n/gnosis/flow-obstruction subpath: shared tools can classify stagnation, hydraulic jumps, eddy currents, missing backpressure, cavitation, and constriction with one theorem-backed kernel instead of copying scanner-local heuristics.

The executable universe kernel now lives in src/universe/ and is exported both from the root package and the dedicated @a0n/gnosis/universe surface.

The canonical formal-ledger kernel for non-technical platform services now lives in src/formal-ledger.ts. It fixes the primitive basis to fork, race, fold, vent, and interfere, derives family bundles for voidWalking, negotiation, community, metacognition, recovery, and probability, and exposes the shared deriveFormalLedgerBundle(...) contract consumed by shared-utils and shared-ui. The bundle also exposes the exact statistical mechanics accounting certificate and gnostic metrology profile for the 10/30/90 saturation stack over the 12-row Aeon budget. Native helper reductions now cover probability analysis, the Bazaar/Neutral negotiation-profile surface, the communication-field reducer for ombudsman/crisis-style consumers, and dedicated metacognition/recovery reducers.

Prismatic Refraction — Wire Protocol

"Vomit bits as fast as possible and let geometry figure out the shape."

A wire protocol with a one-line app contract: emit raw bytes, no framing, no lane assignment, no shape commitment. The wire layer performs deterministic content-addressed lane assignment mid-flight (the prism). Compatible-lane shards refract on encounter and fold into larger payloads. Shards that never find a partner carry a gauge-invisibility completion certificate. A reader-side storage gate admits only shards on authorized lanes.

The full surface:

• Runtime contract — src/prismatic-refraction.ts: defines the shard/lane/storage-gate reducer and cites the named theorem surface in doc comments.
• Executable witness — src/__tests__/prismatic-refraction.test.ts: exercises the runtime claims for app shapelessness, wire prism behavior, encounter refraction, compatible-lane commutativity, beta1 deficit, gauge invisibility, storage gates, and wire-to-storage soundness.
• Knotgraph paragon — src/prismatic-refraction-knotgraph.ts: map settled shards to 54-dim fp64 blocks in the knotgraph app zone (dims 38-53). Tenant-isolated, content-addressed via 48-bit FNV-1a.
• Portable SQL — src/prismatic-refraction-duckdb.ts: emits dialect-neutral SQL that runs on DuckDB (@duckdb/node-api / @duckdb/duckdb-wasm), Cloudflare D1 (SQLite), and sqlite-wasm / WebSQL in the browser. Schema: 15 DOUBLE columns + 1 BLOB (432 bytes of Float64Array) for bit-exact round-trip.

Integration tests — every Lean theorem witnessed at runtime

cd open-source/gnosis
node ./bin/gnode.js test \
  src/__tests__/prismatic-refraction.test.ts \
  src/__tests__/prismatic-refraction-knotgraph.test.ts \
  src/__tests__/prismatic-refraction-duckdb.test.ts

54 property-based cases across three suites, ~340 ms wall time.

Benchmarks — diversity theorem: best for each lane

The protocol has three implementation lanes. The Lean module proves correctness once; every lane is an operational specialization of the same theorems. Each lane is tuned for its own runtime; nothing is "the fast version" of another.

Reproduce:

# TS reference
node ./bin/gnode.js run scripts/benchmark-prismatic-refraction.ts
# TS fast path vs reference, side-by-side
node ./bin/gnode.js run scripts/benchmark-prismatic-refraction-fast.ts
# Rust native (CLI profile)
cd ../bitwise && cargo run --profile release-fast --bin bench_prismatic_refraction

The TS fast path and Rust native share the same Lean guarantees as the reference (prismRespectsLaneBound, prismPreservesByteCount, wireToStorageIsSound); both include in-run assertions of those invariants so a benchmark that crosses the soundness boundary would fail loudly rather than silently. The WASM build inherits from the same Rust source — it is the compat layer, not a separate implementation to maintain.

Scrambled DNA reassembly — wire is permutation-invariant at the lane level

Claim: scrambling the input byte order does not change the settled lane structure, because lane assignment is content-addressed. The wire recovers the shape from content alone.

Demo 1 — synthetic 1 MB DNA:

node ./bin/gnode.js run scripts/benchmark-scrambled-dna-reassembly.ts

Demo 2 — real cancer-gene corpus (20 FASTA files from @a0n/bitwise):

node ./bin/gnode.js run scripts/benchmark-fasta-reassembly.ts

Aggregate across all 20 cancer genes (130,201 bases, 31.8 KB packed):

• All-lanes reassembly: YES across every gene
• Block-count parity: YES
• DuckDB row-count parity: YES
• Per-block entity-hash divergence: YES (content hash correctly encodes within-lane byte order)
• Average throughput end-to-end: 6.61 MB/s (original + scrambled pipelines combined; 2026-04-19 re-run, M-series Apple Silicon)
• Peak single-gene throughput: 10.69 MB/s (PTEN), 10.55 MB/s (RB1)

Scrambled KRAS produces the same settled lane-byte multisets as unscrambled KRAS; the only thing that differs is the 48-bit FNV content hash, which correctly reflects within-lane byte ordering. Shape recovered from content. Data delegated to geometry.

Full ledger entry with cross-references: FORMAL_LEDGER.md § Wire Geometry Pass 1.

Commercial surface — knotgraft on edgework-app

The wire protocol is exposed as a rate-limited, tenant-isolated commercial endpoint at apps/edgework-app/src/app/api/knotgraft/route.ts. Callers POST raw bytes; the edge projects userId → (tenantHi, tenantLo) (128-bit deterministic djb2 pair stamped into dims 38-39), runs the wire pipeline, and returns knotgraph-shaped blocks with optional portable SQL for DuckDB / D1 / sqlite-wasm materialization. Sliding-window rate limit per tier (free 60/min, growth 300/min, pro 600/min, enterprise 6000/min); per-tier max request size (1–64 MB). Every invocation runs the wireToStorageIsSound witness and 500s if the formal soundness pair ever breaks. 10 test cases green: bun test src/app/api/knotgraft/route.test.ts.

Multi-transport fabric — knotgraft-fabric-server

Full aeon-supported projection of the knotgraft ingest. One server, three transports speaking the same Prismatic Refraction pipeline through the same processIngest core:

Start the server:

cd open-source/gnosis
node --import tsx scripts/run-knotgraft-fabric.ts
# [knotgraft-fabric] all three transports up:
#   HTTP:     :7801
#   TCP Flow: :4244
#   UDP Flow: :4245

Hit it over HTTP:

curl -X POST -H 'content-type: application/octet-stream' \
  --data-binary @KRAS.fasta http://localhost:7801/ingest
# {"blocks":16,"totalBytes":5472,"lanesOccupied":16,"laneCount":16,...}

Or over UDP via aeon wall:

wall --udp aeon://localhost:4245/<any-path>
# {"blocks":13,"totalBytes":34,...}

Verified end-to-end: integration test src/__tests__/knotgraft-fabric-smoke.test.ts binds real ports, sends the same payload over HTTP + TCP + UDP, asserts all three return the same tenant-stamped, soundness-witnessed settled-block shape. Pure-handler tests: src/__tests__/knotgraft-fabric-server.test.ts — 17 cases covering processIngest, HTTP handler (GET info, POST variants, auth, 413, lane-count/emit-sql headers), and FlowFrame encoder/decoder/error. Both green.

Source: src/knotgraft-fabric-server.ts. Modeled on open-source/x-gnosis/src/fabric-server.ts — same three-transport pattern, but ingest-shaped instead of retrieval-shaped.

Client SDK — @a0n/gnosis/knotgraft-client

Dependency-free TS client (src/knotgraft-client.ts). Works on Node ≥ 18, browsers, Deno, Bun, and Cloudflare Workers. Handles bearer auth, content-type selection, automatic Retry-After back-off on 429, and chunked ingest for large payloads.

import { KnotgraftClient } from '@a0n/gnosis/knotgraft-client';

const client = new KnotgraftClient({
  baseUrl: 'https://edgework.ai',
  token: process.env.EDGEWORK_API_TOKEN!,
  maxRetries: 3,
});

// One-shot ingest of a byte buffer.
const result = await client.ingest(bytes, { laneCount: 16, emitSql: true });
console.log(`${result.blocks} blocks from ${result.totalBytes} bytes`);

// Stream a large file in chunks sized to the caller's tier.
const { limits } = await client.describe();
await client.ingestChunked(bigBuffer, limits.maxRequestBytes);

11 tests green: node ./bin/gnode.js test src/__tests__/knotgraft-client.test.ts — covers bearer auth, octet-stream vs JSON transport, lane-count validation, 401/413/429, automatic Retry-After retries up to maxRetries, chunked ingest, and describe().

Gnosis-First Testing

open-source/gnosis now treats gnode test as the canonical test surface.

• .test.gg files remain the formal topology-proof layer.
• TypeScript runtime/integration tests should import from @a0n/gnosis/test.
• bun:test and vitest are compatibility adapters under the same Gnosis-owned matcher and mock layer rather than the source of truth.
• The mixed runner keeps formal law status visible instead of flattening theorem-aware diagnostics into generic pass/fail output. entrypoints that normalize aggregate Halogram C0-C3 outputs plus deterministic stress-response markers into the shared family contracts. The same kernel now also exposes non-core justice and governance helper reductions: justice maps evidence/adjudication state into probability/community/metacognition bundles, and governance maps Aeon Voting tallies plus decision-process pressure into negotiation/community/metacognition/recovery bundles, so UI layers can stay at projection instead of re-implementing theorem math locally. The latest non-core pass keeps that same fixed primitive basis while adding native trust and behavior reducers: trust reduces authority/manipulation surfaces into community/metacognition/recovery, and behavior reduces deterministic loop analyses into the same families, so shared consumers can deepen the math without expanding the core family enum. The human-facing FORMAL_LEDGER.md is intentionally theory-only: downstream shell/runtime adapters may consume these bundles, but implementation details stay with the consumer docs rather than being recorded as theorem ledger entries.

The canonical twin/psyche reducer now lives in src/twin-psyche-formalization.ts. It has expanded beyond the initial identity/upload bundle to include the newer Lean and PsycheGrind consciousness, knot-thermodynamic conflict, deceptacon/void-walking, emotion/personality, vent/exhaustion, and master theorem surfaces. The same deterministic reducer now drives public-twin, twin-directory, digital-twin simulation, relationship-profile, shell-digest, and api-edge formalization consumers.

That runtime catalog now carries 105 explicit theorem ids, with the newest promotion wave traced directly back to concrete PsycheGrind.lean theorem names. Downstream consumers therefore get both human-readable theorem labels and exact mechanized provenance instead of a theorem list that can drift away from the Lean surface.

The twin/psyche theorem integration now also lives in src/twin-psyche-formalization.ts. That module promotes the 32 established twin-identity, psyche cross-mix, and consciousness-upload results into an executable reducer that emits spotlight theorems, anti-thesis controls, and a supporting formal-ledger bundle for shared-ui, api-edge, and Aeon Shell consumers.

All commands support --json and --sarif for CI integration.

For TypeScript orchestration entrypoints, gnode compiles a strict TS subset into GG, prints an Aeon-style lane schedule, and runs the result through Gnosis today. The same CLI now also exposes explicit cross-domain compilation across code, natural, and gg, with preservation obligations carried as semantic facets instead of being flattened away. That keeps natural-language flows in the same kernel: STT -> text -> parser adapter -> discourse IR -> GG topology -> target emission.

The precompiled artifact host for that path now lives directly in src/gnode-execution.ts, exported as @a0n/gnosis/gnode-execution and reused by x-gnosis for its /.aeon/gnode/* compatibility surface instead of being owned downstream.

The same runtime layer now also exposes a Gnosis-owned WASM host surface in src/wasm-execution.ts on top of the lower-level src/wasm-execution-bridge.ts: scalar (scalar-v1) and JSON (json-v1) guests can now be registered and executed through the same /.aeon/wasm/* control contract that downstream hosts consume. Capability validation now also recognizes explicit browser and WASI guest targets (wasm-browser, wasi) so downstream hosts like Forge, x-gnosis, and gnosis-uring can certify the same topology against the actual guest boundary instead of pretending every Gnosis app is just bun.

Native hosts now also have a checked-in runtime bridge in src/native-host-bridge.ts plus the bin/gnosis-host.js launcher. That long-lived stdio surface keeps GnosisGnodeExecutionSurface and GnosisWasmExecutionSurface resident in one process so a front listener such as gnosis-uring can own the public /.aeon/gnode/* and /.aeon/wasm/* routes without bouncing those requests back through a second HTTP loop.

That same path now emits a QDoc-first certified app envelope in src/certified-app.ts. The envelope is the canonical app identity for Gnosis-owned artifacts: it binds the universe certificate, source/artifact digests, runtime/capability requirements, and append-only deploy/publish/runtime/AeonPID attestations into one record. JSON mirrors are deterministic exports for boundary consumers, not a second source of truth.

The shared CLI keeps a daily daisy-chain cache of compiled GG artifacts, .qdoc cache records, stable runtime binding modules, and a Node compile-cache layer that can be primed ahead of time with pnpm --dir open-source/gnosis run gnode:prewarm -- --json. The wrapper also tracks its own bundle freshness from an exact dependency manifest instead of scanning whole source trees before every run. If GNODE_CACHE_AEON_RELAY_URL or GNODE_CACHE_RELAY_URL is present, those cache records also federate through the built-in DashRelay/Aeon relay path. Use --trace-timings on a single gnode run to see the wrapper plus cold-versus-warm runtime path directly. The native landing zone for those compiled processes is x-gnosis and its Rust transport surface in gnosis-uring.

That surface now also has a checked-in toy runtime shootout for echo, fib, and Promise.all fanout entrypoints across gnode, Bun, tsx, ts-node, plain Node on compiled JavaScript, and Deno when Deno is installed. Run the local smoke through pnpm --dir open-source/gnosis run bench:gnode-runtimes; the larger sample counts belong on Cloud Build, not on a laptop.

The gnode daemon (gnode/daemon.mjs) eliminates repeated V8 startup and bundle-import overhead for resident local scripts. A persistent Node process stays hot behind a Unix socket; the revived path loads the current prewarmed ESM bridge bundle and caches esbuild-compiled script modules by source mtime. On the local fib(20) fixture, the first request still pays compile work (~87ms internal), while repeated warm requests return in roughly 0.04-0.07ms inside the daemon (~0.22-0.43ms socket round-trip from a Node client). Fresh subprocess shootouts remain separate from this resident hot-path number.

What You Get

Language Primitives

Universe Surface

The language/runtime now exposes ambient law directly:

The official package entrypoint for that surface is @a0n/gnosis/universe.

• ambient enforcement: universe admission is automatic and fail-closed for executable paths
• observable built-ins: law.status, law.deficit, law.heat, law.conservation, law.certificate
• first-class values: LawState, LawCertificate, LawKernel
• direct constants: Pi, SpeedOfLight, PlanckConstant, GravityConstant, Second, Meter, LightYear, ApplicationDimension, CurrentDimension, DefaultLanguage, SupportedLanguages, QuantumBell, and related aliases
• direct formulas: KernelFormulaWeight, LandauerHeat, PhotonEnergy, GravitationalForce, ProperTimeSeconds, DimensionDeficit, SemioticDeficit, InformationAscentBitsFromMass, QubitProbability

Applications remain dimensionless by contract. The current execution dimension is explicit and defaults to information; quantum literals carry currentDimension = "quantum" while remaining dimensionless application values.

Structured Primitives

Higher-order graph shapes for recurring patterns:

• WallingtonRotation -- chunk-level pipelined processing
• WorthingtonWhip -- shard-level fork/rotate/fold
• StructuredMoA -- sparse expert routing across attention blocks, now lowered with explicit corridor/trace/vent request-compression boundaries
• HeteroMoAFabric -- backend-diverse mirrored StructuredMoA lanes with per-layer cannon/helix rotation, paired-kernel race/adjudication, one laminar global collapse, and a runtime plan that can bind to CPU, WebGPU, WebNN, WASM/browser, and env-driven CUDA or vendor-NPU runners while learning slowest-to-fastest cross-layer launch staggering from community memory

The WallingtonRotation lowering path now also has a compiler-side Aeon Flux site witness surface: lowered GG can be re-read as a positive-stream-budget site with typed pathCount, streamCount, and Δβ, and the resulting witness is keyed directly to the in-tree adequacy theorems rather than to prose-only annotations.

UFCS Sugar

Linear PROCESS chains can be written in either direction:

(x)-[:PROCESS { fn: 'double' }]->(y)
// or equivalently:
x.double()

Native Transport: gnosis-uring

The parallel chaos swarm simulator and chaos-swarm CLI/FFI binary ship as gnosis-chaos in this package; gnosis-uring depends on that crate for the same static server topology types. NativeManifoldExecutor invokes gnosis-chaos/target/release/chaos-swarm by default.

The production Rust transport maps the four primitives directly onto io_uring:

Architecture:

• Compiled route tables -- O(1) hashmap dispatch, .gg JSON topology loader, function-pointer chains
• Multi-worker SO_REUSEPORT -- kernel distributes connections, no userspace multiplexing
• SQPOLL mode -- zero-syscall hot path via io_uring kernel polling thread
• Core pinning -- sched_setaffinity eliminates cross-core cache thrashing
• Laminar codec racing -- per-chunk compression (identity/gzip/brotli/deflate), smallest wins
• Same-request collapse -- bounded race table prevents duplicate work on TCP+UDP
• Pipelined HTTP -- batch parsing with incomplete-tail carryover
• Dual protocol -- HTTP/1.1 for browsers, Aeon Flow (10-byte frames) for topology clients
• TechEmpower ready -- all seven benchmark categories: plaintext, JSON, DB, queries, updates, fortunes, cached-queries

Jet-Engine Compressor Cascade

Transport stages are instrumented as a jet-engine compressor cascade: a pipeline's overall ratio is the product of its per-stage ratios (proven axiom-clean in Gnosis.MathJetEngine.overallRatio_append). The laminar codec racing above is the L4/L7 compressor stage; the protocol69 L5 teleport cache-skip is a 9x stage (288 / 32 envelope bytes when a warm admission window collapses repeated FOIL fetches into a cached hit). The shared TypeScript primitive lives at open-source/aether/src/wasm-simd/compressor-cascade.ts.

Why It Works

Benchmarks

Topological Raycaster vs Linear Memory Parsing

By compiling data schemas into 28-byte Grassmannian Amplituhedron tensors (.knot), the Gnosis Swarm replaces $O(N)$ string memory scanning with $O(1)$ geometric raycasting.

The Octonionic Compiler (Non-Associative Routing)

Gnosis abandons traditional associative AST control flow (if/else, switch). Instead, topological operations are mapped to the imaginary bases ($e_1 \dots e_7$) of the Fano Plane. By shifting AST parenthesis groupings, execution is routed physically by breaking mathematical associativity.

// Path A: Grouping yields -e6 (Inverse RACE)
const astA = [[':OBSERVE', ':SLIVER'], ':FOLD'];
executeOctonionicQuery(astA); // Physically maps to `!=` (Exclusion)

// Path B: Grouping yields +e6 (Forward RACE)
const astB = [':OBSERVE', [':SLIVER', ':FOLD']];
executeOctonionicQuery(astB); // Physically maps to `==` (Inclusion)

Zero conditional logic is evaluated. Geometry dictates the execution boundary.

HTTP Throughput (gnosis-uring, Linux io_uring, 8 threads)

HTTP Throughput (x-gnosis, Bun, macOS M1)

vs nginx (same gzip surface, local loopback)

Wire Efficiency

Topology Execution (compiled codegen, V8)

Benchmark Suites

The repo includes 15 benchmark families with bootstrap intervals, regime sweeps, and adversarial controls:

• fold-training -- linear vs nonlinear selection boundary
• negative-controls -- one-path parity checks
• near-control-sweep -- fine-grained boundary zoom
• regime-sweep -- continuous regime variation
• adversarial-controls -- winner selection and early-stop rewards
• moe-routing -- four-expert mini-MoE routing
• aeon-framed-transformer -- four-stage Wallington triangle with Aeon frames
• moa-transformer-shootout -- dense vs sparse rotated transformers
• moa-transformer-evidence -- workload sweep, sparsity ablation, timing summaries
• hetero-moa-fabric -- mirrored backend racing with Cloud Run profiling
• concurrency -- concurrent execution patterns
• expressiveness -- language expressiveness coverage
• formal-verification -- stability and optimization pass validation
• compiler-phase -- five-compiler shootout (Betty, Betti, Franky, Beckett, aeon-logic) + 13-phase Betty breakdown + self-hosting optimality test
• forest-convergence -- per-node polyglot racing with the sliver (+1), meta-iteration, diversity theorem validation

Native Compiler Boundary & Formal Validations

The Gnosis compilation engine uses gnosis-betti-wasm for high-performance, Rust-native O(1) semantic extraction, completely decoupled from legacy JS bundlers. Topological correctness is enforced at admission time via the shared universe kernel.

Native Runtime Shootout (Static Prediction vs. Empirical Reality):

Gnosis polyglot ships as both a native binary (gnosis-betti) and a WASM fallback, following the existing lilith deployment pattern. On native surfaces (macOS, Linux), the TypeScript bridge spawns the standalone Rust binary to completely bypass V8's WASM initialization overhead.

Are Gnosis static extractions faster than actual native execution? Yes. For compiled targets (Rust, Go), Gnosis extraction takes ~9-10ms vs natively compiling and executing which takes ~150-510ms. For interpreted targets like Python, bypassing WASM init entirely drops the native extraction time down to ~45ms, soundly outpacing the actual native Python interpreter.

═══════════════════════════════════════════════════════════════════
 Native Runtime Benchmark — Static Prediction vs. Empirical Reality
═══════════════════════════════════════════════════════════════════

── ✓ Python resource + threads [python]
   Native runtime: 53ms   Topology extraction: 45ms
   Precision: 7/9 checks (78%)

── ✓ Rust sequential + error handling [rust]
   Native runtime: 149ms   Topology extraction: 10ms
   Precision: 7/8 checks (88%)

── ✓ Go goroutine fan-out + WaitGroup [go]
   Native runtime: 510ms   Topology extraction: 9ms
   Precision: 8/8 checks (100%)

── Overall ──────────────────────────────────────────────────────────
   Checks passed: 22 / 25
   Precision: 88.0%
   Wall-clock (native):      python: 53ms  rust: 149ms  go: 510ms
   Wall-clock (extraction):  python: 45ms  rust: 10ms  go: 9ms

Reproduce: node ./bin/gnode.js run src/benchmarks/native-runtime-benchmark.ts

Monster resident Flow serving rerun (local release binary, May 2026):

The hot monster path is now resident Flow stdio. For supported pure benchmark topologies, Monster prepares or reuses a cached C AOT artifact and execs into that binary as the resident Flow process; --no-aot-c keeps the Rust walker baseline available. Latest local serving cut (warmup=3, measured=10):

For native companion fanout (ada:user|ada:profile), the same benchmark family measured monster-gg-flow-resident at 93.700us mean, rust-native at 4.04ms, JVM Java at 71.75ms, and CPython at 78.61ms. These are process-bound runtime comparisons, not claims against in-process function calls.

Cold-Start Subprocess Shootout (echo and fib benchmarks, warmup=1 measured=3, Apple M-series, 2026-04-21):

echo

fib

7× improvement over the previous run (1,187ms → 172ms on fib) after fixing @a0n/aeon-logic and @a0n/aeon-clockwork package exports to point at compiled dist/ instead of raw .ts source. gnode was silently falling back to the tsx execution path on every invocation; the current wrapper now runs the prewarmed ESM bundle and comfortably beats both tsx and ts-node.

Reproduce: pnpm --dir open-source/gnosis run bench:gnode-runtimes

Latest local rerun, 2026-05-01 (pnpm run bench:gnode-runtimes -- --iterations=3 --warmup=1), completed echo and fib before Universe admission rejected fanout (eventual:eventually_beta1_zero remained open), so the full harness exited 1. p50 wall milliseconds from the completed rows:

[!NOTE] > This shootout measures cold-start subprocess latency only — the cost of spawning a fresh process, initializing the runtime, and running one function. It is not a sustained-throughput comparison.

gnode has two faster execution modes this table does not capture:

Mode	gnode	Bun
Daemon warm hit (persistent process, Unix socket)	0.22-0.43ms	11ms
gnosis-uring HTTP (io_uring, 8 threads, depth 256)	5.1M req/sec	~112K req/sec

The daemon (gnode/daemon.mjs + gnode/client.c) eliminates repeated V8 startup and bundle-import work for resident scripts: a persistent Node process stays hot, caches compiled modules by source mtime, and serves the local fib(20) fixture in sub-millisecond warm round trips. The gnosis-uring Rust transport maps FORK/RACE/FOLD directly onto io_uring SQEs/CQEs and runs at millions of requests per second. Neither mode pays the cold-start cost shown above.

MoA Transformer Benchmark Shootout: The native compiler enforces Universe algebraic bounds at admission time. The transformer shootout confirms strict formal gating:

• moa-transformer-regular.gg: PASS (law=verified, 14 formal proofs unbroken)
• moa-transformer-moa.gg: PASS (law=violated, Universe admission correctly rejected)

Corpus

The repo includes 530+ .gg topologies, 30+ .test.gg suites, 30+ TypeScript tests, 15 host-language bindings, and 600+ generated TLA artifacts.

Top-level witness topologies now also include topologies/aeon/aeon_object.gg, a minimal AEON constitution that folds address, capability, witness, storage scope, replication policy, and projection into one launchable materialization plan.

Example families: transformers, CRDTs, synth graphs, privacy flows, edge pipelines, failure-boundary witnesses.

Repository Guide

• src -- compiler, runtime, CLI, module tooling, auth, CRDT, benchmarks, forest convergence engine, emitted Aeon Flux site witnesses, and the unified TypeScript formal-check surface that merges GG analysis with polyglot leak diagnostics.
• polyglot -- the Rust polyglot extractor/compiler crate, including Ditto framework recognition, GG lowering, theorem-anchored diagnostics, ghost-mass leak accounting, the focused framework-recognizer test corpus, and Monster's resident Flow C AOT serving path.
• harnesses -- subprocess harnesses and framework-compatibility shims for polyglot execution, including the Node router capture lane for Express, Hono, Koa, and Fastify, the Go router capture lane for Gin, Chi, Fiber, and Echo, the Python service capture lanes for Flask and FastAPI, the Ruby service capture lane for StructuralErroratra, and the Java service capture lane for Spring
• gnode -- Rust-fronted TypeScript-to-GG runner and schedule surface
• examples -- executable examples and .test.gg suites, including the Aeon Flux site adequacy proof topology and the minimal WallingtonRotation witness source
• bindings -- subprocess-based client bindings for non-TS hosts
• content -- manuscript and publication mirrors only; not the canonical proof source
• docs -- supporting research notes and static documentation assets (Aeon Flux vs x-gnosis Hono imports, anime-inspired ontology gap analysis, Lean transformation-family plan, randomness / PRNG formal map)
• lean -- canonical Lean theorem surface, including the Init-only training-saturation readiness bridge and statistical mechanics accounting pass
• lean-minimal -- fast Init-only Lake package (no Mathlib)
• tla -- canonical promoted TLA+ corpus
• ROADMAP -- language roadmap and near-term design edges

Formal Voting Surface

The repository now also carries a standalone voting proof/kernel pair for ecosystem governance:

• topologies/aeon/aeon_voting.test.gg: witness topology for the governance-deficit rule
• lean/README.md: entrypoint into the standalone Lean theorem surface
• PROOF_OF_LIFE_LEDGER.md: ledger entry for the Aeon voting theorem surface. The historical lean/Lean/ForkRaceFoldTheorems/AeonVoting.lean reference is not present in this checkout, so keep voting proof claims ledger-scoped until the module is restored.

Worker-facing TypeScript helpers now resolve Node createRequire() lazily, so importing the surrounding Gnosis surface inside Cloudflare Worker bundles no longer crashes at module initialization when no Node-style module path exists.

License

Copyright Taylor William Buley. All rights reserved.

MPL-2.0

FOIL Grassmannian Default Hotpath (purity-gated adaptive write-back)

monster run <file> / gnode run <file> now auto-caches PURE, deterministic, single-result runs and skips re-execution on reuse (the "squirt"). On a cold run of a pure script, gnode executes it once with stdout captured (re-running itself with FOIL disabled, so no recursion — path-agnostic across monster/bundle/tsx), emits the output, and writes the result to the grassmannian cache (distributed-inference/.qa-artifacts/fib20-shootout/). The next run hits the cache and returns in a few ms regardless of workload weight (fib(40): 5779ms cold -> 6.49ms wrapper hit, ~890x).

Safety: the purity gate denies anything that reads argv/env/stdin/clock/random/fs/net or is interactive, so impure scripts always re-execute (their side effects are never skipped). Controls: FOIL_ENTROPY_BOOST=0 (opt out), // @foil-pure or // @squirt (force cache), // @foil-impure (force off). Adaptive Reynolds: write-after-cold pays from run 2 (R* ~= 1.37, measured on the FOIL smart-skip shootout). Backed by Gnosis.EcballiumLauncher + Gnosis.MathJetEngine.overallRatio (the time-domain compressor).