MQSS: Munich Quantum Software Stack

• MQSS is a modular, open-source ecosystem enabling hybrid quantum-classical computation through a multi-layered architecture.
• It integrates front-end adapters, an MLIR-based compiler, and a vendor-agnostic quantum device interface for flexible hardware abstraction.
• Its design supports extensive benchmarking, resource scheduling, and community-driven development to advance fault-tolerant quantum computing.

The Munich Quantum Software Stack (MQSS) is a modular, community-driven, open-source ecosystem designed to enable hybrid quantum-classical computation by bridging diverse quantum hardware platforms with advanced software, compiler, and resource management infrastructure. MQSS supports flexible integration of user applications, front-end programming frameworks, high-performance scheduling, dynamic compilation, and unified hardware access, with a multilayered architecture that anticipates next-generation, fault-tolerant quantum computing.

1. Layered Architecture and Design

MQSS is architected as a multi-layer stack, conceptually organized into Front-End, Middle-End, and Back-End layers (Burgholzer et al., 2 Sep 2025):

• Front-End Layer: Exposes programming interfaces and adapters to frameworks such as Qiskit, PennyLane, and the Quantum Programming Interface (QPI) for HPC. These adapters enable users to interact with MQSS in familiar paradigms, abstracting away hardware details and stack-specific complexity.
• Middle-End Layer: Embeds quantum workflows within classical HPC scheduling environments. This layer contains an MLIR-based compiler infrastructure, scheduling and resource management engines, and pass managers (including AI-assisted selection modules and telemetry-informed routines via FoMaCs).
• Back-End Layer: Provides unified, vendor-agnostic access to heterogeneous quantum hardware through the Quantum Device Management Interface (QDMI), standardizing job submission, session management, telemetry queries, and hardware abstraction.

The stack is defined mathematically by the function

$$\text{MQSS} = f\Bigl(\text{Front-End}, \text{Middle-End (Compiler+Scheduler)}, \text{Back-End (QDMI)}\Bigr).$$

This separation allows each layer to evolve independently, supporting extensibility and rapid adaptation to new quantum paradigms and hardware technologies.

2. Core Components and Functionalities

Several specialized components underpin MQSS functionality (Burgholzer et al., 2 Sep 2025):

• Front-End Adapters: Interface with diverse SDKs and programming models, decoupling high-level algorithm design from hardware-specific execution. They ensure interoperability across frameworks and act as glue-code between user applications and MQSS core.
• HPC-Integrated Scheduler and Resource Manager: Coordinates allocation of quantum and classical resources, harmonizing quantum job execution within batch scheduling environments (e.g., Slurm). Real-time device health and performance metrics are fed into the scheduling process for adaptive resource optimization.
• MLIR-Based Compiler Infrastructure: Utilizes a Multi-Level Intermediate Representation and modular passes for both device-agnostic optimization and hardware-specific lowering. Supports dialects for quantum and classical computation and can target evolving standards (e.g., QIR).
• Quantum Device Management Interface (QDMI): Abstracts device control and status, supporting session and job management, device querying, and extensibility through vendor plugins.

These modules integrate with benchmarking tools (such as MQT Bench (Quetschlich et al., 2022)), simulation engines (DDSIM (Wille et al., 27 May 2024)), mapping utilities (QMAP), and equivalence/verifier packages (QCEC).

3. Hybrid Quantum-Classical and HPC Integration

MQSS is distinguished by its tight integration with classical HPC resources, treating quantum processors as accelerators within scientific and industrial workflows (Shehata et al., 3 Mar 2025, Burgholzer et al., 2 Sep 2025):

• Scheduling Coupling: Quantum workloads are scheduled alongside classical jobs via three-level systems coordinating resource pools and time allocation. This enables simultaneous or interleaved execution and efficient data flow between quantum and classical environments.
• Resource Management System: Leverages real-time device telemetry (FoMaCs) and standardized APIs (QPI and QPM) to support dynamic, credit-based reservation and prioritization. This integration supports both simultaneous and chained job allocations and efficiently manages quantum resource contention.

