Quantinuum Built a Universal Gate Set With 28 Qubits, Not Hundreds

In my last post I wrote about how I often take my time learning about complex things. This one has been percolating for a while - the first experimental demonstration of switching between two different error-correcting codes to build a universal gate set, using 28 physical qubits instead of the hundreds that brute-force magic state distillation usually needs. Here we go!

Chapter 6 in my Quantum book covers Quantinuum's H2 trapped-ion computer through its gate fidelity, meaning how often a single operation on a qubit comes out correct. That number sits at 99.0 to 99.5 percent, close to IonQ's 99.99 percent result also cited in that chapter. A single clean operation is not the same thing as a working quantum computer. You need to run thousands or millions of operations in sequence, and you need every type of operation a quantum algorithm requires, not just the easy ones. A team from Quantinuum and UC Davis showed a way to get every type of operation working together reliably, using only 28 qubits where earlier approaches needed hundreds.

Let's start with some basics. A classical computer builds everything out of simple logic gates, AND, OR, NOT. A quantum computer builds everything out of quantum gates instead, operations that rotate or combine qubits in specific ways. Some quantum gates are considered easy to protect with error correction. Others are considered hard. That split matters more in quantum computing than it does in classical computing, and it is the whole reason this experiment is worth explaining.

The easy gates are called Clifford gates. Hadamard, CNOT, and the phase gate all fall into this group. Error correcting codes, like the Steane code already described in Chapter 6, were designed around these gates. Run a Clifford gate on a protected, encoded qubit and the code keeps working the way it is supposed to. The catch is that Clifford gates by themselves are not enough. A computer that only ever runs Clifford gates can be copied and simulated by an ordinary laptop. Nothing quantum about the result. To get an actual advantage over classical computing, you need one more type of gate, called the T gate, and it does not play by the same rules. Try to run a T gate directly inside most error correcting codes and the protection breaks down. If you want the fuller story on how trapped-ion qubits and error correction work together on this hardware, Chapter 6's background on QCCD architecture and logical qubits covers that ground.

Rather than force the T gate to behave, researchers build it a workaround. They prepare a separate, specially crafted qubit ahead of time, called a magic state, and use a process similar to quantum teleportation to transfer its effect onto the qubit that needs the T gate. The protected data qubit never runs the risky operation directly. The magic state absorbs the risk instead. The problem shifts from protecting a difficult gate to manufacturing a clean enough magic state in the first place.

Building a magic state clean enough to trust normally means distillation: take several noisy magic states, run a check on them, and keep only the ones that pass. Repeat that over several rounds and the result gets cleaner, but each round eats more qubits. Estimates for reaching Quantinuum's target fidelity through this brute-force approach ran into the hundreds of physical qubits, well beyond what most trapped-ion computers carry today.

Estimated qubit cost of brute-force distillation versus the demonstrated cost of code switching.

Quantinuum's team used a different trick called code switching. Instead of distilling one magic state over and over inside a single code, they built the state inside a 15-qubit code called the quantum Reed-Muller code, chosen because the T gate happens to work cleanly inside it with no extra steps. They then moved that already-clean state into the 7-qubit Steane code, the same code already in Chapter 6, which handles the rest of the gate set. The move works like a teleportation with a built-in check: if the check fails, that attempt gets thrown out rather than trusted. About 17 percent of attempts failed and were discarded, leaving a usable magic state in the remaining 83 percent.

The code-switching pipeline: build the state where the T gate is easy, check it, then move it to the code that runs everything else.

The number that matters most: the finished magic state had an infidelity of about 5.1 times ten to the negative fourth, roughly 2.7 times lower than the error rate of the physical qubits used to build it. In plain terms, the finished, protected result was cleaner than the raw hardware that made it. That is the entire promise of error correction, and no one had shown it for this particular gate before. The total qubit cost was 28: 22 data qubits and 6 more used just to run the checks. The full technical writeup, published in Physical Review X, is worth a look if you want the underlying math.

Quantinuum's newer Helios system has since carried the same idea further. In November 2025 it produced 48 logical qubits from 98 physical qubits, close to a 2 to 1 ratio, using a different checking scheme called the Iceberg code. None of this means a large, code-breaking quantum computer is close. It means the qubit cost of turning noisy hardware into something trustworthy has started to come down, on the same H-series machines Chapter 6 already covers. This is also the same territory last month's post on Quantinuum's topological-qubit workaround explored, using the H2 processor to test a different route to fault tolerance entirely.

