The same score. Two machines. Different bytes.

Reproducibility is not one property

Hand one score to two orchestras. Nobody argues about whether it is the same work, and no two recordings are identical. If your test for same work is the recordings move the air identically, no performance ever passes.

Software has the same shape. The usual check hashes the rendered audio and compares the hash, which answers whether two files hold the same bytes. It is read as though it answered whether they sound the same. It does not.

So the kernel splits the question and gives each half its own guarantee.

Layer 1 · realization — byte-identical everywhere measured

The events a score becomes, across two architectures, two operating systems and three audio backends. Same events, same resource bindings, same output length. This layer can be signed and promised.

Layer 2 · audio — identical on no pair of hosts

Byte-identical for repeated renders on one machine, and on no cross-host comparison we have. On the pair whose renders we kept, samples differ by one unit on 0.02 % of the total. Inaudible, and real.

Which instrument reaches which relation

The word identical was doing duty for six different questions. Separating them is most of the work, and the last row is the one worth reading twice.

relation	holds when	instrument	our result
source identity	the input score is the same bytes	export manifest, archive record	by construction an input rather than an output
event identity	the realized events are the same values	realizationDigest	holds on every host measured
PCM structure	channels, rate, frames and byte length agree	wavBytes, structural fields	holds everywhere, including the host whose samples diverged
PCM identity	rendered samples are byte-equal	wavDigest	fails across hosts, holds on each measured host
numeric proximity	samples differ, bounded	sample diff, RMS, correlation, envelope	measured one host pair, 1 unit on 0.02 % of samples
perceptual equivalence	a listener cannot tell	not instrumented	not claimed anywhere

A digest decides the fourth row and nothing else. On a mismatch it proves the bytes differ, and says nothing about by how much, why, or whether anyone could hear it. Reading it as an answer to the last two rows is the mistake this kernel is built to stop.

The paper

Everything above is written up, submitted, and archived with the artefacts a reader needs to check it.

Re-derivable by a Stranger: Determinism and Per-Event Origin in an Agent-Authored Music Pipeline
Submitted to ICLC 2027 · under review

For rendered audio we checked ours with a checksum, which decides only whether two files hold the same bytes. It cannot reach audibility, and we had read it as though it could.

Reproducibility separates into two layers with different guarantees, and that separation is the main result. The realization layer is identical across two architectures, two operating systems and three audio backends. The audio layer is byte-identical on one host and identical on no pair of hosts, differing by one unit on 0.02 % of samples.

The distance between what a check states and what its mechanism distinguishes is a debt, and we use it to audit eight of our own checks and a Strudel case study.

The paper reports eight checks of our own whose stated scope exceeded what their mechanism could distinguish, and turns the same lens on Strudel, the most used system in its ecosystem. Three observations went to its maintainers before submission.

Check it yourself

The engine and both reference works are archived under permanent identifiers. One command fetches the digest-pinned banks, renders the reference score and compares what it got against what was published.

git clone --branch v1.0.0-iclc2027 --depth 1 \
  https://github.com/Alodai/music-render.git && cd music-render
pnpm install && pnpm reproduce

It exits non-zero on any mismatch and prints obtained against expected. Two developers outside the project have run it on machines we do not control. One reproduced all eight checks. One did not, and that run is written up rather than buried.

Why it holds up

We do not sell it is reproducible. We sell it is reproducible at this layer, with this evidence, and at the other layer the difference measures this much.

A system that states its limits with numbers is harder to knock down than one promising perfection. When someone objects that the audio does not match across machines, the answer is already written, measured and published.