BUILD

Author against stable contracts.

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

One trait and a manifest.

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

01 bind

wire up once, before traffic

02 handle

one envelope in, dispatches out

03 shutdown

drain before unload

manifest

nameversionabientrypointscapabilitiesrequirementsprovenancecontent_addressprovides

WHAT RUNS TODAY

What you can lean on 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.

The roadmap tracks the status of each →

native daemon + WASM beast + Rhai crittersafe hot-reload and unloadAI self-authoring looped25519 transport between Sanctumsgossip clusteringcontent-addressed registry seedAbode migration + fork / mergecapability gatingHTTP + MCP control surface

QUICKSTART

Clone it. Run the whole loop.

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

Stand it up and poke it.

Three narrated demos drive the real substrate. No mocks. Each rides code the test suite proves.

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.

cargo run -p federation

A federation over TCP

Several Sanctums across 2–3 Realms wired over real ed25519-authenticated TCP: within-Realm fetch, cross-Realm pull, signed reputation, quarantine.

demos/cluster/

Three real nodes

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 →

OPEN PROBLEMS

The hard parts, in the open.

These are unsolved in the general case. If one is your kind of problem, this is the work.

Native trust limit

A native daemon runs in-process and is trusted by admission. Containing native speed without trusting the author is still open.

Cross-tier ABI

Daemons, beasts, and critters run today. Moving a behavior cleanly across tiers without a flag day is ongoing.

Anti-entropy

Realm peers need clean store-and-forward convergence after drift or partition, especially over light-lagged links.

Trust models

Verifiable randomness has a reference creature. Consensus and weighting stay injected, deployment-chosen models.