PowerMove: Optimizing Compilation for Neutral Atom Quantum Computers with Zoned Architecture

In a neutral-atom quantum computer each qubit is a single atom held in a light trap, and you can physically shuttle atoms to bring any two together for a gate — a superpower for connectivity — while a new zoned architecture even parks idle qubits in a protected storage zone away from the laser that would disturb them; but a compiler must choreograph gate scheduling, qubit placement, atom movement, and zone transfers all at once, and prior compilers either froze the layout or could not scale to fully dynamic moves; this paper (UC San Diego, PNNL, and Oak Ridge — Jixuan Ruan, Xiang Fang, Hezi Zhang, Ang Li, Travis S. Humble, Yufei Ding) presents PowerMove, whose continuous router moves qubits directly between layouts instead of through fixed intermediate steps, and whose stage and collective-move schedulers exploit the storage zone, improving fidelity by orders of magnitude while cutting execution time by up to 3.76 times and compilation time by up to 216.9 times.

The argument in one glance

Problem

Neutral-atom machines can move qubits and protect them, but only if the compiler can plan it

A neutral-atom quantum computer holds each qubit as a single atom in a tiny optical trap, and it has two remarkable abilities. First, it can physically move atoms during a computation, shuttling them around to bring any two qubits next to each other for a two-qubit gate — so unlike fixed-wiring machines, connectivity is not limited by a static layout. Second, a recent zoned architecture splits the machine into a computation zone, where a laser executes gates, and a storage zone, where idle qubits sit protected from that laser and barely decohere. Together these promise both flexible connectivity and long-lived qubits. But the abilities are only as good as the compiler that orchestrates them: turning a quantum circuit into a schedule of gates, atom placements, movements, and zone transfers is a hard planning problem, and if the compiler plans poorly the machine spends its short coherence budget moving atoms around badly.
What people did

Build a compiler that schedules gates and routes qubit movement

Several neutral-atom compilers already exist to harness qubit movement. They partition a circuit into stages of parallel gates, place qubits so the intended pairs can interact, and then rearrange the atoms between stages using the machine's collective-movement operations, trying to realize the circuit's connectivity through motion rather than fixed links.
Why it fell short

Prior compilers waste the movement freedom and ignore the new zones

The paper argues existing compilers fall short of the flexibility the hardware offers. Some settle for a partially fixed layout, giving up much of the freedom that free movement provides; others try to handle fully dynamic layout transitions but do not scale, because the joint design space — gate scheduling, qubit allocation, movement under strict collective-move rules, and inter-zone transfers all at once — is enormous, and solver-based methods bog down. Movement is also constrained: atoms picked up by the mobile traps form rows and columns that must move together and cannot cross, so you cannot reposition one qubit in isolation. On top of this, the zoned architecture is new and underexploited, because a compiler that already struggles with movement cannot readily add the storage zone. The result is that the machine's two headline abilities — flexible movement and protective storage — are left largely on the table.
This paper's idea

Route qubits directly between layouts and schedule around the storage zone

PowerMove is a compiler for neutral-atom machines that unlocks the movement flexibility while fully integrating the zoned architecture. Its centerpiece is a continuous router that enables direct transitions between one stage's qubit layout and the next, instead of shuffling atoms through a sequence of fixed intermediate positions, which sharply reduces movement overhead; it decides each single qubit's movement and then groups compatible moves into the collective movements the hardware requires. Around this, a stage scheduler partitions the circuit into stages of parallel gates and schedules them, and a collective-move scheduler (with intra-stage and multi-mobile-trap scheduling) exploits the storage zone to keep idle qubits protected and minimize decoherence — integrating the storage zone for the first time to eliminate laser-induced excitation errors at minimal overhead. Across NISQ applications, PowerMove improves fidelity by orders of magnitude over the state of the art, cuts execution time by up to 3.76 times and compilation time by up to 216.9 times, and extends to fault-tolerant computing with a 4.78 times execution-time reduction.

