Fault-Tolerant Quantum Computers

Fault-tolerant quantum computing, or FTQC, is about one problem, errors. The best machines today still slip often. The most accurate, by its maker’s account, gets a basic two-qubit step wrong in about 8 of every 10,000 tries. Useful jobs, such as designing a new catalyst for industry or breaking a code that guards bank data, need millions or billions of those steps in a row. So the errors have to be caught and fixed while the program runs.

The idea is almost as old as quantum hardware. In December 1995 a team including Christopher Monroe reported a working two-qubit logic gate in a trapped ion. In 1996 Peter Shor showed how to compute with error-correcting codes. By 1998 Aharonov and Ben-Or, Kitaev, and Knill, Laflamme and Zurek had proved what is now called the threshold theorem. It says that if faults are rare enough and not strongly linked to one another, adding more qubits makes the whole machine more reliable rather than less, however long the calculation runs. Experiments have now shown the theorem’s central prediction on small codes. Nobody has yet built a machine that keeps the promise for a whole useful program.

Fault tolerance means fixing errors faster than they pile up

A qubit is fragile. It is the basic unit of a quantum computer, and heat, stray signals and tiny flaws in the chip can knock it out of its state within a fraction of a second. You cannot copy a qubit to keep a spare, because quantum physics forbids it. Error correction gets round this by spreading one piece of information across many physical qubits. No single fault can then wipe it out.

The protected unit is called a logical qubit. It is the one reliable qubit a program sees, built from many unreliable ones underneath, and helper qubits check the group again and again without reading the data itself. Then the decoder, a classical chip or program that reads those checks and works out which fault most likely happened, says what to fix. On Google’s Willow chip one round of checks takes about 1.1 microseconds. Fall behind and the errors win.

Two numbers decide whether any of this works. The first is the threshold. It is the error rate per step below which adding qubits helps rather than hurts. For the surface code, the most studied layout, it is about 1 per cent in the most favourable analyses. The widely cited 2012 simulation by Fowler and colleagues put it at 0.57 per cent. The second is code distance, the smallest number of faults that can corrupt the stored information without being noticed, so a bigger distance means a sturdier code. A distance-d code can correct up to (d−1)/2 faults, rounded down, so a distance-2 code can only detect one.

A full computer needs one more ingredient. The easy family of operations, called Clifford gates, can be protected cheaply, but on their own they cannot run every program a quantum computer is meant to run. The missing ones, non-Clifford gates, come from magic states, qubits prepared in a special state, then checked and fed in. Sergey Bravyi and Alexei Kitaev set out how to purify them in 2005. Making enough is still one of the largest costs in published designs. Our guide to quantum error correction covers the codes in more depth.

Today’s machines are not fault-tolerant because their errors come too often for long programs

The best physical qubits are now very good. They are still not good enough. Quantinuum’s 98-qubit Helios, launched in November 2025, gets about 8 in 10,000 two-qubit steps wrong on average, a figure the company calls the highest fidelity of any commercial system. A program with a million such steps would still be swamped by errors long before it finished.

Fault tolerance closes the gap by stacking protection on top of the hardware. Quantinuum’s own researchers put the logical error rates needed for early fault-tolerant work at one in a million to one in a hundred million, far below what any bare qubit manages today. IBM’s planned Starling machine is meant to run 100 million operations. That is the gap error correction has to cover.

Machines without full protection are called NISQ machines. John Preskill coined the name in 2018, short for noisy intermediate-scale quantum, and our guide to NISQ explains what such machines can and cannot do. Preskill has since described a stage in between, the megaquop machine, which runs about a million reliable steps and is the subject of our megaquop explainer. That goal is smaller than full fault tolerance, and nearer.

Google showed in December 2024 that a bigger code now means fewer errors

The most cited result came from Google Quantum AI. In a paper published in Nature in December 2024, its team ran surface codes on the Willow chip at distances three, five and seven. Each step up cut the logical error rate by a factor of about two. The largest code used 101 qubits and failed about 0.14 per cent of the time per round, a result the paper’s title sums up as error correction below the surface code threshold.

Two other findings matter as much. The protected qubit lasted 2.4 times longer than the best single qubit on the chip, which the paper calls beyond break-even. The factor of about two and the about 0.14 per cent came from decoding the data afterwards on separate computers. On a second, 72-qubit chip the team also decoded in real time at distance five, and that decoder kept pace with the cycle for up to a million rounds, giving a factor of 2.0. It returned each answer about 63 microseconds after the last round, but did not yet feed its corrections back into the circuit.

The paper is candid about what is left. In longer tests on simpler repetition codes, rare bursts of linked errors, arriving roughly once an hour, set a floor that adding more distance alone did not remove. This was one logical qubit holding its memory, not a computer running a program. Our profile of Google Quantum AI covers the wider programme.

