Qiskit v2.5 Release Enables Multi-Representation Compilation Workflows and New Name IBM Quantum Compute Service

The Qiskit team has released version 2.5 of its open-source quantum software development kit, introducing a new compiler framework designed to enable multi-representation compilation workflows. This update addresses a key gap in interoperability by expanding the C Application Programming Interface (API) to now support inspection of the same control-flow operations available through Qiskit’s ControlFlowOp hierarchy, including if/else, while, for, switch, break, and continue instructions. The team states that alongside these improvements, Qiskit Runtime Service is now officially the IBM Quantum Compute Service, a platform naming update intended to clarify the distinction between the open-source SDK and IBM’s quantum services.

• Classical control flow in the C API. You can now inspect classical control flow instructions used in dynamic circuits directly from C. This fills one of the biggest remaining gaps between the C API and Python for Qiskit’s core data model.
• Multi-representation compiler framework. New abstractions let you build compilation pipelines that move between different intermediate representations (IR)—an important capability for domain-specific workflows, complex FTQC (fault-tolerant quantum computing) compiler flows, and more.
• Dedicated fault-tolerant pipelines. New preset pass managers simplify compilation to PBC and Clifford+T representations, both of which are important for FTQC.
• Faster transpilation. Algorithmic improvements in LightSabre, software optimisations, more multithreading, and new fidelity-focused passes all combine to make compilation meaningfully faster in v2.5.
• Qiskit v1.x series end of life. As a reminder, the release of Qiskit SDK v1.4.6 on 12 June marked end of life for the Qiskit v1.x series. Releases in the v1.x series will no longer receive any support—including bug fixes, security updates, or other patches. Users should upgrade to the v2.x series to continue receiving updates and support. Check the Qiskit v2.0 migration guide for more details.

Qiskit v2.5: Naming of IBM Quantum Compute Service

The latest release of Qiskit, version 2.5, marks a significant clarification in IBM’s quantum computing offerings, formally renaming Qiskit Runtime Service as the IBM Quantum Compute Service. This adjustment, while seemingly semantic, aims to resolve user confusion stemming from the distinction between the open-source Qiskit software development kit and the cloud-based quantum services provided by IBM; the company emphasizes that this is a naming update only, with no alterations to existing application programming interfaces or workflows. This shift underscores a strategic effort to delineate between the tools for building quantum algorithms, Qiskit, and the platform for running them, IBM Quantum Compute Service. Beyond the platform naming, Qiskit v2.5 delivers substantial technical improvements, notably expanding the capabilities of its C Application Programming Interface. Developers can now perform classical control flow inspection directly from C, a feature previously limited to Python.

This advancement closes one of the biggest remaining gaps between the C API and Python for Qiskit’s core data model, enabling more efficient and streamlined integration of C code within quantum circuits, particularly in hybrid Python-C environments. Qiskit v2.5 adds support for inspecting the same control-flow operations available through Qiskit’s ControlFlowOp hierarchy, including if/else, while, for, switch, break, and continue instructions. The ability to inspect instructions like if/else statements, while loops, and for loops directly from C allows for deeper analysis and optimization at a lower level, potentially unlocking performance gains for complex quantum programs. This inspection capability does not yet extend to construction of these control-flow operations from C, representing a step toward full C API parity. The release introduces a new compiler framework designed to facilitate workflows that transition between different intermediate representations.

This abstraction allows developers to tailor compilation pipelines to specific quantum algorithm needs, such as those found in fault-tolerant quantum computing. The framework is particularly beneficial for domain-specific compilers, enabling specialized optimizations before lowering to Qiskit’s standard circuit representation. The Qiskit team explains that this flexibility is particularly valuable for advanced compilation workflows, and that the feature is designed to integrate seamlessly with existing pass managers. Complementing this is the introduction of preset pass managers dedicated to Pauli-based computation and Clifford+T representations, both vital for advanced fault-tolerant quantum computing workflows. These dedicated pipelines simplify compilation for these specific representations, potentially leading to improved performance and efficiency. The team reports significant speedups in the transpiler, achieved through algorithmic improvements in LightSabre, expanded multithreading, and a new fidelity-focused optimization pass, demonstrating a commitment to delivering consistent progress without disrupting existing workflows.

The increasing sophistication of quantum algorithms demands greater flexibility in how they are compiled and executed, a trend reflected in the latest iteration of Qiskit. While previous versions focused heavily on Python-based workflows, version 2.5 now adds support for inspecting the same control-flow operations available through Qiskit’s ControlFlowOp hierarchy, including if/else, while, for, switch, break, and continue instructions. This enhancement allows developers utilizing Qiskit’s C API, particularly in hybrid Python-C modes established in version 2.4, to analyze dynamic circuits with greater precision and efficiency. This granular level of access permits querying of control-flow types, examination of nested circuit blocks, and retrieval of parameters governing conditions and loops. The new MultiStagePassManager, introduced alongside the C API improvements, further underscores this commitment to flexible compilation workflows, allowing developers to tailor pipelines to specific algorithm requirements and hardware constraints. This framework enables the use of multiple intermediate representations, optimizing each stage of compilation for maximum efficiency and control.

Multi-Representation Compilation with MultiStagePassManager

