Release News: Qiskit v2.3 is here!

We're excited to announce the release of Qiskit SDK v2.3! Qiskit’s first feature release of the year arrives with a significant expansion of its C API and faster, more flexible tools for building and optimizing quantum circuits. Read on for a summary of the key highlights and as always you can see the full release notes here.

Qiskit v2.3 builds on the momentum we’ve gained across each of the releases in the v2 series, which have all centered on establishing Qiskit as a powerful tool for building hybrid quantum-HPC workflows. Prior releases set the foundations: C-based observables in v2.0, high-performance circuit construction in v2.1, and a C-callable transpiler in v2.2. Now, we’re filling in another key piece with custom transpiler passes in C via the new QkDag and expanded QkTarget.

These new capabilities give developers the freedom to implement their own circuit optimization strategies in the environment where their HPC workflows already live. We hope you’ll experiment with them and share your feedback to let us know what works, what doesn’t, and what you’d like to see next. Your input plays a vital role in shaping how we prioritize new features and future improvements.

Qiskit v2.3 also advances our early explorations of large-scale, fault-tolerant architectures. Updates such as improved Clifford+T transpilation and early support for compilation to Pauli-based computation (PBC) act as important building blocks for compilation to fault-tolerant instruction sets, including those proposed for qLDPC codes. These efforts give us a preview of how fully realized fault-tolerant pipelines may eventually come together, while also offering real value for developers working today.

The TL;DR

The biggest updates we’re going to cover in this article include the following:

• Custom transpiler passes in C. You can now write custom transpiler passes through Qiskit’s C API thanks to a new QkDag object and expanded QkTarget object, which let you inspect, modify, and extend the compilation process step by step—all without rebuilding the entire compiler pipeline. These updates will enable deeper integrations with custom hardware, research tools, and standalone workflows.
• Faster hardware layout selection. Upgrades and Rust-driven performance enhancements made to VF2Layout and VF2PostLayout improve the speed and scalability of circuit-to-hardware layout selection, delivering reduced compilation overhead and improved fidelity on quantum hardware.
• New multi-qubit Pauli measurement. A new instruction class, PauliProductMeasurement, enables joint projective measurement across multiple qubits in a single operation. This unlocks compilation to Pauli-based computation, a common representation used in the context of fault-tolerant quantum computing.
• Improvements in early fault-tolerant transpilation. Performance and feature set improvements associated with transpilation to early fault-tolerant targets—especially Clifford+T targets—allow you to more efficiently build transpilation pipelines for future QPUs. New optimization passes further simplify circuits by canceling redundant gates, exploiting commutativity, and minimizing costly operations like T-gates. These updates also introduce gridsynth as a more efficient method for RZ synthesis.

Below, we take a closer look at these new features and improvements, and also provide details on the most important bug fixes and deprecations in Qiskit v2.3.

Top new features & improvements

In this section we’ll cover some of the most important new features and enhancements included in this release. If you want to know more about these, or other features that didn’t make it into this article, you can see the full list of new features here.

Custom transpilation using Qiskit’s C API

This latest Qiskit release introduces several enhancements to the C API through the introduction of QkDag, a circuit representation newly exposed to C and backed by the same DAGCircuit object used in Python. This, along with an expanded QkTarget model, makes transpilation much more flexible within a C context.

The newly exposed QkDag object comes with standard methods to add and query instructions, obtain topological iteration order, inspect the predecessor and successor relationships that define the circuit’s data-flow structure, and perform simple instruction substitutions. Qiskit v2.3 also exposes new functions for running transpiler stages, including qk_transpile_stage_init(), qk_transpile_stage_layout(), qk_transpile_stage_routing(), qk_transpile_stage_translation(), and qk_transpile_stage_optimization(). Together, these new features allow you to build transpilation pipelines with custom passes in C.

Previously, the C API allowed developers to construct a QkTarget for Qiskit to use. With this release, it now allows you to write transpiler passes that consume the QkTarget. You can retrieve operations directly through the new methods qk_target_op_get(), qk_target_op_gate(), and qk_target_op_clear(), each of which returns a QkTargetOp—the object that represents operations within the target. These additions streamline interaction with target operations and provide a more structured approach to managing them.

These functions allow developers to execute preset pass manager stages on QkDag objects, enabling composable transpilation workflows from C when combined with custom passes. Additional features include qk_transpile_layout_generate_from_mapping() for creating custom layouts, and standalone VF2-based “perfect” layout selection passes, which give users greater control over layout generation and optimization.

Transpiler updates and performance improvements

IBM is exploring the next-generation compilation strategies and computation models that will be needed for large-scale, fault-tolerant quantum computing, and Qiskit v2.3 introduces important tools that contribute to this effort.

Qiskit v2.3 expands its support for compilation into Clifford+T basis with the addition of the Ross-Selinger (gridsynth) algorithm. The algorithm constructs a single-qubit quantum circuit approximating an RZ-rotation with a specified angle, and is exposed both as a standalone function, gridsynth_rz(), and as part of the UnitarySynthesis transpiler pass when the parameter method is set to ”gridsynth”. In practice, enabling gridsynth looks like this:

In addition to these gridsynth-based improvements, we’ve also improved the OptimizeCliffordT pass (introduced in v2.1), further enhancing the quality of Clifford+T circuits.

