What Is Photonic Quantum Computing?
Almost every long-distance conversation you have travels as light. A phone call to another continent, a video stream, a bank transaction, all of it moves through glass fibre as pulses from a laser, timed and read by detectors built to do exactly that job, at a scale most people never think about. That infrastructure took decades to build and is now one of the most mature manufacturing ecosystems on the planet.
Photonic computing asks whether that same infrastructure can be pushed one step further: not just carrying information, but processing it.
Photonic quantum computers use the quantum properties of light instead of the matter-based qubits found in superconducting circuits or trapped ions to encode, manipulate and measure information. The building blocks are largely the ones optical engineers already work with: lasers, beam splitters, interferometers, phase shifters, photodetectors. What changes is what they’re being asked to do.
Whether that bet pays off is still genuinely open. But the reason photonics is worth watching isn’t that it swaps electrons for photons. It’s that it lets quantum computing draw on a manufacturing base that already exists at industrial scale, instead of requiring an entirely new one built from nothing. It also banks on the fact that photons are already mobile in fibre and hence interconnecting quantum computers or scaling large systems becomes significantly less complicated.
Why compute with light?
There’s no single accepted way to build a quantum computer. Superconducting circuits, trapped ions, neutral atoms, quantum dots and photons are all being pursued in parallel, each with a different set of trade-offs around coherence, control, fabrication and connectivity. Photonics puts information processing directly into a physical medium, light, that engineers have already spent decades learning to generate, route and measure with extraordinary precision.
A few things follow from that choice. Many photonic operations run at or near room temperature, where several other architectures depend on dilution refrigerators cooling hardware to a fraction of a degree above absolute zero — effective and well-understood, but expensive and bulky. Photonics doesn’t eliminate the need for specialised environments in every component (some detectors still operate with cryogenic cooling), but it reduces how much of the system depends on it. Light also moves fast: optical communication systems already push enormous volumes of data at high speed, and much of that physical basis carries over, at least in principle, to a photonic processor. And photonics isn’t starting from a blank slate. Fibres, lasers, modulators, detectors and increasingly capable photonic integrated circuits are already produced at scale for telecom, data centres and sensing. This is manufacturing know-how a photonic quantum computer can draw on that has nothing to do with quantum computing at all.
None of this guarantees photonics wins. It just means the starting conditions are unusually favourable.
What makes a photon a qubit
A classical bit of light is either on or off. A quantum bit of light can be both at once, and that single fact — superposition — is the entire reason any of this is interesting.
Send a single photon at a 50:50 beam splitter and something genuinely strange happens: it doesn’t go left or right. It goes into a superposition of both paths simultaneously, and stays that way until something forces a measurement. Point a detector at each output and you’ll find the photon at one or the other, never both. But until you look, the photon’s state is a combination of “left” and “right,” and that combination is what a photonic qubit actually is. Add a phase shifter to one path and a second beam splitter to recombine them, and you can steer how that superposition interferes with itself, reinforcing some outcomes, cancelling others. That’s not a metaphor for how a photonic quantum computer works; it’s almost literally what one does, over and over, with rapidly growing numbers of photons and paths.
Two photons make this richer still. Send two identical, indistinguishable photons into the two input ports of a beam splitter at the same instant and they don’t split up the way classical particles would — quantum interference makes them bunch together and leave from the same output port as a pair, every time. This effect, discovered in 1987 and known as Hong-Ou-Mandel interference, is one of the clearest demonstrations that light behaves as a genuinely quantum object at this scale, and it’s also one of the basic tools photonic architectures use to entangle photons with each other.
A working photonic quantum computer chains a great many of these interference events together: generate quantum states of light, let them interfere and entangle across a circuit of beam splitters and phase shifters, measure the result, and hand the measurement to classical electronics that interpret it and decide what happens next. Each individual step is well understood. Making thousands of them happen correctly, in sequence, is the actual engineering problem. That is what this article comes back to below, because it’s harder than it sounds.
The superposition in the beam-splitter example above is about as simple as photonic superposition gets: one photon, deciding between two paths. Not every architecture’s qubit is built from something this straightforward, and not every architecture finds its version of that superposition equally easy to make. The next two sections get into why.
Ways to encode a qubit in light
There isn’t one way to turn a photon into a qubit — there are several. The choice of which way shapes almost everything downstream about how a system is built.
Some encodings are, loosely, particle-like. Dual-rail (or path) encoding uses which of two optical paths a photon occupies — the same superposition described above. Polarisation encoding uses the orientation of the photon’s electric field, horizontal versus vertical, or the diagonal and circular variants built from them. Time-bin encoding uses when a photon arrives, early or late, which makes it especially robust for sending qubits down long stretches of fibre where polarisation can drift. Frequency-bin encoding uses which of two optical frequencies a photon carries. These are discrete-variable approaches, and they’re what most linear-optical, photon-counting architectures are built around.
Quanfluence’s architecture starts from a different place: continuous-variable, or CV, encoding, which represents information in continuous properties of the light field itself — the amplitude and phase quadratures of its electric field — using techniques like squeezing, interference and homodyne detection to generate, transform and read it out. Specifically, Quanfluence encodes its qubits using the Gottesman-Kitaev-Preskill, or GKP, code. This is a way of embedding a discrete qubit inside a continuous-variable mode by preparing it in a highly specific, periodic comb-like superposition spread across many quantised values of the field’s amplitude and phase, rather than confined to two states. The redundancy of the periodic quantisation of a GKP qubit gives CV hardware a built-in resilience to the small, continuous errors that CV systems naturally accumulate.
That combination is exactly why GKP is attractive and exactly why it’s hard to build. The comb-like state a GKP qubit needs isn’t the simple two-path superposition described above; it’s a far more delicate, highly structured quantum state, and producing one with enough precision to be useful is, by most accounts, the single hardest step in building a GKP-based photonic quantum computer. That problem, and how different groups approach it, gets its own section below.
None of these encodings is simply “correct.” Each trades differently across generation difficulty, resistance to loss, compatibility with fibre transmission, and how naturally it supports the operations a useful computation needs. This is exactly why different groups working on photonic quantum computing have converged on different choices.
How it stacks up against other approaches
Superconducting circuits execute very fast quantum operations but generally need dilution refrigerators near absolute zero. Trapped ions offer high-fidelity operations and long coherence times, usually at the cost of slower operation. Neutral atoms, steered by lasers, have drawn attention for how large a grid researchers can create, but has limited fidelity of operation.
Photonics trades some of those strengths for lighter cryogenic demands and a manufacturing base that overlaps with telecom and semiconductors.
Nobody has a settled answer as to which of these wins, and it’s worth being honest about that: there is no universally accepted winning architecture for fault-tolerant quantum computing yet. The real question isn’t which physical system can demonstrate quantum behaviour in a lab, several already have. It’s which one can combine performance, error correction, manufacturability and scale into something you could actually build a business around.
The physics is hard. Then it gets harder.
It’s tempting to describe photonic quantum computing’s challenge as purely one of engineering scale, get the physics right, then just build a lot of it. That undersells the physics.
Photons have a property that makes them wonderful for carrying information over long distances and genuinely awkward for computing with: they barely interact with anything, including each other. Two electrons can be made to influence one another through their electric charge; two atoms can be coupled through their electromagnetic fields. Two photons, left alone, pass straight through. That’s exactly why light is such a good long-haul messenger and exactly why building a two-qubit gate, the basic operation any useful quantum computer needs, is so much harder for photons than for almost any other physical qubit. What you do about it, though, depends heavily on which kind of photonic architecture you’re building.
For discrete-variable architectures — the ones built on dual-rail, polarisation, time-bin or frequency encoding — this was solved, in principle, by a 2001 proposal from Knill, Laflamme and Milburn usually called the KLM protocol. It doesn’t force photons to interact directly. Instead, it uses only linear optics — beam splitters and phase shifters — together with extra “helper” photons and a measurement. When the measurement comes out a certain way, you can be confident, after the fact, that the equivalent of a two-photon interaction took place; when it doesn’t, you discard the attempt and try again. That turns “make two qubits interact” into a probabilistic, heralded event rather than something you can simply command to happen. This is a real cost, paid in extra photons and extra attempts, even once you’re good at it.
Quanfluence’s continuous-variable architecture runs into a different version of the same underlying problem. CV hardware can perform a wide range of operations — squeezing, beam splitters, phase shifts, the homodyne measurements used to read qubits out — directly and deterministically with linear optics. These are called Gaussian operations, and they don’t need the photon-counting tricks discrete-variable architectures rely on. But Gaussian operations alone can never add up to a universal, fault-tolerant quantum computer; that takes one genuinely non-Gaussian ingredient somewhere in the system. In a GKP-based machine, that ingredient is the GKP state itself, the highly structured, comb-like superposition described in the previous section. The two-qubit interaction problem that discrete-variable architectures solve with heralded photon measurements shows up here instead as a state-generation problem, and it’s arguably the harder of the two: a GKP state has to be good enough, essentially in one shot, to serve as the foundation the rest of the computation is built on.
There are, broadly, two ways researchers have found to make one. The first stays entirely within optics: start with squeezed light, remove individual photons from it in carefully chosen ways, and combine several such states through beam splitters and heralded measurements: a “breeding” process that gets closer to a true GKP state with each successful round, at the cost of being probabilistic like any other heralded photonic process, and less likely to succeed the higher the quality you’re aiming for. The second route borrows a nonlinearity that light doesn’t have on its own, by coupling the optical mode directly to a matter system, an atom, an ion, or another well-controlled quantum system and using that engineered light-matter interaction to sculpt the desired state directly, rather than fish for it through postselection. Quanfluence’s architecture is built around this second route. Other groups pursuing GKP-based photonics have made different bets here, which is one of the places where “photonic quantum computing” stops being a single technology and starts being several different ones operating under the same name.
And loss doesn’t forgive. A photon absorbed by a fibre, scattered at an imperfect junction, or simply missed by a detector isn’t a qubit that’s degraded, it’s a qubit that’s gone, along with whatever information it carried. Some other qubit technologies decohere gracefully enough that error correction can catch problems while the physical qubit is still there to be fixed. A lost photon offers no such second chance.
Put those things together — a fundamental lack of photon-photon interaction, a genuinely hard-to-generate core resource state, probabilistic raw ingredients, and unforgiving loss — and the “integration challenge” people talk about isn’t a separate problem sitting on top of the physics. It’s a direct consequence of it. The way the field has generally responded is to stop expecting any single component to be perfect and build redundancy and correction into the architecture instead: combine many GKP-encoded modes into a large entangled cluster state, then run the computation by measuring modes in a chosen sequence — measurement-based quantum computation — rather than applying gates to a fixed set of qubits one at a time. That approach can tolerate a fair number of imperfect or missing modes, provided enough of the rest are good enough and the errors are tracked as they happen. Designing for imperfection at the level of individual components, rather than eliminating it, is the strategy most photonic architectures have converged on, discrete- and continuous-variable alike. They just implement it differently. It’s also why a photonic quantum computer ends up looking less like “a chip” and more like a coordinated system of lasers, sources, circuits, detectors and control electronics that all have to hold together at once, at a scale current systems are still working toward.
What Quanfluence is building
Quanfluence is developing a full-stack, continuous-variable photonic quantum computing platform built around GKP-encoded qubits, generated through engineered light-matter interaction. These are then combined into large entangled states. Gate operations happen via measurement-based quantum computation, rather than by applying them to qubits one at a time. Hardware, detection systems, control electronics and software are built together rather than assembled from separately optimised parts. The long-term goal is a general-purpose, fault-tolerant quantum computer capable of solving problems that stay out of reach for classical machines. Treating the quantum processor as one component in a larger system is the bet behind that approach. When the hardest single ingredient is a delicate, engineered quantum state rather than a mature, off-the-shelf part, the detection, control and correction layers aren’t add-ons to the quantum hardware, they’re what make the quantum hardware usable at all.
Some of what’s being developed along the way already stands on its own. A high-speed balanced detector, built for the precise measurements CV homodyne detection depends on, also serves telecommunications applications. A room-temperature single-photon detector is aimed at secure quantum communication and low-light sensing. A quantum random number generator draws entropy directly from vacuum fluctuations in the light field — quantum noise rather than an algorithm’s approximation of randomness — and turns it into numbers usable for cryptography.
What it could be used for
The applications usually listed for quantum computing — optimisation, materials discovery, drug development, financial modelling, machine learning, cryptography — turn up in almost any article about the field. This is for a good reason: fault-tolerant quantum computers, should be genuinely useful for exploring enormous solution spaces and simulating quantum systems like molecules. And genuine, physically grounded randomness, a by-product of how these systems work, not an approximation of it, is already useful in cryptography today, well ahead of any of the bigger promises.
Not a replacement for classical computers
Quantum computers aren’t being built to replace the machine you’re reading this on. Classical systems remain extremely good at almost everything computers currently do. Quantum processors are better understood as specialised resources that would sit alongside CPUs, GPUs and other accelerators in a future computing stack, called on for the specific class of problems they’re actually suited to. The goal was never to make classical computing obsolete, it’s to widen the range of problems computing can practically take on.
Where this goes
Nobody can say yet whether photonics, superconducting circuits, trapped ions or neutral atoms or some combination of them will end up defining fault-tolerant quantum computing. That’s a genuinely open question, and treating it otherwise would be dishonest.
What photonics brings to that competition is a head start most other approaches don’t have: light is already one of the world’s most heavily engineered information technologies, running the internet’s backbone, threading through data centres, and increasingly manufactured with the same techniques used for semiconductors. Photonic quantum computing doesn’t get to skip its own hard physics because of that inheritance. But it does mean the tools for solving the engineering half of the problem — precision manufacturing, high-speed detection, integrated optics at scale — don’t all have to be invented from nothing. Engineers are also highly excited about the ability of photonic qubits to scale and to network large quantum computing clusters.
That’s the opportunity Quanfluence is building toward: not a demonstration that photons can behave quantum-mechanically, but an integrated system aimed at doing something useful with them.