Why this problem is worth solving

Neutral atoms are one of the most promising roads to scalable quantum computing precisely because of the abilities that make them hard to compile for.

In a neutral-atom machine, each qubit is one atom trapped by focused light. There are two kinds of traps: static ones made by a spatial light modulator, and mobile ones made by a crossed acousto-optic deflector that can be steered. By transferring an atom into a mobile trap and moving that trap, the machine physically relocates the qubit while it holds its quantum state, and it can move many atoms together this way. This is the source of neutral atoms’ famous flexibility: rather than being stuck with whichever qubits are wired as neighbors, the machine can bring any pair of qubits close together on demand, giving all-to-all connectivity through motion. To perform a two-qubit gate, it brings the interacting pairs close and fires a global Rydberg laser, which executes the entangling gate on every nearby pair at once, in parallel. Single-qubit and two-qubit gate fidelities are already very high and coherence times reach seconds. So the hardware offers a rare combination: reconfigurable connectivity, parallel gates, and long-lived qubits. The catch is that all of this depends on choreographing where every atom is and when it moves, which is not a hardware problem but a compiler problem — the physics gives you the moves, and the compiler has to decide them.

The zoned architecture adds a second lever, protection, that raises both the payoff and the difficulty.

The Rydberg laser that performs gates is global — it illuminates the whole computation region — so any qubit sitting there while a gate fires is exposed to excitation errors, even if it is not meant to be part of the gate. The zoned architecture addresses this by dividing the machine into a computation zone, where gates happen under the laser, and a storage zone, where qubits are kept away from the laser, decohering negligibly and shielded from those excitation errors. The strategy this enables is powerful: keep every qubit in protected storage by default, and shuttle a qubit out into the computation zone only for the moments it actually participates in a gate, then return it. Done well, this dramatically cuts the errors idle qubits accumulate, which is often what limits how deep a circuit you can run. But it makes the compiler’s job harder, not easier, because now the plan must also decide, for every stage, which qubits to move between zones and when, on top of scheduling the gates and routing the movements — and every inter-zone trip is itself a collective move subject to the hardware’s rules. The zoned architecture is thus a genuine opportunity to improve fidelity, but only a compiler that can already handle movement well can seize it, which is exactly the gap PowerMove sets out to fill.

What people did before, and where it broke

Fixed or partially fixed layouts. Keep the qubit layout mostly static and route the few needed interactions, avoiding the complexity of free movement. Where it broke. This throws away the flexibility that qubit movement offers, so the compiler cannot realize the connectivity and parallelism the hardware could achieve.
Fully dynamic layout via solvers. Let the layout change freely between stages and solve for the movements with a general solver. Where it broke. The joint space of gate scheduling, allocation, movement, and zone transfers is enormous, so solver-based approaches do not scale to realistic circuit sizes.
Movement through fixed intermediate steps. Rearrange atoms by passing them through a sequence of predefined intermediate positions. Where it broke. Forcing every layout change through fixed waypoints adds unnecessary movement, and movement takes time during which qubits decohere, so overhead and error pile up.
Movement-focused compilers without the zoned architecture. Optimize qubit movement but on a single-zone machine. Where it broke. They cannot readily incorporate the newly introduced storage zone, so they leave its large fidelity benefit — protecting idle qubits from excitation errors — unexploited.
The gap. No compiler both fully exploited qubit movement (routing directly between layouts, at scale, under the collective-move rules) and integrated the zoned architecture to protect idle qubits, which is what is needed to turn the hardware’s flexibility and protection into real fidelity and speed.

How PowerMove works

Compiling a circuit into staged gates, direct movements, and zone transfers

↓ →
new
↓ →
new
↓ →
new
↓ →
new
↓ →
new

The idea

