Write a qubit on a single photon and it flies down an optical fiber for free — the perfect quantum-network messenger. The catch is the same property that makes it fly: photons barely touch each other, so making two of them do a logic gate means abandoning the circuit model and computing by measurement. Here is how light became the field's best wire and its most awkward computer.
Part of the How to Build a Quantum Computer series.
The previous three posts were all, secretly, about the same struggle: how to hold a piece of matter still. A superconducting qubit is a circuit faking an atom, cooled to a whisker above absolute zero so it stops twitching. A trapped ion is a real atom you grab by its charge and levitate in vacuum. A neutral atom is a real atom you pinch in a knot of light. Each platform spends most of its engineering budget on the same verb — holding — because a qubit that drifts away forgets. This post is about the platform that gives up on holding entirely, and picks a qubit that refuses to sit still by its very nature: a single particle of light. A photonic qubit cannot be trapped, cooled, or pinned; it is always moving at, well, the speed of light. That sounds like a fatal flaw, and for one job — computing — it nearly is. But for the other job this series keeps watching, networking, it is the closest thing to a cheat code anyone has found.
It reads like the setup to a joke — computing with light that barely touches itself — so take it seriously: it is one of the strangest and most ingenious corners of the whole field.
Start, as always, with the two-level system. For a transmon it was a fabricated circuit; for an ion or a neutral atom it was two of a real atom’s internal levels. Here the qubit is carried by a single photon — one quantum of the electromagnetic field — and the cleverness is that a lone photon offers several pairs of distinguishable states to choose from. You pick any one pair, call them $\vert 0\rangle$ and $\vert 1\rangle$, and you have your bit riding on a particle that travels at the speed of light. The common “alphabets”:
Path, or dual-rail. Send the photon down one of two waveguides or fibers. “Photon in the upper rail” is $\vert 0\rangle$; “photon in the lower rail” is $\vert 1\rangle$. In Fock-state notation, with mode $a$ the upper rail and mode $b$ the lower, those are the states $\vert 10\rangle$ (one photon in $a$, none in $b$) and $\vert 01\rangle$. A general dual-rail qubit is
\[\vert\psi\rangle \;=\; \alpha\,\vert 10\rangle \;+\; \beta\,\vert 01\rangle ,\]a single photon in a superposition of which path it took. This is the encoding most on-chip photonic processors actually use, and the one the figures below assume.
Beyond these single-photon encodings sits a whole second philosophy — the continuous-variable route, which writes information into the quadratures of squeezed light (laser light whose quantum noise has been reshaped so that one property is quieter than the usual quantum limit, at the price of another being noisier). It forks into two machines worth keeping apart: a non-universal sampling cousin, Gaussian boson sampling, with no error correction at all, and a fault-tolerant, universal version that builds cluster states out of squeezed light and protects them with the Gottesman–Kitaev–Preskill (GKP) bosonic code. We meet both in the State-of-the-art section; for the story of how light computes, the single-photon dual-rail picture is the cleanest lens, so we lean on that.
Two things make the photonic qubit feel different from everything before it the moment you meet it. The first is a temperature joke. Because a photon flying through glass or a waveguide barely couples to anything, the optics run at room temperature — no dilution fridge, no vacuum cathedral. And yet the machine is not fridge-free, because the two hardest components are cold: the single-photon detectors (superconducting nanowires, SNSPDs) need cooling to a few kelvin, and many single-photon sources (semiconductor quantum dots) want roughly 4 K. So a “room-temperature quantum computer” still runs a cryostat — just for the bouncers at the door who count photons in and out. The light is warm; the things watching the light are frozen.
The second difference is deeper, and it reshapes the entire engineering problem: a photonic qubit’s dominant error is nothing like the others’. Superconducting and atomic qubits live in fear of decoherence — the slow leak of phase information into the environment, the $T_2$ clock ticking down. A photon in flight barely decoheres at all; it is gloriously isolated, which is exactly why it makes such a good messenger. Its weakness is blunter and more total: loss. A photon is either there or it is gone. Every fiber connector, every imperfect detector, every kilometer of glass has some chance of simply eating the photon — standard telecom fiber leaks about $0.2$ dB per kilometer — and when it does, the qubit does not slowly fade or pick up a small phase error. It vanishes, all at once. The slogan that organizes this entire platform is therefore: lose a photon, lose the qubit. Hold that thought; it is the hinge on which every later strength and cost turns.
Here is where the photon’s nature stops being charming and starts being a genuine problem.
Single-qubit gates are the easy, beautiful half. Take a dual-rail qubit — one photon, two paths. A beam splitter mixes the two paths, and a phase shifter delays one relative to the other. In the Heisenberg picture a beam splitter just transforms the two modes’ creation operators linearly into each other,
\[\hat a^\dagger \;\to\; \cos\theta\,\hat a^\dagger + e^{i\varphi}\sin\theta\,\hat b^\dagger , \qquad \hat b^\dagger \;\to\; -e^{-i\varphi}\sin\theta\,\hat a^\dagger + \cos\theta\,\hat b^\dagger ,\]and for a single photon that is a rotation on the Bloch sphere of ${\vert 10\rangle,\vert 01\rangle}$. One beam splitter alone is not quite enough for every gate, though: with only two knobs $(\theta,\varphi)$ it reaches a restricted family — note that both diagonal entries are the same $\cos\theta$, so a pure relative-phase (a $Z$ rotation) is off the menu. Add two phase shifters — making a Mach–Zehnder interferometer — and now you can reach any single-qubit gate you like, deterministically, with a “gate time” set by how long light takes to cross a single beam splitter or phase shifter: picoseconds. Single-qubit operations are where photons are happiest. On PsiQuantum’s silicon-photonic chips, dual-rail state preparation and measurement reach a fidelity of $99.98\%$
Two-qubit gates are where the trouble lives — and the trouble is fundamental physics, not bad engineering. To entangle two qubits you need them to interact: one qubit’s state has to change something about the other. But in linear optics, photons essentially do not interact. Two beams of light pass straight through each other and emerge unchanged; that is why you can see across a crowded room without the light rays scattering off one another. And here is the deep reason it cannot be patched: what a beam-splitter network does to a million photons is completely fixed by what it does to one — there is no extra knob, anywhere in the optics, that lets two photons feel each other. A deterministic entangling gate, a controlled-$Z$, say, demands exactly the kind of nonlinear coupling — a phase that depends on whether both qubits are excited — that single optical photons stubbornly refuse to provide. You cannot build a CZ out of mirrors and beam splitters. Full stop.
So how does anyone entangle light at all? Two great ideas, and they are the intellectual heart of this post.
Idea one: measurement-induced nonlinearity (the KLM scheme). Even though photons do not interact, measuring them can fake an interaction. The seed is Hong–Ou–Mandel interference
The beam splitter that produces this bunching is perfectly linear — nothing nonlinear has happened yet. The effective nonlinearity appears only once we count photons: the act of detecting a particular number in a particular port is what reaches back and reshapes the surviving state. In 2001, Knill, Laflamme, and Milburn turned this into a recipe: combine linear optics with ancillary “helper” photons, photon-number-resolving detectors, and feed-forward (using a detector’s click to choose what you do to the surviving photons), and you can implement a true entangling gate
Idea two: stop running a circuit at all — compute by measuring (cluster states and fusion). If gates are probabilistic and photons hate being stored, the whole “apply gate 1, then gate 2, then gate 3” picture is a bad fit. So photonics largely abandons it for a different model of computation entirely. In measurement-based quantum computing, due to Raussendorf and Briegel, you first build one big, highly entangled state — a cluster state, a lattice of qubits all linked together — and then you compute by measuring its qubits one at a time, choosing each measurement’s basis — by feed-forward — from earlier outcomes
The modern, hardware-minded refinement is fusion-based quantum computing (FBQC), introduced by Bartolucci and colleagues at PsiQuantum
Notice the through-line of both ideas: photonics buys determinism with numbers. Rather than hope one probabilistic gate or one fusion pays off, you build thousands in parallel and use fast optical switches to route the lucky successes onward. That brute-force-and-elegant strategy, multiplexing, is the master key of the platform — and, as we are about to see, the source of its heaviest bill.
Add up the photon’s virtues and a clear identity emerges: it is a so-so computer wrapped around a world-class network node. Four strengths, the last of which is the one that matters most for this series.
Room temperature. The optical core runs warm — no dilution fridge. Its only cold parts are the sources and detectors.
Almost no decoherence in flight. Because a flying photon is so weakly coupled to its surroundings, it does not gather phase errors the way a transmon or an atom does sitting in its trap — there is essentially no $T_2$ clock ticking down mid-flight. The qubit that is hardest to store is, paradoxically, one of the easiest to keep faithful while it travels.
Speed and manufacturability. Single-qubit gates happen at the speed of light crossing a chip, and the chips themselves can be made in a commercial silicon-photonics foundry. PsiQuantum fabricated its Omega chipset on a standard semiconductor line at GlobalFoundries and reported component fidelities — $99.98\%$ state preparation and measurement, $99.50\%$ two-photon interference visibility between independent sources, $99.22\%$ two-qubit fusion — that read like a mature platform, not a lab curiosity
It is born to network — the trump card. This is where the photon stops being a runner-up and becomes the obvious choice. Every other platform, to send quantum information across a room or a city, must first convert its qubit into a photon that can enter an optical fiber. For trapped ions and neutral atoms that conversion is at least natural — an atom can emit a photon entangled with its internal state — but it still has to be coaxed and collected. For superconducting qubits it is a near-disaster: their information lives in ~5 GHz microwave photons that cannot travel down an optical fiber at all, so they need a microwave-to-optical transducer, a translation box that today is lossy and immature. The photonic qubit skips the entire problem, because the qubit already is an optical photon. No conversion, no transducer — write your state on a telecom-band photon and drop it straight into off-the-shelf fiber. Consequently the core operations of a quantum network — quantum key distribution, teleportation, entanglement distribution, and the photonic link layer of the quantum repeaters that would tie distant nodes together (their memory half being the one part photons cannot supply) — are all native to photons rather than bolt-on tricks. Figure 3 makes the contrast literal.
PsiQuantum demonstrated this directly: a chip-to-chip entangling link distributed qubits across $42$ m of standard telecom fiber at $99.72\%$ fidelity
This is the lens the series keeps returning to. Of the five platforms, the photon may be the weakest stand-alone computer, yet it is the consensus best network node — because it never has to become a photon to travel. The debt is old and deep: the 2022 Nobel Prize in Physics went to Alain Aspect, John Clauser, and Anton Zeilinger for the experiments with entangled photons that turned Bell’s inequality from philosophy into measurable physics and founded quantum information science
Now settle the bill, because the same non-interaction that makes the photon a perfect messenger makes it an awkward computer, and the costs are as blunt as the strengths.
Loss is the enemy, and it is a different kind of enemy. Return to the slogan: lose a photon, lose the qubit. Where other platforms must keep their gate errors below a fault-tolerance threshold, photonics must keep its qubit disappearance rate below one — a tougher demand, because a lost photon is a whole missing qubit, not a small rotation error. There is one consolation: photon loss is an erasure error — you usually know which qubit went missing (its detector simply never clicked), and located errors are easier to correct than unlocated ones. Fusion-based architectures lean hard on exactly this, and Bartolucci and colleagues quote explicit per-component loss thresholds their codes can tolerate
Probabilistic gates mean staggering overhead. Multiplexing is clever, but at fault-tolerant scale the bookkeeping is sobering. Each logical operation rests on many probabilistic fusions; each fusion needs several resource states; each resource state needs several near-perfect single photons; and to make the probabilistic pieces behave deterministically you replicate everything many times over and switch between the successes. The honest estimate for a useful, universal photonic machine runs to millions of components — sources, beam splitters, switches, detectors, delay lines — all phase-stable and synchronized at once. And every one of those millions of components is another opportunity to lose a photon, which feeds straight back into the first problem.
No good memory, and a synchronization headache. A photon will not hold still, so “store this qubit for a moment while I wait for its partner” is genuinely hard. Today’s stopgap is almost comic: to delay a photon you send it on a longer trip — literally a loop of optical fiber as a delay line. Xanadu’s Aurora prototype carries about $13$ km of fiber for exactly this kind of timing and buffering
The components have to be nearly perfect — and some of them are cold. The whole scheme assumes near-deterministic single-photon sources (you want exactly one photon, on demand, every time) and high-efficiency detectors (you cannot afford to miss the photons you do have). Reality is closing the gap but is not there: among the best demonstrated, quantum-dot sources reach roughly $57\%$ end-to-end efficiency with $\sim97.5\%$ indistinguishability
The photonic scoreboard splits cleanly in two, and the single most important habit for reading it is the series’ golden rule, sharpened: do not mistake a few thousand photons for a few thousand qubits.
The boson-sampling lane — big numbers, narrow task. The headline “quantum advantage” results on this platform come from Gaussian boson sampling (GBS), a specialized experiment: inject squeezed light into a big interferometer and sample where the photons come out, a distribution believed hard to reproduce classically. USTC’s Jiuzhang 1.0 kicked it off in 2020 with up to $76$ detected photons and a claimed $\sim10^{14}$-fold speedup over classical simulation
The universal lane — small numbers, real architecture. Measured as programmable, universal machines, photonic processors are still tiny, and the field is refreshingly honest about it. Xanadu’s Aurora, published in Nature in 2025, is a $12$-qubit-scale prototype — but its form factor is the actual point: $35$ photonic chips across four fiber-networked server racks, $\sim13$ km of fiber, all at room temperature, stitching a cluster state across separate chips and running real-time measurement-based error correction
The players and their bets. PsiQuantum is pursuing fusion-based, silicon-photonics fault tolerance at foundry scale, betting on its Omega chipset and a manufacturing partnership to reach a million qubits
The three caveats that discipline every post in this series all reappear here in photonic dialect: photons in a sampler are not qubits in a computer, a fidelity quoted conditional on detection is not the same number once loss is counted, and a sampling advantage is one task, not a programmable machine.
A photonic qubit is the field’s flying messenger: not the strongest computer in the room, but the only qubit that travels by nature, and the consensus best node for a quantum network. Its strengths — room-temperature optics, near-zero in-flight decoherence, foundry manufacturing, and a qubit that drops straight into telecom fiber — and its matching weaknesses, itemized in the table below, are two readings of one fact: a photon barely interacts with anything, including the other photons you wish it would entangle with.
So the answer to this series’ recurring question is, for once, lopsided. Can it compute? Yes, in principle — KLM proved it, and fusion-based architectures give a credible, if enormous, blueprint — but today’s universal machines hold about a dozen qubits, and the road to a useful one runs through millions of near-perfect, low-loss components. Can it network? Better than anything else here. It does not need a transducer, it does not need to coax a photon out of an atom, it does not need to be collected from a cavity. It is the photon. Where the superconducting node’s honest answer was “not yet” and the atomic nodes’ was “natural” and “promising,” the photon’s is simply: it is the wire.
| Superconducting | Trapped ion | Neutral atom | Photonic | |
|---|---|---|---|---|
| Qubit | printed circuit (transmon) | a real atom (ion) | a real atom | a photon |
| Gate speed | very fast (~10–70 ns) | slow (~µs) | slow (~µs) | n/a (measurement) |
| Coherence | short (~0.1–1.7 ms) | very long (s–min) | long (s) | loss-limited |
| Connectivity | mostly nearest-neighbor | all-to-all | reconfigurable | hard (no interaction) |
| Operating temp | ~10 mK (dilution fridge) | room-temp vacuum | room-temp vacuum | room-temp optics (cold sources/detectors) |
| As a network node | needs transduction | natural (emits photons) | promising | it is the photon |
No platform wins every row — the whole reason five of them are still racing. Superconducting out-sprints decoherence; the trapped ion out-lasts and out-connects everyone; the neutral atom out-scales them; and the photon, last in this lineup for raw computing, is first and nearly uncontested for the one job none of the others can do without help — being the link that carries a qubit from one machine to the next. There is one route in this series still unbuilt — the platform that leaves light behind and returns to the solid state, to electron and nuclear spins in silicon and diamond, and to a quasiparticle that may not even exist. The sixth and final build: solid-state spins and the rest.
More in this series — How to Build a Quantum Computer: Superconducting · Trapped ion · Neutral atom · Photonic · Other platforms