---
title: "Alice & Bob Decodes Cat-Qubit Error Correction on GPUs with Quantum Machines via NVIDIA NVQLink"
date: "2026-11-11T15:04:38+00:00"
url: "https://www.quantum-machines.co/resources/blog/alice-bob-ldpc-cat-codes-gpu-decoding-nvqlink/"
description: "Alice & Bob decoded LDPC-cat codes on GPUs via NVIDIA NVQLink, using Quantum Machines’ OPX1000 and Open Acceleration Stack. See the results and what’s next."
---

# Alice & Bob Decodes Cat-Qubit Error Correction on GPUs with Quantum Machines via NVIDIA NVQLink

Writers

![Unnati Akhouri](https://www.quantum-machines.co/wp-content/uploads/2026/05/Unnati-150x150.jpeg.webp)

#### Unnati Akhouri

Unnati Akhouri is a Product Solutions Physicist at Quantum Machines, specializing in the intersection of quantum theory and hardware control. She holds a PhD from Penn State and a Master’s from Oxford, with deep expertise in open quantum systems and qubit decoherence. As a dedicated science communicator, she is the creator of the “Bit, Byte, and Nibble” series and the “Fatal Physics” comics, which aim to simplify complex concepts of quantum computing and fundamental physics into easily understandable and entertaining content.

Blog November 2026 | 5 min read

![](https://www.quantum-machines.co/wp-content/uploads/2026/11/Decoding-Cat-Qubit-Error-Correction-on-GPUs_-Alice-Bobs-First-Step-with-NVQLink-1-1024x568.png.webp)

Alice & Bob has [decoded its LDPC-cat error-correcting codes](https://alice-bob.com/newsroom/alice-bob-decodes/) on GPUs via [NVIDIA NVQLink](https://www.nvidia.com/en-us/solutions/quantum-computing/nvqlink/), using Quantum Machines’ OPX1000 and Open Acceleration Stack. This proof of concept addresses a question every error-corrected quantum computer will face: can decoding capacity grow with the machine? Let’s explore the results Alice & Bob have put out.

## Why does decoding set the pace of error correction?

Errors are inevitable and accumulate throughout a computation, so they must be detected and corrected in real time. In a stabilizer code, that means repeatedly measuring syndromes. A classical decoder then uses those syndromes to infer the most likely errors, so their effect can be undone when interpreting the results. Pauli corrections can be tracked and applied at the end, so a backlog can build for a while. Non-Clifford operations such as T gates are less forgiving: the decoded outcome determines whether a corrective S operation is required, so decoder results must be available before the computation can proceed.

The catch is timing. The decoder must keep up with the rate at which syndromes arrive; otherwise, a backlog of unresolved correction information accumulates. While Pauli-frame updates can be deferred for some time, non-Clifford operations eventually require the decoded result, creating a latency constraint on the decoder.

For realistic superconducting architectures, controller-decoder closed-loop latencies must remain in [the tens-of-microseconds range](https://www.quantum-machines.co/resources/blog/non-clifford-fault-tolerant-control/). As systems scale, the decoding workload also grows because each error-correction round produces syndrome data from an increasing number of physical qubits.

![](https://www.quantum-machines.co/wp-content/uploads/2026/11/image-3.png.webp)

The Open Acceleration Stack connects classical accelerators (GPUs, CPUs and FPGAs) to the OPX1000, which controls the QPUs, with a 4 µs round trip

This is an engineering problem. With one logical qubit, decoding is a manageable task. At the scale of a fault-tolerant machine, it becomes a latency and throughput problem that a classical processor sitting next to the controller has to solve. That is where GPUs come in: built for parallel throughput, they are a natural fit for decoding many syndromes at once, so if they can be woven into the control loop, decoding capacity can grow with the machine.

## What did Alice & Bob show?

Cat qubits suppress one class of errors in hardware, so the outer code can concentrate on the other. Alice & Bob’s LDPC-cat codes combine [cat qubits](https://www.nature.com/articles/s41467-025-56298-8) with 2D low-density parity-check codes, aiming for low-overhead fault tolerance. Last year they laid out the architecture and theory for this. Now they have shown it in operation by moving the decoding data from the control electronics to a GPU.

NVIDIA NVQLink and the OPX1000 make that possible. The team ran the decoding on synthetic data to test. The French cat-qubit pioneers [report](https://alice-bob.com/newsroom/alice-bob-decodes/) this as the first time LDPC-cat codes have been decoded on GPUs through NVQLink.

But as with most research, answers only lead to more questions. The team also found that batching pays off. Decoding many syndromes together makes latency grow sublinearly, compared with decoding them one at a time, so the time per syndrome falls as the batch grows. From a control point of view, that is promising. Larger machines produce more syndromes, and the GPU will get more efficient as it is given more to do at once.

The result shows that GPU decoding of these codes is feasible over a low-latency link, and that batching helps. The next step is to do this live, with real data, which will require the path from controller to GPU to be optimized to match the machine’s cycle time.

## What does the controller have to do?

At Quantum Machines, we envision the [Open Acceleration Stack](https://www.quantum-machines.co/solutions/open-acceleration-stack/) (OAS), which interconnects OPX1000 with classical accelerators as a capability that unlocks many avenues. A kernel on the server decodes the syndromes and returns corrections to the OPX1000 with bounded latency. The stack is NVQLink-compliant, and supports [NVIDIA CUDA-Q](https://developer.nvidia.com/cuda-q), [CUDA](https://developer.nvidia.com/cuda/toolkit), C++ and Python. It keeps the round trip between accelerator and QPU at 2-4 µs, which leaves most of a decoding budget of the order above to the decoder itself.

In the Alice & Bob setup, the OPX1000 streams synthetic syndromes and decoded results via the OAS. At Academia Sinica, the OPX1000-NVIDIA GH200 stack lets a reinforcement-learning agent [calibrate a two-qubit CZ gate in about 25 seconds](https://www.quantum-machines.co/resources/blog/reinforcement-learning-two-qubit-gate-calibration/), compared with roughly 15 minutes by hand. For neutral atoms, the OAS enabled [closed a readout-to-correction loop in about 460 µs](https://www.quantum-machines.co/resources/blog/classically-accelerated-readout-neutral-atoms-cpu-gpu-readout/) in a benchmark on a 10×10 array.

The modalities may be different, but the architecture adapts to the workloads running on it. Taken together, these results point to the growing demand for leveraging classical compute in quantum workflows, across a hierarchy of timescales and compute resources.

We are glad to be enabling this path, and glad to see Alice & Bob build on this capability. We await their next milestone: real-time decoding of LDPC-cat codes. If you are building error correction on any modality and want to see what the Open Acceleration Stack can do for your decoder, request a demo.