hardware advanced · 19 min read · April 29, 2026

Photonic Quantum Computing: The Dark Horse Architecture That Skips Cryogenics

Photonic quantum computers use photons as qubits and measurements as the source of nonlinearity — a fundamentally different architecture from transmon, ion, and neutral-atom platforms. PsiQuantum, Xanadu, ORCA, Quandela, and QuiX are the leading commercial efforts; the fusion-based quantum computing model gives photonics a credible path to fault tolerance without ever needing a long-lived coherent quantum state. This tutorial covers the architecture, the leading companies, and where the gamble actually pays off.

Prerequisites: Tutorial 35: Neutral Atom Quantum Computing

Every other quantum-computing platform is fighting decoherence — cryogenic vacuum, ultra-low temperatures, magnetic-field shielding, lab-grade laser stabilization. Photonic quantum computing skips all of it. Photons travel through silicon waveguides at room temperature, do not interact with their environment in any meaningful way, and don’t decohere over algorithm timescales. The hardware infrastructure is essentially commercial fiber-optic and silicon-photonics manufacturing, scaled.

The cost of this advantage: photons don’t naturally interact with each other, which means there is no natural two-photon gate. Photonic quantum computing has to invent the nonlinearity it needs, and the standard answer is measurement-based quantum computing — perform measurements on entangled photonic states, and use the measurement outcomes to drive the quantum computation. The resulting architecture is structurally different from gate-model platforms, with different cost lines and a different fault-tolerance picture.

This tutorial covers photonic quantum computing end-to-end: the qubit encoding choices, the KLM scheme that proved it could be universal, the measurement-based and fusion-based architectures that drive the commercial companies, current 2026 status, and an honest assessment of whether the platform’s “skip cryogenics” pitch holds up.

The qubit: a photon

A single photon can encode a qubit in several ways:

• Polarization: $|0\rangle$ = horizontal polarization, $|1\rangle$ = vertical. Free-space optics; less common in modern integrated systems.
• Dual-rail: $|0\rangle$ = photon in waveguide A, $|1\rangle$ = photon in waveguide B. Used in PsiQuantum, ORCA, Quandela. Robust to loss-detection (a missing photon is detectable as “no click in either rail”).
• Time-bin: $|0\rangle$ = photon in early time slot, $|1\rangle$ = photon in late time slot. Used in some long-distance and measurement-based protocols.
• Continuous-variable (CV): quadratures of a coherent or squeezed light state. Used by Xanadu — an entirely different mathematical framework.

Most flagship 2026 commercial systems use dual-rail encoding: each logical qubit is a single photon distributed across two waveguides. The encoding has the property that “photon loss” — the dominant error mode — produces a detectable event, which can be treated as an erasure. This is one of photonics’ nicest engineering properties.

Why photons need help: the no-go for direct two-photon interaction

In linear optics — the regime where photons travel through beam splitters, phase shifters, mirrors, and waveguides without nonlinear materials — two photons do not interact. Each photon evolves independently. The Hamiltonian is bilinear in the photon-mode operators, with no cross terms.

This is the fundamental obstacle. A two-qubit gate requires conditional dependence between the photon states, which a bilinear Hamiltonian cannot provide. Naive linear optics is not universal for quantum computing.

The classical workarounds — strong nonlinear optical materials, single-photon Kerr media — produce too little phase shift for practical use. The Kerr nonlinearity that would give a deterministic CZ gate on two photons is roughly $10^{10}\times$ too weak in any known material.

The KLM scheme: nonlinearity from measurement

In 2001, Knill, Laflamme, and Milburn published a remarkable result: linear optics plus single-photon measurements is universal for quantum computing. The trick is to use measurement outcomes to drive a probabilistic two-qubit gate, then make the gate near-deterministic using teleportation and resource overhead.

The KLM construction:

1. Prepare auxiliary photonic states (e.g., specific entangled pairs).
2. Mix the auxiliary photons with the data photons through linear-optics circuits.
3. Measure some of the photons.
4. Conditioned on specific measurement outcomes, the remaining photons end up in the desired two-qubit-gated state.

The core gate has success probability $p < 1$ per attempt. By using teleportation-based “gate teleportation” (resource-state manufacture plus correction by measurement), the effective gate error can be driven down at the cost of more resource photons per gate.

KLM was a theoretical breakthrough but architecturally heavy: the resource-state requirements for near-deterministic gates were enormous. The practical photonic-computing field needed a more efficient framework, which arrived as measurement-based quantum computing (MBQC).

Measurement-based quantum computing

In MBQC (Raussendorf-Briegel 2001), the computation proceeds as follows:

