hardware advanced · 21 min read · April 29, 2026

Trapped Ion Quantum Computing: The Platform with the Best Gate Fidelities and the Slowest Gates

Trapped ions hold the published-fidelity records on essentially every quantum-hardware metric. They have the longest coherence times, the cleanest two-qubit gates, and the most natural all-to-all connectivity. They are also the slowest platform by orders of magnitude, with system architectures that are harder to scale than superconducting alternatives. This tutorial covers the physics, the leading systems (Quantinuum H2/Helios, IonQ Tempo), the QCCD architecture, and where the trapped-ion advantage actually matters.

Prerequisites: Tutorial 33: Transmon Qubits

If you read a 2026 quantum-computing benchmark paper and see two-qubit gate fidelities reported as $99.97\%$ or higher, the platform is almost always trapped ions. The Quantinuum H2 and Helios systems, IonQ’s Forte and Tempo, and the academic ion-trap groups at Innsbruck, Maryland, Sydney, and Oxford collectively hold the published-fidelity records for essentially every relevant metric: single-qubit gates, two-qubit gates, state preparation, mid-circuit measurement, and ion qubit coherence.

This is not a fluke. Trapped ions have several physical advantages that translate directly into hardware quality: nearly perfect natural qubits (atomic transitions identical across all ions), long coherence times (hours, in principle, for hyperfine qubits), and inherent all-to-all connectivity within a single trap.

The catch: trapped-ion gates are slow. A two-qubit gate on a transmon is 30-200 ns; on a trapped ion it is $50\,\mu s$ to milliseconds. Three to five orders of magnitude slower. This speed gap shapes everything about ion-based architectures, from how algorithms are compiled to how systems are scaled.

This tutorial covers the trapped-ion platform end-to-end: the physics of the qubit, the Mølmer-Sørensen gate that delivers the high fidelities, the QCCD shuttling architecture that enables scaling beyond $\sim 100$ ions per trap, current 2026 numbers, and the regimes where the speed-vs-fidelity tradeoff makes ions the right choice.

The qubit: a single ion in a vacuum chamber

A trapped-ion qubit is a single ion — typically Ytterbium-171 ($^{171}\mathrm{Yb}^+$), Barium-137 ($^{137}\mathrm{Ba}^+$), Calcium-43 ($^{43}\mathrm{Ca}^+$), or similar — held in vacuum by a configuration of oscillating electric fields (a Paul trap). The qubit states are two specific atomic energy levels of the ion. There are two main qubit-encoding choices:

• Hyperfine qubit: Two ground-state hyperfine levels separated by GHz-frequency microwaves. Long coherence ($T_2 > 10$ s in trapped clouds, $T_2 \sim$ seconds in single-ion qubits), driven by microwaves or stimulated Raman transitions.
• Optical qubit: Two electronic levels separated by an optical frequency. Shorter coherence ($T_2 \sim 100$ ms), driven by precision lasers. Used in some Calcium-based devices.

Most flagship 2026 systems use hyperfine qubits, primarily because the long coherence time means decoherence is essentially negligible compared to gate errors. The dominant error in a modern ion-trap circuit is the gate, not the wait-time.

The ion is identified by the laser frequencies it responds to — every $^{171}\mathrm{Yb}^+$ ion in the universe has the same hyperfine splitting, so the qubit is “natural” in a way that lithographically fabricated qubits can never be. Two ions of the same species are indistinguishable. This is a quietly important advantage: there is no manufacturing variability across qubits.

The trap: Paul traps and surface traps

The ion is held by a Paul trap — a configuration of electrodes producing oscillating electric fields that average to a confining harmonic potential at the trap center. Modern systems use one of two geometries:

• Linear Paul traps (3D rod-style): four parallel rods produce the trapping field; ions form a 1D chain along the axis. Used in early systems, still common in academic labs.
• Surface-electrode traps (2D chip-style): the trap electrodes are patterned onto a planar substrate, with the ion floating $\sim 50\,\mu m$ above the chip. Easier to fabricate at scale; underlies all the modern QCCD architectures.

