Munich Quantum Toolkit (MQT)

Updated 12 January 2026

MQT is a modular, open-source quantum software ecosystem providing integrated tools for circuit design, compilation, simulation, verification, and benchmarking with hardware awareness.
It employs advanced design automation techniques, including heuristic and exact mapping, machine learning predictions, and reinforcement learning to optimize quantum circuit compilation.
MQT Bench standardizes quantum circuit evaluation across multiple abstraction levels, enabling reproducible benchmarks for diverse algorithms and hardware platforms.

The Munich Quantum Toolkit (MQT) is a modular, open-source quantum software ecosystem developed by the Chair for Design Automation at the Technical University of Munich. It provides an integrated suite of interoperable tools for quantum circuit design, compilation, simulation, mapping, verification, benchmarking, and design automation. MQT explicitly builds upon design automation expertise from the classical domain to address the requirements of scalable, efficient, and hardware-aware quantum computing workflows. The toolkit spans the entire quantum software stack, including support for high-level algorithm formulation, compilation across multiple hardware targets, classical simulation, circuit verification, error correction, and benchmarking (Wille et al., 2024).

1. Architectural Overview and Core Components

MQT is structured into layered modules, each addressing a specific design or automation task. At its foundation, MQT Core delivers an intermediate representation (IR) for quantum circuits, optimized for both classical and quantum-specific operations:

MQT Core: C++ engine providing a gate-based circuit IR, optimized decision diagram (DD) structures, and a ZX-calculus library for circuit rewriting.
Compilation Layer: QMAP module performs qubit mapping and hardware-aware routing, supporting both heuristic and exact (SAT-based) approaches (Wille et al., 2023).
Simulation Layer: DDSIM enables strong and weak simulation, hybrid simulation, and noise-aware or approximate modes.
Verification Layer: QCEC carries out equivalence checking, leveraging DDs and ZX rules for both standard and parameterized circuits.
Benchmarking Layer: MQT Bench provides a uniform, cross-level benchmark suite (MQT Bench), supporting all levels of abstraction and multiple compilation backends (Quetschlich et al., 2022).

All elements are exposed via Python APIs, enabling easy integration with external SDKs such as Qiskit. MQT modules are designed to be chained in configurable workflows, supporting both batch pipelines and interactive programmatic usage (Wille et al., 2024).

2. Benchmarking: MQT Bench

MQT Bench constitutes the benchmarking component of the toolkit, enabling reproducible evaluation of quantum software tools across four abstraction levels:

Algorithmic level: High-level, parameterized circuits with looping constructs.
Target-independent level: Loops unrolled, parameter folding, basic gate simplification.
Target-dependent native-gates: Circuits translated to a device’s native gate set and optimized.
Target-dependent mapped: Qubit mapping applied for real hardware connectivity and final routing.

The benchmark collection spans over 70,000 circuits, from 2 to 130 qubits. It encompasses algorithmic primitives (QFT, GHZ, W, random), canonical algorithms (Grover, Shor, Deutsch–Jozsa, QPE, AE), variational methods (VQE, QAOA, standard ansatzes), and domain-specific applications (TSP, QNNs, financial optimization, chemistry). MQT Bench standardizes key structural and functional metrics, including gate count, circuit depth, percentage of multi-qubit gates, and five feature vector metrics as introduced in SupermarQ (program communication, critical depth, entanglement ratio, liveness, and parallelism). Benchmarks are accessible via a web interface, command-line, or Python API (Quetschlich et al., 2022).

MQT Bench is fully extensible: users can add new algorithms, devices, or native gate sets by script or configuration, which are then automatically integrated into the suite.

3. Compilation, Mapping, and Optimization

Quantum circuit mapping and hardware-aware compilation lie at the core of MQT’s automation stack. The QMAP module addresses the NP-hard qubit mapping and SWAP minimization problem on arbitrary device topologies. It supports two complementary methods:

Exact mapping: Encodes mapping as a MaxSAT instance, solved via the Z3 SMT backend, suitable for up to ~8 qubits and ~1,000 gates.
Heuristic mapping: Applies an A*-search over circuit layers, optimizing the placement and SWAPs required for hardware connectivity. This approach scales to hundreds of qubits and 10⁵+ gates in milliseconds to seconds (Wille et al., 2023).

Device and compiler selection is further automated using machine learning and reinforcement learning:

