30 Functions. Two Languages. Zero Divergences.

30 functions. Two languages. 50,000 test runs. Bit-for-bit comparison. Zero divergences. Not one.

The Translation Problem

Here is a question every engineering team should be asking: when you transpile code from one language to another, how do you know the output is truly equivalent to the input? Today, you test it. You run the same inputs through both versions and compare. But how many inputs is enough? A hundred? A thousand? Ten thousand? What about the one input you did not test — the one that triggers a rounding difference between JavaScript's IEEE 754 doubles and Python's arbitrary-precision integers? That one input is the one that will cost you.

BRIK64 takes a fundamentally different approach. Instead of testing equivalence, it proves it. The PCD blueprint is the canonical representation. When compiled to JavaScript and Python, both outputs are derived from the same mathematical specification. The question is not "do they happen to agree?" but "must they agree?"

The Shootout

We put this to the test. We compiled 30 PCD programs — ranging from trivial arithmetic all the way to deeply nested compositions with conditional branching and complex control flow — to both JavaScript and Python. Each program was executed with canonical test inputs derived from the closure domains: boundary values, zero, midpoint, random samples. Every single output was compared against the canonical interpreter — our reference implementation that evaluates PCD directly, without compilation, as the mathematical oracle.

The result: 30 out of 30 functions verified equivalent. Zero divergences. Across over 50,000 cumulative test runs. Not a single bit out of place. JavaScript and Python, producing identical results, because they were generated from the same mathematical truth.

How It Works

The differential testing framework does something beautifully simple: it generates random but well-formed PCD programs, compiles them to multiple targets simultaneously, executes every target with identical inputs, and compares outputs bit-for-bit. The canonical interpreter serves as the oracle — the single source of mathematical truth. If any compiled target disagrees with the interpreter by even one bit, that target has a bug. No ambiguity. No debate.

The full technical framework — the program generator, the canonical interpreter, how we scale to 10,000+ programs, and how it integrates into CI pipelines — is documented on Digital Circuitality:

Read the differential semantics framework →

# Run it yourself
git clone https://github.com/brik64/brik64-demos.git
cd brik64-demos
./run_demo.sh demo2-translation-validation

Same input. Same output. Every language. Every time. That is not aspirational. That is not "in most cases." That is what "equivalent" actually means — and BRIK64 is the only system that delivers it.