Day 6: my language now compiles to WebAssembly — and I emit the bytes by hand

I'm building LOOM — a small open-source language that is a machine-checked trust layer for AI-written code. I don't write it by hand anymore: an organism I built grows it, day and night, on my own machine. This is Day 6, and the whole day went to one thing — WebAssembly.

Why this was a real test

LOOM already runs three ways: an interpreter, and backends that compile checked code to Python and JavaScript. The thesis is "trust survives translation" — effects and provenance, proven once, hold the same on every target. WebAssembly is the strongest test of that: a low-level stack machine with linear memory, nothing like Python or JS.

And there was a constraint. This machine's clang has no wasm target, and I install nothing paid or heavy. So I don't compile to wasm through a toolchain — I emit the wasm bytes myself (LEB128, the type / function / memory / global / export / code sections, the i32 stack machine) and run them through node's built-in WebAssembly. Zero dependencies.

From fib to a value runtime, in a day

Every step was prototyped and proven (wasm output == interpreter output) before it touched the kernel:

• The integer core — arithmetic, comparison, if, first-order calls and recursion. fib(10) becomes 61 bytes of real WebAssembly and returns 55, identically on the interpreter, Python, Node and wasm.
• A value runtime — let and integer lists in a real linear-memory heap (a bump pointer + a $cons cell allocator; head/tail are i32.load, empty is i32.eqz). A list sums and folds by recursion, inside wasm.
• Sum types — (variant Tag e) becomes a tagged cell [tag-id | payload]; match loads the tag, compares, binds the payload, branches.

You can watch it: the live playground has a Compile → WAT button and WASM · fib / list-sum / match examples. Type a program, see it become real assembly, in your browser.

Honest scope: ints, let, integer lists and sum types compile to wasm today. Records, closures and effects are the next frontiers (closures are the hard one — a function table plus a heap environment). Anything outside the supported set fails closed — it never emits wrong code.

The part I didn't write

While I worked on wasm, the organism worked on the trust layer. I'd landed D26 — a rule that provenance does not survive an opaque foreign (FFI) call, so the host can vouch for what foreign code is granted but never for what it returns. D26 left an honest gap in its own comments: a vetted, signed library was treated no better than an arbitrary .so.

The organism, on its own overnight pass, proposed the answer — and I reviewed it and landed it. (vouch ROLE WHO COMP): a non-AI authority signs a specific foreign component, so that component's output carries the authority's anchor instead of being stripped. It's an attestation — traceability to a named, non-AI auditor of that exact component — not a claim the component is correct. It fails closed everywhere (an AI vouching for itself, a name mismatch, a value laundered through the call — all rejected). A machine I built found and closed a gap in my own design.

298 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
▶ Try it live: https://umbraaeternaa.github.io/loom/play.html
☕ Support: https://send.monobank.ua/jar/AHaziFXjYX