Why Colour Codes?

For many years, the surface code has been the de facto standard for quantum error correction. Qubits are arranged on a two-dimensional grid, and errors are detected by repeatedly measuring local parity checks between neighbouring qubits. Its appeal lies in its conceptual simplicity, strictly local interactions, and high error threshold. Notably, Google Quantum AI recently demonstrated surface-code quantum memories operating below threshold, where logical errors decrease as the code distance increases (Google Quantum AI 2023; Google Quantum AI and Collaborators 2025).

The surface code’s main drawback is the overhead of fault-tolerant logic. Even single-qubit logical Clifford operations typically require lattice surgery and careful scheduling, while T gates rely on costly magic-state distillation. As a result, large-scale surface-code architectures are expected to devote most physical qubits to producing and consuming magic states rather than storing data.

The colour code offers an attractive alternative. It supports transversal single-qubit Clifford gates with minimal overhead and is at the core of recent proposals for significantly reducing T-gate costs through magic-state cultivation (Gidney, Shutty, and Jones 2024). However, its adoption has been limited by the lack of fast, scalable decoders capable of operating accurately within the stringent sub-microsecond latency constraints of real-time quantum error correction.

Vibe decoding the colour code

In our recent paper (Koutsioumpas et al. 2025), we introduced the vibe decoder which, for the first time, demonstrates that colour codes can match surface code performance under a decoder with polynomial-bounded runtime. This method works by combining multiple Belief Propagation (BP) decoders, in an ensemble with OSD or LSD postprocessing (Hillmann et al. 2025). Each ensemble member is configured with a permuted schedule, with the aim of obtaining multiple possible solutions to the decoding problem for each syndrome; our scheme selects the best candidate solution and uses this as the prediction. In (Koutsioumpas et al. 2025), we outlined the algorithm and implemented proof-of-concept numerical simulations on a CPU, showing that the colour code decoded with the Vibe Decoder matches the performance of the surface code decoded with correlated minimum-weight perfect-matching algorithm from the PyMatching package (Higgott and Gidney 2025).

Vibe Decoding on a GPU

In recent months, we have been working with NVIDIA and Supermicro as part of the Grace Hopper Superchip Seed Programme. Our primary goal has been to make the Vibe Decoder fast enough to support sub-microsecond throughput for simulation and benchmarking of colour code architectures.

The GH200 GPU enables high parallelisation, allowing efficient memory-local operations. Our Vibe Decoder maps naturally to this parallel setting, as each BP decoder operates independently within the ensemble. We implement various optimisations to the BP message schedules, to ensure full use of the GPUs memory bandwidth, as well as implementing batching over shots.

In our timing tests and simulations, we used ensemble sizes of six, selected to optimally permute the decoding graph. The BP iteration depth was limited to six, with an early exit triggered at first convergence. Under these settings, the ensemble performs an average of two iterations up to colour codes of distance 9. While this configuration slightly reduces accuracy, its polynomially-bounded worst-case runtime (, where is the number of columns in decoding graph) and average throughput enable sub-microsecond decoding throughput for superconducting platforms up to distance 7. Further optimisations are under investigation.

Vibe Decoding Experimental Data

Recent demonstrations of colour codes on the Google Quantum AI Willow chip (Acharya et al. 2024; Bluvstein et al. 2025) mark a significant advance in quantum error correction. As part of our benchmarks, we evaluated our Vibe Decoder GH200 implementation on open-source experimental data from the Willow experiment. Without any training, our method matches the performance of the neural-network (Senior et al. 2025; Bonilla Ataides et al. 2025) and integer-programming decoders (Beni, Higgott, and Shutty 2025) reported in the original study, both of which were extensively trained on device-specific data. With device calibration and modest tuning of the ensemble, colour-code performance could approach that of surface codes, addressing one of the remaining obstacles to surpassing them experimentally.

Figure 4 summarises these results. The Vibe decoder achieves comparable error suppression between distance 3 and 5 colour codes to the more complex simplex (integer-programming) and neural-network decoders. By contrast, the Chromobius decoder (Gidney and Jones 2023), also shown in Figure 4 and previously the leading polynomial-time decoder for this setting, does not achieve error suppression on this dataset.

