Pinch a neutral atom in nothing but focused light, split one laser into thousands of those pinches, then rearrange the atoms like a board game — here is how the LEGO of quantum computing went from a trapping trick to the platform now leading on sheer qubit count and error-corrected logical qubits, and the slippery costs it pays for the lead.
Part of the How to Build a Quantum Computer series.
The previous post left us with a teasing question. A superconducting qubit is a circuit faking an atom; a trapped ion is a real atom you grab by its electric charge — precise, but a single chain tops out near a hundred. So: if catching one real atom is this good and herding many is this hard, what if you did not strip the electron at all, and held a neutral atom in a pinch of pure light?
You lose the charge handle that made the ion easy to grip — but you gain something extraordinary in exchange. A single laser beam, passed through the right optics, can be carved into thousands of independent traps at once, each cradling one atom, and you can pick those atoms up and set them down somewhere else mid-computation.
If the trapped ion is a master craftsman carving one perfect chain, the neutral atom is a child with an enormous box of identical LEGO bricks: not the finest single piece, but you can build big, and rearrange as you go. That box is the reason this platform now holds the records for raw qubit count and for error-corrected logical qubits at the same time. Let us see how light alone holds an atom still — and what it costs to herd thousands of them.
Start, as always, with the two-level system. Here it is the genuine article, same as the ion: a single neutral atom, its electron count intact. The usual choices fall into two families. The alkali atoms — rubidium-87 and cesium-133 — store the qubit in two hyperfine sublevels of the electronic ground state; in $^{87}\mathrm{Rb}$ these hyperfine “clock states” — the microwave levels atomic clocks are built on — are split by about $6.8$ GHz. The alkaline-earth-like atoms split the labor by whether the isotope carries nuclear spin: the fermionic $^{171}\mathrm{Yb}$, with nuclear spin $\tfrac12$, carries a clean two-state nuclear-spin qubit that barely notices magnetic noise, while the bosonic $^{88}\mathrm{Sr}$ — zero nuclear spin to use — instead encodes its qubit on a razor-narrow optical-clock transition. Either way, you pick two of the atom’s own levels, call them $\vert 0\rangle$ and $\vert 1\rangle$, and the discreteness a transmon had to manufacture comes free, because an atom’s electrons simply cannot sit between levels.
And here the neutral atom inherits the trapped ion’s best birthright, the one fabricated qubits openly envy: every atom of a given isotope is fundamentally identical to every other. Not “matched to manufacturing tolerance” — the same, set by nature to a precision no foundry will ever reach. There are no snowflakes here, no per-qubit frequency that drifted because one oxide barrier came out a nanometer thick. When your array holds three thousand atoms, it holds three thousand copies of the same qubit. (The same footnote the ions earned applies here: the atoms are identical, but their local environments — stray fields, laser intensity, position in the trap — are not, so nobody actually skips calibration. They just start from a place no engineered qubit can.)
So the qubit itself is, once again, nature’s free gift. The entire art of this platform is in two verbs: holding thousands of these slippery, chargeless atoms still with nothing but light, and talking to them — making them interact on demand without knocking them loose. That art is the rest of this post.
Gripping an atom with light. A neutral atom carries no charge, so you cannot push it around with electrodes the way you herd an ion. What you can do is exploit the fact that light is an oscillating electric field, and that field induces a tiny dipole in the atom. Focus a laser beam tuned below the atom’s resonance (red-detuned) to a micron-scale waist, and the induced dipole is pulled toward the region of highest intensity — the focal point. The atom sits in a potential well shaped like the light itself,
\[U(\mathbf r) \;\approx\; \frac{3\pi c^2}{2\,\omega_0^3}\,\frac{\Gamma}{\Delta}\,I(\mathbf r),\]where $I(\mathbf r)$ is the intensity, $\Gamma$ the natural linewidth, and $\Delta=\omega-\omega_0<0$ the red detuning. That sign is the whole trick: with $\Delta<0$, $U\propto\Gamma/\Delta$ is negative, so $U$ is lowest where $I$ is highest, and the atom is trapped at the bright focus of the beam. This is an optical tweezer — a single tightly focused laser acting as a bowl of light a fraction of a millikelvin deep. The technique earned Arthur Ashkin a share of the 2018 Nobel Prize in Physics
The leap from one tweezer to a quantum computer is an exercise in optics. Send the trapping beam through a spatial light modulator or a pair of crossed acousto-optic deflectors, and you split it into hundreds or thousands of independent foci — a whole grid of tweezers conjured from a single laser. The build then goes in three steps. First, a magneto-optical trap laser-cools a dilute cloud of atoms to the microkelvin range. Second, the tweezer grid dips into that cold cloud and each focus grabs an atom. Third — the clever part — the array is rearranged into the shape you actually want.
Why rearrangement is unavoidable. When a tweezer dips into the cold cloud, it does not reliably catch exactly one atom. A beautiful piece of physics called the collisional blockade ensures it catches zero or one — never two, because a pair of atoms in so small a volume undergoes a light-assisted collision that ejects both — but it cannot decide which. Schlosser and colleagues showed in 2001 that this mechanism locks the average occupancy at almost exactly $0.5$ atoms per trap
Single-qubit gates are the easy half: a resonant microwave pulse (for hyperfine qubits) or a pair of laser beams (a Raman transition, or a direct optical-clock drive) flips $\vert 0\rangle\leftrightarrow\vert 1\rangle$, on one atom or, with a global field, on all of them.
Two-qubit gates are where the genius lives — and the mechanism is the most charming in all of quantum computing. The problem is that two neutral atoms in their ground states barely feel each other; they are tiny and far apart. The solution is to make them, briefly, enormous. Drive an atom’s outer electron up to a Rydberg state of high principal quantum number $n$ — in the tens, typically $n\approx 50$–$80$ — and the electron’s orbit balloons. A Rydberg atom’s size grows as $n^2$, so at $n=70$ it is hundreds of nanometers across, thousands of times larger than a ground-state atom: a fragile, bloated giant with a correspondingly giant electric dipole. Because the dipole matrix elements scale as $n^2$, the interaction between two Rydberg atoms is colossal — the van der Waals coefficient scales as $C_6\propto n^{11}$
That shove is the gate, through an effect named the Rydberg blockade, proposed by Jaksch and colleagues in 2000 and extended by Lukin and colleagues in 2001
then the laser simply cannot excite both atoms at once: the pair is locked into “at most one of you may be a giant.” For $n\approx 70$ atoms, $R_b$ runs to several microns — comfortably larger than the typical few-micron spacing in the array — so neighbors blockade each other reliably. This conditional “you may, but then you may not” is exactly the logical structure of a controlled gate. Turning it into a phase gate is the final flourish. A single carefully shaped pulse drives both atoms up toward $\vert r\rangle$ and back down again: when only one of the pair began in $\vert 1\rangle$, it completes a clean round trip and picks up a definite phase. But when both began in $\vert 1\rangle$, the blockade forbids the doubly-excited state, so the $\vert 11\rangle$ branch takes a different path and accumulates a different phase. That extra, conditional phase on $\vert 11\rangle$ alone — not the blockade by itself — is the native controlled-Z. This global-pulse protocol (Levine, Pichler and colleagues, 2019)
Reconfigurable wiring. One more control trick sets neutral atoms apart. The blockade only entangles atoms that are close together — but the claw machine that assembled the array can also move atoms during the computation. Pick up a qubit, glide it across the chip to sit beside any partner, run the blockade gate, glide it back (Figure 3). This atom shuttling turns a fixed grid into an effectively all-to-all connected machine, with the routing chosen on the fly
Lay out the ledger and the neutral atom’s defining virtue is not raw speed — its gates beat an ion’s but trail a transmon’s, and slow readout drags the clock — it is scale, and the error-correction headroom that scale unlocks.
Numbers from one laser. Because the array is conjured optically rather than fabricated qubit by qubit, growing it means splitting the beam into more spots, not threading more wires into a fridge. In 2023 Atom Computing crossed a symbolic line — a $1{,}225$-site array holding 1,180 atoms, the first gate-model platform past a thousand qubits
Identical, and reconfigurable, and cool enough. Identical atoms (above) means no fabrication spread to fight across thousands of qubits. Atom shuttling means any pair can be made neighbors, so circuits stay short instead of relaying through chains of SWAP gates. And the whole apparatus runs at room temperature — there is no dilution refrigerator, only (and this is not nothing) a rack of phase-locked lasers and an ultra-high-vacuum chamber. You save the fridge; you do not save the optics table.
Coherence in the seconds — and that is enough. Held quiet between operations, these qubits remember for a satisfyingly long time. (The trap light is not free here: it shifts $\vert 0\rangle$ and $\vert 1\rangle$ by slightly different amounts and would slowly dephase the qubit, so the headline coherence numbers are taken with the tweezer briefly off, or at a “magic” wavelength tuned to push both levels equally.) The Caltech cesium array measured a hyperfine coherence time of $12.6$ seconds
The error-correction edge. Scale plus all-to-all connectivity plus mid-circuit measurement is precisely the toolkit quantum error correction wants. And the platform turns one of its own weaknesses into a tool: when an atom is lost, or a Rydberg excitation leaks out of the qubit’s two levels, the mishap can often be detected and relabeled as an “erasure” — an error whose location is known — and quantum codes tolerate erasures at a much higher rate than ordinary blind errors
Now settle the bill. The same chargelessness that lets light hold thousands of atoms also makes them slippery in ways that charged ions never are.
Atoms run off, and loading is a coin flip. Two related leaks. The first we already met: loading is the ~50% coin flip
It is slow — but not where you’d think. The two-qubit gate itself is quick: hundreds of nanoseconds, faster than an ion’s, though it can’t touch a transmon’s. The real clock penalties live elsewhere. Readout is slow and not gentle: you read a qubit’s state by scattering many photons off it (fluorescence imaging), which takes about a millisecond to tens of milliseconds and can heat or eject the very atom you measured, so mid-circuit readout must be done carefully and locally. And the reconfigurable-connectivity superpower we met earlier bills by the move — every shuttled atom costs that hundreds-of-microseconds tax.
Gate fidelity only recently caught up. For years this was the platform’s soft spot: two-qubit gates lagged the ions and the best transmons. That changed in 2023, when an Evered–Lukin demonstration reported a two-qubit fidelity of 99.5% on up to 60 atoms in parallel — the first neutral-atom gates clearly above the surface-code error-correction threshold, using fast single-pulse gates, a low-phase-noise Rydberg laser, and better cooling
The big asterisk. That eye-popping 6,100-atom array is, today, a quantum register — a memory and a testbed for transport and imaging — not a 6,100-qubit computer. Entangling gates have not been run across all of them
The neutral-atom scoreboard is, remarkably, strong on both fronts the other platforms normally have to choose between: raw qubit count and error correction. Read each result for exactly what it is.
The logical-qubit run. The platform’s signature credential is encoded qubits. In 2024 a Harvard-led team (Bluvstein and colleagues) ran a logical processor on up to 280 physical atoms that produced 48 logical qubits, using transversal gates — logic applied to the encoded qubits atom-by-atom, so a single physical fault cannot cascade into a logical one — and reconfigurable connectivity to run circuits no prior machine could: the result that opened the neutral-atom error-correction era
The commercial and continuous milestones. On the company side, in late 2024 Microsoft and Atom Computing entangled 24 logical qubits in a cat state — a single Schrödinger’s-cat-style superposition spread across all 24 at once — on a neutral-atom processor, the largest number of entangled logical qubits reported at the time, with logical error rates several times below the physical baseline
The players. It is a crowded, fast field. QuEra runs Aquila, a publicly accessible 256-atom analog quantum simulator on the cloud
Three caveats, the same ones that govern every platform in this series, keep the scoreboard honest: a physical qubit is not a logical qubit, a lab hero-run is not an in-machine median, and a below-threshold demonstration is not yet a fault-tolerant computation. Neutral-atom practitioners, to their credit, tend to say so themselves.
A neutral-atom machine is the field’s scale-and-error-correction contender: not the fastest gates or the single finest qubit, but the easiest route to many identical qubits and the logical-qubit headroom that fault tolerance demands. Its weaknesses are the flip side of the same coin — atoms that load by coin-flip and slowly leak away, slow and delicate readout, a Rydberg-laser error budget, and the time tax on every atom you move.
And then the question this series keeps asking: can it network as well as compute? Here the neutral atom rates good, and rising. Like an ion, an atom can emit a photon entangled with its own internal state, so it can serve as a network node. The thrilling recent twist is the wavelength: in 2025 the Covey group at Illinois entangled a single $^{171}\mathrm{Yb}$ atom with a photon at 1389 nm — in the telecom band, carried with low loss by modern fiber and far better suited to it than the visible light most atomic qubits emit
| Superconducting | Trapped ion | Neutral atom | Photonic | |
|---|---|---|---|---|
| Qubit | printed circuit (transmon) | a real atom (ion) | a real atom | a photon |
| Gate speed | very fast (~10–70 ns) | slow (~µs) | medium (~0.1–1 µs) | n/a (measurement) |
| Coherence | short (~0.1–1.7 ms) | very long (s–hr) | long (s) | loss-limited |
| Connectivity | mostly nearest-neighbor | all-to-all | reconfigurable | hard (no interaction) |
| Operating temp | ~10 mK (dilution fridge) | room-temp vacuum | room-temp vacuum | room temperature |
| As a network node | needs transduction | natural (emits photons) | promising | it is the photon |
No platform wins every row — the whole reason five of them are still racing. Superconducting out-sprints decoherence; the trapped ion out-lasts and out-connects everyone; the neutral atom out-scales them, trading top-end per-qubit quality for a box of thousands of identical bricks and the error-correction headroom that comes with it. If your wish list is a cloud-accessible engineering juggernaut today, superconducting still leads; if it is record fidelity and a triple-threat memory-processor-node, the ion is the one to beat; if it is many qubits, many logical qubits, and a clear path to fault tolerance, the neutral atom is the route now setting the pace. But notice what every platform so far has had to fight for: holding a piece of matter still and quiet long enough to compute. The next route stops fighting that battle entirely — by choosing a qubit that refuses to sit still at all, that flies down a fiber by its very nature, and is the consensus best quantum-network node. The fourth build: photonic.
More in this series — How to Build a Quantum Computer: Superconducting · Trapped ion · Neutral atom · Photonic · Other platforms