Scroll down to Figure 1 in NVIDIA's post and there's a small asterisk next to d=31. Easy to miss. It's also most of the story, because the 347.7x logical error rate improvement everyone is quoting sits on an extrapolated point rather than a measured one. What NVIDIA actually shipped on July 13 is real, and it's properly open: an Apache 2.0 pre-decoder called Ising Decoder ColorCode 1 Fast that thins out error syndromes on a GPU before a classical decoder finishes the job. The engineering looks sound to us. We just think the number doing the rounds needs a footnote, starting with the part where none of this ran on a quantum computer.
The short answer
NVIDIA published Ising Decoder ColorCode 1 Fast on July 13, a 2.9M parameter CNN that sparsifies color code syndromes on a GPU before Chromobius decodes them. The claimed 347.7x logical error rate gain and 7.3x speedup are real results from NVIDIA’s own simulation, but the d=31 point they’re quoted at is extrapolated, the speedup pits a GB300 against a Grace CPU, and no quantum processor was involved. The code is open and the idea is good. The headline number is doing some work.
What NVIDIA actually shipped
Color codes have a reputation problem. They’re attractive on paper, because you can do all your Clifford gates transversally, which makes logical operations cheaper than the surface code equivalent. The catch has always been decoding. It’s hard, and it’s slow, and if you can’t decode in real time while the algorithm runs, none of the elegance helps you. So color codes got shelved.
That’s the problem Ising Decoder ColorCode 1 Fast goes after. It’s a 3D CNN, 17 layers, receptive field of 13, about 2.9 million parameters, trained on 13x13x19 input volumes. It reads the syndrome map, resolves the easy localized stuff on the GPU, and passes a thinner map to Chromobius. Chromobius still does the actual decode.
That last part matters and gets lost in most of the coverage. This isn’t a replacement decoder. It’s a filter bolted to the front of one.
The asterisk
Here’s the bit we didn’t expect. NVIDIA’s Figure 1 plots logical error rate against runtime for code distances 5, 9, 13, 17, 21 and 31, for raw Chromobius against the combined pipeline. The measured distances are filled dots. Both d=31 points are hollow circles with error bars, labelled d=31*, and down in the corner the legend spells out what the asterisk means: extrapolated.
So the 347.7x and the 7.3x, the two numbers in the headline and in every writeup we read, come from the one distance on the chart that nobody measured.
To be fair to NVIDIA, they labelled it. It’s in their own figure, plainly marked, and the measured points from d=13 up do trend the right way. Extrapolating a decoder curve is a normal thing to do. But there’s a difference between “the trend suggests roughly this” and a precise-looking 347.7x in a headline, and the second one is what travelled.
One more wrinkle we couldn’t fully resolve: the chart is plotted at p = 0.001, while the headline claim cites a physical error rate of 0.3%. The sample code in the post has the same tension, a comment saying 0.3% above a call passing p_error=1e-3. There may be an si1000 scaling convention that reconciles those, and honestly I might be missing something obvious here, but we couldn’t make the two line up from the post alone.
Image: NVIDIA Developer Blog, Figure 1. Note the hollow d=31* markers on both curves and the “extrapolated” note in the lower right.
The GPU against the CPU
The 7.3x runtime figure needs its own note, and again NVIDIA is upfront about it in the caption: the Fast model ran on a DGX GB300, and Chromobius ran on a Grace Neoverse-V2 CPU.
That’s a GPU system measured against a CPU. Part of the gap is the pre-decoder doing clever work, part of it is just silicon, and NVIDIA doesn’t publish the split. We’d want to see Chromobius given a fair shake on comparable hardware before treating 7.3x as an algorithmic result. It might still hold up. We just can’t tell from what’s published.
Where it stops helping
Look at the left side of that chart. At d=5, the combined pipeline sits around 20 microseconds per round while raw Chromobius does the same job in about 1. The pre-decoder makes things worse at small distances, and considerably so. The curves cross near d=13, which is exactly what NVIDIA says: the benefit shows up around distance 13 and grows from there.
Which lands us on the practical question. Nobody is running d=31 triangular color codes on real hardware today. Not close. So the regime where this pays off is a regime the field hasn’t reached yet, and the regime we’re actually in is the one where the pre-decoder costs you time.
That’s not a knock on the work. Decoders have to exist before the hardware needs them, otherwise you get the color code situation all over again, a good code with no way to run it. Building the decoder early is the point.
The genuinely good part
The openness isn’t marketing. It’s Apache 2.0 on GitHub at NVIDIA/Ising-Decoding, with weights, training recipes, the synthetic data tooling built on cuQuantum and cuStabilizer, and a full training pipeline. The pitch is that you retrain it against your own QPU’s noise profile rather than taking NVIDIA’s model as-is, which for a decoder is the right pitch. Noise is hardware-specific.
Worth knowing before you clone it: the pre-trained weights posted so far are the surface code models, Ising-Decoder-SurfaceCode-1-Fast and -Accurate, and they’re access-gated behind a Hugging Face login. The repo also notes that color code offline decoding from .dets files isn’t implemented yet, and that Triton, which torch.compile wants, doesn’t run on native Windows. Plan for WSL or Linux.
So: a real contribution, openly licensed, with a headline that’s ahead of its own data. I’d rather have this than another closed benchmark table. And if you work on QEC, the training pipeline is probably more valuable to you than the 2.9M parameter model it ships with.
If you’re here because the quantum headlines have you wondering about your own systems, the thing that actually deserves your attention this year isn’t decoders, it’s post-quantum TLS and why ML-DSA is the signature to ship. That one has a migration path and a calendar. This one has a chart with an asterisk.
Sources
- NVIDIA Technical Blog, “NVIDIA Ising Decoding Cuts Color Code Logical Error Rates by Over 300X”, July 13, 2026, including Figure 1 and its caption.
- NVIDIA/Ising-Decoding on GitHub, for the Apache 2.0 license, the posted model list and the README caveats.
- The Quantum Insider, July 15, 2026.
- Quantum Computing Report, for the si1000 noise model and benchmark conditions.
Frequently asked questions
What is NVIDIA Ising Decoder ColorCode 1 Fast?
It's a small neural network that sits in front of a classical quantum error correction decoder. NVIDIA published it on July 13, 2026. It's a 3D convolutional network, 17 layers and roughly 2.9 million parameters, trained to clean up the easy localized errors in a triangular color code syndrome map on a GPU. Whatever is left gets handed to Chromobius, the existing open source color code decoder, which does the final decode. It replaces nothing. It just hands the real decoder a smaller problem.
Is the 347x logical error rate improvement real?
It's NVIDIA's own simulated result, and the specific d=31 comparison behind it is extrapolated. In Figure 1 of NVIDIA's post, every measured code distance from 5 to 21 is drawn as a filled dot, while both d=31 points are hollow circles carrying error bars, and the legend labels them as extrapolated. So 347.7x is a projection from the measured trend, not a run someone benchmarked end to end. The direction of the trend is well supported by the measured points. The exact headline multiple is not.
Did any of this run on a real quantum computer?
No. Everything is simulation. NVIDIA generates synthetic syndrome data with its cuStabilizer library inside cuQuantum, under the si1000 circuit level noise model, and trains and benchmarks against that. No QPU is involved anywhere in the pipeline. That isn't a scandal, it's how decoder research normally works, but it does mean the numbers describe a model of a quantum computer rather than a quantum computer.
Is the 7.3x speedup a fair comparison?
Only partly, and NVIDIA says so in its own figure caption. The Ising pre-decoder ran on a DGX GB300 while the Chromobius baseline ran on a Grace Neoverse-V2 CPU. Some of that 7.3x is the algorithm and some of it is simply the hardware gap between a modern GPU system and a CPU. NVIDIA doesn't publish a GPU-to-GPU comparison, so we can't tell you how the split breaks down.
Should I do anything about this today?
Almost certainly not, unless you build QEC decoders for a living. The benefit only appears above roughly code distance 13, and below it the pre-decoder is a net loss on runtime. Nobody is running d=31 triangular color codes on real hardware right now. If you do work in this area, the weights and the full training pipeline are on GitHub under Apache 2.0 and worth a look. For everyone else this is a research milestone, not a thing to action.