Match the compiler to the machine’s actual freedom and rules. The organizing move in PowerMove is to build a compiler around exactly what neutral-atom hardware can do — arbitrary movement of atoms, parallel gates under a global laser, and now zoned storage — and exactly the constraints it imposes, rather than settling for a simplified model that discards the flexibility. Prior compilers either fixed the layout (losing the movement power) or modeled full dynamism with a solver (losing scalability); PowerMove instead designs dedicated stages that jointly respect the freedom and the collective-move rules. Building a compiler that is specialized to the concrete structure and constraints of a particular quantum architecture, rather than a generic mapper, is the same principle the work on exploiting the regular structure of modern quantum architectures for compilation covered elsewhere on this site is built on, letting the hardware’s specifics guide the compilation strategy. PowerMove applies that stance to the neutral-atom setting, where the defining structure is free but rule-bound atom movement plus zones.

Move directly between layouts instead of through fixed waypoints. The heart of the speed and fidelity gains is the continuous router. Every layout change costs time, and time costs coherence, so the fewer and shorter the movements, the better. Routing atoms through a sequence of predefined intermediate positions, as earlier approaches did, adds movement that is not strictly necessary; PowerMove’s router instead computes a direct transition from the current layout to the next, deciding single-qubit moves and then grouping them into the hardware’s collective movements. Managing qubit positions cleverly through the compiler — deciding when and how qubits are relocated or reused so the circuit runs with less overhead — is the same discipline the work on compiler-assisted qubit reuse through dynamic circuits covered elsewhere on this site pursues, treating qubit logistics as a compilation-time optimization. PowerMove’s version optimizes the physical trajectories of atoms, turning layout changes into direct, grouped moves.

Spend the storage zone to buy fidelity. The other half of PowerMove’s benefit is protection: because idle qubits exposed to the global gate laser accumulate excitation errors, keeping them in the storage zone whenever they are not needed removes a major error source, and PowerMove is the first compiler to integrate this zone, scheduling qubits in and out of storage while keeping the extra movement overhead small. Reducing the errors a circuit accumulates by carefully controlling when and how qubits are exposed to noisy operations is the same fidelity-first instinct the work on boosting the fidelity of noisy quantum circuits covered elsewhere on this site embodies, treating error avoidance as a compile-time objective. PowerMove pursues it structurally, using the hardware’s protected zone as the place to hide qubits from the very laser that runs the gates, so the coherence budget goes toward computation rather than idle exposure.

Following a circuit through PowerMove

Compiling and running one circuit on a zoned neutral-atom machine

A trace, drawn from the paper, of how PowerMove turns a circuit into staged gates, direct movements, and storage-zone transfers.

Step 1 of 5

Partition the circuit into stages of parallel gates

The stage scheduler groups the circuit's gates into stages in which the gates act on disjoint qubits, so a single firing of the global Rydberg laser executes all of a stage's two-qubit gates at once. This defines, for each stage, which qubits must be paired up in the computation zone.

Parallel stages exploit the global laser, which entangles all nearby pairs simultaneously.

Why it works

Direct layout transitions cut movement and thus error. Routing atoms through fixed intermediate positions adds motion that is not needed → but a continuous router transitions straight to the next layout → so atoms spend less time moving and accumulate less decoherence.
Parallel stages use the global laser fully. Running two-qubit gates one at a time wastes the hardware’s parallelism → but partitioning into stages of disjoint-qubit gates lets one laser pulse do many → so more computation happens per exposure and per unit time.
The storage zone removes a major idle-error source. Idle qubits left in the computation zone are hit by the global gate laser → but parking them in the protected storage zone shields them → so the errors that idle exposure would cause are eliminated.
Grouping into collective moves respects the hardware yet stays efficient. The mobile traps can only move rows and columns together without crossing → but grouping the router’s single-qubit decisions into legal collective moves honors that → so the plan is executable while still minimizing the number of moves.
Dedicated schedulers scale where solvers do not. Solving the whole coupled problem at once does not scale to real circuits → but splitting it into stage, routing, and collective-move schedulers makes each tractable → so PowerMove compiles far faster, up to 216.9 times, while improving results.

