Quantum repeaters

Four operations used by 1G and 2G

A repeater chain is a sequence of nodes $N_0,N_1,\dots ,N_n$ (with Alice at $N_0$ and Bob at $N_n$) connected by short fibre segments of length $L_0$ each. Within that chain, 1G and 2G both use the same four operations:

1. Heralded entanglement generation (HEG). Each adjacent pair $(N_k,N_{k+1})$ runs HEG — typically photonic, with the heralding signal announced over a classical channel. On success, the two nodes share a Bell pair stored in their local quantum memories; on failure, they retry.
2. Heralded entanglement purification (HEP). Operation errors and channel noise drop Bell-pair fidelity. HEP repairs it: two low-fidelity pairs in, one higher-fidelity pair out, with classical post-selection on local measurement outcomes ^{Bennett et al. 1996} .
3. Quantum memory. Each node holds its half of a successful pair while waiting for its other neighbour's pair to herald (or for a purification round to complete). Memory coherence time bounds how unsynchronised the link-level successes can be before the stored pair degrades.
4. Entanglement swapping. Each interior node performs a Bell-state measurement on its two stored qubits, fusing the two adjacent Bell pairs into one across the longer distance ^{Żukowski et al. 1993} . Composed across the chain, this delivers an end-to-end pair between Alice and Bob.

The first generation runs all four steps as written. The second replaces the purification step (and, where possible, the heralded-generation step) with quantum error correction on the memory qubits. The third drops the generation-and-swap pattern altogether and instead transmits a block-encoded quantum state directly through the chain, repairing loss at each station with QEC.

Node architecture: comm and memory qubits

The four operations above are protocol-level — HEG, HEP, memory, swap — and silent on what a "qubit" inside a repeater node physically is. At the hardware-substrate level, every memory-based repeater demonstrated to date splits its qubits into two roles per side of the node: a communication qubit that couples to the photon on the fibre, and a memory qubit that stores the heralded state between attempts. In the leading colour-centre platforms the comm qubit is an electron spin — fast, optically active, reset every attempt — and the memory qubit is a nearby nuclear spin — long-lived, decoupled from the photonic transition, untouched while the electron retries.

Knaut et al. state the split definitionally for the SiV platform ^{Knaut et al. 2024} :

The same split appears in the NV implementation (Pompili et al., Delft), in rare-earth-ion systems, and is the hardware model assumed by the SIGCOMM 2019 link-layer protocol ^{Dahlberg et al. 2019} . It is the field-wide convention, not a platform-specific quirk.

Reuse while storing

The two roles matter because heralded entanglement generation is probabilistic: each attempt either heralds or fails, and the failures vastly outnumber the successes. If the qubit that just heralded had to wait — idle and decohering — for the other side of the node to also herald, the per-hop success rate would collapse. The fix is to SWAP the heralded state off the comm qubit and onto the memory the moment a herald arrives, freeing the comm qubit to keep retrying. Azuma's review describes the primitive as demonstrated by Pompili et al. ^{Azuma et al. 2023} :

This is what the memory qubit is for in a 1G repeater. It is not the qubit that talks to the photon; it is the qubit that holds the state while the comm qubit goes back to the photon-emission loop.

One emitter per node vs two

A repeater node sits between two neighbours and has to herald with each independently. Two real architectures fall out of that requirement, and current experimental practice has picked the first while the roadmap points to the second.

The 1-emitter sequential design runs one side of the node to completion — herald on the left, SWAP the state from electron to nucleus — then runs the right side with the same emitter, and finally performs a local Bell-state measurement on the electron–nucleus pair to swap the entanglement across the hop. Only one optical cavity per node; only one colour-centre. This is the architecture demonstrated in the Delft 3-node NV chain ^{Pompili et al. 2021} , and it is the smallest configuration that supports the full repeater protocol.

The 2-emitter parallel design gives each side of the node its own colour-centre and its own cavity. The left attempt and the right attempt run concurrently, each storing its heralded state on its own nucleus. The local BSM is now between the two nuclei (or between the two electrons after SWAP-back from the nuclei), and the per-hop time is no longer dominated by the time-multiplexing of one emitter against two neighbours ^{Knaut et al. 2024} . Knaut et al. depict this configuration in Fig. 1b as the design that scales the SiV platform up from a two-node testbed to a multi-hop network.

The forward-looking figures on this site lean on the 2-emitter parallel design because throughput, not minimum viable hardware, is the constraint that matters at network scale. The Knaut case study — what was actually built end-to-end with that hardware on a deployed Boston fibre loop — is treated on the transduction progress page; this page treats only the architectural rationale.

See the 4-hop pipeline figure for the 2-emitter parallel architecture in context.

1G — heralded generation, purification, two-way signalling

First-generation repeaters suppress both loss errors and operation errors probabilistically. Loss is handled by HEG — repeat until heralded success — and operation errors are handled by HEP, the two-way entanglement purification family (canonically BBPSSW / 2-EDP). Both subprotocols require classical messages travelling between repeater nodes in both directions, which is the architectural signature of 1G: the time scale per success step is bounded below by $\max (L_0/c,t_{\text{op}})$, where $L_0/c$ is the round-trip classical-signalling latency between adjacent nodes ^{Azuma et al. 2023} .