A single trap can hold up to $\sim 100$ ions in a chain before phonon-mode crowding starts to degrade gate fidelity. To scale beyond this, you need to break the system into multiple traps connected by shuttling — the QCCD architecture covered below.

The Mølmer-Sørensen gate

Two-qubit gates on trapped ions exploit the shared phonon mode of the ion chain. Both ions sit in the same harmonic trap; their motion is coupled. By driving both ions with carefully tuned bichromatic laser pulses, you can implement a unitary that entangles their qubit states via the shared motional mode, with the motion ending up disentangled from the qubits at the end of the gate.

This is the Mølmer-Sørensen (MS) gate (Mølmer-Sørensen 1999). The mathematical content:

$$U_\text{MS}(\theta) \;=\; \exp\bigl(-i \theta \, X \otimes X\bigr) \;=\; \cos\theta \, I + i \sin\theta \, X \otimes X.$$

Setting $\theta = \pi/4$ gives an entangling gate equivalent (up to single-qubit rotations) to a CNOT. The gate is fundamentally a controlled rotation in the $\{|00\rangle, |11\rangle\} \leftrightarrow \{|01\rangle, |10\rangle\}$ subspace.

The key property: the gate is structurally insensitive to the initial motional state of the ions, as long as the motion is in the Lamb-Dicke regime. This makes the gate robust to thermal motion of the ion chain — you don’t have to ground-state cool the ions to subkilohertz temperatures.

Modern MS gates achieve fidelities of $\sim 99.97\%$ on Quantinuum H2 (Moses et al. 2024 reports $99.989\%$ on a 2-qubit subsystem) and similar on Quantinuum Helios. These are by a wide margin the highest-published two-qubit fidelities on any quantum-hardware platform. Theoretical limits (laser phase noise, motional decoherence, off-resonant excitations) sit somewhere around $99.99\%$ for current designs; pushing past that requires architectural changes.

Connectivity: native all-to-all within a trap

Within a single ion-trap module, every ion couples to every other ion through the shared motional modes. There is no concept of “nearest neighbor” — any two ions can be entangled by a single MS gate without intermediate SWAP operations.

This is a real advantage. Algorithms with long-range connectivity (e.g., quantum chemistry mappings of molecular Hamiltonians, qLDPC codes that need degree-6 connectivity) compile to far shorter circuits on ions than on transmons. A circuit that needs many SWAP networks on 2D-grid hardware needs zero SWAPs on ion hardware.

The compilation-time savings can be 5-10× in two-qubit gate count, which partially offsets the 1000× speed disadvantage. For algorithms where connectivity matters more than absolute speed, the ions can compete on total wall-clock.

Scaling: the QCCD architecture

A single ion trap saturates around 50-100 ions before the shared phonon modes become too crowded for high-fidelity gates. To go beyond, the leading approach is the Quantum Charge-Coupled Device (QCCD) architecture (Wineland and collaborators, 1990s; first practical implementations 2010s):

• Multiple “zones” on a single chip: storage zones, gate zones, measurement zones.
• Ions are physically shuttled between zones using time-varying voltages on the trap electrodes.
• Gates are performed in dedicated gate zones with optimized laser geometries.
• Idle ions are stored in cooling-friendly zones.

The QCCD architecture decouples “memory” from “compute” — like classical CPU caches and registers. Quantinuum’s H-series and Helios use QCCD to scale to hundreds of ions per chip. Current limits are around 56-96 fully-controlled ions per device (H2 has 56; Helios is ramping). Multi-chip scaling, with photonic interconnects between chips, is on the roadmap but not yet at parity with single-chip systems.

Shuttling is fast (microseconds per move) but not free: it adds heating, requires careful electrode engineering, and the routing decisions become part of compilation. The QCCD scheduler is a real piece of software, not an afterthought.

Current 2026 numbers

The state-of-the-art ion systems and their published numbers as of early 2026:

