Compilation, Emulation & Verification of Neutral Atom Computing

Quantum computing is transitioning from an academic idea to a practical technology, driven by recent hardware advancements and clear paths toward real-world applications. Universal quantum ecosystems (e.g., Qiskit, Cirq, PennyLane) facilitate this transition by providing a consistent interface to diverse quantum devices, abstracting hardware-specific details through a device model that captures each device's computational capabilities. However, these device models have historically been shaped by superconducting hardware, assuming static qubit positions and fixed coupling maps, which prevents them from representing the unique computational capabilities of emerging technologies such as neutral atoms, which feature dynamic qubit rearrangement and zoned operations. As a result, although numerous specialized compilers for neutral atom devices already exist, they cannot retrieve the hardware information they need through these ecosystems—creating a technology lock that hinders or even prevents the integration of neutral atom devices. In this work, we demonstrate how this limitation leads to suboptimal compilation results and can exclude certain devices entirely. Motivated by this, we propose rethinking current device models to faithfully represent neutral atom devices, enabling their seamless integration into universal quantum ecosystems. Evaluations conducted within the Quantum Device Management Interface (QDMI) demonstrate that the proposed device model unlocks a routing overhead fidelity improvement by a factor of up to 100,000 on a circuit with 16 qubits and 600 gates.

Atom loss is one of the key sources of error in neutral atom quantum computing, so it is important to account for it in compilation and simulation. In this talk, I will discuss several unique considerations that arise as we handle atom loss across quantum error correction workflows. In particular, I will use the gate-removing-under-loss model as the main motivating example and show how it pressures compilation, verification, simulation, and decoding stacks in ways that standard Pauli noise models do not. I will also present some early efforts towards using gadget abstractions to analyze neutral atom quantum computing systems.

Neutral-atom quantum computers expose a complex control surface: not only which gates to apply, but where atoms sit and how they move. Programming them well therefore demands a compiler. I will give an overview of Bloqade, QuEra's open-source SDK for neutral-atom quantum computing, framed as a multi-level compiler pipeline: from high-level kernels written in embedded DSLs, through circuit-level intermediate representations, down to the physical trap positions and atom-shuttling schedules the hardware actually executes. I will then cover three recent developments in the ecosystem. First, the fixed-line architecture, a hardware abstraction that constrains atom movement to a fixed set of lanes, making the shuttling problem tractable to compile against at scale. Second, an ongoing Rust reimplementation of Kirin, the compiler infrastructure underpinning Bloqade, motivated by performance and by a cleaner foundation for analysis and transformation passes. Third, PPVM, a new simulator built to give realistic, noise-aware simulation of device behavior rather than idealized circuit semantics. Bloqade is developed in the open, and I will close with outlooking where we are working towards in the Bloqade ecosystem, and our approach to FTQC from a software perspective.

Neutral-atom architectures open up different opportunities to optimize quantum programs than their superconducting counterparts: reconfigurable connectivity via atom movement, zone-structured hardware, and global gate application all offer degrees of freedom that a fixed coupling map cannot express. This talk examines how a compiler can exploit these opportunities for fault-tolerant programs by reasoning about the underlying physical mechanisms. When neutral atom-based fault-tolerant quantum computing arrives on AWS, compilers that take advantage of these controls will power the most impactful workloads.

Neutral atom quantum computers can rearrange qubits before entangling operations, but realistic movement constraints make compilation a difficult hardware-constrained search problem. In fixed-lane architectures, atoms must move along calibrated transport paths, obey coupled AOD pickup rules, avoid collisions and invalid occupancies, and return to home locations after each entangling layer. We introduce Entropy-Guided Search (EGS), a bounded heuristic graph-search algorithm for compiling CZ layers into valid neutral atom movement schedules. EGS combines target-directed routing with a node-local entropy mechanism that increases mobility-preserving exploration when greedy progress fails, allowing the search to escape cyclic deadlocks and preserve future routing options. Implemented in Bloqade Lanes, EGS is evaluated against A*, BFS, greedy search, DFS, and iterative diving search on random and application-derived benchmark circuits. Across 300 correlated-CZ random circuits and nine application-based workloads, EGS successfully compiles all tested circuits while producing lower or comparable movement-layer counts than other search strategies, demonstrating a practical and tunable approach to movement compilation for constrained neutral atom hardware.