The canonical 1G protocol family is BDCZ (Briegel–Dür–Cirac–Zoller, 1998), built around nested purification: pairs at distance $L_0$ are purified, then swapped to distance $2L_0$, purified again, swapped to $4L_0$, and so on up to the full chain length. The atomic-ensemble variants pioneered by DLCZ (Duan–Lukin–Cirac–Zoller, 2001) and surveyed exhaustively by Sangouard et al. share the same control structure with photonic emission from collective ensemble excitations ^{Sangouard et al. 2011} .

1G is the family with the longest experimental track record — every memory-based repeater demonstration to date (NV centres, SiV centres, trapped ions, neutral atoms) is, architecturally, a 1G prototype with a small number of nodes. The cost is the rate scaling: the cost coefficient is $\text{poly}(L)$, and the time scale per step is dominated by the classical round-trip ^{Muralidharan et al. 2016} .

One reminder relevant here: the Bell-state measurement used at each swap station has a 50 % success ceiling when implemented in linear optics without ancillae (Calsamiglia & Lütkenhaus) ^{Azuma et al. 2023} . Each successful HEG already burns $1/P_{\text{ent}}$ attempts from photon loss and detector inefficiency; the BSM ceiling halves throughput again at the swap stations, so the per-hop overhead compounds with chain length. Ancilla-assisted ("boosted") BSMs break the bound — Bayerbach et al. measured 57.9 % with two ancilla photons ^{Bayerbach et al. 2023} . The full derivation lives on the entanglement page.

For an animated walk-through of a 4-hop 1G repeater (EG, 1st ES, 2nd ES, Result, with classical-bit latency visualised), see The canonical 1G repeater on the swapping page.

2G — encoded memory qubits with quantum error correction

Second-generation repeaters keep the heralded-generation-plus-swapping structure of 1G but replace probabilistic purification with deterministic quantum error correction at the encoding level. Each logical memory qubit is encoded into a block of physical qubits (a small CSS or surface code), and operation errors at the swap stations are corrected by syndrome measurement rather than purified out by 2-EDP. Loss errors during photonic generation are still handled probabilistically, so two-way signalling for the generation step remains; the swaps and gates themselves no longer need it.

The shift from 2-EDP to QEC has a measurable effect on the time scale: it drops from $\max (L/c,t_0)$ in 1G to $\max (L_0/c,t_0)$ in 2G, with $L_0$ being the inter-node spacing rather than the full distance $L$, and the cost coefficient improves to $\text{polylog}(L)$ ^{Azuma et al. 2023} . The overhead is hardware: each memory qubit is now several physical qubits, and each repeater node needs a fault-tolerant logical processor good enough to run the syndrome circuits at the code's threshold.

2G has not yet been demonstrated end-to-end. The hardware requirement (logical memory qubits below threshold, performing local QEC continuously) is essentially the same as for fault-tolerant local quantum computing, which the field has only recently approached at the small-block-code scale.

3G — block-encoded transport, one-way signalling

Third-generation repeaters dispense with the heralded-generation-and-swap pattern entirely. Instead, the sender encodes a logical qubit into a block of physical qubits and transmits the block through the chain. Each repeater station applies QEC to repair both loss and operation errors before forwarding the block to the next station. There are no Bell pairs in the architectural picture, no swap operations, and — most importantly — no two-way classical signalling: each station processes its block and forwards it onward in one direction ^{Muralidharan et al. 2016} .

The signalling change matters because it removes the $L_0/c$ latency floor that 1G and 2G inherit from their retry-and-confirm subprotocols. The 3G time scale per step is the local gate time $t_0$ alone, and the cost coefficient is $\text{polylog}(L)$ ^{Azuma et al. 2023} . In regimes where the bottleneck is end-to-end latency rather than hardware density, 3G is the architecture that wins.

The hardware demand is the steepest of the three. The block code must tolerate at least 50 % loss per segment to break the no-cloning bound on deterministic loss correction (see Sec. III.B of Azuma et al.) — a high bar for any current photonic platform — and the QEC at each station must run at the line rate. 3G remains a theoretical regime, with proposed concrete implementations based on tree-graph codes, parity-check codes, and GKP-encoded continuous-variable channels but no end-to-end experimental demonstration.

Side-by-side comparison

The same axes the literature uses to define the generations (Muralidharan 2016 Table 1; Azuma 2023 Table V), summarised:

Network role

Repeaters are the network element that turns a two-node Bell-pair link into a long-haul service. Where the entanglement-distribution layer below them delivers Bell pairs across a single link, repeaters chain those links together to span continents. The choice of generation is a hardware-economics question: 1G is what we can build today, 2G is what becomes available once logical memory qubits are below threshold, and 3G is what becomes available once high-loss-tolerant block codes can be processed at line rate at every station ^{Kumar et al. 2025} .

Three companion subjects expand this:

• Purification details the 2-EDP step that 1G repeaters use to clean up operation errors. Covered in the purification subject.
• All-photonic repeaters cover an alternative family that sidesteps the memory requirement entirely by transmitting cluster states. Covered in the all-photonic subject.
• Links describes the per-segment fibre, hollow-core, free- space, and satellite media on which any repeater chain is built ^{Jones et al. 2016} . Covered in the links subject.
• Metrics grounds the loss / fidelity / coherence numbers that bound how each generation performs in practice. Covered in the metrics subject.