How close are fault-tolerant quantum computers?

Why care? The quantum algorithms with proven speedups need billions of steps in a row. Today's machines make too many mistakes to get that far. Fault tolerance is the fix. Until it works at scale, the famous algorithms stay on paper.

Start with the problem. A physical qubit is one real piece of hardware that holds quantum information. Today's physical qubits fail about once every thousand operations. Some do better and some worse; see how to read hardware specs. The useful algorithms need billions of operations without a single uncorrected error.

Do the arithmetic. One error per thousand is an error rate of 10^-3. A billion clean steps needs an error rate near 10^-9 or smaller. From 10^-3 to 10^-9 is six powers of ten. So raw hardware falls short by six or seven orders of magnitude, which means factors of ten.

Fault tolerance closes that gap with backup. Many physical qubits work together to store one logical qubit. Helper qubits, called ancillas, are measured again and again to spot errors. A normal computer, the decoder, reads those checks and works out the fixes in real time.

Think of a spell-checker that runs while you type. It spots a slip and fixes it before the mistake spreads. The example has a limit. You cannot copy a qubit, or peek at it without disturbing it. So the checks compare qubits with each other. They never read the stored value itself.

The threshold theorem says this works. As the code grows, logical errors shrink exponentially: each size step divides the error by a steady factor. But that only happens once physical error rates are below a certain level, the threshold. The price is overhead. It takes about 100 to 1,000 physical qubits per logical qubit. The exact number depends on the code and on the error rate you want.

So "how close?" is really three questions:

• Is the hardware below threshold? Yes, that has been shown.
• Can logical qubits compute, not just store? Partly, at small scale.
• Can anyone build enough of them? Not yet. That is what the roadmaps promise.

Here is the path since 2023. Each step is real, and each step is limited.

• 2024 (April to September): Microsoft and Quantinuum ran logical circuits with error rates up to hundreds of times below the physical qubits' rates. They scaled to 12 entangled logical qubits. Entangled means the qubits' results are linked, so they must be described together. The circuits were shallow, meaning only a few steps long. They also used heavy postselection: runs where an error was spotted were thrown away.
• 2024 (December): Google's Willow showed below-threshold error correction. It used a surface code, a grid of qubits that check their neighbours. A code's distance measures its size and strength, and Willow reached distance 7. Each step up in distance cut the error rate by more than half. This was one logical qubit, storing information rather than computing.
• 2025: Quantinuum made high-quality logical magic states at small scale. Magic states are special prepared qubits. They supply the extra gates that make logical computing universal, meaning able to run any algorithm.

Notice what the list is missing. There is no deep logical circuit. No algorithm has run fault-tolerantly from start to finish. No machine has more than a few dozen logical qubits. The demonstrations test the recipe. Nobody has cooked the meal yet.

Trust them as targets, not deliveries. IBM and Quantinuum have both staked public roadmaps on 2029-2030. IBM's plan is Starling: 200 logical qubits running 100 million gates. Quantinuum's plan is Apollo: hundreds of logical qubits. Both name smaller systems along the way. That makes the claims testable year by year, which is healthy. This industry has also missed dates before.

Rather than watching announcements, watch four numbers:

• The error-suppression factor per code-distance step. That is how many times smaller the error gets each time the code grows. Willow's was about 2.14. It needs to hold at larger sizes.
• Logical two-qubit gate error rates. Storing is the easy part. Computing with pairs of qubits is harder.
• Magic-state production rates.
• Decoder speed at scale.

Here is why the first number matters. If the factor stays at 2.14, three more distance steps cut the error by 2.14 × 2.14 × 2.14 ≈ 9.8. That is about ten times. If the factor shrinks as codes grow, that gain fades fast.

Steady progress on all four makes 2029-2030 believable for first systems. A stall on any one pushes everything later.

What would change this page's answer? A logical algorithm that actually runs: dozens of logical qubits, thousands of logical gates, and no thrown-away runs. That would move useful fault tolerance from roadmap to imminent. On the other hand, if error suppression stops improving as codes grow, timelines get much longer. For what this unlocks if it works, see the quantum advantage assessment.

The devices on the QPU index are almost all physical-qubit machines. They have roughly 100-1,000 noisy qubits. Their two-qubit gate errors are around 0.1-1%, which is 1 to 10 mistakes per 1,000 operations. No error correction is applied to your circuits. Cloud services commonly offer error mitigation, which is clever clean-up after the run. Error correction is not something you can switch on.

There is one narrow exception. Microsoft's Azure Quantum offers early access to small numbers of "reliable" logical qubits on Quantinuum hardware. That is useful for trying out logical-qubit workflows. But it means about a dozen logical qubits, not the hundreds that algorithms need.

Note that the lab on this site is a noiseless simulator. Your circuits run error-free there, which is exactly the luxury real hardware lacks. Run the same circuit in the lab and on real hardware, then compare. It is the fastest way to feel why fault tolerance matters.