What it costs (trade-offs and scope)

Using the storage zone adds movement. Protecting idle qubits means shuttling qubits between the storage and computation zones, which is extra motion; PowerMove integrates the storage zone with minimal overhead, but the benefit is a trade between the errors avoided by protection and the time and error added by the extra trips, which depends on the circuit.
It is specialized to neutral-atom hardware and its rules. The whole design is built around atom movement, the global Rydberg laser, collective row-and-column moves, and the zoned architecture; it does not transfer to quantum platforms with different connectivity and gate mechanisms, and its models assume the specific movement constraints of these machines.
Gains depend on the circuit’s structure. How much PowerMove helps depends on how much movement and idle protection a given circuit can benefit from; circuits that are already local or shallow offer less room, and the reported speedups are ranges, not guarantees, across the evaluated applications.
The reported numbers are versus specific baselines and settings. The orders-of-magnitude fidelity improvement, up to 3.76 times execution and 216.9 times compilation speedups, and the 4.78 times fault-tolerant execution reduction are measured against the state-of-the-art neutral-atom compiler on particular NISQ and fault-tolerant benchmarks; other circuits, hardware parameters, and baselines would shift them.
It optimizes compilation, not the hardware’s error rates. PowerMove improves how well a circuit is scheduled and routed; it does not change the underlying gate or coherence quality, so its fidelity gains come from reducing avoidable movement and idle exposure, not from better physics.

The evaluation

Compiling circuits for a zoned neutral-atom quantum computer

Property	Fixed-layout compiler	Solver-based dynamic compiler	PowerMove
Uses full movement flexibility
Scales to real circuits
Movement between layouts
Uses the storage zone
Reported outcome

A qualitative comparison of neutral-atom compilers. Against the state of the art, PowerMove improves fidelity by orders of magnitude and reduces execution time by up to 3.76 times and compilation time by up to 216.9 times on NISQ applications, and extends to fault-tolerant computing with a 4.78 times execution-time reduction.Underlined values explain themselves when clicked.

Where this stops working

What to keep in mind

This explainer is based on the paper’s abstract and its arXiv preprint (arXiv:2411.12263), together with standard background on neutral-atom quantum computing. The mechanism described is the paper’s: PowerMove is a compiler for neutral-atom quantum computers with the zoned architecture, comprising a stage scheduler (stage partition and scheduling), a continuous router that enables direct transitions between qubit layouts (single-qubit movement decisions grouped into collective movements), and a collective-move scheduler (intra-stage and multi-mobile-trap scheduling) that integrates the storage zone to protect idle qubits from excitation errors at minimal overhead. The headline figures quoted here — orders-of-magnitude fidelity improvement, up to 3.76 times execution-time reduction, up to 216.9 times compilation speedup, and a 4.78 times fault-tolerant execution-time reduction — are the published version’s reported results; note the earlier arXiv v1 preprint reports slightly different figures (up to 3.46 times execution and 213.5 times compilation), reflecting revisions between versions. Exact algorithms, the fidelity model, hardware parameters, and full benchmarks should be read from the paper. The code is open-sourced at github.com/Scarlett0815/PowerMove.

Background

Why quantum compilation is where the leverage is now

It helps to see PowerMove as part of a broad realization in quantum computing: much of the near-term and long-term performance of a quantum machine is decided not by the raw device but by the compiler that maps abstract circuits onto its messy physical reality. Real quantum hardware has restricted connectivity, noisy gates, short coherence, and idiosyncratic control mechanisms, and a circuit written in the ideal must be transformed — mapped, routed, scheduled, and optimized — to run at all, let alone well. Because gate and coherence errors compound, small differences in how a compiler places and moves qubits or orders operations translate into large differences in the fidelity of the final result, so the compiler is often the difference between a usable answer and noise. This is why so much effort now goes into architecture-aware compilation, and why each new hardware capability — movable atoms, zoned protection, and beyond — immediately raises a matching compiler challenge. The same recognition that unlocking a quantum machine’s promise requires software and systems built for it, all the way up to the fault-tolerant, error-corrected regime, animates the work on a fault-tolerant, million-qubit-scale distributed quantum computer covered elsewhere on this site, which reasons about the full stack needed at scale. PowerMove is a concrete instance for neutral atoms, and its extension to the fault-tolerant setting shows the same compiler ideas carrying forward.

