Skip to main content

WAI Extension: Determinism Tiers for Neural Decode

Mirrored from the canonical text at commit 498e6b88 ().

Status: Draft. Names the spectrum of reproducibility guarantees a neural capability can make, so a manifest can declare which one it satisfies and a verifier knows what it may check. Defines two tiers — entropy-consistency (the entropy decode reproduces) and decode-equivalence (the whole decode to the final medium reproduces) — and states which one intent = replicate over a neural capability promises, what a receipt can hash under each, which WAI capabilities are registered at each and at what cost, what the repository demonstrates today, and what exactness was measured to cost and what WAI claims from that measurement (§7). One optional manifest member carries a tier name: a pin’s tier (SPEC.md §3.1). Otherwise a vocabulary and conformance framing over §7. Keywords MUST, MUST NOT, SHOULD, MAY are RFC 2119/8174.

1. Why tiers

Neural decode reproducibility is not binary. A neural decode evaluated in float through an inference runtime does not, in general, reproduce its reconstruction across hardware. Each IEEE-754 basic operation (add, subtract, multiply, divide, square root) is correctly rounded, so it gives the same result for the same operands everywhere; the differences come from what a runtime may choose per device — kernels and accumulation order, vector width, fused multiply-add, reduced precision, math-library functions — and from the process’s floating-point environment. A decoder that also derives its entropy parameters in float can, from one diverging bit, select a different distribution from the encoder’s and corrupt the entropy decode. A float stage whose operations, order, precision and environment are all fixed does reproduce, within the implementation that fixes them; §5 describes one, and §2–§3 say why that is not a tier and does not back replicate. Five published routes to reproducibility are below. Two make the entropy stage reproducible while leaving the reconstruction to pixels to the implementation, within whatever criterion a conformance specification sets on it:

The other three make the reconstruction itself reproducible, each by decoding in integer arithmetic:

One more published line reaches neither tier: float synchronised on a tested hardware class. A streamable learned video codec (arXiv 2608.00483) decodes its P-frames in 16-bit float, and its I-frames and its periodic resets of a feature adapter in 32-bit float (§II-C, §II-D). It was tested on twelve GPUs of one vendor under one driver (Table II). In the mixed mode, a stream decoded only on GPUs of the generation that encoded it, and at 1080p not on every one of them; in pure 32-bit float, streams decoded across generations at 1080p and split into three groups at 4K (Table IV). A stream decoded outside its group fell from 26.3 dB to between 11.9 and 13.7 dB of luma PSNR at 1080p, and from 28.2 dB to between 7.3 and 10.6 dB at 4K, or the decoder did not complete (§II-F-3, Table IV). The authors give the cause SPEC §7 gives (Replicate-soundness): pure 32-bit float “is strictly non-deterministic, with each GPU architecture generating a unique bitstream”, because kernels “whose differing reduction orders break bit-exactness even under IEEE-754 FP32, which fixes per-operation rounding but not operation ordering” were chosen per generation (§III-B). Exactness found on the devices tested is a property of those devices and not of a capability (§2), and the frames between two resets have no portable hash, so this line is no tier of this document (§3, No tier between the two).

WAI names the two outcomes as tiers, so a capability states which one it makes, an envelope’s intent can demand the one it needs (replicate over a neural capability demands decode-equivalence, §3), and a receipt or a provenance binding (reconstruction-binding) can do the same.

2. The tiers

entropy-consistency

The entropy decode reproduces byte-for-byte across devices — the decoded symbols (the entropy-decoder output) have a portable hash — but the reconstruction to the final medium (pixels, samples) MAY differ between conforming sinks. A sink achieves this either by integer entropy arithmetic (deriving the coding parameters with fixed-point ops, as WAI’s integer decoders and JPEG AI’s entropy pipeline do) or by explicit parameter transmission (the codestream carries the parameters, so no bit-exact derivation is required).

Why transmitting parameters stops at this tier. A learned entropy decode desyncs when the decoder derives an entropy parameter (a scale, and from it the distribution the next symbol is decoded with) that selects a different distribution from the one the encoder used. Transmitting the parameter removes that derivation from the decoder: every decoder reads the same value and decodes the same symbols, whatever arithmetic its networks run in. Nothing after the entropy decoder is constrained. The steps that turn symbols into a latent and the synthesis transform still run in the arithmetic the device provides — float, reduced precision, fused or reordered accumulation — and, unless the implementation fixes that arithmetic, their results differ by device. A codestream can pin values; it cannot pin the arithmetic a network is evaluated in, and the reconstruction depends on that arithmetic. So a portable hash of the reconstruction needs every stage after the entropy decode fixed as well, which is the next tier. The two routes compose: a capability MAY transmit parameters and pin its arithmetic.

decode-equivalence

The whole decode to the final medium reproduces byte-for-byte on every conforming sink — the reconstructed pixels (or samples, or attributes) have a portable hash. The capability’s registration pins one reconstruction and specifies it in integer / fixed-point arithmetic end to end, entropy and synthesis, so the output depends on nothing a build, a device or a process chooses. Where the base codec admits several conformant reconstructions, this tier fixes one. This is what intent = replicate over a neural capability promises (§3).

A tier is a property of the capability as registered, not of one implementation. An implementation that pins a reconstruction by evaluating float stages in a fixed order (§5 describes one) reproduces it only under conditions of its own build and process (§3). That is a property of the implementation, stated as such; it does not place the capability at this tier.

A capability satisfying decode-equivalence satisfies entropy-consistency by construction; the reverse does not hold.

What a tier covers

A tier is a property of the whole path from codestream to the medium that is hashed, bound, or presented — not of the decode stage in isolation. A sink that decodes conformantly and then alters the result has not satisfied the tier, however faithful the decode itself was. Processing that changes the medium after a conformant decode, or alongside it, can arrive through the same pipe as the codestream, and a payload can arrive already altered.

The rules:

The general rule, which is why this section exists: a determinism claim covers what the sink emits. A hash over a decode that something later modified describes an artifact nobody saw — the hash verifies, and it attests the wrong thing.

Processing that alters the medium (informative). Published and draft standards define mechanisms that change the medium after, or alongside, a conformant decode, and they arrive through the same pipe as the codestream:

Other 23001-11 mechanisms leave the decode as it is. Three of them change the payload before it arrives:

In each case the sink decodes what it receives like any other bitstream, but the payload is not the one that would have been sent otherwise. The remaining two alter neither a payload nor a decode’s output. Media-selection metadata lets an adaptive-streaming client choose among the available representations by their decoder- and display-power characteristics; what it receives is one of those representations as published. Complexity metrics let a decoder vary its operating frequency, which changes what a decode costs, not what it outputs.

All of this is metadata for saving power, stated in advance; none of it reports energy that was spent. Its energy quantities are expectations: an attenuation map’s expected energy saving rate, and the rates a receiver asks for and a transmitter says the receiver can expect, each a percentage (clause 7.4); a representation’s decoder-operation reduction ratios and its maximum potential display power saving (clause 8). Complexity metrics are proportions of decoding operations over a period (clause 6.2), and a DOR-Resp acknowledges what the encoder changed. So a sink that acts on this metadata has a prescription, not a measurement, and a tier claim or receipt over its output is bound by the rules above like any other.

This section accounts for every metadata set that the Introduction of the 4th-edition CD text (WG 3 N1864, dated 2026-08-28) names. Read in that text: the Introduction, and in part clauses 6, 7, 8 and 9 and Annex B.2, B.4, B.5 and B.6. The published edition was not read.

Pinned integer derivations in this revision. wai-synthesis:upscale2 and wai-synthesis:denoise3 (synthesis §4), and the super-resolution derivations of exact-upscale §3 under a prior the sink holds by its SHA-256, are such derivations: a sink that emits their output states the derivation, and its prior, with it (synthesis §9.2, exact-upscale §6).

HDR display adaptation is such processing: a sink makes, from the decoded picture, a gain map or dynamic metadata and its display’s headroom, the rendition it presents, and the standards that define it state the computation in real numbers, so the presented pixels differ from sink to sink. The derivations of exact-tonemap §4 and §5 pin it in integer arithmetic: a rendition is a pure function of the decoded samples, the companion’s bytes and the headroom, so a sink that presents one holds the tier of the decode it ran on, and states the headroom and the rendition’s digest in its rendition record (exact-tonemap §7).

3. Declaring and using a tier

Profiles and the reference implementation (informative).

4. Framing

Both tiers here are reproducibility guarantees: a sink can check them from the bytes it received. A separate axis exists for media whose correctness is a downstream model’s behaviour rather than a byte comparison — see task-fidelity, which is a sibling rather than a third tier precisely because such a claim is not sink-checkable from the bytes.

The two tiers are named so that each capability states which one it makes. entropy-consistency is the tier at which JPEG AI sets its bit-exact conformance point, and the tier WAI registers wai.image.jpegai at. decode-equivalence pins one full reconstruction, so the rendered result, not only the entropy stream, is reproducible and hashable; it is what replicate over a neural capability promises. §5 lists the WAI capabilities at each tier, with what the tier costs them.

5. Where WAI offers each tier, and what it costs

decode-equivalence

capabilityhashable mediumhow the reconstruction is pinned
wai.neural.int_synthRGBinteger synthesis (post-training quantisation of a float model, with per-layer shifts calibrated on measured activations; of the committed vectors only photo is such a model, and gradient, bloom, facade and the cross-architecture golden of §6 use seeded integer weights)
wai.neural.int_hyperRGBinteger hyper-decoder, integer scale → distribution step, integer synthesis (post-training quantisation of a float model)
wai.video.int_hyperper-framean int_hyper keyframe, then integer motion-compensated P-frames
wai.audio.int_codecint16 PCMinteger synthesis over a factorized rANS latent
wai.splat.int_codecattribute tensorinteger synthesis over a factorized rANS latent
wai.neural.int_mlicppRGBinteger hyper-decoder; an integer entropy network re-run before each of the 2·K channel-slice × checkerboard passes, integer scale → distribution step; integer synthesis. Stream values an exact decode cannot hold are refused, not wrapped
wai.video.int_condper-frameconditional inter-frame coding over the previous frame’s decoded feature: an integer context network, an integer scale → distribution step, an integer conditional decoder and synthesis (integer-payloads §17); the reference vector’s networks trained, then quantised after training

