Five workloads written for the contract, computed in this tab

Each panel below is a faithful port of one C tool in host/tools/ - its --engine loop path, and for zoom and orbits its --engine program path too, the same operation sequence, the same rounding attributes, the same flag handling - running on the same wasm module the conformance page embeds. Every tool records a SHA-256 chain over its results. Each panel computes the same records and the same chain, and prints it beside the chain the native tool produced, so the claim this page makes is checkable in one glance: the browser computes the same bits as the C tool.

These are measurements of a slow software tier, not a performance claim - the same sentence docs/BENCHMARKS.md makes about every number in it.

The module that loaded

loading the wasm module…
No panel has run yet.

1 · zoom — a deep-zoom reference orbit

A perturbation renderer needs one reference orbit computed to the depth of the view. At a pixel of about 10-61 a binary64 reference is not merely inaccurate, it is somewhere else entirely - and it raises no flag saying so. The fp256 reference is bit-identical on every host, so the frame is too. Port of cft-zoom, both engines: the reference orbit's eight opcodes an iteration at fp256 - as a host cft_run loop or as one sequencer program - and the perturbed pixels' twenty-three at fp64, which are cft_run either way.

fp256 reference, fp64 perturbed pixels

 

the frame an fp64 reference produces

 

2 · orbits — a Kepler ensemble and its invariants

A symplectic integrator's energy drift is a property of the method and is the same at every format. Its angular-momentum drift is a property of the arithmetic, and is where the formats separate: the same ensemble, the same step, the same code - and roundoff two hundred binary orders apart. Port of cft-orbits, Kepler at eccentricity 3/4, Stormer-Verlet. The first pair takes 1/r³ from cft_sqrt and cft_div, correctly rounded; the second takes it from the tile's own rsqrt seed and a derived number of Newton passes, which is the route a sequencer program can hold.

the ellipse, both ensembles

fp256 members   fp64 members

drift, |H−H₀| and |L−L₀| (log)

fp256   fp64   solid = energy (the method)   dashed = angular momentum (the arithmetic)

the ensemble separating: |qₖ − q₀| per member (log)

fp256 members   their fp64 twins — the same one-ulp ladder, the same steps, and roughly 2184 between the two clouds. Computed IN THE FORMAT: at fp256 the members differ by about 10-70, which subtracting their binary64 shadows would report as zero.

3 · Collatz — exact integers, and the edge of exactness

Every integer below 2p is exact in a binary format, and the inexact flag is the certificate: the tool commits a step only when 3n+1 was computed exactly, and the library's flag and the tool's per-element witness must agree on every call or the run stops. At fp256 that ceiling is 2237, so a seventy-two-digit starting value is ordinary arithmetic. Port of cft-collatz --engine loop, twenty-three elementwise opcodes per step.

the trajectory (log₂ of the value)

trajectory   the 2p exactness edge   where exactness ended

stopping times over the sweep

one dot per starting value: total stopping time against n

4 · enclose — the interval ladder, at every format

Two directed roundings per instruction turn a computation into a proof: evaluate the lower end under roundTowardNegative and the upper under roundTowardPositive and the true value is inside, whatever the conditioning. The dot ladder below is a sum whose exact value is one and whose terms cancel over an exponent spread that grows down the rungs. Watch the fp64 bars cross zero while the fp256 enclosure stays a point. Port of cft-enclose --engine loop, all three kernels, one run per format.

enclosure width of the dot ladder (log scale)

fp32   fp64   fp128   fp256   × marks an enclosure that straddles zero

the ill-conditioned dot product

5 · Mersenne — Lucas-Lehmer on an exact multiplier

fp256 holds every integer below 2237 exactly, so a wide integer becomes an array of limbs and its square becomes a convolution of dot reductions - and the reductions' clean flag word is the certificate that not one product rounded. The limb width is derived from the format's own p, never tabulated. Port of cft-mersenne --engine loop, the carry split as fifteen cft_run passes.