, most people knew about quantum physics, but it was mostly theory and maybe a little science fiction-sounding. But since IBM released Qiskit and opened access to its hardware, advances in quantum computing have continued to come. People from different disciplines and backgrounds could write code for quantum and run it on actual devices.
Although the past decade has seen many amazing breakthroughs in the field, the software side of quantum computing is still very underdeveloped.
However, every player in the field, from enthusiasts to developers to researchers, recognizes the importance of building a mature quantum software stack. So, last month (Feb 2026), a couple of research labs and companies launched the Quantum Software Alliance: a collaboration intending to build and support the quantum software community.
And so, there is no better time than the present to step back and take a look at the layout of the quantum software stack. In this article, I will walk you through the landscape of programming quantum computing today. We will explore algorithm design, execution, debugging, and orchestration, and highlight the major approaches and tools available now.
The Three Computational Modalities
At its core, quantum programming isn’t just “another language” implemented on existing computers. Quantum computers compute with qubits (units of information that exploit superposition and entanglement), making the mathematical and operational models fundamentally different from classical bits. These differences cascade through every layer of the software stack, creating new needs for languages, compilers, runtime systems, and debugging tools.
Before we talk about tools, let us take a step back and understand what kinds of quantum computation we program today. In other words, how can I describe a quantum algorithm today? There are three different ways we can describe quantum algorithms:
1. Gate-Based (Circuit Model)
This is the most widely used approach for general quantum algorithms such as Grover’s search or the Quantum Fourier Transform. Programs are expressed as sequences of quantum gates applied to qubits, forming circuits similar to classical logic circuits. Gate-based quantum computing is universal.
Which means, with the right gates and error correction, it can implement any quantum algorithm.
2. Analog & Special-Purpose Models
Not all quantum computing modalities use gates to implement algorithms. For example, quantum annealing enables the system to evolve toward a low-energy state, thereby finding solutions to combinatorial problems. Another example is Hamiltonian simulation and analog dynamics, which are used in physics simulations.
These models often require different interfaces compared with circuit languages. Think of those two modalities like general-purpose computing and embedded systems.
3. Hybrid Quantum-Classical Workflows
Today, quantum computers require fault tolerance. But even in the future, most quantum computers will not be standalone. Practical quantum programs often run hybrid workflows: heavy classical preprocessing, a quantum subroutine, and classical postprocessing.
These pipelines require systems that allow communication between multiple environments and often run in the cloud.
Quantum Programming Abstractions
Now that we have a rough idea of the different modalities for implementing quantum algorithms, we can discuss the levels of abstraction in quantum programming. Quantum programming spans a spectrum from hardware-near instruction sets to high-level algorithmic languages.
Low-Level & Intermediate Representations
Let’s start from the bottom and go up!
- QASM: A hardware-agnostic quantum assembly language used as a compilation target for many frameworks. QASM was developed so programmers could write code for different hardware using different programming languages/ libraries.
- Quil (Quantum Instruction Set Architecture): Designed by Rigetti, it introduces a shared quantum-classical memory model supported by Python libraries such as pyQuil.
- OpenPulse: Quantum computers are, in a sense, analog computers. Each quantum gate can be implemented as a pulse (an electromagnetic wave) applied to the qubit. OpenPulse was introduced by IBM to allow users better control of the hardware.
These languages offer tight control over gate sequences but require more expertise and are not easy to master.
High-Level Frameworks
Frameworks in familiar languages like Python let developers build and test quantum programs using abstractions close to classical programming. This is the most common way to implement and explore quantum algorithms.
- Qiskit – Python-based SDK from IBM that remains one of the most widely used stacks for circuit construction, optimization, and hardware targeting.
- Qrisp – A newer high-level framework that brings classical programming constructs (variables, loops, control flow) to quantum circuit generation while handling low-level details for you.
Other frameworks include Cirq, TKet, QuTip, and PennyLane. These frameworks’ algorithms make it easy to construct quantum algorithms, which is key to quantum education and prototyping.
#A simple Python code generating an entangled pair
from qiskit import QuantumCircuit
from qiskit_aer import AerSimulator
from qiskit import transpile
# Create a Bell state circuit
qc = QuantumCircuit(2)
qc.h(0)
qc.cx(0, 1)
qc.measure_all()
# Simulate
sim = AerSimulator()
compiled = transpile(qc, sim)
result = sim.run(compiled, shots=1024).result()
print(result.get_counts())Quantum-Specific Languages
These are languages built specifically for expressing quantum logic; the two most popular ones are:
- Q#: a high-level, domain-specific language from Microsoft intended for scalable quantum algorithms; it integrates classical and quantum logic with compile-time checks and a type system tailored to quantum operations.
- Silq: a high-level programming language for quantum computing with a strong static type system, developed at ETH Zürich.
The Hard Question: Simulators or Hardware?
Now, if you decide to write a quantum program today, you would choose an abstraction level (most likely Python with Qiskit or PennyLane). Then, once you have built your circuit, you will probably wonder, “Where does my program run?”
It is a very valid question! And you have two options: you can either run it on a simulator or on actual hardware.
Quantum Simulators
Classical simulators execute quantum circuits up to decent qubit counts (mostly 23-30 qubits). This is quite useful for development before deploying on real hardware.
- Many frameworks include built-in statevector or density-matrix simulators.
- Simulators are essential for debugging and validation before running on real hardware.
Cloud Hardware
However, classical computers can’t simulate larger quantum systems (if they did, we wouldn’t need a quantum computer!). Luckily, major cloud providers now offer access to real quantum processors:
These services typically provide API access, backends with real qubits, and job-scheduling systems. Sadly, not all these companies allow for free access, but I know for sure that IBM does offer a couple of free minutes of computing time per month.
Another option to have access to quantum hardware is to use services that provide a full online ecosystem. Using these websites, you can buy tokens to access different hardware from one place. Some examples of such services are:
Testing & Debugging in Quantum Software Engineering
Classical programmers know the value of unit tests and debuggers. In quantum computing, these practices are just emerging. Quantum systems behave differently, and we still don’t have a concrete idea for developing tools that make debugging quantum programs efficient.
Today, programmers will have to do everything by hand and often need to understand the circuit’s math to figure out what went wrong if the output is not what’s expected. Testing and debugging a quantum circuit was the main focus of my PhD thesis. The core of my work was to introduce a structured framework for debugging circuits by categorizing common circuit block types and proposing tailored debugging strategies.
This kind of tooling is important for advancing the quantum software stack. Because bugs in quantum circuits can be subtle, errors may stem from incorrect qubit ordering, improper uncomputation, or miscalibrated phases! Also, these errors are not always evident from output statistics alone.
arXiv:2311.18202)
Another unique challenge in quantum software engineering is efficiently translating high-level logic into hardware-compatible instructions while ensuring correctness and accuracy.
Quantum compilers and transpilers perform tasks such as qubit mapping, gate decomposition, and error-mitigation preparation (similar to classical EDA but with quantum-specific constraints, such as decoherence and the no-cloning principle).
Where We Are And Where We’re Going?
Though quantum hardware is not fully here yet. We can’t build real-life-size applications or complex system simulations on it yet, but the hardware researchers are working harder than ever to get us to that point. So, the software side needs to catch up and be compatible with current and future hardware for us to utilize it. Quantum programming today is at an exciting inflection point:
- Languages and SDKs make quantum algorithm development accessible.
- Cloud services democratize access to real quantum processors.
- Debugging and test tooling are beginning to catch up with classical expectations.
- Design automation and compilers are reducing the burden of low-level engineering.
But, software challenges remain: what is the best way to write quantum programs, how do we test them, and how do we debug them when something goes wrong? The need for more robust software engineering practices in the quantum world is increasing by the day.
So, for all the data scientists who are curious about quantum computing, I am writing to tell you that now is an ideal time to explore, experiment, and contribute!
