QTurbo: A Robust and Efficient Compiler for Analog Quantum Simulation

Junyu Zhou, Yuhao Liu, Shize Che, Anupam Mitra, Efekan Kökcü, Ermal Rrapaj and 2 others

To study a quantum system on an analog quantum computer you tune the machine's own physics to imitate the system, which means a compiler must turn your target into precise analog control pulses — but the only existing tool solves one giant tangled equation for all the controls at once, so it is painfully slow and often produces long, error-prone pulses; this paper (Penn and Berkeley Lab — Junyu Zhou, Gushu Li, and colleagues) presents QTurbo, which splits that monolith into a fast linear part plus small independent pieces, compiling around 600 times faster with pulses half as long and far more accurate.

The argument in one glance

Problem

Analog quantum simulation needs a compiler to make control pulses

One of the most promising uses of quantum computers is simulating quantum systems themselves — understanding many-body physics, chemical reactions, and new materials by reproducing how a target quantum system evolves in time under its Hamiltonian (the operator that governs its dynamics). There are two ways to do this. The digital approach builds a circuit of quantum gates that approximates the time evolution, but it needs a staggering number of gates — simulating even around 100 qubits can take on the order of ten billion gate operations before error correction. The analog approach instead bypasses gates entirely: it directly tunes the native, continuously-adjustable Hamiltonian of the quantum hardware so the device itself behaves like the target system. This is far more efficient, and real machines do it — QuEra's 256-qubit neutral-atom computer Aquila and Google's superconducting processor have both run analog simulations. But to use an analog device, you must compile: translate a user's target Hamiltonian into the low-level analog control pulses the hardware actually executes. That compilation step — mapping an abstract Hamiltonian onto a specific device's tunable controls and pulse schedules — is where analog simulation gets stuck, because the tooling for it is immature.
What people did

Solve one global equation for all the controls at once (SimuQ)

The only publicly available compiler framework for analog simulation is SimuQ. It maps a target quantum system onto a simulator's instruction set by formulating a single global equation system that relates all the device's tunable controls to the target Hamiltonian, and solving it to produce the pulse schedules. This is a unified, solver-based pipeline: write down one big system of equations capturing every control variable simultaneously, hand it to a solver, and read out the analog pulses. It is elegant in principle — one formulation, one solve, from Hamiltonian to hardware controls.
Why it fell short

One giant mixed equation is slow, non-deterministic, and fragile

Solving everything at once is exactly what makes SimuQ struggle. The single global system mixes continuous variables (pulse amplitudes and durations) with binary ones (which instructions are active), so it is a large-scale mixed continuous-and-binary optimization problem with an exponentially large search space — and solving all variables simultaneously makes compilation extremely slow, especially as the system grows. Worse, the results are unreliable: the length of the compiled pulse sequence is not deterministic, it is usually far from optimal, and it can vary unpredictably depending on the solver's conditions. In some cases SimuQ simply fails to find a solution at all. And pulse length is not a cosmetic concern — longer pulse sequences spend more time on noisy hardware, accumulating more decoherence and error, so a bloated, unpredictable pulse schedule directly degrades the accuracy of the simulation on a real device. So the state of the art was a compiler that is slow, brittle, and produces pulses that are longer and noisier than they need to be. What was missing was a compilation approach that exploits the structure hidden inside that monolithic equation system, so it can solve faster and produce short, precise, noise-resilient pulses reliably.
This paper's idea

Break the monolith into a fast linear part plus small local pieces

