Quantum programming languages we build with

Most quantum programming in 2026 happens in Python. Qiskit, Cirq and PennyLane are the three SDKs you will meet first, Q# and CUDA-Q cover the needs Python handles less well, and OpenQASM 3 and QIR are the formats that let a program move between them. This page compares the quantum programming languages and toolkits we build with at AndesQubit, what each one targets and who maintains it, and how we decide which one a project gets.

Two limits apply to everything below. None of these tools makes a quantum computer beat a good classical solver on a business problem today; the language is rarely what limits a project. And these toolkits change quickly. Qiskit dropped older APIs in both its 1.0 and 2.0 releases, and Strawberry Fields went from popular to archived. We checked every version and status below against official repositories and documentation in September 2026.

Quantum programming languages compared

“Level” says how close to the hardware you work. An SDK builds circuits in a host language (usually Python), a language has its own compiler, and an IR is a format that tools exchange.

What is the best quantum programming language to learn in 2026?

For most engineers the best quantum programming language to learn in 2026 is Python with Qiskit. It has the largest community and the most tutorials, and the same code reaches IBM’s processors. After that, learn to read OpenQASM 3, because every major SDK can export it and it shows what a circuit really contains.

The second tool depends on your job. Data scientists should add PennyLane, which connects circuits to PyTorch and JAX. Teams that already write CUDA should add CUDA-Q. Anyone studying error correction or estimating how large a machine an algorithm needs should spend time with Q# and the Microsoft Quantum resource estimator, which Microsoft offers free and without an Azure account.

The concepts carry across tools more than the syntax does: qubits, gates, measurement, noise and how a hybrid loop works. Our quantum training for teams starts there and adds the SDK that matches the hardware your company is likely to use. The glossary defines the terms used on this page.

Qiskit vs Cirq vs PennyLane: which should you use?

Use Qiskit if you want IBM hardware or the widest set of examples, Cirq if you need tight control over a specific device or work in research, and PennyLane if your problem is machine learning or needs gradients through the circuit. All three are Apache 2.0, free and actively released.

Qiskit reached version 2.5.2 in August 2026. IBM now surrounds the core SDK with Qiskit Runtime for execution, a C API and a catalog of Qiskit Functions built by partners. The cost of that pace is breaking changes: code written for Qiskit 0.x needs work to run today.

Cirq (1.7.0, June 2026) is maintained by Google Quantum AI and pairs with its simulator qsim and with libraries such as OpenFermion and Stim. The repository includes vendor modules for Google, IonQ, AQT and Pasqal hardware.

PennyLane (0.45.1, June 2026) comes from Xanadu. It treats circuits as differentiable functions and runs on superconducting, trapped-ion, neutral-atom and photonic devices through plugins. Its Catalyst compiler is built on MLIR and lowers programs to LLVM and QIR, which matters when a hybrid loop needs to run fast.

Which other Python SDKs are worth knowing?

The Amazon Braket SDK, pytket and Guppy from Quantinuum, Qrisp and Qibo each solve a narrower problem well. We pick them when the hardware, the compiler or the team’s infrastructure points that way.

The Amazon Braket SDK is the simplest way to compare hardware from AQT, IonQ, IQM, QuEra and Rigetti under one AWS bill, which suits companies already on AWS. pytket is Quantinuum’s circuit compiler; it imports circuits from Qiskit or OpenQASM, optimizes them and converts them to each device’s native gates. Guppy, also from Quantinuum, is a newer language embedded in Python for programs that mix quantum operations with real classical control flow, such as measuring a qubit halfway through and branching on the result. It compiles to HUGR, Quantinuum’s open intermediate representation.

Qrisp, now an Eclipse Foundation project released under EPL-2.0, lets you write algorithms with typed quantum variables and handles qubit allocation and uncomputation for you. It runs on any backend that accepts QASM. Qibo is sponsored by the Technology Innovation Institute in Abu Dhabi and offers fast simulation on CPUs and GPUs plus drivers for controlling lab hardware, which makes it useful for university labs that build their own qubits.

