Library / SDK
Qiskit/qiskit avatar
Qiskit/qiskit

Qiskit core: a Python SDK with a Rust data model, a transpiler, and a C API you can only build from source

Qiskit is an open-source SDK for working with quantum computers at the level of extended quantum circuits, operators, and primitives.

7,973 stars3,129 forksPythonApache-2.0

At a glance

What is it?
Qiskit/qiskit is the Apache-2.0 core of the Qiskit quantum SDK: circuits, operators, the Sampler and Estimator primitives, a transpiler and a quantum information toolbox. Since Qiskit 2.0 it also ships a C API on top of an internal data model written in Rust.
Who is it for?
Use Qiskit if you want to build quantum circuits in Python, run them through the Sampler and Estimator primitives, and transpile them for a device's basis gates and qubit connectivity. Do not expect the statevector primitives to model large circuits, and do not plan on a prebuilt C library, because the README says building from source is the only route.
Can I use it commercially?
Yes. Apache-2.0 is a permissive licence: you can use, modify and sell software built on it, as long as you keep its copyright and licence notices.
Is it still maintained?
Yes. The repository received new commits within the last day.
What is it written in?
Mainly Python, according to GitHub's language statistics.

Answers come from the project's GitHub data, last synced on November 15, 2026, and from our analysis. They are not legal advice.

From daily snapshots

Star history

  • Qiskit/qiskit7,973 ★ · +148
Star history
Repository2026-09-222026-11-15
Qiskit/qiskit7.8k8k

148 Stars in the last 54 days, measured from the daily GitHub snapshot. Compare with other projects

Editorial analysis

Qiskit is a Python library, not a programming language, with a C API added in 2.0

The repository is the core component of Qiskit: building blocks for creating and working with quantum circuits, quantum operators and the primitive functions Sampler and Estimator. It also contains a transpiler that optimizes quantum circuits and a quantum information toolbox for creating advanced operators.

There are two public APIs. The Python API is the primary interface, and before Qiskit 2.0 it was the only public API. The C API gives direct access to Qiskit's internal data model, which is written in Rust. It can be consumed as a shared library, libqiskit.so, for standalone use, or from its embedding in the qiskit Python package for writing Python extension modules. So Qiskit is code you import, not a language you compile with a dedicated tool, and the Rust core means a source build touches a Rust toolchain as well as Python.

pip install qiskit is the main route, and the package requires Python 3.11 or newer

The README recommends installing through pip:

bash
pip install qiskit

It says pip handles all dependencies automatically and installs the latest, well-tested version. The pyproject.toml sets requires-python to 3.11 or above, so an environment on an older interpreter cannot take this release line. The runtime requirements include numpy>=2.0,<3, scipy>=1.14, rustworkx>=0.15.0, dill>=0.3, stevedore>=3.0.0 and typing-extensions. The package lists macOS, Windows and Linux as operating systems and carries the classifier Development Status 5, Production/Stable.

For a source install the README sends you to the installation guide in the documentation. The build backend is setuptools with setuptools-rust, and a build can be switched between debug and release through the QISKIT_BUILD_PROFILE environment variable, which accepts debug and release.

The standalone C library has no binary download, only make c

The README is direct about the C library: the only option currently is to build Qiskit from source. That requires the Rust compiler, and GNU Make is recommended to simplify the build. With those installed you run:

bash
make c

This compiles the C library and puts a dist/c directory in the root of the repository, containing the shared library and the C headers. The Cargo workspace pins a minimum Rust version of 1.91, which is kept in sync with the README and rust-toolchain.toml, and the version in the workspace is 2.7.0-dev, meaning main is ahead of the 2.6.x releases. If you cannot install a Rust toolchain on your build machines, the C API is out of reach for you.

The first program builds a GHZ-type state, then picks Sampler or Estimator

The tutorial in the README builds three steps: define a quantum circuit that represents the state, define the classical output by measurements or observable operators, and then use the Sampler primitive to sample outcomes or the Estimator primitive to estimate expectation values. The circuit prepares an entangled state:

python
import numpy as np
from qiskit import QuantumCircuit

# 1. A quantum circuit for preparing the quantum state |000> + i |111> / √2
qc = QuantumCircuit(3)
qc.h(0)             # generate superposition
qc.p(np.pi / 2, 0)  # add quantum phase
qc.cx(0, 1)         # 0th-qubit-Controlled-NOT gate on 1st qubit
qc.cx(0, 2)         # 0th-qubit-Controlled-NOT gate on 2nd qubit