IBM’s continued refinement of its Qiskit quantum software development kit took a significant step forward with version 2.5. While previous iterations focused on foundational improvements, the latest release empowers developers with tools to tailor compilation processes, moving beyond a one-size-fits-all approach to quantum circuit design. This shift is particularly evident in the introduction of the MultiStagePassManager, a system allowing compilation pipelines to operate across multiple intermediate representations (IRs). The core innovation lies in abandoning the constraint of a single IR throughout the entire compilation process. Previously, quantum circuits were typically transformed within a unified representation; now, developers can define stages utilizing the most appropriate IR for each task. For instance, a specialized compiler might leverage a high-level representation for initial optimizations before transitioning to Qiskit’s standard DAGCircuit for transpilation.

The team emphasizes that while powerful, this feature is primarily aimed at advanced users building custom pipelines, integrating seamlessly with existing Qiskit tools for incremental adoption. Users retain responsibility for defining transitions between these stages, ensuring a deliberate and controlled compilation process. An example provided showcases integration with the Qiskit Fermions package, demonstrating a pipeline moving from a fermionic program through an intermediate representation before lowering to a DAGCircuit. Beyond the framework itself, Qiskit v2.5 delivers dedicated compilation pipelines tailored to specific quantum algorithm needs. New preset pass managers simplify compilation for both Pauli-based computation (PBC) and Clifford+T representations, both crucial for fault-tolerant quantum computing (FTQC). This targeted approach allows developers to optimize circuits for specific hardware architectures and error correction schemes, potentially leading to significant performance gains. These combined optimizations aim to deliver a meaningfully faster compilation experience.

Transpiler Speedups via LightSabre & Multithreading

Beyond expanding the capabilities of quantum circuit construction and analysis, Qiskit v2.5 delivers substantial performance improvements to the transpiler, the crucial component that translates abstract quantum algorithms into instructions executable on specific hardware. These speedups are not merely incremental; they represent a concerted effort to address bottlenecks and optimize the compilation process, directly impacting the time it takes to run experiments and develop new quantum applications. Algorithmic refinements within LightSabre, Qiskit’s core transpiler, are central to this advancement, coupled with expanded multithreading capabilities and a newly implemented fidelity-focused optimization pass. The team reports demonstrating significant gains through these combined enhancements, though specific performance metrics were not detailed in the release. This focus on transpiler efficiency is particularly important as quantum programs grow in complexity; a slow or inefficient transpiler can quickly become a limiting factor, overshadowing improvements in quantum hardware itself.

The new fidelity-focused pass, in particular, addresses a critical need for error mitigation, attempting to minimize the impact of noise and imperfections inherent in current quantum devices. This is achieved by prioritizing circuit transformations that preserve quantum coherence and reduce the likelihood of errors during execution. Further enhancing control over the compilation process, Qiskit v2.5 offers pre-configured pipelines that streamline the process of optimizing circuits for specific algorithm types, allowing users to bypass manual configuration and leverage optimized workflows. This allows advanced users to construct workflows that leverage the strengths of different representations at each stage of compilation, potentially unlocking further performance gains. The release also signals a move towards giving developers greater control over the entire compilation process. By providing tools to configure, extend, and tailor the SDK, Qiskit aims to empower users to optimize their quantum programs for specific hardware and algorithmic requirements.

These improvements, taken together, position Qiskit v2.5 as a significant step forward in bridging the gap between theoretical quantum algorithms and practical implementation on real-world quantum computers.

Qiskit v1.x Series End of Life & v2.x Migration

While many anticipate a smooth transition in quantum software development, the reality is often marked by necessary, if sometimes disruptive, updates. The recent release of Qiskit SDK v2.5 signals precisely such a shift, accompanied by the official end-of-life for the older Qiskit v1.x series on June 12. This isn’t simply a version upgrade; it represents a fundamental restructuring of how developers interact with IBM’s quantum computing ecosystem, and a deliberate move to clarify the boundaries between open-source tools and commercial services. Releases in the v1.x series will no longer receive any support, including bug fixes, security updates, or other patches. Users should upgrade to the v2.x series to continue receiving updates and support. The Qiskit team provides a dedicated v2.0 migration guide to assist with this process.

Beyond sunsetting the older version, Qiskit v2.5 introduces significant technical advancements, most notably a renaming of the Qiskit Runtime Service to IBM Quantum Compute Service. According to the Qiskit team, the message is simple: “Build with Qiskit. Run with IBM Quantum Compute.” This naming convention will be rolled out gradually, ensuring minimal disruption to existing workflows, and will not affect APIs or current program integrations. The team emphasizes this is a naming update only, and existing programs will continue to function as before. Further enhancing developer capabilities, Qiskit v2.5 expands the C API with classical control flow inspection. This capability enables deeper integration with lower-level tooling and compiler backends, offering a more comprehensive analysis of circuit behavior. The release also introduces a new compiler framework, the MultiStagePassManager, which allows for the construction of custom compilation pipelines operating across multiple intermediate representations.

This abstraction provides increased flexibility, particularly for advanced workflows and fault-tolerant quantum computing (FTQC) applications. The team highlights that this feature is designed for advanced users, but integrates seamlessly with existing Qiskit infrastructure.