In a new paper, Quantinuum scientists have perfected a way of doing maths with diagrams instead of symbols

• Record accuracy: Using Quantinuum’s logical error-correction architecture, Helios achieved a logical memory fidelity of 99.9995%—just five uncorrectable errors per million operations—reducing logical memory errors tenfold compared with Quantinuum’s September record and more than 100-fold compared with the superconducting record.
• Errors fall exponentially as protection grows: Each tested increase in code distance reduced logical memory errors by an average factor of 12, and logical gate errors by an average factor of 9, demonstrating the exponential error suppression needed to scale toward longer, more reliable quantum computations.
• A flexible path to fault tolerance: Successive breakthroughs using different codes within the same logical architecture, on the same commercial Helios hardware, demonstrate how accuracy and qubit efficiency can be optimized as Quantinuum advances toward Apollo in 2029.

‍‍
Recently, we started making the case that that theNISQ¹ era is coming to an end. At Quantinuum, we’ve already demonstrated numerous QEC codes, all the primitives needed for logical computation, steadily declining logical error rates, and full computations at the logical level.

To truly leave the NISQ era, though, we need to demonstrate a “megaquop” machine – a quantum computer that can run over a million operations error-free. With our latest result, we are on the cusp of this monumental achievement: using Quantinuum’s logical error-correction architecture, Helios achieved a logical memory fidelity of 99.9995%— or a million operations with only 5 uncorrectable errors, a new world record. This logical error rate is ten times lower than our September record and more than 100 times lower than the record achieved on a superconducting system.

Coming after September’s Helix-code demonstration on the same Helios hardware, this result shows how our flexible logical architecture and highly accurate trapped-ion technology support rapid improvements in accuracy.

These results indicate that an Apollo-scale machine could reach the fault-tolerant quantum advantage regime using 30x fewer physical qubits than other leading approaches, reinforcing our path to Apollo, our first universal fault-tolerant quantum computer.

A quantum memory that lasts

At Quantinuum, we don’t have delicate qubits that can only hold their state for milliseconds at a time. We’ve already shown quantum memories lasting over 20 seconds. However, this latest result takes it to a whole new level: we have demonstrated the most robust quantum memory ever recorded.

This latest result was enabled by something scientists call “distance scaling”, a key result in quantum error correction (QEC) theory: the prediction that error rates should be suppressed exponentially as longer distance codes (more physical qubits per logical qubit) are used.

In experiments using color codes of distance 3, 5 and 7, Helios (with code written in Guppy) reduced the logical failure rate by an average factor of 12 each time the code distance increased. At distance 7, the system achieved a logical fidelity of 99.9995% per syndrome-extraction cycle, equivalent to a failure probability of just 5 × 10⁻⁶. This nearly “six nines” result sets a new record for logical accuracy through quantum error correction.

