Quantum Programming at the Pulse Level: How QUA Enables Real-Time Control
Quantum programming is often introduced through circuit-based frameworks like IBM’s Qiskit and Google’s Cirq. But real quantum hardware requires something more dynamic: real-time control, pulse-level precision, and hybrid quantum-classical execution.
In practice, most users begin with circuits: define a program, submit it to hardware, and wait for results.
It works well when the system is stable, but real quantum hardware doesn’t behave that way, as frequencies drift, qubits interact with each other, and ultimately, calibration shifts. Experiments rarely run the same way twice. And sooner or later, every circuit has to translate into something much more concrete: pulses, delays, measurements, and real-time decisions on the hardware.
That’s why we built QUA – to address just that. QUA operates at the level where circuits meet hardware. But it also goes beyond that, because built for hybrid quantum-classical programs.
Quantum programming beyond circuits: programming the experiment
QUA doesn’t describe an abstract circuit, it describes what actually happens on the machine. A QUA program plays pulses, updates frequencies, measures signals, and reacts to results while the experiment is still running. Instead of submitting a job and waiting, you write logic that interacts with the system in real time.
This changes what’s possible. You can measure a qubit, process the result immediately, and adjust control parameters on the fly. You can run optimization routines as part of the experiment itself. You can continuously track and stabilize system parameters while the hardware runs.
The following demo shows what real-time calibration looks like in practice, running continuously while the experiment is active:
This kind of interaction requires tight integration between quantum operations and classical processing. You can process measurement results in real time and feed it back into the control sequence with sub-microsecond latency, enabling experiments that adapt as they run. That level of interaction doesn’t fit naturally into circuit descriptions. It requires a different model, one where quantum and classical computation operate together.
QUA runs on QM’s pulse processing unit, but it doesn’t operate in isolation. It forms part of a broader system that combines quantum control with classical computation. This is where the open acceleration stack comes in, as QUA integrates with classical accelerators to create a hybrid environment where both parts of the computation run together and coordinate their execution.
With tools like Quarc, users can write programs that span quantum hardware and classical processors, orchestrating both as part of a single workflow. Quarc acts as the layer that connects and manages these different resources, allowing quantum and classical code to run together in a coordinated way. Instead of stitching together separate tools, the system behaves as one programmable unit.
At the same time, QUA doesn’t force users to stay at the lowest level. Many workflows start with circuit descriptions, especially as systems become more complex. QUA supports that. Through QUAM – Quantum Abstract Machine, a framework that sits above QUA – and integrations like OpenQASM and Qiskit, users can work at the circuit level while still retaining access to pulse-level control. QUAM provides a structured representation of the entire system, meaning qubits, pulses, and everything else, as reusable Python objects.
This flexibility matters, as it allows researchers to move between abstraction layers depending on the task. They can define high-level algorithms when that is convenient, and drop down to precise control when tuning, calibrating, or debugging. They can even mix and match abstraction levels in the same program, enabling fine-grained pulse-level control only when needed. The two approaches don’t compete but complement each other.
Pulse-level quantum control: closer to hardware, more expressive
Programming in QUA requires a different mindset compared to writing circuits in Python-based frameworks. Each instruction corresponds directly to a physical operation. When you read a QUA program, you see what the hardware does: which pulse plays, when a measurement happens, how parameters change over time. That closeness makes programs more expressive. It also makes them easier to reason about when something goes wrong.
QUA supports loops, conditionals, and complex control flow, allowing users to implement experimental logic that would be difficult to express in circuit-based tools. Instead of forcing workflows into a predefined structure, it provides the tools to define them explicitly.
Despite operating close to the hardware, QUA does not introduce a steep learning curve. The language is readable, and its structure mirrors the physical processes it controls. This makes it easier to understand what a program is doing without needing to mentally translate between abstraction layers. Documentation plays an important role here. It covers not only the syntax of the language, but also the underlying concepts such as filtering, demodulation, and pulse processing, which are essential for using the system effectively.
Calibration libraries provide working examples that users can run and adapt directly. They serve both as practical tools and as a way to learn best practices. Support also plays a key role. QM teams work closely with labs during system setup, helping them reach a fully calibrated system and understand how to use it effectively. This hands-on engagement often accelerates progress significantly.
Scaling quantum systems: managing complexity with QUA and QUAM
As quantum systems grow, experiments become more complex – calibration routines expand, feedback loops multiply, and workflows become harder to manage. QUA addresses this by structuring how systems are represented and how workflows are executed.
QUAM provides a clear representation of the entire system, including qubits, pulses, and parameters. This allows users to work with structured objects rather than redefining everything from scratch. QUAlibrate organizes calibration workflows into repeatable steps, making them easier to run, debug, and scale. It enables more robust processes, including automated retries or recovery routines when a calibration step fails.
This structure helps keep complexity manageable, even as systems scale. Quantum computing is not moving toward a single abstraction level. It is moving toward integration.
Researchers need to combine circuit-level thinking with pulse-level control. They need to integrate quantum hardware with classical computation. And they need tools that scale with system complexity.
This is where QUA is heading: toward a unified environment that brings together control, computation, and abstraction.
As quantum systems become more capable, that kind of integration becomes essential. It is the only way to keep experiments – and progress – under control. QUA represents a shift toward real-time, pulse-level quantum programming, enabling scalable and adaptive quantum computing workflows.
FAQ
What is QUA in quantum computing?
QUA is a real-time quantum programming language designed for pulse-level control and hybrid quantum-classical execution.
How is QUA different from Qiskit or Cirq?
Unlike circuit-based frameworks, QUA operates directly at the hardware level, enabling real-time feedback and adaptive experiments.
What is pulse-level quantum control?
Pulse-level control refers to directly programming the physical signals that manipulate qubits, rather than abstract quantum gates.
Why is real-time feedback important in quantum computing?
Because quantum hardware is unstable, real-time feedback allows experiments to adapt instantly to drift and noise.
