The Qiskit team has released version 2.3 of its open-source quantum SDK on January 22, 2026, significantly expanding its C API to boost performance for high-performance computing (HPC) users. Building on previous releases focused on hybrid quantum-HPC workflows, Qiskit v2.3 introduces new tools for circuit optimization, including custom transpiler passes implemented directly in C via the new QkDag and expanded QkTarget objects. This allows developers to integrate their own strategies “in the environment where their HPC workflows already live.” Beyond speed improvements—including faster hardware layout selection and new multi-qubit Pauli measurements—the update also lays groundwork for fault-tolerant quantum architectures with early explorations of compilation to Pauli-based computation.

Expanded C API Enables Custom HPC Circuit Optimization

The latest release focuses on empowering developers with unprecedented control over circuit optimization through an expanded C Application Programming Interface (API). This isn’t simply about speed; it’s about unlocking the potential for truly customized workflows where quantum algorithms seamlessly interface with existing HPC infrastructure. Central to this advancement is the introduction of “QkDag,” a circuit representation newly exposed to C and backed by the same DAGCircuit object used in Python. Alongside an expanded “QkTarget” model, developers can now meticulously inspect, modify, and extend the compilation process “step by step—all without rebuilding the entire compiler pipeline,” according to release documentation.

Previously, the C API allowed for target construction; now, it enables the creation of entirely custom transpiler passes within that C environment. Specific functions like “qk_transpile_stage_init()” and “qk_transpile_stage_optimization()” facilitate this granular control, allowing developers to build composable transpilation workflows. This level of access is crucial for organizations already heavily invested in HPC, allowing them to leverage existing infrastructure and expertise. The ability to write custom passes in C, the language of many HPC systems, circumvents the performance overhead of constantly translating between Python and compiled code.

Furthermore, new functions like “qk_target_op_get()” streamline interaction with target operations, offering a structured approach to managing them. Qiskit v2.3 isn’t solely focused on present-day optimization. Updates, including improved Clifford+T transpilation and early support for compilation to Pauli-based computation (PBC), are strategically positioned to support the development of large-scale, fault-tolerant architectures. “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 inclusion of the Ross-Selinger algorithm, “gridsynth,” for efficient RZ-rotation synthesis further demonstrates a commitment to future-proofing quantum computation.

VF2Layout & PauliProductMeasurement Enhance Circuit Performance

Qiskit SDK v2.3 delivers substantial gains in quantum circuit performance through refinements to layout selection and the introduction of novel measurement capabilities, pushing the boundaries of what’s achievable with near-term quantum processors. Upgrades to VF2Layout and VF2PostLayout are demonstrably improving speed and scalability, reducing the computational burden of mapping abstract quantum circuits onto the physical topology of quantum hardware. These enhancements are critical as researchers strive to maximize fidelity and minimize errors in increasingly complex computations. The performance boost stems from a focus on optimizing the initial stages of compilation.

According to the Qiskit team, these updates provide “reduced compilation overhead and improved fidelity on quantum hardware.” This isn’t simply about shaving milliseconds off processing time; it’s about enabling larger, more intricate circuits to run effectively on existing systems. Further control is offered through standalone VF2-based “perfect” layout selection passes, giving users greater control over layout generation and optimization, alongside the ability to create custom layouts via qk_transpile_layout_generate_from_mapping(). Beyond layout optimization, Qiskit v2.3 introduces PauliProductMeasurement, a new instruction class enabling joint projective measurement across multiple qubits.

This innovation is a key step towards compilation for Pauli-based computation (PBC), a computational paradigm central to fault-tolerant quantum computing. “Pauli-based computing plays an essential role in error-corrected circuits and stabilizer-based protocols,” highlighting the long-term strategic importance of this feature. The LitinskiTransformation pass has been extended to include measurements, facilitating end-to-end transpilation pipelines for PBC and opening avenues for integration with other open-source tools. These advancements are coupled with improvements in early fault-tolerant transpilation, specifically with Clifford+T targets and the implementation of the Ross-Selinger (gridsynth) algorithm.

As the Qiskit team explains, “Qiskit v2.3 expands its support for compilation into Clifford+T basis with the addition of the Ross-Selinger (gridsynth) algorithm.” This algorithm efficiently approximates RZ-rotations, and is accessible both as a standalone function, gridsynth_rz(), and as part of the UnitarySynthesis transpiler pass. These combined features position Qiskit as a crucial platform for exploring and developing the next generation of quantum algorithms and hardware.

QkDag and QkTarget Facilitate Flexible Transpilation

Qiskit v2.3 marks a significant step towards customizable quantum compilation, granting developers unprecedented control over how algorithms are translated into executable instructions for quantum hardware. This isn’t merely about accelerating existing workflows, but about enabling a level of bespoke optimization previously unattainable. The expanded C API is particularly geared towards organizations already leveraging HPC infrastructure. This is achieved through features like standard methods to add and query instructions within QkDag, and new functions such as “qk_transpile_stage_init()”, “qk_transpile_stage_layout()”, and “qk_transpile_stage_optimization()”. These allow developers to execute preset pass manager stages on QkDag objects, building composable transpilation workflows entirely within a C context. Developers can now retrieve operations directly through methods like “qk_target_op_get()”, “qk_target_op_gate()”, and “qk_target_op_clear()”, streamlining interaction with target operations. As the Qiskit Team explains, these updates will “enable deeper integrations with custom hardware, research tools, and standalone workflows.” Beyond immediate optimization, Qiskit v2.3 is also laying groundwork for future fault-tolerant quantum architectures.

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.

Qiskit Team

Clifford+T Transpilation & gridsynth Advance Fault Tolerance

Beyond simply accelerating calculations, the latest release delivers tools for building and refining pipelines that acknowledge the inherent fragility of quantum states, paving the way for more reliable quantum processors. Central to this is improved support for Clifford+T transpilation, a crucial technique for compiling quantum algorithms onto hardware with limited native gate sets. The Qiskit team is actively exploring compilation strategies needed for large-scale, fault-tolerant systems, and v2.3 introduces the Ross-Selinger algorithm – known as “gridsynth” – to improve single-qubit RZ-rotation approximations.

Coupled with improvements to the existing OptimizeCliffordT pass (introduced in v2.1), these updates allow developers to build transpilation pipelines for future quantum processing units (QPUs) with greater efficiency. This isn’t solely a long-term play; the advancements also offer immediate benefits. This, alongside an extended LitinskiTransformation pass, facilitates “end‑to‑end transpilation pipelines for Pauli‑based computations and enabling compilation to measurement-based instruction sets.” Furthermore, a new CommutativeOptimization pass streamlines circuits by exploiting gate commutativity, reducing costs and enhancing performance. These developments build upon previous iterations of Qiskit, including C-based observables (v2.0), high-performance circuit construction (v2.1), and a C-callable transpiler (v2.2).

The expanded C API, now featuring the QkDag object, allows developers to deeply integrate custom optimization strategies within their existing high-performance computing (HPC) workflows, a key benefit for organizations heavily invested in these systems. Ultimately, Qiskit v2.3 isn’t just about faster circuits, but about laying the groundwork for a future where quantum computations are demonstrably robust and reliable.

Qiskit v2.3 also adds a new transpiler pass, Commutative Optimization , which unifies and extends the functionality of both CommutativeCancellation and CommutativeInverseCancellation .