⚛️ quantum physics

QASMTrans: An End-to-End QASM Compilation Framework with Pulse Generation for Near-Term Quantum Devices

QASMTrans is a lightweight, self-contained C++ quantum compiler that achieves over 100x faster transpilation than Qiskit while offering end-to-end pulse-level control, noise-adaptive optimization, and device partitioning to enable real-time, high-fidelity execution on near-term quantum devices.

Original authors: Aaron Hoyt, Meng Wang, Fei Hua, Chunshu Wu, Chenxu Liu, Muqing Zheng, Samuel Stein, Drew Rebar, Yufei Ding, Travis S. Humble, Ang Li

Published 2026-02-06

📖 5 min read🧠 Deep dive

CC BY 4.0

Original authors: Aaron Hoyt, Meng Wang, Fei Hua, Chunshu Wu, Chenxu Liu, Muqing Zheng, Samuel Stein, Drew Rebar, Yufei Ding, Travis S. Humble, Ang Li

Original paper licensed under CC BY 4.0 (http://creativecommons.org/licenses/by/4.0/). ✨ This is an AI-generated explanation of the paper below. It is not written or endorsed by the authors. For technical accuracy, refer to the original paper. Read full disclaimer

Imagine you have a brilliant, complex recipe for a gourmet dish (a quantum algorithm). However, the kitchen you want to cook in (the quantum computer) is very strange. It only has specific, limited tools, the counters are arranged in a weird shape, and the ingredients spoil very quickly. If you try to cook your recipe exactly as written, it will fail or taste terrible.

QASMTrans is like a super-fast, ultra-smart sous-chef that instantly rewrites your recipe to fit that specific, quirky kitchen. It doesn't just translate the words; it optimizes the cooking process so the dish is ready before the ingredients go bad, and it even sends direct instructions to the stove and oven to control the heat with perfect precision.

Here is a breakdown of what this paper claims, using simple analogies:

1. The Speed Problem: The "Express Lane" Chef

Most existing tools for translating quantum recipes (like Qiskit) are like a slow, meticulous chef who reads the whole book, thinks about every step, and takes hours to rewrite a recipe. This is too slow for modern quantum computers, which need instructions right now (Just-in-Time).

The Claim: QASMTrans is written in a very efficient language (C++) that acts like a high-speed express lane. In tests, it rewrote complex recipes 100 times faster than the standard tools, sometimes doing in seconds what took others minutes or hours.
The Analogy: If Qiskit is a librarian who walks every aisle to find a book, QASMTrans is a drone that zips straight to the shelf and grabs it instantly.

2. The "Direct-to-Stove" Connection (Pulse Generation)

Usually, a translator gives you a list of ingredients and steps (gates), and you have to figure out how to actually turn the knobs on the stove. But quantum computers are so sensitive that you need to control the exact voltage and timing of the "heat" (pulses) to get a good result.

The Claim: QASMTrans doesn't just stop at the recipe list. It goes all the way down to the "pulse level." It generates the exact electrical signals needed to control the quantum hardware directly. It connects straight to a control system called QICK (which is like a smart, programmable remote control for the quantum computer).
The Analogy: Instead of just telling a human chef "turn the heat to medium," QASMTrans sends a digital signal directly to the stove's thermostat to set the temperature to exactly 350.2°F for exactly 4.5 seconds. This allows for "closed-loop" cooking, where the system can adjust the heat in real-time based on how the food is reacting.

3. The "Custom Tool" Strategy (Application-Tailored Gates)

Imagine you have to chop onions, carrots, and potatoes. The standard way is to use a generic knife for everything. But what if you had a special "onion-chopping machine" that was pre-calibrated to chop onions perfectly in half the time?

The Claim: QASMTrans looks at the recipe and identifies the most critical, time-consuming steps (the "critical path"). It then designs a custom, pre-calibrated "pulse" (a special tool) specifically for those frequent steps.
The Result: By using these custom tools for the hardest parts of the recipe, the paper claims they reduced the time the quantum computer had to stay "active" (latency) by up to 31% and improved the quality of the final result (fidelity) by up to 12%.

4. The "Smart Seating Chart" (Noise-Adaptive Mapping)

Quantum computers have "noisy" parts (qubits that make mistakes easily) and "quiet" parts. If you put a difficult part of the recipe on a noisy counter, it will fail.

The Claim: QASMTrans looks at a map of the quantum computer's "health" (calibration data). It then figures out the best way to seat the ingredients (qubits) so that the most important parts of the recipe sit on the "quietest," most reliable counters.
The Analogy: It's like a wedding planner who knows which guests talk too loudly. They strategically seat the quiet, important guests away from the noisy ones to ensure the conversation goes smoothly.

5. The "Shared Kitchen" (Space Sharing)

Usually, a quantum computer runs one recipe at a time, leaving the rest of the kitchen empty.

The Claim: QASMTrans can split the quantum computer into smaller, isolated zones. This allows multiple different recipes (or different parts of the same experiment) to run at the same time on the same machine without interfering with each other.
The Analogy: Instead of one family using the whole kitchen for one big dinner, QASMTrans puts up temporary walls so three different families can cook their own meals in the same kitchen simultaneously without bumping into each other.

6. Portability: The "Universal Adapter"

Many quantum tools only work on specific computers (like IBM's) or require heavy software that is hard to install on different machines.

The Claim: QASMTrans is "self-contained." It doesn't rely on a bunch of other heavy software libraries. It works on everything from massive supercomputers to small, portable devices (like the chips inside a quantum computer's control box).
The Analogy: It's a universal power adapter that fits into any wall socket, from a giant server room to a tiny laptop, without needing extra extension cords or heavy batteries.

Summary

The paper presents QASMTrans as a lightweight, lightning-fast translator that bridges the gap between a theoretical quantum idea and the physical reality of a quantum machine. It claims to be significantly faster than current tools, capable of controlling the hardware directly with high precision, and smart enough to optimize the recipe based on the specific health and layout of the machine it's running on.

Technical Summary: QASMTrans

Problem Statement

The current landscape of quantum compilation faces significant bottlenecks in speed, flexibility, and hardware integration, particularly for Noisy Intermediate-Scale Quantum (NISQ) devices. Existing commercial transpilers, such as those embedded in Qiskit and Cirq, offer comprehensive functionality but suffer from slow compilation times, especially for deep circuits common in chemistry, optimization, and nuclear physics applications. This latency limits the exploration of larger design spaces and hinders the integration of advanced, computationally expensive optimizations. Furthermore, many academic research efforts focus on isolated transpilation techniques (e.g., gate decomposition or routing) that lack end-to-end demonstrations and are often constrained by the limitations of the underlying Python-based frameworks they inhabit.

A critical gap exists in pulse-level control. While emerging quantum testbeds require fine-grained pulse optimization for adaptive algorithms (e.g., ADAPT-VQE, ADAPT-QAOA), existing tools offer limited support for direct integration with embedded systems. Qiskit restricts pulse operations to IBM hardware, and XACC supports pulse compilation only to its internal simulator. Consequently, there is a lack of a lightweight, self-contained framework capable of bridging abstract quantum algorithms directly to device-level control with just-in-time (JIT) deployment capabilities on QPU testbeds.

Methodology

QASMTrans addresses these challenges through a lightweight, high-performance, C++-based quantum compiler framework designed for end-to-end compilation from OpenQASM to device-level pulse schedules. The framework is self-contained with no external library dependencies (utilizing header-only libraries like Lexertk and JSON), facilitating deployment across diverse hardware from ARM-based embedded devices to leadership-class HPC systems.

The methodology is structured around four primary components:

Input/Output (IO) Module:
- Parsing: Utilizes a high-performance C++ parser (Lexertk) to tokenize OpenQASM 2.0 files, translating them into an internal Gate Intermediate Representation (IR). This IR encapsulates gate names, target qubits, parameters, and matrix representations.
- Hardware Configuration: Extracts backend device details (coupling graphs, basis gates) from JSON files.
- Output: Exports transpiled circuits in QASM, QIR, or Quil formats.
Configuration Module:
- Graph Generation: Constructs a Directed Acyclic Graph (DAG) to represent gate dependencies and a Coupling Graph based on the target hardware topology.
- Decomposition: Systematically breaks down 3-qubit gates (e.g., CCX) into 1-qubit and 2-qubit gates prior to routing.
- Optimization Strategies: Implements "Simulation-Oriented Optimization," including constrained qubit routing (limiting the search space to relevant subgraphs for classical simulation) and user-guided qubit prioritization to minimize communication overhead in distributed simulations.
Transpilation Core:
- Routing and Mapping: Employs the Sabre algorithm as a baseline but introduces optimizations to reduce traversal costs. Instead of traversing the entire DAG after every gate, it maintains a front layer, updating only executed nodes and newly available gates, reducing complexity from $O(G)$ to $O(n)$ (where $n$ is the number of qubits).
- SWAP Pruning: Introduces a method to constrain the physical qubit area when selecting SWAP candidates, reducing the search space for large machines.
- Basis Gate Decomposition: Translates general gates into the specific basis gate set of the target device (e.g., IBMQ, Rigetti, IonQ, Quantinuum) after routing.
Pulse Compilation and Adaptive Strategies:
- QICK Integration: Directly interfaces with the Quantum Instrumentation Control Kit (QICK) for FPGA-based control, enabling low-latency, real-time pulse emission.
- Application-tailored Gate Set (AGS): Identifies high-impact gate sequences along the circuit's critical path. It synthesizes optimized pulse schedules for these specific sequences using pre-defined robust ansatz (e.g., AshN for two-qubit gates), reducing calibration overhead and circuit latency.
- Noise-Adaptive Transpilation: Uses device calibration data (T1, T2, error rates) to perform subgraph isomorphism (via VF2++) for circuit placement. It prioritizes mappings that minimize the average error along the critical path rather than the entire circuit.
- Space Sharing: Implements a partitioning algorithm that divides the hardware coupling graph into isolated subchips, allowing concurrent execution of multiple circuits or shots on a single QPU.

Key Contributions

End-to-End C++ Framework: The authors propose a self-contained, open-source quantum compiler that significantly reduces transpilation time for a wide range of applications, improving efficiency on NISQ devices.
Pulse-Level Integration: QASMTrans is equipped to generate specific basis gates and calibrated pulse schedules for different target machines, integrating directly with QICK for embedded control.
Performance and Portability: Through comprehensive experiments, the framework demonstrates the ability to transpile circuits with comparable fidelity to Qiskit on real devices (Rigetti, IBMQ, IonQ, Quantinuum) but at a significantly faster speed. It is validated across diverse platforms, including ARM-based embedded devices and HPC systems.
Novel Optimization Techniques:
- AGS: A latency-aware approach to synthesize custom pulse sequences for frequent pre-transpiled gates, reducing execution latency.
- Critical Path Heuristics: A noise-adaptive placement strategy that focuses optimization on the circuit's critical path to reduce transpilation time while maintaining fidelity.
- Space Sharing: A mechanism for concurrent circuit execution via calibration-aware device partitioning.

Results

The paper validates QASMTrans through extensive benchmarks and real-device execution:

Compilation Speed: QASMTrans achieves more than 100× faster compilation than Qiskit in some circuits with similar quality. In specific benchmarks (e.g., bwt_n21 with 87K gates), it demonstrated a 4× speedup over Qiskit O3 with comparable circuit depth. Overall speedups reached up to 171×.
Circuit Quality: The transpiled circuits exhibit comparable depth, gate counts, and 2-qubit gate counts to Qiskit.
Fidelity: Validation on four real NISQ devices (IBM-Brisbane, Rigetti-AspenM2, IonQ-Aria1, Quantinuum-H1-1) shows less than 1% fidelity deviation from Qiskit results.
Pulse-Level Optimization: Integrated QuTiP pulse-level simulation on a 9-qubit Rigetti model showed that the AGS scheme could reduce execution latency by up to 31.7% and improve final-state fidelity by up to 12% in tested circuits.
Portability: Compilation times on various platforms (from Apple M2 to Frontier HPC) were consistently under 100 seconds, with most completing in under 1 second.

Significance

The paper positions QASMTrans as a foundational infrastructure for the quantum software stack, specifically targeting the needs of near-term devices and adaptive algorithms. Its significance lies in:

Bridging the Gap: It closes the gap between logical circuits and hardware control by enabling end-to-end compilation from QASM to calibrated pulses, a capability previously limited or non-existent in open-source frameworks.
Enabling Real-Time Adaptation: By achieving fast transpilation times (seconds for large circuits), it enables the deployment of real-time adaptive algorithms like ADAPT-VQE and ADAPT-QAOA, which require dynamic circuit generation and JIT compilation.
Hardware Agnosticism and Portability: The C++ implementation and lack of external dependencies allow it to run on embedded systems (e.g., FPGAs via QICK) as well as supercomputers, making it suitable for both testbed operators and large-scale simulation environments.
Optimization Efficiency: By focusing on the critical path for noise-adaptive placement and pulse synthesis, it offers a practical approach to error mitigation without the prohibitive computational cost of global optimization.

The authors conclude that QASMTrans serves as both a baseline for implementing advanced transpilation technologies and a practical tool for testbed operators, facilitating the efficient execution of complex quantum algorithms on NISQ devices.