Neutral Atom Quantum Computing, and Why It Is Not Gate-Based

Everything here is runnable on your own circuit. Try it in the console

Neutral atom quantum computing has the largest publicly accessible qubit count of any modality. QuEra's Aquila offers 256 qubits, against 108 for the largest publicly accessible superconducting device and 36 for the largest trapped-ion one. On a specification sheet that looks decisive.

It is also misleading, because Aquila does not accept quantum gates. Understanding why is the most useful thing to know about the modality, and it is rarely the first thing said about it.

The physics

A neutral atom quantum computer holds individual atoms, usually rubidium, in optical tweezers: tightly focused laser beams that trap a single atom at a fixed point in space. An array of such tweezers holds an array of atoms, and because the tweezers can be positioned arbitrarily, the qubit array can be arranged in almost any geometry. Two dimensional lattices, rings, arbitrary graphs, all are available by moving light rather than by fabricating a new chip.

The qubit is encoded in two electronic states of the atom. Interaction between qubits uses the Rydberg blockade: exciting an atom to a Rydberg state, one with a very high principal quantum number, inflates it enormously and shifts the energy levels of its neighbours.

Within a blockade radius, a second atom cannot be excited simultaneously. That conditional behaviour is the two-qubit interaction.

Two consequences follow, and they are the modality's real advantages.

Every qubit is identical. Atoms of a given isotope are indistinguishable by physical law. Superconducting qubits are lithographically fabricated and vary from one another, which is why calibration is a permanent operational burden on those platforms. Neutral atom arrays have no fabrication variance to calibrate away.

The geometry is programmable. Connectivity is set by where the tweezers put the atoms, not by wiring laid down at manufacture. A problem whose natural structure is a triangular lattice can be given a triangular lattice.

The part the qubit count does not tell you

Aquila is an analog Hamiltonian simulator, not a gate-based quantum computer. Its interface reflects that directly. Querying the device registry returns a paradigm of quera_ahs_paradigm_properties and a single accepted program type, braket.ir.ahs.program. It does not accept OpenQASM. There is no gate set to compile to.

Device        QuEra Aquila
Qubits        256
Paradigm      analog Hamiltonian simulation (AHS)
Accepts       braket.ir.ahs.program
Does NOT      OpenQASM, gate-based circuits
Shots         1 to 1,000 per task
Price         $0.01 per shot

Programming it means something structurally different from writing a circuit. Instead of a sequence of gates, you supply the positions of the atoms and a set of time-dependent control functions: the Rabi frequency, the detuning, and the phase, each specified as a waveform over the duration of the run. The machine then evolves the whole system under the Hamiltonian those parameters define, and you measure the final configuration.

This is quantum simulation in the original sense that Feynman proposed: building a controllable quantum system whose dynamics mirror the system you want to study. It is not a universal computer executing an algorithm. Grover's algorithm has no meaning on Aquila, because Grover's algorithm is a sequence of gates and there are no gates.

What that makes it good for, and bad for

The natural applications are problems that map onto the physics directly.

• Condensed-matter physics. Quantum spin models, phase transitions and quench dynamics in Ising-type systems are what the Rydberg Hamiltonian naturally expresses. This is the strongest use, and it is genuine research rather than a demonstration
• Combinatorial optimisation with a geometric structure. Maximum independent set maps onto the Rydberg blockade almost exactly: within a blockade radius, two atoms cannot both be excited, which is the independent set constraint expressed as physics rather than as a penalty term. Placing atoms according to a graph makes the ground state the answer

The exclusions are equally sharp. Shor's algorithm, Grover search, quantum phase estimation, variational circuits with parameterised gates and error-corrected logical operations are all gate-based constructions, and none of them apply. A team whose work is written in Qiskit cannot submit it to Aquila by changing a device string.

Click to enlarge

Close

How it compares in practice

Set against the other modalities available on the same cloud:

                        Superconducting     Trapped ion        Neutral atom
Qubits (public)         up to 108           up to 36           256
Gate-based              yes                 yes                not on Aquila
Connectivity            fixed by wiring     all-to-all         programmable
                                                               geometry
Gate speed              fast                slow               n/a (analog)
Qubit uniformity        fabrication         identical          identical
                        variation
Price per shot          $0.000425 to        $0.0235 to         $0.01
                        $0.0016             $0.08

The pricing is worth noting because it is quoted per shot and Aquila caps a task at 1,000 shots, so a single run costs at most ten dollars. That is inexpensive for hardware access. The constraint is not budget, it is applicability.

Where the modality is going

The gate-based limitation is a property of this generation rather than of neutral atoms. Gate-based neutral atom processors exist in the laboratory, and the modality is a serious contender for fault-tolerant quantum computing precisely because atoms can be physically moved during a computation, which allows logical qubits to be shuffled into position rather than requiring long-range couplers.

QuEra has stated a fault-tolerant target of 2028, and specialised compilers for fault-tolerant neutral atom hardware are already being built commercially.

For now, the honest summary is that neutral atoms lead on qubit count and on physical elegance, and that the leading accessible machine solves a different class of problem from the gate-based devices it is listed beside. A qubit count comparison across modalities is therefore not a like-for-like comparison, and treating it as one leads to the wrong hardware.

What the blockade actually buys you, measured

The claim that neutral-atom order comes from the Rydberg blockade is repeated everywhere and quantified almost nowhere. So we measured it: seven atoms in a line, one adiabatic pulse sequence, 1000 shots at each of seven spacings, changing nothing but the distance between atoms.

