Vision

You run software you can't see inside. Every day, on every machine, processes you never wrote and can't read decide what touches your files, your network, your keychain, your camera. You trust them because there has never been another option.

It started with one question: what does this Apple system binary actually do? Apple doesn't say. Google doesn't know. The only way to find out was days in IDA — one binary, by one of maybe ten thousand people alive who read disassembly fluently. So most software is never looked at. We ship it, run it, and hope.

openbinary is the bet that a compiled binary is not a sealed box. It's an unread document — and reading it can be automatic, fast, and open to anyone who can ask a question.

Three movements

Read it. Behavior from the bytes, not the vendor's claims. What it accesses, what it talks to, what it collects, whether it's safe — recovered from the binary itself, in milliseconds, without running it.

At any scale. Not one analyst on one binary over days. Every binary on a machine, inside a firmware image, across a fleet — automatically, and increasingly driven by agents that ask their own questions. Reverse engineering stops being a craft for specialists and becomes a query.

Replace it. A binary doesn't just get understood — it gets reconstructed as compilable Rust you can read, diff, and rebuild. Once a closed implementation is source again, you are no longer required to trust it. You can reimplement it on your terms.

The world this builds

Every binary open: readable, searchable, auditable, comparable across every version. The sealed box becomes source.

And then the part that started it all — sovereignty over your own hardware. Take the best silicon made and refuse to take the software that shipped with it. Run Apple-silicon Macs on Linux. Keep the things you actually use — AirDrop, AirPlay, the AirPods and iPhone handoff — reconstructed from their binaries and reimplemented in the open, secured on your terms. The untrusted OS becomes optional, and porting to each new chipset becomes a pipeline step instead of a multi-year effort.

That this ends in replacement is not an accident of the design. We decompile to Rust — the same language you would reimplement in. Analysis and replacement are the same pipeline, run to different depths.

Why now

Pure Rust makes the engine fast, safe, embeddable, and air-gap-deployable. Static-only means nothing ever executes. And LLMs make the structured output legible to anyone — and let agents drive the analysis themselves. The pieces needed to read the world's binaries, at scale, finally exist at the same time.

Most of this was meant to be years away. Most of it already runs — see Product for what's real today, and Roadmap for what's next.