Challenges
Datasets
Workspaces
Papers
Discussions
Leaderboard
Log inSign up
Challenges
Datasets
Workspaces
Papers
Discussions
Leaderboard
Blog
Job Board
Q3AS

© 2026 Aqora Quantum S.A.S.

TermsPrivacyLegal Notice

arXiv:2408.06469 · IEEE International Conference on Quantum Computing and Engineering (QCE)

Design and Architecture of the IBM Quantum Engine Compiler

Michael B. Healy, Reza Jokar, Soolu Thomas, Vincent Richard Pascuzzi, Kit Barton, Thomas A. Alexander, Roy Elkabetz, Brian C. Donovan, Hiroshi Horii, Marius Hillenbrand

Published Sep 1, 2024• 14 citations
arXivHTMLPDF

Abstract

In this work, we describe the design and architecture of the open-source Quantum Engine Compiler (qe-compiler) currently used in production for IBM Quantum systems. The qe-compiler is built using LLVM's Multi-Level Intermediate Representation (MLIR) framework and includes definitions for several dialects to represent parameterized quantum computation at multiple levels of abstraction. The compiler also provides Python bindings and a diagnostic system. An open-source LALR lexer and parser built using Bison and Flex generates an Abstract Syntax Tree that is translated to a high-level MLIR dialect. An extensible hierarchical target system for modeling the heterogeneous nature of control systems at compilation time is included. Target-based and generic compilation passes are added using a pipeline interface to translate the input down to low-level intermediate representations (including LLVM IR) and can take advantage of LLVM backends and tooling to generate machine executable binaries. The qe-compiler is built to be extensible, maintainable, performant, and scalable to support the future of quantum computing.

DOI
10.1109/qce60285.2024.00106

Related papers

A MLIR Dialect for Quantum Assembly Languages

Alexander McCaskey, Thien Nguyen

We demonstrate the utility of the Multi-Level Intermediate Representation (MLIR) for quantum computing. Specifically, we extend MLIR with a new quantum dialect that enables the expression and compilation of common quantum assembly languages. The true utility of this dialect is in its ability to be lowered to the LLVM intermediate representation (IR) in a manner that is adherent to the quantum intermediate representation (QIR) specification recently proposed by Microsoft. We leverage a qcor-enabled implementation of the QIR quantum runtime API to enable a retargetable (quantum hardware agnostic) compiler workflow mapping quantum languages to hybrid quantum-classical binary executables and object code. We evaluate and demonstrate this novel compiler workflow with quantum programs written in OpenQASM 2.0. We provide concrete examples detailing the generation of MLIR from OpenQASM source files, the lowering process from MLIR to LLVM IR, and ultimately the generation of executable binaries targeting available quantum processors.

arXiv:2101.11365•IEEE International Conference on Quantum Computing and Engineering (QCE)•Oct 1, 2021•58 citations

QLLVM: A Scalable Quantum-Classical Co-Compilation Framework based on LLVM

Yu Zhu, Qiming Du, Yuqiong Jin +5 more

To address the urgent need in the NISQ era for high-performance, scalable quantum compilers and to advance the integration of classical and quantum computing, we present QLLVM, an advanced Quantum-Classical co-compilation framework built on LLVM. To our knowledge, QLLVM delivers an end-to-end, LLVM-based compilation workflow that unifies the build of classical high-performance programs, including CUDA, MPI, and C++, together with quantum programs into a single executable. For quantum program compilation, QLLVM adopts a three-stage design: high-level optimizations are implemented in the MLIR Quantum dialect and then lowered to QIR, an LLVM IR-based representation, for low-level optimization and hardware mapping. Its extensible architecture and seamless interoperability with classical high-performance computing provide an efficient, flexible, industrial-grade compilation infrastructure for future quantum software development. Experimental results show that, on the MQTBench benchmark suite, QLLVM reduces circuit depth and gate counts compared with state-of-the-art compilers and demonstrates clear advantages in compiling hybrid classical-quantum programs.

