Every other qubit we meet is a piece of matter held painfully still — a superconducting loop chilled to a hair above absolute zero, an ion clamped in an electromagnetic trap. Photonic quantum computing makes a radical bet in the opposite direction: the qubit is a single particle of light, a lone photon flying through a chip at, quite literally, the speed of light. This is the approach pursued by companies like Xanadu and PsiQuantum, and it turns the usual engineering trade-off completely on its head.

A photon barely notices the world around it. It does not care about a stray magnetic field, it does not thermally jiggle, and it will happily race down an optical fibre for kilometres. So where a matter qubit fights a losing battle against decoherence, a photon has almost nothing to decohere against — its coherence is superb and it runs at room temperature. The catch, as we will see, is the flip side of that same coin: a particle that ignores its environment also ignores other photons, which makes them fiendishly hard to entangle. Let us see how photons measure up against the DiVincenzo criteria.

Where do you hide a bit inside a photon?

A photon is a rich little object, and there are several distinct properties you can use to store the two-level |0\rangle, |1\rangle of a qubit. The three standard encodings are:

• Polarisation. Encode |0\rangle as horizontal polarisation |H\rangle and |1\rangle as vertical |V\rangle. A diagonal photon is then a genuine superposition \tfrac{1}{\sqrt2}(|H\rangle + |V\rangle) — the two polarisations are the computational basis, and any polarisation in between is a point on the Bloch sphere (here it is called the Poincaré sphere).
• Path (dual-rail). Use two waveguides. A single photon in the top rail means |0\rangle; the same photon in the bottom rail means |1\rangle. A superposition is the photon travelling in both rails at once, \alpha|0\rangle + \beta|1\rangle = \alpha|\text{top}\rangle + \beta|\text{bottom}\rangle. One qubit costs two optical modes — hence "dual-rail".
• Time-bin. Split the possibilities across time: a photon in an early time slot is |0\rangle, a late one is |1\rangle. This is robust to the phase drift of long fibres, which is why it is a favourite for sending qubits down real-world optical networks.

All three are used in practice, and you can even convert between them. The important point is the same in every case: one photon carries one qubit, and the "state" is which property (which polarisation, which rail, which time slot) the single photon is in.

The easy part: single-qubit gates are just optics

Here is the great gift of photonics. To perform any single-qubit gate on a photon, you do not need a laser pulse timed to the nanosecond or a microwave drive — you need a piece of glass. Single-qubit gates are built from passive linear optics:

• a beamsplitter mixes two paths — for a dual-rail qubit this is exactly a rotation, the photonic Hadamard;
• a phase shifter (a slower patch of waveguide) delays one path, applying a relative phase — a Z-rotation;
• a waveplate rotates polarisation, doing the same job for a polarisation qubit.

These components are passive: they use no power, add essentially no noise, and are (ideally) lossless and perfectly coherent. A universal single-qubit gate is a fixed arrangement of two beamsplitters and a couple of phase shifters. Compare that with the delicate, calibration-hungry pulses a matter qubit demands, and you see why photonic single-qubit control is considered a solved problem.

Worked example: a waveplate as a Hadamard

Take a polarisation qubit that starts horizontal, |0\rangle = |H\rangle. A half-wave plate set at 22.5^\circ reflects the polarisation about that axis, rotating |H\rangle by 45^\circ to the diagonal state:

That is precisely the action of the Hadamard gate, H|0\rangle = |{+}\rangle — implemented by a single slab of birefringent crystal, no active control at all. Feed the diagonal photon back through the same plate and it returns to |H\rangle, mirroring H^2 = I. Every single-qubit gate you know has a static piece of glass that does it: rotate the waveplate's angle and you dial in any rotation on the Bloch sphere.

The hard part: photons refuse to talk to each other

A two-qubit entangling gate needs one qubit's state to condition what happens to another — the two must interact. For matter qubits this is the easy direction: charges and spins push on their neighbours all the time. For photons it is the nightmare. In ordinary linear optics two photons pass straight through each other as if the other were not there. Beamsplitters and phase shifters, no matter how you wire them, only ever produce single-photon rotations — you cannot build a deterministic CNOT out of "just two more beamsplitters", because none of those components let one photon's presence change another's evolution.

