Deterministic Execution
Ayrıca şöyle anılır determinism, bit-exact execution
Deterministic execution means a program produces exactly the same output from exactly the same input, every single time, regardless of which machine runs it, how many CPU cores it has, or what order its threads happen to execute in. It sounds like it should be the default, computers are supposed to be predictable, but it isn't automatic. Different CPUs can round floating-point numbers slightly differently, different image or audio decoders can produce slightly different pixel or sample values from the same file, and multi-threaded code can produce different results depending on which thread finishes first. Any of those, left unguarded, can make "run the same program twice" quietly stop being true.
That gap matters enormously the moment two different parties need to agree on a result without trusting each other. It's the entire reason every blockchain's transaction-execution engine, Bitcoin's Script, Ethereum's EVM, is built to be strictly deterministic: if node A and node B could honestly compute two different results from the same transaction, the network could never agree on what happened, and consensus collapses. The same requirement resurfaces in a newer setting, networks that dispatch AI inference jobs to independent operators and then compare results to catch cheaters (see Verifiable Off-Chain Compute), because that comparison is worthless if two honest operators can legitimately disagree.
Where it comes from
The formal foundation is Fred Schneider's 1990 paper on the state-machine replication approach to fault tolerance, which established that a distributed system can only stay consistent if every replica processes the same inputs deterministically. Blockchain virtual machines inherited that requirement directly. The DePIN and verifiable-compute space, networks like io.net and Akash that spot-check work across independent, mutually distrusting operators, applies the same underlying requirement to a newer problem: ML inference, not transaction execution. None of this theory or practice originates with Solidus.
Solidus status
Solidus ran directly into this problem building its compute network, and the fix is shipped and specific. The node software that decodes a media payload (a cropped face image) before feeding it to an inference model originally risked using a JPEG decoder, and different CPUs' JPEG decoders pick different IDCT and color-conversion code paths based on runtime CPU capability (AVX2 vs. NEON vs. scalar), producing slightly different decoded bytes on different machines from the identical file. In a network that compares one operator's output against a reference to catch cheating (see Anti-Cheat Precondition), that's not a cosmetic bug: it means two honest operators on different hardware could decode the same input differently, produce different embeddings, and get one of them wrongly flagged as a cheat. The fix: the JPEG codec is compiled out entirely (a disabled Cargo feature, not a comment), the media codec is restricted to PNG, lossless and byte-identical by format, regardless of which CPU decodes it. The image-resampling filter is pinned in source with an explicit warning against changing it silently, and the image-decoding library's version is pinned exactly in the workspace manifest, because even a routine dependency bump could shift decoded bytes by a bit and split a mixed-version operator fleet.
Proof: gpu-node/apps/gpu-node/crates/solidus-gpu-node/src/codec.rs in
the public solidusnetwork/protocol repository is readable by anyone. The
file's own comments state the reasoning directly: "Two nodes handed the
same route and the same payload must produce BIT-IDENTICAL tensors, or the
canary / spot-check comparison that keeps operators honest starts flagging
honest nodes", a rare case of the determinism requirement being documented
in the exact place it's enforced, not just asserted after the fact.
Nereden geliyor
Bunu başkası belirtti. Solidus bir araya getiriyor.
Deterministic execution means the same input, run through the same program, produces the exact same output, every time, on every machine, down to the bit, with no room for a different CPU, a different thread schedule, or a different floating-point rounding mode to sneak in a different answer. It's a foundational requirement of distributed-systems theory (state-machine replication, formalized by Fred Schneider's 1990 paper "Implementing Fault-Tolerant Services Using the State Machine Approach") and it is, concretely, why every blockchain virtual machine, Bitcoin's Script, Ethereum's EVM, is built to be deterministic: if two honest nodes could compute two different results from the same transaction, consensus itself breaks. Verifiable-compute and DePIN networks (see Verifiable Off-Chain Compute) apply the identical requirement to a newer problem, comparing one operator's AI-inference output against another's to catch cheating only works if two honest operators are guaranteed to compute the same answer. Solidus did not invent the requirement; it enforces it in its own compute pipeline.
Bunu nasıl doğrularsınız
Bugün üretimde çalışıyor.
Public, checkable in source: gpu-node/apps/gpu-node/crates/solidus-gpu-node/src/codec.rs in the public solidusnetwork/protocol repository pins the resampling filter, restricts the compiled-in image codec to PNG only (deliberately excluding JPEG, whose decoder is not bit-identical across CPUs), and pins the image-decoding library to an exact version, with the reasoning documented directly in the file's own comments.