Nvidia Simulates 104-Qubit Fault-Tolerant Quantum Computer on JUPITER

A record simulation, not a new quantum chip

Nvidia’s latest quantum-computing milestone is easy to misread. The company has not announced a 104-qubit physical quantum processor, nor has JUPITER become a quantum computer. Instead, Nvidia and researchers at the Jülich Supercomputing Centre used JUPITER, Europe’s first exascale supercomputer, to run what Nvidia describes as the largest comprehensive simulation to date of a fault-tolerant quantum processor [1]. The simulated system spans 104 physical qubits and focuses on how a realistic error-corrected quantum design behaves when hardware noise is included [1].

That distinction matters. Quantum hardware remains fragile: qubits are disturbed by control errors, environmental noise and device imperfections. Fault-tolerant quantum computing is the effort to keep computation reliable despite those errors, usually by encoding information across many physical qubits and constantly detecting or suppressing faults. Nvidia’s result is therefore not a demonstration of quantum advantage on a quantum machine. It is a high-fidelity classical simulation of one of the hard pieces future quantum computers will need to perform [2].

The work was announced on October 19, 2026, and was reported more broadly on October 21 by The Next Web, which emphasized that the full run used 8,192 Nvidia GPUs at Germany’s Jülich Supercomputing Centre and modeled real hardware noise rather than idealized, noise-free conditions [3]. Nvidia says the simulation gives researchers a way to test design choices before expensive quantum hardware is built [1].

Why magic states are the focus

The technical target was magic-state cultivation, a method for preparing special quantum states needed for universal fault-tolerant computation [1]. In many error-corrected architectures, a large class of operations called Clifford operations can be handled comparatively efficiently, but universal quantum computing requires additional non-Clifford resources. Magic states supply those resources and are consumed as a computation proceeds [2].

That consumption creates a bottleneck. If a useful quantum computer must constantly manufacture high-quality magic states, then the cost, reliability and qubit overhead of that process become central engineering questions. Nvidia says the approach it simulated can use 90% fewer physical qubits than previous methods, which is why validating the process under realistic noise is presented as a major step for quantum-system design [1].

The simulation did not merely ask whether an abstract mathematical circuit works. According to Nvidia’s technical account, it modeled a magic-state preparation protocol that begins with a distance-3 color code, uses additional flag measurements to detect harmful faults, and grows into a distance-7 hybrid color/surface-code configuration before later correction and readout steps [2]. The 104-qubit count includes both data qubits and auxiliary qubits used across that sequence [2].

What JUPITER contributed

JUPITER’s role was classical muscle. Nvidia says the largest run used 8,192 Nvidia GH200 GPUs to model the 104-qubit magic-state preparation protocol [2]. The Jülich machine provided the scale needed to represent the evolving quantum state while also incorporating noise mechanisms that make the calculation far more difficult than a simplified stabilizer-style model [2].

The memory requirements explain why this is a supercomputing story as much as a quantum-computing story. Nvidia’s technical blog says the simulation used a 45-bit encoded register representing about 35.2 trillion complex amplitudes; in double precision, the state alone occupied 512 TiB of distributed GPU memory, or 64 GiB per GPU [2]. Quantum Computing Report summarized the same infrastructure profile, noting the use of 8,192 GH200 Grace Hopper superchips, a 45-bit encoded state vector and 512 TiB of distributed GPU RAM [4].

The software stack was equally important. Nvidia says the simulations used cuQuantum for optimized performance and scaling, while CUDA-Q’s fault-tolerant logical layer expressed the magic-state circuit [1]. The technical account adds that the team used cuStateVec, packed three-level systems into binary storage and developed distributed factorization tools using cuBLASMp and cuSOLVERMp [2]. Those details are not incidental: they show that the advance comes from a combination of hardware scale, memory organization, circuit rewriting and numerical analysis.

More realistic noise than earlier work

A key claim is that this run moved beyond idealized simulation. Nvidia says earlier Jülich research simulated 50 qubits under ideal, noiseless conditions, while the new 104-qubit work simulates magic-state cultivation under realistic hardware noise [1]. The Next Web likewise framed the new result as a follow-up to prior 50-qubit work that did not include real noise effects [3].

