Skip to content
LumenaryAcademy
Frontier 85 min

Quantum hardware engineering

Qubits as engineered devices — superconducting transmons and their microwave electronics, dilution refrigerators, coherence, error correction below threshold, the other modalities, and an honest account of where the field stands in 2026.

Code tested · 5AI-draftedAwaiting review by an electrical engineer

Your guides: Chloe · The Physicist, Margaret · The Bench Engineer, Gideon · The Design Reviewer

MotivationH

A qubit is a device

Textbooks treat a qubit as an abstract two-level system, a vector in C2\mathbb{C}^2 acted on by unitary matrices (Lumenary Math's mathematical foundations of quantum mechanics develops that language). Engineers have to build one. A qubit must be isolated well enough that its quantum state survives, yet coupled well enough to be controlled and measured in nanoseconds; it must be manufacturable by the thousand with nearly identical properties; and every one must be wired, cooled or trapped, and controlled by classical electronics with exquisite timing. In 2000 David DiVincenzo listed what a quantum computer needs (DiVincenzo): scalable, well-characterised qubits; initialisation; long coherence compared with gate times; a universal set of gates; and measurement. Every item on that list is an electrical-engineering problem as much as a physics one.

This lesson takes the leading superconducting approach in depth — the circuit, the electronics, the refrigerator, the errors — then error correction, which is where the field's real progress since 2023 has been, the other platforms, and an honest assessment dated late 2026. You will use resonant circuits, transmission lines, the microwave techniques of AC and phasors and the coding ideas of Information and coding.

DefinitionsH

The transmon: an LC circuit with a nonlinear inductor

An LC resonator cooled near absolute zero is a quantum harmonic oscillator: its energy levels are equally spaced, En=(n+12)hfE_n = (n + \tfrac12) h f. That is useless as a qubit, because a pulse at frequency ff that drives the 0→10 \to 1 transition drives 1→21 \to 2, 2→32 \to 3 and so on just as well. To make a qubit you need anharmonicity: unequal spacings, so the lowest two levels can be addressed alone. Superconducting circuits get it from the Josephson junction.

Definition— Josephson junction

Two superconductors separated by a barrier about a nanometre thick (in practice aluminium, its oxide, and aluminium). Cooper pairs tunnel through it, and the current depends on the difference φ\varphi of the superconducting phases across it: I=Icsin⁡φI = I_c \sin\varphi, with V=Φ02πdφdtV = \frac{\Phi_0}{2\pi}\frac{d\varphi}{dt} where Φ0=h/2e\Phi_0 = h/2e is the flux quantum. Differentiating, V=Φ02πIccos⁡φdIdtV = \frac{\Phi_0}{2\pi I_c \cos\varphi}\frac{dI}{dt}: the junction is an inductor, LJ=Φ0/(2πIccos⁡φ)L_J = \Phi_0 / (2\pi I_c\cos\varphi), whose inductance depends on the current through it — a lossless nonlinear inductor.

A transmon (Koch et al., 2007) is a Josephson junction shunted by a large capacitor, typically two aluminium pads a fraction of a millimetre across on a silicon or sapphire chip. Its Hamiltonian, in terms of the number n^\hat n of Cooper pairs that have tunnelled and the phase φ^\hat\varphi, is

H^=4EC(n^−ng)2−EJcos⁡φ^,\hat H = 4E_C(\hat n - n_g)^2 - E_J\cos\hat\varphi,

where EC=e2/2CE_C = e^2/2C is the charging energy, EJ=Φ0Ic/2πE_J = \Phi_0 I_c / 2\pi the Josephson energy, and ngn_g a stray offset charge from the environment. The cosine is a pendulum's potential: for small φ\varphi it is a parabola (a harmonic oscillator) but it flattens further out, so the upper levels crowd together. The program computes EJE_J and ECE_C from device values, diagonalises H^\hat H in the charge basis, and then shows why transmons are built with EJ/EC≈50E_J/E_C \approx 50.

Cjunctionreadoutresonatordrive lineharmonic oscillatortransmon01230123f01f12
Left: a transmon is a Josephson junction (the boxed cross) shunted by a capacitor, coupled to a readout resonator and a drive line. Right: a harmonic oscillator has equally spaced levels; the transmon's levels crowd together, so a pulse at f01 does not also drive the 1→2 transition.
python
import numpy as np

h, e = 6.62607015e-34, 1.602176634e-19
PHI0 = h / (2 * e)                                  # flux quantum, Wb

# 1. From device parameters to energies: a junction with critical current Ic, shunted by C.
Ic, C = 30e-9, 80e-15                               # 30 nA, 80 fF (typical orders of magnitude)
L_J = PHI0 / (2 * np.pi * Ic)                       # Josephson inductance at zero bias
EJ = PHI0 * Ic / (2 * np.pi) / h                    # in hertz
EC = e**2 / (2 * C) / h
print(f"L_J = {L_J * 1e9:.1f} nH, E_J/h = {EJ / 1e9:.2f} GHz, E_C/h = {EC / 1e6:.0f} MHz, "
      f"E_J/E_C = {EJ / EC:.0f}")
print(f"if the junction were a linear inductor: f = 1/(2 pi sqrt(L_J C)) = "
      f"{1 / (2 * np.pi * np.sqrt(L_J * C)) / 1e9:.2f} GHz\n")

# 2. Diagonalise H = 4 E_C (n - n_g)^2 - E_J cos(phi) in the charge basis |n>, n = -N..N.
def transmon_levels(EJ, EC, ng=0.0, N=30, k=3):
    n = np.arange(-N, N + 1)
    H = np.diag(4 * EC * (n - ng) ** 2)
    off = -EJ / 2 * np.ones(2 * N)                  # cos(phi) couples n to n +/- 1
    H += np.diag(off, 1) + np.diag(off, -1)
    E = np.linalg.eigvalsh(H)
    return E[:k] - E[0]

E = transmon_levels(EJ, EC)
f01, f12 = E[1], E[2] - E[1]
print(f"this transmon: f01 = {f01 / 1e9:.3f} GHz, f12 = {f12 / 1e9:.3f} GHz, "
      f"anharmonicity = {(f12 - f01) / 1e6:.0f} MHz")
print(f"approximations: sqrt(8 EJ EC) - EC = {(np.sqrt(8 * EJ * EC) - EC) / 1e9:.3f} GHz, "
      f"anharmonicity ~ -EC = {-EC / 1e6:.0f} MHz\n")

# 3. Why E_J/E_C ~ 50: charge noise. Compare f01 at offset charge n_g = 0 and 0.5.
print(" EJ/EC   f01 (GHz)   anharmonicity (MHz)   charge dispersion of f01")
for ratio in (1, 5, 10, 20, 50, 100):
    ej = ratio * EC
    a = transmon_levels(ej, EC, 0.0)
    b = transmon_levels(ej, EC, 0.5)
    disp = abs(a[1] - b[1])
    print(f"  {ratio:4d}    {a[1] / 1e9:7.3f}       {(a[2] - 2 * a[1]) / 1e6:8.0f}            {disp:12.3e} Hz")

# 4. Why the fridge, and why attenuators: thermal photons at the qubit frequency, n = 1/(e^(hf/kT) - 1).
kB, f = 1.380649e-23, 5e9
def n_th(T):
    return 1 / np.expm1(h * f / (kB * T))
print("\nthermal photons at 5 GHz:", ", ".join(f"{T} K: {n_th(T):.2g}" for T in (300, 4, 0.1, 0.02)))
x = n_th(300)                                      # noise entering the control line at room temperature
for att_db, T in ((20, 4), (10, 0.8), (10, 0.1), (20, 0.02)):
    A = 10 ** (att_db / 10)
    x = x / A + (1 - 1 / A) * n_th(T)              # an attenuator at T passes 1/A and adds its own noise
    print(f"  after {att_db} dB at {T:5} K: {x:.3g} photons")
Runs entirely in your browser, in an isolated worker. Nothing is sent to a server.

With a 30 nA junction and 80 fF of capacitance, EJ/EC≈62E_J/E_C \approx 62: the qubit frequency is 5.12 GHz and the 1→21 \to 2 transition sits 273 MHz lower, so a pulse tuned to f01f_{01} and a few nanoseconds long addresses only the qubit. The approximation 8EJEC−EC\sqrt{8E_JE_C} - E_C is within 12 MHz, and the anharmonicity is close to −EC-E_C. The middle table is the transmon's design trade-off. At small EJ/ECE_J/E_C (the original Cooper-pair box) the anharmonicity is large but f01f_{01} shifts by hundreds of megahertz as stray charges move, which destroys coherence; by EJ/EC=50E_J/E_C = 50 that charge sensitivity has fallen exponentially, to about 10 kHz, while the anharmonicity has fallen only slowly. The last lines are about the refrigerator, and come back below.

ExplanationH

Control, readout and the refrigerator

Control. A single-qubit gate is a shaped microwave pulse at the qubit frequency, typically 10–50 ns long. Room-temperature electronics synthesise it: fast digital-to-analogue converters generate in-phase and quadrature envelopes that are mixed up to 4–8 GHz (or, increasingly, synthesised directly by radio-frequency data converters), with pulse shapes such as DRAG that suppress leakage to level 2. Two-qubit gates use couplers, often themselves tunable by magnetic flux, driven by precisely shaped baseband pulses. The pulse sequencers are FPGA-based, from vendors such as Zurich Instruments, Quantum Machines, Qblox and Keysight, and open-source projects such as Fermilab's QICK on AMD's RFSoC devices (QICK).

Readout. Each transmon is coupled to its own microwave resonator, whose frequency shifts by a small amount depending on whether the qubit is in ∣0⟩|0\rangle or ∣1⟩|1\rangle (dispersive readout). A probe tone sent through the resonator returns with a state-dependent phase; it is amplified first by a near-quantum-limited parametric amplifier (often a travelling-wave parametric amplifier built from Josephson junctions) at the coldest stage, then by a cryogenic HEMT transistor amplifier at about 4 K, then digitised and classified, all in a few hundred nanoseconds. Many resonators at different frequencies share one readout line, multiplexed in frequency like the WDM channels of Photonics.

Cold. A 5 GHz photon has energy hfhf equivalent to about 240 mK. To keep the qubit in its ground state and its environment quiet, transmons operate in a dilution refrigerator at about 10–20 mK. Below a few kelvin such a refrigerator cools by dissolving helium-3 into helium-4, a process that absorbs heat; a pulse-tube cryocooler handles the stages down to about 3–4 K. The stages sit on nested plates — roughly 50 K, 4 K, about 1 K (the "still"), about 100 mK and the mixing chamber at about 10 mK — and the available cooling power falls from watts at 4 K to of order ten microwatts at 20 mK. Bluefors in Finland is the largest supplier, among several in Europe, North America and Asia.

300 K50 K4 K~1 K (still)~100 mK~10 mKqubit chipattenuatorsHEMT amplifierparametric amplifiercontrol inreadout out
A dilution refrigerator's stages with one control line and one readout line (simplified). Attenuators on each stage remove thermal noise coming down the control line; the readout signal goes up through isolators, a parametric amplifier at the coldest stage and a HEMT amplifier at 4 K.

Wiring. Every control line is a path for heat and for noise. A coaxial cable from room temperature carries the thermal noise of a 300 K resistor: the first program's last lines compute about 1,200 thermal photons per mode at 5 GHz at 300 K, against 0.000006 at 20 mK. So each line has attenuators bolted to successive stages, each absorbing the noise from above and re-emitting only the noise of its own, colder temperature; the program's chain of 60 dB in total brings the noise down to about 0.006 photons. Each line also conducts heat, so a refrigerator can accommodate only some hundreds to a few thousand lines — and a processor of a million physical qubits cannot be wired this way. That is the case for cryo-CMOS: control and readout electronics made in ordinary CMOS, operated at 4 K or below, close to the qubits (Intel, Google, and university groups have all demonstrated such controllers), and for multiplexing, flexible superconducting cables and, eventually, optical links into the cryostat.

ComputationC

Coherence: T1, T2 and Rabi oscillations

Definition— T1 and T2

T1T_1 (energy relaxation time) is the time constant with which a qubit prepared in ∣1⟩|1\rangle decays to ∣0⟩|0\rangle, by giving its energy to the environment. T2T_2 (coherence time) is the time constant with which a superposition loses its definite phase: it includes relaxation and pure dephasing from fluctuations of the qubit frequency, with T2≤2T1T_2 \le 2T_1. T2T_2 measured by a Ramsey experiment (T2∗T_2^*) includes slow frequency drifts that a spin-echo sequence can refocus.

For transmons in good processors in 2024–26, T1T_1 is typically one to a few hundred microseconds, and the best research devices, made with tantalum films and cleaner substrates, have reached around a millisecond. Gate times are tens of nanoseconds, so a qubit lives for thousands of gates; but a useful algorithm needs millions or more, which is the reason for error correction. The losses are mostly materials science: two-level defects in amorphous oxides at the metal surfaces and interfaces, quasiparticles (broken Cooper pairs) created by stray infrared light and even by cosmic rays and natural radioactivity, and radiation into the package.

Driving a qubit with a resonant microwave makes it oscillate between ∣0⟩|0\rangle and ∣1⟩|1\rangle — Rabi oscillations. Calibrating a gate starts by measuring them: a π pulse is the drive that turns ∣0⟩|0\rangle into ∣1⟩|1\rangle. In the frame rotating with the drive, the Hamiltonian is H^=ℏ2(Δ σ^z+Ω σ^x)\hat H = \tfrac{\hbar}{2}(\Delta\,\hat\sigma_z + \Omega\,\hat\sigma_x), with Rabi frequency Ω\Omega and detuning Δ\Delta. The program integrates the Lindblad master equation, which evolves the qubit's density matrix under H^\hat H while relaxation and dephasing act on it, with coherence times deliberately shortened so the decay is visible in two microseconds.

python
import numpy as np

# A driven qubit in the frame rotating with the drive: H = (Delta/2) sz + (Omega/2) sx  (hbar = 1).
# Basis order (|0>, |1>), with |1> the excited state.
sx = np.array([[0, 1], [1, 0]], dtype=complex)
sz = np.array([[-1, 0], [0, 1]], dtype=complex)
lower = np.array([[0, 1], [0, 0]], dtype=complex)     # |1> -> |0>: energy relaxation

def rabi(Omega, Delta, T1, T2, t_end, steps=4000):
    """Integrate the Lindblad master equation with RK4; return times and P(|1>)."""
    H = 0.5 * Delta * sz + 0.5 * Omega * sx
    g1 = 1 / T1                                       # energy relaxation
    gphi = 1 / T2 - 1 / (2 * T1)                      # pure dephasing
    L_ops = [np.sqrt(g1) * lower, np.sqrt(gphi / 2) * sz]
    def f(r):
        d = -1j * (H @ r - r @ H)
        for L in L_ops:
            d += L @ r @ L.conj().T - 0.5 * (L.conj().T @ L @ r + r @ L.conj().T @ L)
        return d
    dt = t_end / steps
    r = np.array([[1, 0], [0, 0]], dtype=complex)     # start in |0>
    ts, p1 = [0.0], [0.0]
    for k in range(steps):
        k1 = f(r); k2 = f(r + dt / 2 * k1); k3 = f(r + dt / 2 * k2); k4 = f(r + dt * k3)
        r = r + dt / 6 * (k1 + 2 * k2 + 2 * k3 + k4)
        ts.append((k + 1) * dt); p1.append(r[1, 1].real)
    return np.array(ts), np.array(p1)

us = 1e-6
Omega = 2 * np.pi * 5e6                               # Rabi frequency 5 MHz
print(f"pi pulse (|0> -> |1>) lasts {np.pi / Omega * 1e9:.0f} ns at a 5 MHz Rabi frequency\n")

# Deliberately short coherence times so the decay shows within 2 microseconds.
t, p_res = rabi(Omega, 0.0, T1=2 * us, T2=1.5 * us, t_end=2 * us)
t, p_det = rabi(Omega, 2 * np.pi * 5e6, T1=2 * us, T2=1.5 * us, t_end=2 * us)

print("P(|1>) on resonance (#) and detuned by 5 MHz (o), first 500 ns:")
for i in range(0, 1001, 40):
    bar = [" "] * 41
    bar[int(round(40 * p_det[i]))] = "o"
    bar[int(round(40 * p_res[i]))] = "#"
    print(f"{t[i] * 1e9:6.0f} ns |{''.join(bar)}|")
print(f"\nmax P(|1>) detuned: {p_det[:400].max():.2f}  (ideal Omega^2/(Omega^2+Delta^2) = 0.50)")
first, last = p_res[t <= 0.2 * us], p_res[t >= 1.8 * us]
print(f"on resonance, swing of P(|1>) in the first 200 ns: {first.max() - first.min():.2f}; "
      f"from 1.8 to 2.0 us: {last.max() - last.min():.2f}")
Runs entirely in your browser, in an isolated worker. Nothing is sent to a server.

On resonance (#), the population swings fully from 0 to 1 and back every 200 ns, so a 5 MHz drive gives a 100 ns π pulse. Detuned by 5 MHz (o), the oscillation is faster — at the generalised Rabi frequency Ω2+Δ2\sqrt{\Omega^2 + \Delta^2} — and reaches only about half way, Ω2/(Ω2+Δ2)\Omega^2/(\Omega^2 + \Delta^2). That is how experimenters find a qubit's frequency: sweep the drive and look for the slowest, fullest oscillation. Decoherence shrinks the on-resonance swing from 0.97 in the first 200 ns to 0.34 after 1.8 µs.

ComputationC

Error correction and the surface code

The threshold theorem says that if every physical operation fails with probability below some threshold pthp_{th}, errors can be corrected faster than they accumulate, and arbitrarily long computations become possible with a resource overhead that grows only polylogarithmically with the computation's length. Quantum error correction cannot simply copy states (the no-cloning theorem forbids it), and it must catch phase errors as well as bit flips, so it spreads one logical qubit over many physical ones and repeatedly measures stabilisers — multi-qubit parity checks that reveal errors without revealing the encoded state.

The workhorse for superconducting chips is the surface code (Fowler et al., 2012): data qubits on a square grid, with measurement qubits between them checking the parity of their four neighbours, alternately in the ZZ and XX bases. It needs only nearest-neighbour connections and tolerates physical error rates up to roughly 1%. A distance-dd patch uses d2d^2 data qubits and d2−1d^2 - 1 measurement qubits and corrects any ⌊(d−1)/2⌋\lfloor (d-1)/2 \rfloor errors. A classical decoder must interpret the stream of parity results in real time, about a million rounds per second — itself a hard computing problem.

Below threshold, each increase of the distance by 2 divides the logical error rate by a factor Λ (lambda); above threshold, larger codes make things worse. The program shows both behaviours in the simplest code, then uses Λ to estimate what a useful logical qubit costs.

python
import math

# 1. The simplest code: a distance-d repetition code against bit flips, decoded by majority vote.
#    It fails when more than half of the d copies flip (each independently with probability p).
def repetition_failure(d, p):
    return sum(math.comb(d, k) * p**k * (1 - p)**(d - k) for k in range(d // 2 + 1, d + 1))

print("repetition code, logical error vs distance")
print("   p      d=1        d=3        d=5        d=7        d=9")
for p in (0.01, 0.1, 0.3, 0.5, 0.6):
    print(f"  {p:4.2f}  " + "  ".join(f"{repetition_failure(d, p):9.2e}" for d in (1, 3, 5, 7, 9)))

# 2. The surface code below threshold: each step d -> d + 2 divides the logical error by Lambda.
#    Start from a measured point: about 0.143% per cycle at d = 7 with Lambda about 2.14 (Google, 2024).
def logical_error(d, eps7=1.43e-3, lam=2.14):
    return eps7 / lam ** ((d - 7) / 2)

def distance_for(target, lam, eps7=1.43e-3):
    d = 7
    while logical_error(d, eps7, lam) > target:
        d += 2
    return d

print("\nsurface code: distance and physical qubits (2d^2 - 1) per logical qubit")
print("  target per cycle   Lambda=2.14          Lambda=4             Lambda=10")
for target in (1e-6, 1e-9, 1e-12):
    cells = []
    for lam in (2.14, 4.0, 10.0):
        d = distance_for(target, lam)
        cells.append(f"d={d:3d}, {2 * d * d - 1:6d}")
    print(f"     {target:7.0e}       " + "    ".join(cells))
Runs entirely in your browser, in an isolated worker. Nothing is sent to a server.

For the repetition code under independent bit flips the threshold is p=0.5p = 0.5: at p=0.01p = 0.01 each step in distance cuts the logical error about thirtyfold, at 0.30.3 only slightly, at 0.50.5 not at all, and at 0.60.6 larger codes are worse. In December 2024 Google Quantum AI reported surface-code memories of distance 3, 5 and 7 on its 105-qubit Willow processor with Λ≈2.14\Lambda \approx 2.14 and a distance-7 logical error of about 0.143% per correction cycle, a logical qubit that outlived its best physical qubit, with real-time decoding (Google Quantum AI, 2024) — the first convincing demonstration of the surface code below threshold, following a 2023 result in which distance 5 had only just beaten distance 3 (2022 preprint). The lower table is the sobering part: at that Λ, a logical error rate of 10−1210^{-12} per cycle — the regime of large algorithms — needs distance 63, nearly 8,000 physical qubits per logical qubit. Raising Λ to 10, by lowering physical error rates, brings it to under 1,500. Error rates, not qubit counts alone, decide the size of a fault-tolerant machine.

Other codes trade connectivity for efficiency. IBM's quantum low-density parity-check (qLDPC) codes, such as its "gross" bivariate-bicycle code (Bravyi et al.), encode 12 logical qubits in 144 data qubits (plus as many check qubits) with protection comparable to much larger surface codes, but need longer-range couplers; IBM's published roadmap builds towards a fault-tolerant machine of about 200 logical qubits, "Starling", by 2029 (IBM). AWS's Ocelot chip (2025) builds on cat qubits, oscillator states engineered so that bit flips are exponentially suppressed, leaving mainly phase flips to correct (Putterman et al.).

ExplanationH

Other ways to build a qubit

No platform has won, and each has a different engineering profile:

PlatformQubitStrengthsEngineering difficulties
Superconducting circuitstransmons and variants on a chip at ~10 mKfast gates (tens of ns), lithographic fabrication, the most mature error-correction demonstrationsshort coherence, wiring and cooling at scale, materials defects, fixed nearest-neighbour coupling
Trapped ionsinternal states of ions (e.g. ytterbium, barium) held by electric fields in vacuumthe highest gate fidelities (two-qubit gates around 99.9%), identical qubits, all-to-all connectivity by moving ionsslow gates (tens to hundreds of µs), many lasers or precise microwave control, scaling ion traps beyond hundreds of qubits
Neutral atomsatoms (rubidium, caesium, ytterbium) in arrays of optical tweezers, entangled via Rydberg stateslarge arrays (thousands of atoms), qubits that can be moved mid-computationatom loss, slower cycles, laser power and stability
Photonsmodes of light in integrated optical circuitsroom-temperature components, networking, fastphoton loss; deterministic two-photon gates are impossible, so schemes rely on measurement and huge numbers of components
Spin qubitssingle electron or hole spins in silicon or germanium quantum dotstiny, potentially made in CMOS fabs, some able to operate at around 1 Kvariability between devices, crosstalk, wiring density

Milestones worth knowing, each from the groups' own papers: Harvard, MIT and QuEra ran algorithms on up to 48 logical qubits encoded in neutral atoms (Bluvstein et al., 2023), and a Caltech group trapped over 6,100 atomic qubits in one tweezer array (Manetsch et al., 2024); Microsoft and Quantinuum showed trapped-ion logical qubits with error rates far below the physical ones (da Silva et al., 2024), and Quantinuum's 98-qubit Helios system, launched in 2025, reports two-qubit fidelities of about 99.92% (Quantinuum, 2025); spin qubits made on 300 mm CMOS lines by Intel, imec and others are moving from lab to foundry processes; and photonic companies such as PsiQuantum and Xanadu are building large fabrication and assembly programmes. Microsoft's topological approach reported a parity measurement in 2025 (Microsoft), but the published paper does not itself establish the Majorana modes that topological qubits require, and the claim remains contested.

ExplanationH

The state of the field, late 2026

An honest summary, dated November 2026:

  • What is real. Error correction now works as theory predicted: several groups, on several platforms, have shown logical qubits whose errors fall as codes grow, and through 2026 further results — from Quantinuum's Helios, IBM's qLDPC programme, Chinese groups' superconducting processors and others — have appeared, many first as preprints and press releases still being assessed. Physical gate fidelities of 99.9% are routine on the best systems.
  • What is not yet real. No quantum computer has yet run a commercially useful computation that a classical computer could not. Claims of "beyond-classical" results since 2019 have been real scientific achievements on carefully chosen sampling and simulation tasks, but several were later matched by improved classical algorithms, and their usefulness is limited. The useful applications most experts expect first — simulating molecules and materials, then factoring and other cryptanalysis — need fault-tolerant machines with hundreds to thousands of logical qubits and billions of logical operations.
  • What the roadmaps say. IBM, Google, Quantinuum, QuEra, PsiQuantum and others publish roadmaps aiming at fault-tolerant machines of a hundred or more logical qubits around 2029–2030 (IBM; Google). Roadmaps have slipped before; treat them as engineering plans, not forecasts.
  • What engineers work on. Materials and fabrication yield, cryogenic and room-temperature electronics, wiring, real-time decoding (often on FPGAs and ASICs), modular links between refrigerators or traps, and the classical control software — a large and growing share of quantum engineering is classical electrical engineering.

The most immediate practical consequence is defensive: because encrypted data recorded today could be decrypted by a future machine, governments and companies are already migrating to post-quantum cryptography (Lumenary CS's applied cryptography describes the new standards).

Common misconceptionsH

Common misconceptions

Misconception

"More qubits means a more powerful quantum computer." A thousand noisy qubits without error correction can do less useful work than a few hundred good ones. What matters is the error rate, connectivity and speed — and, for fault tolerance, how many logical qubits the machine supports and how many logical operations it can run.

Misconception

"Quantum computers try every answer at once." A quantum computer manipulates amplitudes, which can interfere; a measurement returns one outcome. Speed-ups come only from algorithms that arrange for wrong answers to cancel and right ones to reinforce, and such algorithms are known for particular problems, not for everything.

Misconception

"The refrigerator is just a freezer." It is a precision instrument and a large part of the engineering: its cooling power at 10 mK, the heat load of every cable, vibration from the pulse tube, magnetic shielding and the infrared light that leaks down the wiring all limit what the qubits can do.

Exercises

Exercises

1. Quantum hardware engineering

Warm-upHuman

A Josephson junction has a critical current of 20 nA. What is its Josephson inductance at zero bias, LJ=Φ0/(2πIc)L_J = \Phi_0 / (2\pi I_c), to the nearest nanohenry? (Φ0=h/2e≈2.068×10−15\Phi_0 = h/2e \approx 2.068 \times 10^{-15} Wb.)

2. Quantum hardware engineering

Warm-upHuman

A transmon has a frequency of 6 GHz. At what temperature, in millikelvin, does kBTk_B T equal the energy hfhf of one photon at that frequency? Round to the nearest millikelvin (h=6.626×10−34h = 6.626 \times 10^{-34} J s, kB=1.381×10−23k_B = 1.381 \times 10^{-23} J/K).

3. Quantum hardware engineering

Warm-upHuman

A resonant drive produces Rabi oscillations at a Rabi frequency Ω/2π=20\Omega/2\pi = 20 MHz (one full cycle ∣0⟩→∣1⟩→∣0⟩|0\rangle \to |1\rangle \to |0\rangle every 50 ns). How long, in nanoseconds, is a π pulse?

4. Quantum hardware engineering

CoreComputational

Write transmon(EJ, EC, ng=0.0, N=30) that builds the transmon Hamiltonian H=4EC(n−ng)2−EJcos⁡φH = 4E_C(n - n_g)^2 - E_J\cos\varphi in the charge basis n=−N,…,Nn = -N, \dots, N (the cosine couples nn to n±1n \pm 1 with matrix element −EJ/2-E_J/2), diagonalises it with np.linalg.eigvalsh, and returns (f01, alpha): the 0→1 transition energy and the anharmonicity (E2−E1)−(E1−E0)(E_2 - E_1) - (E_1 - E_0), in the same units as EJ and EC (for example GHz).

Runs entirely in your browser, in an isolated worker. Nothing is sent to a server.

5. Quantum hardware engineering

CoreComputational

Write distance_needed(eps3, lam, target) returning (d, qubits): the smallest odd distance d≥3d \geq 3 at which a surface code's logical error per cycle is at most target, if the error at d=3d = 3 is eps3 and each increase of dd by 2 divides it by lam; and the number of physical qubits in one distance-dd patch, 2d2−12d^2 - 1.

Runs entirely in your browser, in an isolated worker. Nothing is sent to a server.

6. Quantum hardware engineering

CoreHuman

Why are transmons designed with EJ/ECE_J/E_C of roughly 50, rather than near 1 as in the earlier Cooper-pair box?

Choose one

7. Quantum hardware engineering

CoreHuman

Which of these statements about Google's 2024 surface-code experiment on its Willow processor are accurate? Enter the letters.

  • A. The logical error per cycle fell as the code distance increased from 3 to 5 to 7, by a factor Λ\Lambda of about 2 per step.
  • B. The distance-7 logical qubit outlived the best physical qubit on the chip.
  • C. The experiment factored a number that classical computers cannot factor.
  • D. The processor had 105 physical qubits.
  • E. It showed that physical error rates no longer matter once error correction works.

Write elements separated by commas. Order and repeats don’t matter — just like in a set!

Further reading and resources