System	Ions	Two-qubit fidelity	Coherence	Public access
Quantinuum H2	56	$\sim 99.97\%$	$T_2 > 10$ s	Quantinuum cloud
Quantinuum Helios	96	$\sim 99.96\%$	$T_2 > 10$ s	Quantinuum cloud
IonQ Forte	36	$\sim 99.7\%$	$T_2 \sim 1$ s	Cloud (AWS, Azure)
IonQ Tempo	64	$\sim 99.8\%$	$T_2 \sim 1$ s	Cloud (early access)
AQT Pine	24	$\sim 99.5\%$	$T_2 \sim 1$ s	Cloud (research)
Oxford Ionics	research	$\sim 99.97\%$	$T_2 > 1$ s	Research (no public access)

Key observations:

• Quantinuum holds the fidelity lead. Their two-qubit gate errors below $3 \times 10^{-4}$ are roughly 10× better than the best transmon platforms. This translates directly into longer effective circuit depth before logical errors dominate.
• Coherence is essentially infinite for practical purposes. $T_2 > 10$ s combined with $50\,\mu s$ gates means $T_2 / t_\text{gate} > 2 \times 10^5$ — three orders of magnitude better than transmons.
• Qubit count is two-digit. Compared to transmon devices in the hundreds, ions are smaller in raw qubit count. Whether this is a “limitation” depends on what the algorithm needs; for 50-qubit chemistry simulations, ions are fine; for 200-qubit error correction demos, they are not yet.

Strengths and bottlenecks

Strengths:

1. Fidelity. Best in class. The order-of-magnitude advantage in two-qubit gate error translates into longer circuit-depth budgets and lower error-correction overhead.
2. Coherence. Hyperfine qubits are essentially “ideal” qubits on the timescales of any algorithm.
3. All-to-all connectivity. No SWAP overhead; algorithms compile shorter.
4. Mid-circuit measurement. Ion-trap mid-circuit measurement and reset is mature and high-fidelity, enabling adaptive circuits and dynamic-circuit error correction.
5. Manufacturing uniformity. Every ion of a species is identical; no calibration variability across qubits.

Bottlenecks:

1. Speed. $50\,\mu s$ to milliseconds per two-qubit gate. A 100,000-gate algorithm takes 5+ seconds on ions vs ~10 ms on transmons. For algorithms with billions of gates (most fault-tolerant work), this is a wall-clock killer.
2. Scaling. QCCD scales gracefully to ~100s of ions; photonic interconnects to multi-chip systems are still maturing. Reaching the 1000-1M qubit scale needed for fault tolerance is harder than on transmons.
3. Laser engineering. Each gate requires precise lasers; the laser systems are bulky, expensive, and a primary failure mode.
4. Vacuum and cryogenics. Some systems use cryogenic vacuum (Quantinuum H2 at $\sim 4$ K), adding infrastructure complexity. Room-temperature traps exist but face additional decoherence.

Companies and roadmaps

The 2026 landscape:

• Quantinuum (Cambridge UK, Broomfield CO): the technical leader on fidelity and qubit-system maturity. H2 is the production system; Helios is the next-gen 96-ion device. Their roadmap targets ~$10^4$ logical qubits via QCCD scaling and photonic interconnect by 2030. Public-cloud access via Quantinuum’s own cloud platform.
• IonQ (College Park MD): public company (NYSE: IONQ), commercially aggressive. Forte and Tempo systems target the cloud-quantum-services market. Roadmap focuses on networked multi-trap systems.
• AQT (Innsbruck): European leader, commercial spin-out from the Innsbruck academic group. Smaller systems with strong ties to academic research.
• Oxford Ionics (Oxford UK): newer entrant emphasizing a non-laser approach (RF-driven gates), aiming for higher gate speeds. Acquired by IonQ in 2025.
• Universal Quantum (Sussex UK): networked-modular ion-trap architecture; currently research-focused.
• Honeywell (was the original developer of Quantinuum’s hardware before the merger): no current independent ion-trap product.

The ion-trap industry has seen fewer “moonshot” claims than transmon vendors, with progress measured more in fidelity improvement than in qubit-count milestones. This is consistent with the platform’s strengths.

