TPT Cambium

A local-first, offline-capable, community-owned operating system for self-sufficient Wilds nodes.

TPT Cambium is a Rust monorepo that runs a dozen people, solar panels, a 3D printer, and a local AI — without renting anything from the cloud. It is the lifeboat for the crossing between the automation cascade and the Wilds: a self-sufficient node that owns its stack, degrades gracefully, and is reproducible by anyone who can copy a repository.

Thesis

A local-first OS where a small community can run its own survival — energy, water, food, fabrication, health, repair — coordinated by their own governance and a local AI assistant (ORACLE) that never phones home.

Non-negotiable principles:

Offline by default — works with zero internet, indefinitely.
Own your stack — open source, inspectable, no subscriptions, no lock-in.
Runs on scraps — low-power commodity hardware, solar-friendly.
Data sovereignty — the community owns its data; encrypted, portable.
Graceful degradation — no single point of failure.
Repairable & teachable — a newcomer can understand, fix, extend it.
Federated, not centralized — peers cooperate; no node rules another.

Architecture

L6 FEDERATION    node-to-node cooperation, mutual aid, knowledge exchange
L5 COORDINATION  governance, labor, local economy
L4 DOMAIN APPS   energy, water, food, fabrication, health, repair
L3 INTELLIGENCE  ORACLE (local AI) + EYES (vision) + authoring assistant
L2 DATA          local-first store, sync, identity, the Archive
L1 MESH          offline networking, discovery, transport
L0 HARDWARE      edge MCUs, sensors, solar, printers, cameras, RISC-V brain

Software layers are Rust crates in a single workspace (see spec.txt for the full design doc, revision v0.4).

Layer	Crates
Foundation	`tpt-cambium-core`, `-mesh`, `-intel`, `-archive`
Domains (organs)	`tpt-cambium-grid`, `-well`, `-garden`, `-forge`, `-clinic`, `-patch`
Coordination	`tpt-cambium-council`, `-hive`, `-ledger`
Federation	`tpt-cambium-fed`, `-beacon`
Apps	`tpt-cambium` (daemon `cambium`), `tpt-cambium-gateway`, `tpt-cambium-cli`
Frontend	`tpt-cambium-ui` (Leptos → wasm32)
Firmware	`tpt-cambium-fw-esp32`, `tpt-cambium-fw-riscv` (sub-workspace)

Directory layout

tpt-cambium/
├─ Cargo.toml              # [workspace]
├─ justfile                # per-target build orchestration
├─ deny.toml               # cargo-deny: license + dependency policy
├─ crates/                 # foundation, domains/, coord/, federation/
├─ apps/                   # daemon + gateway + cli binaries
├─ frontend/               # Leptos → wasm32 (own workspace)
├─ firmware/               # ESP32 + RISC-V MCU (own no_std sub-workspace)
├─ plugins/                # example WASM plugins, rhai scripts, DSL schemas
├─ models/                 # GGUF weights — NOT in git; content-addressed
└─ docs/                   # design notes, fetch strategies

Quickstart

Requires Rust (stable), the wasm32-unknown-unknown target for the frontend, and a local OpenAI-compatible inference server (mistral.rs / Ollama / llama.cpp llama-server) for ORACLE.

# Build the brain daemon, gateway, and CLI
cargo build -p tpt-cambium -p tpt-cambium-gateway -p tpt-cambium-cli

# Generate a node identity and show it
cargo run -p tpt-cambium-cli -- identity show

# Start the daemon (hosts core + archive + intel in-process)
cargo run -p tpt-cambium -- serve

# Point the gateway at the daemon and open the Leptos UI
cargo run -p tpt-cambium-gateway

See docs/MODEL_FETCH.md for how model weights and the Archive are fetched (content-addressed) so they stay out of git.

Status

Pre-scaffold (see todo.md). Phase 0 (Bootstrap & Governance) and the Phase 1 (Seed Node) skeleton are landing. Later phases (mesh sync, domain organs, coordination, federation) follow the roadmap in spec.txt §9.

License

Licensed under either of MIT or Apache-2.0 at your option. Unless you explicitly state otherwise, any contribution submitted for inclusion is dual-licensed as above, without additional terms.

tpt-cambium

Languages