QTurbo's key observation is that the seemingly monolithic global equation system is not actually monolithic — it has a hierarchical structure that can be exploited. Instead of solving for all the Hamiltonian controls at once, QTurbo decomposes the compilation into stages with intermediate variables, and it recognizes that the tunable terms on an analog simulator are not all dependent on each other, so the one huge equation system can be split into many smaller, independent local systems that are far easier to solve. Concretely, QTurbo restructures the problem into a global linear equation system plus several localized mixed systems, which dramatically reduces the computational complexity of solving compared with one large mixed problem. It then solves those smaller local mixed systems, and finally refines the resulting pulses for accuracy. This three-stage pipeline — compile faster, make the execution shorter, make the result more accurate — replaces SimuQ's single global solve. The payoff is large: compared with SimuQ, QTurbo compiles about 600 times faster (up to 1600 times) and scales to larger systems, produces pulses that are 51 percent shorter on average (up to 90 percent), and improves compilation accuracy by 72 percent on average (up to 100 percent). On QuEra's Aquila hardware, the shorter, more precise pulses cut measurement error by 51 percent on average and up to 94 percent.

Why this problem is worth solving

Analog simulation is one of the nearest-term ways quantum hardware can do something useful, and a good compiler is what stands between a target problem and a reliable run on the machine.

Simulating quantum systems is the application where quantum computers have the clearest advantage, and analog simulation is an especially practical route to it because it sidesteps the enormous gate counts that digital simulation demands — ten billion gates just for a medium system is out of reach on today’s noisy hardware, whereas an analog device can imitate a Hamiltonian directly and efficiently. Real machines like QuEra’s Aquila are already running analog simulations of physics and optimization problems. But none of that is usable without compilation: a scientist thinks in terms of a target Hamiltonian, while the hardware executes only low-level analog pulses, and something has to bridge the two automatically and correctly. If that bridge is slow, every experiment waits on a long compile; if it is unreliable, the pulses it produces are longer than necessary and the extra time on noisy hardware corrupts the answer. So the compiler is not a convenience — it directly determines whether analog simulation is fast enough to iterate on and accurate enough to trust. Improving it by orders of magnitude in speed, while producing shorter and more precise pulses, therefore widens what analog quantum simulation can actually deliver on real devices, which is why the reported error reductions on Aquila matter as much as the compile-time speedups.

The core realization is that a problem posed as one monolithic solve is often secretly decomposable, and decomposing it changes the complexity class of the work.

SimuQ’s difficulty comes from treating pulse design as one indivisible optimization: every control variable, continuous and binary, entangled in a single global system handed to a solver. That framing is faithful but computationally brutal, because a mixed continuous-and-binary problem has a search space that explodes with the number of variables, and solving it all together means the whole thing is as hard as its hardest coupling. QTurbo’s insight is that this monolith has exploitable structure in two senses. First, it is hierarchical: rather than solving directly for the final controls, you can introduce intermediate variables and separate the problem into stages, and in particular you can peel off a global linear part — which is cheap to solve — from the harder mixed part. Second, the remaining hard part is not globally coupled: many of the device’s tunable terms are independent of one another, so the residual mixed problem breaks into many small local systems that can be solved separately instead of all at once. Both moves attack the exponential blowup, because the cost of solving several small independent problems is vastly less than one big coupled one. This is why QTurbo is not just a faster implementation but a fundamentally cheaper formulation — and because the smaller, staged problems are better-behaved, the pulses it finds are also shorter and more reliable, which is what turns compile-time speed into real-device accuracy.

What people did before, and where it broke

Digital simulation with gates. Approximate the Hamiltonian’s time evolution with a quantum circuit (for example via Trotter decomposition). Where it broke. It needs astronomically many gates — on the order of ten billion for a medium system — far beyond noisy hardware.
Analog simulation, compiled by SimuQ. Formulate one global equation system over all controls and solve it for pulse schedules. Where it broke. The single mixed continuous-and-binary system has an exponential search space, so compilation is very slow and scales poorly.
Trust the solver’s pulse output. Take whatever pulse sequence the global solve produces. Where it broke. Pulse length is non-deterministic and far from optimal, varies with solver conditions, and sometimes no solution is found at all.
Accept longer pulses. Run the simulation with the compiled schedule regardless of its length. Where it broke. Longer pulses spend more time on noisy hardware, accumulating decoherence and degrading the simulation’s accuracy.
The gap. No compiler exploited the hidden structure of the equation system to solve fast and reliably while producing short, precise, noise-resilient pulses — leaving analog simulation bottlenecked at the compile step and noisier than necessary on real devices.