It uses the Hadamard gate (h), the Phase gate (p) and the CNOT gate (cx). For the Sampler you call measure_all(inplace=False) to get a copy with every qubit measured, then run it with StatevectorSampler and shots=1000. The README says the outcome is similar to {'000': 497, '111': 503}, which is 000 half the time and 111 half the time up to statistical fluctuations.

The Estimator needs a circuit without measurements and returns 4 for the README observable

For the Estimator, the README builds the operator XXY+XYX+YXX-YYY with SparsePauliOp from the quantum information toolbox, and passes it to run() together with the circuit. The detail that catches people: the Estimator requires a circuit without measurements, so you pass the original qc and not the measured copy used for the Sampler.

The run call takes a precision argument, set to 1e-3 in the example, and the README says the outcome is 4. It then suggests trying to assign a value of plus or minus 1 to each single-qubit X and Y operator to reach that outcome, and tells you in advance that this is not possible. Passing a measured circuit to the Estimator is the mistake the sentence guards against.

The statevector primitives will not take you very far, and hardware needs transpiling

The README says plainly that the Qiskit-provided StatevectorSampler and StatevectorEstimator will not take you very far. The power of quantum computing cannot be simulated on classical computers, so scaling to larger circuits needs real quantum hardware. The consequence is that these two primitives are for learning and small checks, not for benchmarking large circuits.

Running on hardware requires rewriting the circuit to the device's basis gates and connectivity, and the transpiler does that, with passes for synthesis, optimization, mapping and scheduling and a default compiler that the README says works very well in most examples. The example maps the circuit to the basis gates cz, sx and rz on a bidirectional linear chain of three qubits:

python
from qiskit import transpile
from qiskit.transpiler import Target, CouplingMap
target = Target.from_configuration(
    basis_gates=["cz", "sx", "rz"],
    coupling_map=CouplingMap.from_line(3),
)
qc_transpiled = transpile(qc, target=target)

Hardware access goes through an abstraction layer for vendors with a compatible interface

Qiskit provides an abstraction layer that lets users run quantum circuits on hardware from any vendor that provides a compatible interface. A vendor without such an interface is not covered by this layer.

The documentation for the SDK lives at quantum.cloud.ibm.com/docs, and the repository's homepage is the IBM Quantum Qiskit page. Because the Python package, the Rust core and the C API all live in this one repository, the layout includes crates, qiskit, test, releasenotes and docs folders, plus a Makefile, a tox.ini and a Cargo.toml. A SECURITY.md and a CONTRIBUTING.md are present for people reporting issues or sending changes.

Release 2.6.1 arrived six days after 2.6.0, which itself followed a release candidate

The recent releases are 2.6.1 on 22 October 2026, 2.6.0 on 16 October 2026 and 2.6.0rc1 on 13 October 2026. The last push was on 2 November 2026 and the repository is not archived. Pin your version in a requirements file if reproducibility matters, since the workspace is already at 2.7.0-dev.

The license is Apache-2.0. The setup.py header also asks that modified files carry a notice saying they were changed from the originals.

Editorial conclusion

Use Qiskit if you want to build quantum circuits in Python, run them through the Sampler and Estimator primitives, and transpile them for a device's basis gates and qubit connectivity. Do not expect the statevector primitives to model large circuits, and do not plan on a prebuilt C library, because the README says building from source is the only route. Check your Python version against the 3.11 minimum before installing.

Frequently asked questions

Is Qiskit a coding language?

No. Qiskit is an open-source SDK for working with quantum computers at the level of extended quantum circuits, operators and primitives. Its primary interface is a Python API, and a C API exists alongside it.

How to install Qiskit?

Run pip install qiskit. The README says pip handles all dependencies and installs the latest, well-tested version. The package requires Python 3.11 or newer.

How to use Qiskit in Python?

Build a circuit with the QuantumCircuit class, then run it with the Sampler primitive to sample outcomes or the Estimator primitive to estimate expectation values. The Estimator needs a circuit without measurements.

Official sources

  1. License: Apache-2.0
  2. Project website
  3. Qiskit/qiskit on GitHub
  4. README
  5. Releases
Add this badge to your README

If you maintain this project, the badge below links readers to this analysis and shows its maintenance status from the daily GitHub snapshot. Paste the markdown into your README; add ?metric=license or ?metric=stars to the image URL for a different field.

Add this badge to your README

markdown
[![Hysen Labs](https://hysenlabs.com/badge/qiskit-qiskit.svg)](https://hysenlabs.com/projects/qiskit-qiskit)

Star history chart for your README

markdown
[![Star history](https://hysenlabs.com/chart/qiskit-qiskit.svg)](https://hysenlabs.com/projects/qiskit-qiskit)

Was this useful?