Furcate OS · Build your own
For open-source builders
Build your own private AI.
AI that runs on boards you can buy today, in your home, your workshop or your lab. The model sits next to the camera or the sensor it reads. There is no cloud account behind it, no subscription to keep paying, and nothing that stops working when the internet does. Every board takes its identity from its own silicon, installs only what you signed, and answers to you alone.
- Gateway
- Raspberry Pi 5 verified
- Leaf
- ESP32 verified
- Controller
- a Linux machine of yours with a TPM verified
- Other boards
- planned
- Models
- run on your own boards
- Cloud
- none required
- Licence
- Apache-2.0
- Source
- GitHub
01
Local AI(6)
The model runs where the data is, on a board you own.
Your cameras, your sensors, your models. On your boards.
Most smart devices send what they see to someone else's computer and rent the answer back. A Furcate build works the other way round. The model runs on the device, or on a board in the same building. Readings stay put unless you send them somewhere, and the system keeps going with the router unplugged.
- 01
On your devices
A leaf runs a small model right next to the sensor it reads. The gateway runs larger ones for the whole room or house.
- 02
No cloud, no subscription
There is no account to keep paying for, and no service whose shutdown turns your hardware into a brick.
- 03
Works offline
Everything a board needs to run is already on the boards. New models and updates arrive when you choose to bring them.
- 04
Keys held in hardware
Each board's identity comes from its own silicon: a one-time-programmable key on the gateway, and a fingerprint of the chip on the leaf.
- 05
Signed updates
System images, firmware and models install only with valid signatures. An update that fails rolls itself back.
- 06
Owner-controlled
A leaf obeys only the gateway it was told to trust, and the gateway obeys only a controller you hold. Nobody outside the building can switch any of it off.
02
The reference build(3)
Two boards you can buy today, and a machine you already own.
A gateway, a leaf, and a machine of yours in charge.
The reference build is one small cell. A Raspberry Pi 5 sits at its head as the gateway. ESP32 boards sit at the sensors as leaves. Above them is a controller: a Linux machine of yours running Furcate OS, holding its key in a TPM. Authority and models travel down, and results travel up. Raw data stays on the lowest board that can handle it.
Your laptop is not in the control path. A controller that stays on holds the authority, so nothing waits for a machine that comes and goes.
Gateway · Raspberry Pi 5
Runs Furcate OS headless from a microSD card. Heads its cell and owns the leaves under it.
- Identity
- a key in the board's one-time-programmable memory
- Updates
- signed, applied live without a reboot, rolled back on failure
- Network
- Wi-Fi or Ethernet, on your own private overlay
- Role
- heads a cell
Leaf · ESP32
Firmware for the board at the sensor. No operating system: an identity, a signed link to its gateway and a model server.
- Identity
- a fingerprint of its own silicon
- Link
- unknown keys and replayed messages refused
- Models
- loaded at runtime, no reflash
- Firmware
- needs two release signatures; a failed update rolls back
Controller · your machine
Any Linux machine of yours with a TPM, running the Furcate OS Server edition. It stays on and holds the authority over the cell.
- Holds
- the key that controls the gateway, sealed in its TPM
- Signs
- the gateway's authority over its cell
- Get it
- Server edition
03
On the bench
What the reference build has actually done, not what it is meant to do.
Every line below happened on real boards.
One gateway and one leaf, the leaf on a basic development board with no extra memory. Each refusal was provoked on purpose. A system that only ever sees valid input has not been tested.
| Board | Check | Result |
|---|---|---|
| Gateway | Identity | a P-256 key burned into one-time-programmable memory; the same node across reboots |
| Gateway | Live update | a new Furcate release installed in 1.6 seconds, with no reboot |
| Gateway | Unsigned or altered image | refused; the running version kept |
| Gateway | Network | on Wi-Fi, joined the owner's private overlay, heading a cell |
| Leaf | Unknown key, replayed messages | refused |
| Leaf | Model loaded at runtime | person detection on a 96 by 96 frame: 475 ms per inference |
| Leaf | Firmware with one signature | refused: two release keys, each in a server's TPM, must both sign |
| Leaf | Firmware that fails its trial boot | rolled back to the previous version by itself |
04
Boards(6)
A board is listed as verified only after it has passed the same bench.
Start with what is verified. The rest is on the way.
Furcate is one operating system on every board that runs Linux, with only the kernel and boot changing underneath. Leaves run firmware instead. A planned board is one we intend to support and have not yet put through the bench.
| Board | Role | Status |
|---|---|---|
| Raspberry Pi 5 | gateway | verified |
| ESP32 development board | leaf | verified |
| Linux server with a TPM | controller | verified |
| Newer ESP32 family boards | leaf, for sensors and for vision | planned |
| Raspberry Pi 5 with an AI accelerator | gateway with an NPU | planned |
| Embedded GPU modules | edge AI, above the gateway | planned |
05
Coming(5)
Designed, not shipped. Each one moves up when it passes the bench.
Next, the gateway learns to talk.
The leaf already runs its own model. The next step is a model server on the gateway, sized for it, with models pulled from a signed registry and nothing sideloaded.
- 01
Language models on the gateway
Small language and embedding models served on the gateway, for local chat, search and summaries of what the leaves report.
- 02
Leaves on Wi-Fi
Today a leaf talks to its gateway over USB. The wireless link uses the same signatures and the same refusals.
- 03
The NPU
Vision models on the gateway's AI accelerator, for faster detection across several cameras.
- 04
Web and tablet
Every board serves the same page for managing and watching its cell, on the local network with no cloud in the path.
- 05
A guided path
From unboxing to a working cell, step by step, on the reference boards.
06
Source
Apache-2.0. Public on GitHub.
The source for the gateway image and the leaf firmware is public.
The open base covers everything that makes a trust claim and everything a builder needs to run a cell: identity, the signed link, the model server on the leaf, signed updates and rollback. The Server edition for the controller is also available to download.
Stewarded by Praecise
Praecise develops Furcate in the open and keeps the open base complete for anyone building their own system. On top of the same foundation it builds its own hardware and optimised systems for production, as Praecise Furcate.