How QTurbo works

From one global solve to a staged, decomposed pipeline

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

The idea

Exploit the structure of the compilation problem instead of brute-forcing it. QTurbo’s foundation is that compiling a Hamiltonian onto analog controls has exploitable structure — a hierarchy and independent terms — rather than being one indivisible solve. Recognizing that a quantum-simulation compilation problem has algebraic structure that can be decomposed and optimized in pieces, instead of treating the whole program as an opaque monolith, is the same principle the work on a generalized block-wise compiler optimization framework for Hamiltonian simulation (Paulihedral) covered elsewhere on this site is built on, using the problem’s structure to compile far more efficiently. QTurbo applies this to the analog pulse-design equation system, turning one global solve into a staged, decomposed one.

Make the compiler fast and scalable by solving smaller, independent problems. Rather than one exponentially large mixed optimization, QTurbo separates a cheap global linear system from many small local mixed systems that can be solved independently, so compile time drops by orders of magnitude and scales to larger devices. Restructuring a quantum compiler so that expensive optimization is broken into tractable, well-scoped subproblems, trading a monolithic slow solve for fast staged ones, is the same engineering the work on optimizing quantum circuits fast and slow (fast and slow compilation) covered elsewhere on this site pursues, balancing thoroughness against speed to compile at scale. QTurbo’s decomposition is what delivers its roughly 600-times compilation speedup.

Produce short, noise-resilient pulses so the answer survives real hardware. QTurbo does not just compile faster; it generates shorter, more precise pulse schedules, and on noisy hardware shorter pulses mean less accumulated decoherence and lower error. Shaping the low-level pulse and schedule to minimize the noise a quantum program accumulates on real hardware is the same concern the work on suppressing ZZ crosstalk through pulse and scheduling optimization (ZZ crosstalk suppression) covered elsewhere on this site addresses, treating pulse-level control as a lever for reliability. QTurbo’s shorter, refined pulses are what translate its compile-time gains into a reported 51-percent-average measurement-error reduction on QuEra’s Aquila.

Following a Hamiltonian through QTurbo

Compiling a target Hamiltonian onto an analog simulator

A trace, drawn from the paper, of how QTurbo produces pulse schedules by decomposition.

Step 1 of 5

Start from a target Hamiltonian and a device

A user specifies the target quantum system as a Hamiltonian expression, and QTurbo takes the analog simulator's tunable controls (its instruction set) as the thing to map onto — the same inputs SimuQ would take.

The goal is a pulse schedule that makes the device imitate the target.

Why it works

Decomposing beats one monolithic mixed solve. Solving all continuous and binary controls together has an exponential search space → but staging the problem with intermediate variables → so the work is broken into far cheaper pieces.
A linear part can be split off and solved cheaply. The global mixed system is hard as a whole → but peeling off a global linear equation system → so a large fraction of the problem is solved with low-cost linear methods.
Independent terms become independent small problems. Coupling everything makes the solve as hard as its worst link → but many tunable terms are not mutually dependent → so the residual mixed part factors into small local systems solved separately.
Faster, better-behaved solves give shorter pulses. SimuQ’s pulse lengths are non-deterministic and bloated → but staged, well-scoped subproblems plus refinement → so QTurbo’s pulses are about half as long and far more reliable.
Shorter pulses mean less noise on real hardware. Long pulse sequences accumulate decoherence → but cutting pulse length substantially → so measurement error on QuEra’s Aquila drops by up to 94 percent.

What it costs (trade-offs and scope)