| wai.audio.opus.dred.int | the feature sequence (i32 at 2^16) | the draft’s DRED feature decoder as the wai-ops/1 graphs of dred-int/1, over the draft’s own weights file pinned by SHA-256: weights quantized from their float32 bits, integer activations, tanh and the sigmoid as integer tables (opus-dred §4). The vocoder that renders the features is the sink’s and outside the claim |

These eight, with the frame forms of wai.video.int_hyper and wai.video.int_cond, are integer throughout, are the capabilities the registry classifies as NeuralIntegerExact, and are the neural capabilities that back replicate.

entropy-consistency: wai.image.jpegai, and its exact decoder’s pinned reconstruction

The registry classifies wai.image.jpegai as NeuralEntropyExact and registers it at entropy-consistency. This is a downgrade: earlier in v0.4.0 the capability was listed in the table above and classified StandardDefined, and the reference strict check passed a replicate envelope over it whenever the prior declared an integer contract. It moved because its reconstruction runs float stages and the reference sink can decode it through a float ONNX Runtime path, so decode-equivalence never held as a property of the capability (SPEC §7).

stagearithmetic
entropy decode (mANS) and the scale-index derivation (an integer hyper-scale network)integer on both reference decode paths — what the capability guarantees
hyper-decoder, context-model and synthesis networks16-bit-PTQ integer in the exact decoder; float through ONNX Runtime in the fallback
dequantisation, latent refinement, the post-filter chain (the eICCI post-filter is a float CNN), colour conversionIEEE-754 float in a fixed evaluation order in the exact decoder; float in the fallback

The exact decoder’s pinned reconstruction. WAI’s exact decoder (jpegai_decode::decode) pins one reconstruction to canonical RGB8: the high-operation-point synthesis, then the post-filters, in the arithmetic above. It reproduces across machines when the conditions in §6 hold: its float stages use only IEEE-754 basic operations in the fixed order of the source, with the gain scaler’s exp and every rounding built from those operations (float_repro), so no platform math library is on the path; the target evaluates at the operands’ own precision; and the floating-point environment is the default. The decoder checks the last two before decoding (jpegai_decode::check_scope). Those conditions belong to this implementation. That is why the pinned reconstruction is not a tier, does not back replicate, and is bindable only as reconstruction-binding defines. On one codestream, the decoded bytes, and the float values the decoder reports after each stage, have been measured identical on four platforms (§6); values inside a stage are not compared directly.

The exact decoder implements the configurations of its bundle’s model that its tests and the configuration vectors exercise (wai-rs/tests/jpegai_configs.rs; decisions D74). jpegai_decode::check_codestream accepts a codestream only when its headers select one of them:

Two configurations are refused with a code of their own, configuration_undetermined, because the reference software leaves their result to the machine it runs on (D74): residual variance scaling without GRFS, whose dequantisation it computes by an integer shift or a float division as its tables happen to sit, and a signalled colour matrix, whose inverse is its tensor library’s and whose first row it applies to all three components. Any other codestream is refused as unsupported: another model_id, the base or simple synthesis, another eICCI model pair, a side past 256, of 64, or not a multiple of 64, subsampling, more than 8 bits, and the rest of the conditions above.

Of the reference encoder’s five default rate points (cfg/BRM/default.json), which select model_id 0 to 3, only the first selects the bundle’s model, tools_0; what else the encoder chooses for a picture (eICCI’s models among it) decides whether its codestream is in scope. On 29 configuration vectors (synthetic pictures the reference encoder coded at the configurations above, and header edits of them) the exact decoder is max|Δ| = 1 from the reference decoder’s picture, on 2.5% to 6.6% of samples (§6).

The float ONNX path hard-codes one of these configurations, the reference codestream’s (256 × 256, β 0, every tool on, the built-in colour transform), and refuses every other codestream (jpegai_decode::check_reference_configuration), so the reference sink refuses a codestream outside what a path decodes rather than decoding it to the wrong image. Within the configurations, the exact decoder runs when the sink supplies its integer weight bundle and the thread’s floating-point environment is the IEEE-754 default. Otherwise the reference sink decodes the reference codestream’s configuration through the float ONNX Runtime path, whose reconstruction is not pinned, and refuses the others. The reference dispatch reports which path ran: neural::decode_envelope returns, with the image, the capability it decoded through and the path, DecodePath::Exact or DecodePath::Float. A sink states that path in a reconstruct-session claim as its decoder entry’s variant, exact or float (jwp-receipts §2.4.12), and the reference check of a reconstruction binding reads it (neural::check_reconstruction_binding, reconstruction-binding §2). wai-rs/tests/jpegai_decode_path.rs runs each path and requires the result, the claim and the binding check to say which ran. CI runs the exact decoder over the pinned bundle; the float path’s model bundle is not in the repository, so its case runs locally only, on a host that holds it.

On both paths the stages the capability’s claim covers, the scale path and the two entropy decodes, run through the integer operator set, by the lowering jpegai-int/1 (integer-operators §13.6.1) at the profile acc32. Their refusals have codes: model_mismatch for a bundle that fails a load check of §13.6.1 or whose scale graphs do not meet acc32, and stream_exhausted for a latent or hyper-latent substream that ends before the decode it carries. The exact decoder runs its hyper decoders, context stages and synthesis through the same operator set too, by jpegai-int/1 (§13.6.2) at the profile acc64: those graphs’ outputs lie outside the claim, and their refusals are model_mismatch for a weight file that fails §13.6.2’s load checks or networks that do not meet acc64, and field_range for a dequantised residual, a latent or an activation that leaves i32. A sink that holds the integer weight bundle and refuses the exact decode reports that refusal, with its code; it does not then decode the codestream through the float path. Only a sink without the bundle, or a thread or target that cannot run the exact decoder’s float stages, takes the float path. A decoded-pixel hash or a reconstruction binding over wai.image.jpegai holds only for output of the exact decoder.

What decode-equivalence costs

The tier adds nothing to the wire: nothing is transmitted beyond the capability’s own codestream. The costs fall elsewhere, and the JPEG AI exact decoder pays the same ones for its integer networks:

Parameter transmission pays in bitrate and leaves the decoder’s arithmetic free; the integer decode pays in quantisation, compute and model preparation and adds no bits. A capability’s tier states which trade it made.

Where decode-equivalence holds: fabrics, and output a sink cannot read

The tier is a property of the integer arithmetic a capability’s registration fixes, so a fabric meets it when it executes that arithmetic exactly. What this revision shows, by fabric:

The tier covers the medium a sink emits and can hash (§2, What a tier covers). A sink that hands a payload to a protected media path whose output the application cannot read, as Lane A of SPEC §6.5 does, holds no output to hash, and the tier never covers that output: the sink MUST NOT claim the tier for it, or bind a digest, a reconstruction or an energy figure to it. Content that the application decrypts itself, as in Lane B of SPEC §6.5, is decoded like any plaintext, and the tier holds for it as it does for plaintext.

Claiming the tier on a GPU, and on another accelerator

decode-equivalence holds on an accelerator (a GPU, a neural processor, any device other than the CPU that runs a decoder’s graphs) only where three things keep the integer arithmetic the capability’s registration fixes: the program the device runs, the toolchain’s translation of that program into the device’s own code, and the device. In general form, a decoder claims the tier for output an accelerator computed only when, for every program that ran it: the program computes in integers only, so no reassociation or fusion can change a result; it uses no operation whose result depends on a grouping the device chooses; no result depends on scheduling (item 3 below, as written); the translation gives the program language’s result for every operation it uses, and the program does not reach an operation on operands where the translation does not; the device passes a conformance suite of the operations’ edge cases, and the implementation’s probe of the wider arithmetic it builds, before it runs a graph; and the claim names the device and the toolchain that ran. The items below are those conditions for a GPU, whose programs are WGSL modules; another accelerator’s text states its own program language, translator, suite and probe in their place.

The texts read for a GPU are WGSL, W3C Candidate Recommendation Draft, 21 October 2026 (for workgroup memory, barriers and uniformity, the draft of 6 November 2026, read on 2026-11-12), and naga 30.0.1, the translator wgpu 30.0.1 compiles WGSL with.

WGSL defines each integer operation at run time, the cases that are errors when the operands are known before the shader runs included (WGSL §8.8, §8.10, §17.5): addition, subtraction, multiplication and negation of a concrete integer type are modulo 2^32; e1 / 0 is e1, and e1 % 0 is 0; the most negative i32 divided by −1 is itself, and its remainder 0; a shift amount is taken modulo 32; an integer clamp(e, low, high) is min(max(e, low), high); a bit field’s offset and count are clamped to the word. The languages a WGSL module is translated into leave some of these open: MSL and HLSL leave signed overflow undefined; MSL leaves a left shift of a negative or overflowing signed value undefined, and a right shift of a negative value to the implementation; and MSL, HLSL and SPIR-V leave a zero divisor, the most negative value divided by −1, a shift by the width or more, and a clamp whose bounds are out of order undefined or to the implementation. Floating point is open even in WGSL: an implementation may reassociate operations, and may fuse them where the result is at least as accurate (WGSL §15.7.5). A subgroup operation’s result depends on its subgroup, whose size is a power of two from 4 to 128 that the device compiler chooses, whose invocations have no defined relationship to local_invocation_index, and of whose invocations only the active ones take part (WGSL §15.5, §15.6.3). An out-of-bounds access has several permitted outcomes (WGSL §6.5.7).

