Lunima — the open engine
Lunima is the open-source engine at the core of Qfactr. It provides the physical layout, routing, components, and simulation-aware model that the Qfactr workspace is built on.
Qfactr is built on top of Lunima, an open-source engine for photonic integrated circuit design. Lunima is the open core: it holds the data model and the design primitives — physical layout, PDK-aware components, explicit waveguide routing, hierarchy, simulation-aware loss, and exports. Qfactr is the company and product built on that foundation.
Splitting an open engine from a product on top of it is a deliberate choice. The core representation — how a photonic design is described, edited, and reasoned about — stays open and inspectable, while Qfactr adds the workspace experience and the physics-informed generative ML direction around it. If you want to understand exactly how a design is stored and manipulated, Lunima is where that lives.
What Lunima provides
Lunima implements the representation layer that the workspace edits. Everything you see on the canvas — a placed component, a routed waveguide, a frozen subcircuit — is backed by a Lunima model that keeps layout, connectivity, hierarchy, and physical context in one editable place rather than scattering them across a schematic, a spreadsheet, and a separate mask file.
- Physical layout — components live at real coordinates in micrometers (µm), so the geometry is true from the first placement rather than an abstract grid.
- PDK-aware components — parts carry physical pin positions and S-matrix (S-parameter) data, so they behave like the devices they represent.
- Explicit routing — waveguides are real
S-bendand Manhattan paths between real component pins, not abstract nets drawn between symbols. - Simulation-aware loss — transmission and loss are derived from the actual path geometry, so the physics tracks the layout as you edit it.
- Hierarchy — reusable subcircuits become blocks with external pins and frozen layouts that you can compose into larger systems.
- Exports — one design hands off to the downstream tools your team already runs, including Nazca (Python) and
GDSfor fabrication.
Because all of this is one connected model, an edit on the canvas is an edit to a structured circuit state — the same state the AI assistant works over, and the same state that gets translated when you export.
Lunima and Qfactr
It helps to keep the two roles distinct. Lunima is the engine; Qfactr is the product. The engine defines what a photonic design is and the operations you can perform on it. The product is the workspace you sit in to do that work, plus the research direction layered on top of the open core.
| Lunima | Qfactr | |
|---|---|---|
| Role | Open-source engine / core | Company and product |
| Owns | The representation layer: layout, components, routing, hierarchy, loss model, exports | The workspace experience built on that engine, and the physics-informed generative ML direction |
| Availability | Open source on GitHub | Built on Lunima; request access to the product |
In practice this means the core concepts you learn in these docs — physical coordinates, pins, explicit routes, hierarchy, simulation-aware loss — are properties of the Lunima engine. The workspace simply gives you a direct, visual way to manipulate them.
Where the generative direction fits
Qfactr's longer-term goal is physics-informed generative ML for photonic layout. The open Lunima engine is the substrate that makes this tractable: because the model already carries real geometry, routing, and loss, a layout proposal can be evaluated against the same physical constraints a human designer faces, rather than against an abstract placement objective.