The decomposition must be valid for the device’s structure. QTurbo’s speed comes from splitting the equation system into a linear part and independent local systems; this relies on the analog simulator’s tunable terms actually having that hierarchical, partly-independent structure.
It is a staged pipeline, not a single solve. Replacing one global optimization with global-linear, local-mixed, and refinement stages is more machinery than SimuQ’s single formulation, and each stage is part of the design that must be gotten right.
It targets analog Hamiltonian simulation specifically. QTurbo compiles target Hamiltonians onto analog simulators; it is not a general digital circuit compiler, and its advantages are tied to the analog pulse-design setting.
Accuracy still depends on the hardware and refinement. Shorter, refined pulses reduce error, but the ultimate fidelity is bounded by the analog device’s own noise; QTurbo reduces error rather than eliminating it.
Reported figures are against SimuQ on specific systems. The roughly 600-times compile speedup, 51-percent shorter pulses, and up-to-94-percent error reduction are measured versus SimuQ on particular benchmarks and QuEra’s Aquila; results depend on the target system, device, and baseline.

The comparison

Compiling a target Hamiltonian onto an analog quantum simulator

Property	Digital (gate circuit)	SimuQ (global solve)	QTurbo
Approach
Cost / scalability
Pulse length
Reliability
Error on real device

A comparison of ways to run a Hamiltonian simulation. Digital circuits need astronomically many gates; the SimuQ analog compiler solves one global mixed equation, which is slow, fragile, and yields long noisy pulses. QTurbo decomposes that equation into a cheap global linear system plus small independent local systems and refines the result, compiling about 600 times faster with pulses 51 percent shorter and far more accurate, cutting measurement error on QuEra's Aquila by up to 94 percent. Exact figures should be read from the paper.Underlined values explain themselves when clicked.

Where this stops working

What to keep in mind

This explainer is based on the paper’s full text (the authors’ arXiv copy, 2506.22958, of the ASPLOS 2026 paper). The described system is the paper’s: QTurbo is a compiler for analog quantum simulation that maps a target Hamiltonian onto an analog simulator’s tunable controls and pulse schedules. Its baseline and point of comparison is SimuQ, which formulates and solves a single global mixed continuous-and-binary equation system over all controls at once — leading to an exponential search space, long and non-deterministic compilation, pulse sequences far from optimal, and occasional failure to solve. QTurbo’s key observation is that this global system has hierarchical structure and that the device’s tunable terms are not all mutually dependent, so it decomposes the compilation into a global linear equation system plus several localized mixed systems (solved separately), followed by a pulse-refinement stage. The paper reports, versus SimuQ, roughly 600 times (up to 1600 times) faster compilation, pulses 51 percent shorter (up to 90 percent), 72 percent (up to 100 percent) better compilation accuracy, and, on QuEra’s Aquila neutral-atom analog quantum computer, an average measurement-error reduction of 51 percent (up to 94 percent). The background above on Hamiltonian simulation, digital versus analog approaches, pulse schedules, and mixed continuous-and-binary optimization is standard context provided to make the approach intuitive. The step-by-step walkthrough is an illustration of the described mechanism. Exact formulations of the equation systems, the decomposition and refinement algorithms, and the full evaluation should be read from the paper.

Background

Why usable quantum hardware depends on the compiler that reaches the pulses

It helps to see QTurbo within a broad truth about quantum computing: the gap between what a scientist wants to run and what the hardware can execute is bridged entirely by compilation, and on noisy machines that bridge largely determines whether an experiment succeeds. A quantum device does not natively understand Hamiltonians or high-level algorithms; it understands low-level controls — gates, and beneath them, analog pulses. Getting from the abstract specification down to those controls, efficiently and in a way that minimizes the noise the program accumulates, is one of the central problems of practical quantum computing, and it recurs at every layer: mapping algorithms to circuits, circuits to gates, and gates or Hamiltonians to pulses. The recurring lesson is that naive, monolithic compilation both scales badly and produces control sequences that are longer and noisier than necessary, and that exploiting the problem’s structure is what makes compilation both fast and reliable. QTurbo is a clean instance for analog simulation, decomposing a tangled global pulse-design problem into tractable pieces. The broader effort it belongs to — building compilers that turn a target into efficient, low-noise controls for a particular quantum architecture — is the same terrain the work on optimizing compilation for neutral-atom quantum computers (PowerMove) covered elsewhere on this site occupies, tailoring compilation to the hardware QTurbo also targets. QTurbo’s particular contribution is to show that decomposing the analog pulse-design equation system yields orders-of-magnitude faster compiles and shorter, more accurate pulses that measurably reduce error on real neutral-atom hardware.

