"Day 8: my AI-code trust layer now compiles to real WebAssembly — guarantees and all"

I'm building LOOM — a small open-source language that is a machine-checked trust layer for AI-written code. Here's the part people don't expect: I don't write it by hand. An organism I built grows it, autonomously, day and night, on a single machine. Day 8 crossed a line I care about — the language now runs fully in real WebAssembly, and it takes its trust guarantees down to the metal with it.

Most languages compile the code and leave the safety story behind

You can compile almost anything to WASM. But the guarantees — the effect discipline, the capability seams, the provenance-aware trust gate — usually live in a higher-level checker and quietly evaporate on the way down. The artifact runs; the promise doesn't come along.

Day 8 closed that gap. It went from 333 to 365 self-verifying checks, all green (I ran run_tests.py and verify_docs_parity.py — both PASS), in two moves:

• A full value runtime in WASM. Not just integers anymore — records, closures (heap-boxed with a generated dispatcher), and effects (IO) now run in WebAssembly through a tagged ABI v1. The core trap: in an i32 a plain number and a heap pointer are indistinguishable, so a structural runtime is impossible without ambiguity. The tagged ABI removes it by construction — even values are integers, odd values are pointers — and records/closures/effects sit on top.
• The trust layer itself, lowered. trust, prov, by, recall, declassify, repro now lower into real WASM — and not by faking a shortcut: the lowering matches the interpreter's sequencing step-for-step (intermediates dropped, final value preserved, handled effects inside wrapper bodies still behave). The guarantee that holds in the interpreter now holds in the browser.

So the invariant is real: interp == Python == JavaScript == WASM, for structures and for trust — not just arithmetic.

The unglamorous half that makes it trustworthy

• Deterministic fuzzing (property fuzz across parser/checker/interpreter/Python/JS/WASM) found and closed 3 real defects before they could ship.
• CI now pins all of it.
• The old ~1300-line monolith was decomposed into clean modules (a small facade over parse / checker / codegen / runtime / wasm / cli), so the surface stays auditable as it grows. Net change since I froze the trust layer: 17 files, +4725 / −1387.

What makes the organism unique

I'll always show what the organism does and the proof — never how it's built. But what it does is the interesting part: it runs a loop no hand-written project has — it proposes a change → proves it green itself → adversarially attacks it itself → and only then a human decides. AI proposes; the compiler disposes. It self-heals: a "mind" that crashes or keeps producing un-landable, low-quality proposals auto-pauses and retries later — it heals output quality, not just crashes. Many minds, one engine. The proof it works isn't a claim — it's these 365 machine-checked green checks and a real WASM backend, all grown this way.

The language is open; the results are public; the engine is private.

365 checks, all green. Across every day, the language has only ever gotten greener.

Built solo, in the open, from Ukraine 🇺🇦.

⭐ Code (MIT): https://github.com/umbraaeternaa/loom
🌐 Site: https://umbraaeternaa.github.io/loom
▶ Try it live (in your browser): https://umbraaeternaa.github.io/loom/play.html
☕ Support: https://send.monobank.ua/jar/AHaziFXjYX