Figure 5 shows the average per-round decoding time, averaged over the batch, for the Vibe decoder. Microsecond decoding throughput is achieved for distance 3, 5, and 7 colour codes. At present, the closest competitor with comparable accuracy is the Tesseract decoder (Beni, Higgott, and Shutty 2025). As shown in Figure 5, it is currently around 900× slower for distance 5 and 7 codes.

Summary

Our results also indicate that NVIDIA GPUs are an excellent platform for decoder optimisation. The architecture offers massive parallelism that maps naturally onto ensemble decoding, delivers throughput far beyond what is practical on CPUs, and enables much faster development cycles than specialised targets such as FPGAs. This allows rapid iteration over algorithmic variants, memory layouts, and kernel-level optimisations while maintaining a clear path to practical real-time decoding performance.

Looking ahead, further performance gains are likely through additional kernel optimisation, improved memory locality, and tighter integration with hardware-specific features of modern GPU architectures. An especially promising direction is to move beyond batch-based decoding and explore GPU implementations designed for streaming operation. In such a setting, syndrome data could be processed continuously as it is generated by the quantum processor, enabling GPUs to operate as real-time decoders connected directly to QPU hardware through high-bandwidth interfaces such as NVQLink (Caldwell et al. 2025). This would open a practical pathway towards deploying GPU-based decoders in large-scale quantum computing systems.

The combination of the Vibe decoder’s algorithmic efficiency and GPU acceleration demonstrates that colour codes can now compete with surface codes not only in theoretical metrics but also in terms of decoding performance. With microsecond-scale throughput achieved on current hardware and a clear path toward further optimisation, colour-code quantum error correction is becoming a viable option for near-term fault-tolerant quantum computing architectures.

The decoding problem and the role of QPU–HPC integration

One of the greatest challenges in QEC is the real-time decoding problem. Stabiliser measurements produce a continuous stream of syndromes—binary bit-strings indicating where errors may have occurred. A classical decoder must infer the most likely error configuration and issue recovery instructions back to the quantum processing unit (QPU) before qubits decohere.

At scale, this becomes daunting: syndrome data rates are expected to reach terabits per second. Decoders must therefore be fast, accurate, and massively parallelizable. Achieving this demands tight QPU–HPC integration and efficient algorithms capable of leveraging modern accelerators like GPUs.

Trapping Sets in Belief Propagation Decoders

Low Density Parity Check codes (LDPC) are a promising candidate for error correction, as they require very low physical qubit overhead. They can be represented by a graph called a Tanner graph. Decoders like Belief Propagation (BP) work by passing messages along the edges of this graph to identify and correct errors.

However, a known weakness of BP decoders is their vulnerability to “trapping sets” (Raveendran and Vasić 2021)—small graphical structures, like short cycles, that can cause the algorithm to get stuck in a loop, failing to converge on the correct solution.

Circuit Level noise

To account for circuit-level faults, we use the superconducting qubit inspired Si1000 noise model (Gidney et al. 2021). Unlike a uniform baseline, Si1000 assigns different error rates by operation, with higher error probabilities for measurements, two-qubit gates, and idling during measurement/reset windows. These differences create a model more reflective of real hardware. The heterogeneous structure means decoders must contend with noisy syndromes and fault propagation across gates, not just independent flips—making circuit-level decoding substantially more challenging.

Designing decoding algorithms for GPUs

The QEC decoding problem is inherently well-suited to GPU acceleration. With platforms such as NVIDIA CUDA-Q and its QEC library (NVIDIA Corporation 2025), parallel decoding algorithms can be developed, benchmarked, and refined at pace, shortening the design cycle from theoretical models to practical, deployable protocols. CUDA-Q offers out of the box implementations of BP-OSD decoders.

Decoders also need to be versatile. In large-scale systems where logical information is actively manipulated, they must continuously update correlations between qubits in the logical register in real time. GPUs provide the flexibility to support this dynamic behaviour, offering a more adaptable solution than specialised hardware such as FPGAs or ASICs.