Zoned neutral atom architectures are emerging as a promising platform for large-scale quantum computing. Their growing scale, however, creates a critical need for efficient and automated compilation solutions. Yet, existing methods fail to scale to the thousands of qubits these devices promise. State-of-the-art compilers, in particular, suffer from immense memory requirements that limit them to small-scale problems. This work proposes a scalable compilation strategy that "searches smarter, not harder". We introduce Iterative Diving Search (IDS), a goal-directed search algorithm that avoids the memory issues of previous methods, and relaxed routing, an optimization to mitigate atom rearrangement overhead. Our evaluation confirms that this approach compiles circuits with thousands of qubits and, in addition, even reduces rearrangement overhead by 28.1% on average. The complete code is publicly available in open-source as part of the Munich Quantum Toolkit (MQT) at https://github.com/munich-quantum-toolkit/qmap.

Neutral-atom arrays are emerging as a leading platform for scalable quantum error correction (QEC). Qubits are routed and reused across the array, while detected loss is reported to the decoder as erasure information. Existing neutral-atom compilers optimize this movement, including routing, shuttling, and reuse, and often model loss through scalar exposure costs. Yet total exposure is an incomplete statistic for erasure-corrected QEC. It captures how much loss occurs, but not where it lands on the code, which we call its deposition. Under the same expected atom-loss budget, different deposition patterns over a code patch induce substantially different logical error rates (LER). We formalize this as decoder-aware risk deposition and present CAST, a compiler-side optimization pass that overlays a code-topology sensitivity map on a role-indexed exposure ledger and minimizes a decoder-weighted harm objective under a comparable-exposure constraint, using only local route, role, and seam-cooling actions. Across surface-code memory, physical-scale architecture models, lattice surgery, and decoder-mismatch checks, CAST lowers LER relative to topology-blind exposure minimization, improving on it in 35 of 48 physical-scale settings and by as much as 5.3x where exposure is heterogeneous and routing has slack. The largest gains occur when high exposure and high decoder sensitivity are initially misaligned, giving CAST room to redirect risk toward lower-impact code roles. CAST shows that decoder-aware atom-loss risk deposition can be optimized as a compiler-side pass in neutral-atom QEC.

Neutral-atom processors rely on spatially arranged qubit arrays and parallel Rydberg entangling gates for scalable execution. Their compilers enforce geometric spacing rules for simultaneous gates, yet legal separation does not make residual van der Waals coupling disappear. This paper studies that gap between geometric legality and residual noise by treating entangling-zone spacing as a cross-layer reliability--parallelism variable anchored to experimental neutral-atom geometry. We combine fixed-schedule residual replay, surface-code simulation with matched correlated decoding, and fresh recompilation to connect spacing to physical residual exposure, logical reliability, and makespan cost. The results show that near-floor spacing can produce structured correlated exposure that is visible both at the physical layer and, in the tightest case, after quantum error correction (QEC). Modest geometric slack strongly suppresses this residual contribution, but the timing cost of looser spacing is mediated by placement and scheduling rather than by a simple monotonic slowdown. These findings distinguish hardware legality from residual-noise safety and motivate spacing-aware compiler evaluations that report physical geometry, QEC absorption, and scheduling cost together.

Fault-tolerant quantum computing requires efficient compilation across multiple abstraction levels, from synthesizing resource-efficient logical circuits to executing them on physical architectures. In this talk, I will present our recent efforts toward cross-layer compilation for fault-tolerant quantum computing. At the frontend, we exploit circuit structure to reduce costly non-Clifford operations. At the backend, I will introduce FT-Weave, a real-time compilation framework that integrates scheduling, routing, and resource assignment with runtime adaptation to probabilistic hardware outcomes on neutral-atom architectures. By connecting circuit synthesis with real-time backend compilation, this cross-layer approach enables optimization across the compilation stack and reduces the overall cost of fault-tolerant quantum computation.

Designing a fault-tolerant architecture usually means a slow loop: propose a code and protocol, hand it off to a simulator, wait, and interpret the numbers. In this live demo, we collapse that loop into an interactive workflow where error-correction protocols can be built, tweaked, and evaluated on the spot. Realistic feedback comes from PPVM, a noise-aware simulator that models actual neutral-atom device behavior rather than idealized circuit semantics, and decoding is handled through an integration with Microsoft's DEQ. We will design an error-correcting protocol from scratch, inject hardware-realistic noise, and watch logical performance respond as we adjust the architecture—turning QEC design into something you can explore in real time.

Neutral atom quantum computing offers unique advantages through mobile qubits and flexible connectivity. However, mapping quantum circuits onto these physical platforms requires addressing complex spatial and timing constraints. This workshop introduces an end to end compilation pipeline tailored for neutral atom architectures. We will discuss how to optimize atom shuttling to fully exploit distinct hardware capabilities, including parallel acousto optic deflector operations and zoned architectures. Additionally, we will discuss potential applications of AI and machine learning to accelerate these optimization tasks, aiming to improve overall compilation efficiency and execution fidelity.