There are only two ways out, and both are hard:

• A strong optical nonlinearity. A special material whose response depends on photon number could make one photon shift another's phase (a "Kerr" interaction). But at the single-photon level such nonlinearities are vanishingly weak — far too weak for a clean gate.
• Measurement-induced interaction (KLM). The Knill–Laflamme–Milburn scheme performs an entangling gate without any material nonlinearity, using only linear optics, some extra ancilla photons, and measurement. The trick is that detecting the ancillas in the right pattern projects the remaining photons into an entangled state — the measurement itself supplies the nonlinearity. The price is that it is probabilistic: the gate only succeeds when the ancilla detectors fire the right way, so it works with some probability p < 1 and you must detect the herald and retry (or repair) when it fails.

So the fundamental asymmetry of photonic computing is this: one-qubit gates are trivial and deterministic; two-qubit gates are the whole ball game, and the best we have are heralded, probabilistic entangling operations.

The computing model: build a cluster, then measure it

If your entangling gate only fires probabilistically, running a long circuit gate-by-gate would stall the instant one gate failed. The photonic answer is to change the model entirely: measurement-based (cluster-state) quantum computing.

The idea splits computation into two phases:

• Build the resource. Offline, and as many times as it takes, use the probabilistic gates to stitch photons into one enormous entangled cluster state (a graph state). Because you can keep retrying the flaky gates until they succeed and only then glue the piece on, the probabilistic step is banished to the preparation stage.
• Compute by measuring. With the cluster ready, the entire computation is just a sequence of single-qubit measurements on its photons, each measurement's basis chosen using the previous outcomes. The entanglement is consumed to drive the logic — you never need a live two-qubit gate during the computation at all.

This is why photonic proposals talk endlessly about generating and fusing large entangled states: in this model, making the cluster is the machine, and running the program is just measuring it.

Picture: a photon on a chip

Here is a single dual-rail qubit as it would sit on a photonic chip: two waveguides, a beamsplitter and a phase shifter to perform single-qubit gates, and single-photon detectors at the end to read the answer. Everything in between is passive glass; the only "active" moment is the measurement. Step through it.

The real enemy: photon loss

Because photons scarcely decohere, the dominant error in photonic computing is not decoherence at all — it is loss. A photon can be absorbed in a waveguide, scattered at a junction, or simply missed by an imperfect detector, and then your qubit has literally vanished. Worse, loss compounds: if a photon survives each optical component with probability p, then after N components in a row its chance of still being there is

With p = 0.99 and a hundred components you are already down near 0.99^{100} \approx 0.37. This is why low-loss waveguides, high-efficiency single-photon sources, and near-unit-efficiency detectors are the central hardware challenges — and why photonic error correction is built to fight loss above all. Slide the transmission below and watch how fast the survival probability collapses as the circuit gets deeper.

Scoring photons against DiVincenzo

Mapping photons onto the DiVincenzo criteria shows a very lopsided report card:

• 1. Scalable qubits — photons are identical and cheap, but you need reliable single-photon sources on demand: a work in progress.
• 2. Initialisation — easy: prepare a photon in a definite polarisation, rail, or time slot.
• 3. Long coherence — outstanding. Photons barely interact with the environment, so coherence is excellent, at room temperature.
• 4. Universal gates — half-solved: single-qubit gates are trivial (linear optics), but two-qubit gates are only probabilistic (KLM), which is why the cluster-state model is used.
• 5. Measurement — a single-photon detector reads the qubit out; the main limit is detector efficiency (a face of the loss problem).
• 6 & 7. Flying qubits & faithful transmission — photons win outright. Light is the natural flying qubit; a photon in an optical fibre is exactly how you send quantum information between distant nodes.

In short: photons are mediocre-to-excellent at the "sit still and compute" criteria and simply the best available at the "move information around" criteria — which is why, even for people who bet on matter qubits for the processor, photons are the presumptive qubit of a future quantum internet.

Summary

Photonic qubits trade the coherence war for an interaction war. They are the natural flying qubit and run at room temperature, but their probabilistic entangling gates push the field toward measurement-based computing and a relentless fight against loss.