The noise model matters because fault tolerance is ultimately about how physical errors propagate. Nvidia’s technical description says the JUPITER model includes coherent phase errors, which can accumulate and interfere, and leakage, where a superconducting qubit escapes the usual two-level computational subspace [2]. To capture leakage, selected physical sites were modeled with a third energy level, increasing the complexity of the simulation [2].

This is why the run is more than a larger qubit number. A 104-qubit simulation under a simplified error model would answer a different and less useful question. By including coherent errors and leakage, Nvidia and Jülich are trying to probe the specific imperfections that hardware designers must manage. The result gives researchers a controlled reference for studying how faults move through the magic-state preparation circuit and which error-control choices matter most [2].

The development pipeline: NVAQC to exascale

Nvidia also used the announcement to highlight a workflow for future quantum simulations. Before the biggest JUPITER jobs, researchers developed and tested the approach at the Nvidia Accelerated Quantum Research Center, using an Nvidia GB200 NVL72 system to scale experiments from four GPUs to hundreds [1]. Nvidia says that preparation helped reduce a weekslong simulation effort to days and allowed the team to compare results with JUPITER while improving the simulation methods [1].

That staging process is important because access to exascale systems is limited. A team cannot casually launch many poorly characterized jobs on a machine like JUPITER. Nvidia’s technical account describes smaller runs as a yardstick for estimating GPU requirements, memory needs, execution time, communication cost and analysis overhead before committing large allocations [2]. In other words, the result is both a scientific simulation and a demonstration of how quantum-computing workloads may be engineered for supercomputers.

Quantum Computing Report described the project as a technical milestone announced at GTC Berlin 2026 and emphasized the combination of JUPITER execution, NVAQC staging, CUDA-Q, cuQuantum and advanced qutrit-to-binary mapping [4]. That framing captures the strategic message: Nvidia wants its GPU platforms and quantum software stack to become part of the standard toolchain for designing fault-tolerant quantum computers.

Why this matters for useful quantum computing

Useful quantum computing will likely require far more than a few hundred pristine qubits. It will require logical qubits protected by error-correcting codes, plus reliable ways to perform the operations that give quantum algorithms their advantage. Magic-state production is one of the resource-heavy components in that picture. If its overhead can be reduced, the path to practical machines may become less daunting [1].

The simulated applications remain prospective. Nvidia names drug discovery, financial modeling and materials science as fields that could benefit from useful quantum computers, but this JUPITER run did not solve a drug, finance or materials problem [1]. Its value lies upstream: it helps evaluate designs, noise sensitivities and error-correction choices before future hardware reaches the necessary scale.

That is why the result should be seen as a hardware-adjacent advance rather than a hardware breakthrough in the narrow sense of a new quantum processor. It demonstrates that classical accelerated computing can model increasingly realistic pieces of fault-tolerant quantum machines. It also shows that exascale infrastructure can help the quantum industry avoid some blind trial and error by testing protocols numerically before implementation [1].

The limits of the announcement

Several caveats are essential. First, the 104 qubits are simulated physical qubits, not 104 working logical qubits in a real processor. Second, the simulated protocol is a component of fault-tolerant computation, not an entire application-scale quantum computer. Third, a simulation can validate a model only to the extent that the model captures the right hardware physics.

Even so, the result is meaningful because it attacks a practical design uncertainty. Producing high-quality magic states can consume a large share of a future quantum computer’s resources, and hardware imperfections can change the real cost of that production [2]. A detailed simulation that includes leakage and coherent phase errors gives researchers a better benchmark than a noiseless or overly abstract model.

The Next Web’s report put the point plainly: the entire simulation ran on conventional computers, not on a quantum processor [3]. That should not weaken the story. For now, conventional supercomputers are among the best instruments available for testing how proposed quantum architectures may behave before they are manufactured at scale.

A milestone for the quantum-HPC bridge

The JUPITER run illustrates an emerging pattern: progress in quantum computing increasingly depends on classical computing. Better GPUs, larger memory pools, distributed numerical libraries and mature programming models are becoming essential to understanding quantum machines that do not yet exist physically.

For Nvidia, the announcement also reinforces a broader platform strategy. CUDA-Q and cuQuantum are presented not as side tools but as infrastructure for the hybrid future of quantum research [1]. For Jülich and Europe, JUPITER’s use in this project underscores the scientific value of exascale investment: the machine can support research questions that would be impractical on smaller systems [1].

