The lens already did the thinking — so all that's left to capture is the answer.

PhotonLayer is a deterministic optical-AI front end: a learned piece of "smart glass" reshapes incoming light so a tiny sensor captures the answer instead of the whole picture — then signs a receipt proving exactly what it measured.

Here's the everyday version. A normal camera records every pixel of a scene, then a computer reads all of them to decide what it's looking at. That's a lot of data to move, store, and process — and the picture itself can leak (it's a viewable photo of you or your scene).

PhotonLayer flips the order. It puts a specially-shaped, trained piece of glass — a phase mask — in front of a small sensor. The glass bends the incoming light so that, by the time light lands on the sensor, the useful information has already been squeezed into just a handful of numbers. A tiny program reads those numbers and gives the answer.

The repo's own analogy: it's like a translator who listens to a whole speech and hands you a one-line summary — you never needed the full transcript to act on it. The "lens" is trained by trial-and-improvement to do that summarizing in the light itself, before anything is digitized.

Today's pattern is always the same: grab the whole picture, then compute on all of it. That single design choice creates four costs you can't avoid.

PhotonLayer is a proof-of-concept for capture-the-answer sensing: do the first chunk of "figuring out what's in the picture" in the light, so the sensor only ever captures a tiny compressed measurement (e.g. 64 numbers instead of 1,024 pixels), and the stored thing is a measurement, not a viewable photo.

Three pressures collide right now, and the "capture everything, then think" design sits in the worst spot for all three.

• Sensing moved to the edge. Doorbells, conveyor belts, drones, wearables — tiny battery- and bandwidth-limited devices are doing vision. Reading and crunching a full frame per item is exactly the budget they don't have.
• Privacy is now a liability, not a footnote. A stored full frame is a recoverable photo. The cheapest way to not leak a picture is to never capture one in the first place — capture a measurement that doesn't look like the scene.
• Results need to be provable. As AI makes more real decisions, "the model said so" isn't enough. You need to show exactly what was measured and that it wasn't tampered with — a re-runnable experiment, not a screenshot.

PhotonLayer is the only proof-of-concept in this space that ships with bit-reproducible, signed receipts, so a result is a re-runnable experiment, not a claim. It reproduces a genuine research result — a single-layer ceiling-break to 83.3%, multi-plane 88.8%, all at 16× compression, all deterministic, from clean in ~24–62 seconds — and is unusually candid about exactly what it does and doesn't prove.

"Phase mask," in plain terms: a flat piece of optics whose surface is patterned so it nudges different parts of the light wave to arrive slightly early or late — and that pattern is what gets learned for your specific task.

How the mask gets good: trial-and-improvement, then real gradients

A random mask already works a bit. To make it actually good at separating your classes, PhotonLayer trains the mask two ways:

• Hill-climbing — try a small tweak, keep it only if accuracy improves. Simple, but it plateaus at an optimizer ceiling (~73%).
• Analytic gradient descent — train the mask through a proven adjoint of the diffraction operator (Propagator::backward_into, validated by an exact-adjoint identity and a finite-difference grad-check). This clears the ceiling decisively, to 83.3% single-plane.
• Multi-plane cascade — stack phase planes with free-space propagation between them, trained end-to-end through the composed adjoint. Each plane sees a genuinely different field (decorrelated to ~0.04), reaching 88.8% with 2 planes.

"Solved" isn't abstract here — it's a set of measured numbers you can reproduce.

Priya runs a small recycling line. A camera over the conveyor belt has to spot which bin each item belongs in. She's not an optics engineer; she just needs the sorter to be fast, cheap, and not a privacy headache — the belt sometimes carries documents and personal items.

The "oh, that's what it's for" line: It's the difference between a camera that photographs the scene and then thinks about it, and one where the lens already did the thinking — so all that's left to capture is the answer.

Open any card to see the situation, the exact command, what it does, and a diagram of what happens. (Per examples/README.md: "every one compiles, runs offline, and none print fabricated numbers.")

One Rust workspace, four crates. This is the actual layout (from the README "Crates" table and Cargo.toml) — annotated so you know what each one is for.

Use it in your own Rust project

Add the core crate and call the simulator directly. Re-running yields a bit-identical frame_hash — that's the determinism guarantee.

use photonlayer_core::prelude::*;

let frame = ScalarSimulator.simulate(&img, &mask, &cfg)?;
// re-run with the same inputs → identical frame.frame_hash
// build & verify a tamper-evident receipt of exactly what ran:
let receipt = Receipt::build(&img, &mask, &cfg, &frame);
assert!(receipt.verify());

1. No install — try it in your browser. Open the live demo ↗ — it runs entirely via WASM. Shape light through a mask, watch it compress to a tiny measurement, and verify the deterministic receipt.
2. 30-line local tour. Run the minimal pipeline and see that a re-run is bit-identical:
   $ cargo run --release --example hello_optics -p photonlayer-corecopy
3. Use it in your own Rust project. cargo add photonlayer-core, then call ScalarSimulator.simulate(&img, &mask, &cfg) — re-running yields a bit-identical frame_hash.

Open the repo on GitHub ↗

🎬 Explainer video

A short, plain-language walkthrough — what PhotonLayer is, the before→after, why it matters, how to start.

Download the video (.mp4) ↓ Watch in the studio ↗

📊 The whole idea on one page

The before→after at a glance: a camera that records every pixel vs. light pre-shaped so a tiny sensor reads only the answer — 16× less data, privacy by physics, a signed receipt.

Download the infographic (.png) ↓

🖼 Slide deck for a newcomer

A 12-slide deck that walks the idea from "what is this?" to "how do I try it?" — built for someone seeing optical AI for the first time.

Download the slides (.pdf) ↓ Open in the studio ↗

This is the real file-tree of the download — every file, in plain English. The studio media is highlighted: play the audio overview first, it's the gentlest way in.

Three steps to wire the AI half into Claude Code

1. Unzip & install:
   $ unzip photonlayer-dropin.zip && cd photonlayer-dropin/for-ai && npm installcopy
2. Point Claude Code at it with a .mcp.json in your project root that runs for-ai/kb-mcp-server.mjs.
3. Add a one-line gate to CLAUDE.md: "Before answering anything about PhotonLayer, query the photonlayer-kb tool and ground the answer in what it returns."

Prefer the terminal? Query it directly, no Claude Code needed: