The Demo · AI you can prove
Native x86-64 and a typed interpreter. Same program. They agree — or we show you exactly where they don't.
The transcripts below are a recorded run — real, captured from our own repo, the exact command shown and the raw output one click away, unedited. And now the live playground is here: edit a program yourself and watch the two runtimes agree, in your own browser.
Recorded run · press ▶ Replay to watch it again
Two independent runtimes. One certificate.
Every QUANTA program compiles to native x86-64 AND runs in a typed tree-walking interpreter. On every single compile — never disabled — the two are compared, value for value. This is that comparison, captured live from the repo, not simulated for the web.
chapters/L0/algos/algos.q — six classic algorithms, hand-written in QUANTA
fn powmod(b, e, m) {
let result = 1; let base = b; let exp = e;
while (exp > 0) {
if ((exp & 1) == 1) { result = (result * base) % m; }
base = (base * base) % m; exp = exp >> 1;
}
return result;
}
// ...plus ackermann, collatz_steps, hanoi_moves, binomial, euclid
// main() runs 20 assert()s, then returns their checksum (113).$ ./qc2 --check chapters/L0/algos/algos.q
NATIVE x86-64 ▸ executing…
TYPED INTERPRETER ▸ executing…
Now try it yourself · live, in this tab
Don't take the recording's word for it — run the gate yourself.
Edit the program below and watch it execute two independent ways at once — a tree-walking interpreter and a compiled bytecode VM — proven identical value-for-value, live. Break it on purpose and the gate surfaces the mismatch. Nothing is sent to us; this is your machine, not a recording of ours.
When they don't match — the most convincing screen we own
A real 32-bit wraparound, caught, not covered up.
QUANTA has no 32-bit type — every integer is a uniform 64-bit value. Real C unsigned int arithmetic wraps at 2³²; QUANTA’s doesn’t. So when we converted a genuine wraparound function, the converter didn’t quietly call it equivalent — the gate refused, and said exactly why.
$ ./c2q wrap_test.c # a real 32-bit-unsigned-wraparound function
QUANTA (native ≡ interp — the sacred gate still holds)
ORIGINAL C ▸ gcc -O2, run for real
Note what held and what didn’t: native ≡ interpreter still passed — the sacred gate is about QUANTA agreeing with itself, and it never lies. What failed was gate 3, the behavioural check against the original C — exactly the case it exists to catch. This is why the corpus holds 1,026 certified functions and not one more — on unfiltered real-world C the converter currently certifies about 1 function in 20 and honestly refuses the rest. The refusals are the proof that what it does certify is real.
What’s next