If you remember only three things

1. Analog quantum simulation studies a quantum system by tuning a device's own native Hamiltonian to imitate the target, bypassing quantum gates — far more efficient than the digital approach, which can need on the order of ten billion gates even for a medium system. Real machines like QuEra's 256-qubit neutral-atom Aquila run analog simulations. But using an analog device requires compilation: translating a target Hamiltonian into the low-level analog control pulses the hardware executes. The only public compiler, SimuQ, formulates one global equation system over all the device's controls — mixing continuous variables (pulse amplitudes, durations) with binary ones (which instructions are active) — and solves it all at once. This gives an exponentially large search space and very slow compilation, and the resulting pulse sequences are non-deterministic, far from optimal, sometimes unsolvable, and longer than necessary — and longer pulses accumulate more noise on real hardware.
2. QTurbo's key observation is that the seemingly monolithic global equation system is not truly monolithic: it has hierarchical structure, and the device's tunable terms are not all dependent on one another. So instead of solving for all controls at once, QTurbo decomposes the compilation — peeling off a global linear equation system (cheap to solve) from the harder mixed part, then splitting that residual into several small independent local mixed systems solved separately, and finally refining the pulses for accuracy. This staged "compile faster, execution shorter, more accurate" pipeline attacks the exponential blowup, because solving many small independent problems is vastly cheaper than one giant coupled optimization, and the better-behaved subproblems also yield shorter, more reliable pulses.
3. Compared with SimuQ, QTurbo compiles about 600 times faster (up to 1600 times) and scales to larger systems, produces pulses 51 percent shorter on average (up to 90 percent), and improves compilation accuracy by 72 percent (up to 100 percent). Crucially, the shorter, more precise pulses reduce noise on real hardware: on QuEra's Aquila, QTurbo cuts measurement error by 51 percent on average and up to 94 percent. The trade-offs and scope: the decomposition relies on the analog device's tunable terms actually having that partly-independent structure, it is a multi-stage pipeline rather than a single solve, it targets analog Hamiltonian simulation specifically, and it reduces rather than eliminates error, which is ultimately bounded by the hardware. This explainer is based on the paper's full text.

Check yourself

Check your understanding

1. What is analog quantum simulation, and why does it need a compiler?
2. Why does the prior compiler SimuQ struggle?
3. What is QTurbo's key idea for compiling faster and better?
4. What does QTurbo achieve, and what are the limits of the approach?

Sources

The paper is “QTurbo: A Robust and Efficient Compiler for Analog Quantum Simulation” by Junyu Zhou, Yuhao Liu, Shize Che, Anupam Mitra, Efekan Kokcu, Ermal Rrapaj, Costin Iancu, and Gushu Li (University of Pennsylvania and Lawrence Berkeley National Laboratory), published at ASPLOS 2026, DOI 10.1145/3760250.3762227. It is available on arXiv as 2506.22958.

This explainer is written from the paper’s full text (the authors’ arXiv copy). QTurbo is an analog quantum simulation compiler that maps a target Hamiltonian onto a simulator’s pulse schedules. Its baseline, SimuQ, solves one global mixed continuous-and-binary equation system over all controls, which is slow, non-deterministic, and fragile. QTurbo observes that this system has hierarchical structure and partly-independent terms, so it decomposes compilation into a global linear system plus small local mixed systems solved separately, followed by pulse refinement. The paper reports roughly 600 times (up to 1600 times) faster compilation, pulses 51 percent shorter (up to 90 percent), 72 percent better compilation accuracy, and an average measurement-error reduction of 51 percent (up to 94 percent) on QuEra’s Aquila. Background on analog quantum simulation, Hamiltonians, and pulse schedules is standard context. The numbers are the paper’s own; exact mechanisms and full results should be confirmed in the paper.