Is Q# still used?

Yes. Q# is alive and in active development. Microsoft rebuilt the Quantum Development Kit as open source in the microsoft/qdk repository, released version 1.32 in September 2026 and now ships it as the qdk Python package, with extras for Azure Quantum, Qiskit, Cirq and Jupyter.

Q# is a standalone language with its own compiler, not a Python library. Its strengths are a type system built for quantum code, a clean separation between quantum and classical logic, and the resource estimator, which tells you how many physical qubits and how much time an algorithm would need on a future fault-tolerant machine. Through Azure Quantum, programs reach IonQ, Pasqal, Quantinuum and Rigetti processors. The QDK also simulates and compiles OpenQASM, so a team does not have to choose Q# for everything.

We choose Q# when a client needs to size a fault-tolerant algorithm, such as estimating when a given key size becomes breakable, or when the team already works in the Microsoft stack.

The same Bell state in Qiskit, Q# and OpenQASM 3

A Bell state, two entangled qubits that always measure the same value, is the “hello world” of quantum computing. We ran both snippets below with Qiskit 2.5.2 and qdk 1.32.3.

from qiskit import QuantumCircuit
from qiskit.primitives import StatevectorSampler

qc = QuantumCircuit(2)
qc.h(0)
qc.cx(0, 1)
qc.measure_all()

result = StatevectorSampler().run([qc], shots=1000).result()
print(result[0].data.meas.get_counts())  # about half '00', half '11'

operation Main() : (Result, Result) {
    use (q1, q2) = (Qubit(), Qubit());
    H(q1);
    CNOT(q1, q2);
    let results = (M(q1), M(q2));
    ResetAll([q1, q2]);
    return results;
}

Exporting the Qiskit circuit with qiskit.qasm3.dumps gives the OpenQASM 3 version, which pytket, the QDK, Braket and most other tools can read:

OPENQASM 3.0;
include "stdgates.inc";
bit[2] meas;
qubit[2] q;
h q[0];
cx q[0], q[1];
barrier q[0], q[1];
meas[0] = measure q[0];
meas[1] = measure q[1];

Languages outside the Python mainstream

CUDA-Q is the one most companies will actually use. The rest are research languages or specialized platforms that are worth knowing about but rarely the right base for a company project.

CUDA-Q (version 0.16.0, September 2026) is NVIDIA’s programming model for hybrid applications in C++ and Python. It runs state-vector and tensor-network simulators on one or many GPUs, and its documentation lists hardware from IonQ, Quantinuum, IQM, OQC, Anyon, TII, Infleqtion, Pasqal, QuEra and ORCA, plus access through Amazon Braket, Scaleway and qBraid. Its compiler uses MLIR dialects of its own, called Quake. We use it when simulation speed or an existing HPC codebase decides the project.

Classiq’s Qmod works at a higher level: you describe what the algorithm should do and Classiq’s engine synthesizes an optimized circuit for the hardware constraints you set. It is a proprietary platform, with a free open library of examples. Silq, from the SRI Lab at ETH Zurich, is a research language known for safe automatic uncomputation and a strong static type system. Quipper is a functional language embedded in Haskell; its last release, 0.9.0.0, came out in December 2019, so we treat it as an academic reference.

In Julia, Yao.jl (Apache 2.0, still labeled beta by its authors) is a fast simulator and algorithm-design framework. QuEra’s Bloqade started in Julia; QuEra now puts new work into the Python bloqade package and describes Bloqade.jl as stable and still open to fixes.

Annealing, analog and photonic: what do you program them with?

Machines that are not gate-based circuits come with their own SDKs: D-Wave Ocean for annealing, Pulser and Bloqade for neutral atoms at the pulse or analog level, and Perceval for photonics. Strawberry Fields, once the main photonic library, is archived.