Trapped ions and neutral atoms have run dozens of logical qubits, mostly with error detection

Quantinuum has the longest run of results on trapped ions, charged atoms held in place by electric fields. In April 2024, working with Microsoft, it reported logical qubits with error rates 4.7 to 800 times lower than the physical ones. The best figures relied on discarding flagged runs. In June 2025, on its 20-qubit H1-1, it ran a protected non-Clifford gate using magic states, which were made in a small error-detecting code with about 15 per cent of attempts thrown away. The gate’s error was at most 2.3 in 10,000, against 1 in 1,000 for the bare gate.

Then came Helios. At its launch Quantinuum reported 94 logical qubits beating bare ones with error detection. It reported 48 with error correction, in a test of preparing and reading out the qubits rather than running a program. Detection is not correction. A detecting code spots that something went wrong and throws that run away, while a correcting code fixes the fault and carries on, which is what a long program needs. Quantinuum’s September 2026 paper on Helios went further. It reported an error between about 2 and 11 in 100,000, with a central estimate near 5, per logical qubit per round of correction, without throwing away a single run. Our report on its Helix codes has more.

Neutral atoms are single atoms held by laser beams. They can be moved mid-run. On raw count they have grown fastest. In December 2023 a Harvard-led team working with QuEra reported a processor of up to 280 physical qubits. It ran circuits on up to 48 logical qubits in small blocks that catch errors. The gains came from discarding runs in which an error was detected. A follow-up in Nature in November 2025, with up to 448 atoms, is one the team says showed every main part of a full fault-tolerant design.

Microsoft and Atom Computing used ytterbium atoms. In November 2024, on a 256-qubit machine, they linked 24 logical qubits held in 48 atoms. They also ran a simple test program on up to 28 logical qubits spread across 112 atoms, and the coded runs made fewer errors than the bare atoms did. Lost atoms were corrected, but other errors were only detected, and those runs were discarded. Their trick is to design the operations so that key errors turn into missing atoms, which a camera can spot. Atom Computing is now in DARPA’s final test stage with its neutral-atom design. Microsoft is there separately, with its topological design.

Cheaper codes and faster decoders decide how big the machine must be

The surface code is reliable but costly. A logical qubit good enough for serious work needs of order a thousand to ten thousand physical qubits, on Fowler and colleagues’ estimate. IBM has bet on a different family, quantum low-density parity-check codes, which our guide to qLDPC codes explains. Its March 2024 paper in Nature showed in simulation that 12 logical qubits could be kept for nearly one million rounds with 288 physical qubits, at an error rate of 0.1 per cent. The surface code would need nearly 3,000 for the same job. The catch is wiring, since each qubit must link to six others, some of them far across the chip.

Amazon Web Services attacked the cost from the hardware side. Its Ocelot chip, unveiled in February 2025, uses cat qubits, which store information in a microwave resonator so that one kind of error, the bit flip, becomes very rare. A short chain of five such qubits then corrects the other kind. AWS says the approach could cut the cost of error correction by up to 90 per cent. The Nature paper is more modest. It reports a logical error under 2 per cent per round, which makes the chip a proof of principle rather than a memory anyone could use yet, as our Ocelot report notes.

Alice & Bob builds only cat qubits. The Paris company raised €100 million in January 2025, and told TechCrunch at the time that its first useful quantum computer would be available by 2030. Our profile of its chief executive, Théau Peronnin, looks at the bet in detail. Neither firm has yet run a long computation on cat qubits.

Decoders are the less visible half of the problem. Riverlane, a Cambridge firm, published one in December 2025. It runs on chips that can be rewired in software and handles each round in under a microsecond. In a simulation it reached a million error-free steps with four times fewer physical qubits than a standard decoder, because it adapts when qubits slip out of their working states. Our report on Riverlane’s Deltaflow covers the product built on it.

Breaking RSA would take under a million noisy qubits and under a week, on Google’s assumptions

Resource estimates are where fault tolerance meets the real world. They are often misread. In May 2025 Craig Gidney of Google Quantum AI estimated that a 2048-bit RSA key could be factored in less than a week by a machine with less than a million noisy qubits. RSA-2048 is still widely used to sign web certificates and software. His 2019 estimate with Martin Ekerå had needed 20 million qubits and eight hours. The drop came from smarter arithmetic, denser storage of idle qubits and cheaper magic states, and it was bought partly with a longer run. The hardware assumptions are unchanged from 2019.

