For two decades, quantum error correction (QEC) was the field's cruelest paradox. Every serious roadmap acknowledged it as mandatory, yet every serious demonstration seemed perpetually "five years away." The physics was elegant—mathematically airtight, in fact—but the engineering demands were so brutal that even the most optimistic projections felt like science fiction.
The core problem is simple to state and brutal to solve: quantum information is fragile. A single stray photon, a thermal fluctuation, or a vibration in the laboratory floor can destroy the delicate superposition states that give quantum computers their power. This process, called decoherence, happens on timescales of microseconds to milliseconds—far too fast for any useful computation. And unlike classical bits, quantum states cannot be copied or backed up. The no-cloning theorem forbids it.
For years, the consensus was that we'd need millions of physical qubits to create even a few thousand logical ones—an engineering prospect so daunting that it pushed fault-tolerant quantum computing into the 2030s or beyond. The error correction codes themselves were well understood. The hardware to run them was not.
Then something shifted. Between 2024 and 2026, a series of demonstrations transformed QEC from a theoretical necessity into a practical engineering discipline. Google showed that scaling up error correction actually worked—errors dropped exponentially as code size increased. Microsoft and Quantinuum produced logical qubits with error rates 800 times better than their physical constituents. IBM demonstrated fault-tolerant operations, not just storage. And in 2025, researchers at MIT and Harvard kept a logical qubit alive for over a second—an eternity in quantum time.
This article examines how these milestones were achieved, what they mean for the field, and why 2026 marks the moment when quantum error correction moved from theory to practice.
Key Takeaway: Quantum error correction has crossed the threshold from theoretical necessity to practical engineering. The demonstrations of 2024–2026 prove that QEC works, scales, and can be integrated into real computations.
Every quantum computer is built from physical qubits—the actual hardware elements that store and process quantum information. These might be superconducting circuits, trapped ions, or neutral atoms. Physical qubits are noisy. They interact with their environment, lose coherence, and make errors.
A logical qubit is an abstraction: a single unit of quantum information encoded across multiple physical qubits in such a way that errors in any individual physical qubit can be detected and corrected before they corrupt the logical state. Think of it like storing a message in a distributed system with redundancy—except quantum mechanics makes this vastly more complex.
The key insight is that errors, while inevitable, are also detectable. By carefully designing the encoding, you can measure the system in ways that reveal whether an error has occurred without destroying the quantum information itself.
The standard approach to QEC uses what are called stabilizer codes. Here's how it works in practice:
Encoding: A single logical qubit's state is spread across multiple physical qubits using entangled states. For example, in the simplest surface code, the logical state is distributed across a lattice of physical qubits.
Stabilizer measurements: Periodically, you measure certain collective properties of the qubits—called stabilizers—that should have a fixed value if no error has occurred. These measurements don't reveal the quantum information itself; they only reveal whether the system has drifted from its encoded state.
Error syndromes: When a stabilizer measurement returns an unexpected value, it produces an "error syndrome"—a pattern that tells you something went wrong and where. The decoder (more on this later) interprets these syndromes to determine what correction to apply.
Correction: Based on the syndrome, you apply a corrective operation to return the system to its intended state.
The elegance of this approach is that you never need to know exactly what error occurred—only that one did and where. The correction is typically a simple operation that resets the system.
The threshold theorem is the theoretical foundation that makes QEC viable. It states that if the physical error rate per qubit is below a certain threshold (around 1% for surface codes), then you can arbitrarily suppress logical errors by increasing the code size.
This is a remarkable result. It means that you don't need perfect qubits to build a reliable quantum computer—you just need qubits that are "good enough." The theorem guarantees that if you're below threshold, scaling up the code will exponentially reduce the logical error rate.
The practical implication is profound: hardware doesn't need to be perfect; it needs to be good enough to cross the threshold. The 2024–2026 demonstrations proved that modern hardware has crossed this line.
Three main code families dominate current research:
Surface codes are the workhorse of the field. They're geometrically local—meaning operations only happen between neighboring qubits—which makes them physically implementable on most hardware platforms. Their downside is overhead: you need many physical qubits per logical qubit.
Low-density parity-check (LDPC) codes are a newer development that dramatically reduces overhead. By allowing long-range interactions (or clever routing), LDPC codes can achieve the same error suppression with up to 10x fewer physical qubits. These were largely theoretical until 2024, when Bravyi et al. published practical constructions.
Bosonic codes take a completely different approach. Instead of encoding information across many two-level systems, they encode it in the continuous states of a harmonic oscillator—typically a superconducting cavity. The GKP (Gottesman-Kitaev-Preskill) code is the most prominent example, and it offers the possibility of autonomous error correction, where the physics of the system itself corrects errors without active intervention.
The first steps were modest. Researchers demonstrated that error correction worked at all—that a logical qubit could preserve information better than the best physical qubit. These early demonstrations used small codes (distance-2 or distance-3), which can detect or correct only limited numbers of errors.
The results were encouraging but not yet practical. The logical qubits weren't better than physical ones in any meaningful way—they were just proof that the concept worked in real hardware.
The turning point came in late 2024 with Google's Willow chip. Using surface codes of increasing size (distance-3, distance-5, and distance-7), the Google team demonstrated something that had never been shown before: increasing the code size reduced the logical error rate by a factor of 2.5 at each step.
This was the first clear demonstration of the threshold theorem in action. The logical error rate dropped exponentially with code size, exactly as theory predicted. It proved that QEC isn't just a theoretical curiosity—it's a scalable engineering solution.
Key Takeaway: Google's Willow chip in 2024 was the first demonstration that scaling up error correction actually reduces errors exponentially. This validated the entire QEC framework.
In April 2024, Microsoft and Quantinuum announced a different kind of milestone. Using Quantinuum's trapped-ion hardware and Microsoft's qubit virtualization system, they created logical qubits with error rates 800 times lower than the best physical qubit on the same chip.
This was the first time logical qubits were practically better than physical qubits—not just theoretically, but in a way that could be used for meaningful computation. They even ran a chemistry simulation on a logical qubit, demonstrating that QEC could be integrated into real workloads.
Storing quantum information reliably is one thing; computing with it is another. In 2025, IBM demonstrated fault-tolerant CNOT gates—the essential two-qubit operation for quantum computation—on logical qubits. The logical gate error rates were below the physical gate error rates, meaning the error correction was working during computation, not just during storage.
This moved QEC from "error-corrected memory" to "error-corrected computation," a critical distinction for building practical quantum computers.
One of the hidden challenges of QEC is that error correction must happen faster than errors accumulate. If the decoder—the classical processor that interprets error syndromes and determines corrections—is too slow, errors will pile up faster than they can be corrected.
In 2025, a collaboration between Google and university researchers demonstrated a real-time decoder that could process error syndromes at the speed required by the quantum processor. This might sound like an engineering detail, but it's actually a critical milestone. Without real-time decoding, QEC is useless for computation—you can only store information, not process it.
Later in 2025, a team from MIT and Harvard demonstrated a logical qubit with a coherence time exceeding one second, using a GKP code in a superconducting cavity. A second might not sound impressive, but in quantum terms, it's an eternity—long enough for millions of operations.
This demonstration was particularly significant because it showed the power of bosonic codes, which offer a fundamentally different approach to error correction. The GKP code can correct errors autonomously, without the need for constant measurement and feedback.
As of 2026, the focus has shifted from demonstrating QEC to integrating it into real algorithms. Companies including IBM, Google, and PsiQuantum have announced roadmaps to achieve "fault-tolerant quantum advantage" by 2029, with QEC as the central enabling technology.
The demonstrations of 2024–2025 proved the components work. The challenge now is engineering: scaling up from a handful of logical qubits to the hundreds or thousands needed for useful computation.
The most fundamental enabler of practical QEC has been steady improvement in hardware quality. Coherence times have increased by orders of magnitude over the past decade, and gate fidelities have crossed the threshold needed for effective error correction.
Modern superconducting qubits achieve coherence times in the hundreds of microseconds—enough time for thousands of operations. Trapped-ion qubits are even better, with coherence times measured in seconds. These improvements directly translate into lower physical error rates, which means fewer physical qubits are needed per logical qubit.
The development of practical LDPC codes represents one of the most important theoretical advances of the decade. Surface codes require hundreds to thousands of physical qubits per logical qubit. LDPC codes can achieve the same error suppression with an order of magnitude fewer.
The 2024 paper by Bravyi et al. in Nature showed that LDPC codes with practical constructions are possible, and subsequent work has demonstrated them in real hardware. This dramatically reduces the resource requirements for fault-tolerant quantum computing.
Key Takeaway: LDPC codes reduce QEC overhead by up to 10x compared to surface codes, making fault-tolerant quantum computing feasible with far fewer physical qubits.
The GKP code offers a fundamentally different approach to QEC. Instead of encoding information across many discrete qubits, it encodes information in the continuous states of a harmonic oscillator. The key advantage is that certain types of errors can be corrected autonomously—the physics of the system naturally restores the encoded state without active intervention.
The 2025 MIT/Harvard demonstration of a GKP logical qubit with over a second of coherence time showed that this approach is viable in real hardware. Bosonic codes may complement or even replace traditional qubit-based codes for certain applications.
While most attention has focused on superconducting qubits, neutral-atom platforms have emerged as a serious contender. Companies like QuEra and Pasqal have demonstrated high-fidelity operations and, crucially, lower crosstalk between qubits compared to superconducting systems.
Neutral atoms also offer unique advantages for QEC: they can be rearranged mid-computation, enabling the long-range interactions that LDPC codes require. QuEra demonstrated an LDPC code implementation on a neutral-atom platform in 2025, showing a practical path to low-overhead QEC.
One of the dirty secrets of QEC is that it handles Clifford gates (a subset of quantum operations) relatively easily, but universal quantum computation requires non-Clifford gates like the T-gate. These are much harder to protect with error correction.
The standard solution is magic state distillation: preparing noisy T-gates, purifying them through a distillation process, and using the purified states to implement fault-tolerant T-gates. This process has historically been extremely resource-intensive, but recent advances have made it significantly more efficient, reducing the overhead for universal computation.
The decoder is the classical processor that interprets error syndromes and determines what corrections to apply. It's a critical component of the QEC pipeline because the speed and accuracy of decoding directly determine the effectiveness of error correction.
A decoder must solve two problems simultaneously: it must correctly identify what errors occurred (or at least what correction to apply), and it must do so quickly enough to keep up with the quantum processor. Both are challenging. The decoding problem is computationally hard in general, and the time constraint is unforgiving.
Quantum processors operate at microsecond timescales. Each round of stabilizer measurements takes a few hundred nanoseconds to a few microseconds. The decoder must process the resulting syndrome and determine the correction within that same timescale—otherwise, errors accumulate faster than they're corrected.
For small codes, this is manageable. But as codes grow larger, the decoding problem becomes exponentially more complex. A surface code with distance-7 has hundreds of physical qubits and produces thousands of syndrome bits per round. Decoding this quickly enough requires sophisticated algorithms and specialized hardware.
The 2025 Google collaboration demonstrated a decoder that could process error syndromes at the required speed for a distance-7 surface code. This was achieved using a combination of algorithmic improvements and specialized hardware (FPGAs and ASICs).
This might sound like a niche engineering achievement, but it's actually a critical milestone. Without real-time decoding, QEC is limited to error-corrected memory—you can store quantum information reliably, but you can't compute with it. The 2025 demonstration opened the door to error-corrected computation.
The decoding problem is a natural fit for machine learning. Neural network decoders can be trained to recognize error patterns and suggest corrections, potentially achieving better accuracy than algorithmic decoders.
The challenge is speed. Neural network inference is typically slower than algorithmic decoding, though specialized hardware (like TPUs or custom ASICs) can help. Several research groups are working on neural decoders that are both fast and accurate, and this remains an active area of research.
Superconducting qubits are the most mature platform for QEC. Google's Willow chip demonstrated exponential error suppression with surface codes, and IBM has demonstrated fault-tolerant operations on its heavy-hex lattice architecture.
The advantages of superconducting qubits are speed (gate times in nanoseconds) and manufacturability (they're fabricated using standard semiconductor processes). The disadvantages are relatively short coherence times and significant crosstalk between qubits.
Trapped-ion systems, exemplified by Quantinuum's hardware, offer the best physical qubit quality of any platform. Their coherence times are measured in seconds, and gate fidelities are the best in the industry.
The Microsoft/Quantinuum demonstration of logical qubits with 800x improvement over physical qubits was enabled by these exceptional physical properties. The main challenge for trapped ions is speed—gate operations are much slower than in superconducting systems.
Photonic quantum computers take a fundamentally different approach. Instead of manipulating matter-based qubits, they use photons—particles of light—which are naturally resistant to decoherence.
PsiQuantum, the most prominent photonic quantum computing company, has integrated QEC into its hardware design from the ground up. Their approach uses measurement-based QEC, where the error correction is built into the architecture rather than added on top. They're targeting fault-tolerant operation with millions of qubits by 2029.
Neutral-atom platforms offer a unique combination of advantages: high-fidelity operations, low crosstalk, and the ability to rearrange atoms mid-computation. This last feature is particularly valuable for LDPC codes, which require long-range interactions.
QuEra's 2025 demonstration of LDPC codes on a neutral-atom platform was a significant milestone, showing a practical path to low-overhead QEC. The main challenge for neutral atoms is speed—gate operations are slower than in superconducting systems, though comparable to trapped ions.
Each platform has its own sweet spot in the QEC design space. Superconducting systems are fast but require more physical qubits per logical qubit. Trapped ions have the best physical qubits but are slower. Photonic systems offer natural scalability but require sophisticated measurement-based QEC. Neutral atoms offer flexibility but are still maturing.
The ultimate winner isn't predetermined—it will depend on which platform can achieve the best combination of low physical error rates, fast operations, and manufacturability at scale.
Key Takeaway: No single QEC approach has won yet. Superconducting, trapped-ion, photonic, and neutral-atom platforms each offer distinct trade-offs, and the field is still converging on the optimal architecture.
The overhead of QEC is the elephant in the room. For surface codes, a single logical qubit requires anywhere from 100 to 1000 physical qubits, depending on the desired level of error suppression. This is why early roadmaps called for millions of physical qubits.
LDPC codes dramatically reduce this overhead. With LDPC codes, the physical-to-logical ratio drops to roughly 10–100, depending on the code parameters. This is the difference between a quantum computer that fits in a large room and one that fits in a modest lab.
The overhead story gets more complicated when you consider universal computation. Clifford gates (which include CNOT, Hadamard, and phase gates) can be implemented fault-tolerantly with relatively modest overhead. But non-Clifford gates, like the T-gate, require magic state distillation, which is enormously resource-intensive.
Early estimates suggested that magic state distillation could dominate the resource requirements of fault-tolerant computation. Recent advances have reduced this overhead, but it remains a significant cost factor. Some researchers are exploring alternative approaches, such as using LDPC codes that have transversal T-gates, to reduce this burden.
The choice between surface codes and LDPC codes involves a fundamental trade-off. Surface codes require more physical qubits but are simpler to implement—they only require nearest-neighbor interactions. LDPC codes require fewer qubits but need long-range interactions, which are harder to engineer.
The neutral-atom platform's ability to rearrange atoms makes LDPC codes more practical, while superconducting systems are better suited to surface codes. This is why the code choice is tightly coupled to the hardware platform.
Several companies have announced roadmaps to fault-tolerant quantum advantage by 2029:
These roadmaps are ambitious, but the 2024–2026 demonstrations have made them plausible. The question is no longer whether QEC works—it's whether the engineering can scale fast enough.
One of the most common misconceptions about QEC is that it makes quantum computers error-free. This is not the case. QEC suppresses errors—it reduces them to a manageable level—but it doesn't eliminate them entirely.
The logical error rate decreases exponentially with code size, but it never reaches zero. For practical purposes, this is fine: you can make the error rate low enough that it doesn't meaningfully affect your computation. But it's important to understand that QEC is about managing errors, not eliminating them.
A related misconception is that the measurement process inherent in QEC destroys the quantum information. This would be true for naive measurements, but QEC uses carefully designed stabilizer measurements that reveal error information without revealing the logical state.
This is the key insight that makes QEC possible: you can learn about errors without learning about the information being protected. The stabilizer measurements are specifically designed to be "blind" to the logical state.
Adding more physical qubits to a QEC code doesn't automatically improve performance. If the physical error rate is above the threshold, adding more qubits actually makes things worse—the errors compound faster than the code can correct them.
This is why the threshold theorem is so important. It defines the boundary between useful and counterproductive error correction. Below threshold, scaling helps. Above threshold, scaling hurts. The 2024–2026 demonstrations were so significant because they showed that modern hardware is firmly below threshold.
Early QEC demonstrations focused on memory—storing quantum information reliably. But practical quantum computing requires computation, which means performing operations on logical qubits.
Fault-tolerant gates are much harder to implement than error-corrected storage. The IBM demonstration of logical CNOT gates in 2025 was a critical milestone because it showed that computation with error correction is possible. But universal fault-tolerant computation remains a significant engineering challenge.
The choice of QEC code is not purely theoretical—it's tightly coupled to the hardware platform. Surface codes work well on superconducting systems because they only require nearest-neighbor interactions. LDPC codes are better suited to platforms that can support long-range interactions, like neutral atoms.
Similarly, bosonic codes like GKP are only practical on platforms with high-quality harmonic oscillators, such as superconducting cavities. The optimal code depends on the specific strengths and weaknesses of the hardware.
The 2026 focus is on integrating QEC into real algorithms. Quantum chemistry is the most promising near-term application—it requires modest numbers of logical qubits (hundreds, not thousands) and offers clear advantages over classical methods.
The Microsoft/Quantinuum demonstration of a chemistry simulation on a logical qubit was a proof of concept. The next step is scaling up to problems that are genuinely intractable on classical computers.
The consensus roadmap targets fault-tolerant quantum advantage by 2029–2030. This means a quantum computer that can solve problems beyond the reach of classical computers, with errors suppressed to the point where they don't affect the results.
This is an ambitious timeline, but the 2024–2026 demonstrations have made it plausible. The key remaining challenges are scaling up the number of logical qubits, reducing overhead, and integrating QEC with practical algorithms.
Several open problems remain:
Reducing overhead further: LDPC codes have reduced overhead, but more efficient codes would help. Theoretical work on quantum LDPC codes with better parameters is ongoing.
Improving decoders: Real-time decoding works for current code sizes, but scaling to larger codes will require faster and more accurate decoders. Machine learning approaches are promising but not yet practical.
Scaling up: The current demonstrations use a handful of logical qubits. Scaling to hundreds or thousands of logical qubits is primarily an engineering challenge, but it's a formidable one.
The impact of practical QEC extends beyond quantum computing itself. The techniques developed for QEC—stabilizer measurements, syndrome decoding, fault-tolerant operations—are finding applications in other areas, including quantum sensing and quantum communication.
For industry, the path to fault-tolerant quantum computing opens up applications in drug discovery, materials science, optimization, and cryptography. The 2029–2030 timeline for fault-tolerant advantage suggests that these applications could become practical within the next few years.
Key Takeaway: The focus has shifted from demonstrating QEC to integrating it into real algorithms. The path to fault-tolerant quantum advantage by 2029–2030 is now plausible, though significant engineering challenges remain.
The state of quantum error correction in 2026 is fundamentally different from what it was even two years ago. The 2024–2025 demonstrations proved that QEC works, scales, and can be integrated into real computations. The focus has shifted from "does it work?" to "how do we scale it?"
Google's Willow chip showed that increasing code size reduces logical error rates exponentially. Microsoft and Quantinuum demonstrated logical qubits with error rates 800 times better than physical qubits. IBM showed fault-tolerant computation, not just storage. The MIT/Harvard team kept a logical qubit alive for over a second. And real-time decoding made error-corrected computation possible.
These milestones matter because they transform QEC from a theoretical necessity into a practical engineering discipline. The path to fault-tolerant quantum advantage by 2029–2030 is now plausible, and the remaining challenges—scaling up, reducing overhead, improving decoders—are engineering problems, not fundamental physics problems.
Quantum error correction is no longer the field's cruelest paradox. It's the cornerstone upon which practical quantum computing will be built. The next few years will determine just how quickly that foundation can be expanded.
Quantum computers are inherently noisy. Physical qubits interact with their environment, causing decoherence and errors. Unlike classical bits, quantum states cannot be copied or backed up, so errors must be detected and corrected in place. Without error correction, quantum computations would be corrupted before they can complete.
Physical qubits are the actual hardware elements—superconducting circuits, trapped ions, or neutral atoms—that store quantum information. They're noisy and error-prone. Logical qubits are abstract units of quantum information encoded across many physical qubits using error correction techniques. A logical qubit is much more reliable than any individual physical qubit.
QEC encodes a logical qubit across many physical qubits, then periodically measures stabilizers—collective properties that reveal whether errors have occurred without revealing the logical state itself. When errors are detected, a decoder interprets the error syndrome and determines what correction to apply. This process suppresses errors exponentially as the code size increases.
The error threshold is the physical error rate below which QEC can suppress errors. For surface codes, this threshold is approximately 1%. If the physical error rate is above the threshold, adding more qubits makes things worse. Below the threshold, scaling up the code reduces logical errors exponentially. The threshold theorem guarantees this behavior.
The main challenges are overhead (many physical qubits are needed per logical qubit), the cost of non-Clifford gates (which require resource-intensive magic state distillation), real-time decoding (which must keep up with the quantum processor), and scaling up to hundreds or thousands of logical qubits.
As of 2026, QEC has been demonstrated in real hardware with logical qubits that are significantly more reliable than physical qubits. Google, IBM, Microsoft, and Quantinuum have all demonstrated key milestones. The focus has shifted to integrating QEC into real algorithms, with several companies targeting fault-tolerant quantum advantage by 2029.
The main code families are surface codes (geometrically local, high overhead, well-suited to superconducting hardware), LDPC codes (lower overhead, require long-range interactions, well-suited to neutral atoms), and bosonic codes like GKP (encode information in harmonic oscillators, offer autonomous error correction).
For surface codes, typically 100–1000 physical qubits are needed per logical qubit, depending on the desired error suppression. LDPC codes reduce this to roughly 10–100 physical qubits per logical qubit.
A decoder is the classical processor that interprets error syndromes and determines what corrections to apply. It must be fast enough to keep up with the quantum processor and accurate enough to correctly identify errors. Real-time decoding was demonstrated in 2025, enabling error-corrected computation.
Several companies have announced roadmaps to fault-tolerant quantum advantage by 2029–2030. The 2024–2026 demonstrations have made these timelines plausible, though significant engineering challenges remain in scaling up to hundreds or thousands of logical qubits.
Subscribe to our newsletter for the latest breakthroughs in quantum computing and error correction.