What This Changes in the Book

Chapter 6 will get a new section on code-switching magic states alongside the existing H2 fidelity numbers, with the 28-qubit figure and the 5.1x10 to the negative 4 logical infidelity placed next to the 99.0 to 99.5 percent physical gate fidelity already cited, so readers can see the difference between a clean single operation and a clean chain of protected ones. Chapter 12, which covers the overhead problem in error correction, will note code switching as a second qubit-efficient alternative to brute-force distillation, alongside the NVIDIA AI-assisted calibration work already in that chapter.

This post will be folded into the next quarterly edition of Quantum from the Ground Up, due September 1. The current edition is available at the link above.

A Second Way to Build a Topological Qubit, and It Runs on Hardware Already Available

Chapter 10 of Quantum from the Ground Up tells one story about topological qubits: Microsoft growing an exotic nanowire material to host a particle called a Majorana zero mode. That approach needs new physics and new materials, and it has been slow going. A team at Quantinuum, working with researchers at Harvard, UChicago, and Stony Brook University, just showed a different way to get the same protection against errors. They published the result in Nature.

Here is the paper describing a universal topological gate set built from braiding and fusing exotic particles called anyons. They did not grow anything new. They took an ordinary trapped-ion quantum computer, Quantinuum's H2, and used 54 of its regular qubits to build a state of matter that behaves the way the exotic Majorana material is supposed to behave.

Start with what an anyon is. In everyday physics, particles come in two types: fermions, like electrons, and bosons, like photons. Anyons are not fundamental particles. They only show up inside certain engineered quantum systems, as patterns in how a group of qubits is entangled together. The interesting kind here are called non-Abelian anyons. If you take two of them and swap their positions, then swap two more in a different order, you get a different final result depending on which order you did the swapping in.

That sounds like a technicality, but it is the whole point. Because the result depends on the order of the swaps and not on small local wobbles or noise, information stored this way is naturally protected. Physicists call the swapping process braiding, since tracking two anyons moving around each other looks like braiding two strands of hair. In the diagram below, a1 passes in front of a2, shown by the small break in a2's line where it crosses behind. Swap them the other way, with a2 in front instead, and the anyons end up in a different state. Which one passes in front is not a drawing choice. It is the physical information the braid records.

Braiding by itself has a known gap. Researchers proved back in a 2003 proposal from physicist Carlos Mochon that for the simplest type of non-Abelian anyons, braiding alone cannot give you every operation a computer needs. You can protect information this way, but you cannot fully compute with it. Something was missing.

The Quantinuum team's answer was to add a second move: fusion. Instead of only moving anyons around each other, they also merge two anyons together and measure what comes out. Braiding plus fusion turns out to supply the missing operations, creating a mathematically complete set of gates capable of running any algorithm.

They built a 54-qubit state based on a mathematical structure called S₃—the smallest group that produces non-Abelian anyons—then stored information in the combined fusion outcomes of many anyons taken together rather than in any single qubit. Each unit of stored information could hold three states instead of the usual two (a qutrit rather than a qubit), since these anyons naturally support three possible fusion outcomes. Using braiding and fusion together, the team ran a computationally universal set of operations and read out the result correctly.

As a real test, they used the setup to build what is called a magic state, a specific resource that most fault-tolerant quantum computing schemes need. Normally, generating that resource requires an expensive extra process called magic state distillation, which eats up huge numbers of physical qubits just to produce one clean logical one. This approach made the same resource directly via topological operations without that extra step.

What This Changes in the Book

Chapter 10 needs a second section. Microsoft and Quantinuum are both chasing the same goal—a qubit that resists errors because of its shape rather than because of constant correction—but they are getting there in different ways. Microsoft is trying to grow a new material that hosts the right kind of particle directly. Quantinuum instead uses software and precise control to make an ordinary quantum computer behave as if that exotic material were there.

Chapter 6 gets an update too. The H2 processor was already in the book because of its record for entangling 56 qubits at once. Now it has a second claim to fame: it is a working testbed for this kind of engineered, error-resistant state of matter.

Neither team has built an actively error-corrected logical qubit that outperforms physical hardware yet. Both just found a more believable road toward one—and it turns out you do not need exotic new hardware to try.

This post will roll into the next edition, due September 1. The current edition is free at gordostuff.com/p/quantum-from-ground-up-hardware.html