Demonstrations.
Every cargo class, verified in this tab.

A sealed interactive session re-derives every state from kilobytes of signed ops — and converges to the same hash on every machine.

An interactive world MODEL, integer all the way down: drive it with the arrow keys, every generated frame hash-verified, every keystroke a signed action op whose trace replays to one portable session hash. A generated world you can put in a receipt.

A film is a sealed camera-on-rails world. The tab reads the world at each frame, projects it through the camera, and re-derives every frame's hash.

A moving Gaussian cloud carried as per-Gaussian keyframed tracks — interpolated and re-hashed frame by frame, in the fixed-point floor.

A digital human as a skeletal pose stream — bone transforms replay to the identical hash and skin a glTF mesh by the deterministic pose.

A ~1.4 KB bitstream from a post-training-quantized learned codec, decoded entirely in pure-i64 wasm — no float, no ML runtime — then hash-verified byte-for-byte against the native reference.

The ISO/IEC 6048 JPEG-AI mANS entropy decode — a published international standard's bitstream — run with the same pure-i64 wasm a native sink runs, its decoded symbols hash-verified byte-for-byte against the native reference.

An integer inter-frame clip — integer motion compensation + quantized residual — decoded and played in-tab, every frame re-checked against the native reference hash. The keyframe can be the learned int_hyper codec.

A learned 1-D audio codec — integer transposed-conv synthesis + integer IGDN over a factorized-rANS latent — decoded to int16 PCM in pure-i64 wasm, hash-verified against the native reference, then played. The audio sibling of int_hyper.

A learned Gaussian-splat codec — integer synthesis over a factorized-rANS latent — decoded to the [14,S,S] attribute tensor in pure-i64 wasm, hash-verified against the native reference, then rasterized. The int_hyper of 3D; WAI pins the attributes, not the pixels.

A prompt and seed generate an image in pure integer arithmetic — no float, no ML runtime — so the same inputs produce the same bytes on every machine. There is no original, yet the hash is portable and verifiable.

A working course in quantum algorithmic design — taught as a way of thinking about problems, on the classical hardware you already have. Seven modules, each running its idea live in the browser: interference as the one irreducible resource a thermodynamic sampler cannot use, the phasor unification that collapses quantum kernels, Born machines and holographic representations into a single algebra, the deployable phasor classifier, the honest limits (barren plateaus, dequantization), the surviving exponential moat of learning from quantum data, and a signed energy receipt for every operation. Change the inputs and watch the math answer. No QPU, no cloud, no account.

A few hundred bytes of gate op-log, classically simulated in pure-i64 wasm — the reconstructed 2ⁿ-amplitude statevector hash-verified byte-for-byte against the native reference. The QFT presets are the quantum Fourier transform, carried as a circuit. No quantum hardware, no speedup — a quantum computation you can put in a receipt.

Automated calibration primitives — Rabi tune-up, Ramsey/T2, RB, readout, silicon-spin charge-stability, two-qubit cross-resonance, crosstalk, DRAG, and robust optimal control — plus a signed calibration campaign — as deterministic Rust in pure-i64 wasm. Each autonomously recovers a hidden device parameter from a blind sweep (hit 'new device' and watch it find any value), byte-exactly, and seals a signed wai.quantum.calibration receipt. Deterministic and attested. Simulated device, no cryostat.

The classical layer between raw QPU counts and the reported number — zero-noise extrapolation, tensored readout inversion (M3), and classical shadows — as deterministic pure-i64 wasm. Each recovers a hidden ideal expectation from a simulated noisy front-end, byte-exactly, and seals a signed, joule-metered wai.quantum.mitigate receipt binding (raw data, noise-model hash, method, seed) → (mitigated estimate ± error). The one layer the float mitigation stacks leave unsigned. Simulated front-end, no QPU.

A deterministic fixed-point Relay-BP (normalized min-sum) decoder for quantum LDPC codes — the toric code and the [[72,12]] bivariate-bicycle 'gross' code — as pure-i64 wasm. Plain belief propagation fails on quantum codes (degeneracy + short cycles); relay legs with disordered per-node memory break the symmetry, and the Monte-Carlo panel shows Relay-BP's logical error rate below plain BP's across the range. Each decode is byte-identical on every machine and seals a signed, joule-metered wai.quantum.decode receipt carrying joules-per-decode — the metric no decoder reports and none signs. Simulated syndromes, no QPU.