When ions are the right answer

Three regimes where ions clearly win as of 2026:

1. High-precision NISQ algorithms. VQE on chemistry molecules where chemical accuracy ($\sim 10^{-3}$ Hartree) is needed: ions’ high gate fidelity gives much shallower error budget than transmons. Several quantum-chemistry benchmarks have shown ions matching or beating transmons on gate count to chemical accuracy.
2. Low-overhead error correction. With $10^{-4}$ physical gate error vs transmon’s $10^{-3}$, ions cross the surface-code threshold by a much larger margin, allowing lower code distance for the same logical error. Tutorial 27 quantified this — a 10× lower physical error reduces required code distance by ~5, which reduces qubit overhead by ~$5^2 \sim 25\times$.
3. Algorithms requiring rich connectivity. Quantum simulation of physical Hamiltonians with long-range couplings, qLDPC codes, all-to-all-connectivity-friendly algorithms.

Three regimes where transmons usually win:

1. Real-time / low-latency applications. Anything needing microsecond-scale wall-clock turnaround.
2. Large NISQ demos. 100+ qubit algorithms where the qubit count is the constraint.
3. Production fault tolerance circa 2027-2030. The transmon vendors have a head start on FTQC engineering at scale; ions catch up later if the QCCD scaling story works.

Common misconceptions

“Ions are slow because the gate is slow.” Wrong frame. Ions are slow per-gate but their fidelity is so high that the effective circuit depth is much longer. Total wall-clock for a fixed algorithm depth depends on $(t_\text{gate} \cdot \text{depth\_to\_failure})$, which is comparable to transmons for many problem sizes.

“Ions can’t scale because traps saturate.” The QCCD architecture solves the within-chip saturation. Multi-chip scaling via photonic interconnects is the open engineering problem. It is harder than for transmons but not fundamentally infeasible.

“Ions are quantum-only and have no classical role.” Modern ion-trap systems include sophisticated classical control: real-time scheduling for shuttling, real-time decoder hardware for fault-tolerance, and a non-trivial software stack. The classical engineering is comparable to a transmon system.

“All ion species are equivalent.” Yb, Ba, Ca, and Sr each have different transition wavelengths, hyperfine splittings, magnetic-field sensitivities, and coherence properties. Quantinuum uses Yb; IonQ uses Yb; some research groups use Ba (which has visible-wavelength transitions easier to manipulate with off-the-shelf lasers). The species choice shapes the laser systems and indirectly the gate fidelity.

“Long coherence makes ions automatically better.” Long coherence is necessary but not sufficient. The gate error per gate is what matters for circuit-depth budget, not coherence per se. Ions happen to have both high fidelity and long coherence — that’s the win.

Decision rule

For a candidate algorithm, ions vs transmons:

1. Is gate fidelity the bottleneck? If yes → ions. If your error budget is dominated by gate errors that need to be 10× lower than the best transmon platforms, ions are the only published path to that.
2. Is wall-clock the bottleneck? If yes → transmons. Real-time applications, very large algorithm sizes (10M+ gates), or compute-heavy classical-quantum loops favor speed over per-gate fidelity.
3. Is connectivity the bottleneck? If your algorithm needs long-range or all-to-all interactions, ions compile to fewer gates and beat transmons even at slower per-gate speeds.
4. Is qubit count the bottleneck? If you need 200+ qubits per algorithm: transmons today. Ions are catching up but the largest ion systems in 2026 are still under 100 ions per chip.

Most production quantum-computing work in 2026 picks the platform based on this rule. Many published benchmark papers run the same algorithm on both platforms; the right answer is problem-dependent.

Exercises

1. Wall-clock vs depth budget

A 100-qubit algorithm has 10,000 two-qubit gates. Compute the wall-clock time and total expected logical errors on (a) Quantinuum H2 (50 µs gate, $3 \times 10^{-4}$ error), and (b) IBM Heron r2 (90 ns gate, $3 \times 10^{-3}$ error). Which platform is more likely to execute the algorithm successfully?

Show answer

