LUV

Type. Physics. Hardware. One sentence.

The language that binds the three

LUV is the language that binds type, physics, and hardware in one sentence. The operator says what is true; the machine keeps it. A type is not a comment sitting above a chip. It is the field the chip can hold, the arithmetic that field admits, the Reed-Solomon code that field registered, and the target that physically implements that dimension. Write the sentence. The compiler keeps the sentence.

The one-line idea is type = physics = hardware. A type error is an impossible hardware configuration — a program that would ask a chip to do something the physics will not do. The compiler refuses that program at the desk. Heaters do not drift while someone discovers the mismatch. Developers write against a machine whose arithmetic, codes, dimension, and target are the same object.

Photonic chips are analog. Heater voltages, phase masks, continuous fields whose dimension is the hardware’s mode count. The quantum state lives in the field itself. The field is the chip. A language that cannot name that identity cannot enforce it. LUV names it, then holds it. Output matches hardware limits before a photon moves.

One contrast, then the get

Gate-model tools treat a qubit as an abstract two-level object. Photonic chips are not that object. The experimental workflow still looks like this: decompose a unitary in Python, calibrate the heaters by hand, emit a DAC table, and pray the chip matches the notebook. Qiskit, QASM, Cirq, Blackbird, Strawberry Fields, PennyLane, MrMustard, and Walrus each automate one slice — a gate circuit, a photonic IR, a gradient, a squeezed state, a photon count. The rest is a manual bridge. The engineer remains the compiler.

That is the contrast. The get is one language that takes the operation all the way to the chip. Enzo wrote the compiler, the types, and the backends. Sky wrote the photonic IR, the analog optical layer, and the chip ladder. They were not reading papers about quantum languages. They were coding in them. Then they designed LUV so nobody has to stitch six toolchains to talk to a chip.

One declaration names the machine

The proof of the type system is a single line: field 8. That declaration is not a comment and not a side config. It simultaneously defines four things that other stacks still treat as four different jobs:

• GF(2⁸) arithmetic — a 256-element finite field for every add and multiply.
• RS(255,247) error correction — Reed-Solomon as a language statement, not a library call.
• 256-dimensional qudits — the state space is the field size, not a theoretical knob.
• THETA chip target — the hardware that physically implements d=256.

Change the field and you change the machine. Reed-Solomon parameters are fixed by the field. A field without registered codes is a compile error. Error correction is baked into the declaration the way voltage is baked into a heater. F64 is a compile error: the DAC cannot resolve that precision, so the language will not pretend it can.

One declaration names the arithmetic, the code, the qudit, and the chip. Type, physics, and hardware are the same object.

The field is the chip

Qudit dimension is not a theory parameter. It is the physical dimension of the optical field. GEMINI is d=2 — dual-rail spatial modes, Mach–Zehnder phases, the smallest honest chip. SOLAR is d=10 — a ten-tooth frequency comb, spectral holograms, prime-field arithmetic over GF(11). GALAXY, TETRIS, NOVA, and SUPER sit on the frequency-bin rungs. THETA is d=256 — GF(2⁸), AES polynomial 0x11B. LOTUS is d=512 — frequency-bin × time, rack-scale processing, the top of the ladder.

The field maps to a legal target. A program written for GEMINI cannot silently pretend it is LOTUS. The compiler checks that the declared arithmetic matches the field, that the qudit dimension matches the chip, and that the Reed-Solomon codes are the ones that field registered. Type errors and physics errors are the same error, caught in the same place. Nothing ships to a heater until that check passes.

Arrays are the native data of photonics: phases in a mesh, bins in a comb, clicks on a detector. LUV values are Galois-field scalars, vectors, and rank-2 matrices. Floats appear only where a heater needs an angle. Provenance is a compile-time label — simulated, model, or designed — not a comment a paper can lose.

Source lowers to the chip

Source lowers to QIL, the photonic intermediate representation. Clements decomposition turns an n-mode unitary into n(n−1)/2 Mach–Zehnder phase shifts. A thermal inverse corrects crosstalk across thirty-two DAC channels on an AD5372. Every luvc build emits three artifacts: heater voltages, a quantum-field schedule, and a shot contract. The simulator’s stall semantics match the FPGA behavioral spec. What you simulate is what the chip can do.

Nine backends — Python, Rust, Julia, Go, Metal, NIR, Beam, TypeScript, QIL — and zero runtime dependencies. The language is the runtime. Developers write against recall, not against a prompt window that forgets the binding. The compiler verifies the program can run on that hardware before a photon moves.

The operator says what is true. The machine keeps it.

What this page is honest about

Wave 3 is a close, not the lede. LUV is not Year-1 Memory SKU. Isolated recall on a quiet machine is 13.834 µs. Under load we have also seen 5,127 µs. Those stay the Memory clocks. LUV must not overwrite them. $20 million is an ask — to land the archive first. The language company comes later.

Next in the catalog: Akosha.