Skip to content
audiotale.net
Sign in
NewsNews

NVIDIA and Jülich simulate 104 fault-tolerant qubits on 8,192 GPUs in Europe's JUPITER supercomputer

NVIDIA says the noisy magic-state cultivation run is the largest of its kind and could cut qubit needs by up to 90%; it is a classical simulation, and the figures are the company's.

audiotale.net team

· 6 min read

Written by AI from the sources linked below. How we use AI

Buildings of the Jülich Supercomputing Centre at Forschungszentrum Jülich
Photo: JiriMatejicek, CC BY-SA 3.0, via Wikimedia Commons
On this page
  1. Key points
  2. What happened
  3. Background
  4. The numbers
  5. What it means
  6. What we don't know yet
  7. What to watch next
  8. Sources

NVIDIA and the Jülich Supercomputing Centre (JSC) in Germany said on 19 October 2026 that they have run what NVIDIA calls the largest comprehensive simulation of a fault-tolerant quantum processor to date: 104 qubits, with realistic hardware noise, on 8,192 NVIDIA GH200 chips in JUPITER, Europe's first exascale supercomputer. The run models "magic state cultivation", the technique that Google recently showed on its Willow chip. It matters because it is a way to test designs for error-corrected quantum computers on today's classical hardware, before anyone builds them. It is not a quantum computer, and the headline "90% fewer qubits" is NVIDIA's claim.

Key points

  • NVIDIA says the simulation covers 104 qubits under realistic noise and ran on 8,192 GH200 GPUs on JUPITER at Forschungszentrum Jülich, announced 19 October 2026.
  • It models magic state cultivation, which NVIDIA says needs up to 90% fewer qubits than earlier methods; independent outlets repeat this as NVIDIA's figure and note that the baseline is not specified.
  • Earlier Jülich work simulated 50 qubits under ideal, noiseless conditions; this run adds noise models such as coherent phase noise and leakage.
  • NVIDIA says a GB200 NVL72 system at its quantum research centre cut development from weeks to days before the full-scale run.
  • This is a classical simulation, not a demonstration on quantum hardware, and no peer-reviewed paper was cited in the coverage we read.

What happened

NVIDIA's announcement says JSC researchers and NVIDIA ran a 104-qubit simulation of a fault-tolerant quantum processor on JUPITER, which it describes as the largest in Europe. The machine used for the run has 8,192 NVIDIA GH200 superchips. NVIDIA calls it "the largest comprehensive simulation of its kind to date". It says the work validates magic state cultivation, "a leading fault-tolerant approach".

Development did not start on JUPITER. According to NVIDIA, researchers first worked on a GB200 NVL72 system at the NVIDIA Accelerated Quantum Research Center (NVAQC), scaling tests from four GPUs to hundreds, and only then moved to all 8,192 GPUs. NVIDIA says this turned a simulation effort that took weeks into one that takes days. The software is NVIDIA's cuQuantum library plus the fault-tolerant logical layer of CUDA-Q, used to write down the magic-state circuit.

Quantum Computing Report, which read NVIDIA's technical material, adds detail the press release leaves out. It says the noise models include coherent phase noise and three-level leakage (a qubit's state escaping out of the two levels used for computing), and that the error-correction setup moves from a distance-3 colour code to a distance-7 hybrid colour/surface code, with active flag-based error detection. It reports an encoded state vector of 45 bits, about 35.2 trillion complex amplitudes, spread over 512 TiB of aggregate GPU memory (64 GiB per node on 8,192 GPUs). We checked the arithmetic: 8,192 × 64 GiB is 512 TiB, and 2^45 is about 35.2 trillion. We have not seen those technical details in NVIDIA's own press release, so treat them as that outlet's reading of NVIDIA's technical blog.

Jensen Huang, NVIDIA's CEO, said useful quantum computing "will require fantastically complex, fault-tolerant systems." Kristel Michielsen, who directs the JSC, said JUPITER lets researchers "investigate questions that were previously beyond reach."

Background

A quantum computer's physical qubits are fragile, so useful machines are expected to bundle many physical qubits into one "logical" qubit protected by an error-correcting code. Some operations, though, cannot be done directly on protected qubits. Universal computation needs a "T gate" or equivalent, and implementing it fault-tolerantly requires special resource states called magic states. These are consumed continuously, so the cost of making them is a large part of the overall cost of a machine.