(a) H2: time = 10⁴ × 50 µs = 0.5 s. Total error budget: $1 - (1 - 3 \times 10^{-4})^{10^4} \approx 0.95$ — likely to fail with 95% probability per run. (b) Heron: time = 10⁴ × 90 ns = 0.9 ms. Total error: $1 - (1 - 3 \times 10^{-3})^{10^4} \approx 1.0$ — essentially certain failure. Both platforms fail this algorithm without error correction. H2 is closer to making it work; reducing the algorithm to 1,000 gates makes H2’s error budget feasible (~26% failure rate) while Heron is still >90% failure. The lesson: gate fidelity is the binding constraint for medium-depth NISQ algorithms; H2 is roughly an order of magnitude ahead.

2. Why all-to-all connectivity matters

A 50-qubit algorithm needs $200$ two-qubit gates between non-nearest-neighbor qubits on a 2D grid. On a transmon device with grid connectivity, each non-local CNOT requires SWAP networks; estimate the SWAP overhead and the effective gate count. Compare to ions.

Show answer

On a 50-qubit 2D grid (e.g., a 5×10 array), the average distance between two qubits is $\sim 5$ grid steps. Each non-local CNOT requires $\sim 5$ SWAPs (each SWAP = 3 CNOTs), so ~15 CNOTs per non-local CNOT. Total CNOT count on transmon: $200 \times 15 = 3{,}000$ CNOTs. On an all-to-all-connected ion trap: $200$ CNOTs, no SWAPs needed. The ion compilation is 15× shorter in two-qubit gate count. Combined with ions’ 10× better gate fidelity, that is roughly 150× lower expected total error — partially offsetting the speed disadvantage.

3. The QCCD shuttling cost

A QCCD computation requires moving an ion 1 mm at $\sim 10$ m/s; the move takes $\sim 100\,\mu s$. If a circuit requires 100 such moves interleaved with gates, what fraction of total wall-clock is shuttling?

Show answer

100 moves × 100 µs = 10 ms shuttling. If gates take comparable time (say, 100 gates × 50 µs = 5 ms gates), shuttling is ~67% of wall-clock. Shuttling is a real fraction of the runtime budget, especially for circuits with many non-local interactions that require physically rerouting ions to gate zones. This is one of the main targets for QCCD architecture optimization.

4. Which platform for quantum chemistry to chemical accuracy?

Quantum chemistry to chemical accuracy ($10^{-3}$ Hartree) requires gate errors below $\sim 10^{-3}$ per gate to make 1000-gate algorithms feasible. Transmons at $\sim 3 \times 10^{-3}$ are borderline; ions at $\sim 3 \times 10^{-4}$ have margin. Pick a platform and justify.

Show answer

For 1000-gate chemistry circuits: transmon at $3 \times 10^{-3}$ gives $1 - (1 - 3 \times 10^{-3})^{1000} \approx 95\%$ chance of failure; ion at $3 \times 10^{-4}$ gives $\sim 26\%$ failure. Ions are the practical choice for any chemistry algorithm of this depth. This is why Quantinuum H2 has been the dominant published platform for quantum chemistry results in 2024-2025. With error correction, transmons can match ion performance, but the physical-error margin matters at the NISQ level. The crossover point where transmons become competitive depends on whether you have access to the latest hardware (e.g., IBM Heron r2 vs older devices) and whether you are willing to use error mitigation techniques to extend the effective depth budget.

Where this goes next

Tutorial 35 covers neutral atoms / Rydberg arrays — a platform that combines some of the trapped-ion advantages (uniform natural qubits, long coherence) with much more flexibility in array geometry. The 2024-2025 results from Atom Computing, Pasqal, and QuEra have made this the fastest-improving platform of the year. Tutorial 36 covers photonic quantum computing and the fundamentally different fault-tolerance picture it presents.

---

Weekly dispatch

Quantum, for people who already code.

One serious tutorial per week, plus the industry moves that actually matter. No hype, no hand-waving.

Email Subscribe

Free. Unsubscribe anytime. We will never sell your email.