The quantity that decides the physics is the blockade radius divided by the spacing, Rb/a. Above 1 each atom suppresses its neighbour and the chain settles into the alternating pattern 1010101; below 1 it does not.

spacing   Rb/a   1010101 %   distinct outcomes seen
 5.0 um   1.28       89.9%          12
 5.6 um   1.14       84.9%          23
 6.0 um   1.07       62.9%          36
 6.4 um   1.00       36.9%          64
 7.0 um   0.91        6.8%          72
 8.0 um   0.80        0.0%          36

Two things are worth taking from that. The order does not switch off at a threshold, it decays, and steeply: between Rb/a of 1.28 and 1.00, a spacing change of a third of a micrometre, the target state falls from nine runs in ten to fewer than four. And at 8.0 um the chain becomes ordered again into the *wrong* state, every atom excited, which an experiment measuring only whether the output is sharply peaked would score as a success.

The full sweep, including the certificate for one run, is in Rydberg blockade and antiferromagnetic order.

What the hardware actually returned

Everything above was measured on the emulator. On 11 September 2026 we ran a sequence on Aquila itself: four atoms, 20 shots, $0.50, submitted through the ordinary API.

It is worth being precise about the timing, because the obvious number is the misleading one. We submitted on a Wednesday afternoon and the result arrived 38.8 hours later, but Aquila publishes no Tuesday-to-Thursday window and opened at 04:00 UTC on the Friday.

The run completed at 06:06 UTC. The device took about two hours from the window opening; the other 36 hours were its published schedule, which we knew before submitting. Quoting the wall clock as a queue time would be blaming the machine for being closed.

outcome   measured   ideal
0000        14/19     0.552
0110         0/19     0.129
1001         0/19     0.129
0100         3/19     0.046
0001         2/19     0.046

One shot of the twenty registered an empty site, an atom that never loaded, and is excluded. It measured a smaller register than the one submitted, so it has no counterpart in any simulation of it. That is standard practice and it is still post-selection, so the retained fraction, 0.95 here, is reported alongside rather than folded away.

The certified fidelity against our own exact simulation is 0.6294 (certificate d3abecb2c8d14c2f). The device under-excited: the ideal puts 12.9 percent on each of 0110 and 1001 and the run produced neither, while landing 74 percent on the all-ground state against an ideal 55 percent.

That is a small result and worth reading as one. It establishes that the path works end to end on real neutral-atom hardware and that the deviation is the device rather than the sampling; it does not characterise Aquila, which would take hundreds of shots and more than four atoms.

That larger instance has since run. On 18 September 2026 the same path took nine atoms on a 3x3 grid at 1,000 shots, which is the maximum independent set problem the blockade encodes directly, and the identical register was run on the local emulator for comparison.

Run on our engines

Nine atoms on a 3x3 grid at 6 um spacing, whose blockade graph is the king's graph: 9 vertices, 20 edges, and a maximum independent set of 4 that can be checked by hand. On 25 September the identical sequence ran on analog.pulser.gpu, an NVIDIA GPU, returning the same set with all 500 shots valid. Submitted to each kind of compute we offer, on 18 and 25 September 2026. Every figure below is a real job on the service, priced as any customer would be priced.

Device	Engine	Kind	Qubits	Result	Cost
	analog.pulser.cpu	CPU	9	found [0, 2, 6, 8], size 4; 500 of 500 shots valid	$0.0001
	analog.pulser.gpu	GPU	9	found [0, 2, 6, 8], size 4; 500 of 500 shots valid certificate	$0.0017
	qpu.quera.aquila	QPU	9	found [0, 2, 6, 8], size 4; 883 of 947 shots valid, 574 optimal•best outcome	$10.3000
	qpu.pasqal.fresnel	QPU	—	takes the identical Pulser sequence, but is billed as machine time at one shot per four seconds, so a run at this shot count is not comparable in cost	—

The same problem is yours to run: every instance here is seeded, so it rebuilds exactly. Open the console and a cost estimate is free before anything executes.

At this size the result is checkable by hand. The four corners sit outside the blockade, and no independent set of five exists on the king's graph. Both rows found it. The difference is in the shots that obeyed the constraint, every one on the emulator against 883 of 947 on hardware, which is the number worth carrying forward to sizes where the answer cannot be checked. The method is written up at maximum independent set on neutral atoms.

Before any hardware run

This applies to every modality and it applies here with particular force, because the programming model is unfamiliar. Whatever the device, the question worth asking first is whether a classical simulation answers the same question for a fraction of a cent.

Ising dynamics of the kind Aquila runs are frequently within reach of tensor-network methods on a laptop, as measured in How many qubits can a tensor network simulate, and a simulated run tells you what the hardware ought to produce, which is the only way to know whether the hardware run succeeded.

The general argument is in CPU vs GPU vs TPU vs QPU, and the comparison of the gate-based modalities is in Transmon or trapped ion.

For neutral atoms specifically that simulation is exact and free at small sizes. The analog engine here integrates the full state with no truncation up to 14 atoms, at $0.0001 per circuit, and validates a sequence against a real device's constraints before submission, so a register the hardware would refuse is caught locally rather than after a queue.

Above 20 atoms the exactness stops: cost grows with 2^n amplitudes carried through every timestep, and no exact classical method follows a 256-atom machine anywhere. The CPU engine holds 14 and the GPU engine 20, which moves the wall rather than removing it. One run at 5.2 um carries a public certificate at cb6bf9ecb491466d, reporting 909 of 1000 shots in the target state with the full outcome distribution attached.

Pricing every figure below against your own workload: open the per shot cost calculator.