So a decoder MAY claim decode-equivalence for output whose graphs ran on a GPU only when every condition below holds for every shader module that ran them, on that adapter, in that process. Otherwise the output is the GPU’s, and no tier is claimed for it.

  1. Integer only. Every scalar type in the module, of every declaration and of every expression, is bool, i32 or u32; every literal is of one of them; every conversion is between them. No floating-point type appears for any purpose, an index or a loop bound included. With no floating-point operation, no reassociation or fusion an implementation may make changes a result: integer addition and multiplication modulo 2^32 give the same value in any order.

  2. No subgroup or quad operation, and no extension. The module enables nothing (enable) and calls no subgroup or quad built-in.

  3. No result depends on scheduling. Each output word is written by one invocation and read by no other invocation of the same dispatch. Every atomic operation on a given memory word is of one kind: atomicOr, atomicAnd, atomicMin or atomicMax, or atomicAdd and atomicSub together; no atomicLoad, atomicStore, atomicExchange or atomicCompareExchangeWeak reaches it in the dispatch; and the value an atomic returns is not used. Each of those kinds alone is order-free; two on one word are not (an atomicOr then an atomicAnd differs from the reverse). No access is out of bounds. Workgroup memory, which the invocations of one workgroup share, is used only in this form (decision D76):

    • it holds i32 and u32 words, in arrays of a fixed length, and no atomic;
    • each word is written by at most one invocation of its workgroup: every write is at the invocation’s local invocation index, or at a counter that starts there and steps by the workgroup’s size, and is below the array’s length;
    • no stretch of the program that an invocation can run without reaching a workgroupBarrier both writes and reads the same workgroup variable, so a write and a read of it by two invocations are always separated by a barrier both reach;
    • every workgroupBarrier is reached in uniform control flow (WGSL §15.2), and no other barrier and no workgroupUniformLoad is used; and
    • the host keeps the zero initialisation of workgroup memory (WGSL §7.3) on: in wgpu, a pipeline’s zero_initialize_workgroup_memory is never set false.

    Then every read of workgroup memory has one possible value: the value written by the one invocation whose write most recently precedes it across a barrier, or zero. A workgroupBarrier is a control barrier of the workgroup’s execution and memory scope with acquire-release semantics on workgroup memory, so what any invocation wrote before it is visible to every read after it (WGSL §14.5.3, §14.5.4, §17.11); with every conflicting pair of accesses separated by one there is no data race (WGSL §1.1, §2.2, §6.5.7); and the values written are computed in integers only (item 1). So each output word is a function of the inputs alone, as it is in a kernel that uses no workgroup memory, whatever order the invocations and the workgroups run in.

  4. The translation gives WGSL’s results. A translation into a language that leaves an integer result open produces WGSL’s result for each operation the module uses: signed addition, subtraction, multiplication and negation evaluated in unsigned arithmetic and reinterpreted; division and remainder through a guard that substitutes the divisor 1 where WGSL’s result is the dividend, and remainder 0; the absolute value of the most negative value, itself. naga 30.0.1 does all of these in MSL and HLSL (its naga_div, naga_mod, naga_neg and naga_abs, and signed arithmetic through unsigned); in SPIR-V, whose integer addition, subtraction, multiplication and negation wrap, it guards division and remainder. In MSL the division and remainder guards, and in SPIR-V the division and unsigned-remainder guards, are written only while its integer-division checks are on; SPIR-V’s signed remainder is guarded even with them off, and HLSL’s guards are always written (DX12’s translation goes through FXC, shader model 5.1). A host MUST NOT turn a translator’s guards off: in wgpu, a module created unchecked, or ShaderRuntimeChecks::int_div_checks false. Where a translator does not produce WGSL’s result for an operation, the module MUST NOT reach that operation on the operands concerned. naga 30.0.1 passes a shift amount to MSL, HLSL and SPIR-V without reducing it modulo 32, writes a signed left shift as it is, and writes an integer clamp as MSL’s and HLSL’s clamp; so every shift amount in the module is a literal below 32 or masked below 32 (e & 31u), no left shift has a signed left operand (the module shifts the u32 and bitcasts), and every clamp has literal bounds in order, another bound being written min(max(e, low), high). A right shift of a negative value, which MSL leaves to the implementation, is held by item 5: the suite runs it on the adapter.

  5. The adapter passes the conformance suite first. Before an adapter runs any graph of the decode, in the same process, it gives WGSL’s result for every case of the integer semantics vectors (wai/wgsl-conformance/integer.jsonl) that the file marks guarded, and for further cases of each operation that the implementation draws, and the host’s result for every word of the implementation’s probe of the wider arithmetic it builds from 32-bit words. And the implementation has reproduced, on that adapter, backend and driver, every graph vector of integer-operators §14.1 and §14.2 its subset covers, at each width it runs (integer-operators §12, Evidence for a fabric). An adapter that differs on any guarded case or probe word runs no graph.

  6. The claim names what ran. A receipt or report of a GPU decode at this tier names the adapter (backend, PCI vendor and device, driver) and the translator and its release. Where the backend reports no PCI identity and no driver (Metal and a browser’s WebGPU give vendor and device 0x0 and an empty driver), it names in their place the adapter name the backend gives and the operating system’s build, or the browser and its version.

The semantics vectors cover every integer operation a kernel may use (rule 7 of tests/wgsl_rules.rs keeps the kernels inside them), on i32, u32 and two-component vectors of them where a kernel uses those, with the edge cases above: every pair of a set of values at and near the edges of both types for the arithmetic, division and remainder, every shift amount from 0 to 40 and the extremes past it, and bit fields at and past the word. They mark as unguarded the cases item 4 keeps a module from, a shift amount of 32 or more and clamp bounds out of order, whose result is the hardware’s through naga 30.0.1. A run reports what each adapter gives on them; a difference there does not refuse the adapter, since no module at this tier reaches one. The file is written from WGSL’s definitions by wai_ops_gpu::semantics::reference and checked against it natively, and against the same reference compiled to wasm32, under Node and in a browser page.

wai/wai-ops-gpu meets these conditions. tests/wgsl_rules.rs holds every shipped module, on naga’s IR, to items 1, 2 and 4 and to item 3’s atomic, barrier and workgroup parts: the types and literals; a closed list of expressions and built-in functions; the one atomic operation, atomicOr on the flag binding, its result unused, and no atomic load or store; the bindings, no private memory, and workgroup memory only as arrays of i32 and u32 words; workgroupBarrier the one barrier, in entry points only; the shift masks, no signed left shift, and clamp bounds; that every integer operation a kernel uses is one the semantics suite runs; naga’s wrapping of signed arithmetic and its guard helpers in each module’s MSL and HLSL translations, which disappear from the MSL with its division checks turned off, and the workgroup barrier in both translations; and item 3’s workgroup form, mechanically (its rule 9): a uniformity analysis of its own, stricter than WGSL’s, that puts every barrier in uniform control flow (naga’s validation does not refuse a barrier outside it); every write to workgroup memory at the invocation’s index, or at a counter from it that steps by the workgroup’s size and is guarded below the array’s length by the loop it steps in; only entry points writing workgroup memory; and, along every path through branches, around loops and into the functions an entry point calls, no stretch between barriers that both writes and reads one workgroup array. Item 3’s other parts, each output word written by one invocation and read by no other, and no access out of bounds (a workgroup array’s reads included: each tiled kernel reads below its arrays’ lengths for every parameter the host gives it, the host choosing a tiled kernel only where its tile holds the operator), rest on the host’s indexing of the dispatch and on wgpu’s bounds checks, which the checked module-creation call keeps on; the rules check does not decide them. It also holds the crate to the checked module-creation call and to wgpu’s zero initialisation of workgroup memory, and shows each planted violation (a floating-point value, f16, a subgroup reduction, an atomicAdd, an atomic’s result read, an atomic load, an atomic store, a storage barrier alone, an unmasked shift, a signed left shift, a clamp with run-time bounds; and, in workgroup memory, a missing barrier before a tile’s read and before its next write, a barrier in non-uniform control flow, after a non-uniform return and in a loop of non-uniform count, a write at a fixed index, a counter guarded past its array, stepping by less than the workgroup or not starting at the invocation’s index, a write in a function, an atomic, a workgroupUniformLoad) refused by the rule it breaks, and a tiled kernel in the admitted form passed. Discovery runs item 5’s suite and probe on each adapter before it runs a graph; tests/semantics.rs shows every adapter refused when the suite’s remainder is written by hand, a - (a / b) * b, which gives a where WGSL gives 0. In a browser, wai-ops-gpu/browser runs the same suite through the browser’s own WGSL compiler.

6. Evidence status

What the repository demonstrates, claim by claim, as of 2026-09-27 (main at afc7ece), except where a row names a later run: the rows that cite run 745 read the forge’s runs of the landing chain’s head 7cfcecfa on 2026-09-30. A test that skips reports as passing, and a matrix leg whose runner did not run reports nothing; neither is evidence.

The CI rows below come from the forge’s commit statuses (/api/v1/repos/Transaction-Science/open-standards/commits/<sha>/statuses), read for every commit on main since 2026-08-10 and for the pre-merge commits named, not from the workflow definitions. Two workflows run the same golden-byte suite (wai/byte-exact-conformance, cargo test --release): the cross-arch byte-equality job of wai-conformance.yml, and wai-byte-equality.yml. Both declared Linux x86_64, Linux arm64, macOS arm64 and Windows x86_64 legs until 2026-09-30, when the Windows x86_64 legs were taken out of both workflows while its runner was offline. No Windows x86_64 job ran for this repository from 2026-08-28 until that runner was back: every Windows status on main in that time is “Waiting to run” or “Has been cancelled”.