Frequency-domain robust control for correlated / 1-f dephasing, as deterministic pure-i64 DSP. Noise spectroscopy reconstructs a hidden noise PSD from a dynamical-decoupling filter bank (Richardson–Lucy); filter-function robust control reshapes a DD sequence to push its filter's stopband over that noise, turning a large coherence loss into a large gain. Both run entirely offline against a model, byte-identical on every machine, each sealing a signed wai.quantum.calibration receipt — the robust one binds the exact PSD hash it is hardened against. Simulated device, no cryostat.

Cycle Benchmarking + Cycle Error Reconstruction of a sparse Pauli–Lindblad noise model, as deterministic pure-i64 Rust. Recovers a hidden device's Pauli error rates from a simulated twirled-cycle experiment (positivity-preserving multiplicative solve), seals the signed model, and closes the loop: a probabilistic-error-cancellation of a Pauli observable binds that exact model by its hash — the producer for wai.quantum.mitigate's noise_model_hash hook. Simulated cycle, no QPU.

A deterministic Clifford circuit router plus a byte-exact stabilizer-tableau equivalence check. Routes a circuit onto a hardware coupling graph (inserting SWAPs so every two-qubit gate is local), proves the routed circuit is equivalent to the source, and seals a signed wai.quantum.compile receipt binding (source hash, compiled hash, coupling hash) → equivalent — then the same check rejects a tampered circuit. Compilation correctness, which no compiler signs; exact for Clifford circuits. Simulated, no QPU.

A full quantum development environment that runs entirely in the browser — no cloud, no account, no Python, no vendor SDK. Build or load a circuit (Bell, GHZ, QFT, Grover, Bernstein–Vazirani, teleportation, …), run it on the byte-exact classical simulator, and inspect amplitudes, interference, per-qubit entanglement, measurement statistics, and the recommended backend (Clifford → statevector → tensor-network). Import/export OpenQASM; every run reproducible to the bit and sealed into a signed receipt.

A deterministic Hungarian / linear-sum-assignment solver for neutral-atom register preparation. Loads a stochastic ~half-full trap array and plans the minimum-total-distance moves that turn it into a defect-free target register — every target site assigned a distinct atom — sealing a signed wai.quantum.rearrange receipt whose success verdict is re-checkable, and rejecting a tampered plan. Solver optimality is exact (tested vs brute force); a geometric model, transport physics out of scope.

A Quantum Bill of Materials: the stage receipts of one computation — a routed+proven circuit, a calibration, a defect-free atom register, an error mitigation, a decode — assembled into a single signed, content-addressed provenance manifest with a total-energy roll-up and an operator-envelope export. Every listed stage binds a receipt that itself verifies, so a swapped or forged stage breaks the bill. The synthesis of the quantum-ops receipt family; the audit sidecar an operations stack doesn't sign.

Object-based audio: sound objects + a scene, mixed to a bit-exact PCM for a declared layout in the deterministic floor.

Music as note events — a trig-free synth in the Fx floor renders the canonical mixdown; a soundfont is the sink's presentation.

Touch as a keyframed intensity/sharpness envelope, reconstructed to actuator samples that hash identically on every sink.

Scoreboards, telemetry, market tape as signed state — converges to one hash regardless of arrival order. Ship state, not pixels.

Two isolated tabs sign skeletal ops over the relay and converge on the identical pose hash — a live world of avatars.

Two tabs co-drive one generative world; each keystroke is a signed action op, both replay the merged log and converge on the identical byte-exact world + session hash. Multiplayer convergence for a generated world.

End-to-end encrypted over the real relay: an MLS group derives a shared SFrame key, object payloads are sealed so the relay forwards + signs a moq-jwp receipt over only ciphertext. A member decrypts; a non-member can't. MLS + SFrame per draft-jennings-moq-e2ee-mls.

One envelope carrying several cargo classes — a cut film and its embedded soundtrack — every part re-derived and checked, played in sync.

A signed, energy-accounted lineage for opaque captured content — content-addressed, Ed25519-sealed, with measured joules per step.

The verify half applied to the quantum-control industry: seal a signed, content-addressed, joule-metered, grant-authorized receipt of a calibration run or a QPU job — then watch it enforce itself in-tab. Tamper a field and verify fails; blow the joule budget and verify fails; a job binds the exact calibration state it ran under. WAI owns the receipt; the control system runs the hardware.

The verify half applied to streaming delivery: a per-session manifest rendered as a pure function of the session class — ads spliced at real EXT-X-DISCONTINUITY, blackouts and geo applied — and sealed in a receipt binding the grant, the composition and the policy. Substitute a creative and the receipt breaks; drop the grant's funds ceiling below the billable spend and it refuses to verify; and because the manifest depends on the class rather than the viewer, one generation serves the whole class, so the per-viewer energy amortises in front of you.