Hi there! It’s me again—though this time not about architectures. Or rather, not about classical architectures.
So, the much-cited Moore’s Law (essentially an empirical observation based on limited data) is no longer holding up. On top of that, the fundamental physical limits of the observable universe mean that once transistor sizes drop below 1 nanometer, they approach atomic scales. At around 5 nanometers, electron tunneling already occurs—a quantum effect that shouldn’t exist under classical physics, where electrons effectively penetrate an energy barrier. This leads to current leakage (electrons passing through the insulator, causing energy loss). As a result, transistors at these scales become unstable.
Here’s the situation: following the current trajectory of microelectronics, future performance gains will come only from horizontal and vertical scaling—3D transistors and 3D chips (with FinFET and GAAFET already in use), chiplets, and modular design (also already in practice). Yes, there are promising materials like nanosheets, carbon nanotubes, graphene, and molybdenum disulfide—but all of them run into the same fundamental physical limits.
In other words, we’ve taken a dead-end path. We’re about to hit a ceiling—you might be able to push it up slightly, but beyond that lies a reinforced concrete wall that current technology simply can’t break through.
Let’s assume that in 50 to 100 years (and that’s a conservative estimate), engineers manage to build the most powerful computational unit physically possible within a given space. Say it’s based on RISC-V or Arm. Engineers assemble a chiplet made of 10 stacked chips with full 3D integration, and software developers squeeze every last drop of efficiency out of it.
The History of Quantum Computing: From Concept to Prototype
I’d love to jump straight into the exciting part—show you quantum processors, explain how they’ll solve this deadlock, lead us to technological singularity, and so on.
But first, that’s far from guaranteed. And second, most people don’t really understand what quantum computers actually are (let’s abbreviate them as QC).
People are generally familiar with classical computers and processors, but quantum computing hasn’t exactly gone mainstream—even among technical audiences. It’s widely discussed, you see headlines and occasional deep-dive articles, but real-world adoption has been slow.
So let’s clarify the basics.
A “quantum” (from the Latin quantum, meaning “how much”) is the smallest indivisible unit of a physical quantity. It’s a general term for discrete amounts of energy (energy quanta), angular momentum, its projections, and other quantities that describe the properties of microscopic (quantum) systems.
The first concise idea of quantum computation was proposed by american physicist Paul Benioff described the first quantum-mechanical model of a computer in his paper The Computer as a Physical System: A Microscopic Quantum Mechanical Hamiltonian Model of Computers as Represented by Turing Machines.
A year later, Nobel Prize–winning physicist Richard Feynman—who argued that efficiently simulating quantum systems on classical computers is impossible—introduced the idea of a quantum computer in his lecture There's Plenty of Room at the Bottom.
From 1980 to 1998, the field entered a phase of theoretical development and early experimentation. In those 18 years, a solid foundation was established: initial concepts, models of quantum computers, quantum algorithms, and error correction methods. For example, in 1985, David Deutsch developed the first theoretical model of a universal quantum computer. In 1994, Peter Shor introduced a quantum algorithm for integer factorization, which significantly boosted interest in the field.
The first quantum computer was built only in 1998. The project involved Isaac Chuang from Los Alamos National Laboratory, Neil Gershenfeld from MIT, and Mark Kubinec from the University of California, Berkeley. This system used nuclear magnetic resonance (NMR) to manipulate quantum states and had 2 qubits. It demonstrated the first experimental implementation of a quantum algorithm.
We’ll come back to qubits and related concepts later—plenty of time to dive deeper.
In 2000, IBM and Stanford University expanded on this work by developing a 7-qubit quantum computer, also based on NMR.
Since 2019, the field has seen rapid growth, with more companies and government programs investing in quantum technologies. Today, major tech players like IBM, Google, Microsoft, and D-Wave Systems are actively advancing quantum computing, competing alongside national research labs and universities worldwide.
Time to take a closer look at what they’ve built.
His Majesty — the Quantum Computer
When you hear “quantum computer,” you probably imagine some kind of wunderwaffe the size of a refrigerator.
In reality, there’s still no standardized form factor—no dual-rack server setups or 42U cabinets for quantum systems. Researchers in labs are essentially building whatever configurations they need, experimenting freely.
That said, there are even desktop systems from SpinQ Technology that are barely distinguishable from office PCs or printers—just a bit larger. Some are even brightly colored, with decorative lighting—very on-brand.
The American company IQM Quantum Computers has published a roadmap aiming for systems with up to one million qubits by around 2033 or later. Ambitious, to say the least.
Now it’s time to go over the concepts of qubits, qutrits, and qudits—otherwise, what follows won’t make much sense. If you’re already familiar with quantum computing, feel free to skip ahead or just use this as a quick refresher.
Quantum Computing: Qubits and Qudits
One of the key differences between quantum and classical computers is the use of qubits instead of bits (and, at a deeper level, instead of transistors in microprocessors).
For example, x86 processors operate on bits (0 or 1). Each bit is the smallest unit of information in the binary system. Bits are grouped into larger structures—bytes (8 bits), words, and double words—to represent more complex data and instructions.
Qubits (quantum bits) are the fundamental units of quantum computation. Unlike classical bits, they can exist in a superposition of two states—|0⟩ and |1⟩—meaning they can be both 0 and 1 simultaneously, each with a certain probability. This property enables massive parallelism in computation.
At this point, you’ve essentially grasped the core idea of quantum superposition—the foundational principle behind quantum computing and what allows quantum systems to go beyond standard binary logic.
A more grounded way to think about it: imagine a system that can occupy multiple valid states at once until you measure it. While unobserved, it evolves as a combination of all those possibilities. The moment you perform a measurement, the system resolves into a single definite state.
There are also generalizations of qubits where more than two states are possible.
Qutrits and qudits extend this idea. A qutrit has three possible states: |0⟩, |1⟩, and |2⟩. A qudit can exist in N distinct states (where N is an integer greater than two). For example, a four-level qudit (sometimes called a “ququart”) can be in |0⟩, |1⟩, |2⟩, or |3⟩.
When a quantum computer has multiple qubits, things scale quickly. Instead of representing a single configuration, the system represents a superposition of all possible configurations simultaneously. This is what gives quantum computing its theoretical advantage.
When you measure the system, however, that superposition collapses into one specific configuration—this outcome is the result of the computation.
The number of possible states grows exponentially: a system of N qubits can represent 2^N basis states (for example, 00, 01, 10, 11 for two qubits). These states can exist in superposition, meaning the system encodes all 2^N possibilities at once. However, upon measurement, it collapses to a single state, yielding only N bits of classical information.
Beyond superposition, there’s another critical property: quantum entanglement.
Think of two particles whose states are intrinsically linked. Even if they are separated by large distances, the state of one immediately determines the state of the other. Interacting with one gives you information about the other instantly.
A simple analogy: imagine a pair of correlated objects prepared in such a way that if one is found in a particular state, the other must be in a complementary state. No matter how far apart they are, measuring one immediately tells you the state of the other.
In classical physics, this kind of behavior seems paradoxical. But in quantum mechanics, it’s a well-established phenomenon and a key resource for complex computations. Information in quantum systems is encoded not just in individual qubits, but in the correlations between entangled qubits.
This property enables coordinated behavior across qubits regardless of distance, forming the basis for many quantum algorithms and even quantum teleportation (which is about transferring quantum states, not physical objects).
Quantum superposition and entanglement are not about physical positions in space, but about possible states of a system and how those states interfere probabilistically.
In fact, many particles in the universe can become entangled, but this entanglement is typically destroyed almost immediately through interaction with the environment—a process known as decoherence. That’s why stable entanglement can only be maintained in highly controlled, isolated systems like quantum computers.
So, we’ve covered the basics: qubits instead of bits, superposition, entanglement, and state collapse upon measurement. Take a pause here—because in the next part, we’ll dive into the actual architecture of quantum computers.