To measure the failure rate of something that rarely fails, you must run it for a long time. This ensures that you get reasonable enough statistics to feel comfortable that your measured value isn’t just a statistical fluctuation (scientists call this 'averaging down’ the uncertainty in your measurement).

When you only get an error 5 times in a million rounds, this often means ‘averaging down’ for a long time to even see an error².

“We felt a mix of excitement and suspense every time the results came in. When errors are this rare, each one really matters."

- Dr. Adam Reed, Lead Physicist, Commercial Operations

More than a memory: high-fidelity logical gates

The team also explored logical computation, measuring 2-qubit Clifford gate fidelity at increasing code distance. In this case, the team measured a suppression factor Λ of 9 when stepping the code distance up from 3 to 5, proving again our hardware’s exponential error suppression³.

If one assumes a “Clifford + T” model of universal computation (with T gates teleported via magic state injection), then a fully fault tolerant processor built with this code will have three crucial components:

1. Magic state preparation
2. Two-qubit Clifford gates
3. Syndrome extraction gadgets.

This work demonstrates high accuracy implementation and below threshold scaling of the latter two, and we demonstrated the first in a separate paper (with the same code) back in 2025.  Teleporting T gates via magic state injection will require real-time decoding, which we first demonstrated back in 2021 and have been refining ever since – in fact, this work shows that this is viable for near-optimal decoders. There is still work to be done, however: nobody has yet demonstrated below threshold scaling for magic state preparation.

We’ve already put almost everything together in the Helix code. Soon, we will be integrating all these color-code components into increasingly large, reliable computations. Our ability to fully employ multiple codes is a testament to our powerful error correction architecture.

World-record logical fidelities come from world-leading physical fidelities‍

Distance scaling is great in theory, but it is rarely demonstrated because it only works when the underlying hardware noise falls below a certain threshold. This is known as the “threshold theorem.” Basically, until the physical layer has low enough noise levels, QEC will just add more noise than it takes away.

Helios’ incredible performance – with a ‘suppression rate’ Λ of 12 (for memory) and 9 (for Clifford gates) - is a clear demonstration of our world-leading physical fidelity, which puts us well below the ‘threshold’.

The rate Λ captures the exponential suppression in error rate with increasing code distance⁴: increasing the code distance once gives an 12x reduction in logical error, increasing the distance twice gives 144x, three times 1728x, and so on. In contrast, a machine with a Λ of 2 gives you a 2x reduction, then a 4x reduction, then 8x, and so on – a much slower gain. The magnitude of Λ is crucial for how well quantum computers can scale, and this is the largest Λ ever measured.

This effect shows up in the best error rates, too. The previous state of the art color-code error rate (at distance 5) was 0.819% per cycle. Helios, in contrast, showed an error rate of 0.0005% with a distance 7 code, a 1,638x improvement⁵. This massive improvement is due to our excellent physical fidelity, improved scaling behavior, and our ability to go to a longer distance code (in this case, d=7 vs d=5)⁶.

Comparing at the same code distance, the previous best demonstrated error rate was using a surface code. In this case, the researchers demonstrated an error rate of 0.0772% per cycle with a distance 7 code. In this case, Helios shows a 154x improvement⁷.

‍

Figure 4. Animation of logical qubit growth with increasing code distance. The white circles represent physical qubits, and the animation shows how logical qubits are formed at color code distances of 3, 5, and 7.

Our trapped-ion qubits lead to significant resource savings

On top of our new record in fidelity, the scaling with code distance reveals something very important: our QCCD⁸ approach is expected to reach utility scale with far less resources than other modalities.

This all comes down to the value of Λ, which describes how quickly error rates decrease with increasing code distance. The most comparable result, done in a superconducting architecture with the color code, had a Λ of 1.56, while Helios demonstrated a Λ of 12. This means that we can hit a ‘utility scale’ error rate, say 10^-12, with shorter distance codes - which translates to far less physical qubits.

Mathematically, this is a straightforward calculation: you take a known error rate at a given distance (call this LER_d), then you compute LER_d×Λ^(x-d)/2, then find whatever code distance is needed to get to your desired error rate.  

The plot above compares state-of-the-art color code implementations on Helios and a superconducting architecture. For an error rate of 10^-12, indicated with a horizontal black line, the superconducting system would need a code distance of 109 to achieve the target error rate, while our computers would only need a code distance of 21⁹.

Translating this into a physical qubit requirement to generate 100 logical qubits, the superconducting processor would need ~900,000 physical qubits while our QCCD processors would only need ~30,000, a ~30x resource savings. This also brings in timelines: building a 30,000-qubit processor is much more likely in the near term than a 900,000-qubit processor.

In our recent blog about the Helix QEC architecture, we pointed out how our targeted physical fidelities will keep advancing our logical fidelities. That holds here as well: with the physical fidelity improvements targeted for Sol and Apollo, we will see an improved LER_d and Λ, meaning that we can achieve target error rates at even shorter distance codes than above. This brings in timelines further: even fewer physical qubits will be needed.

Finally, we have access to codes that cost less qubits in the first place. These ‘high encoding rate’ codes require connectivity beyond what is available in fixed qubit superconducting systems. With our reconfigurable qubits, we can implement exotic entangling schemes that allow for a single physical qubit to be shared amongst several logical qubits, further improving resource estimates and bringing in the timelines to large scale utility.
‍
Our Sol system, coming next year, will continue to reduce these costs by moving us to a grid-shaped trap, shortening transport and cooling times, while enabling full connectivity at a larger scale.

‍

Figure 6. A qubit moves through a prototype grid trap, demonstrating the precise control and dynamic qubit transport that enable all-to-all connectivity in our QCCD architecture. This is footage from an operating device, not an artist’s rendering.

An important takeaway is that a lot of resource estimates that claim we will need X qubits or Y gates to do some algorithm are outdated; as they rely on assumptions about distance scaling and QEC codes that are not relevant to our QCCD architecture. With our high fidelity and full connectivity, we will be able to achieve target applications sooner than expected (compared to many external estimates), needing fewer qubits and fewer gates overall.

Helios as a pathfinder

Figure 7. Qubits are rearranged within a prototype grid trap using broadcast control signals, demonstrating our solution to quantum computing’s “wiring problem.” This approach dramatically reduces the number of control signals—or “wires”—needed to route qubits, overcoming a critical barrier to scaling into the megaquop regime. We first demonstrated this capability in 2024. The video shows real qubits in motion—it is not an artist’s rendering.

This result reflects more than the performance of an exceptional QPU. It is the product of a cross-functional, full-stack team working in close coordination, using Helios as a pathfinder for our next generation systems.

For example, one challenge every leading quantum computing platform faces is leakage: an unwanted process that takes the system out of the two qubit states used for computation. Leakage is especially damaging for QEC codes, which are built to fix errors within those two states and are not equipped to handle a qubit that has left them. Moreover, all subsequent operations on a leaked qubit quietly fail — a single leak can lead to a cascade of correlated errors which could result in a logical failure.

On Helios, the team built a mid-circuit fix: ‘leakage repump’, which returns leaked qubits back into the computational states as ordinary, correctable errors — improving our logical error rate by over an order of magnitude and enabling our distance-scaling demonstration.

Another example is ultra-efficient decoding. Syndrome data must be interpreted quickly enough to correct errors before the quantum information degrades. The team evaluated several approaches, including machine-learning decoders developed by Quantinuum’s AI team, ultimately demonstrating accurate decoding with sub-millisecond latency, which is 10-100x faster than needed to get corrections.

Both of these point to Helios operating in pathfinder mode: helping us understand how to extract the best performance from this generation of hardware, while translating those lessons into the next. That knowledge cannot come from simulation alone – we need to build and test real hardware to continue advancing. As Lead Physicist Dr. Adam Reed put it,  "When we push Helios to its limits, we often learn something the simulations didn't tell us."

By bringing together our theory, facilities, AI, and hardware teams, we pushed our trapped-ion hardware into a new performance regime—showing how our flexible logical architecture, tailored decoders, and highly accurate trapped-ion hardware work together to advance our path to Apollo in 2029.

¹ Noisy Intermediate-Scale Quantum
‍

² In practice, we ran for 580,000 shots (29k shots, each one having 20 rounds, and observed 3 failures), which gave us just enough statistical confidence to claim the ultimate error rate.
‍

³ As you can see in Figure 3, the suppression factor has error bars of +8 and -4, meaning it could be much better or closer to the 12x we measured in the other experiment.
‍

⁴ With the color code, only odd code distances are available.
‍

⁵ The previous state of the art demonstration of distance scaling with the color code (with a maximum distance of 5) showed an error rate of 1.1% per cycle, in which case Helios shows a 2,200x improvement.
‍

⁶ If you want to compare these demonstrations at the same distance, Helios showed an error rate of 0.004% with a distance 5 code, which is a 204x improvement.
‍

⁷ The previous state of the art demonstration of distance scaling with the surface code (with a maximum distance of 7) showed an error rate of 0.143% per cycle, in which case Helios shows a 286x improvement.
‍

⁸ Quantum Charge Coupled Device
‍

⁹ It might look like we need a shorter distance code, but recall that only odd code distances are available with the color code. To hit the teraquop regime, we need slightly more than a code distance of 19. The next highest distance is 21.

• Our team, in partnership with HQS Quantum Simulations, just published what we believe to be the most accurate¹ large-scale quantum simulation of Nuclear Magnetic Resonance (NMR) to date, pointing the way to new frontiers in computational chemistry.
• NMR is a widely used analytical technique that can require significant computational costs to interpret, costs that can balloon quickly on classical systems.
• In this result, the joint team ran an end-to-end simulation on System Model H2, reproducing key spectral features that previous demonstrations were unable to capture.

Nuclear magnetic resonance (NMR) spectroscopy is one of the most powerful analytical techniques in modern science. From identifying drug candidates to understanding battery materials, it allows researchers to probe the local atomic structure of molecules and materials with remarkable precision.

Interpreting NMR experiments often requires simulations that are just as challenging as the experiments themselves. As the number of interacting nuclear spins grows, the computational cost of simulating these systems increases exponentially on classical computers. Quantum computers, which naturally represent and evolve quantum states, offer a fundamentally different approach.

In our latest work, we demonstrate the most accurate large-scale digital NMR simulation performed on quantum hardware to date. Using Quantinuum's System Model H2, we carried out an end-to-end simulation of a classically challenging NMR experiment, reproducing key spectral features that previous hardware demonstrations were unable to capture.

Why simulate NMR?

NMR is a cornerstone of chemical analysis. Researchers use it to determine molecular structures, characterize new compounds, and study how atoms interact with one another.

These capabilities make NMR indispensable across industry. In pharmaceutical research, NMR helps identify and characterize drug candidates. In materials science, it reveals the local atomic environments that determine material properties. Battery researchers, for example, use NMR to study cathode materials such as lithium cobalt oxide, allowing them to monitor how the material changes during charging and discharging and ultimately improve battery performance.

In many cases, the experimental spectrum is only part of the story. Simulations help scientists interpret complex spectra by revealing which atomic interactions give rise to the observed peaks. They provide the link between an experimental measurement and the underlying molecular structure.

The classical challenge and the quantum solution

The difficulty lies in the physics.

An NMR experiment measures the dynamics of interacting nuclear spins. Every additional spin rapidly increases the size of the quantum state that must be represented (in the case of a spin-½ particle, every spin doubles the state). As a result, exact classical simulations become exponentially more expensive as the system size grows.

Today's best classical methods are remarkably sophisticated. Exact simulations are typically limited to systems of around 25 interacting spins, while advanced approximation techniques can often extend calculations to roughly 40–50 spins for many practical problems.

Those approximations have made classical NMR software extraordinarily effective for conventional liquid-state spectroscopy. In fact, our collaborators on this project are developing one of the leading classical simulation packages and noted that, despite the success of our quantum experiment, the current spectral resolution is still insufficient for routine use by practicing spectroscopists. Resolving the fine structure needed for many real-world analyses would require substantially longer simulations—and therefore much deeper quantum circuits than current hardware can yet support.

This highlights both the progress and the remaining challenge. Quantum computers are beginning to produce meaningful NMR spectra, but practical utility will require larger quantum computers and increased simulation depth.

In the longer term, interacting spin systems are among the most natural applications for quantum computers. Instead of storing the exponentially large quantum state explicitly, a quantum computer represents it directly in its physical qubits. For spin-½ nuclei, the mapping is particularly efficient: each nuclear spin corresponds directly to a single qubit. Higher-spin nuclei require only a small number of additional qubits.

This does not eliminate every computational challenge—longer simulations still require deeper quantum circuits—but it avoids the exponential memory bottleneck that limits classical simulation.

For NMR, this makes quantum simulation an especially compelling long-term application.

Our experiment

Working with collaborators at HQS Quantum Simulations, we implemented a complete quantum workflow for simulating an NMR experiment on Quantinuum's H2 trapped-ion quantum computer.

Rather than stopping at Hamiltonian simulation alone, we reproduced the entire computational pipeline:

• constructing the nuclear spin Hamiltonian,
• compiling efficient quantum circuits,
• simulating the spin dynamics through Trotterized real-time evolution,
• applying targeted error-suppression techniques,
• reconstructing the free induction decay, and
• generating the final NMR spectrum through Fourier analysis.

The benchmark molecule, 1,2-di-tert-butyl-diphosphane, is a well-known challenge for NMR simulation. After applying hardware-efficient model reduction, we simulated an effective 21-spin Hamiltonian using a 42-qubit (21 system qubits and 21 ancilla qubits) computation on System Model H2.

Our deepest circuits reached over 1,400 two-qubit gates and simulated 70 Trotter steps, corresponding to approximately 29 ms of physical evolution time.

Most importantly, the resulting spectrum reproduced the key benchmark features of the classical reference calculation, including a characteristic double-peak structure that previous quantum hardware demonstrations had failed to recover.

This represents the most complete hardware demonstration of digital NMR simulation reported to date.

Why trapped ions mattered

Achieving this result depended not only on the quantum algorithm but also on the underlying hardware.

Large Hamiltonian simulations require long, high-fidelity quantum circuits. Quantinuum's trapped-ion architecture provides all-to-all qubit connectivity, high-fidelity gates, and effective error-suppression techniques that allowed us to preserve the spectroscopic features throughout the computation.

The close agreement between hardware, emulator, and classical reference calculations demonstrates that deep quantum simulations of chemically meaningful systems are becoming increasingly feasible on today's hardware.

Looking ahead

To make quantum NMR genuinely useful for practicing spectroscopists, future systems will need substantially deeper circuits.

Our experiment simulated approximately 29 ms of evolution time, producing spectral features with a resolution of roughly 0.07 ppm, a very promising start.

Reaching that scale will require continued improvements in hardware fidelity, error correction, and quantum algorithms.

Nevertheless, this work demonstrates that digital quantum simulation of realistic NMR experiments is no longer purely theoretical. It establishes a practical end-to-end workflow, validates key algorithmic techniques, and shows that quantum computers can already reproduce chemically meaningful spectral signatures.

As quantum hardware continues to improve, applications such as molecular spectroscopy, materials characterization, and chemical simulation are becoming increasingly realistic targets for practical quantum computing.

¹ Based on a study of existing literature

• In a recent independent study by the Julich Supercomputing Center, Quantinuum’s trapped-ion systems outperformed superconducting processors in tests of fault tolerant operations.
• Testing small chunks of circuits that would be used in larger QEC workflows, Quantinuum’s Helios demonstrated an approximately 10x lower effective hardware error compared to superconducting systems.
• Quantinuum’s flexible connectivity enabled tests across three error-correcting code families, compared to just one for superconducting systems, illustrating the expanding options for advancing fault tolerance with our QCCD architecture.

The demands of fault tolerance are bringing Quantinuum’s advantages into sharper focus.

In a new independent study from the Jülich Supercomputing Centre, Quantinuum’s Helios demonstrated an approximately order-of-magnitude advantage over superconducting hardware in tests of operations essential to quantum error correction. More precisely, Helios’ effective hardware error was approximately 13 times lower at 30 data qubits and eight times lower at 50 data qubits than the comparable superconducting result.

The advantage extended to architectural flexibility. Quantinuum’s systems supported tests across three error-correcting code families, while connectivity and control restrictions limited implementation to only one on the superconducting devices evaluated.

These findings build on earlier independent research by the same organization highlighting Quantinuum’s physical-level performance. As we have argued, the NISQ era is coming to an end. The demands of error correction are bringing our architectural differences into sharper focus—and this study provides further evidence of Quantinuum’s advantage.

Error correction exposes performance gaps

A fault-tolerant quantum computer must repeatedly detect and correct errors to protect the computation in progress. That requires reliable mid-circuit measurements, conditional operations, and real-time coordinated scheduling.

In a direct comparison, introducing mid-circuit measurement caused substantially greater degradation on the superconducting processors compared to the Quantinuum systems.

That difference matters. Mid-circuit measurement must be repeated throughout fault-tolerant computations. Their (potential) performance penalty directly affects how much computation a machine can sustain.

Helios demonstrated strong performance under those demands, extending its advantage beyond the physical layer into circuits exercising essential error-correction capabilities.

Connectivity expands the options

The study also highlighted how architectural restrictions affect which error-correction structures hardware can implement directly.

On Quantinuum’s systems, researchers ran tests exploring the surface-code, triangular color-code, and a bivariate-bicycle qLDPC code. In contrast, the superconducting devices evaluated were only able to explore the surface code due to device constraints.

This is because Quantinuum’s QCCD architecture offers greater flexibility: mobile qubits enable codes that require higher connectivity than is allowed on traditional superconducting processors. Ultimately, this gives researchers more freedom to explore multiple codes—and more opportunities to reduce the qubit and time overheads of fault tolerance.

Building on an architectural advantage

The Jülich study provides independent evidence that Quantinuum’s architectural choices deliver advantages for operations essential to fault tolerance. It also reveals performance and implementation gaps in the superconducting systems tested.

We intend to extend that lead. Our investments in fidelity, flexible connectivity, and integrated control are foundations for increasingly capable machines.

As error-correction workloads become more demanding, those capabilities become more consequential. Quantinuum is building to meet that challenge—and to keep raising the performance bar.