If you remember only three things

1. Neutral-atom quantum computers can physically move atoms to bring any qubits together (flexible connectivity) and, with the new zoned architecture, park idle qubits in a storage zone protected from the global gate laser. But exploiting these abilities requires a compiler to jointly solve gate scheduling, qubit placement, atom movement under strict collective-move rules, and inter-zone transfers — a huge coupled space. Prior compilers either fixed part of the layout (wasting the movement flexibility) or handled full dynamism but did not scale, and none properly used the storage zone.
2. PowerMove is a neutral-atom compiler with three parts: a stage scheduler that partitions the circuit into stages of parallel gates; a continuous router that transitions directly between one stage's layout and the next (deciding single-qubit moves and grouping them into legal collective movements) instead of routing through fixed waypoints, cutting movement overhead; and a collective-move scheduler that, for the first time, integrates the storage zone to protect idle qubits from excitation errors at minimal overhead, using multiple mobile traps.
3. Against the state-of-the-art neutral-atom compiler, PowerMove improves fidelity by orders of magnitude and reduces execution time by up to 3.76 times and compilation time by up to 216.9 times on NISQ applications, and extends to fault-tolerant computing with a 4.78 times execution-time reduction. Its gains trade extra zone-transfer movement for protection, are specific to neutral-atom hardware and its rules, and depend on the circuit; the code is open-sourced.

Check yourself

Check your understanding

1. What two hardware abilities of neutral-atom quantum computers make compilation both powerful and hard?
2. What is PowerMove's central contribution?
3. Why does routing qubits directly between layouts improve fidelity?
4. What did PowerMove achieve, and what are its main caveats?

Sources

The paper is “PowerMove: Optimizing Compilation for Neutral Atom Quantum Computers with Zoned Architecture” by Jixuan Ruan, Xiang Fang, Hezi Zhang, Ang Li, Travis S. Humble, and Yufei Ding (University of California San Diego, Pacific Northwest National Laboratory, and Oak Ridge National Laboratory), published at ASPLOS 2025, DOI 10.1145/3676642.3736128. The code is open-sourced at github.com/Scarlett0815/PowerMove.

This explainer is written from the paper’s abstract and its arXiv preprint (arXiv:2411.12263), plus standard background on neutral-atom quantum computing. The paper presents PowerMove, an efficient compiler for neutral-atom quantum computers that fully leverages qubit movement while integrating the zoned architecture. Its components are a stage scheduler (stage partition and stage scheduling), a continuous router that enables direct transitions between qubit layouts by deciding single-qubit movements and grouping them into collective movements (reducing movement overhead), and a collective-move scheduler (intra-stage and multi-mobile-trap scheduling) that integrates the storage zone for the first time to eliminate laser-induced excitation errors on idle qubits at minimal overhead. The published abstract reports fidelity improvements of several orders of magnitude over state-of-the-art methods, execution-time reductions of up to 3.76 times, compilation-time speedups of up to 216.9 times across NISQ applications, and, extending to the fault-tolerant setting with logical qubits encoded in quantum error-correcting codes, a 4.78 times execution-time reduction; the earlier arXiv v1 preprint reports somewhat lower figures (up to 3.46 times execution and 213.5 times compilation), reflecting revisions between the preprint and the published version. No numbers beyond the paper’s own have been introduced; exact algorithms, the fidelity model, hardware parameters, and full benchmarks should be confirmed in the paper.