cargo run -p walkthrough One node, the whole loop
An AI authors → compiles → signs → runs a creature, then a running self migrates between two Sanctums with its state cryptographically intact.
BUILD
Implement one trait. Declare a manifest. Your creature runs, reloads, and travels on the same substrate the lab runs on. A script-tier critter takes no compiler at all.
THE SURFACE
A creature is a unit of capability. It implements Creature (three methods), speaks
through the Bus, and carries one manifest.
The SDK (forge) depends only on aether and sigil, never on
the kernel. That keeps native daemons, WASM beasts, and script critters on one load path.
Native rule: spawn every thread through forge::spawn so the Sanctum can join it
before unload.lifecycle
wire up once, before traffic
one envelope in, dispatches out
drain before unload
manifest
WHAT RUNS TODAY
The source-first release is pre-1.0 and unaudited, but these mechanisms are real enough to build against. Native code is still trusted by admission; hosted federation and production hardening come later.
QUICKSTART
Alpha is open source under GPL-3.0. Clone the repo and the narrated walkthrough drives the real substrate end to end: author → build → sign → admit → load → run → migrate, no mocks.
$ git clone https://github.com/gawd-ai/alpha
$ cd alpha
$ cargo run -p walkthrough # the whole loop, narrated Then boot a live node and author into it in plain English. A critter is one Rhai function: sandboxed, metered, authored with no compiler, then written, signed, admitted, and hot-loaded in milliseconds:
// a critter is one Rhai function: no crate, no compiler
fn handle(env) {
env.text.to_upper() // reply with the message, upshouted
} $ cargo run -p alpha -- node # boot a live node → the alpha> REPL
alpha> author --critter reverse a string
✓ authored → signed → admitted → hot-loaded critter as id=7
alpha> send 7 hello
reply: olleh That is one node. To make a fabric, build both poles and mesh them. alpha is the control surface; omega serve is the federation server.
Boot an omega node, seed your alpha to it, then admit it from the REPL — every link is mutually
ed25519-authenticated, so each end must already hold the other's key (no TOFU):
$ cargo build --release -p alpha -p omega # two poles: control + fabric
$ alpha node --node-id op --cluster-listen 127.0.0.1:9302 # your control surface
$ omega serve --node-id fab --realm crew --cluster-listen 127.0.0.1:9301 \
--seed [email protected]:9302#<op-pub> # a fabric node, seeded to your alpha
alpha> cluster join [email protected]:9301#<fab-pub> # admit it; gossip carries the rest
op ── fab (connected) Add more omega gateways — one per Realm, with --realm and --peer-realm — and they federate across Realms. See the whole cross-Realm story in cargo run -p federation, or as real processes in demos/cluster/; drive any
node over MCP or the HTTP API too.
A native daemon is the other end: full Rust, real threads, full speed. Write the type, implement the trait, and declare it. No kernel imports appear anywhere in it.
use forge::prelude::*;
#[derive(Default)]
struct Echo;
impl Creature for Echo {
// wired once, before any envelope; keep a Bus handle here if you emit.
fn bind(&mut self, _ctx: CreatureCtx) {}
// one envelope in, dispatches out.
fn handle(&mut self, env: Envelope) -> Outcome {
let reversed: Vec<u8> = env.payload.iter().copied().rev().collect();
Outcome::reply(&env, reversed) // emit a reply back through the Bus
}
}
forge::declare_creature!(Echo); Hand the node a manifest (a JSON file) and the compiled .so:
{
"name": "echo",
"version": "0.1.0",
"abi": { "backend": "daemon", "abi_tag": "gawd_creature_v1" },
"entrypoints": [{ "name": "handle", "signature": "(Envelope) -> Outcome" }],
"provides": ["handler"]
} alpha> load ./echo.json ./target/debug/libecho.so
loaded id=7
alpha> send 7 hello
reply: olleh
alpha> reload 7 ./target/debug/libecho.so # swap in a new build, live
reloaded id=7 (threads joined, rss stable) The reload is not a restart. The kernel drains the old instance, joins its threads, then loads the new one. A 1000-cycle loop proves the path stays RSS-stable and leak-free.
SEE IT RUN
Three narrated demos drive the real substrate. No mocks. Each rides code the test suite proves.
cargo run -p walkthrough An AI authors → compiles → signs → runs a creature, then a running self migrates between two Sanctums with its state cryptographically intact.
cargo run -p federation Several Sanctums across 2–3 Realms wired over real ed25519-authenticated TCP: within-Realm fetch, cross-Realm pull, signed reputation, quarantine.
demos/cluster/ A numbered runbook that stands up three nodes across both poles — an omega serve anchor plus alpha node operators — forms the gossip mesh, cross-executes, and attaches an AI to each over MCP.
Or drive a live node yourself: boot it, author from a prompt, watch the sense-tape, then attach an AI over MCP. See the control surface →
READ THE SOURCE
Alpha is source-first and GPL-3.0. Nothing here is slideware. Every claim on this site clicks through to code you can clone, read, and run. Good places to start:
README.md The pitch, the workspace map, and runnable demos. Every claim links to a test.
CONTRIBUTING.md Toolchain, the two contracts, and how to add a creature on each tier.
cosmos/forge/ The SDK you build against: the Creature trait, declare_creature!, the prelude.
cosmos/sanctum/ Three model-free kernel jobs: lifecycle, routing, admission.
cosmos/sigil/manifest.schema.json The at-rest manifest contract, drift-guarded against the Rust type.
cosmos/sanctum/tests/ The end-to-end tests behind every governing loop. No mocks.
AGENTS.md Machine-first orientation: the map an AI reads before touching the repo.
LICENSE GPL-3.0-or-later. Source-first, copyleft.
OPEN PROBLEMS
These are unsolved in the general case. If one is your kind of problem, this is the work.
A native daemon runs in-process and is trusted by admission. Containing native speed without trusting the author is still open.
Daemons, beasts, and critters run today. Moving a behavior cleanly across tiers without a flag day is ongoing.
Realm peers need clean store-and-forward convergence after drift or partition, especially over light-lagged links.
Verifiable randomness has a reference creature. Consensus and weighting stay injected, deployment-chosen models.
Get build notes.
Source releases, demos, and notes when there is code to try.