many people knew about quantum physics, but it was mostly theory and maybe a little science fiction. But since IBM released Qiskit and opened access to its hardware, quantum computing advances have kept coming. People from different fields and backgrounds can write quantum code and use it in real devices.
Although the last decade has seen many remarkable achievements in the field, the software side of quantum computing is still very much under development.
However, every player in the field, from enthusiasts to developers to researchers, recognizes the importance of building a mature quantum software stack. Therefore, last month (Feb 2026), a number of research labs and companies launched the Quantum Software Alliance: a collaboration aimed at building and supporting a quantum software community.
Therefore, there is no better time than the present to step back and look at the architecture of the quantum software stack. In this article, I will walk you through the process of programming quantum computing today. We will explore algorithm design, implementation, debugging, and music, and highlight the major methods and tools available now.
Three Methods of Calculation
Actually, quantum programming is not just “another language” used in existing computers. Quantum computers include qubits (units of information using superposition and entrapment), which make mathematical and functional models very different from ancient bits. These differences trickle down to every layer of software, creating new requirements for languages, compilers, runtime systems, and debugging tools.
Before we talk about tools, let's get back to basics what types quantum computing we plan today. In other words, how would I describe a quantum algorithm today? There are three different ways we can describe quantum algorithms:
1. Gate Based (Circuit Model)
This is a technique that is widely used in standard quantum algorithms such as Grover's search or the Quantum Fourier Transform. The systems are expressed as a sequence of quantum gates used in qubits, which form circuits similar to logic circuits. Gate-based quantum computing is universal.
That is, with the right gates and error correction, it can run any quantum algorithm.
2. Analog and Special Purpose Models
Not all quantum computing modalities use gates to implement algorithms. For example, quantum annealing enables a system to evolve to a state with less energy, thereby finding solutions to integral problems. Another example is Hamiltonian simulation and analog dynamics, used in physics simulations.
These models often require different interfaces compared to circuit languages. Think of those two approaches as general-purpose computing and embedded systems.
3. Hybrid Quantum-Classical Workflows
Today, quantum computers require fault tolerance. But even tomorrow, most quantum computers will not be independent. Functional quantum systems often use a hybrid workflow: heavy classical preprocessing, quantum subroutines, and classical postprocessing.
These pipelines require systems that allow communication between multiple locations and often run in the cloud.
Quantum Programming Abstractions
Now that we have a rough idea of the different ways to use quantum algorithms, we can discuss the output levels in a quantum system. Quantum programming covers the spectrum from near-hardware instruction sets to high-level algorithmic languages.
Low Level & Medium Representation
Let's start from the bottom and go up!
- QASM: A hardware-agnostic quantum assembly language used as a target for multi-framework assembly. QASM was developed so that programmers can write code for different platforms using different programming languages/libraries.
- Quil (Quantum Instruction Set Architecture): Designed by Rigetti, it introduces a quantum-classical shared memory model supported by Python libraries such as pyQuil.
- OpenPulse: Quantum computers are, in a sense, analog computers. Each quantum gate can be used as a pulse (electromagnetic wave) applied to the qubit. OpenPulse is introduced by IBM to allow users to better control the hardware.
These languages provide tight control over gate sequences but require a lot of expertise and are not easy to master.
High-Level Frameworks
Frameworks in standard languages such as Python allow developers to build and test quantum systems using abstractions close to classical programming. This is the most common way to use and test quantum algorithms.
- Qiskit – A Python-based SDK from IBM that remains one of the most widely used stacks in circuit design, optimization, and hardware design.
- Qrisp – A new high-level framework that brings classical programming (variables, loops, control flow) to quantum circuit generation while handling low-level details.
Other frameworks include Cirq, TKet, QuTip, and PennyLane. These framework algorithms make it easy to build quantum algorithms, which is the 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 designed specifically to express quantum logic; two of the most popular are:
- Q#: a high-level, domain-specific language from Microsoft aimed at scalable quantum algorithms; combines classical and quantum logic with integration-time evaluation and a type system designed for quantum operations.
- Silq: a high-level programming language for quantum computing with strong static type programming, developed at ETH Zürich.
The Tough Question: Emulators or Hardware?
Now, if you decide to write a quantum program today, you can choose an abstraction level (likely Python with Qiskit or PennyLane). Then, once you've built your circuit, you'll ask yourself, “Where's my plan run?”
A valid question! And you have two options: you can run it on the simulator or on real hardware.
Quantum Simulators
Classical simulators use quantum circuits that reach a decent qubit count (23-30 qubits at most). This is very useful for development before using actual hardware.
- Many frameworks include built-in statevector or density-matrix simulators.
- Simulators are important for debugging and verification before running on real hardware.
Cloud Hardware
However, classical computers cannot simulate large quantum systems (if they did, we wouldn't need a quantum computer!). Fortunately, major cloud providers now offer access to real quantum processors:
These services typically provide API access, backends with real qubits, and job scheduling programs. Sadly, not all of these companies allow free access, but I know for sure that IBM offers a few free minutes of computer time per month.
Another option to access quantum hardware is to use services that provide a full online ecosystem. Using these websites, you can shop tokens access different hardware in one place. Some examples of these services are:
Testing & Debugging in Quantum Software Engineering
Classic programmers know the value of unit tests and debuggers. In quantum computing, these trends are just emerging. Quantum systems behave differently, and we still don't have a concrete idea of making tools that make debugging quantum systems efficient.
Today, programmers will have to do everything by hand and often need to understand the math of the circuit to figure out what went wrong if the output is not what was expected. Testing and debugging quantum circuits was the focus of my PhD thesis. The core of my work was to present a systematic framework for error correction by classifying common circuit block types and proposing error correction strategies.
This type of tools is essential for developing a quantum software stack. Because errors in quantum circuits can be subtle, errors can come from incorrect qubit arrangement, incorrect math operations, or incorrect phases! Again, these errors are not always visible in output statistics alone.
arXiv:2311.18202)
Another unique challenge in quantum software engineering is to properly translate high-level logic into hardware-compatible instructions while ensuring correctness and accuracy.
Quantum integrators and transpilers perform tasks such as qubit mapping, gate decomposition, and error-reduction correction (similar to classical EDA but with quantum-specific constraints, such as non-coherence and the non-coherence principle).
Where Are We and Where Are We Going?
Although quantum hardware is not yet fully developed. We can't build real-life-sized applications or complex system simulators for it yet, but hardware researchers are working harder than ever to get us to that point. Therefore, the software side needs to catch up and be compatible with current and future hardware in order to use it. The Quantum system today is in an interesting place of change:
- Languages and SDKs makes quantum algorithm development accessible.
- Cloud services democratize access to real quantum processors.
- Debugging and testing tools they are beginning to conform to old expectations.
- Design automation and compilers they reduce 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 robust software engineering practices in the quantum world is increasing day by day.
So, to all data scientists who are curious about quantum computing, I'm writing to tell you that now is a great time to explore, experiment, and contribute!
