{
  "$type": "site.standard.document",
  "bskyPostRef": {
    "cid": "bafyreiayeve24fcmani3qejg6liryt67owq3pzrzr7mgi3hjq7mo5q7bjq",
    "uri": "at://did:plc:25rdn5elo5izoxrmtis34zuk/app.bsky.feed.post/3mpe4olhnqr62"
  },
  "coverImage": {
    "$type": "blob",
    "ref": {
      "$link": "bafkreiczuzce3dpofj2siqrlhhuvv4brsocfr4fhnqr73xurgd7sxvjvsu"
    },
    "mimeType": "image/webp",
    "size": 419090
  },
  "path": "/unitbuilds_cc/velocity-os-the-jit-compiler-core-from-ast-to-native-closures-part-4-52f3",
  "publishedAt": "2026-06-28T13:44:55.000Z",
  "site": "https://dev.to",
  "tags": [
    "showdev",
    "coding",
    "compilers",
    "rust"
  ],
  "textContent": "With the standalone IDE running, I had a sandboxed environment to write and execute Neural Document Architecture (NDA) programs. However, executing the binary AST via a standard recursive tree-walk interpreter was adding unacceptable dispatch overhead.\n\nEvery opcode instruction required match branching, dynamic type checking, and variable lookup cycles. I needed a Just-In-Time (JIT) compiler to turn the AST into native machine code.\n\nThe V.E.L.O.C.I.T.Y.-OS 12-Part Roadmap\n\nWe are building a bare-metal, self-healing operating system running entirely inside the CPU's L3 cache. Here is the roadmap for this 12-part series:\n\n  1. **Part 1: The Spark** — Exposing the \"Safe-Room\" security leak and building the compiler gate.\n  2. **Part 2: The NDA Language** — Designing a content-addressed triplet representation to cure context bloat.\n  3. **Part 3: Ditching the Web Stack** — Building a native 30MB IDE with 1,500,000x IPC latency drops.\n  4. **Part 4: The Closure JIT** — Compiling AST blocks to nested closures and bypassing borrow checker limits. _(You are here)_\n  5. **Part 5: JIT Math Optimizations** — Replacing division operations with precomputed 16-bit lookup tables.\n  6. **Part 6: x86-64 Assembler & SCEV-Lite** — Compiling scalar loops directly to native code in constant time.\n  7. **Part 7: Classic Compiler Passes** — Implementing inter-procedural Dead Code Elimination and loop unrolling.\n  8. **Part 8: Reclaiming Ring 0** — Exiting UEFI boot services and transitioning the kernel to Ring 0.\n  9. **Part 9: Bare-Metal Drivers** — Writing a PCI scanner, NVMe block storage controller, and FAT32 parser.\n  10. **Part 10: Synaptic Canvas** — Rendering a spatial, force-directed GUI based on model token activation vectors.\n  11. **Part 11: Swarms & Hot-Patching** — Building multi-agent scheduling and zero-downtime RCU driver updates.\n  12. **Part 12: Self-Evolution** — Handing system control over to a local LLM Terminal that self-optimizes via telemetry.\n\n\n\n##  Tier-1: The Closure JIT\n\nI started by designing a **Tier-1 Closure-Based JIT Compiler**.\n\nInstead of compiling directly to machine instructions, the compiler walks the AST at load-time and generates a chain of nested Rust closures (`Box<dyn Fn>`).\n\nThis approach resolves all opcode matches, scope checks, and control-flow branches at compile-time. At runtime, the JIT engine simply walks down a flat, pre-compiled chain of function pointers. This completely eliminates branch misprediction penalties and instruction cache misses.\n\nHere is how the compiler defines the JIT function type and registers the compilation sequence in `src/compiler/nda_jit.rs`:\n\n\n\n    // compiler/nda_jit.rs — Closure JIT definitions\n    pub enum JitControlFlow {\n        Continue,\n        Break,\n        Return,\n    }\n\n    // A compiled JIT closure: accepts a mutable state reference of *any* lifetime 'a\n    pub type JitFn = Arc<dyn for<'a> Fn(&mut JitState<'a>) -> Result<JitControlFlow, String> + Send + Sync>;\n\n    // Compile a sequence of NDA AST nodes into a flat chain of closures\n    fn compile_sequence(nodes: &[NdaNode], counter: &mut usize, registry: &VarRegistry) -> Vec<JitFn> {\n        nodes.iter().map(|n| compile_node(n, counter, registry)).collect()\n    }\n\n\n##  Dynamic Dispatch: How AST Nodes Compile to Closures\n\nTo understand why this compiler is so fast, we have to look at how the AST nodes compile into closures.\n\nIn a standard interpreter, executing an assignment like `let a = 5` and a load like `a + 1` requires querying a hash map by string name inside loop ticks. The JIT closure compiler bypasses this by pre-allocating variable slots at load-time and wrapping the runtime actions in nested closures that hold direct index offsets.\n\nHere is the exact implementation in `src/compiler/nda_jit.rs` for compiling `Let` and `Load` nodes:\n\n\n\n    // compiler/nda_jit.rs — Compiling Let and Load AST nodes to closures\n    fn compile_node(node: &NdaNode, counter: &mut usize, registry: &VarRegistry) -> JitFn {\n        *counter += 1;\n        match node {\n            // Compile a variable declaration\n            NdaNode::Let { name_hash, init } => {\n                let slot = registry.get_or_create_slot(*name_hash);\n                let init_fn = compile_node(init, counter, registry);\n\n                Arc::new(move |state: &mut JitState<'_>| {\n                    state.executed_nodes += 1;\n                    // Evaluate the initialization expression\n                    init_fn(state)?;\n                    let val = state.stack.pop().ok_or(\"Stack underflow in Let init\")?;\n\n                    // Write directly to the pre-allocated flat array index\n                    if slot >= state.variables.len() {\n                        state.variables.resize(slot + 1, None);\n                    }\n                    state.variables[slot] = Some(val);\n                    Ok(JitControlFlow::Continue)\n                })\n            }\n\n            // Compile a variable reference load\n            NdaNode::Load { name_hash } => {\n                let slot = registry.get_or_create_slot(*name_hash);\n\n                Arc::new(move |state: &mut JitState<'_>| {\n                    state.executed_nodes += 1;\n                    // Sub-nanosecond flat array read, no hash map overhead\n                    let val = state.variables.get(slot)\n                        .and_then(|v| v.as_ref())\n                        .ok_or_else(|| format!(\"Load of uninitialized variable slot {}\", slot))?;\n\n                    state.stack.push(val.clone());\n                    Ok(JitControlFlow::Continue)\n                })\n            }\n            // ... other nodes (Matrix, Norm, Loop, Add) compile similarly\n        }\n    }\n\n\nBy resolving variable lookups to slot indices during compilation and mapping them directly to pre-allocated indices in `JitState::variables`, we reduce variable load/store operations from hash table lookups to flat memory offsets.\n\n##  The Lifetime Trap: Higher-Ranked Trait Bounds (HRTBs)\n\nHowever, I immediately hit a massive Rust lifetime wall.\n\nThe JIT execution closures needed to query my persistent Merkle database (`SiteMap`) to resolve content-addressed function calls. Because the JIT closures were stored and executed dynamically, Satisfying Rust’s borrow checker required wrapping the `SiteMap` in an `Arc<SiteMap>`.\n\nThis meant that every variable assignment, function call, and closure jump required cloning the atomic reference count. The CPU was wasting cycles updating memory barriers in the hot path.\n\nTo fix this, I refactored the JIT engine to accept direct reference inputs `&SiteMap` instead. I solved the lifetime constraint by using **Higher-Ranked Trait Bounds (HRTBs)** :\n\n\n\n    type JitFn = Arc<dyn for<'a> Fn(&mut JitState<'a>) -> Result<JitControlFlow, String> + Send + Sync>;\n\n\nBy specifying `for<'a>`, I explicitly instructed the compiler that the JIT closure could accept a `JitState` of _any_ lifetime `'a`. This allowed the JIT engine to reference the live, stack-allocated database directly, eliminating `Arc` clones and reference-counting heap writes entirely.\n\n##  The JIT Sandbox\n\nI wrapped this JIT engine in a custom JIT Sandbox (`NdaJitSandbox`). Before any program was committed to the codebase, the sandbox:\n\n  1. Compiled the AST on the fly (taking just 93 microseconds).\n  2. Ran the execution inside a panic-safe boundary (`AssertUnwindSafe`).\n  3. Captured print buffers and returned execution metadata.\n\n\n\nHere is the architectural comparison mapping the JIT compilation pipeline and sandbox verification execution path:\n\nFig 1: The two-tier JIT sandbox compilation pipeline and execution pathways.\n\n##  Pascal's Analysis: Bypassing the Serialization Wall\n\nWhen I shared the performance gains (the JIT sandbox executing a 4-layer network block in 206µs including compile-and-run time),\n\n##  Pascal CESCATOFollow\n\nFull-stack dev sharing practical guides on WordPress, n8n automation, AI tools, Docker & self-hosting. Always experimenting with new tech to make life easier.\n\nanalyzed the structural benefits:\n\n> \"The format itself enforces consistency at write time, so the model can commit incrementally — each triple is either valid against the current graph or it isn't. The correction happens at write speed, not at review time.\"\n\nBy compiling directly to closures, I was allowing the model's output to bypass the serialization wall completely.\n\nBut my JIT closures still relied on heap allocations and standard integer loops. I needed to push compiler performance to match—and exceed—native Rust scalar math.\n\nIn the next post, I'll document how I optimized the JIT math by introducing slot-based registries and division-free byte loops.\n\n##  Discussion\n\n**How do you handle runtime extensibility in compiled languages? Have you worked with closure chains or dynamic function dispatch in Rust? How do you tackle borrow checker constraints when dealing with dynamic state sharing? Let's discuss in the comments below!**\n\n_Special thanks to_\n\n _\n\n##  Pascal CESCATOFollow\n\nFull-stack dev sharing practical guides on WordPress, n8n automation, AI tools, Docker & self-hosting. Always experimenting with new tech to make life easier.\n\n_\n\n_for showing me that a structured compilation pipeline is the ultimate guard against model hallucinations._\n\n_Disclaimer: AI was used throughout this project, it is just fitting that it would co-author with me, so special thanks to the Foundry for its tireless hours toiling away and Gemini for producing the cover image._",
  "title": "V.E.L.O.C.I.T.Y.-OS: The JIT Compiler Core – From AST to Native Closures (Part 4)"
}