The headline number, 104 qubits, is important. But the deeper message is that Nvidia and Jülich have built a more realistic simulation path for a specific bottleneck in fault-tolerant quantum computing. If future hardware teams can use this kind of modeling to reduce qubit overhead, identify harmful noise channels and refine error-correction protocols before fabrication, then JUPITER’s classical simulation may help accelerate the arrival of genuinely useful quantum processors.

Developments

1. Nvidia simulates 104-qubit fault-tolerant quantum computer on JUPITERThe Next Web · Oct 21, 2026, 10:05 AM · 9/10
2. NVIDIA sets record with fault-tolerant quantum simulationHPCwire · Oct 20, 2026, 7:38 AM · 8/10
3. NVIDIA Runs Record Fault-Tolerant Quantum Simulation at Jülich Supercomputing CentreHPCwire · Oct 20, 2026, 7:38 AM · 9/10
4. Nvidia Simulates 104-Qubit Fault-Tolerant Quantum Computer on JUPITER, Reducing Overhead by 90%BigGo Finance · Oct 20, 2026, 1:55 AM · 8/10
5. Nvidia Simulates 104-Qubit Fault-Tolerant Quantum Computer with 90% Qubit ReductionBigGo Finance · Oct 20, 2026, 1:55 AM · 8/10
6. NVIDIA and Jülich Run 104-Qubit Magic State Cultivation Simulation on JUPITER SupercomputerQuantum Computing Report · Oct 20, 2026, 12:51 AM · 8/10
7. NVIDIA and Jülich Achieve 104-Qubit Simulation on JUPITER SupercomputerQuantum Computing Report · Oct 20, 2026, 12:51 AM · 9/10
8. NVIDIA conducts largest 104-qubit quantum simulation on JUPITERInteresting Engineering · Oct 19, 2026, 10:35 PM · 8/10
9. NVIDIA Performs Largest 104-Qubit Quantum Simulation on JUPITERInteresting Engineering · Oct 19, 2026, 10:35 PM · 8/10
10. NVIDIA achieves record simulation of 104-qubit fault-tolerant quantum computerQuantum Zeitgeist · Oct 19, 2026, 9:51 PM · 9/10
11. NVIDIA Sets Record Simulating 104-Qubit Fault-Tolerant Quantum ComputerQuantum Zeitgeist · Oct 19, 2026, 9:45 PM · 9/10
12. NVIDIA Sets Fault-Tolerant Quantum Simulation Record at JülichInvesting News Network · Oct 19, 2026, 9:37 PM · 8/10
13. NVIDIA Sets Record in Fault-Tolerant Quantum Computing SimulationInvesting News Network · Oct 19, 2026, 9:37 PM · 9/10
14. NVIDIA Sets Record with 104-Qubit Fault-Tolerant Protocol on JUPITERUnite.AI · Oct 19, 2026, 8:23 PM · 8/10
15. NVIDIA Simulates Fault-Tolerant 104-Qubit Protocol on JUPITERUnite.AI · Oct 19, 2026, 8:23 PM · 9/10
16. NVIDIA Breaks Record with 104-Qubit Quantum SimulationInvesting.com · Oct 19, 2026, 8:21 PM · 8/10
17. NVIDIA Sets 104-Qubit Quantum Simulation Record on JUPITERInvesting.com · Oct 19, 2026, 8:21 PM · 8/10
18. NVIDIA utilizes JUPITER supercomputer for record quantum simulationQuiver Quantitative · Oct 19, 2026, 8:10 PM · 8/10

Sources from the last 72 hours

1. [1]NVIDIA Runs Record Simulation of Fault-Tolerant Quantum Computing at Jülich Supercomputing CentreOct 19, 2026, 2:00 AM
2. [2]Advancing Fault-Tolerant Quantum Computing with GPU-Accelerated SimulationOct 19, 2026, 2:00 AM
3. [3]Nvidia simulates 104-qubit fault-tolerant quantum computer on JUPITEROct 21, 2026, 10:04 AM
4. [4]NVIDIA and Jülich Run 104-Qubit Magic State Cultivation Simulation on JUPITER SupercomputerOct 19, 2026, 2:00 AM

AI-generated article based on recent web research, then preserved as a dated editorial snapshot.