The traditional method is magic state distillation, in which many noisy magic states are put through a factory circuit to yield fewer, cleaner ones. Cultivation is a newer proposal in which a single magic state is grown and checked in place, and discarded if a check fails. It was put forward by Google Quantum AI researchers, and Google has since reported a demonstration on its Willow chip, which we covered in our earlier article.

Simulating such circuits classically is hard. A state vector for n qubits holds 2^n amplitudes, so memory doubles with each added qubit. That is why the records are small in qubit count even on giant machines. In earlier JUPITER work, Jülich researchers and NVIDIA simulated a universal 50-qubit quantum computer, using about 2 petabytes of memory across more than 16,000 GH200 superchips, according to trade coverage of that run. It beat an earlier 48-qubit record on Japan's K computer; the sources we found disagree on the year of that earlier record (HPCwire says 2022, other outlets say 2019), so we leave it out of the chart below.

Cultivation circuits can be simulated more cheaply by specialised methods. A December 2025 preprint on arXiv, "SOFT: a high-performance simulator for universal fault-tolerant quantum circuits" (Li et al.), used a GPU-parallel stabiliser-based method to simulate cultivation at code distance 5, involving 42 qubits and 72 T gates over more than 200 billion shots. The authors reported a large discrepancy between the actual logical error rate and previously reported values. That paper is independent of NVIDIA's run and shows the field is still checking the numbers behind cultivation.

The numbers

Qubits in recent classical simulations of quantum circuitsqubits
Qubits in recent classical simulations of quantum circuits (qubits)
qubits
NVIDIA/JSC fault-tolerant run104
JUPITER universal simulation (ideal)50
SOFT cultivation simulation (d=5)42

Source: NVIDIA press release (19 Oct 2026); Jülich 50-qubit run as reported by trade press; Li et al., arXiv:2512.23037

The bars are not directly comparable. The 50-qubit run simulates a general universal quantum computer without noise, while the SOFT run uses a specialised method for fault-tolerant circuits. The 45-bit encoded state vector reported by Quantum Computing Report suggests the 104-qubit run does not store a raw 104-qubit state, which would need 2^104 amplitudes; we have not seen NVIDIA explain how the encoding works.

What it means

For quantum hardware teams. A validated simulator lets designers try codes, noise models and decoders at realistic size before building chips. If NVIDIA's workflow does cut a weeks-long run to days, teams can iterate faster on cultivation-style schemes.

For NVIDIA. The announcement fits its pitch that GPUs are the control and simulation layer for quantum computing, through cuQuantum and CUDA-Q. It also gives the company a European showcase for GH200 hardware.

For people learning the field. The result is a useful reminder of the gap between simulation and hardware. Cultivation has theory (Google Quantum AI), a hardware demonstration (Willow) and now a large-scale noisy simulation, but none of these is a complete error-corrected computer.

Who loses. Nobody directly, but the "90% fewer qubits" line is easy to over-read. As Quantum Computing Report notes, the figure is an "up to" value compared with traditional distillation, and no detailed baseline is given. It applies to preparing magic states, not to everything a quantum computer needs.

What we don't know yet

  • The headline 90% reduction has no published baseline or methodology in the coverage we read, and we found no independent verification.
  • Fidelity, logical error rates and run time on JUPITER were not given in the sources we read.
  • We did not find a peer-reviewed paper or preprint for the 104-qubit run. NVIDIA's own technical blog is the closest source, and we could not read it in full.
  • Whether the simulation agrees with Google's Willow measurements, or with the discrepancy that the SOFT authors reported, is not addressed in the coverage.
  • "Largest" is NVIDIA's own description; there is no standard benchmark for fault-tolerant simulations.

What to watch next

  • A technical paper or open code release for the run, with logical error rates and the assumptions behind the 90% figure.
  • Whether other groups reproduce cultivation results with independent simulators such as SOFT.
  • Further hardware results on cultivation from Google and others.
  • Whether JSC and NVIDIA extend the simulation to larger code distances or full algorithms.

Sources

SaveStart the discussion

Written by

audiotale.net team

The official account of the people who run audiotale.net: announcements, conversation starters and the newsroom's drafts. Posts written with AI say so. Every other account here is a real person.

Read next