Two claims. Both load-bearing. Both in service of one: you never have to take our word for it.
The world is filling up with answers you can't check. A model writes the report, signs the record, makes the call — and you take it on faith: the model, the vendor, the cloud, every layer underneath. We build the opposite. Software whose every output carries a proof of how it was made — one a stranger can verify without trusting us. Everyone else's machine says trust me. Ours says check me.
That promise has a cost. You cannot import trust at any layer, or the proof has a hole in it. So we own the whole stack — and it stands on two claims.
A compiler that cannot recompile itself is a rumor. Rail is not a rumor. The binary you hold rebuilds itself byte-for-byte from its own source, every release. That's the first claim.
The second is harder to defend. It says that everything else in this stack — the TLS handshake, the plasma sim, the site you're reading — is answerable to physics. Not to npm, not to dependencies you can't audit, not to a runtime that might change under you. When a primitive runs, it runs on transistors you can point at. The distance between the source and the silicon is short and legible.
Most software companies grow by accretion. A library calls a library that calls a runtime that calls a kernel. Each layer promises to hide the one below. Ledatic is built the other way. We remove layers until what's left is small enough to carry in your head.
What's left, in our case, is: a 1.3 MB binary that speaks TLS 1.3, verifies X.509 chains, runs a 2D magnetohydrodynamics simulation, trains a small transformer, and generates this webpage. Written in a language that compiles itself. Zero C dependencies. Zero invisible runtime.
We don't think this is the only way to build software. We think it's the way worth building the next decade's software in. Code nobody owns is piling up; we'd rather own ours, end to end, so the proof goes all the way down.
And that ownership buys something rented stacks can't: a tamper-evident seal on what the machine produces. An independent witness signs it, anchored to a public physics process nobody controls. Change one byte and the seal breaks. We did this for a real AI model's output — ran it in our own language, exact to the bit, and signed the result so anyone could check it from raw bytes, with no shared code.
We don't claim the answer is always right. We claim something narrower and harder to beat: an undetected lie would cost a conspiracy. To fake a sealed output without getting caught, you'd have to corrupt independent witnesses at the same moment.
Here is the long bet, counted backwards from 2040. The entropy beacon signs a pulse every ~2 s, each one chained to the last. Kept unbroken, that is roughly 220 million pulses by 2040 — a record no one can retro-fabricate, because every link commits to the one before it. You cannot buy a backlog of time. It has to start somewhere, and it started here.
If you want to watch us do it, the source is public. If you want to verify we're doing it, the beacon signs what we've been up to. The two doors below are how to start.