Monitor

Q-Day Monitor

How big a quantum computer would it take to break RSA-2048, the public-key encryption behind much of the internet, and how close are real machines? This page plots every published estimate we could check against its primary paper, next to what hardware has actually demonstrated. Every number links to its source, with the assumptions it rests on.

Last checked: Dataset version 1.2Data (JSON)Data (CSV)Background: the Q-Day Note

Qubits needed vs. qubits built

Red circles are published estimates of the physical qubits a machine would need to factor a 2048-bit RSA number. Purple marks are machines that exist. The vertical scale is logarithmic: each gridline is ten times the one below it.

Estimates (on paper)

published estimate of what an attack needsestimate that counts only part of the machine

Hardware

gate-based processor, qubit count as announced (top chart); whole-machine or many-gate average (gate-error chart)best pair or small lab setupatoms trapped, not computing across the arraylogical qubits demonstrated (codes differ)company claim: announcement only, not checked against a paper (dashed outline)
Physical qubits: published RSA-2048 estimates vs. demonstrated hardware101001,00010,000100,0001 million10 million100 million1 billion10 billion2012201320142015201620172018201920202021202220232024202520262027physical qubits (log scale)P1 · Google Sycamore, 53 · Oct. 23, 2019: “a processor with programmable superconducting qubits to create quantum states on 53 qubits” (https://www.nature.com/articles/s41586-019-1666-5) Caveat: Gate-model processor running full-array circuits.Google Sycamore, 53P2 · IBM Eagle, 127 · Nov. 16, 2021: “127-qubit Eagle processor” (https://newsroom.ibm.com/2021-11-16-IBM-Unveils-Breakthrough-127-Qubit-Quantum-Processor) Caveat: Company announcement; the release does not give gate fidelities.IBM Eagle, 127P3 · IBM Osprey, 433 · Nov. 9, 2022: “The new 433 qubit 'Osprey' processor” (https://newsroom.ibm.com/2022-11-09-IBM-Unveils-400-Qubit-Plus-Quantum-Processor-and-Next-Generation-IBM-Quantum-System-Two) Caveat: Company announcement; the release does not give gate fidelities.IBM Osprey, 433P4 · Atom Computing, 1,180 atoms · Oct. 24, 2023: “Atom Computing announced it has created a 1,225-site atomic array, currently populated with 1,180 qubits” (https://www.prnewswire.com/news-releases/quantum-startup-atom-computing-first-to-exceed-1-000-qubits-301964712.html) Caveat: Press release; it reports atoms held in the array, not gate benchmarks across all 1,180.Atom Computing, 1,180 atomsP5 · IBM Condor, 1,121 (scale milestone) · Dec. 4, 2023: “We have introduced IBM Condor, a 1,121 superconducting qubit quantum processor based on our cross-resonance gate technology.” (https://www.ibm.com/quantum/blog/quantum-roadmap-2033) Caveat: IBM describes it as a scale milestone: "With performance comparable to our previous 433-qubit Osprey, it serves as an innovation milestone".IBM Condor, 1,121 (scale milestone)P6 · Caltech, 6,100 atoms trapped · Mar. 18, 2024: “optical tweezers trapping over 6,100 neutral atoms in around 12,000 sites” (https://arxiv.org/abs/2403.12021) Caveat: Trapping and coherence demonstration; it does not report entangling gates across the array. Not a computer of 6,100 working qubits.Caltech, 6,100 atoms trappedP7 · Google Willow, 105 · Aug. 24, 2024: “using a 105-qubit processor with similar performance, we realize a distance-7 surface code” (https://arxiv.org/abs/2408.13687) Caveat: Gate-model processor used for error-correction experiments.Google Willow, 105P8 · Harvard, 3,000 atoms held · Jun. 25, 2025: “maintain an array of over 3,000 atoms for more than 2 hours” (https://arxiv.org/abs/2506.20660) Caveat: Demonstrates keeping a large array loaded and coherent; not gate operations across all 3,000.Harvard, 3,000 atoms heldP9 · Quantinuum Helios, 98 · Nov. 7, 2025: “We report on Quantinuum Helios, a 98-qubit trapped-ion quantum processor” (https://arxiv.org/abs/2511.05465) Caveat: Gate-model processor with all-to-all connectivity.Quantinuum Helios, 98P10 · Tsinghua 2026, 11,000 atoms trapped · Jun. 1, 2026: “Here, we robustly trap 11,000 individual atoms in a tweezer array” (https://arxiv.org/abs/2606.02715) Caveat: Trapping demonstration; it does not report entangling gates across the array. Not a computer of 11,000 working qubits.Tsinghua 2026,11,000 atoms trappedE1 · Fowler et al. 2012 · Aug. 4, 2012: “the full quantum computer needs about a billion physical qubits, operating for about one day” (https://arxiv.org/abs/1208.0928)Fowler et al. 2012: about 1 billion (about 1 day)E2 · Gidney & Ekera 2019 · May 23, 2019: “How to factor 2048 bit RSA integers in 8 hours using 20 million noisy qubits (title); Table 2, (ours) 2019 (parallel): 20 million physical qubits” (https://arxiv.org/abs/1905.09749)Gidney & Ekerå 2019: 20 million (8 hours)E3 · Gouzien & Sangouard 2021 · Mar. 10, 2021: “factoring a 2 048-bit RSA integer is shown to be possible in 177 days with 3D gauge color codes assuming a threshold of 0.75 % with a processor made with 13 436 physical qubits and a memory that can store 28 million spatial modes and 45 temporal modes with 2 hours' storage time” (https://arxiv.org/abs/2103.06159)Gouzien & Sangouard 2021: 13,436 + memory (177 days)E5 · Gidney 2025 · May 21, 2025: “I estimate that a 2048 bit RSA integer could be factored in less than a week by a quantum computer with less than a million noisy qubits. ... The total number of physical qubits is 897864.” (https://arxiv.org/abs/2505.15917)Gidney 2025: under 1 million (under a week)E6 · Webster et al. 2026 (Pinnacle) · Feb. 12, 2026: “2048-bit RSA integers can be factored with fewer than one hundred thousand physical qubits (abstract); Table VI (v2), 1 us cycle, 10^-3 error: 94 kq for a runtime of 1 month or less (135 kq for 1 week, 381 kq for 1 day)” (https://arxiv.org/abs/2602.11457)Webster et al. Feb. 202694,000 (1 month)E7 · Cain et al. 2026 · Mar. 30, 2026: “our most time-efficient architectures can potentially enable runtimes of ... 97 days for RSA-2048 with approximately 102,000 qubits” (https://arxiv.org/abs/2603.28627)Cain et al. 2026102,000 (97 days)E8 · Mundada et al. 2026 · Apr. 7, 2026: “using an experimentally demonstrated grid-coupling topology, factoring RSA-2048 requires 381k physical qubits and 9.2 days, which can be reduced to 4.9 days via addition of an algorithm-specific accelerator for the Adder subroutine (requiring 439k qubits)” (https://arxiv.org/abs/2604.06319)Mundada et al. 2026381,000 (9.2 days)E9 · Webster et al. 2026 (fixed connectivity) · Sep. 18, 2026: “we show that a 2048-bit RSA integer can be factored in one month with approximately 120 000 physical qubits” (https://arxiv.org/abs/2609.21249)Webster et al. Sep. 2026120,000 (1 month)
Physical qubits: published RSA-2048 estimates vs. demonstrated hardware101001,00010,000100,0001 million10 million100 million1 billion10 billion201220182024physical qubits (log scale)P1 · Google Sycamore, 53 · Oct. 23, 2019: “a processor with programmable superconducting qubits to create quantum states on 53 qubits” (https://www.nature.com/articles/s41586-019-1666-5) Caveat: Gate-model processor running full-array circuits.P1 Google Sycamore,53P2 · IBM Eagle, 127 · Nov. 16, 2021: “127-qubit Eagle processor” (https://newsroom.ibm.com/2021-11-16-IBM-Unveils-Breakthrough-127-Qubit-Quantum-Processor) Caveat: Company announcement; the release does not give gate fidelities.P2 IBM Eagle, 127P3 · IBM Osprey, 433 · Nov. 9, 2022: “The new 433 qubit 'Osprey' processor” (https://newsroom.ibm.com/2022-11-09-IBM-Unveils-400-Qubit-Plus-Quantum-Processor-and-Next-Generation-IBM-Quantum-System-Two) Caveat: Company announcement; the release does not give gate fidelities.P3 IBM Osprey, 433P4 · Atom Computing, 1,180 atoms · Oct. 24, 2023: “Atom Computing announced it has created a 1,225-site atomic array, currently populated with 1,180 qubits” (https://www.prnewswire.com/news-releases/quantum-startup-atom-computing-first-to-exceed-1-000-qubits-301964712.html) Caveat: Press release; it reports atoms held in the array, not gate benchmarks across all 1,180.P4 Atom Computing,1,180 atomsP5 · IBM Condor, 1,121 (scale milestone) · Dec. 4, 2023: “We have introduced IBM Condor, a 1,121 superconducting qubit quantum processor based on our cross-resonance gate technology.” (https://www.ibm.com/quantum/blog/quantum-roadmap-2033) Caveat: IBM describes it as a scale milestone: "With performance comparable to our previous 433-qubit Osprey, it serves as an innovation milestone".P5 IBM Condor, 1,121(scale milestone)P6 · Caltech, 6,100 atoms trapped · Mar. 18, 2024: “optical tweezers trapping over 6,100 neutral atoms in around 12,000 sites” (https://arxiv.org/abs/2403.12021) Caveat: Trapping and coherence demonstration; it does not report entangling gates across the array. Not a computer of 6,100 working qubits.P6 Caltech, 6,100atoms trappedP7 · Google Willow, 105 · Aug. 24, 2024: “using a 105-qubit processor with similar performance, we realize a distance-7 surface code” (https://arxiv.org/abs/2408.13687) Caveat: Gate-model processor used for error-correction experiments.P7 Google Willow, 105P8 · Harvard, 3,000 atoms held · Jun. 25, 2025: “maintain an array of over 3,000 atoms for more than 2 hours” (https://arxiv.org/abs/2506.20660) Caveat: Demonstrates keeping a large array loaded and coherent; not gate operations across all 3,000.P8 Harvard, 3,000atoms heldP9 · Quantinuum Helios, 98 · Nov. 7, 2025: “We report on Quantinuum Helios, a 98-qubit trapped-ion quantum processor” (https://arxiv.org/abs/2511.05465) Caveat: Gate-model processor with all-to-all connectivity.P9 Quantinuum Helios,98P10 · Tsinghua 2026, 11,000 atoms trapped · Jun. 1, 2026: “Here, we robustly trap 11,000 individual atoms in a tweezer array” (https://arxiv.org/abs/2606.02715) Caveat: Trapping demonstration; it does not report entangling gates across the array. Not a computer of 11,000 working qubits.P10 Tsinghua 2026,11,000 atoms trappedE1 · Fowler et al. 2012 · Aug. 4, 2012: “the full quantum computer needs about a billion physical qubits, operating for about one day” (https://arxiv.org/abs/1208.0928)E1 Fowler et al. 2012E2 · Gidney & Ekera 2019 · May 23, 2019: “How to factor 2048 bit RSA integers in 8 hours using 20 million noisy qubits (title); Table 2, (ours) 2019 (parallel): 20 million physical qubits” (https://arxiv.org/abs/1905.09749)E2 Gidney & Ekerå2019E3 · Gouzien & Sangouard 2021 · Mar. 10, 2021: “factoring a 2 048-bit RSA integer is shown to be possible in 177 days with 3D gauge color codes assuming a threshold of 0.75 % with a processor made with 13 436 physical qubits and a memory that can store 28 million spatial modes and 45 temporal modes with 2 hours' storage time” (https://arxiv.org/abs/2103.06159)E3 Gouzien &Sangouard 2021E5 · Gidney 2025 · May 21, 2025: “I estimate that a 2048 bit RSA integer could be factored in less than a week by a quantum computer with less than a million noisy qubits. ... The total number of physical qubits is 897864.” (https://arxiv.org/abs/2505.15917)E5 Gidney 2025E6 · Webster et al. 2026 (Pinnacle) · Feb. 12, 2026: “2048-bit RSA integers can be factored with fewer than one hundred thousand physical qubits (abstract); Table VI (v2), 1 us cycle, 10^-3 error: 94 kq for a runtime of 1 month or less (135 kq for 1 week, 381 kq for 1 day)” (https://arxiv.org/abs/2602.11457)E6 Webster et al.Feb. 2026E7 · Cain et al. 2026 · Mar. 30, 2026: “our most time-efficient architectures can potentially enable runtimes of ... 97 days for RSA-2048 with approximately 102,000 qubits” (https://arxiv.org/abs/2603.28627)E7 Cain et al. 2026E8 · Mundada et al. 2026 · Apr. 7, 2026: “using an experimentally demonstrated grid-coupling topology, factoring RSA-2048 requires 381k physical qubits and 9.2 days, which can be reduced to 4.9 days via addition of an algorithm-specific accelerator for the Adder subroutine (requiring 439k qubits)” (https://arxiv.org/abs/2604.06319)E8 Mundada et al.2026E9 · Webster et al. 2026 (fixed connectivity) · Sep. 18, 2026: “we show that a 2048-bit RSA integer can be factored in one month with approximately 120 000 physical qubits” (https://arxiv.org/abs/2609.21249)E9 Webster et al.Sep. 2026
Sources: 8 estimates and 10 hardware results, each in the source table under its key (E for estimates, P for physical-qubit results). Hover over or tap a point for the quoted figure. No lines join the points: this page draws no trends and makes no projections.

What the gap means

Think of the estimates as recipes and the hardware as kitchens. Each recipe says how large a machine, working how accurately and how fast, could factor one 2048-bit RSA number. The recipes keep shrinking: about a billion qubits in 2012, 20 million in 2019, under a million in 2025, and between 94,000 and 381,000 in four 2026 preprints, each under its own assumptions. The kitchens keep growing and getting more accurate.

But a qubit in a recipe is not the same as a qubit in a headline. Every estimate here assumes that all of its qubits work together, with about one error per thousand operations on every gate (one per two thousand in one case), running error correction cycle after cycle for days to months without a break. The largest atom arrays so far, 6,100 and 11,000 atoms, held atoms in place; they did not run gates across the whole array. The gate-based processors on this chart (single chips or machines) have 53 to 1,121 qubits, counted as announced. That is not the same as one computation running across all of them: IBM describes its 1,121-qubit Condor as a scale milestone, with performance comparable to its 433-qubit Osprey.

So the gap is not one number. It has four parts, and the charts below show each one separately:

1 · Count

Enough qubits computing together

Not atoms trapped, or chips built: qubits that all take part in one computation.

2 · Accuracy

About 0.1% error on every gate

Several systems report two-qubit errors at or below 0.1%, mostly on small systems or single pairs. The estimates need it everywhere, at full size.

3 · Error correction

Logical qubits that correct, at scale

Estimates need about 1,400 to 8,300 logical qubits. Demonstrations have between 3 and 94, some of which only detect errors.

4 · Speed

Fast error-correction cycles

Most estimates assume one microsecond per cycle. One 2026 estimate assumes one millisecond, typical of atoms, and needs 97 days instead of under a week.

Two kinds of progress move the picture, and both count. New algorithms and codes lower the red circles. Better machines raise the purple marks. Neither one is a date, and this page does not forecast one. For why the date matters less than the migration already under way, see Q-Day: A Threshold, Not a Date.

How to read this

  • One point, one published claim, placed at the date it first appeared in public (usually the arXiv posting).
  • Logarithmic scale. Equal distances mean equal multiples. Going from 100 to 1,000 qubits looks the same as going from 100,000 to 1 million.
  • Compare like with like. Estimates differ in error rate, cycle time, wiring and the kind of code they use. One counts only the processor and leaves out a large memory. The source table lists every assumption.
  • A record depends on how it is measured. A best pair of qubits, a whole-machine average and a 60-gate parallel test are different claims. We list each with its conditions and do not pick a winner.
  • Estimates are not machines. Several 2026 estimates come from companies with their own architectures and have not been peer-reviewed. They are marked in the table.

Accuracy: two-qubit gate error

The dashed line is the 0.1% error rate that most RSA-2048 estimates assume for every gate. Filled squares are averages over a whole machine or many gates running at once; open squares are best pairs or small lab setups. Where a source gives fidelity, we plot error as 1 minus fidelity.

Best reported two-qubit gate error over time0.001%0.01%0.1%1%10%201320142015201620172018201920202021202220232024202520262027two-qubit gate error0.1%: the error rate most RSA-2048 estimates assumeA1 · UCSB/Google 2014 · Feb. 19, 2014: “a two-qubit gate fidelity up to 99.4%” (https://arxiv.org/abs/1402.4848) Caveat: Best pair on a small device ("up to").UCSB/Google 2014A2 · Oxford 2015 · Dec. 14, 2015: “two-qubit and single-qubit logic gates with fidelities 99.9(1)% and 99.9934(3)% respectively” (https://arxiv.org/abs/1512.04600) Caveat: Two-ion laboratory demonstration.Oxford 2015A3 · NIST 2016 · Mar. 31, 2016: “By creating a Bell state with a deterministic two-qubit gate, we deduce a gate error of 8(4) x 10^-4.” (https://arxiv.org/abs/1604.00032) Caveat: Two-ion laboratory demonstration; large uncertainty (plus or minus 4 x 10^-4).NIST 2016A4 · Sycamore, chip average · Oct. 23, 2019: “we repeat the same procedure while simultaneously running two-qubit circuits for the entire array ... we find an average e2 of 0.62%” (https://www.nature.com/articles/s41586-019-1666-5) Caveat: Whole-chip average, not a best pair; Pauli error is not identical to 1 minus average fidelity.Sycamore, chip averageA5 · Harvard 2023, 60 atoms · Apr. 11, 2023: “two-qubit entangling gates with 99.5% fidelity on up to 60 atoms in parallel” (https://arxiv.org/abs/2304.05420) Caveat: Parallel gates on up to 60 atoms.Harvard 2023, 60 atomsA6 · Quantinuum H1-1 · Apr. 16, 2024: “the first demonstration of 99.914(3)% 2-qubit gate fidelity, showing repeatable performance across all qubit pairs on our H1-1 system” (https://www.quantinuum.com/blog/quantinuum-extends-its-significant-lead-in-quantum-computing-achieving-historic-milestones-for-hardware-fidelity-and-quantum-volume) Caveat: Company blog; a system-wide figure across all qubit pairs of a smaller commercial machine.Quantinuum H1-1A7 · Oxford Ionics (IonQ), 2 ions · Oct. 20, 2025: “We demonstrate electronically controlled two-qubit gates with an estimated error of 8.4(7) x 10^-5 without ground-state cooling.” (https://arxiv.org/abs/2510.17286) Caveat: Two-ion demonstration, not a full processor. IonQ's press release (Oct 21, 2025) calls it a world record; we do not rank records.Oxford Ionics (IonQ), 2 ionsA8 · Helios, 98-qubit average · Nov. 7, 2025: “Averaged over all operational zones in the system, we achieve average infidelities of 2.5(1) x 10^-5 for single-qubit gates, 7.9(2) x 10^-4 for two-qubit gates” (https://arxiv.org/abs/2511.05465) Caveat: System-wide average on a 98-qubit machine; not comparable one-to-one with two-ion records.Helios, 98-qubit averageA9 · Harvard 2026, raw · Apr. 28, 2026: “achieve state-of-the-art fidelities of 99.854(4)% which improve to 99.941(3)% upon loss postselection” (https://arxiv.org/abs/2604.25987) Caveat: Raw fidelity plotted; the higher figure needs postselection.Harvard 2026, raw
Best reported two-qubit gate error over time0.001%0.01%0.1%1%10%20132016201920222025two-qubit gate errorA1 · UCSB/Google 2014 · Feb. 19, 2014: “a two-qubit gate fidelity up to 99.4%” (https://arxiv.org/abs/1402.4848) Caveat: Best pair on a small device ("up to").A1 UCSB/Google 2014A2 · Oxford 2015 · Dec. 14, 2015: “two-qubit and single-qubit logic gates with fidelities 99.9(1)% and 99.9934(3)% respectively” (https://arxiv.org/abs/1512.04600) Caveat: Two-ion laboratory demonstration.A2 Oxford 2015A3 · NIST 2016 · Mar. 31, 2016: “By creating a Bell state with a deterministic two-qubit gate, we deduce a gate error of 8(4) x 10^-4.” (https://arxiv.org/abs/1604.00032) Caveat: Two-ion laboratory demonstration; large uncertainty (plus or minus 4 x 10^-4).A3 NIST 2016A4 · Sycamore, chip average · Oct. 23, 2019: “we repeat the same procedure while simultaneously running two-qubit circuits for the entire array ... we find an average e2 of 0.62%” (https://www.nature.com/articles/s41586-019-1666-5) Caveat: Whole-chip average, not a best pair; Pauli error is not identical to 1 minus average fidelity.A4 Sycamore, chipaverageA5 · Harvard 2023, 60 atoms · Apr. 11, 2023: “two-qubit entangling gates with 99.5% fidelity on up to 60 atoms in parallel” (https://arxiv.org/abs/2304.05420) Caveat: Parallel gates on up to 60 atoms.A5 Harvard 2023, 60atomsA6 · Quantinuum H1-1 · Apr. 16, 2024: “the first demonstration of 99.914(3)% 2-qubit gate fidelity, showing repeatable performance across all qubit pairs on our H1-1 system” (https://www.quantinuum.com/blog/quantinuum-extends-its-significant-lead-in-quantum-computing-achieving-historic-milestones-for-hardware-fidelity-and-quantum-volume) Caveat: Company blog; a system-wide figure across all qubit pairs of a smaller commercial machine.A6 Quantinuum H1-1A7 · Oxford Ionics (IonQ), 2 ions · Oct. 20, 2025: “We demonstrate electronically controlled two-qubit gates with an estimated error of 8.4(7) x 10^-5 without ground-state cooling.” (https://arxiv.org/abs/2510.17286) Caveat: Two-ion demonstration, not a full processor. IonQ's press release (Oct 21, 2025) calls it a world record; we do not rank records.A7 Oxford Ionics(IonQ), 2 ionsA8 · Helios, 98-qubit average · Nov. 7, 2025: “Averaged over all operational zones in the system, we achieve average infidelities of 2.5(1) x 10^-5 for single-qubit gates, 7.9(2) x 10^-4 for two-qubit gates” (https://arxiv.org/abs/2511.05465) Caveat: System-wide average on a 98-qubit machine; not comparable one-to-one with two-ion records.A8 Helios, 98-qubitaverageA9 · Harvard 2026, raw · Apr. 28, 2026: “achieve state-of-the-art fidelities of 99.854(4)% which improve to 99.941(3)% upon loss postselection” (https://arxiv.org/abs/2604.25987) Caveat: Raw fidelity plotted; the higher figure needs postselection.A9 Harvard 2026, raw0.1%: assumed by most estimates
Keys A1 to A9 in the source table. Benchmarking methods differ (randomized benchmarking, Bell-state fidelity, cross-entropy benchmarking), so small differences between points are not meaningful.

Logical qubits: needed vs. demonstrated

A logical qubit is one reliable qubit built from many physical ones (see the logical qubit Note). The estimates count logical qubits that correct errors well enough to run for days. The demonstrations use smaller codes, and some of them only detect errors and discard the failed runs.

Logical qubits: needed by estimates vs. demonstrated1101001,00010,000100,0002012201320142015201620172018201920202021202220232024202520262027logical qubits (log scale)E1 · Fowler et al. 2012 · Aug. 4, 2012: “the number of computational logical qubits, which for this circuit is about 2N = 4,000” (https://arxiv.org/abs/1208.0928)Fowler et al. 2012: about 4,000E3 · Gouzien & Sangouard 2021 · Mar. 10, 2021: “Table I, n = 2 048 row: logical qubits 8 284” (https://arxiv.org/abs/2103.06159)Gouzien & Sangouard 2021: 8,284E4 · Chevignard, Fouque & Schrottenloher 2024 · Feb. 13, 2024: “To factor an RSA-2048 instance, we estimate that 1730 logical qubits and 2^36 Toffoli gates will suffice for a single run, and the algorithm needs on average 40 runs.” (https://eprint.iacr.org/2024/222)Chevignard et al. 2024: 1,730E5 · Gidney 2025 · May 21, 2025: “Table 5, n = 2048 row: Qubits 1399 (1,537 logical qubits including idle hot patches, Section 3)” (https://arxiv.org/abs/2505.15917)Gidney 2025: 1,399L1 · Harvard/QuEra, 48 (detect only) · Dec. 7, 2023: “Using three-dimensional [[8,3,2]] code blocks, we realize computationally complex sampling circuits with up to 48 logical qubits” (https://arxiv.org/abs/2312.03982) Caveat: Error-detecting code with postselection; not the kind of logical qubit a factoring estimate assumes.Harvard/QuEra, 48 (detect only)L2 · Microsoft/Atom, 28 · Nov. 18, 2024: “we demonstrate the entanglement of 24 logical qubits encoded into 48 atoms ... with up to 28 logical qubits encoded into 112 atoms, showing better-than-physical error rates” (https://arxiv.org/abs/2411.11822) Caveat: Small codes; compare code distance before comparing counts.Microsoft/Atom, 28L3 · Helios, 94 (detect) / 48 (correct) · Feb. 25, 2026: “benchmarks with between 48 and 94 logical qubits ... 94 logical qubits in iceberg QED codes, and up to 48 logical qubits (the largest for which a full QEC cycle can be executed on Helios)” (https://arxiv.org/abs/2602.22211) Caveat: The 94 are error-detected, not error-corrected; the error-corrected count is 48.Helios, 94 (detect) / 48 (correct)Company claim (announcement only, not checked against a paper). L4 · IBM/UChicago, 70 · Jul. 30, 2026: “the team executed 70 logical qubits — shielding them from errors to run 2,415 logical two-qubit operations and 468 logical "T gates"” (https://newsroom.ibm.com/2026-07-30-ibm-and-the-university-of-chicago-demonstrate-quantum-advantage,-establishing-trusted-quantum-computation-on-logical-circuits) Caveat: Company claim: IBM newsroom announcement only, not checked by us against a paper; the code and distance are not stated in it. Underlying paper: "Sampling hard circuits with verifiably high fidelity" (not yet checked by us). Shown with an open, dashed marker, never as a measured result.IBM/UChicago, 70(company claim)L5 · Sydney on IBM Nighthawk, 3 (distance 3) · Oct. 23, 2026: “With three logical qubits and lattice surgery, we perform logical teleportation of a range of states and gates, observing fidelities in the range 78% - 93%.” (https://arxiv.org/abs/2610.32347) Caveat: Not below-threshold scaling: the distance-5 memory only matches the best distance-3 codes (Sec. II A), so no Lambda is reported. Fidelities are post-selected on clean preparation.Sydney on IBM Nighthawk, 3 (distance 3)
Logical qubits: needed by estimates vs. demonstrated1101001,00010,000100,000201220182024logical qubits (log scale)E1 · Fowler et al. 2012 · Aug. 4, 2012: “the number of computational logical qubits, which for this circuit is about 2N = 4,000” (https://arxiv.org/abs/1208.0928)E1 Fowler et al. 2012E3 · Gouzien & Sangouard 2021 · Mar. 10, 2021: “Table I, n = 2 048 row: logical qubits 8 284” (https://arxiv.org/abs/2103.06159)E3 Gouzien &Sangouard 2021E4 · Chevignard, Fouque & Schrottenloher 2024 · Feb. 13, 2024: “To factor an RSA-2048 instance, we estimate that 1730 logical qubits and 2^36 Toffoli gates will suffice for a single run, and the algorithm needs on average 40 runs.” (https://eprint.iacr.org/2024/222)E4 Chevignard et al.2024E5 · Gidney 2025 · May 21, 2025: “Table 5, n = 2048 row: Qubits 1399 (1,537 logical qubits including idle hot patches, Section 3)” (https://arxiv.org/abs/2505.15917)E5 Gidney 2025L1 · Harvard/QuEra, 48 (detect only) · Dec. 7, 2023: “Using three-dimensional [[8,3,2]] code blocks, we realize computationally complex sampling circuits with up to 48 logical qubits” (https://arxiv.org/abs/2312.03982) Caveat: Error-detecting code with postselection; not the kind of logical qubit a factoring estimate assumes.L1 Harvard/QuEra, 48(detect only)L2 · Microsoft/Atom, 28 · Nov. 18, 2024: “we demonstrate the entanglement of 24 logical qubits encoded into 48 atoms ... with up to 28 logical qubits encoded into 112 atoms, showing better-than-physical error rates” (https://arxiv.org/abs/2411.11822) Caveat: Small codes; compare code distance before comparing counts.L2 Microsoft/Atom, 28L3 · Helios, 94 (detect) / 48 (correct) · Feb. 25, 2026: “benchmarks with between 48 and 94 logical qubits ... 94 logical qubits in iceberg QED codes, and up to 48 logical qubits (the largest for which a full QEC cycle can be executed on Helios)” (https://arxiv.org/abs/2602.22211) Caveat: The 94 are error-detected, not error-corrected; the error-corrected count is 48.L3 Helios, 94(detect) / 48(correct)Company claim (announcement only, not checked against a paper). L4 · IBM/UChicago, 70 · Jul. 30, 2026: “the team executed 70 logical qubits — shielding them from errors to run 2,415 logical two-qubit operations and 468 logical "T gates"” (https://newsroom.ibm.com/2026-07-30-ibm-and-the-university-of-chicago-demonstrate-quantum-advantage,-establishing-trusted-quantum-computation-on-logical-circuits) Caveat: Company claim: IBM newsroom announcement only, not checked by us against a paper; the code and distance are not stated in it. Underlying paper: "Sampling hard circuits with verifiably high fidelity" (not yet checked by us). Shown with an open, dashed marker, never as a measured result.L4 IBM/UChicago, 70(company claim)L5 · Sydney on IBM Nighthawk, 3 (distance 3) · Oct. 23, 2026: “With three logical qubits and lattice surgery, we perform logical teleportation of a range of states and gates, observing fidelities in the range 78% - 93%.” (https://arxiv.org/abs/2610.32347) Caveat: Not below-threshold scaling: the distance-5 memory only matches the best distance-3 codes (Sec. II A), so no Lambda is reported. Fidelities are post-selected on clean preparation.L5 Sydney on IBMNighthawk, 3(distance 3)
Red circles: logical qubits needed (keys E). Open triangles: logical qubits demonstrated (keys L). The dashed triangle (L4, IBM/UChicago, 70) is a company claim: it comes from an announcement only and has not been checked against a paper, so it is not shown as a measured result. Mundada et al. 2026 uses the same 1,399-qubit program as Gidney 2025, so it is not plotted twice.

Below threshold: do bigger codes help?

Error correction pays only if adding qubits removes more errors than it adds. The factor Lambda says how much the error rate falls each time the code grows one step. Above 1, bigger codes help. All four results here are memory experiments: they store a qubit, they do not run a long computation.

Error suppression per step up in code size (Lambda)0136912152024202520262027Lambda (higher is better)1 = a bigger code gives no gainS1 · Google surface code, 2.14 · Aug. 24, 2024: “The logical error rate of our larger quantum memory is suppressed by a factor of Lambda = 2.14 +/- 0.02 when increasing the code distance by two, culminating in a 101-qubit distance-7 code with 0.143% +/- 0.003% error per cycle” (https://arxiv.org/abs/2408.13687) Caveat: Memory only, not a computation.Google surface code, 2.14S2 · Google color code, 1.56 · Dec. 18, 2024: “suppresses logical errors by a factor of Lambda_3/5 = 1.56(4)” (https://arxiv.org/abs/2412.14256) Caveat: Memory plus logic tests; one distance step.Google color code, 1.56S4 · Quantinuum color code, 12 · Oct. 16, 2026: “error suppression by over an order of magnitude, Lambda = 12 (+3/-2), with each successive increase in code distance” (https://arxiv.org/abs/2610.24077) Caveat: Memory and Clifford gates; magic states not tested; offline decoding. See the paper “Quantum error correction well below the color code threshold” (https://arxiv.org/abs/2610.24077).Quantinuum color code, 12S3 · PNNL on IBM, 1.85 · Oct. 16, 2026: “an error-suppression factor (Lambda) of 1.68 and 1.85 under maximum-likelihood decoding” (https://arxiv.org/abs/2610.23840) Caveat: Independent team on cloud hardware; over 150 rounds the gain shrank. See the paper “Demonstration of Logical Error Suppression in a Surface Code Memory on a Cloud-Accessible IBM Superconducting Processor” (https://arxiv.org/abs/2610.23840).PNNL on IBM, 1.85
Error suppression per step up in code size (Lambda)0136912152024202520262027Lambda (higher is better)S1 · Google surface code, 2.14 · Aug. 24, 2024: “The logical error rate of our larger quantum memory is suppressed by a factor of Lambda = 2.14 +/- 0.02 when increasing the code distance by two, culminating in a 101-qubit distance-7 code with 0.143% +/- 0.003% error per cycle” (https://arxiv.org/abs/2408.13687) Caveat: Memory only, not a computation.S1 Google surfacecode, 2.14S2 · Google color code, 1.56 · Dec. 18, 2024: “suppresses logical errors by a factor of Lambda_3/5 = 1.56(4)” (https://arxiv.org/abs/2412.14256) Caveat: Memory plus logic tests; one distance step.S2 Google color code,1.56S4 · Quantinuum color code, 12 · Oct. 16, 2026: “error suppression by over an order of magnitude, Lambda = 12 (+3/-2), with each successive increase in code distance” (https://arxiv.org/abs/2610.24077) Caveat: Memory and Clifford gates; magic states not tested; offline decoding. See the paper “Quantum error correction well below the color code threshold” (https://arxiv.org/abs/2610.24077).S4 Quantinuum colorcode, 12S3 · PNNL on IBM, 1.85 · Oct. 16, 2026: “an error-suppression factor (Lambda) of 1.68 and 1.85 under maximum-likelihood decoding” (https://arxiv.org/abs/2610.23840) Caveat: Independent team on cloud hardware; over 150 rounds the gain shrank. See the paper “Demonstration of Logical Error Suppression in a Surface Code Memory on a Cloud-Accessible IBM Superconducting Processor” (https://arxiv.org/abs/2610.23840).S3 PNNL on IBM, 1.851 = no gain
Keys S1 to S4 in the source table. A magic-state result (M1), the other ingredient a factoring machine needs, is listed in the table only.

Methodology

  • What counts as an estimate. A paper or preprint that states a physical-qubit or logical-qubit count for factoring RSA-2048. Fowler et al. 2012 is included because later papers use it as the baseline, although it treats a 2,000-bit number.
  • Every figure checked against the primary source. Each value was read in the paper or announcement itself and is quoted in the table. Values were checked on October 20, 2026, except L5 (Sydney on IBM Nighthawk), checked on October 26, 2026. Each source cell shows its own check date. Quotes are verbatim except that citation markers are dropped, math is written in plain text, and an ellipsis marks omitted words.
  • No numbers of our own. When a paper gives an exact count and a rounded headline (897,864 vs. “less than a million”), we plot the exact count and label it with the paper’s own bound. The only transformation is plotting error as 1 minus fidelity.
  • Hardware claims, not rankings. Where “the best” is ambiguous (a pair vs. a whole machine, trapped vs. computing, detected vs. corrected), each claim is listed with its conditions and a caveat. Company announcements and preprints are marked.
  • Dates are first public appearance: arXiv version 1, IACR ePrint receipt, or the announcement date.
  • Not included: elliptic-curve estimates (a different problem; one recent example is listed as context), figures we could only find in secondary reports, and any projection.
  • Data. Version 1.2, frozen on October 26, 2026. JSON and CSV, one row per sourced value. The page and charts are generated from the JSON by a script and checked for sources, dates and duplicates.

All sources

9 estimates, 29 hardware results and 1 context item, 52 sourced values in all.

KeyDateWhatFigure as stated (quoted)Assumptions, conditions, caveatsPrimary source
Resource estimates for factoring RSA-2048 (on paper)
E1Aug. 4, 2012arXiv v1 postedFowler et al. 2012University of Melbourne; UC Santa Barbara · Factoring a 2,000-bit number (not exactly 2,048)“the full quantum computer needs about a billion physical qubits, operating for about one day”about 1,000,000,000 physical qubits“the number of computational logical qubits, which for this circuit is about 2N = 4,000”about 4,000 logical qubits“it will take about 26.7 hours to complete the exponentiation”about 26.7 hourserror rate: about one-tenth of the threshold; the appendix works at p = 10^-3 ("Here we assume an error rate approximately one-tenth the threshold rate")
cycle: physical qubit measurement time 100 ns; surface code cycle about 200 ns ("a 200 ns time for this cycle is not unreasonable")
reaction time: not stated as a separate parameter
connectivity: 2D nearest-neighbor surface code array
code: surface code with magic-state distillation
other: about 14,500 physical qubits per logical qubit; most of the machine generates |A> magic statesProblem size is N = 2000 bits. Gidney and Ekera 2019 (Table 2) restate this estimate at n = 2048 as 1,000 million qubits and 1.1 days. Counts the 4,000 logical qubits as less than 6% of the machine.
Surface codes: Towards practical large-scale quantum computationPhysical Review A 86, 032324 (2012) · checked October 20, 2026
E2May 23, 2019arXiv v1 postedGidney & Ekera 2019Google; KTH Royal Institute of Technology · Factoring 2048-bit RSA integers“How to factor 2048 bit RSA integers in 8 hours using 20 million noisy qubits (title); Table 2, (ours) 2019 (parallel): 20 million physical qubits”about 20,000,000 physical qubits“in 8 hours (title); Table 2 expected runtime 0.31 days”about 8 hourserror rate: 10^-3 ("a characteristic physical gate error rate of 10^-3")
cycle: 1 microsecond surface code cycle
reaction time: 10 microseconds
connectivity: planar grid, nearest-neighbor
code: surface code; CCZ magic-state factories
other: abstract-circuit cost given as a formula: 3n + 0.002n lg n logical qubits; no single logical-qubit count is plotted herePeer-reviewed version published April 15, 2021; plotted at the first public (arXiv) date.
How to factor 2048 bit RSA integers in 8 hours using 20 million noisy qubitsQuantum 5, 433 (2021) · checked October 20, 2026
E3Mar. 10, 2021arXiv v1 postedGouzien & Sangouard 2021Universite Paris-Saclay, CEA, CNRS · Factoring a 2048-bit RSA integer“factoring a 2 048-bit RSA integer is shown to be possible in 177 days with 3D gauge color codes assuming a threshold of 0.75 % with a processor made with 13 436 physical qubits and a memory that can store 28 million spatial modes and 45 temporal modes with 2 hours' storage time”13,436 physical qubits (processor only)“Table I, n = 2 048 row: logical qubits 8 284”8,284 logical qubits“177 days”about 177 dayserror rate: 10^-3 ("a characteristic physical gate error rate of 10^-3")
cycle: processor cycle time 1 microsecond
reaction time: not stated in the abstract
connectivity: small processor plus a separate multimode quantum memory
code: 3D gauge color codes, assumed threshold 0.75%
other: requires a memory storing 28 million spatial modes and 45 temporal modes with 2 hours of storage time; the memory is not counted in the 13,436Different architecture: the qubit count covers only the processor. Not directly comparable to whole-machine counts; drawn with an open marker.
Factoring 2048-bit RSA Integers in 177 Days with 13436 Qubits and a Multimode MemoryPhysical Review Letters 127, 140503 (2021) · checked October 20, 2026
E4Feb. 13, 2024IACR ePrint receivedChevignard, Fouque & Schrottenloher 2024Univ Rennes, Inria, CNRS, IRISA · Factoring an RSA-2048 instance“To factor an RSA-2048 instance, we estimate that 1730 logical qubits and 2^36 Toffoli gates will suffice for a single run, and the algorithm needs on average 40 runs.”1,730 logical qubitserror rate: not applicable (logical-level estimate)
code: none; abstract circuit model
other: 2^36 Toffoli gates per run, 40 runs on averageLogical-qubit count only; no physical-qubit estimate. Its approximate residue arithmetic is one of the ingredients of Gidney 2025.
Reducing the Number of Qubits in Quantum FactoringCRYPTO 2025 (LNCS 16001); IACR ePrint 2024/222 · checked October 20, 2026
E5May 21, 2025arXiv v1 postedGidney 2025Google Quantum AI · Factoring a 2048-bit RSA integer“I estimate that a 2048 bit RSA integer could be factored in less than a week by a quantum computer with less than a million noisy qubits. ... The total number of physical qubits is 897864.”897,864 physical qubits (less than a million)“Table 5, n = 2048 row: Qubits 1399 (1,537 logical qubits including idle hot patches, Section 3)”1,399 logical qubits“the actual time estimate per factoring: 4.96 days. Which I round up to a week for slack.”less than a week 4.96 dayserror rate: 0.1% ("a uniform gate error rate of 0.1%")
cycle: 1 microsecond surface code cycle
reaction time: 10 microseconds
connectivity: square grid, nearest-neighbor
code: surface code; yoked surface codes for idle qubits; magic state cultivation
other: same assumptions as Gidney & Ekera 2019Savings come from approximate residue arithmetic (Chevignard et al. 2024), yoked surface codes and magic state cultivation, per the abstract. This is the estimate the Q-Day Note cites.
How to factor 2048 bit RSA integers with less than a million noisy qubitsnot peer-reviewedarXiv preprint · checked October 20, 2026
E6Feb. 12, 2026arXiv v1 posted (values from v2, May 5, 2026)Webster et al. 2026 (Pinnacle)Iceberg Quantum · Factoring 2048-bit RSA integers“2048-bit RSA integers can be factored with fewer than one hundred thousand physical qubits (abstract); Table VI (v2), 1 us cycle, 10^-3 error: 94 kq for a runtime of 1 month or less (135 kq for 1 week, 381 kq for 1 day)”94,000 physical qubits (fewer than 100,000)“fewer than one hundred thousand physical qubits are required for factoring at a physical error rate of p = 10^-3 in an expected runtime of one month”at most 1 montherror rate: 10^-3
cycle: 1 microsecond code cycle
reaction time: 10 microseconds
connectivity: quasi-local connections between physical qubits (not a planar nearest-neighbor grid)
code: quantum LDPC (generalized bicycle) codes
other: uses an algorithm based on Gidney 2025v2 (May 5, 2026) corrected a technical error in v1, per its acknowledgements. v2 text says one week needs 139 thousand qubits while its Table VI says 135 kq; recorded as stated. Requires connectivity that today's fixed-layout superconducting chips do not have; see est-frozen-pinnacle-2026.
The Pinnacle Architecture: Reducing the cost of breaking RSA-2048 to 100 000 physical qubits using quantum LDPC codesnot peer-reviewedarXiv preprint (company authors) · checked October 20, 2026
E7Mar. 30, 2026arXiv v1 postedCain et al. 2026Oratomic; Caltech; UC Berkeley · Factoring RSA-2048 integers“our most time-efficient architectures can potentially enable runtimes of ... 97 days for RSA-2048 with approximately 102,000 qubits”about 102,000 physical qubits“97 days for RSA-2048”about 97 dayserror rate: 0.1% circuit-level depolarizing noise (p = 0.1%)
cycle: 1 ms stabilizer measurement cycle ("Here we assume a 1 ms stabilizer measurement cycle")
reaction time: not stated in the summary
connectivity: reconfigurable neutral-atom arrays (qubits moved by optical tweezers)
code: high-rate lifted-product codes with surgery-based logic
other: time-efficient architecture with up to P = 1,160 Toffoli gates in parallel; the authors call these estimates preliminaryThe headline 10,000-qubit figure refers to the smallest architectures (ECC-256); for RSA-2048 the paper says 11,000 to 14,000 qubits give runtimes roughly two orders of magnitude longer, with no single runtime stated in the text, so only the 102,000-qubit point is plotted. Slow (1 ms) cycle assumed, unlike the 1 us estimates.
Shor's algorithm is possible with as few as 10,000 reconfigurable atomic qubitsnot peer-reviewedarXiv preprint (company and university authors) · checked October 20, 2026
E8Apr. 7, 2026arXiv v1 postedMundada et al. 2026Q-CTRL · Factoring 2048-bit RSA integers“using an experimentally demonstrated grid-coupling topology, factoring RSA-2048 requires 381k physical qubits and 9.2 days, which can be reduced to 4.9 days via addition of an algorithm-specific accelerator for the Adder subroutine (requiring 439k qubits)”about 381,000 physical qubits“the 1,399-logical-qubit program”1,399 logical qubits (Gidney 2025 program)“381k physical qubits and 9.2 days”about 9.2 dayserror rate: 5 x 10^-4 for the superconducting processors ("We assume physical error rates of 5 x 10^-4 and code threshold of 6 x 10^-3")
cycle: 1 microsecond
reaction time: not stated in the summary
connectivity: grid coupling for processors; separate quantum memory modules
code: surface code processors; memory in a long-coherence modality without active error correction
other: heterogeneous design: rare-earth-ion memory parameters T1 ~ 23 days, T2 > 10 hr; 190k qubits if hypothetical long-range coupling allows qLDPC memoryAssumes a lower physical error rate (5 x 10^-4) than the 10^-3 used by most other estimates, plus a memory technology of a different kind. Compiles Gidney 2025's algorithm.
Heterogeneous architectures enable a 138x reduction in physical qubit requirements for fault-tolerant quantum computing under detailed accountingnot peer-reviewedarXiv preprint (company authors) · checked October 20, 2026
E9Sep. 18, 2026arXiv v1 postedWebster et al. 2026 (fixed connectivity)Iceberg Quantum · Factoring a 2048-bit RSA integer“we show that a 2048-bit RSA integer can be factored in one month with approximately 120 000 physical qubits”approximately 120,000 physical qubits“factored in one month”about 1 montherror rate: 10^-3
cycle: 1 microsecond code cycle
reaction time: 10 microseconds
connectivity: fixed connectivity of degree eight (compatible with fabricated superconducting chips)
code: quantum LDPC (Pinnacle variant)
other: adapts est-pinnacle-2026 to fixed wiringSame authors' company as est-pinnacle-2026. Part of Iceberg Quantum's Pinnacle 1.1 release (Sept 22, 2026).
The Pinnacle Architecture with fixed connectivity of degree eightnot peer-reviewedarXiv preprint (company authors) · checked October 20, 2026
Hardware: physical qubits
P1Oct. 23, 2019journal publicationSycamoreGoogle · superconducting“a processor with programmable superconducting qubits to create quantum states on 53 qubits”53 physical qubits54-qubit chip; one qubit did not function, so the device used 53 qubits and 86 couplers
Gate-model processor running full-array circuits.
Quantum supremacy using a programmable superconducting processorNature 574, 505 (2019) · checked October 20, 2026
P2Nov. 16, 2021company announcementEagleIBM · superconducting“127-qubit Eagle processor”127 physical qubitsCompany announcement; the release does not give gate fidelities.IBM Unveils Breakthrough 127-Qubit Quantum Processornot peer-reviewedIBM newsroom · checked October 20, 2026
P3Nov. 9, 2022company announcementOspreyIBM · superconducting“The new 433 qubit 'Osprey' processor”433 physical qubitsCompany announcement; the release does not give gate fidelities.IBM Unveils 400 Qubit-Plus Quantum Processor and Next-Generation IBM Quantum System Twonot peer-reviewedIBM newsroom · checked October 20, 2026
P4Oct. 24, 2023company announcementnext-generation platform (1,225-site array)Atom Computing · neutral atoms“Atom Computing announced it has created a 1,225-site atomic array, currently populated with 1,180 qubits”1,180 physical qubits (array populated with)array sites populated with atoms
Press release; it reports atoms held in the array, not gate benchmarks across all 1,180.
Quantum Startup Atom Computing First to Exceed 1,000 Qubitsnot peer-reviewedPress release (PR Newswire) · checked October 20, 2026
P5Dec. 4, 2023company announcementCondorIBM · superconducting“We have introduced IBM Condor, a 1,121 superconducting qubit quantum processor based on our cross-resonance gate technology.”1,121 physical qubitsIBM describes it as a scale milestone: "With performance comparable to our previous 433-qubit Osprey, it serves as an innovation milestone".The hardware and software for the era of quantum utility is herenot peer-reviewedIBM Quantum blog · checked October 20, 2026
P6Mar. 18, 2024arXiv v1 postedtweezer array (Manetsch et al.)Caltech · neutral atoms“optical tweezers trapping over 6,100 neutral atoms in around 12,000 sites”over 6,100 physical qubitsatoms trapped as qubits with coherence time of 12.6 s reported
Trapping and coherence demonstration; it does not report entangling gates across the array. Not a computer of 6,100 working qubits.
A tweezer array with 6100 highly coherent atomic qubitsNature (2025), doi:10.1038/s41586-025-09641-4 · checked October 20, 2026
P7Aug. 24, 2024arXiv v1 postedWillowGoogle · superconducting“using a 105-qubit processor with similar performance, we realize a distance-7 surface code”105 physical qubitsGate-model processor used for error-correction experiments. Google announced the chip by name (Willow) on December 9, 2024.Quantum error correction below the surface code thresholdNature 638, 920 (2025) · checked October 20, 2026
P8Jun. 25, 2025arXiv v1 postedcontinuously reloaded atom array (Chiu et al.)Harvard / MIT / QuEra · neutral atoms“maintain an array of over 3,000 atoms for more than 2 hours”over 3,000 physical qubitscontinuous reloading of atoms
Demonstrates keeping a large array loaded and coherent; not gate operations across all 3,000.
Continuous operation of a coherent 3,000-qubit systemNature (2025), doi:10.1038/s41586-025-09596-6 · checked October 20, 2026
P9Nov. 7, 2025arXiv v1 postedHeliosQuantinuum · trapped ions“We report on Quantinuum Helios, a 98-qubit trapped-ion quantum processor”98 physical qubitsGate-model processor with all-to-all connectivity. The Q-Day Note's 98-qubit figure.Helios: A 98-qubit trapped-ion quantum computernot peer-reviewedarXiv preprint (company authors) · checked October 20, 2026
P10Jun. 1, 2026arXiv v1 postedmetasurface tweezer array (Wang et al.)Tsinghua University / Qosmos · neutral atoms“Here, we robustly trap 11,000 individual atoms in a tweezer array”11,000 physical qubits (atoms trapped)atoms trapped in a tweezer array generated by a single metasurface
Trapping demonstration; it does not report entangling gates across the array. Not a computer of 11,000 working qubits. Cross-checked with TQINB analysis.
Trapping 11,000 Atoms in a Tweezer Array Generated by a Single Metasurfacenot peer-reviewedarXiv preprint · checked October 20, 2026
Hardware: two-qubit gate accuracy
A1Feb. 19, 2014arXiv v1 posted5-qubit Xmon arrayUC Santa Barbara / Google · superconducting“a two-qubit gate fidelity up to 99.4%”99.4% fidelityCZ gate, randomized benchmarking
Best pair on a small device ("up to").
Logic gates at the surface code threshold: Superconducting qubits poised for fault-tolerant quantum computingNature 508, 500 (2014) · checked October 20, 2026
A2Dec. 14, 2015arXiv v1 postedlaser-driven 43Ca+ gatesUniversity of Oxford · trapped ions“two-qubit and single-qubit logic gates with fidelities 99.9(1)% and 99.9934(3)% respectively”99.9(1)% fidelitytwo ions
Two-ion laboratory demonstration.
High-fidelity quantum logic gates using trapped-ion hyperfine qubitsPhysical Review Letters 117, 060504 (2016) · checked October 20, 2026
A3Mar. 31, 2016arXiv v1 posted9Be+ ion gatesNIST · trapped ions“By creating a Bell state with a deterministic two-qubit gate, we deduce a gate error of 8(4) x 10^-4.”8(4) x 10^-4 errortwo ions; error deduced from Bell-state fidelity
Two-ion laboratory demonstration; large uncertainty (plus or minus 4 x 10^-4).
High-Fidelity Universal Gate Set for 9Be+ Ion QubitsPhysical Review Letters 117, 060505 (2016) · checked October 20, 2026
A4Oct. 23, 2019journal publicationSycamore (53 qubits)Google · superconducting“we repeat the same procedure while simultaneously running two-qubit circuits for the entire array ... we find an average e2 of 0.62%”average, simultaneous operation erroraverage Pauli error over all pairs, all gates running at once (0.36% average in isolation)
Whole-chip average, not a best pair; Pauli error is not identical to 1 minus average fidelity.
Quantum supremacy using a programmable superconducting processorNature 574, 505 (2019) · checked October 20, 2026
A5Apr. 11, 2023arXiv v1 postedRydberg CZ gatesHarvard / MIT / QuEra · neutral atoms“two-qubit entangling gates with 99.5% fidelity on up to 60 atoms in parallel”99.52(4)% fidelityparallel CZ gates on up to 60 atoms
Parallel gates on up to 60 atoms.
High-fidelity parallel entangling gates on a neutral atom quantum computerNature 622, 268 (2023) · checked October 20, 2026
A6Apr. 16, 2024company announcementH1-1Quantinuum · trapped ions“the first demonstration of 99.914(3)% 2-qubit gate fidelity, showing repeatable performance across all qubit pairs on our H1-1 system”99.914(3)% fidelitycommercial system, randomized benchmarking across five gate zones
Company blog; a system-wide figure across all qubit pairs of a smaller commercial machine.
Quantinuum extends its significant lead in quantum computing, achieving historic milestones for hardware fidelity and Quantum Volumenot peer-reviewedQuantinuum blog · checked October 20, 2026
A7Oct. 20, 2025arXiv v1 postedelectronically controlled 40Ca+ gatesOxford Ionics (an IonQ company) · trapped ions“We demonstrate electronically controlled two-qubit gates with an estimated error of 8.4(7) x 10^-5 without ground-state cooling.”8.4(7) x 10^-5 errora pair of ions; subspace-benchmarked
Two-ion demonstration, not a full processor. IonQ's press release (Oct 21, 2025) calls it a world record; we do not rank records.
Trapped-ion two-qubit gates with >99.99% fidelity without ground-state coolingnot peer-reviewedarXiv preprint (company authors) · checked October 20, 2026
A8Nov. 7, 2025arXiv v1 postedHelios (98 qubits)Quantinuum · trapped ions“Averaged over all operational zones in the system, we achieve average infidelities of 2.5(1) x 10^-5 for single-qubit gates, 7.9(2) x 10^-4 for two-qubit gates”7.9(2) x 10^-4 erroraverage over all operational zones of a 98-qubit system
System-wide average on a 98-qubit machine; not comparable one-to-one with two-ion records.
Helios: A 98-qubit trapped-ion quantum computernot peer-reviewedarXiv preprint (company authors) · checked October 20, 2026
A9Apr. 28, 2026arXiv v1 postedRydberg CZ gatesHarvard / MIT / QuEra · neutral atoms“achieve state-of-the-art fidelities of 99.854(4)% which improve to 99.941(3)% upon loss postselection”99.854(4)% fidelityraw value plotted; 99.941(3)% if shots with lost atoms are discarded
Raw fidelity plotted; the higher figure needs postselection.
High-fidelity entangling gates and nonlocal circuits with neutral atomsnot peer-reviewedarXiv preprint · checked October 20, 2026
Hardware: logical qubits
L1Dec. 7, 2023arXiv v1 postedreconfigurable atom array (Bluvstein et al.)Harvard / MIT / QuEra · neutral atoms“Using three-dimensional [[8,3,2]] code blocks, we realize computationally complex sampling circuits with up to 48 logical qubits”up to 48 logical qubits[[8,3,2]] codes: distance 2, which detect but cannot correct an error
Error-detecting code with postselection; not the kind of logical qubit a factoring estimate assumes.
Logical quantum processor based on reconfigurable atom arraysNature 626, 58 (2024) · checked October 20, 2026
L2Nov. 18, 2024arXiv v1 postedneutral-atom processorMicrosoft / Atom Computing · neutral atoms“we demonstrate the entanglement of 24 logical qubits encoded into 48 atoms ... with up to 28 logical qubits encoded into 112 atoms, showing better-than-physical error rates”up to 28 logical qubits24 logical qubits entangled; up to 28 in an algorithm
Small codes; compare code distance before comparing counts.
Fault-tolerant quantum computation with a neutral atom processornot peer-reviewedarXiv preprint (company authors) · checked October 20, 2026
L3Feb. 25, 2026arXiv v1 postedHelios (98 qubits)Quantinuum · trapped ions“benchmarks with between 48 and 94 logical qubits ... 94 logical qubits in iceberg QED codes, and up to 48 logical qubits (the largest for which a full QEC cycle can be executed on Helios)”up to (error-detected) 94 logical qubits94 in error-detecting iceberg codes (distance 2); 48 in concatenated error-correcting codes (distance 4); postselection used
The 94 are error-detected, not error-corrected; the error-corrected count is 48.
Computing with many encoded logical qubits beyond break-evennot peer-reviewedarXiv preprint (company authors) · checked October 20, 2026
L4Jul. 30, 2026company announcementIBM quantum computer company claimIBM / University of Chicago · superconducting“the team executed 70 logical qubits — shielding them from errors to run 2,415 logical two-qubit operations and 468 logical "T gates"”70 logical qubitsencoded random-circuit-style sampling with error detection during the computation
Company claim: IBM newsroom announcement only, not checked by us against a paper; the code and distance are not stated in it. Underlying paper: "Sampling hard circuits with verifiably high fidelity" (not yet checked by us). Shown with an open, dashed marker, never as a measured result.
IBM and The University of Chicago Demonstrate Quantum Advantage, Establishing Trusted Quantum Computation on Logical Circuitsnot peer-reviewedIBM newsroom · checked October 20, 2026
L5Oct. 23, 2026arXiv v1 postedIBM Nighthawk r2 (ibm_phoenix, 120 qubits), distance-3 surface codesUniversity of Sydney (one IBM Quantum co-author) · superconducting“With three logical qubits and lattice surgery, we perform logical teleportation of a range of states and gates, observing fidelities in the range 78% - 93%.”3 logical qubits (three distance-3 surface codes)Three distance-3 surface-code logical qubits with ancilla re-purposing (defect exclusion), entangled by lattice surgery (Sec. II C, Fig. 3). Teleportation fidelities: 78% to 93% in the abstract; the gate-teleportation bars in Fig. 3(d) go as low as 74.2%. Results keep only runs with a clean initial preparation (post-selection yields about 0.85% to 2.4% in Fig. 3(c)-(d); 1.2% for Bell-pair transfer). Separately, a distance-5 surface-code memory reached 0.9% logical error per round with up to three qubits excluded, versus 1.9% without (Sec. I, Sec. II A, Fig. 1; Belief Matching decoder with a noise model; fit over 50 rounds, App. C 1). Two-logical-qubit Bell-state fidelity above 93% via lattice surgery, post-selected on clean preparation (yield 40% +/- 2%), bounded from XX and ZZ only (Fig. 2).
Not below-threshold scaling: the distance-5 memory only matches the best distance-3 codes (Sec. II A), so no Lambda is reported. Fidelities are post-selected on clean preparation. The stability experiment's figure of about 2 x 10^-7 at 170 rounds (8 failures in 50 million runs; walking circuit, Sec. II D, Fig. 4) is not a logical memory error rate and is not plotted. No RSA or ECC resource estimate in the paper.
Entangled logical qubits on a superconducting quantum processornot peer-reviewedarXiv preprint (university authors, one IBM co-author) · checked October 26, 2026
Hardware: error suppression as codes grow (below threshold)
S1Aug. 24, 2024arXiv v1 postedWillow, surface code memoryGoogle · superconducting“The logical error rate of our larger quantum memory is suppressed by a factor of Lambda = 2.14 +/- 0.02 when increasing the code distance by two, culminating in a 101-qubit distance-7 code with 0.143% +/- 0.003% error per cycle”Lambda = 2.14 +/- 0.02memory (storing one logical qubit), distance 3 to 7, real-time decoder
Memory only, not a computation.
Quantum error correction below the surface code thresholdNature 638, 920 (2025) · checked October 20, 2026
S2Dec. 18, 2024arXiv v1 postedcolor code memoryGoogle · superconducting“suppresses logical errors by a factor of Lambda_3/5 = 1.56(4)”Lambda = 1.56(4)color code, distance 3 to 5
Memory plus logic tests; one distance step.
Scaling and logic in the color code on a superconducting quantum processorNature 645, 614 (2025) · checked October 20, 2026
S3Oct. 16, 2026arXiv v1 postedIBM Nighthawk r2 (ibm_phoenix), surface code memoryPNNL and partners (on IBM hardware) · superconducting“an error-suppression factor (Lambda) of 1.68 and 1.85 under maximum-likelihood decoding”Lambda = 1.85 X memory (1.68 Z memory)only one code distance grown (3 to 6), the other fixed at 3; short runs of 3 to 13 rounds
Independent team on cloud hardware; over 150 rounds the gain shrank. See the paper “Demonstration of Logical Error Suppression in a Surface Code Memory on a Cloud-Accessible IBM Superconducting Processor” (arXiv:2610.23840).
Demonstration of Logical Error Suppression in a Surface Code Memory on a Cloud-Accessible IBM Superconducting Processornot peer-reviewedarXiv preprint (no IBM authors) · checked October 20, 2026
S4Oct. 16, 2026arXiv v1 postedHelios-1, color code memoryQuantinuum · trapped ions“error suppression by over an order of magnitude, Lambda = 12 (+3/-2), with each successive increase in code distance”Lambda = 12 (+3/-2)memory over 20 rounds at distance 3, 5 and 7; decoded offline; distance-7 point rests on 3 failures in 29,000 shots
Memory and Clifford gates; magic states not tested; offline decoding. See the paper “Quantum error correction well below the color code threshold” (arXiv:2610.24077).
Quantum error correction well below the color code thresholdnot peer-reviewedarXiv preprint (company authors) · checked October 20, 2026
Hardware: magic states (table only)
M1Dec. 15, 2025arXiv v1 postedmagic state cultivation experimentGoogle Quantum AI · superconducting“Cultivation reduces the error by a factor of 40, with a state fidelity of 0.9999(1) (retaining 8% of attempts).”fidelity 0.9999(1), retaining 8% of attemptssingle magic state; 8% of attempts kept
One ingredient (the magic state) demonstrated at small scale; Gidney 2025 relies on cultivation at very large scale. Shown in the table, not on a chart. Cross-checked with TQINB analysis.
Magic state cultivation on a superconducting quantum processornot peer-reviewedarXiv preprint (company authors) · checked October 20, 2026
Context only: a different problem, not plotted
C1Sep. 4, 2026arXiv v1 postedHaner et al. 2026 (IonQ), not RSA256-bit elliptic curve discrete logarithm on secp256k1 (not RSA-2048)“would be able to solve the ECDLP on secp256k1 in approximately 25.7 days using 19,397 physical qubits with an estimated success probability of 63%”19,397 physical qubits“approximately 25.7 days”approximately 25.7 dayserror rate: two-qubit gate noise 10^-4; single-qubit 10^-5
cycle: 6.7 ms per syndrome extraction cycle (stated in the paper's naive-implementation runtime example)
reaction time: not stated in the summary
connectivity: trapped-ion Walking Cat architecture with ion transport
code: quantum LDPC codes
other: success probability 63% per attemptContext only: a different problem (elliptic curves, used by Bitcoin), so it is not plotted against RSA-2048 estimates. Assumes a 10^-4 two-qubit error, ten times lower than the 10^-3 most RSA estimates use.
Computing 256-bit elliptic curve discrete logarithms in 26 days on a fault-tolerant trapped-ion quantum computer with 20,000 qubitsnot peer-reviewedarXiv preprint (company authors) · checked October 20, 2026

Related reading