Introducing LuminaQ: the software stack project for Quantum Computing Files
A photonic quantum software platform built in the open, one layer at a time by Nuno Edgar Nunes Fernandes
Quantum Computing Files has been running since 2021. It started as a twice-weekly curation of research papers, conference talks, and business developments in quantum computing — a way of keeping pace with a field that moves faster than any single person can comfortably read. Over the years, the scope broadened. We covered the GKP error-correction code and its long road from theoretical curiosity to experimental reality. We followed the funding rounds — the $100M Series B at Xanadu, the SPAC wave, the period of reckoning that followed. We tracked the rise and the more complicated maturation of quantum machine learning as a subfield. Through all of it, the publication has been driven by a single editorial conviction: quantum computing deserves serious, unhyped coverage, grounded in what the physics and mathematics actually say.
Today’s post is different. It is the first post in this publication where I am not writing about someone else’s project. I am writing about my own.
A long-running background thread
For anyone who has been reading QCF (Quantum Computing Files) since its early editions, the focus of this publication has always been subtly photonics-weighted. That was not accidental. My background is in physics engineering, with a specialism in optoelectronics and photonics. When I look at the landscape of quantum computing hardware, I keep returning to photons — not out of tribalism, but because the physics genuinely compels attention.
Photonic qubits do not require dilution refrigerators. They operate at room temperature. They are the natural substrate for quantum communication, and their low decoherence makes long coherence times achievable in principle. The integration story with existing telecommunications infrastructure is real, not aspirational. And continuous-variable photonic quantum computing — where information lives not in discrete two-level systems but in the quadratures of the electromagnetic field — opens a computational mode that has no clean classical analog.
This is the territory I explored in the March 2025 post “Illuminating the Quantum Realm: Photonics and the Quantum Computing Journey”, and it is the territory that LuminaQ is built to inhabit.
What LuminaQ is
LuminaQ is a photonic quantum software stack. It is inspired by what companies like Xanadu have demonstrated is possible — that you can build serious, layered quantum software that spans from physics primitives all the way to a user-facing interface — and it applies that architecture specifically to the continuous-variable (CV) photonic paradigm.
The stack is organised into five layers:
lumq-photonics is the physics foundation. It implements quantum optical state representations — Gaussian states in the covariance matrix formalism, Fock-basis states as dense complex tensors — along with a complete gate library covering beamsplitters, squeezers, phase shifters, displacers, two-mode squeezing, and non-Gaussian gates including the Kerr interaction and the cubic phase gate. Measurements include homodyne detection, heterodyne (eight-port homodyne), photon-number-resolving detection, and Fock projection. Phase-space tools — the Wigner function, Husimi Q, and quadrature marginals — are included for visualisation. The entire layer is built on JAX, making every computation differentiable: gradients flow through gates, states, and measurements without any additional instrumentation.
lumq-compiler sits above the physics layer. Its core deliverable is the Clements rectangular mesh decomposer — the algorithm from Clements et al. (Optica, 2016) that maps any N-mode linear optical unitary to an optimal beamsplitter-and-phase-shifter mesh. This is the algorithm that makes photonic chips programmable: instead of hardwiring a specific interferometer, you describe a target unitary and the compiler produces the physical gate sequence for it. The compiler also provides a circuit intermediate representation (IR), an optimisation pass pipeline, and a resource estimator that computes squeezing budgets, gate counts, and circuit depth.
lumq-backends provides the simulation layer. The Gaussian simulator is exact and efficient — it tracks the covariance matrix and displacement vector through each symplectic transformation at O(N²) per gate, and it supports analytic gradient computation through the entire circuit. A Fock-basis simulator handles non-Gaussian circuits at the cost of exponential memory scaling (kept tractable for small mode counts). Both simulators conform to an abstract Device interface, so algorithm code written once runs unchanged on any backend — including, eventually, real photonic hardware.
lumq-api is the FastAPI bridge: a REST and WebSocket gateway that exposes the Python stack to the TypeScript user interface. Every circuit operation, every simulation run, every Wigner function computation is callable via JSON endpoints. The Wigner function endpoint returns a grid ready for direct heatmap rendering in the browser. WebSockets push job completion events in real time.
LuminaQ Platform is the existing TypeScript/React user interface, originally built in Bolt. It provides the circuit canvas, the results viewer, and the hardware monitoring dashboard that the software stack now powers.
The project is fully open-source at github.com/nunofernandes-plight/LuminaQ_Platform.
On the PennyLane lineage
It would be intellectually dishonest not to acknowledge the most important piece of prior art in this space: PennyLane, Xanadu’s quantum programming library.
PennyLane has shaped how the entire field thinks about quantum software architecture. Its central insight — that quantum circuits should be differentiable, that the interface between classical optimisers and quantum hardware should be seamless, that a software framework should be hardware-agnostic — these are not obvious ideas. They were design decisions made early and defended consistently, and the result is a platform that is genuinely useful for research.
The Xanadu team has been building quietly and rigorously for years. A recent announcement from Josh Izaac is worth reading carefully: PennyLane is transitioning from import pennylane as qml to import pennylane as qp. The change is symbolic but meaningful — it signals that PennyLane is no longer primarily a quantum machine learning library but a general-purpose quantum programming platform, covering algorithm design, compilation via Catalyst, fault-tolerant resource estimation, and hardware execution across multiple backends. Eight years of patient, unglamorous software engineering have produced something with real depth.
Also worth noting: Xanadu and South Korea's ETRI have just announced a two-year collaboration to enhance the resource estimation and compiler capabilities of PennyLane and Catalyst, with a focus on fault-tolerant quantum algorithm design. The collaboration is backed by the South Korean government and targets distributed quantum computing. Christian Weedbrook described it plainly: "It is vital for researchers to understand the quantum resources their algorithms require." That sentence could serve as an epigraph for the entire compiler layer of LuminaQ — because resource estimation is not a footnote; it is the difference between an algorithm that is theoretically interesting and one that is physically executable.
And the QML work continues. The Xanadu QML team's latest paper, covered in a March 2026 blog post, makes a careful argument for why the Quantum Fourier Transform — not neural-network-inspired variational circuits — may be the natural starting point for quantum machine learning. The argument is refreshingly honest about the failures of the field to date: most quantum machine learning research has tried to make quantum computers do what classical computers already do well. The QFT direction asks instead what quantum computers are genuinely good at, and builds from there. This is exactly the kind of first-principles thinking that serious quantum software work requires.
LuminaQ is not a competitor to PennyLane. It is a complement — narrower in hardware scope (explicitly photonics-native), built on JAX from the start rather than evolving toward it, and focused on the CV paradigm that PennyLane supports but does not centre. Where PennyLane forked from a QML identity toward general quantum programming, LuminaQ starts from CV photonics and is building upward.
What this publication will cover
With the introduction of LuminaQ as an active project, Quantum Computing Files gains a second mode. The curation and editorial work continues — the field is moving fast enough that there will always be papers and developments worth tracking. The Xanadu-ETRI collaboration. The latest PennyLane releases. The hardware milestones from Quandela, PsiQuantum, and others. The Quantum Insider’s coverage of business developments in the sector. That work has not stopped.
But now there is also a software platform to document, explain, and grow in public. Future posts in this series will cover:
The physics of the CV paradigm. What a Wigner function actually tells you. Why squeezed light is a quantum resource. How the Clements mesh makes an N-mode interferometer programmable. The Gottesman-Kitaev-Preskill (GKP) code — which we discussed in the very first year of this publication — and how it connects to the cubic phase gate that is already implemented in LuminaQ’s physics layer.
The software architecture. Each layer of the stack explained from first principles: why JAX for autodiff matters for variational algorithms, how the Clements decomposition achieves optimality, what the difference between Gaussian and Fock simulation means in practice for algorithm design.
Algorithms. Gaussian boson sampling, which is the first algorithm LuminaQ’s algorithm layer will implement. Variational CV circuits for quantum chemistry and optimisation. Continuous-variable quantum machine learning, with the QFT angle that Xanadu’s team is now pursuing.
The hardware landscape. Xanadu’s X-series photonic chips. Quandela’s single-photon platform. LETI’s integrated photonic processor work. What the compiler needs to know about each target in order to produce executable circuits.
A note on process
LuminaQ is being built iteratively, with every design decision justified from first principles and every component tested before the next is added. The development history is public. The architecture is documented. The code is readable.
This publication exists, in part, to make that process legible to people who are interested in quantum computing but do not spend their days inside a codebase. The physics is real, the engineering is real, and the constraints are real. If the project reveals something interesting — about the difficulty of CV simulation, about the gap between theoretical proposals and implementable circuits, about what resource estimation actually shows when you try to run a meaningful algorithm on realistic hardware — that is worth documenting honestly.
The quantum computing field has enough hype. It does not need more. What it needs is people building things carefully, writing about what they find, and being direct about both the progress and the limits.
That is what this publication has tried to do since 2021. It is what LuminaQ will continue.
Next in this series: the physics of the Gaussian state — what a covariance matrix encodes about a quantum optical field, and why it is the right representation for simulating photonic circuits efficiently.
Links
LuminaQ Platform on GitHub: github.com/nunofernandes-plight/LuminaQ_Platform
PennyLane: pennylane.ai
PennyLane Blog — “import pennylane as qp”: pennylane.ai/blog/2026/03/import-pennylane-as-qp-growing-beyond-just-qml
PennyLane Blog — “Why quantum computers could be great for machine learning after all”: pennylane.ai/blog/2026/03/quantum-computing-useful-for-machine-learning
The Quantum Insider — Xanadu & ETRI partnership: thequantuminsider.com/2026/03/12/xanadu-etri-fault-tolerant-quantum-algorithm-pennylane
Quantum Computing Files archive: quantumcomputingfiles.substack.com
LuminaQ and Quantum Computing Files, both written and developed by Nuno Edgar Nunes Fernandes