#qiskitc

Qiskit SDK v2.2 Advances the Qiskit C API to Support Quantum-Centric Supercomputing

Important additions in the Qiskit SDK v2.2, released by IBM Quantum Research and the Qiskit Team, make it easier to conduct quantum-centric supercomputing (QCSC) tasks in high-performance computing (HPC) environments. For the implementation of end-to-end quantum-centric supercomputing applications written natively in compiled languages such as C++, this minor version offers an essential component. It stands out for its long-awaited features and notable speed improvements. Developers expect QCSC to enable the first demonstrations of quantum advantage by the end of 2026.

End-to-End Hybrid Workflows Are Unlocked by the Qiskit C API

The most significant update in Qiskit SDK v2.2 is centered on Qiskit's C API, which is its first compiled language interface, and is necessary to fully leverage QCSC. To date, Qiskit versions that only support compiled languages have been able to develop a full end-to-end quantum + HPC workflow thanks to the C API.

Qiskit v2.2 introduces a stand-alone transpiler function that can be called straight from C. Users can develop fully functional QCSC applications by combining this new transpiler function with the C API's pre-existing support for circuits (added in v2.1) and observables (introduced in v2.0). These applications can span the four standard steps of a quantum computing workflow: post-processing on conventional HPC infrastructure, quantum circuit execution, optimization, and mapping.

One of the primary benefits of the C API is its wide compatibility with other programming languages, which allows programmers to write wrappers for other compiled languages like C++ and Fortran, which are the two most popular languages in modern HPC systems.

Hybrid Power in Action: The SQD Workflow Demo

To demonstrate the capacity to create end-to-end quantum + HPC workflows natively in compiled languages, IBM Quantum released a new quantum + HPC workflow demo. Working code and comprehensive instructions for implementing a real QCSC process utilizing the Sample-based Quantum Diagonalization (SQD) technique are provided in this example. SQD is an intriguing choice for proving quantum advantage in the near future.

The sample performs the complete SQD workflow as a single application by integrating data preparation, circuit execution, and parallel classical post-processing on HPC equipment using MPI (Message Passing Interface). Two standardized parallel computing frameworks, MPI and OpenMP, are used in this HPC-ready system. The C API demo demonstrates how to post-process noisy quantum samples to estimate the ground state energy of Fe₄S₄, a chemical cluster found in biological entities.

A key component of the demonstration is the new HPC-ready SQD addon, which duplicates the key functionality of the original Python-based SQD addon in a compiled language (C++). This new tool, which is written as a C++17 template library, is designed for scalable HPC cluster execution. By designing their parallel QCSC software in a compiled language such as C++, users can compile it into a single binary executable that is intended to operate using standardized parallel job launching commands like mpiexec or mpirun.

To further enable these native built workflows, Qiskit v2.2 included a QkTranspileLayout object to store qubit mappings and permutations produced by the transpiler. Additionally, a new function called qk_obs_apply_layout() was created in order to apply these qubit layouts to an observable (QkObs).

Moving Forward with Tolerance for Fault

Qiskit v2.2 also includes new features aimed at the long-term goal of fault-tolerant quantum computing. The new transformation step, LitinskiTransformation, implements a specific transformation that is useful in compilation for certain fault-tolerant architectures. This pass converts input circuits with Clifford gates and single-qubit RZ-rotation into circuits with Clifford gates following multi-qubit Pauli rotations (which are implemented as PauliEvolutionGate gates).

Qiskit v2.2 also introduces new ancilla-free synthesis methods for MCX gates and adders. These novel methods are more efficient for fault-tolerant designs than previous methods designed for continuous, near-term gate sets. These synthesis approaches are used in the HighLevelSynthesis step, which now adds an optimization_metric keyword that allows users to target T count minimization (for fault tolerance) or 2-qubit gate count minimization (for short-term aims).

Increased Performance and Expansion of Hardware Modeling

Backends can now specify parameter constraints in much more detail thanks to an improved Target model in the latest SDK release. Crucially, the Target now supports constraints on gate parameters, allowing Qiskit to realistically depict hardware limits like as fractional gates found on systems like IBM Quantum Heron.

The new WrapAngles transpiler pass automatically enforces these limits by transforming out-of-range angles into similar, hardware-valid sequences. In addition, the Target model now includes a seconds_to_dt() function that converts physical seconds into device time steps. This feature simplifies the handling of device time and makes it easier to incorporate calibration-informed durations into scheduling passes.

Along with new features, Qiskit v2.2 provides measurable improvements in circuit translation performance, with an average speedup of 10–20% throughout the entire benchmark suite. Preliminary results suggest that this long-term efficiency boost could be due to the ongoing transfer of Qiskit code to Rust.

Considerations for Upgrades

Users planning to utilize Qiskit v2.2 should note certain platform changes:

The minimum supported version is Rust 1.85, up from 1.79.

Qiskit SDK v2.2 supports Python 3.9 till it's retired. Qiskit 2.3 needs Python 3.10.

Qiskit v2.3 will break Intel Macs (x86-64) running macOS because the manufacturer no longer supports Intel Mac CI runners.