A tour of the hardware

Everything in this course has treated a qubit as an abstract object — two-dimensional complex state space, gates, measurement. That’s deliberate: the algorithms work regardless of how the qubit is physically built. But “how do you actually build one?” is the engineering question that determines whether any of this ever becomes practical.

There are four mainstream physical implementations as of the mid-2020s, with several more in the research pipeline. Each has a distinct set of advantages and challenges. No single approach is obviously best — the field is genuinely uncertain which platform (or which combination) will win.

1. Superconducting qubits

How it works: A tiny loop of superconducting metal cooled to ~20 millikelvin (colder than outer space) carries persistent current without resistance. Careful arrangements of these loops plus a component called a Josephson junction create a two-level quantum system that behaves like an artificial atom. Microwave pulses on the order of 5 GHz perform gates.

Strengths:

• Gates are fast (10–100 nanoseconds).
• Qubits can be fabricated in 2D arrays using established chip manufacturing.
• Error rates are reaching the surface-code threshold ($\sim 10^{-3}$ per gate).

Challenges:

• Requires a dilution refrigerator the size of a refrigerator.
• Qubits are large (millimeter-scale) so scaling to millions is physically difficult.
• Coherence times are modest ($T_2 \sim$ 100 microseconds), limiting circuit depth.

Who: Google Quantum AI, IBM Quantum, Rigetti, Alice & Bob, AWS Center for Quantum Computing.

2. Trapped-ion qubits

How it works: Individual atoms (usually ytterbium, barium, or calcium ions) are held in place by electromagnetic fields in an ion trap inside a high-vacuum chamber. Laser pulses perform gates by driving electronic transitions of the ion. Each ion is a physical qubit.

Strengths:

• Extremely high gate fidelity — error rates below $10^{-4}$ have been demonstrated for single-qubit gates, and around $10^{-3}$ for two-qubit gates.
• Long coherence times (seconds or more, compared to microseconds for superconductors).
• All-to-all qubit connectivity within a single trap — any ion can interact with any other.

Challenges:

• Gate speeds are slower (microseconds to milliseconds).
• Scaling beyond ~100 ions in a single trap is hard; multi-trap architectures are an active research area.

Who: IonQ, Quantinuum, Oxford Ionics, academic groups worldwide.

3. Photonic qubits

How it works: Individual photons are the qubits; their polarization, path, or time bin encodes the $|0\rangle$ and $|1\rangle$ states. Gates are implemented by beam splitters, phase shifters, and nonlinear optical elements.

Strengths:

• Operates at room temperature (no refrigerator).
• Natural fit for quantum networking and communication (photons move through fiber optics easily).
• Effectively infinite coherence time — photons don’t decohere while flying through space.

Challenges:

• Deterministic two-qubit gates are very hard. Most approaches use probabilistic gates and “success heralding.”
• Photon loss is a major source of errors.
• Linear-optical quantum computing (LOQC) requires huge resource overhead compared to superconducting or ion approaches.

Who: PsiQuantum (aiming for silicon photonic fault tolerance), Xanadu (variational photonic quantum computing), Quandela.

4. Neutral-atom qubits

How it works: Individual neutral atoms (usually rubidium or cesium) are trapped by arrays of optical tweezers — tightly focused laser beams. Qubit states are encoded in atomic hyperfine levels. Rydberg interactions between atoms (where atoms are excited to very high-energy “Rydberg” states) implement two-qubit gates.

Strengths:

• Excellent scalability — arrays of 1000+ neutral atoms have been demonstrated.
• Coherence times of several seconds.
• Programmable connectivity by moving atoms in the trap array.
• A relatively new approach that has advanced rapidly (2020–2024).

Challenges:

• Two-qubit gates are still ~1% error rate, which is right at the threshold edge.
• Atom loss from the traps is a source of errors.
• Fault-tolerance on this platform is early-stage but promising.

Who: QuEra Computing, Pasqal, Atom Computing.

Other approaches (research / niche)

• Topological qubits (Microsoft): exotic particles called Majorana fermions would be intrinsically error-resistant, but no demonstration of a working qubit yet. The platform is still being characterized.
• Silicon spin qubits: individual electron or nuclear spins in silicon, potentially fabricated using standard semiconductor processes. Small-scale demonstrations exist.
• NV centers in diamond: nitrogen-vacancy defects in diamond used as room-temperature qubits. Mostly in quantum sensing applications, not computing.
• Bosonic codes (cavity qubits): a single electromagnetic cavity used as a qubit with built-in redundancy for error correction. Under active development.

What wins?

No one knows. As of 2026:

• Superconducting is the most mature and the most capital has flowed into it.
• Trapped ions hold the highest fidelities but struggle to scale.
• Neutral atoms look like the fastest-rising platform.
• Photonics is a dark horse that could dominate if the hard engineering problems are solved.

It may turn out that “fault-tolerant quantum computer” is a category with multiple winners, each best for different tasks. Much like classical computing, which has GPUs, TPUs, CPUs, FPGAs, and ASICs all coexisting, the quantum era may be heterogeneous too.

You’ve finished the course

This is the last lesson. Congratulations — you have a working mental model of all of quantum computing:

• Qubits, gates, superposition, measurement
• Entanglement and Bell states
• Teleportation and superdense coding
• The famous algorithms — Deutsch-Jozsa, Bernstein-Vazirani, Simon, Grover, QFT, Shor, VQE/QAOA
• Noise, error correction, and the surface code
• How real hardware is built

From here you have several directions to explore. You can pick up a proper textbook (Nielsen-Chuang is the canonical reference, but there are now friendlier options like Bernhardt’s Quantum Computing for Everyone or Hidary’s Quantum Computing: An Applied Approach). You can learn a real framework (Qiskit, Cirq, Q#, PennyLane) and run small circuits on actual quantum hardware through the cloud. You can read research papers — arxiv.org/list/quant-ph/new has the latest.

Or you can come back here and re-read any lesson. The widgets aren’t going anywhere.

Thank you for working through it. Go build something.