Automorphism Ensemble decoding

The core idea underpinning AutDEC is that instead of trying to decode on a single, potentially flawed graph, we can decode on many different, but equivalent, graphs at the same time in an ensemble.

An automorphism is a symmetry of the code; it’s a way of shuffling the qubits and check nodes without changing the fundamental structure of the code. Applying an automorphism effectively “rewires” the Tanner graph, changing its structure and potentially breaking the trapping sets that would pose problems to the decoder.

The ensemble method proceeds as follows:

• Take the initial error syndrome, .
• Create multiple, unitary-equivalent versions of the decoding problem ().
• Run an instance of the CUDA-Q BP-OSD decoder on each of these problems in parallel.
• Collect the results from all decoders and select the most likely correction from the list of candidates.

Because this process is highly parallelizable, it is perfectly suited for the massively parallel architecture of Graphics Processing Units (GPUs). The NVIDIA CUDA-Q QEC library allows us to leverage its batch processing utility to process all ensemble paths in parallel, making it a promising candidate for real-time decoding.

Results: Accuracy Gains and Reduced Iterations

We tested this architecture using the high-performance CUDA-Q BP+OSD decoder on bivariate bicycle codes, subjected to a realistic circuit-level noise model (Si1000). We compare AutDEC, configured with an ensemble size of 36 BP+OSD-0 constituent decoders - each limited to 500 BP iterations with OSD-0 - against two baselines which do not leverage GPU-accelerated automorphism ensemble decoding: (1) BP+OSD-CS10 with up to 500 iterations and order-10 combination sweep reprocessing, and (2) BP+OSD-CS10 with up to 1000 iterations and order-10 reprocessing. We highlight below some early results:

• >2x Higher Accuracy: By running multiple decoders in parallel, the probability of at least one of them avoiding a trapping set and finding the correct solution increases dramatically. This more than halved the logical error rate of the code, effectively doubling its accuracy.
• 50% Fewer Iterations: The ensemble approach requires significantly fewer iterations to reach a valid solution. We halve the number of iterations allowed for our decoder, making the process more efficient without compromising results.

Next steps

The automorphism ensemble improves the accuracy of any constituent belief-propagation (BP) decoder without increasing latency. In (Koutsioumpas, Sayginel, et al. 2025), it was shown that an Automorphism Ensemble Decoder using only BP, without any postprocessing, can achieve performance comparable to BP+OSD-0 but without the additional overhead. The NVIDIA CUDA-Q platform further enhances this by providing a fast implementation of Gaussian elimination and enabling high parallelization through batch processing, making OSD-based approaches far more attractive in terms of performance. Moreover, combining OSD-0 with our ensemble allows us to reduce BP iterations while boosting decoding accuracy.

Recently, a more efficient postprocessing method, called Localised Statistics Decoding (LSD), was introduced in (Hillmann et al. 2025). LSD parallelizes many of the traditionally sequential steps in OSD, significantly reducing latency. Building on this, we developed an ensembling strategy that combines a few serial-schedule BP iterations with LSD postprocessing, introducing a powerful new technique we call “Vibe” for colour codes (Koutsioumpas, Noszko, et al. 2025). VibeLSD delivers high accuracy, offers strong parallelizability, and is well-suited for GPU acceleration.

A key strength of ensemble decoding—especially on flexible hardware like GPUs—is the ability to integrate multiple decoding strategies within the ensemble to maximize performance. In future work, we plan to optimise the ensemble implementation further and explore the accuracy–speed trade-offs introduced by different decoder hyperparameters. Additionally, comparing or merging VibeLSD with AutDEC and other ensemble techniques on GPUs promises to unlock substantial additional performance gains.

Conclusion

The automorphism ensemble, when accelerated on GPUs through the CUDA-Q platform, marks a significant advancement toward practical quantum error correction. By overcoming the inherent limitations of traditional BP-based decoders, this approach unlocks higher performance from promising QLDPC codes, paving the way for more efficient and scalable fault-tolerant quantum computing.

References