quant-pharXiv:2604.15094•Apr 17, 2026•3 citations

An Efficient Compilation Architecture for Quantum Experimentation, Calibration and Control Tasks

Lukas Scheller, Cedric Becker, Marvin Fuchs +4 more

Quantum compiler research has largely focused on high-level circuit and gate compilation, while the translation of quantum experiments into low-level control code remains less studied in academia and often confined to vendor-specific toolchains. This “last-mile” compilation stage is critical for calibration, hardware bring-up, and algorithm execution, but may become a major performance and maintainability bottleneck as systems scale. We present a compiler architecture for quantum experiments that decouples frontend experiment languages from backend control hardware through two design choices: (i) a schema-defined abstract syntax tree (AST) represented using Protocol Buffers as a stable, language-agnostic interchange format, and (ii) a compilation pipeline built on the Multi-Level Intermediate Representation (MLIR) framework. Our approach introduces multiple intermediate representations, enabling domain-specific optimizations and systematic lowering from high-level experiment descriptions to binary code, targeting a RISC-V-inspired hardware sequencer. We demonstrate the approach using the QiCode Python-based experiment language and the QiController control platform. Benchmarks on representative calibration workloads show comparable compilation latency and scalability relative to a vendor-API baseline, while synthetic scaling experiments demonstrate sub-second compilation latency for intermediate representation sizes exceeding 1000 qubit control cells, with minimal serialization overhead. These results suggest that combining schema-based AST definitions with MLIR-based multi-stage lowering provides a scalable foundation for portable quantum control compilation pipelines.

IEEE International Conference on Quantum Software (QSW)•Jul 1, 2026•0 citations

The MQT Compiler Collection: A Blueprint for a Future-Proof Quantum-Classical Compilation Framework

Lukas Burgholzer, Daniel Haag, Yannick Stade +3 more

As the capabilities of quantum computing hardware continue to rise, algorithms that exploit them are becoming increasingly complex. These developments increase the need for sophisticated compilation frameworks that translate high-level algorithms into executable code. In the past, most solutions were built with a quantum-first approach and handled mostly pure quantum programs without classical elements such as structured control flow. However, developments in quantum algorithms, error correction, and optimization, as well as the integration into high-performance computing (HPC) environments, depend on such classical elements. As quantum-first approaches increasingly struggle to handle these concepts, classical-first approaches are becoming a promising alternative. In this work, we present the MQT Compiler Collection, a blueprint for a future-proof quantum-classical compilation framework built on the Multi-Level Intermediate Representation (MLIR). After years of experience with the quantum-first approach and its shortcomings, we propose a framework that embraces core MLIR concepts to support the full compilation pipeline from high-level algorithms to hardware-specific instructions. The proposed architecture is designed from the ground up to support complex optimizations beyond, e.g., simple gate cancellation. It is publicly available at https://github.com/munich-quantum-toolkit/core.

quant-pharXiv:2604.08674•Design, Automation, and Test in Europe•Apr 13, 2026•3 citations

Towards a Unified Multi-Target Mlir-Based Compiler: A Heterogeneous Compilation Framework for High-Performance and Quantum Computing Integration

Martín Letras, Jorge Echavarria, Muhammad Nufail Farooqi +5 more

The Munich Quantum Software Stack (MQSS) is a compilation and runtime infrastructure designed to bridge the gap between high-performance computing (HPC) and quantum computing (QC). A unified, extensible, and efficient compilation framework becomes important as quantum devices and applications scale. This paper proposes the integration of Multi-Level Intermediate Representation (MLIR) as intermediate representation into the MQSS to address the challenges of optimizing and compiling hybrid classical-quantum applications across diverse quantum devices. Accordingly, the MQSS can separate abstraction layers, enabling high-level optimizations, seamless integration of existing quantum dialects, and targetspecific optimizations for diverse quantum devices.

IEEE International Conference on Quantum Computing and Engineering (QCE)•Aug 30, 2025•2 citations

