A qubit is a device
Textbooks treat a qubit as an abstract two-level system, a vector in 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.
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, . That is useless as a qubit, because a pulse at frequency that drives the transition drives , 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 of the superconducting phases across it: , with where is the flux quantum. Differentiating, : the junction is an inductor, , 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 of Cooper pairs that have tunnelled and the phase , is
where is the charging energy, the Josephson energy, and a stray offset charge from the environment. The cosine is a pendulum's potential: for small it is a parabola (a harmonic oscillator) but it flattens further out, so the upper levels crowd together. The program computes and from device values, diagonalises in the charge basis, and then shows why transmons are built with .
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")With a 30 nA junction and 80 fF of capacitance, : the qubit frequency is 5.12 GHz and the transition sits 273 MHz lower, so a pulse tuned to and a few nanoseconds long addresses only the qubit. The approximation is within 12 MHz, and the anharmonicity is close to . The middle table is the transmon's design trade-off. At small (the original Cooper-pair box) the anharmonicity is large but shifts by hundreds of megahertz as stray charges move, which destroys coherence; by 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.
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 or (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 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.
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.
Coherence: T1, T2 and Rabi oscillations
Definition— T1 and T2
(energy relaxation time) is the time constant with which a qubit prepared in decays to , by giving its energy to the environment. (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 . measured by a Ramsey experiment () includes slow frequency drifts that a spin-echo sequence can refocus.
For transmons in good processors in 2024–26, 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 and — Rabi oscillations. Calibrating a gate starts by measuring them: a π pulse is the drive that turns into . In the frame rotating with the drive, the Hamiltonian is , with Rabi frequency and detuning . The program integrates the Lindblad master equation, which evolves the qubit's density matrix under while relaxation and dephasing act on it, with coherence times deliberately shortened so the decay is visible in two microseconds.
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}")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 — and reaches only about half way, . 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.
Error correction and the surface code
The threshold theorem says that if every physical operation fails with probability below some threshold , 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 and bases. It needs only nearest-neighbour connections and tolerates physical error rates up to roughly 1%. A distance- patch uses data qubits and measurement qubits and corrects any 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.
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))For the repetition code under independent bit flips the threshold is : at each step in distance cuts the logical error about thirtyfold, at only slightly, at not at all, and at 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 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 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.).
Other ways to build a qubit
No platform has won, and each has a different engineering profile:
| Platform | Qubit | Strengths | Engineering difficulties |
|---|---|---|---|
| Superconducting circuits | transmons and variants on a chip at ~10 mK | fast gates (tens of ns), lithographic fabrication, the most mature error-correction demonstrations | short coherence, wiring and cooling at scale, materials defects, fixed nearest-neighbour coupling |
| Trapped ions | internal states of ions (e.g. ytterbium, barium) held by electric fields in vacuum | the highest gate fidelities (two-qubit gates around 99.9%), identical qubits, all-to-all connectivity by moving ions | slow gates (tens to hundreds of µs), many lasers or precise microwave control, scaling ion traps beyond hundreds of qubits |
| Neutral atoms | atoms (rubidium, caesium, ytterbium) in arrays of optical tweezers, entangled via Rydberg states | large arrays (thousands of atoms), qubits that can be moved mid-computation | atom loss, slower cycles, laser power and stability |
| Photons | modes of light in integrated optical circuits | room-temperature components, networking, fast | photon loss; deterministic two-photon gates are impossible, so schemes rely on measurement and huge numbers of components |
| Spin qubits | single electron or hole spins in silicon or germanium quantum dots | tiny, potentially made in CMOS fabs, some able to operate at around 1 K | variability 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.
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 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
1. Quantum hardware engineering
Warm-upHumanA Josephson junction has a critical current of 20 nA. What is its Josephson inductance at zero bias, , to the nearest nanohenry? ( Wb.)
2. Quantum hardware engineering
Warm-upHumanA transmon has a frequency of 6 GHz. At what temperature, in millikelvin, does equal the energy of one photon at that frequency? Round to the nearest millikelvin ( J s, J/K).
3. Quantum hardware engineering
Warm-upHumanA resonant drive produces Rabi oscillations at a Rabi frequency MHz (one full cycle every 50 ns). How long, in nanoseconds, is a π pulse?
4. Quantum hardware engineering
CoreComputationalWrite transmon(EJ, EC, ng=0.0, N=30) that builds the transmon Hamiltonian in the charge basis (the cosine couples to with matrix element ), diagonalises it with np.linalg.eigvalsh, and returns (f01, alpha): the 0→1 transition energy and the anharmonicity , in the same units as EJ and EC (for example GHz).
5. Quantum hardware engineering
CoreComputationalWrite distance_needed(eps3, lam, target) returning (d, qubits): the smallest odd distance at which a surface code's logical error per cycle is at most target, if the error at is eps3 and each increase of by 2 divides it by lam; and the number of physical qubits in one distance- patch, .
6. Quantum hardware engineering
CoreHumanWhy are transmons designed with of roughly 50, rather than near 1 as in the earlier Cooper-pair box?
7. Quantum hardware engineering
CoreHumanWhich 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 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.
Further reading and resources
- The physical implementation of quantum computation · D. P. DiVincenzo · 2000
- Charge-insensitive qubit design derived from the Cooper pair box · J. Koch et al. · 2007The paper that introduced the transmon.
- A quantum engineer's guide to superconducting qubits · P. Krantz et al. · 2019
- Surface codes: towards practical large-scale quantum computation · A. G. Fowler, M. Mariantoni, J. M. Martinis, A. N. Cleland · 2012
- Suppressing quantum errors by scaling a surface code logical qubit · Google Quantum AI · 2022
- Quantum error correction below the surface code threshold · Google Quantum AI and collaborators · 2024
- Logical quantum processor based on reconfigurable atom arrays · D. Bluvstein et al. · 2023
- Demonstration of logical qubits and repeated error correction with better-than-physical error rates · M. P. da Silva et al. (Microsoft and Quantinuum) · 2024
- Helios: a 98-qubit trapped-ion quantum computer · Quantinuum · 2025
- A tweezer array with 6100 highly coherent atomic qubits · H. J. Manetsch et al. · 2024
- High-threshold and low-overhead fault-tolerant quantum memory · S. Bravyi et al. (IBM) · 2023
- Hardware-efficient quantum error correction via concatenated bosonic qubits · H. Putterman et al. (AWS) · 2024
- Interferometric single-shot parity measurement in InAs–Al hybrid devices · Microsoft Azure Quantum · 2025
- The QICK (Quantum Instrumentation Control Kit): readout and control for qubits and detectors · L. Stefanazzi et al. · 2021
- QICK on GitHub
- IBM: a path to large-scale fault-tolerant quantum computing · IBM Quantum · 2025
- Google Quantum AI roadmap
- How to factor 2048 bit RSA integers with less than a million noisy qubits · C. Gidney · 2025