qiskit-aer simulates Qiskit circuits with hardware noise models

A C++ engine behind a Python interface

Aer is a high performance simulator for quantum circuits written in Qiskit, and it includes realistic noise models. The implementation is C++ with a Python surface, which the repository layout makes clear, with a src/ directory for the engine, a qiskit_aer/ directory for the Python package, a CMakeLists.txt and a cmake/ directory, and a setup.py that still exists alongside pyproject.toml. The Python side is a thin layer over the compiled core, and the value of that split is speed, since statevector simulation of a meaningful circuit size is compute bound and doing it in C++ with hardware-aware kernels is the whole point of the project. The dependency list in setup.py shows the runtime requirements, with qiskit from 1.1.0 up to but not including 3, numpy from 1.16.3, scipy from 1.0, psutil from 5 and python-dateutil from 2.8.0. The classifiers list the supported Python versions from 3.11 through 3.15, and the operating systems as Windows, MacOS and POSIX Linux.

Reduced maintenance is stated up front

The first thing in the README after the introduction is a table, and the table says Aer is currently operating under reduced maintenance, that the maintainers are only able to address critical bug fixes, and that feature requests and non-critical enhancements have been placed in the backlog and will be revisited as capacity allows. That is the single most important fact for anyone planning around this dependency, and it sits above the installation instructions for a reason. The release history backs it up, with 0.17.2 published on 2025-09-17, 0.17.1 on 2025-06-04 and 0.17 on 2025-03-13, so the tagged versions are spread across a year and a half. The repository is not archived and the last push was on 2026-10-20, which tells you the branch still sees work, but a branch that moves is not the same as a project that ships features. If your work depends on a new simulator method or a new noise model, that dependency is a risk you have to price in.

Installing the CPU and GPU packages

The CPU install is a single pip command, and the README is explicit that pip handles all the dependencies and that you will always get the latest and well tested version:

pip install qiskit-aer

Building from source is pointed at the contribution guidelines instead of being documented inline. GPU support has its own package and its own requirements. To install and run the GPU supported simulators on Linux you need CUDA 11.2 or newer already installed, and CUDA itself needs a set of specific GPU drivers, with the NVIDIA documentation linked for the installation procedure. The package for current CUDA is:

pip install qiskit-aer-gpu

and for a system with CUDA 11 installed, the separate variant is:

pip install qiskit-aer-gpu-cu11

The README warns that the GPU package overwrites the current qiskit-aer installation, giving you the same functionality as the canonical package plus the ability to run the GPU supported simulators, which are statevector, density matrix and unitary. There is a hard platform limit, because that package is only available on x86_64 Linux, and for other platforms with CUDA support you have to build from source using the guide section on building with GPU support. The setup.py source explains the packaging logic behind this, with the CUDA major version and the package name read from environment variables, and it notes that ROCm is expected to be present on the target system so that no ROCm requirements are loaded.

Running a circuit and reading an expectation value

The example in the README is a complete working script rather than a fragment, and it is worth reading as the canonical usage pattern. You build a simulator, transpile parameterized circuits into it, define the operators as sparse Pauli operators, and then run an estimator job over a list of circuit, operator and parameter triples:

from qiskit import transpile
from qiskit.circuit.library import RealAmplitudes
from qiskit.quantum_info import SparsePauliOp
from qiskit_aer import AerSimulator

sim = AerSimulator()

The EstimatorV2 primitive is then run with a list of tuples pairing each circuit with the operators to measure and the parameter values to use, and the job result carries the expectation values per circuit. The second half of the example does the same with the SamplerV2 primitive on a two qubit Bell circuit built with an h gate, a cx gate and measure_all, collecting 128 shots, and then on two parameterized circuits with different parameter vectors. The primitives are the Qiskit 2 style interface, so the same EstimatorV2 and SamplerV2 objects can be pointed at real hardware later.

Running against the noise of an actual backend

The third part of the example is the one that makes the simulator worth having, because it wires a live backend's noise into the simulation. It creates a QiskitRuntimeService, takes the least busy backend, and builds the sampler from that backend rather than from a simulator:

from qiskit_ibm_runtime import QiskitRuntimeService
provider = QiskitRuntimeService()
backend = provider.least_busy()

# create sampler from the actual backend
sampler = SamplerV2.from_backend(backend)

The circuit is then transpiled against the backend basis gates with a simulator that is constructed with those same basis gates, and run for 128 shots, giving counts for a Bell circuit with noise. That is the point of the whole package in one snippet. You get the measurement statistics a real device would produce for that circuit on that backend, without using the device, which is what lets you test a variational circuit or a noise mitigation strategy before you have queue time on hardware.

Packaging, wheels and the build stack

The build is more involved than a pure Python package, which is why the packaging configuration is extensive. The build requirements are setuptools, conan below version 2.0, scikit-build, cmake with two excluded versions, ninja and pybind11, so the C++ core is compiled through scikit-build and conan supplies the native dependencies. The wheel build uses cibuildwheel with images for manylinux x86_64, aarch64, s390x and ppc64le, and it skips musllinux, i686 and win32. Wheels are verified with a test command running tools/verify_wheels.py, and the tests install binary numpy and scipy first because they have a tendency to crash when installed from source. There are platform specific notes, including a Linux step that installs openblas-devel and a workaround for Python 3.15 and Qiskit 2.6.0 where glibc does not leave enough thread local storage for libgomp, handled with a GLIBC_TUNABLES setting, and a macOS note that the image clang is newer than conan expects so the build is forced. The repository also carries a .clang-format and .clang-tidy configuration, a .pylintrc, a stestr configuration, a BENCHMARKING.md, a releasenotes/ directory, a tox.ini and a constraints.txt.

Editorial conclusion

Adopt qiskit-aer when you need to run Qiskit circuits locally with a noise model that reflects a specific backend, and you want the same primitives the hardware path uses. Do not adopt it expecting new features, because the project states it is in reduced maintenance with only critical bug fixes being addressed, and plan around the fact that the last tagged release is 0.17.2. Verify first that the simulator methods you need are available in your install, since the GPU package is what adds statevector, density matrix and unitary on GPU, and that your Python version is in the range the classifiers list.

Frequently asked questions

Official sources

1. License: Apache-2.0
2. Project website
3. Qiskit/qiskit-aer on GitHub
4. README
5. Releases