Demos
Most software is described in a pitch. These run. Each one computes real work live in your browser and brings its own proof you can check: the integer path comes out identical to the last bit on your CPU and your GPU alike (prove it yourself below), and every demo states exactly what it shows. Nothing is pre-recorded. Open one and reach in.
The language, running live
Coherence Language is the company's own programming language. Here it compiles, in your browser, to the GPU, to JavaScript, to WebAssembly, and even to itself, and proves the results match.
Check Our Homework
Our own traffic and security numbers, committed to an append-only signed log. This page rebuilds that log's Merkle root in your browser and looks our signing key up in public DNS rather than reading it from our files, then hands you buttons to inflate the numbers, delete an epoch, and re-sign with a forged key so you can watch the verification fail.
The Babel Engine
One function in Coherence Language, compiled to a GPU shader, JavaScript, and WebAssembly at once, then measured live as they agree: to double precision on the CPU and to the single-precision floor on the GPU. Drag a slider and watch.
Self-Hosting Compiler
Edit a .cl equation. A compiler written in Coherence Language, running as WebAssembly, recompiles a million-cell field to a GPU shader live, right in your browser.
Program Your Webcam
Write a per-pixel image kernel in .cl. It compiles to a WebGPU shader in your browser and runs on your camera, with a live receipt that your CPU and GPU computed the same thing.
Float, Made Exact
The problem, and the way out that keeps float. Add the same numbers in a different order and floating point hands you a different answer. Everyone knows the cure: compensated summation, Kahan's algorithm, taught in every numerical methods course. Watch it fail. On your machine, in two hundred random orders per case, Kahan gives more than one answer on five cases out of six and never once lands on the correct value in all of them; pairwise summation, which is what numpy.sum and most BLAS actually do, does no better. Neumaier's improved variant holds one answer everywhere and then misses the correct one on the case with no adversarial structure at all. Exact accumulation: zero and zero. Then hunt for a counterexample yourself, and watch your browser reproduce the Python reference bit for bit. Honest about where it stops: transcendentals and GPU float reductions stay fail-closed.
CPU = GPU, to the Last Bit
Way out two: leave float behind. The same physical field computed in exact integer math on your CPU and your GPU at once, and the two results are bit-for-bit identical: same pixels, same SHA-256, zero difference (0 ULP). Flip one bit and the proof catches it. This is the route a computation takes when it needs a function no accumulation trick can fix, like a logarithm.
Verify it yourself, from the measure up
Start by computing coherence energy itself, the number the company is named for, live in your browser. Then the lab builds a coherence-native model whose every decision you can verify yourself, in your browser, three ways: re-run it bit for bit, check a zero-knowledge proof that hides the input, or audit its signature. The same trust layer wraps a commodity model too, so any decision becomes reproducible, private, and auditable. No server, and nothing you have to take on trust.
A Figure You Can Re-Run
Every chart you have ever read asked you to trust it: a picture is a claim that some data, put through some computation, came out looking like this, and you are almost never given either one. This one ships as a program, its input, and a receipt. Your browser parses the program with our compiler, re-derives all 381 plotted values in exact integer arithmetic, and checks them against a receipt minted by a completely separate implementation. Move one input by a single unit, or change one digit of the program, and watch the receipt refuse it. No GPU and no network: save the page and it keeps verifying offline, forever.
Command a Swarm
A drone swarm that coordinates with zero communication: every body computes the identical mission plan in exact integer arithmetic, so they agree bit-for-bit. Flip it to floating point and the formation shatters; spoof up to 49% of the fleet and every liar is caught to the last unit; shoot drones down and the survivors re-plan with no negotiation. Then seal a signed mission certificate you re-run in your browser to catch any tamper. The real decision engine, ported to run live.
Measure Coherence Energy
The number the company is named for, computed live in your browser: the real coherence-energy functional (a per-world information distance priced in energy), and its exact reduction to the Landauer bound for a definite decision. Move the sliders and check it against the reference yourself.
The Prover Advantage
Coherence's fixed-point-native proof gate needs about half the constraints of a generic field prover for the same computation, because operand bounds are a compile-time language invariant, not an in-circuit range check. Compute the exact head-to-head yourself and watch the ~1.94x, with the saving shown to be load-bearing for soundness, not a corner cut.
Prove It Three Ways
Our 96.8% CIFAR-10 coherence model decides on an image, and you prove that decision three ways live in your browser: re-run it bit for bit, verify a zero-knowledge proof that hides the features, and check an Ed25519-signed credential. Accurate and provable, on a real model.
Re-run the Whole Model
Most verifiable AI re-runs a tiny last step and fingerprints the rest. Here your browser re-runs the entire image model, every convolution, in deterministic integer arithmetic and lands on the lab's exact decision bit for bit, then checks an Ed25519 credential that signs the whole model. No fingerprinted extractor, no trusted black box.
Live on your GPU
Fields you program in Coherence Language, evolving live on your GPU, plus a coherence-routing idea you can see for yourself. All compiled in the browser, nothing pre-recorded.
The Coherence Field
A field you program in Coherence Language, evolving as a live simulation and computed bit-exact on your CPU.
The Coherence Forge
A 1,048,576-cell field evolving in real time on your GPU, sculpted with your mouse, programmed in .cl.
Coherence Volume
A 3D field you program in .cl, raymarched live on your GPU.
Coherence Routing
A path that follows coherence: cost-shaping rather than shortest-line routing, like a flight that rides the winds instead of the straight line.
Next