Leveraging Years of Classical Compiler Expertise for Quantum Computing

Patrick Hopf, Yannick Stade, Damian Rovara +4 more

Decades of research have gone into classical compiler design, producing sophisticated frameworks that transform high-level programs into efficient machine code. Quantum computing faces the same challenge: translating quantum algorithms into hardware-executable instructions. A classical-first approach extends established compiler frameworks with quantum concepts, treating quantum processors as specialized accelerators within larger computing systems. This article presents multilevel intermediate representation (MLIR) as an effective foundation for this approach and demonstrates its use in the Munich Quantum Software Stack, which connects high-level applications to diverse quantum hardware through a modular, high-performance computing (HPC)-integrated pipeline. MLIR dialects support multiple abstraction levels while providing built-in parsing, transformation, and optimization infrastructure. Quantum programs are represented through complementary dialects: one explicitly encodes the circuit's dataflow graph, while the other mirrors established languages for seamless tool interoperability. The resulting framework, the Munich Quantum Toolkit Compiler Collection, supports compiler passes for both flat circuits and structured control flow. It is available at https://github.com/munich-quantum-toolkit/core.

Computing in Science & Engineering•Jul 1, 2026•0 citations
In this work, we describe the design and architecture of the open-source Quantum Engine Compiler (qe-compiler) currently used in production for IBM Quantum systems. The qe-compiler is built using LLVM's Multi-Level Intermediate Representation (MLIR) framework and includes definitions for several dialects to represent parameterized quantum computation at multiple levels of abstraction. The compiler also provides Python bindings and a diagnostic system. An open-source LALR lexer and parser built using Bison and Flex generates an Abstract Syntax Tree that is translated to a high-level MLIR dialect. An extensible hierarchical target system for modeling the heterogeneous nature of control systems at compilation time is included. Target-based and generic compilation passes are added using a pipeline interface to translate the input down to low-level intermediate representations (including LLVM IR) and can take advantage of LLVM backends and tooling to generate machine executable binaries. The qe-compiler is built to be extensible, maintainable, performant, and scalable to support the future of quantum computing.
We demonstrate the utility of the Multi-Level Intermediate Representation (MLIR) for quantum computing. Specifically, we extend MLIR with a new quantum dialect that enables the expression and compilation of common quantum assembly languages. The true utility of this dialect is in its ability to be lowered to the LLVM intermediate representation (IR) in a manner that is adherent to the quantum intermediate representation (QIR) specification recently proposed by Microsoft. We leverage a qcor-enabled implementation of the QIR quantum runtime API to enable a retargetable (quantum hardware agnostic) compiler workflow mapping quantum languages to hybrid quantum-classical binary executables and object code. We evaluate and demonstrate this novel compiler workflow with quantum programs written in OpenQASM 2.0. We provide concrete examples detailing the generation of MLIR from OpenQASM source files, the lowering process from MLIR to LLVM IR, and ultimately the generation of executable binaries targeting available quantum processors.
To address the urgent need in the NISQ era for high-performance, scalable quantum compilers and to advance the integration of classical and quantum computing, we present QLLVM, an advanced Quantum-Classical co-compilation framework built on LLVM. To our knowledge, QLLVM delivers an end-to-end, LLVM-based compilation workflow that unifies the build of classical high-performance programs, including CUDA, MPI, and C++, together with quantum programs into a single executable. For quantum program compilation, QLLVM adopts a three-stage design: high-level optimizations are implemented in the MLIR Quantum dialect and then lowered to QIR, an LLVM IR-based representation, for low-level optimization and hardware mapping. Its extensible architecture and seamless interoperability with classical high-performance computing provide an efficient, flexible, industrial-grade compilation infrastructure for future quantum software development. Experimental results show that, on the MQTBench benchmark suite, QLLVM reduces circuit depth and gate counts compared with state-of-the-art compilers and demonstrates clear advantages in compiling hybrid classical-quantum programs.
Quantum compiler research has largely focused on high-level circuit and gate compilation, while the translation of quantum experiments into low-level control code remains less studied in academia and often confined to vendor-specific toolchains. This “last-mile” compilation stage is critical for calibration, hardware bring-up, and algorithm execution, but may become a major performance and maintainability bottleneck as systems scale. We present a compiler architecture for quantum experiments that decouples frontend experiment languages from backend control hardware through two design choices: (i) a schema-defined abstract syntax tree (AST) represented using Protocol Buffers as a stable, language-agnostic interchange format, and (ii) a compilation pipeline built on the Multi-Level Intermediate Representation (MLIR) framework. Our approach introduces multiple intermediate representations, enabling domain-specific optimizations and systematic lowering from high-level experiment descriptions to binary code, targeting a RISC-V-inspired hardware sequencer. We demonstrate the approach using the QiCode Python-based experiment language and the QiController control platform. Benchmarks on representative calibration workloads show comparable compilation latency and scalability relative to a vendor-API baseline, while synthetic scaling experiments demonstrate sub-second compilation latency for intermediate representation sizes exceeding 1000 qubit control cells, with minimal serialization overhead. These results suggest that combining schema-based AST definitions with MLIR-based multi-stage lowering provides a scalable foundation for portable quantum control compilation pipelines.
As the capabilities of quantum computing hardware continue to rise, algorithms that exploit them are becoming increasingly complex. These developments increase the need for sophisticated compilation frameworks that translate high-level algorithms into executable code. In the past, most solutions were built with a quantum-first approach and handled mostly pure quantum programs without classical elements such as structured control flow. However, developments in quantum algorithms, error correction, and optimization, as well as the integration into high-performance computing (HPC) environments, depend on such classical elements. As quantum-first approaches increasingly struggle to handle these concepts, classical-first approaches are becoming a promising alternative. In this work, we present the MQT Compiler Collection, a blueprint for a future-proof quantum-classical compilation framework built on the Multi-Level Intermediate Representation (MLIR). After years of experience with the quantum-first approach and its shortcomings, we propose a framework that embraces core MLIR concepts to support the full compilation pipeline from high-level algorithms to hardware-specific instructions. The proposed architecture is designed from the ground up to support complex optimizations beyond, e.g., simple gate cancellation. It is publicly available at https://github.com/munich-quantum-toolkit/core.
The Munich Quantum Software Stack (MQSS) is a compilation and runtime infrastructure designed to bridge the gap between high-performance computing (HPC) and quantum computing (QC). A unified, extensible, and efficient compilation framework becomes important as quantum devices and applications scale. This paper proposes the integration of Multi-Level Intermediate Representation (MLIR) as intermediate representation into the MQSS to address the challenges of optimizing and compiling hybrid classical-quantum applications across diverse quantum devices. Accordingly, the MQSS can separate abstraction layers, enabling high-level optimizations, seamless integration of existing quantum dialects, and targetspecific optimizations for diverse quantum devices.
Decades of research have gone into classical compiler design, producing sophisticated frameworks that transform high-level programs into efficient machine code. Quantum computing faces the same challenge: translating quantum algorithms into hardware-executable instructions. A classical-first approach extends established compiler frameworks with quantum concepts, treating quantum processors as specialized accelerators within larger computing systems. This article presents multilevel intermediate representation (MLIR) as an effective foundation for this approach and demonstrates its use in the Munich Quantum Software Stack, which connects high-level applications to diverse quantum hardware through a modular, high-performance computing (HPC)-integrated pipeline. MLIR dialects support multiple abstraction levels while providing built-in parsing, transformation, and optimization infrastructure. Quantum programs are represented through complementary dialects: one explicitly encodes the circuit's dataflow graph, while the other mirrors established languages for seamless tool interoperability. The resulting framework, the Munich Quantum Toolkit Compiler Collection, supports compiler passes for both flat circuits and structured control flow. It is available at https://github.com/munich-quantum-toolkit/core.