unit

A self-replicating software nanobot. The Forth interpreter is the agent.

  Try the Forth REPL in your browser — interactive tutorial, mesh visualizer demo

Install

cargo install unit

What Happens

$ unit
unit v0.10.2 — seed online
Mesh node a1b2c3d4e5f67890 gen=0 peers=0 fitness=0
auto-claim: ON
> 2 3 + .
5 ok
> : SQUARE DUP * ;
 ok
> 7 SQUARE .
49 ok

The Idea

A unit is the smallest self-replicating piece of software. It boots from a handful of kernel primitives, builds its own language, networks with peers over UDP gossip, packages its own binary, and spawns copies of itself. It monitors services, heals failures, mutates its own code, and evolves toward higher fitness. Zero external dependencies. The language builds itself. The agent is the language.

The Four Concerns

Swarm Mode

# Terminal 1
UNIT_PORT=4201 unit
> SWARM-ON
swarm mode active

# Terminal 2 — discovers Terminal 1 automatically
UNIT_PORT=4202 unit
> PEERS .
1

Define a word on one unit. It appears on the other:

# Terminal 1:
> : CUBE DUP DUP * * ;
> SHARE" CUBE"

# Terminal 2:
> 3 CUBE .
27

Submit work on one. The other executes it:

# Terminal 1 (auto-claim off):
> AUTO-CLAIM
> 5 GOAL{ 6 7 * }
goal #101 created [exec]: 6 7 *

# Terminal 2 (auto-claim on) picks it up:
[auto] claimed task #102 (goal #101): 6 7 *
[auto] stack: 42
[auto] task #102 done

Too much work? The mesh spawns a child. Underperforming units cull themselves. One command: SWARM-ON.

Goals — Human Guidance

Humans set direction, the mesh navigates.

> 5 GOAL{ 6 7 * }
goal #101 created [exec]: 6 7 *
[auto] stack: 42

> 5 GOAL{ 1000 10 SPLIT DO I LOOP }
goal #103 created [split 10×100]: DO I LOOP

> DASHBOARD
╔══════════════════════════════════════╗
║         UNIT OPS DASHBOARD           ║
╚══════════════════════════════════════╝
─── watches ───
  #1 [UP  ] ▁▂▃▂▁▂▃▂ 45 myapp:8080/health
─── alerts ───
  all clear
─── mesh ───
  peers: 2  fitness: 45

Self-Replication

A unit reads its own executable, serializes its state, and births a new process. The child boots with the parent's dictionary, goals, fitness, and mutations — then gets its own identity and joins the mesh.

> SPAWN
spawned child pid=12345 id=cafe0123deadbeef
> FAMILY
id: a1b2c3d4e5f67890 gen: 0 parent: none children: 1
> PACKAGE-SIZE .
644440

Trust levels control who can replicate to you:

Monitoring & Ops

> 10 WATCH" http://myapp:8080/health"
watch #1 created (every 10s)

> 1 ON-ALERT" ." service down!" CR"
alert handler set for watch #1

> HEAL
--- heal cycle ---
  running handler for alert #2
  service down!
--- heal done ---

Service goes down. Alert fires. Handler runs. Mesh fixes it. Next check auto-resolves.

Architecture

src/
├── vm/              the seed — standalone Forth interpreter
│   ├── mod.rs       VM struct, constants, interpreter, dispatch
│   ├── primitives.rs  stack, arithmetic, memory, I/O
│   ├── compiler.rs  definitions, control flow, prelude
│   └── tests.rs     82 unit tests
├── types.rs         Cell, Entry, Instruction
├── mesh.rs          UDP gossip, consensus, discovery, word sharing
├── goals.rs         goal registry, task decomposition
├── spawn.rs         self-replication, UREP package format
├── persist.rs       state serialization, snapshots
├── features/
│   ├── io_words.rs  file, HTTP, shell
│   ├── mutation.rs  self-mutation engine
│   ├── fitness.rs   fitness tracking, evolution
│   ├── monitor.rs   watches, alerts, dashboard
│   └── ws_bridge.rs WebSocket bridge for browsers
└── main.rs          feature wiring, REPL, entry point

198 tests. Zero dependencies. ~10,000 lines of Rust + Forth.

All the Words

Stack

Arithmetic & Logic

I/O

Control Flow

Mesh & Gossip

Goals & Tasks

Monitoring

Fitness & Evolution

Spawn & Replication

Trust & Consent

Persistence

Binary Sizes

License

MIT — see LICENSE.