Floor 3 · 3 exhibits
The Machine Room
Real code, turned into the tiny steps a machine actually runs — and proven honest.
Compilation, bytecode & VMs, registers & spilling, hashing & tamper-evidence.
The Gate
One program, an interpreter and a compiled VM — proven byte-identical, live.
Type any sum. Two completely different machines compute it — and either they agree to the very last bit, or this demo says so, live.
How deep would you like to go?
show me · the plain-English storyThe same expression runs two genuinely different ways: a tree-walking interpreter that reads the parsed sum directly, and a compiler that turns it into bytecode for a tiny stack-based virtual machine. Their answers are compared bit-for-bit — that's the real proof technique compilers use to trust a faster, optimised path.
Wow — The check isn't a rounded “close enough” — it compares the literal IEEE-754 bit pattern of both answers, digit for digit. That's the same proof technique that lets a compiler trust an optimised path against a slow, trusted one.
Try this — Type your own expression, then tick “Deliberately break the compiled path” — watch the green tick turn into an honest, live red mismatch, instead of the demo hiding it.
What's really happening · A small, real interpreter and a small, real bytecode compiler + stack VM, both written from scratch here — not a metaphor for QUANTA's own compiler-verification gate, but the same shape of proof at browser scale: an optimised path only counts once it's shown, mechanically, to agree with a trusted reference. “Byte-identical” below is a literal IEEE-754 bit comparison, not a loose equality check.
Read the full lab reportRegister Allocation, Live
Real liveness → interference graph → graph-colouring → real spills.
A real program has more numbers to juggle than a machine has hands to hold them. Watch a compiler decide, live, who shares a hand — and who gets set down.
How deep would you like to go?
show me · the plain-English storyEvery variable is alive for a stretch of code; two variables alive at the same time can't share a register. The demo builds that “alive-together” graph for real, then tries to colour it with only K registers — drag K down and watch it genuinely run out.
Wow — Drag the register count down and the very same program can be forced into real spills — this isn't scripted: it's a genuine Chaitin-style graph colouring running out of colours, live, on your program.
Try this — Load a preset, then drag “Registers available (K)” down one at a time and watch the “Spilled” count rise exactly where the interference graph can no longer be coloured.
What's really happening · A from-scratch reimplementation of the textbook register-allocation pipeline (Chaitin, 1981): straight-line code only, no branches or loops in the control-flow graph — the same live-in/live-out equations extend to a full CFG, just not shown here. This is what a real compiler backend automates; the paired report is where every register (AX, BX, CX, DX…) was instead assigned entirely by hand, with no compiler in the loop at all.
Read the full lab reportThe Tamper-Evident Ledger
From-scratch SHA-256, real proof-of-work, cascading tamper detection.
Change one letter in one block. Watch the whole chain from that point notice — live, and honestly.
How deep would you like to go?
show me · the plain-English storyA real SHA-256 hash turns each block's data into a fixed fingerprint; each block also stores the previous block's fingerprint, chaining them together. Edit any block and watch its fingerprint — and the next block's stored copy of it — stop matching, live.
Wow — It's a real, from-scratch SHA-256 — the exact same hash function verified byte-for-byte against Node's own crypto library while it was built, not a lookup table pretending to hash.
Try this — Edit a block's data by one character, watch its hash and its neighbour's link both turn red, then click “Re-mine from the first break” and read the real attempt count and milliseconds it actually took.
What's really happening · A real, from-scratch SHA-256 (FIPS 180-4, verified byte-for-byte against Node's crypto during development) chains real blocks by real content hashes. This is not a reimplementation of NovaChain's own consensus — that chain is a Cosmos-SDK / Tendermint-style fork (proof-of-stake, not proof-of-work); the small proof-of-work search here exists only to make the real cost of “finding a valid hash” visible and clickable, illustrating the tamper-evident property that report's honest evaluation names, not its actual mechanism.
Read the full lab report