D-Wave’s Ocean SDK (9.5.0, September 2026) expresses optimization problems as quadratic models and sends them to D-Wave’s annealers or its hybrid solvers. It is the most direct route to test a scheduling or routing formulation on quantum hardware. Pulser, from Pasqal, composes pulse sequences for neutral-atom devices and supports both digital circuits and analog simulation. Perceval, from Quandela, builds linear-optics circuits and runs them on Quandela’s photonic processors in its cloud.

Xanadu archived Strawberry Fields on January 16, 2026. We do not start new work on it.

What are OpenQASM and QIR, and why do they matter?

OpenQASM 3 and QIR are the two formats that stop a quantum program from belonging to one vendor. OpenQASM is a readable text language for circuits; QIR puts quantum programs inside LLVM IR so compilers can optimize quantum and classical code together.

OpenQASM describes circuits, classical control, subroutines and pulse-level timing. Its specification is at version 3.1, and it has an open governance model on GitHub. In practice, “export to OpenQASM, import elsewhere” is how circuits travel between Qiskit, pytket, the QDK, Braket and Qrisp.

QIR is maintained by the QIR Alliance. Its specification defines a Base Profile and an Adaptive Profile, and QIR 2.0 requires LLVM 16 or later. Most developers never write QIR by hand. They meet it when Catalyst, the QDK or another compiler lowers their program to it. MLIR is the other compiler trend: PennyLane’s Catalyst and CUDA-Q both build on it, and Quantinuum’s HUGR fills a similar role in its own stack.

How AndesQubit chooses a stack

We start from the problem and the hardware that might run it, then pick the smallest set of tools that gets there. The goal is code your engineers can test today on a laptop and move to another vendor later without a rewrite.

1. Keep the problem hardware-agnostic. The business model, data and objective live in plain Python with no SDK imports. Only a thin backend adapter knows about Qiskit, CUDA-Q or Braket.
2. Use open formats at the boundaries. Circuits pass through OpenQASM 3 when they move between tools, and we prefer toolchains that compile to QIR when classical control matters.
3. Simulate first. Almost all development runs on CPU or GPU simulators with noise models. Paid hardware time is for calibration and final benchmarks.
4. Always keep a classical baseline. Every quantum path runs next to the best classical or quantum-inspired method we can build, and the benchmark decides what ships.
5. Pick for the team that stays. If your engineers know CUDA, we lean toward CUDA-Q; if they know PyTorch, toward PennyLane. The code has to outlive our involvement.

In practice we build with Qiskit, PennyLane, CUDA-Q, Cirq and the Braket SDK most often, and we choose Q# for resource estimation, Ocean for annealing experiments and Pulser or Bloqade for analog neutral-atom work. See how this looks in a project in quantum software development and in a scoped hybrid quantum proof of concept. AndesQubit is opening its first engagements in stages, so these describe how we work rather than a list of past projects.

Post-quantum cryptography libraries are a different toolbox

Post-quantum cryptography does not run on quantum computers. It runs on the servers and phones you already have, through ordinary crypto libraries that now implement NIST’s ML-KEM, ML-DSA and SLH-DSA. These are the libraries we work with when migrating encryption.

OpenSSL 3.5, released April 8, 2025, added ML-KEM, ML-DSA and SLH-DSA and made the hybrid X25519MLKEM768 group the preferred TLS key share by default. It is a long-term support release, supported until April 8, 2030. AWS-LC, maintained by the AWS Cryptography team, supports ML-KEM and ML-DSA. BoringSSL, Google’s fork, implements ML-KEM-768 and ML-KEM-1024. Bouncy Castle provides ML-KEM, ML-DSA and SLH-DSA for Java and C#, with a separate FIPS-certified distribution.

liboqs, from the Open Quantum Safe project under the Linux Foundation’s Post-Quantum Cryptography Alliance, is the reference for testing many algorithms, including ones not yet standardized. Its own README warns against using it in production or for sensitive data, so we use it for prototypes and interoperability tests. The production path goes through the libraries above. Our post-quantum cryptography migration service covers the inventory and rollout.