Deployment in production environments (e.g., Leibniz Supercomputing Centre coupling SuperMUC-NG with Q-Exa quantum hardware) demonstrates the practical viability and scalability of MQSS.

4. Benchmarking and Design Automation Ecosystem

MQSS incorporates benchmarking, simulation, and automation components to support rigorous, reproducible evaluation and development (Quetschlich et al., 2022, Wille et al., 27 May 2024, Geissler et al., 15 Apr 2025):

• MQT Bench: Provides >70,000 benchmark circuits across four abstraction levels (algorithmic, target-independent, target-native, hardware-mapped). This enables empirical evaluation and fine-grained comparison of simulation, compilation, and mapping techniques.
• BenchQC: Application-centric benchmarking framework integrated via QUARK for end-to-end metrics collection. Assesses hardware, circuit, resource, and application performance using standardized metrics (e.g., Q-Score, expressibility, entanglement, fidelity, optimality gaps).
• Design Automation Tools: DDSIM (simulation via decision diagrams), QMAP (circuit mapping/compilation), and QCEC (circuit equivalence checking) provide automated optimization and verification throughout the quantum software workflow.

The presence of advanced simulation, compilation, verification, and benchmarking tools supports both research and industrial-grade application development.

5. Modularity, Extensibility, and Community Development

MQSS is developed according to open-source and community-driven principles, enhancing interoperability, rapid evolution, and broad adoption (Fingerhuth et al., 2018, Burgholzer et al., 2 Sep 2025):

• Modular Interfaces: Support plug-in integration for compilers, simulation backends, hardware adapters, and benchmarking suites. Enables swapping modules as needed without stack-wide refactoring.
• Open Standards: Interfaces such as QDMI and QPI standardize communication, fostering external contributions and vendor-agnostic integration.
• Community Processes: Transparent development on platforms like GitHub, adherence to best practices (documentation, CI/CD, branch strategies, contribution guidelines) ensure maintainability and reproducibility. Public forums and roadmaps support engagement and coordinated progress.

Challenges identified include fragmentation, incomplete documentation, limited discussion channels, and lack of standalone open compilers; MQSS addresses these via modular design, standards adoption, and active community building.

6. Forward-Looking Features and Future Prospects

MQSS is structured to adapt to evolving quantum computing demands (Burgholzer et al., 2 Sep 2025):

• Fault-Tolerant Quantum Computing: Architecture accommodates future error-corrected machines, mid-circuit measurements, varied qubit encodings, and advanced compiler/scheduler updates.
• AI-Based Compilation and Scheduling: Development trajectories include AI-assisted pass selection, enhanced resource prediction, and adaptive optimization algorithms.
• Mixed-Dimensional Systems Support: Integration with frameworks such as MQT Qudits (Mato et al., 3 Oct 2024) enables specification, compilation, and simulation of circuits using mixed-dimensional qudits via DITQASM and specialized simulation engines.
• Broader Ecosystem Interoperation: As standards and interfaces mature, MQSS is positioned to unify disparate quantum software systems, supporting commercial and academic adoption and facilitating integration with both proprietary and experimental hardware/software platforms.

7. Methodological Principles and Evaluation Criteria

MQSS development is guided by best practices drawn from open-source software engineering (Fingerhuth et al., 2018):

• Documentation and API Design: Comprehensive, up-to-date documentation and API references support accessibility for new users and external developers.
• Transparent Version Control and Testing: Decentralized version control, automated testing, continuous integration, and rigorous code review underpin stack reliability.
• Evaluation Metrics: Standardized quantitative benchmarks are used to assess performance, reproducibility, and scalability across all stack layers and modules.

Attention to these principles addresses identified shortcomings and cultivates a sustainable, robust software stack that is adaptable to future research advances.

---

In summary, the Munich Quantum Software Stack offers an extensible, multi-layer, modular, and community-driven ecosystem that integrates advanced compilation, scheduling, and hardware abstraction, supporting a wide array of quantum-classical workflows and benchmarking tools. Its architecture, informed by open-source best practices and focused on interoperability and adaptability, anticipates the demands of both near-term and future fault-tolerant quantum computing, facilitating broad accessibility for experts and non-experts in research and industry.