What runs on Windows x86_64 now, read from the forge’s runs on 2026-11-10:

What does not: the cross-arch byte-equality job of wai-conformance.yml keeps its three unix legs, as the suite’s Windows leg is wai-byte-equality.yml’s, and no other job of that workflow has a Windows leg (the independent verifiers, the codec wrappers and the WebAssembly runs among them). Within the cargo-class job, the steps that need a unix shell or tool are skipped on Windows: the check that the JPEG AI exact decoder calls no platform math library, each integer feature built alone, the wasm32 builds, the check of the audio vectors’ provenance, and the OER C kernel. There is no macOS x86_64 or Windows arm64 leg. A Windows result in the rows below from before 2026-08-28 is history; a row names the run where Windows has decoded since.

claimevidencewhere
Cross-architecture identity of the rANS coder, int_synth, and the JPEG AI symbol decode (a reference-encoder codestream, given its distribution indices)golden-byte assertions passed on Linux x86_64, Linux arm64 and macOS arm64 on main at afc7ece (2026-09-27, wai-conformance.yml; wai-byte-equality.yml last ran on main at 3f50097, 2026-08-29, all three legs passing), and on Windows x86_64 last on main at 3e7811f (2026-08-27). Between 3e7811f and afc7ece the suite only gained the video and keyframe goldens; these goldens, the sources they decode and the suite’s lockfile are unchanged. On Windows x86_64 again since 2026-11-05: wai-byte-equality.yml’s windows-x86_64 leg, passing at e694cb096 in run 28636 (job 115713)byte-exact-conformance/; .github/workflows/wai-conformance.yml, wai-byte-equality.yml
Cross-architecture identity of integer inter-frame video, and of int_hyper on a small learned keyframethe same suite, passing on Linux x86_64, Linux arm64 and macOS arm64 on main at afc7ece (2026-09-27). Windows x86_64 did not decode the keyframe clip on main before 2026-11-05: it was added in d4c922b (2026-08-28), whose Windows legs were cancelled. Before then, Windows decoded the integer video goldens only on the pre-merge commits c9be2ad, 256e5dd, 7dfca26 and 3d34860 (2026-08-25/26), whose video sources, vectors and golden file match main but whose byte-exact-conformance/Cargo.lock differs; the change reached main at 3f50097, after the last Windows run on main of that time. Both goldens pass on Windows x86_64 since its wai-byte-equality.yml leg came back: at e694cb096 in run 28636 (job 115713)as above
wai.image.jpegai exact decoder: the integer derivation of the distribution indices matches the reference decoder exactlya test on one machine that skips unless its fixtures (sink-supplied weights, normative tables, codestream) are provided; CI does not provide themwai-rs/tests/jpegai_hyperscale_calibration.rs
wai.image.jpegai exact decoder, whole decode through the one public decode() call: it stays within a stated bound of the reference decoder’s output (max|Δ| ≤ 2, ≤ 5% of samples); two decodes in one process are byte-identical, and a reconstruction binding taken over one verifies the otherwai-jpegai-e2e.yml fetches the pinned jpegai/v1 inputs (an extraction of the reference-software assets, published under WAI’s models root), checks each file against the SHA-256 manifest tools/jpegai-e2e-v1.sha256, and runs both tests with WAI_REQUIRE_SOTA_VECTORS=1, under which a missing input fails instead of skipping. The job also fails on any skip banner in the test log, and requires the decoded pixels to hash to a pinned SHA-256. One 256×256 codestream. The workflow has run on the forge’s Linux runner (x86_64 hardware) and passed on every run since 2026-09-28. Before that, its job passed under forgejo-runner exec on the same host (2026-09-27) with the exact decoder as it stood on main at afc7ece, which calls the platform exp; there too the decoded pixels matched the pinned hash, the value measured on macOS arm64wai-rs/tests/jpegai_e2e_full.rs, jpegai_reconstruction_binding.rs; .github/workflows/wai-jpegai-e2e.yml
wai.image.jpegai exact decoder across platforms: the jpegai/v1 codestream decodes to the same RGB8 bytes, and to the same bits in the float values the decoder reports after each stage (values inside a stage are not hashed), on each platform measuredmeasured 2026-09-28 with rustc 1.98.0, release builds, inputs checked against their SHA-256, all four on the source of the change that added this row: macOS arm64 (native, on the development machine); wasm32-wasip2 (wasmtime 49, on the same machine); Linux arm64 (glibc 2.36, a container in an arm64 Linux VM on that machine); Linux x86_64 (glibc 2.36, the x86_64 build run in that container under user-mode emulation, QEMU 7.0, not on x86_64 hardware). All nine pinned hashes matched on each platform. On all four they also matched on an earlier state of that change, before the decode’s exp and rounding moved to float_repro. Before the move the decode called the platform exp on every target, and its roundings compiled to calls to the symbols round, roundf and rint on x86_64 and round and roundf on wasm32, which the link resolves: an x86_64 Linux test executable inspected after the move, whose other code still rounds this way, took them from Rust’s compiler builtins, not the C library (for wasm32 this was not checked). Not measured: macOS x86_64 (no x86_64 translation layer is installed on the development machine), Windows, x86_64 hardware, 32-bit targets. The test skips unless the inputs are supplied. wai-jpegai-e2e.yml supplies them and requires this test to run and pass on its Linux runner; that workflow has run on the forge’s Linux x86_64 runner and passed on every run since 2026-09-28wai-rs/tests/jpegai_cross_platform.rs
wai.image.jpegai exact decoder over its configuration vectors (decisions D74): each of the 29 in scope decodes to the RGB8 its manifest pins, the direct decode gives the same bits at every stage, each is max|Δ| = 1 from the reference decoder’s picture, and the other 31 are refused with their kind (29 unsupported, among them 17 refusal fixtures, and 2 configuration_undetermined)measured 2026-11-12 with rustc 1.99.1, release builds, the jpegai/v1 bundle checked against its SHA-256: Linux x86_64 (a 32-thread build host) and macOS arm64 (a 28-core build host), the same 29 digests on both; the reference decodes from the reference software on Linux x86_64. The pictures’ share of samples apart from the reference is 2.5% to 6.6%. Not measured: Linux arm64 (the hosts were held by other work that day), Windows. wai-jpegai-e2e.yml runs the test and the comparison on its Linux runnerwai-rs/tests/jpegai_configs.rs, tools/wai_jpegai_configs.py
float_repro, the decode’s exp and rounding: the same bits over a fixed grid of inputs; exp within 2 ULPs of the host math library (1 ULP measured); rounding equal to the standard library’slibrary unit tests under the library-test step of the conformance workflow (neural_int), which has run them on its macOS, Linux x86_64 and Linux arm64 runners since 2026-09-28, and on its Windows x86_64 runner since 2026-11-10 (run 28810, job 116278). The pinned-bits and rounding tests never skip. The host comparison asserts the host library’s accuracy as much as this module’s. Its gate selects by target, not by host: it runs on macOS arm64, on Linux x86_64 and arm64 with glibc, and on WASI, and is reported as ignored, with the reason, elsewhere, Windows included. On the source of the change that added this row it was run against these hosts’ exp, with a worst case of 1 ULP on each: the platform math library on macOS arm64; the WASI C library under wasmtime; glibc 2.36 on Linux arm64, and glibc 2.35 in the Ubuntu 22.04 image the workflow’s Linux arm64 runner used on 2026-09-28; glibc 2.36 on Linux x86_64 under user-mode emulation, against three of the four exp variants glibc chooses among by processor feature (the variant each run used follows from the features glibc’s loader reported active): SSE2 (QEMU 7.0, whose emulated processor reports none of AVX, FMA, AVX2 and FMA4), AVX (QEMU 7.2, -cpu max with FMA and AVX2 masked by glibc’s hwcaps tunable, which leaves AVX active) and FMA (QEMU 7.2, -cpu max). On a separate probe of 20 million inputs, the SSE2 and AVX variants returned the same bits, and the FMA variant different bits for some of them. Not compared: the FMA4 variant, which glibc chooses on a processor that has FMA4 but not both FMA and AVX2, and which neither emulator offers. Not run on x86_64 hardware or on other glibc versions, where the gate still runs it; a failure there would say that the host’s exp and this one are more than 2 ULPs apart, not that float_repro’s bits changedwai-rs/src/float_repro.rs tests
The exact decode path calls no platform math librarytwo checks. Clippy’s disallowed_methods (wai-rs/clippy.toml), denied in each module on the decode path, rejects any use of a listed float method, including f64::exp(x) and .map(f64::exp). tests/jpegai_decode_symbols.rs lists the symbols of an executable that links only the decoder’s entry points and weight loaders. It rejects any C math-library function the executable imports, and any it defines other than the round-to-integral functions (floor, round, rint and the like), whose results IEEE 754 fixes. It allows those definitions because a definition shows what the linker kept, not what the decode calls: linked with GNU ld 2.40 for x86_64 Linux, the debug executable defined the compiler builtins’ floor, though nothing in it referred to floor. On the source of the change that added this row, both checks pass on macOS arm64, the symbol check in debug and release builds. The symbol check also passes, in debug builds, on Linux arm64 (the container above) and on Linux x86_64 under user-mode emulation, linked with GNU ld (reporting that floor as allowed) and with LLD. With a platform exp put back as f64::exp(…), both fail on macOS arm64 while the decoder’s unit tests still pass, and the symbol check fails on Linux x86_64 with GNU ld. With a float % put into the decode, the symbol check fails on macOS arm64 and clippy, which does not see operators, passes. The conformance workflow runs both on its unix legs, on the forge’s runners since 2026-09-28wai-rs/clippy.toml, wai-rs/tests/jpegai_decode_symbols.rs, .github/workflows/wai-conformance.yml
wai.image.jpegai scope: the reference codestream is accepted; copies with β, model_id, the colour transform or an LSBS flag changed are refused; a flush-to-zero or round-toward-zero environment is detected. The float ONNX path calls the same checklibrary unit tests over a committed copy of the reference codestream, which never skip and fall under the library-test step of the conformance workflow (neural_int); the environment test runs on arm64 only. Run on the four platforms above, on the source of the change that added the cross-platform row (the environment test on macOS arm64 and Linux arm64). The float path’s refusal (β and model_id edits) is tested only with its ONNX bundle supplied (jpegai_scope_ort.rs, skips otherwise)wai-rs/src/jpegai_decode.rs tests, wai-rs/tests/vectors/jpegai/
SPEC §7’s replicate rule: the registry class decides first, so an integer-declared prior over wai.image.jpegai or a float codec is refused; wai.image.jpegai is the only NeuralEntropyExact capability; the standard codecs sit in the classes SPEC §7 lists, and the tolerance and unclassified ones are not refused; an encoder that pins no prior (wai wrap) writes replicate only over the standard classes, for the capability and for any declared fallback, or, in the WAI2 companion form, for the base payload’s capability and each companion’slibrary unit tests (codecs, container) that never skip and fall under the same library-test step. The strict-decode test in tests/neural_native_decode.rs needs the neural feature; wai-neural-gates.yml runs it on the Linux runner, in an Ubuntu 24.04 image because the neural test binary does not link in that runner’s default 22.04 image. Its strict-decode job ran on the forge and passed on every run from 2026-09-28; before that the job passed under forgejo-runner exec on the Linux runner’s host (Linux x86_64, 2026-09-27). The pin-aware tests since added to that workflow (its longer exact list of neural_native_decode tests, the step of model-free neural library tests, and the neural C ABI step, tests/ffi_neural_pin.rs) have no recorded forge run yet. The wai binary no longer needs the codecs feature, so the tests that run wai wrap (cli_wrap_intent.rs, and cli_registry.rs for the candidate refusal and the registry export) run in the conformance workflow’s carriage step on every leg; this row records no forge run of them yet. The C envelope packers emit through Wai::to_emit_bytes and WaiMulti::to_emit_bytes, whose candidate refusal a library test checks with no feature (the_emit_path_refuses_a_candidate, in the library-test step); the C wrappers themselves build under the codec-free ffi feature, and tests/ffi_envelope.rs (envelope_pack_refuses_a_candidate, envelope_select_never_picks_a_candidate) runs in the conformance workflow’s C ABI envelope step on every leg; this row records no forge run of that step yet. The browser writers’ refusal runs in wai-web-wasm.yml (verify_pack.mjs)wai-rs/src/codecs/mod.rs, container.rs tests; wai-rs/tests/neural_native_decode.rs, cli_wrap_intent.rs, cli_registry.rs; wai-web/demo/verify_pack.mjs
wai.neural.int_hyper and wai.video.int_hyper at full model scale (the pretrained mbt2018_mean, exported to integers): the Rust decode reproduces the export tool’s integer reference byte for byte (synthesis, hyper-decoder, the whole conditional bitstream, an eight-frame clip), and costs at most 1 dB against the same model’s float decode on one pinned photographwai-sota-vectors.yml regenerates the vectors on the runner from pinned inputs (the photograph’s pixels and the checkpoint’s bytes by SHA-256, the Python stack by version) and runs both tests with WAI_REQUIRE_SOTA_VECTORS=1, under which a missing vector fails instead of skipping. The job also fails on any skip banner in the test log, and runs require_vectors_rule.rs, which checks that without the switch a variable naming absent or incomplete inputs fails as well. Rust is checked against the export of the same run on the same machine: the vectors come from float computation, and some of them differed between machines and between runs, so none of their hashes is pinned and none is compared across machines. The workflow has run on the forge’s Linux runner (x86_64 hardware) and passed on every run since 2026-09-28wai-rs/tests/int_hyper_synth.rs, int_video_sota_keyframe.rs, require_vectors_rule.rs; .github/workflows/wai-sota-vectors.yml
wai.audio.opus.dred.int: the profile’s features are an exact integer function of the payload and the pinned weights, the same on the CPU and on a GPU, and within the draft’s tolerance of its reference featuresthe corpus live-conformance/dred/ regenerates byte for byte, and its second implementation (dred_verify.py, standard-library Python written from the extension) recomputes every digest and row; the two graphs on the GPU at acc64 give the interpreter’s integers graph by graph and the CPU decode’s bytes; on the draft’s eight test vectors the features pass the draft’s feature test and lie at total 0.0021 from the network in floating point (opus-dred §6)measured 2026-10-22 with rustc 1.98.0 on macOS arm64 (the build host: the wai-rs tests in release, the GPU test on its Metal adapter gpu-metal-0) and the Python verifier on a second macOS arm64 host. Not measured: x86_64, Linux, Windows, wasm. CI runs the corpus, the measurement and the verifier on the forge’s Linux arm64 runner (wai-conformance.yml) and the GPU test on the macos runner (wai-ops-gpu.yml), with no forge run recorded yet. The weights are fetched by digest, not committed
wai.audio.int_codec, wai.splat.int_codeccommitted vectors that never skip. Their frozen hashes are the output of an independent Python integer reference, computed when the vectors were exported (tools/wai_int_audio_export.py, tools/wai_int_splat_export.py); no Python runs in CI. The conformance workflow’s fast-kernel steps enable audio_int and splat_int and, in debug and release builds, decode both vectors against those hashes under the reference kernels and every fast-kernel policy (tests/int_kernels_vectors.rs); that passed on the forge’s Linux x86_64, Linux arm64 and macOS arm64 runners for the landing chain’s head 7cfcecfa (run 745, 2026-09-30). The same steps also name tests/int_audio.rs and tests/int_splat.rs, which check each vector against the same hash and against its own metadata (sample count; attribute count, tensor size and grid side); Cargo declares each with its feature as a required feature, so a step that names it without that feature fails instead of running nothing. This row records no forge run of those twowai-rs/tests/int_audio.rs, int_splat.rs, int_kernels_vectors.rs; .github/workflows/wai-conformance.yml
wai.neural.int_mlicpp on its committed vector (synthetic seeded weights; a 64×64 image, 8 latent channels in 4 slices): the decode reproduces the export tool’s independent integer reference byte for byte — the RGB, and every scale bucket and symbol of the latent stream in coding order (512 symbols over all 16 buckets of the scale table, 47 of the symbols coded by the rANS escape) — under the reference kernels and under the fast kernels on 1, 2, 3, 5 and all available threads; one integer unit changed in each of four chosen parameters, one on each path that feeds a value (a hyper-decoder weight, an entropy-network weight, a mean-head bias, a synthesis weight), changes the image; a header whose shapes the model cannot produce, or on which a network would form a buffer over the cap, is refused before anything is allocated (tests/int_mlicpp_preflight.rs, which counts allocations); damaged payloads are refused or decode, and never panic in an overflow-checked buildmeasured 2026-09-29 with rustc 1.98.0 on the source of the change that added this row: macOS arm64 native (the wai-rs tests, with overflow checks on and off; the byte-exact-conformance golden, release) and wasm32-wasip2 under wasmtime 49.0.1 (the same tests and golden, release; on wasm the fast kernels run single-threaded as portable scalar code, and usize is 32-bit). All pinned hashes matched on both. Not measured: x86_64 — the development machine has no x86_64 translation layer installed, and an x86_64-apple-darwin build of the golden compiles but cannot execute there — nor Linux or Windows. The golden runs on every leg of the byte-exact matrix (wai-conformance.yml, wai-byte-equality.yml) and tests/int_mlicpp.rs on every leg of wai-conformance.yml in both profiles. Both passed on the forge’s Linux x86_64, Linux arm64 and macOS arm64 runners for the landing chain’s head 7cfcecfa (run 745, 2026-09-30). On Windows x86_64 the golden passed in wai-byte-equality.yml at e694cb096 (run 28636, job 115713), and tests/int_mlicpp.rs in both profiles at 1d92a4533 (run 28810, job 116278). The dispatch through decode_envelope_strict (the prior pinning the one-file model bundle, the strict gate) runs in wai-neural-gates.yml. The weights are synthetic, so nothing here measures compression qualitywai-rs/tests/int_mlicpp.rs, wai-rs/tests/int_mlicpp_preflight.rs, byte-exact-conformance/src/int_mlicpp_golden.rs, wai-rs/tests/neural_native_decode.rs; tools/wai_int_mlicpp_export.py
wai.video.int_cond and its frame form on the committed trained vector (a six-frame 64×64 clip; an 8-channel latent at 16×16, a 16-channel feature; networks trained on seeded procedural clips and quantised after training): the clip decodes to its sidecar’s SHA-256, which the export tool’s own integer encoder computed; int_payload_verify.py --int-cond, which shares no code with wai-rs, decodes it to the same bytes from the extension’s text; the frame objects decode to the clip’s frames byte for byte; every fixture of int-payload-conformance/int-cond/ is refused with its code by both; the committed clip, and the synthetic set and clip of the module’s tests, decode alike under the reference kernels and every fast-kernel policy; ten planted faults in the decoder and the parser (among them an inter frame read against the zero feature, in the clip and in the frame form, and the scales and means swapped) and four in the Python decode (among them the feature not carried) are each caughtmeasured 2026-11-09 with rustc 1.99.1 on two hosts, Linux x86_64 and Linux arm64: wai_int_payload_vectors verify, tests/int_cond_video.rs with overflow checks on and off, tests/int_kernels_vectors.rs and the other tests of the conformance workflow’s integer-kernel step, the library’s tests, and the Python verifier; every hash matched on both. Not measured: macOS, Windows, wasm32. The networks are small and the clip short: nothing here measures compression at a useful scalewai-rs/tests/int_cond_video.rs, wai-rs/tests/int_kernels_vectors.rs, wai-rs/src/int_cond_video/tests.rs, int-payload-conformance/int_payload_verify.py; tools/wai_int_cond_export.py
wai.neural.int_hyper and wai.neural.int_mlicpp on the sets trained on openly licensed natural pictures (natural of each: 64 synthesis and 64 latent channels; int_mlicpp’s in 4 slices with a 48-channel hyper-latent; trained on 599 pictures of research/training-pictures/natural-1.json, quantised after training by each exporter’s own path), each on its committed 128 × 128 generated coded picture: the decode reproduces the exporter’s integer reference byte for byte, by the sink’s path and through the lowering, under the reference kernels and the fast kernels at one thread and at all; the int_hyper payload decodes in the int-payload corpus natively and is parsed and converted by int_payload_verify.py; the int_mlicpp payload decodes through wai-ops’s stage operators (wai-ops/tests/goldens.rs) to its digest; ops-conformance certifies both sets at acc64; and each of the 24 pictures the sets are read on (768 × 512) decodes by the sink’s path to the digest the trainer’s own decode recorded. A fault planted in the fast kernels (the inverse GDN one off on 64-channel layers) changes both sets’ decodes under the fast kernels and is caught by both goldens, while the reference kernels still give the pinned bytesmeasured 2026-11-12 with rustc 1.99.1: on macOS x86_64, wai_int_payload_vectors verify, wai-verify vectors verify, tools/wai_ops_check.py, int_payload_verify.py, byte-exact-conformance (release), tests/int_hyper_ops.rs (release and debug), tests/int_mlicpp_ops.rs, tests/int_kernels_vectors.rs and wai-ops’s goldens, every hash matching, and the planted fault caught; on Linux x86_64, the 48 payloads of those pictures decoded by wai_det_cost to the trainers’ recorded digests. The byte-exact goldens run on every leg of the byte-exact matrix (wai-conformance.yml, wai-byte-equality.yml) and the module corpus on its engines (wai-int-module.yml) from the change that added this row. The sets are compact and trained briefly: research/trained-sets.md states what they are read atbyte-exact-conformance/src/int_payload_golden.rs, byte-exact-conformance/src/int_mlicpp_golden.rs, wai-rs/tests/int_hyper_ops.rs, wai-ops/tests/goldens.rs, wai-rs/tests/ops_gpu.rs; tools/wai_int_hyper_train.py, tools/wai_int_mlicpp_train.py; research/trained-sets.md
wai-ops/1-i32 graphs on GPUs (wai/wai-ops-gpu, §5, Claiming the tier on a GPU): every shipped module meets items 1, 2 and 4 and item 3’s atomic and barrier parts on naga’s IR; each device gives WGSL’s result for every guarded case of the integer semantics suite and agrees with 128-bit host arithmetic on every probe case; every graph vector of ops-conformance/ that the subset covers gives the interpreter’s outputs or refusal code, at acc32 and at acc64; the integer decoders, with their graphs on the device, give the CPU decode’s bytes or refusal codes on every committed vector and refusal fixture, and every graph the device runs gives the interpreter’s outputsthe forge’s run 10236 (job 46928) of wai-ops-gpu.yml, 2026-10-22, rustc 1.98.0 and wgpu 30.0.1 (naga 30.0.1), release builds, on the kernel text of the change that added Claiming the tier on a GPU, on the adapters §5 lists: Metal on macOS 27.0.1 (arm64), and headless Chromium 148 on that GPU; and, on 2026-10-24 at the commit that added wai/research/ops-gpu-runs.txt (which holds both runs’ report lines), Vulkan on Linux x86_64 with the 0x1002 adapter (Mesa 26.0.8) and llvmpipe, where every test of the crate ran and passed with WAI_OPS_GPU_REQUIRE=1 and the semantics suite, the probe, the corpus and the mutants gave the figures below with none differing. tests/wgsl_rules.rs passed, each planted violation refused by the rule named. On Metal the semantics suite (tests/semantics.rs) gave WGSL’s result for every one of 254,464 cases, the 25,088 committed and 4,096 SplitMix64 cases of each operation: 231,690 guarded, and the 22,774 unguarded too (a shift amount of 32 or more, clamp bounds out of order); the browser leg ran 82,432 cases with none differing, and the committed file reproduced under the reference compiled to wasm32, in the page and under Node 26. The probe (tests/arith.rs) agreed on every word of 1,051,757 cases; the corpus (tests/corpus.rs) ran 813 vectors (1,104 decodes) on the 32-bit kernels and 1,426 (1,921 decodes) on the 64-bit ones, 212 of the decodes refusals, with no difference; 209 graphs use an operator outside the subset and ran on the CPU, and 95 vectors are refused at load. Eighteen edits of one kernel expression each (tests/mutants.rs) were each caught by the corpus, an edited product by the probe, and a remainder written by hand by the semantics suite at discovery. wai-rs/tests/ops_gpu.rs decoded the committed vectors and refusal fixtures of the six capabilities §5 names, the world renderer’s two vectors and wai.image.jpegai’s jpegai/v1 codestream on Metal, in the forge run, comparing every graph the device ran with the interpreter as well as each decode’s bytes; none differed. The browser leg ran the corpus and the semantics suite, not the decoders. Hand runs of this kernel text on Vulkan on Linux x86_64 (PCI vendors 0x10de and 0x8086, and llvmpipe) and on Windows x86_64 (Vulkan and DX12, PCI vendors 0x10de and 0x8086, and the software DX12 adapter) committed no record, and G1’s runs of the 0x10de and 0x8086 adapters were of the kernel text before it; none of those is claimed. wai-rs/tests/ops_gpu.rs has not run on the Vulkan adapters on this kernel text. wai-ops-gpu.yml runs the Metal and browser legs on the macos runner, where an absent adapter fails. No other workflow runs a GPU leg of these testswai-ops-gpu/tests/, wai-ops-gpu/browser/, wai-rs/tests/ops_gpu.rs, wgsl-conformance/; .github/workflows/wai-ops-gpu.yml
wai-ops/1-i32 graphs on GPUs on the kernel text with the narrow kernels and before the run-time and four-channel forms (§5, GPU): every shipped module meets the conditions of Claiming the tier on a GPU as the row above states; a (transposed) convolution of an acc64 graph whose bounds pass admits it gives the interpreter’s integers with each product and each sum of at most K taps in one word, at the edge of the bound included; and the integer decoders, with their graphs on the device, give the CPU decode’s bytes or refusal codesruns 3 to 5 of wai/research/ops-gpu-runs.txt, by hand on 2026-11-11 with rustc 1.99.1 and wgpu and naga 30.0.1, release builds: Metal on the integrated GPUs of an arm64 laptop and of an arm64 desktop of an earlier generation (macOS 27.2.1), and Vulkan on Linux x86_64 on the adapter of PCI vendor 0x1002 (Mesa 26.0.8) and llvmpipe. On each, every test of wai-ops-gpu passed and cargo clippy --all-targets -D warnings was clean: the semantics suite gave WGSL’s result on all 231,690 guarded cases of 254,464; the probe agreed on every word of 1,051,757 cases; the corpus ran 813 vectors at acc32 and 1,426 at acc64 with narrowing on and again with it off, 293 operators of 181 vectors on the narrow kernels, with no difference; the narrow kernels’ own test ran 178 graphs (18 at the bound’s edge) in 916 decodes, 155 operators narrow and 73 of those with a chunk below every tap, with narrowing on and off, no difference; the 18 shader mutants and the eight faults planted in the narrow kernels were each caught. wai-rs/tests/ops_gpu.rs decoded the committed vectors and refusal fixtures of the six capabilities §5 names and the world renderer’s two vectors with no difference, every graph compared with the interpreter; wai.image.jpegai did not run, its inputs not being on these hostswai-ops-gpu/tests/, wai-ops-gpu/tests/narrow.rs, wai-rs/tests/ops_gpu.rs
wai-ops/1-i32 graphs on GPUs on the kernel text with the narrow kernels, the run-time forms and the four-channel forms and before the tiled kernels (§5, GPU): every shipped module meets the conditions of Claiming the tier on a GPU as the rows above state; a (transposed) convolution of an acc64 graph gives the interpreter’s integers on the narrow kernels’ static chunks and on the run-time forms, at the edges of both bounds, with four output channels a thread and with one; an inverse GDN on its run-time form at and past its bound; and the integer decoders, with their graphs on the device, give the CPU decode’s bytes or refusal codesruns 6 to 8 of wai/research/ops-gpu-runs.txt, by hand on 2026-11-12 with rustc 1.99.1 and wgpu and naga 30.0.1, release builds: Metal on the integrated GPUs of an arm64 laptop and of an arm64 desktop of an earlier generation (macOS 27.2.1), and Vulkan on Linux x86_64 on the adapter of PCI vendor 0x1002 (Mesa 26.0.8) and llvmpipe. On each, every test of wai-ops-gpu passed and cargo clippy --all-targets -D warnings was clean: the semantics suite gave WGSL’s result on all 231,690 guarded cases of 254,464; the probe agreed on every word of 1,051,757 cases; the corpus ran 813 vectors at acc32 and 1,426 at acc64 with narrowing on (the run-time forms taking every acc64 convolution and inverse GDN the static plan leaves) and off, with no difference; the narrow kernels’ own test ran 192 graphs (18 at the static bound’s edge, 14 at the run-time forms’) in 962 decodes with narrowing on, four channels and one, and off, no difference; the 18 shader mutants and the 19 faults planted in the narrow and run-time kernels were each caught. wai-rs/tests/ops_gpu.rs decoded the committed vectors and refusal fixtures of the six capabilities §5 names and the world renderer’s two vectors with no difference, every graph compared with the interpreter; the native sink’s decoder gave the CPU’s bytes on its 81 decodes and 95 frame objects, with every graph’s unit chosen by measurement and every graph run on the device compared; wai.image.jpegai did not run, its inputs not being on these hostswai-ops-gpu/tests/, wai-ops-gpu/tests/narrow.rs, wai-rs/tests/ops_gpu.rs, wai-rs/tests/sink_decode.rs
wai-ops/1-i32 graphs on GPUs on the kernel text with the tiled kernels and before the read forms (§5, GPU): every shipped module meets the conditions of Claiming the tier on a GPU, item 3’s workgroup form (D76) included, which tests/wgsl_rules.rs rule 9 checks; a (transposed) convolution and an inverse GDN on the tiled kernels give the interpreter’s integers at the edges of the chunk bound and of the two-word bound, with the operator after them fused and not, and with tiling off; and the integer decoders, with their graphs on the device, give the CPU decode’s bytes or refusal codes, decoded in turn and pipelinedruns 10 to 12 of wai/research/ops-gpu-runs.txt, by hand on 2026-11-12 with rustc 1.99.1 and wgpu and naga 30.0.1, release builds: Metal on the integrated GPUs of an arm64 laptop and of a second arm64 desktop of the earlier generation (macOS 27.2.1), and Vulkan on Linux x86_64 on the adapter of PCI vendor 0x1002 (Mesa 26.0.8) and llvmpipe. On each, every test of wai-ops-gpu passed and cargo clippy --all-targets -D warnings was clean (on two hosts after one test’s lint was allowed, as the record states): the semantics suite gave WGSL’s result on all 231,690 guarded cases of 254,464; the probe agreed on every word of 1,051,757 cases; the corpus ran 813 vectors at acc32 and 1,426 at acc64 with narrowing on and off and with tiling on and off, 362 operators of 197 vectors on the tiled kernels, with no difference; the narrow kernels’ test ran its 192 graphs in 962 decodes, tiled and not, no difference; the tiled kernels’ test ran 185 graphs in 902 decodes (155 operators tiled, 56 with the operator after them fused, 21 of those an inverse GDN) as shipped, with the inverse GDN fused, with nothing fused and with tiling off, no difference; the 18 shader mutants, the 19 faults planted in the narrow and run-time kernels and the 14 planted in the tiled kernels were each caught, and tests/wgsl_rules.rs refused the tiled kernels with any one of their barriers taken out. wai-rs/tests/ops_gpu.rs decoded the committed vectors and refusal fixtures of the six capabilities §5 names, the two natural sets’ among them, and the world renderer’s two vectors with no difference, every graph compared with the interpreter, and a sequence of each natural set’s vector, four payloads drawn at other sizes and a copy of one cut short, pipelined, to the results of decoding them in turn; the native sink’s decoder gave the CPU’s bytes on its 82 decodes and 95 frame objects, and its start-up check caught each of five planted faults, a fold zero-extended in the tiled kernel among them; wai.image.jpegai did not run, its inputs not being on these hostswai-ops-gpu/tests/, wai-ops-gpu/tests/tile.rs, wai-ops-gpu/tests/wgsl_rules.rs, wai-rs/tests/ops_gpu.rs, wai-rs/tests/sink_decode.rs
wai-ops/1-i32 graphs on GPUs on the kernel text with the read forms and before the tiled convolution’s bound per tile and stage (§5, GPU): every shipped module meets the conditions of Claiming the tier on a GPU, item 3’s workgroup form (D76) included; a (transposed) convolution and an inverse GDN on the tiled kernels give the interpreter’s integers as the row above states, and an inverse GDN on igdn_tile and on igdn_r; what a run reads back, formed on the device, is the interpreter’s output: a picture’s bytes with the RGB8 step computed there, and an output’s channels one word an element, its input kept on the device between runs; and the integer decoders, with their graphs on the device, give the CPU decode’s bytes or refusal codes, decoded in turn and pipelinedruns 13 to 15 of wai/research/ops-gpu-runs.txt, by hand on 2026-11-12 with rustc 1.99.1 and wgpu and naga 30.0.1, release builds: Metal on the integrated GPUs of an arm64 laptop and of a second arm64 desktop of the earlier generation (macOS 27.2.1), and Vulkan on Linux x86_64 on the adapter of PCI vendor 0x1002 (Mesa 26.0.8) and llvmpipe. On each, every test of wai-ops-gpu passed and cargo clippy --all-targets -D warnings was clean: the semantics suite gave WGSL’s result on all 231,690 guarded cases of 254,464; the probe agreed on every word of 1,051,757 cases; the corpus ran 813 vectors at acc32 and 1,426 at acc64 with narrowing on and off and with tiling on and off, 362 operators of 197 vectors on the tiled kernels, with no difference; the narrow and tiled kernels’ tests ran as the row above states, no difference; the read forms’ test read 28 graphs as bytes with tiling on and off (56 decodes, 6 refusals), 16 channel reads of a resident input through eight versions, and 9 runs of an inverse GDN on each kernel, no difference; the 18 shader mutants, the 19 faults planted in the narrow and run-time kernels, the 14 in the tiled kernels and the 4 in the read forms (a rounding mode, a clamp, a plane order and a low-word range) were each caught, and tests/wgsl_rules.rs refused the tiled kernels with any one of their barriers taken out. wai-rs/tests/ops_gpu.rs decoded the committed vectors and refusal fixtures of the six capabilities §5 names and the world renderer’s two vectors with no difference, every graph compared with the interpreter (the syntheses read as bytes, the entropy network’s passes read by channel from a resident input), and the pipelined sequences as decoded in turn; the native sink’s decoder gave the CPU’s bytes on its 82 decodes and 95 frame objects, and its start-up check caught each of nine planted faults, the four in the read forms among them; wai.image.jpegai did not run, its inputs not being on these hostswai-ops-gpu/tests/, wai-ops-gpu/tests/out.rs, wai-ops-gpu/tests/wgsl_rules.rs, wai-rs/tests/ops_gpu.rs, wai-rs/tests/sink_decode.rs
wai-ops/1-i32 graphs on GPUs on this revision’s kernel text, the tiled convolution’s bound per tile and stage among it (§5, GPU): every shipped module meets the conditions of Claiming the tier on a GPU, item 3’s workgroup form (D76) included; a (transposed) convolution on the tiled kernel, each stage under the chunk its own tile’s inputs admit, gives the interpreter’s integers at the edges of the chunk bound (a fold every two channels, every two rows, and the 64-bit loop one tap short of a row), with one input past what one word holds in its products at each place that decides which bound a tile and a stage read, and across stages of different chunks, with the operator after it fused and not and with tiling off; a timed run reads the device’s time; and the integer decoders, with their graphs on the device, give the CPU decode’s bytes or refusal codes, decoded in turn and pipelinedruns 16 to 18 of wai/research/ops-gpu-runs.txt, by hand on 2026-11-12 with rustc 1.99.1 and wgpu and naga 30.0.1, release builds: Metal on the integrated GPUs of an arm64 laptop and of a second arm64 desktop of the earlier generation (macOS 27.2.1), and Vulkan on Linux x86_64 on the adapter of PCI vendor 0x1002 (Mesa 26.0.8) and llvmpipe. On each, every test of wai-ops-gpu passed and cargo clippy --all-targets -D warnings was clean (on the Linux host after one lint in the timing code was rewritten, as the record states): the semantics suite gave WGSL’s result on all 231,690 guarded cases of 254,464; the probe agreed on every word of 1,051,757 cases; the corpus ran 813 vectors at acc32 and 1,426 at acc64 with narrowing on and off and with tiling on and off, 362 operators of 197 vectors on the tiled kernels, with no difference; the narrow kernels’ test ran its 192 graphs in 962 decodes, tiled and not, no difference; the tiled kernels’ test ran 192 graphs in 1,159 decodes (162 operators tiled, 56 with the operator after them fused, 21 of those an inverse GDN) as shipped, with the inverse GDN fused, with nothing fused and with tiling off, no difference; the read forms’ test as the row above states, no difference; a timed run read the device’s time above 0 and a profiled run every dispatch’s, on every adapter; the 18 shader mutants, the 19 faults planted in the narrow and run-time kernels, the 20 in the tiled kernels (six of them in the bound per tile and stage: a stage’s bound missing its last channel, the map missing its region’s last column and the row only some phases read, a tile reading its neighbour’s bound, the map’s bound off by one bit, and the one-word sums not folded where the chunk changes) and the 4 in the read forms were each caught, and tests/wgsl_rules.rs refused the tiled kernels with any one of their barriers taken out. wai-rs/tests/ops_gpu.rs and the native sink’s decoder as the row above states, no difference, its start-up check catching each of its nine planted faults; wai.image.jpegai did not run, its inputs not being on these hosts. On decoded latents at 1280 × 768 and 1920 × 1088 (research/gpu-hd-decode.md §9.1), each tiled layer of both natural sets’ synthesis alone gave the interpreter’s integers on every element, and every drawn payload decoded with every graph on the device to the CPU’s bytes, on the Linux host’s GPU and the desktop’swai-ops-gpu/tests/, wai-ops-gpu/tests/tile.rs, wai-ops-gpu/tests/timing.rs, wai-ops-gpu/tests/wgsl_rules.rs, wai-rs/tests/ops_gpu.rs, wai-rs/tests/sink_decode.rs, wai_det_cost layers
wai.neural.int_hyper at full model scale with its graphs on a GPU, natively and in a page through its WebGPU (browser-sink §3): the keyframe decodes to the CPU decode’s bytes whether the decode runs its graphs on the device itself or has them answered from outside it (wai-rs int_ops::offload, the path a page’s WebGPU takes), and a floating-point product planted in the kernels and one changed weight each break the equalitytwo keyframes staged by int_hyper_keyframe_gpu stage from tools/wai_sota_int_synth_export.py’s exports of two 640×360 frames (decoded 640×320), each CPU decode equal to the export tool’s integer reference; then int_hyper_keyframe_gpu run on each adapter, both paths equal to the CPU’s bytes with both graphs on the device at acc64 and no device error, the planted product (acc64’s 16 × 16-bit partial product formed in f32, the probes left as shipped) refusing the decode, and the changed weight giving other bytes, the same on the device and the CPU. Run on 2026-11-09 with rustc 1.99.1 and wgpu 30.0.1, release builds: Metal on the arm64 desktop of the macos runner (gpu-metal-0, macOS 27.2); Vulkan on Linux x86_64 on PCI vendor 0x1002 (gpu-vulkan-1002) and llvmpipe; Vulkan on Linux arm64 on PCI vendor 0x10de (gpu-vulkan-10de) and llvmpipe. In a page (wai-web neural_webgpu, demo/verify_int_neural_webgpu.mjs, Playwright 1.60.0): headless Chromium 148 with --use-angle=metal on the same desktop opened its WebGPU adapter after the probe and the integer-semantics suite passed there and decoded the two keyframes, the committed int_hyper, int_hyper video and four int_synth vectors to their pinned digests on both of the page’s paths, every graph on the device; the planted product and the changed weight were caught on each of the three int_hyper cases. Playwright’s WebKit 26.4, headless and headed, offers the page no navigator.gpu, so it decoded every case on the page’s CPU path only, each to its pinned digest; no WebKit run of the WebGPU path is claimed. The decode times are recorded for dispatch only (browser-sink §4.6): the page’s measured times put the clip in its wasm leg on the WebGPU path and not on the CPU path, and §4.3 and §4.7 routed and chose accordingly in every casewai-rs/examples/int_hyper_keyframe_gpu.rs, wai-rs/src/int_ops_offload.rs, wai-web/src/neural_webgpu.rs, wai-web/src/neural_leg.rs, wai-web/demo/verify_int_neural_webgpu.mjs; the committed vectors in Chromium on the macos runner, .github/workflows/wai-ops-gpu.yml
wai-ops/1-npu graphs on a neural processor (wai/wai-ops-npu, §5): every graph vector of ops-conformance/ that npu.jsonl lists in the subset gives the committed outputs or refusal code, and the interpreter’s, with its arithmetic operators on the devicemeasured 2026-10-22 with rustc 1.98.0, release builds, on the source of the change that added this row, on the device §5 names (one compute core; the tile array’s open toolchain 1.4.3 with its core compiler 22.0.0, Linux 7.0 x86_64). The corpus (tests/corpus.rs) ran 733 vectors, 1,005 decodes, 32 of them refusals, with no difference; 302 of the vectors move data only. Each operand width (8-, 16- and 32-bit), the requantisation, the elementwise operators and lut16 ran on the device. The requantisation probe (tests/probe.rs) agreed with §2 on 786,432 cases at every shift from 0 to 63. Twelve edits of the kernel (tests/mutants.rs) were each caught by the corpus, among them each of the three roundings mapped to a neighbouring mode of the unit, and the shifts of 60 to 63 left to the unit’s shift-round step, which 36 vectors catch. Of the 458 graphs that fail the subset by acc32 alone, 110 gave other results on the device (tests/width.rs). wai-ops-npu.yml runs these tests on the linux-amd runner, which has this device, and fails when it is absent; this row records no forge run of it yetwai-ops-npu/tests/; ops-conformance/npu.jsonl; .github/workflows/wai-ops-npu.yml
wai.avatar.face (avatars §7.8), at generation-equivalence: the registered generator’s frames and a seeded generator’s are the same bytes on the CPU (macOS arm64), under wasm32-wasip2 and with every graph on a GPU (Metal, at acc64, every graph compared with the interpreter), and the corpus’s second implementation, in Python’s integers, gives the same frameswai-rs/tests/avatar_face.rs and avatar_face_verify.py (wai-conformance.yml); wai_avatar_face_vectors verify built for wasm32-wasip2 under wasmtime (the job avatar-face-wasip2); wai-rs/tests/avatar_face_gpu.rs (wai-ops-gpu.yml, metal). Run on the build host, macOS arm64, on 2026-10-22, for the change that registered it; no forge run is recorded herewai/live-conformance/avatar-face/

