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.
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.
fib
to a value runtime, in a day Every step was prototyped and proven (wasm output == interpreter output) before it touched the kernel:
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.let
and integer $cons
cell allocator; head
/tail
are i32.load
, empty
is i32.eqz
). A list sums and folds by recursion, inside wasm.(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.
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](https://github.com/umbraaeternaa/loom)
▶ Try it live: [https://umbraaeternaa.github.io/loom/play.html](https://umbraaeternaa.github.io/loom/play.html)
☕ Support: [https://send.monobank.ua/jar/AHaziFXjYX](https://send.monobank.ua/jar/AHaziFXjYX)