NVIDIA simulates a 104-qubit error-correction protocol on JUPITER
A distributed simulation models a 104-qubit protocol with a smaller evolving representation. Memory, runtime and noise assumptions define the result.
.jpg){kind=link}
The announcement
NVIDIA and Jülich researchers used JUPITER to simulate a magic-state preparation protocol spanning 104 , according to an October 19 technical report. The largest configuration used 8,192 GPUs. It modeled coherent errors and selected leakage processes rather than only an ideal, noiseless circuit.[1][2]
What was actually simulated
The 104-qubit number describes the protocol’s footprint across its sequence. The simulator reorganized the calculation and reused storage after measurements. NVIDIA reports a 45-bit encoded evolving register occupying 512 TiB. This was not an unrestricted 104-qubit state vector stored at once. That distinction makes the engineering more interesting. Finding a representation that preserves the question being asked while reducing the working state is part of the scientific accomplishment.[2]
Why classical simulation belongs in quantum progress
A hardware design becomes easier to evaluate when its weaknesses can be explored before another device is built. Simulation can help ask whether a particular error mechanism is important enough to redesign around. It can also expose a protocol that looks attractive under a convenient approximation but behaves differently under a more detailed model. The model remains a model: confidence depends on how closely its assumptions match the proposed device. More computing capacity cannot make an incorrect assumption true.
The useful comparison
QubitWire’s reading is that this result is best understood as an engineering reference calculation. The valuable outputs are the precisely specified protocol, the noise assumptions, the preserved observables and the comparisons with smaller independently checked calculations.
A broad claim about useful quantum computing would need additional evidence about the hardware and application. The immediate research question is more concrete: which design decisions change when a difficult error mechanism is retained instead of simplified away? That is a result other researchers can inspect and build on.
A simulated quantum processor and a working quantum processor occupy different rows of the evidence table.
Why a more detailed model can change the answer
The original cultivation proposal estimated an order-of-magnitude reduction in qubit-rounds under a specified uniform noise model. A qubit-round counts hardware together with how long it is occupied. That resource measure should remain separate from a headline about physical-qubit count or a claim about total application cost.[3]
A September preprint gives a concrete reason to test the details. Its authors identified faults that behave differently when simulating the required T state and a simpler S-state substitute. Additional flag checks improved their pre-escape error estimate by a factor of 4.9 at a simulated physical noise level of 0.1%, while increasing attempts per accepted result by 1.36. This is separate research cited by NVIDIA, rather than a new measurement from JUPITER.[4]
The trade-off makes the engineering question tangible: a more reliable accepted result can require more attempts. A useful design comparison keeps both quantities visible. Detailed simulation earns its place when it helps expose such costs and motivates a test that future hardware can confirm.
Research in context · checked 20 Oct 2026
The arithmetic behind a large state simulation
A worked explanation of the distinction behind the result.
A direct pure-state representation of n two-level systems contains 2^n complex amplitudes. Each added binary degree of freedom doubles the storage. That is an algebraic property of the representation, not a claim that every useful calculation must store that representation. The distinction is central to understanding simulation headlines.
If each amplitude uses 16 bytes, a 45-bit register needs 2^45 × 16 bytes, which is 2^49 bytes or 512 TiB. The units matter: TiB is based on powers of two. Dividing that amount among 8,192 equal partitions gives 64 GiB per partition. This arithmetic checks the internal consistency of the storage figures in the technical report; it does not independently reproduce the experiment. [2]
Now consider a hypothetical circuit that uses six qubits, measures three and never interacts with them again. If the simulator can condition correctly on those measurements, some information about the measured subsystem no longer needs to remain in the active quantum register. The overall circuit can contain more qubits than the largest live state the simulator stores. Whether this works depends on the circuit and the observables being preserved.
The same caution applies to compression. A compact description is valuable when it preserves the aspects of the state needed for the task. If it silently discards the correlations that determine an error rate, its small footprint is misleading. A useful report therefore describes not just how much memory was saved but which transformations leave the relevant measurement statistics unchanged.
For readers comparing future records, four separate fields are enough to prevent most confusion: total qubits appearing in the protocol, maximum active representation, modeled levels per physical system and bytes actually used. None can substitute for the other three.
Sources and evidence
- NVIDIA Runs Record Simulation of Fault-Tolerant Quantum Computing at Jülich Supercomputing Centre ↗Source published 2026-10-19. company announcement.
- Advancing Fault-Tolerant Quantum Computing with GPU-Accelerated Simulation ↗Published October 19, 2026. Technical report describing the 104-qubit protocol, encoded working state, hardware-noise model and memory requirements.
Research in context · checked 20 Oct 2026
Why leakage changes the question
A worked explanation of the distinction behind the result.
A two-level model describes a qubit using two allowed computational states. Leakage asks what happens when the physical system occupies a state outside that pair. In an ordinary bit-flip picture, a mistaken value remains inside the alphabet. Leakage changes the alphabet available to the device, and later operations may respond differently.
Consider a hypothetical gate that is defined on two input states but has an unspecified action on a third. Applying the two-state truth table to that third state would be an assumption. Adding it to the model makes the missing behavior explicit. The point is not that every additional level always dominates performance. It is that the question cannot be answered by a model that rules the mechanism out at the start.
Memory capacity is also distinct from runtime and communication cost. An array that fits in aggregate GPU memory may still require expensive transfers or computation. A complete reproduction record should therefore identify the representation, precision, operations and data movement, rather than treating capacity alone as proof that the simulation is easy.
Sources and evidence
- NVIDIA Runs Record Simulation of Fault-Tolerant Quantum Computing at Jülich Supercomputing Centre ↗Source published 2026-10-19. company announcement.
- Advancing Fault-Tolerant Quantum Computing with GPU-Accelerated Simulation ↗Published October 19, 2026. Technical report describing the 104-qubit protocol, encoded working state, hardware-noise model and memory requirements.