So at entropy-consistency, WAI’s JPEG AI symbol decode is demonstrated across architectures (x86_64 against arm64) once the distribution indices are given; the integer derivation of those indices is demonstrated against the reference on one machine, by a test CI does not run. At decode-equivalence, cross-architecture identity (x86_64 against arm64) is demonstrated for int_synth, integer video and int_hyper on committed small-scale vectors, and each of the three also decodes to its golden on Windows x86_64 (run 28636). wai.audio.int_codec and wai.splat.int_codec decode their committed vectors to the hashes a separate implementation computed, on Linux x86_64, Linux arm64 and macOS arm64 (run 745), and to the same goldens on Windows x86_64 (run 28636): cross-architecture identity (x86_64 against arm64) against one pinned hash per vector, on small vectors. For full-scale int_hyper, identity rests on construction, not on a cross-machine comparison of decoded output: CI checks its decode against the export’s integer reference on one machine per run. wai.neural.int_mlicpp’s committed vector decodes to the same pinned bytes on macOS arm64 and on wasm32-wasip2 (a 32-bit target), measured on the development machine; it also passed on the byte-exact matrix’s Linux x86_64, Linux arm64 and macOS arm64 legs in run 745. On GPUs, the committed vectors of int_hyper (and its video keyframe), int_codec audio and splat, int_synth and int_mlicpp decode with their graphs on the device to the CPU decode’s bytes on Metal, the adapter §5 lists that runs them, after it gave WGSL’s integer semantics on every guarded case, in the wai-ops-gpu workflow’s forge run 10236 (job 46928). On a neural processor, only the operator vectors have run (wai-ops-npu); no decoder runs its graphs there yet.

