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, defining a program, submitting it to hardware, and waiting for results. This 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. Sooner or later, every circuit must translate into something much more concrete: pulses, delays, measurements, and real-time decisions on the hardware. That’s why we built QUA, to address this need. QUA operates at the level where circuits meet hardware, and it goes beyond that, being built for hybrid quantum-classical programs. Quantum programming beyond circuits means programming the experiment itself. 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. 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, including 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. These approaches don’t compete but complement each other.
QUA Enables Hybrid Quantum-Classical, Real-Time Experiment Control
Sub-microsecond latency enables experiments that adapt as they run, thanks to a new approach to quantum programming developed by QM. While circuit-based frameworks like Qiskit and Cirq dominate introductory quantum programming, QUA directly addresses the need for dynamic, precise control over actual quantum hardware, a necessity often obscured by abstract circuit representations. QUA doesn’t merely define a program and await results; it describes “what actually happens on the machine,” executing pulses, updating frequencies, and reacting to signals as the experiment unfolds. Instead of repeated runs hampered by frequency drift and qubit interactions, QUA facilitates adaptation; measurement results are processed and fed back into the control sequence with sub-microsecond latency, enabling experiments that dynamically adjust to changing conditions. As one researcher explains, “You can measure a qubit, process the result immediately, and adjust control parameters on the fly,” highlighting the system’s responsiveness.
This level of interaction is facilitated by tools like Quarc, which orchestrates quantum hardware and classical processors as a single, programmable unit. The system’s architecture extends beyond standalone operation, as QUA integrates with classical accelerators to create a hybrid environment where quantum and classical computation operate in concert. QUA doesn’t preclude higher-level circuit descriptions; through QUAM, a framework that sits above QUA, and integrations with OpenQASM and Qiskit, users can transition between abstraction layers as needed. Another researcher notes, “They can define high-level algorithms when that is convenient, and drop down to precise control when tuning, calibrating, or debugging,” emphasizing the flexibility of the system. This integration is where the future of quantum computing lies: “It is the only way to keep experiments – and progress – under control.”
QM’s Open Acceleration Stack Integrates QUA with Classical Processors
Quantum programming is evolving beyond abstract circuit descriptions toward systems that directly address the realities of physical hardware, and a new approach centers on tight integration between quantum operations and classical processing. While frameworks like Qiskit and Cirq define programs and await results, QUA, Quantum Application Architecture, is designed for hybrid quantum-classical programs that interact with the system during execution. This capability stems from QUA’s operation at the pulse level, describing “what actually happens on the machine” rather than an idealized circuit. The system 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.
This unified approach contrasts with the need to stitch together separate tools, creating a programmable unit where quantum and classical code run together. However, QUA doesn’t abandon higher-level abstraction entirely. QUAM provides a structured representation of the entire system, including qubits and pulses, as reusable Python objects. As one developer emphasizes, “QUA operates at the level where circuits meet hardware,” highlighting the need for tools that scale with system complexity and allow for adaptive, real-time experimentation. As quantum systems become more capable, this integration becomes essential to maintain control over increasingly complex workflows.
Unlike circuit-based frameworks, QUA operates directly at the hardware level, enabling real-time feedback and adaptive experiments.
QUAM and Quarc Facilitate Scalable System Abstraction
Quantum Motion’s approach to quantum programming extends beyond simply defining circuits; it’s about orchestrating the experiment itself, and tools like QUAM and Quarc are central to managing that complexity. While many frameworks initially focus on abstract circuit descriptions, QUA, the core programming language, operates at a level where quantum and classical computation truly converge, allowing for a level of control previously inaccessible to many researchers. This isn’t merely about defining what a quantum computer should do, but detailing how it happens, with pulses, delays, and measurements all directly programmable. This allows researchers to shift between abstraction layers, defining high-level algorithms when appropriate and accessing precise control during tuning or debugging. This flexibility isn’t about competition between approaches, but rather a complementary relationship. QUAlibrate enables more robust processes, including automated retries. Ultimately, QUA forms part of a broader system where control, computation, and abstraction work in concert, a necessity for maintaining progress as quantum systems become more capable and complex.
It is the only way to keep experiments – and progress – under control.
Pulse-Level Programming Offers Expressiveness and Direct Hardware Access
Beyond the familiar circuit-based approaches to quantum programming, a shift toward direct hardware control is gaining momentum, offering a level of expressiveness and adaptability previously unavailable to many researchers. This granular control is particularly crucial given the inherent instability of current quantum systems, where frequency drift and qubit interactions routinely disrupt experiments. Instead of repeating calibrations after each disturbance, QUA enables continuous calibration while the experiment is running, dynamically adjusting parameters to maintain stability. QUAM, Quantum Abstract Machine, further enhances flexibility, allowing researchers to transition between high-level algorithms and precise pulse control as needed. This isn’t about replacing circuit-level programming, but complementing it; QUA provides the tools to define experimental logic explicitly, supporting loops, conditionals, and complex control flow that would be difficult to express using traditional methods. Ultimately, this integration of control, computation, and abstraction is becoming essential as quantum systems grow in complexity and capability, ensuring experiments, and progress, remain manageable.