1. Prepare a large entangled “cluster state” — a fixed entangled state across many qubits.
2. Perform single-qubit measurements on the cluster, in a sequence determined by the algorithm.
3. The measurement outcomes drive the computation; correction operations (single-qubit Pauli corrections) are applied based on prior outcomes.

The key insight: the entire quantum computation is done by measurements. The cluster state is fixed; the algorithm is encoded in which qubits to measure in which basis.

For photonics, MBQC is natural: you generate a cluster state by mixing entangled photon pairs through linear-optics networks, then measure photons one by one. No two-photon gates are ever directly applied; the entanglement is built once and consumed by measurement.

The catch: cluster states are large. A cluster supporting an $n$-qubit, $T$-depth computation needs $\sim n T$ entangled photons. For meaningful algorithms this is millions to billions of photons.

Fusion-based quantum computing

The 2023 PsiQuantum paper (Bartolucci et al., “Fusion-based quantum computation,” Nature Communications) introduced the architectural framework most modern photonic-FTQC roadmaps target: fusion-based quantum computing (FBQC).

The FBQC picture:

1. Generate small “resource states” — entangled photonic states with $\sim 4-10$ photons each. These are produced by photon sources plus small optical circuits and are independent of the algorithm.
2. Fuse the resource states together using two-photon measurements. Each fusion either succeeds (entangling the resource states into a larger cluster) or fails (giving an erasure).
3. The fault-tolerance code is built directly into the cluster topology that emerges from the fusion network.
4. Final qubit measurements drive the computation.

Why this is attractive:

• No need for long-lived quantum coherence. Photons are generated, fused, and measured on microsecond timescales. There is no “algorithm runtime” during which qubits must stay coherent.
• Architectural modularity. The same hardware (photon sources, fusion gates, measurement detectors) handles error correction and computation; the difference is in which photons get measured in which basis.
• Fits silicon-photonics fabrication. PsiQuantum’s pitch is that the fusion-based architecture can be implemented with $\sim 10^9$-photon-per-second sources, $\sim 10^7$ photonic switches, and $\sim 10^6$ single-photon detectors — all manufacturable with extensions of current commercial silicon photonics.

Fusion-based quantum computation is the cleanest photonic-FTQC framework as of 2026. It is also fundamentally untested at scale — PsiQuantum has not yet publicly demonstrated even a small-scale FBQC implementation. The promise is large; the execution is uncertain.

The dominant error mode: loss

In the gate-model platforms, the dominant error modes are typically gate errors and decoherence. In photonic systems, the dominant error mode is photon loss.

Sources of loss:

• Coupling efficiency from photon sources to waveguides ($\sim 90-99\%$ per coupler in 2026).
• Waveguide propagation loss ($\sim 0.1$ dB/cm at telecom wavelengths in silicon).
• Detector efficiency ($\sim 90-99\%$ for transition-edge sensors and superconducting nanowires).
• Fusion-gate intrinsic inefficiency ($\sim 50\%$ for 2-photon fusions; can be improved with auxiliary states).

Cumulative end-to-end photon-survival probability in a 2026 photonic system is typically 50-80%. For fault-tolerant computation this is well below the threshold of standard codes, which is why photonic-FTQC architectures use erasure-aware codes that handle losses as known-position erasures rather than unknown errors. The loss-tolerant codes have higher thresholds but more complex decoders.

The loss-budget engineering is the central challenge of scaling photonic systems. Each component improvement compounds: a 1% improvement in waveguide loss across 100 components is much more than 100%.

Companies and current status

The photonic-quantum-computing landscape as of 2026:

• PsiQuantum (Palo Alto CA): the largest funded effort in photonic FTQC ($\sim$$4 billion raised). Targets fault-tolerant computing via FBQC on silicon-photonic chips, with claimed 2027-2029 timeline for a million-qubit-class system. Historically secretive; published mostly via the Bartolucci 2023 Nature Communications paper. Construction of major fab partnerships in Australia and the US in 2024-2025.
• Xanadu (Toronto, Canada): continuous-variable photonics; X-series Borealis system (Gaussian boson sampling demonstrations) and gate-model X8 system available on cloud. Strong open-source software stack (PennyLane, Strawberry Fields). Targets photonic gate-model computation with squeezed light.
• ORCA Computing (London UK): photonic quantum computing using time-multiplexed dual-rail qubits. Smaller scale; commercial deployments emphasize integration with classical AI/ML hardware.
• Quandela (Paris, France): photonic processors with quantum-dot single-photon sources. Cloud-accessible Ascella system. European leader in photonic-source technology.
• QuiX Quantum (Enschede, Netherlands): silicon-nitride photonic platforms, primarily targeting quantum-simulation workloads.
• Lightsynq (research, multiple sites): emerging player in photonic networking and computing.