For the JPEG AI exact decoder’s pinned reconstruction (§5), identity across machines rests on construction, and on one comparison: a single codestream on the four platforms in the table. The construction is integer arithmetic for the integer stages and, for the float stages, only IEEE-754 basic operations, which are correctly rounded:

That the exact decoder’s gain scaler equals the reference decoder’s rests on margin, because the two compute it in different arithmetic. The scaler is exp((g + β) · log_k / 2⁷) rounded to 2⁻¹⁰. The exact decoder evaluates it in f64 with float_repro::exp, which was measured within 1 ULP of the host math library on the four platforms. The reference software evaluates it in float32: the log-domain gain as float32, times log_k rounded to float32, then the float32 exp of its tensor library, then rounding half to even. Neither exp is guaranteed to be correctly rounded. The inputs are exactly the normative gain tables, because the exact decoder refuses β ≠ 0.

tools/wai_jpegai_gain_exp_margin.py computes the exact value of both evaluations with 60-digit decimal arithmetic, over the gain tables exported from the reference software, and gates on the result at β = 0. It found the following for every entry of all eight tables:

So any float32 exp within 77 ULPs gives the reference the exact decoder’s scaler. The tool also fails unless the decoder’s log_k is the value the reference computes.

This does not extend to every β. The tool’s --beta-sweep option reports, without gating, all 5118 values of g + β that the tables and the 12-bit header field can produce. At four of them (1115, 1922, 2285 and 2289), the exact value of the reference’s evaluation lies within one float32 ULP of a boundary. There the reference’s own scaler depends on the last bit of its exp, so it can differ between the platforms the reference runs on. At 2285 and 2289 the exact value lies just above the boundary, a correctly rounded float32 exp lands exactly on it, and rounding half to even then gives the integer below it. At every g + β, the exact decoder’s formula gives the scaler that a correctly rounded float32 exp gives. The reference’s own expression, evaluated on the development machine (macOS arm64), also gave the exact decoder’s scaler at all 5118; its float32 exp there was at most 0.85 ULP from exact on those inputs. A decoder that implements β would still have to settle what the reference’s scaler is at those four inputs. This one does not implement β.