MQTPredictor employs supervised ML (random forests) to predict optimal combinations of device, technology, compiler, and settings for a given circuit, achieving top-1 accuracy ≈75% and top-3 accuracy ≈95% on large benchmark suites (Quetschlich et al., 2022).
Compiler flow optimization can be formulated as a Markov Decision Process, and solved using RL (PPO), outperforming standard compilers such as Qiskit and TKET in up to 80% of test cases regarding fidelity and critical depth (Quetschlich et al., 2022).

Integration of MLIR-based compilation (Multi-Level Intermediate Representation) supports modular passes, hardware abstraction, and interoperability with external frameworks (e.g., PennyLane, Qiskit) (Hopf et al., 5 Jan 2026, Burgholzer et al., 2 Sep 2025).

4. Extensibility, Heterogeneous Devices, and Advanced Targets

MQT provides pervasive extensibility and support for a broad spectrum of hardware paradigms:

Gate set and architecture abstraction: New native gate sets and device graphs are registered via JSON/YAML configuration and translation routines, picked up automatically by the generator class (Quetschlich et al., 2022).
Neutral atom and ion-trap platforms: Specialized modules for zone-based entangling (NALAC, routing-aware placement), SMT-based state preparation (nasp), and ion-shuttling scheduling integrate physics-level constraints natively into all design automation stages (Stade et al., 2024, Stade et al., 2024, Stade et al., 28 May 2025, Schoenberger et al., 2024).
Mixed-dimensional (qudit) support: MQT Qudits adds a full-stack design and simulation flow for arbitrary qudit systems, including DITQASM language extensions, decision-diagram–based simulation, and compilation to hardware (Mato et al., 2024, Mato et al., 2024).

All modules are cross-compatible; a common circuit IR enables seamless interoperation among qubit, qudit, and neutral-atom abstractions, and supports hybrid algorithms (Wille et al., 2024, Mato et al., 2024).

5. Application Integration: Problem Solving and Automated Workflows

MQT includes high-level modules for directly tackling combinatorial, optimization, and scientific computing problems with quantum and hybrid algorithms:

mqt-problemsolver: Encodes high-level problem classes (QUBO, QAOA-MaxCut, satellite mission planning, SAT, TSP) into parameterized quantum circuits, compiles with device-awareness, and wraps classical-quantum variational loops (VQE, QAOA, W-QAOA) (Quetschlich et al., 2023, Quetschlich et al., 2022).
Pre-compilation for instance families: Predictive encoding and pre-compilation enable near-instant adaptation of generalized, pre-synthesized circuits to new problem instances—delivering orders-of-magnitude speedup while preserving circuit quality (Quetschlich et al., 2023).
Automated solver interfaces: ProblemSolver API exposes a one-call encode–run–decode workflow, hiding circuit and hardware details, and returning solutions in data structures familiar from classical solvers (Quetschlich et al., 2022).

These modules are positioned to serve domain specialists who require quantum acceleration without low-level programming.

6. Simulation, Verification, and Classical Integration

High-performance simulation is built on decision diagrams (DDSIM for qubits, QMDD for qudits), with strong, weak, approximate, and noise-aware modes. DDSIM exploits redundancies characteristic of quantum circuits, enabling strong simulation for structured circuits up to ~30 qubits and scalable sampling for larger instances. Verification is achieved by equivalence checking (QCEC), with ZX-calculus–guided reductions and randomized stimulus generation. These features ensure rigorous validation of compiler outputs and facilitate hardware-independent benchmarking (Wille et al., 2024).

Integration with classical workflows is further enhanced by the Munich Quantum Software Stack (MQSS): a multilayered hybrid platform that connects front-end adapters (Qiskit, PennyLane, CUDA-Q), MLIR-based middle-end compilers, HPC-aware schedulers, and a vendor-agnostic Quantum Device Management Interface (QDMI), designed for both NISQ and fault-tolerant devices (Burgholzer et al., 2 Sep 2025).

7. Impact, Extensibility, and Research Significance

MQT is distinguished by its open-source, modular, and design-automation–oriented approach, providing solutions and APIs for researchers, engineers, and application scientists across all levels of the quantum stack. Its architecture allows for:

Unified benchmarks and metrics, fostering comparability and reproducibility.
Tight integration of automation, synthesis, and verification, drawing on classical EDA principles.
Extensible interfaces for emergent platforms (e.g., zoned architectures, qudits).
Cross-platform and cross-stack compatibility, lowering entry barriers and enabling rapid prototyping and benchmarking.

By standardizing interfaces and fostering community-driven development, MQT has become a reference platform for quantum software engineering, compiler research, and design automation studies (Wille et al., 2024, Burgholzer et al., 2 Sep 2025, Hopf et al., 5 Jan 2026).