NVIDIA Simulates Record 104-Qubit Fault-Tolerant Protocol on JUPITER

NVIDIA announced on October 19, 2026, what it described as a record-breaking quantum computing simulation on JUPITER, Europe’s first exascale supercomputer: a 104-qubit run executed on 8,192 NVIDIA GH200 GPUs at Jülich Supercomputing Centre that models how a realistic quantum processor performs fault-tolerant computation.

What NVIDIA Says the Run Validates

NVIDIA describes the 104-qubit simulation as the largest comprehensive simulation of a fault-tolerant quantum processor to date, saying no prior simulations have modeled quantum processors in such full detail. According to the company, the run validates magic-state cultivation, an approach to fault-tolerant quantum computing that requires 90% fewer physical qubits than previous methods. NVIDIA said simulations at this fidelity give researchers the data needed to predict the performance of future designs before they are built, reducing reliance on hardware trial and error, and pointed to expected applications in drug discovery, financial modeling and materials science.

“Useful quantum computing will require fantastically complex, fault-tolerant systems — and understanding how they behave at scale is essential to building them,” Jensen Huang, founder and CEO of NVIDIA, said in the company’s announcement. Huang said the Jülich results show that quantum processors and GPU supercomputers can work together on research that would otherwise be out of reach.

Kristel Michielsen, director of the Jülich Supercomputing Centre at Forschungszentrum Jülich, said Europe’s investment in JUPITER gives researchers the ability to investigate questions that were previously beyond reach, and that the collaboration with NVIDIA brings that capability to quantum computing. She said the work helps scientists make better-informed decisions about the designs most likely to deliver useful applications.

Magic States, Codes and a Realistic Noise Model

Qubits operate at the limits of physics, and the interactions needed to control them introduce unavoidable, error-inducing noise, NVIDIA’s announcement explains. Computing in the presence of that noise, known as fault-tolerant quantum computing, requires magic states, a specific arrangement of qubits that is continually consumed during a fault-tolerant computation. Because fault-tolerant machines rely on repeatedly producing magic states, any optimization in how they are made sharply reduces the difficulty of building a useful quantum computer.

A technical post from NVIDIA’s CUDA-Q team details why such simulations are hard. Many operations used in quantum error correction are Clifford operations, which can be simulated efficiently under suitable noise assumptions, but universal quantum computation requires at least one additional non-trivial operation, the ingredient magic states supply. The simulated protocol prepares a state in a small error-correcting code, checks it for faults and grows it to larger code distances: it starts with a distance-3 color code, uses recently designed flag measurements to detect harmful faults, and grows into a distance-7 hybrid color and surface code configuration before further error-correction rounds and readout. The 104 qubits counted include the data and auxiliary qubits used across that sequence.

According to the technical post, the model executed on JUPITER includes coherent phase errors, which can accumulate and interfere, and leakage, in which a superconducting qubit leaves its usual two computational levels. Selected physical sites are modeled with a third energy level, significantly increasing the complexity of the simulation. Those mechanisms let researchers examine behavior beyond a model of random bit and phase flips while retaining the actual non-Clifford operations that prepare the magic state.

The work differs from earlier Jülich research that simulated 50 qubits under ideal, noiseless conditions. Forschungszentrum Jülich announced on November 11, 2025, that a Jülich team working with NVIDIA experts had fully simulated a universal 50-qubit quantum computer on JUPITER, which was inaugurated at Forschungszentrum Jülich in September 2025, surpassing a 48-qubit record Jülich researchers set in 2019 on Japan’s K computer. That announcement noted that each additional qubit doubles computing and memory requirements, putting a 50-qubit simulation at around 2 petabytes of memory.

From a Development Cluster to 8,192 GPUs

Because memory requirements grow exponentially with qubit count, large-scale simulations sit beyond the reach of conventional computing systems, NVIDIA said. An NVIDIA GB200 NVL72 system at the NVIDIA Accelerated Quantum Research Center served as the development platform for the JUPITER project, allowing researchers to scale tests from four GPUs to hundreds before moving to 8,192 GPUs on JUPITER, which was built by Bull. The team used the center to refine simulation methods, compare results with JUPITER and study how accuracy scaled with additional computing resources, work NVIDIA says reduced a weekslong simulation effort to days.

The technical post describes the engineering behind the run. The simulator reorganizes operations while preserving their dependencies and measurement statistics, and it reuses storage as qubits are measured and released. It packs groups of three-level systems into a binary representation that cuQuantum’s cuStateVec library can execute: five three-level systems have 243 basis states and fit within eight binary storage bits, which provide 256 entries. In the 8,192-GPU configuration, a 45-bit encoded register represents approximately 35.2 trillion complex amplitudes, and in double precision the state alone occupies 512 TiB of distributed GPU memory, or 64 GiB per GPU.

The simulations ran using NVIDIA cuQuantum software and the CUDA-Q platform’s fault-tolerant logical layer to express the magic-state circuit. The project also developed distributed factorization tools using NVIDIA cuBLASMp and cuSOLVERMp, which examine selected partitions of the stored state to investigate how much information a more compact representation must retain, creating a route to test approximate simulation methods against a detailed state-vector reference.

In small packed-circuit validation cases at the research center, independent state-vector and tensor-network calculations agreed on measurement probabilities to approximately 10⁻¹³ when the tensor-network truncation threshold was tightened, the team reported. Smaller runs serve as a yardstick for estimating GPU requirements and GPU-hour budgets before committing supercomputing time, and the team said the same approach can support future studies with different leakage models, circuit schedules and error-correction protocols, each checked at manageable scale before being extended to larger configurations.