Pauli-based computing plays an essential role in error-corrected circuits and stabilizer-based protocols. Qiskit v2.3 introduces the PauliProductMeasurement instruction, which performs a joint projective measurement of multi-qubit Pauli operators. Building on this, the LitinskiTransformation pass has been extended to measurements, allowing end‑to‑end transpilation pipelines for Pauli‑based computations and enabling compilation to measurement-based instruction sets combining Qiskit with other open-source tools. Explore that demo here.

Qiskit v2.3 also adds a new transpiler pass, CommutativeOptimization, which unifies and extends the functionality of both CommutativeCancellation and CommutativeInverseCancellation. The pass exploits gate commutativity to perform more extensive gate cancellation and merging, allowing greater circuit simplification and reducing costs across diverse applications. As of this release, CommutativeOptimization can also optimize Pauli-based computation circuits, making it a useful companion to the LitinskiTransformation-based workflows described above.

New features for quantum circuits

Qiskit v2.3 transitions ControlFlowOp to Rust and introduces an important update to the way ControlFlowOp instructions are represented internally once they are added to a QuantumCircuit or DAGCircuit. When inserted, these operations may not appear in the circuit as the exact same Python instance originally provided. As a result, users should avoid mutating any instruction object—including control-flow constructs—after they have been added to a circuit. Doing so may corrupt the circuit structure and lead to unexpected behavior.

Notably, ControlFlowOp was the last major piece of our internal data model that needed to be transitioned to Rust. With this release, that transition is now complete. However, because we’ve kept some Python-level behavior intact to ensure backwards compatibility, this work does introduce some temporary overhead. In particular, transpiler performance involving ControlFlowOp instructions—including BoxOp—may experience a temporary slowdown in Qiskit v2.3. This is due to an ongoing transition from Python-centric control-flow representations to new Rust-native versions.

These short-term drawbacks position us for long-term gains. We expect performance to improve in future releases, as we introduce additional performance gains and long-awaited improvements to control-flow-aware transpiler passes. More importantly, Qiskit’s refactoring in Rust gives us a clear path to speeding up control-flow operations significantly in the future, and will also allow us to expose them to C—something we couldn’t do before.

New Deprecations

In this section, we’ll cover some of the most important new deprecations in this release. This section aims to highlight things that will now start throwing deprecation warnings and will be removed in a later release, following Qiskit’s Deprecation Policy (documented in full here).

For guidance on how to deal with deprecation warnings, check out the deprecations section in our previous article here. You can see more detail about the deprecations specific to this release here.

• The function qk_transpiler_pass_standalone_vf2_layout() is deprecated, and callers should now use qk_transpiler_pass_standalone_vf2_layout_average(). Note that this is the first deprecation that C API builds will emit, using the new systems we’ve put in place for deprecations in the C API. Because the C API is still an explicitly unstable interface, deprecations in it are currently best-effort on our part.

While the following are not formal deprecations, we also want to remind users about two important platform changes included in this release:

• The first is that Qiskit now requires Python 3.10 or higher, following Python 3.9’s end-of-life and prior deprecation notices.

• Additionally, support for macOS x86-64 (Intel) has been downgraded from tier 1 to tier 2. Qiskit will still provide tested and pre-compiled wheels for this platform, but tests are only performed at the time of release, rather than at every change. Have a look at operating system support in our documentation to learn more about the current support tiers for different platforms.

Final notes

And there you have it! The most important details of the latest Qiskit SDK release. Remember, if you want to put ideas forward for future versions of Qiskit you can always open a GitHub issue to request a feature or report a bug! And if you want to follow what's coming up in the next release you can take a look at the Qiskit Roadmap.

Additionally, we want to remind everyone that the Qiskit v2.x series will continue with additional feature releases beyond v2.3. Qiskit SDK v2.4 will arrive later this year and there may be additional entries in the v2.x series beyond that. Keep an eye on the IBM Quantum blog for updates and for future announcements regarding the v2.x series and the release of Qiskit SDK v3.0.

Many people contributed to this release, special thanks to (in alphabetical order):

Aaryav Mishra, Abby Cross, Adithya J, Andrew Eddins, Akhil, Alexander Ivrii,
Ameya Bhave, Aqil Ahmad, Archit Chadalawada, Arnau Casau, Arnav Kapoor,
Daniel Puzzuoli, Debasmita Bhoumik, Dikran Meliksetian, e-zz, Elena Peña Tapia,
Eli Arbel, Emmanuel Osalotioman Osazuwa, Eric Arellano, Gadi Aleksandrowicz,
Gangavarapu Vivek, Heet Bhatt, Ian Hincks, Jake Lishman, John Lapeyre,
Julien Gacon, Jun Doi, Kalyan Dasgupta, Kevin Hartman, Krishan Sharma,
littlebullGit, Luca Oliva, Luciano Bello, ManuelEsparcia, Matthew Treinish,
Max Rossmannek, Neslişah Öztürk, phioa, Pieter Eendebak, Raghav, Rajdeep Aher,
Raynel Sanchez, Ricard Santiago Raigada García, Ritajit Majumdar, Shelly Garion,
Shivam, Siddharth Golecha, Soumyadip Sarkar, Tanuj Rai, and Yael Ben-Haim

This blog post was written by Kaelyn Ferris with help from Luciano Bello, Antonio Córcoles, Salvador De La Puente, Julien Gacon, Alexander Ivrii, Blake Johnson, Jake Lishman, and Matthew Treinish.