7. What exactness costs, and what WAI claims about it

7.1 The measured record (informative)

research/determinism-cost.md measures what decode-equivalence costs one capability, wai.neural.int_hyper, against the float model it is exported from: the pretrained mbt2018_mean at all eight published qualities, each checkpoint pinned by its SHA-256, coded and decoded by the library it is published with, on the 24 self-test pictures of the pinned reference set. Its readings are in research/determinism-cost/record.json, with the procedure that took them. Every figure below is followed by a marker naming its place in the record, and tools/wai_determinism_cost_verify.py, which shares no code with the tool that wrote the record, recomputes each from the readings and checks it, in CI.

Each figure holds for the pictures, models, platforms and builds the record names, and for nothing else (§7.2).

Two published records of float decode across devices are cited in §1. Neither is part of this record. arXiv 2608.00483 found its streams to decode only within the groups of GPUs its tests established (Table IV). arXiv 2606.28027 found its float reconstruction to diverge across devices unless it is resynchronised (§3.2), and its 8-bit integer decode not to be bit-exact across neural processors, for “non-standard implementations of rounding and multiplication in quantize/dequantize and re-quantization” (Supplement D.1).

What the record does not cover is listed in its §1: wai.image.jpegai’s exact decoder (one configuration, so one rate point and no curve; and the reference set was not coded with the standard’s reference encoder), wai.neural.int_synth and wai.neural.int_mlicpp (no float model with a rate axis), a neural processor (no decoder runs its graphs on one, §5), and the encoder.

7.2 What WAI claims, and what it does not