The assumptions carry the result. Gidney assumed a square grid of qubits that talk only to their neighbours, a gate error rate of 0.1 per cent, a correction cycle of one microsecond and controls that react in ten microseconds. No machine meets all of those at that scale. The largest atom array we found published, 6,100 atoms trapped at Caltech in September 2025, did not run error correction. The largest machines in this guide that did held a few hundred qubits.

That is why governments are moving now. Data stolen today could be decrypted once such a machine exists, and in August 2024 NIST published its first post-quantum standards, including FIPS 203 for key exchange. Our guides to Q-Day and post-quantum cryptography cover the switch. The useful reading of Gidney’s paper is that the target keeps shrinking, not that the machine is close.

Every date for a large machine is still a target, and the earliest is 2027

Each date below is a company’s or agency’s own target, in its own words. None of these machines exists yet. Dates in this field have slipped before, and each firm counts logical qubits and errors its own way, so the years do not line up neatly.

IonQ does not use the word fault-tolerant for its 2027 row, and its roadmap does not say what its error figure is measured per. If it means per logical operation, it would sit within the one in a million to one in a hundred million that Quantinuum’s researchers describe as the early fault-tolerant range. Atom and ion builders quote large logical counts soon. Their qubits can be moved to meet any other qubit, which suits the cheaper codes, while superconducting builders work with fixed wiring but much faster rounds of checks. Google and PsiQuantum are not in the table. On the pages we checked, they give milestones and sites but no year for a full machine.

DARPA will test six designs for a machine worth more than it costs by 2033

The most serious outside check is DARPA’s Quantum Benchmarking Initiative. It asks whether any approach can reach utility scale, which DARPA defines as computational value that exceeds its cost, by 2033. It chose nearly 20 companies for its first stage in April 2025. In the final stage, Stage C, a government team works with each firm to test whether its proposed machine can be built as designed and run as intended.

Six firms are now in Stage C. Microsoft and PsiQuantum reached it through US2QC, an earlier DARPA pilot that picked them for its final phase in February 2025. On 7 October 2026 Atom Computing, Diraq, IBM and IonQ joined them, as our report on the final stage covered. Between them the six span neutral atoms, silicon spin qubits, superconducting chips, trapped ions, light and Microsoft’s topological approach, and DARPA says the programme is not meant to pick a single winner.

For a buyer this may be the most useful date in the field. A vendor’s roadmap is a promise. DARPA’s verdict will be an outside judgement on whether the machine can be built at all, made by a government team that has worked through the designs. The Energy Department’s 2028 goal adds a nearer check. Its competition offers up to $215 million in planned funding, most of it still to be approved by Congress, for machines with at least 100 logical qubits. Our analysis of the quantum Manhattan Project idea compares this public money with past crash programmes.

The clearest gains are in simulating molecules and factoring large numbers

Fault-tolerant quantum computing will not give anyone a faster laptop. Its gains are narrow. They come where quantum effects give a big edge, mainly in modelling molecules and materials and in factoring big numbers. Chemistry is the clearest case. A 2017 study estimated what a quantum computer would need to work out the reaction steps of nitrogenase, the enzyme bacteria use to turn nitrogen from the air into fertiliser. A 2021 update by Lee and colleagues put the cost of calculating the energy of FeMoco, the enzyme’s active site, at about four million physical qubits running for under four days. That assumes a 0.1 per cent gate error and one microsecond cycles.

On these two estimates, made under the same hardware assumptions, the code-breaking job needs fewer qubits than the chemistry one. Both counts have fallen sharply in a few years, and the order could change. Elsewhere the gains shrink. Searching unsorted data gains only a square-root speed-up, and the overheads of error correction can cancel that out. Email and video will not change.

The biggest change may be to security. It comes before the machine does, because encrypted data can be copied and stored now and then broken later, once a large enough machine exists. That is why the switch to new encryption has to come first. A firm that waits for news of a working fault-tolerant computer will already be late.

No one is clearly closest, because each leader wins a different test

Asking who is ahead has no single answer yet. Google has the cleanest demonstration that its errors shrink as codes grow. Quantinuum claims the most accurate commercial hardware, and reports 94 logical qubits beating bare ones when runs that flag an error are thrown away, and 48 when errors are corrected. Harvard and QuEra have shown the main parts of a fault-tolerant design on hundreds of atoms. IBM has published a dated plan built on cheaper codes.

The honest summary for October 2026 is that each main ingredient of fault tolerance has been demonstrated, mostly one at a time and at small scale. Several were shown only by discarding runs or decoding after the fact. Nobody has yet joined the parts into one machine. It would need to run a long, useful program from start to finish. When the next claims arrive, check three things, the logical error rate per operation, how it changes as the code grows, and whether any runs were thrown away. Those will show when fault-tolerant quantum computing has arrived, far better than qubit counts.