A unique platform-specific milestone: Gaussian boson sampling (GBS) demonstrations. USTC’s Jiuzhang series (Jiuzhang 1.0 in 2020, Jiuzhang 2.0 in 2021, Jiuzhang 3.0 in 2024) used squeezed-light photonics to demonstrate quantum-supremacy-like sampling tasks at scales claimed to be classically infeasible. The classical simulability of GBS results has been intensely debated — see Bulmer et al. 2022 and follow-up work — but the experimental hardware is genuine and the photonic engineering is impressive.

Strengths and bottlenecks

Strengths:

1. Room-temperature operation. No cryogenics. Smaller infrastructure, lower cost, easier integration.
2. Long photon “coherence.” Photons don’t decohere on algorithm timescales (they just move through waveguides at the speed of light). The decoherence problem is replaced by the loss problem, which is more localized.
3. Modular architecture. Photons travel between modules through fiber, enabling networked multi-chip systems with no exotic interconnects.
4. Manufacturing leverage. Silicon photonics has a $20+$ year history in commercial telecom; the manufacturing infrastructure is largely existent and scalable.
5. Built-in loss detection. Dual-rail encoding makes most photon-loss errors detectable as erasures, simpler for error correction.

Bottlenecks:

1. Photon loss. Cumulative 50-80% photon survival at current technology; needs to reach $\sim 99\%$ for reasonable fault-tolerance overhead. Every component matters.
2. Single-photon sources. Generating high-quality single photons on demand at high rates is a hard manufacturing problem; current sources are either probabilistic (heralded single-photon sources) or use quantum dots with imperfect indistinguishability.
3. Single-photon detectors. Need high efficiency, low dark counts, and microsecond-or-faster timing. Superconducting nanowire detectors meet these but require liquid-helium cooling — partial cryogenics for the detector subsystem only.
4. Architectural complexity. Fusion-based architectures are mathematically well-defined but have not been demonstrated at scale; the scaling from “small demo” to “fault-tolerant machine” has many architectural decisions yet to be locked in.
5. No production FTQC demo. As of 2026, no photonic system has demonstrated logical qubits with code-distance suppression (the equivalent of Willow’s 2024 result for transmons). The platform is the most ambitious plan, with the least experimental milestone-progress.

When photonics is the right answer

Photonic quantum computing is most clearly the right answer when:

1. Networking is fundamental. Quantum networking, quantum communication, and distributed quantum computing all require photonic interfaces. Even non-photonic compute platforms typically use photons for inter-node entanglement distribution.
2. Cryogenic infrastructure is impossible. Edge-deployed quantum computers, embedded quantum sensors, or any application where dilution refrigerators are infeasible.
3. Fault tolerance via measurement-based architectures is preferred. If the user can tolerate the architectural risk of FBQC working at scale, photonics has the largest claimed FTQC headroom.

It is most clearly the wrong answer when:

1. You need NISQ-era results today. Photonic NISQ demos are smaller than transmon, ion, or neutral-atom equivalents. The platform’s strength is asymptotic, not present.
2. Gate-model algorithm familiarity matters. Working with photonic measurement-based code is structurally different from gate-model and requires different mental models.
3. Loss budgets cannot be tolerated. For algorithms requiring high single-shot success probability, the cumulative photon loss is currently a problem.

Common misconceptions

“Photonics is just quantum communication.” No. Quantum communication is photonics-natural, but commercial photonic-computing efforts (PsiQuantum, Xanadu, ORCA) target full quantum computation, not just communication.

“Linear optics is not universal.” False at the system level. Linear optics plus measurements is universal (KLM 2001). The “no two-photon gate” result is a fact about pure linear optics, not about photonic systems with measurement.

“GBS demonstrates quantum supremacy.” Contested. Jiuzhang’s GBS results are real photonic experiments with non-trivial quantum effects, but classical-simulation algorithms have improved substantially; whether the demonstrated GBS instances are still genuinely classically infeasible at the claimed scale is an active research question.

“PsiQuantum is going to ship a million-qubit machine.” It is what they have publicly committed to. Whether they ship is a different question from whether they have committed. Past quantum-hardware roadmaps have slipped by 1-3 years routinely; the FBQC architecture has additional architectural uncertainty.

“Photonic systems have no decoherence.” They have less decoherence than other platforms. Photons can decohere through mode-mismatch effects (different photons being non-identical, frequency drift, polarization drift) and through loss. The decoherence problem is replaced by the loss problem; both are real.

Decision rule

Picking photonics over other platforms:

1. Are you researching quantum networking, communication, or sensing? Photonics is the natural choice. Tutorial 37 (quantum networking) covers this in more depth.
2. Are you working on fault-tolerance protocols that suit measurement-based architectures? Photonics is a natural fit; the FBQC framework is mature.
3. Do you need cloud-accessible photonic hardware in 2026? Xanadu, ORCA, and Quandela offer it. Not at PsiQuantum’s planned scale, but genuinely useful for research and small algorithms.
4. Are you betting on the long-run platform leader for fault tolerance? This is genuinely uncertain. Photonics has the most ambitious roadmap, the most architectural uncertainty, and one of the largest financial bets (PsiQuantum’s funding). Choose based on your appetite for architectural risk.

Exercises

1. Loss budget

A photonic system has 99% transmission per component and uses 50 components per logical qubit. What is the per-photon survival probability? How does it compare to surface-code threshold for an erasure-aware code?

Show answer

Per-photon survival: $0.99^{50} = 0.605$, or 60% photon survival. For ordinary error-correcting codes this is well above threshold (failure rate of 40% per qubit per cycle). Erasure-aware codes have much higher thresholds for detected losses — the surface code’s erasure threshold is around 50%, and other codes (e.g., Reed-Muller-derived erasure codes) have even higher tolerance. So 60% loss is borderline for some erasure codes but not all. The roadmap goal is typically $> 99\%$ photon survival, requiring component improvements to $0.99^{1/50} = 0.9998$, or 99.98% per component — a real engineering target.

2. Why no-cryogenics matters

Estimate the cost overhead of a dilution refrigerator (cryogenics) for a million-qubit system. Compare to room-temperature photonic infrastructure.

Show answer

A million-qubit superconducting system would need ~1000 dilution refrigerators (each handling ~1000 qubits at most), at $\sim$$1M each = $\sim$$1B in cryogenics alone, plus liquid helium consumption, plus building infrastructure for cryogenic plumbing. A million-qubit photonic system would need thousands of silicon-photonic chips at $\sim$$10K each = $\sim$$10M in chips, plus fiber interconnects, plus normal-temperature racks. The infrastructure cost differential is approximately two orders of magnitude. This is the clearest financial argument for photonics: even if performance per qubit is somewhat worse, the deployable-scale cost is dramatically lower. Whether this advantage materializes depends on the per-qubit performance gap.

3. Why measurement-based is structurally different

In a gate-model algorithm, you build a circuit and run it. In MBQC, what does the equivalent of “running an algorithm” look like? Why does this make networking natural?

Show answer

In MBQC, you have a fixed cluster state and an algorithm-determined sequence of measurement-basis choices. To “run an algorithm” you ingest the algorithm specification, compute the measurement schedule, dispatch single-qubit measurement requests across the cluster, and process the measurement outcomes through the classical correction step. The hardware is a cluster-state generator and a measurement-and-correction system; the algorithm is the measurement schedule. Networking is natural because cluster states can be assembled by entangling many small modules through fusion gates; the cluster spans physical modules naturally. By contrast, gate-model platforms must keep a single coherent quantum state across all modules during the entire algorithm, which is much harder to network.

4. Whose roadmap is most credible?

Comparing PsiQuantum (FBQC, $\sim$$4B funding, 2027-29 million-qubit target) and Xanadu (CV photonics, $\sim$$200M funding, smaller-scale near-term targets), which has the more credible roadmap as of 2026?

Show answer

Both bets are real, but they target different things. PsiQuantum’s roadmap is bigger and more ambitious; the architectural risk is also bigger (FBQC at the claimed scale has not been demonstrated). Xanadu’s roadmap is smaller and more incremental; their architectural choices (CV photonics, Gaussian boson sampling) are well-validated experimentally but have a less clear path to general-purpose fault tolerance. Risk-adjusted, neither is clearly more credible than the other — they target different parts of the technology tree. PsiQuantum is the higher-risk, higher-reward bet; Xanadu is the more incremental, application-software-leveraged bet. A serious roadmap evaluation would also include the publication track record (Xanadu publishes more openly), the hiring trajectory, and the leadership stability — all factors that have shifted multiple times for both companies.

Where this goes next

This concludes the four-tutorial hardware deep-dive (33-36) covering the four major quantum-computing platforms. Subsequent tutorials may either deepen specific platforms (specific qubit species, specific error mechanisms) or pivot to adjacent topics: quantum networking (tutorial 37 candidate), quantum sensing, quantum simulation as its own discipline, or back to algorithm/error-correction follow-ups. The hardware track now has five tutorials (20: 4-modality compare; 33-36: per-platform deep dives) — sufficient grounding for any reader to evaluate platform-specific claims with appropriate skepticism.

---

Weekly dispatch

Quantum, for people who already code.

One serious tutorial per week, plus the industry moves that actually matter. No hype, no hand-waving.

Email Subscribe

Free. Unsubscribe anytime. We will never sell your email.