Demystifying the Quantum Computing Stack
Understanding quantum computing from first principles, without a physics degree
2024 was a landmark year for quantum computing. From Google's announcement of their below-threshold Willow processor to Microsoft and Atom Computing’s progress with logical qubits, breakthroughs in quantum hardware have dominated headlines. These announcements mark a watershed moment: after decades of theory, ‘logical qubits’ - the holy grail of fault-tolerant quantum computing - are showing the potential for performance at scale.
However, this progress has bred wild speculation. When Jensen Huang made cautionary comments about quantum computing's future last week, quantum stocks plunged 40%, countering gains from a year-end frenzy that had seen some stocks more than double. These market gyrations expose a deeper truth: few understand how quantum computers actually work, how error correction fits in, and what other technological hurdles stand between us and practical quantum computing.
This confusion is understandable. Despite quantum computing's outsized presence in headlines, there's surprisingly little public understanding of how it works from first principles. To bridge this gap, we need a clear framework that links the basics of qubits to the high-level applications we want to run on quantum computers. This roadmap, called the quantum computing stack, will be the focus of this series. My goal is to help you cut through the hype and understand quantum developments yourself as they unfold. All you need is an interest in technical ideas – no quantum background required.
The Magic of Computing Stacks
Modern computers are incredibly complicated devices. The applications we use every day require billions of bits to run, and managing this complexity directly would be impossible for humans. Our brains simply aren't wired to work with billions of anything, let alone coordinate them all simultaneously. The key to managing such overwhelming complexity is to break it into smaller, focused tasks, where each set of tasks builds on the work done by the tasks before it. This building-block approach is called a stack - essentially a hierarchy where each level handles its own piece of the puzzle while hiding all the complexity from the levels above it.
As a helpful analogy, think about building a house. You start with the foundation, then build the walls, install windows, add furniture, and finally decorate. When you're hanging curtains, you don't think about the sturdiness of the foundation or windows anymore - you just trust they’re solid. Each layer builds on the one below it, allowing you to focus on one thing at a time. Similarly, layers of a computing stack enable researchers and developers to focus on their specific problems without having to engineer every other aspect of the technology they rely on.
Take your smartphone – it’s a marvel of layered engineering that you never have to think about. At its heart are billions of tiny transistors, which combine into processors that execute instructions, which run an operating system, which supports your apps, which ultimately let you send that text message. That's the magic of a computing stack: each layer transforms something complex into something simple that the layer above it can use. We see this pattern everywhere in modern technology - from how the internet turns electrical pulses into video streams, to how generative AI platforms transform matrix operations into natural conversations. Each layer of a stack is carefully orchestrated to handle its own unique challenges while presenting a clean, simple interface to the layer above it, and ultimately to the users who benefit from the entire stack.
Understanding a computing stack is like developing an X-ray vision for a technology; it lets you see through the surface to understand how everything fits together underneath. That's exactly what we'll do in this series: layer by layer, we'll reveal how quantum computers work, from the fundamental physics of quantum bits all the way up to the applications that could transform industries and revolutionize high-performance computing.
Quantum Computing from the Ground Up
Similar to other stacks, the quantum computing stack aims to provide useful abstractions to programmers, architects, and users to interact with quantum computers. However, the quantum stack has another critical goal: managing the inherent fragility of quantum information. While classical computers can usually maintain data integrity with simple error checking, quantum errors occur far more frequently and are much harder to correct. This is the most pressing obstacle to practical quantum computing, and it shapes the entire stack from top to bottom.
Let’s see what this looks like in practice. The quantum computing stack, shown in the diagram below, is built from six essential layers. With this map as our guide, I'll now walk you through how quantum computers really work, showing you what each layer does and why it matters. This overview is just the beginning - in subsequent posts, I'll publish deep dives into each of these layers, exploring the state of the field, the challenges we're facing, and how companies and researchers are tackling them. You'll find links to each article below as they're published.
Physical Qubits: At the foundation are qubits, the quantum counterpart to classical bits. While classical bits are built from transistors and can only be 0 or 1, qubits can exhibit states “in between” these (superposition) and can be physically correlated with each other (entanglement). These powerful properties come at a cost: qubits are extremely sensitive to noise and environmental disturbances. Many different types of physical qubits exist, from superconducting circuits to trapped ions to neutral atoms to photons. While all types of qubits attempt to physically realize the same quantum properties, each comes with their own advantages and challenges in performing scalable quantum computing.
Pulse Control: In order to do anything useful with these qubits, we need to be able to control them precisely. This layer does just that: it converts quantum operations into precisely timed electromagnetic pulses that control qubits. Pulse generation instructions are, roughly speaking, the quantum counterparts to machine code in classical systems. Achieving the necessary precision and timing for these pulses is a significant engineering challenge. Even tiny imperfections can corrupt quantum information.
In my upcoming article on physical qubits and pulse control, we’ll discuss different types of qubits, who’s working on them, what their tradeoffs are, and their paths to scalability.
Error Correction and Mitigation: Quantum information is incredibly sensitive to disturbances, making advanced error-reduction techniques essential for any practical quantum computer. Two broad approaches have emerged to tackle this challenge. Quantum Error Correction (QEC) combines many imperfect physical qubits to create more reliable "logical" qubits through sophisticated error correction codes. In contrast, Quantum Error Mitigation (QEM) reduces errors by running extra circuits rather than using additional qubits. In this “error reduction” layer, one can leverage techniques from QEC, QEM, or both. All of these techniques directly rely on the design and control of physical qubit systems, explaining its place in the hierarchy.
In my article on error reduction, we’ll explore both QEC and QEM, recent advances in the area, their respective tradeoffs, and the computing regimes that they define.
Logical Gates and Circuits: Now that we have techniques to create more reliable ‘logical’ qubits, we can implement higher-level quantum operations on them. These operations, called logical gates, enable us to leverage quantum phenomena like superposition and entanglement between logical qubits. We can combine logical gates to form logical circuits, which parallels how classical operations are combined to form classical logic circuits. The challenge at this layer is implementing logical operations that provide us computational flexibility while preserving the hard-won stability of our error-corrected qubits.
Compilation: In order to run applications on a quantum device, we need to translate quantum algorithms into logical quantum circuits. Just like in classical computing, this is done via a compiler. While the basic compilation challenges mirror classical computing - managing resources, scheduling operations, mapping to hardware - the nascent state of current quantum technology makes every constraint more important and hardware-dependent. Each additional qubit risks decoherence, each extra gate amplifies errors, and hardware limitations restrict how operations can be arranged. The challenge here is finding ways to implement quantum algorithms effectively despite these severe hardware restrictions - a challenge that will evolve as quantum technology matures.
In my article on Logical Circuits and Compilation, we'll examine how quantum algorithms get translated into something quantum computers can actually run, what makes certain algorithms practical or impractical on current hardware, and what this means for near-term quantum applications.
Applications: At the top of the stack are the quantum algorithms and applications that solve real-world problems. These range from simulating quantum chemistry for drug discovery to breaking certain types of encryption. The key challenge here is identifying problems where quantum computers can provide meaningful advantages over classical alternatives - a far subtler question than it might first appear.
In my article on Applications, we’ll explore the key questions that shape quantum computing's potential: Which problems might genuinely benefit from quantum approaches? What hardware capabilities would we need to realize these benefits? And how do we navigate between quantum computing's genuine promise and its more speculative claims?
Core Design Principles
Before I wrap up, I want to briefly touch on some important ideas that will pervade our exploration of the quantum stack. These ideas also inform how researchers and engineers think about building quantum computer systems.
1. Architecture-aware design. Just because we can abstract away the engineering details of lower layers doesn't mean they're irrelevant to us. Take our house analogy: if you have fewer windows, you'll want to think carefully about artificial lighting and furniture placement to keep rooms bright and usable. Similarly in quantum computing, if your quantum bits can only interact with some of their neighbors, this shapes the optimal way to process information at every layer above. Since QC hardware is so nascent, we are heavily informed by lower layers in each level of the stack. As we'll see throughout this series, this architecture-aware design is crucial for building practical quantum computers.
2. Top-down constraints. Just as low-level constraints shape high-level possibilities, high-level goals can also inform low-level design. Take our house analogy: if you know you'll need a home office for remote work, this affects everything from where you place electrical outlets to which room gets the best natural light. Similarly in quantum computing, if we know we want to run certain kinds of algorithms, this can drive crucial choices about how we build and arrange our physical qubits. As we explore each layer of the stack, we'll see how these top-down requirements are just as important as bottom-up constraints. This idea is already prevalent in classical computing in the form of specialized hardware such as FPGAs, GPUs, and more recently, Transformer ASICs.
3. Fluidity. There are various ‘correct’ ways to break down the quantum stack: this is just one perspective on a rapidly evolving field. Like any new technology pushing into uncharted territory, the boundaries between layers shift as we learn more about what works best. Furthermore, certain types of quantum hardware, like photonic systems, use stacks that look quite different to this one.
Stay Tuned!
The quantum stack gives us a powerful lens to understand some of the key quantum breakthroughs of 2024, from Google's Willow to the logical qubit results from QuEra and Atom Computing. While these were fundamentally advances at the "Error Correction and Mitigation" layer of the stack, they also represent significant progress across physical qubits and control systems. In turn, these advances unlock new possibilities in the layers above, from better logical gates up to applications. But critical questions remain: What fundamental innovations made these breakthroughs possible? What are the remaining bottlenecks in each layer? And perhaps most importantly - once we solve the core technical challenges, where will quantum computers deliver real value?
Over the next articles in this series, we'll examine each layer of the stack and understand how to answer these questions from first principles. We'll discuss not just the technical state of play, but how progress in each area combines to bring us closer to practical quantum computing. Whether you're an investor trying to evaluate quantum companies, a developer interested in quantum applications, or simply someone fascinated by this technology's potential, understanding the stack will help you cut through the hype and grasp what really matters to the future of quantum computing. Subscribe to State of the Qunion to stay tuned.