8b-is ENGINE — the world-model sim-MMO + game engine. A world is a geometry of admissible continuation: Rust 2024 + Go 1.26, NATS actor-mesh, quant physics, wgpu, Steam (macOS AS + Linux). vaked.dev · 8b.is
  • Rust 39.9%
  • JavaScript 36.8%
  • HTML 15.6%
  • Go 3.4%
  • Python 1.4%
  • Other 2.3%
Find a file
Repository files (latest commit first)
Filename Latest commit message Latest commit date
2026-10-21 09:51:26 +09:00
.github/workflows ci: the wasm surface answers its new name — the rename's binary ships, sealed 2026-09-10 12:19:24 +02:00
6502-is fix(security): link libzigkern.a with +whole-archive,-bundle (FR-ENG-01) and update rustls, quinn-proto, h2, and vite 2026-10-18 21:04:08 +09:00
assets feat: the hook kit — SOTA, Claude-Code-like, under the consent doctrine 2026-09-12 17:07:09 +02:00
client ci: the wasm surface answers its new name — the rename's binary ships, sealed 2026-09-10 12:19:24 +02:00
crates feat(admissibility): add governance_trilogy_instances (CMS, SAS, TCT) as CT-000/CT-015 witnesses 2026-10-21 09:51:26 +09:00
docs feat(admissibility): wire spherepop_instance CT-000/CT-015/CT-016 witness 2026-10-21 00:08:46 +09:00
enthea docs: the token-budget hooks — Spotify's move, in the fork's syntax 2026-09-12 17:15:25 +02:00
entheai fix(security): link libzigkern.a with +whole-archive,-bundle (FR-ENG-01) and update rustls, quinn-proto, h2, and vite 2026-10-18 21:04:08 +09:00
examples feat(world): the world runs without you — GAIA, keeper, world-core, browser mesh, the two folds 2026-09-09 07:42:08 +02:00
games games: the mini-games lane opens — Spike Sprint seated as the first browser lane 2026-10-07 08:20:43 +09:00
music.vaked.dev feat: the hook kit — SOTA, Claude-Code-like, under the consent doctrine 2026-09-12 17:07:09 +02:00
proto feat: actor-mesh EventBus, visual direction, credits, quick-start, git-lfs 2026-09-08 13:05:30 +02:00
scripts ci: the wasm surface answers its new name — the rename's binary ships, sealed 2026-09-10 12:19:24 +02:00
tools feat: the circumsolar momentum bank — a conservation-exact PoC 2026-09-12 09:16:53 +02:00
.gitattributes feat: actor-mesh EventBus, visual direction, credits, quick-start, git-lfs 2026-09-08 13:05:30 +02:00
.gitignore feat(ternary): the dream, in the browser — the third surface made visible 2026-09-10 09:30:21 +02:00
Cargo.lock feat(pipeline): wire CT-000 admissibility gate and golden receipt 2026-10-21 08:17:52 +09:00
Cargo.toml Bridge the language cousin: Spherepop — innermost-first pops as admissible continuation 2026-10-13 03:31:32 +09:00
CHANGELOG.md feat(lane): the obliterated lane — plan, the world dataset, the notebook, the colab-mcp wiring 2026-09-10 15:44:47 +02:00
CONTRIBUTING.md feat: scaffold 8b-is engine repo — the MMO + game engine of the chaos overworld 2026-09-08 11:49:03 +02:00
CREDITS.md feat: actor-mesh EventBus, visual direction, credits, quick-start, git-lfs 2026-09-08 13:05:30 +02:00
GEMINI.md feat: v0.7.0 — the kit edge: crates, Zig, the seal, the sandboxes, the engrams 2026-09-10 11:48:33 +02:00
LICENSE feat: scaffold 8b-is engine repo — the MMO + game engine of the chaos overworld 2026-09-08 11:49:03 +02:00
MERGED.md feat: the 8-bit seed — 6502-is (3d visual6502) joins the engine 2026-09-12 11:30:18 +02:00
opencode.json chore(swarm): pin the model matrix on the opencode go/zen catalogs 2026-09-09 11:55:24 +02:00
README.md feat(admissibility): add governance_trilogy_instances (CMS, SAS, TCT) as CT-000/CT-015 witnesses 2026-10-21 09:51:26 +09:00
sandbox.sh polish: align the roadmap with shipped work + fix dead patterns 2026-09-08 14:12:16 +02:00
scaffold.sh feat: v1.9.0 wave — the sidecar mirror, the dream eval, the engram demo, the tightened seal 2026-09-10 12:13:00 +02:00
SEMVER.md feat: v1.9.0 wave — the sidecar mirror, the dream eval, the engram demo, the tightened seal 2026-09-10 12:13:00 +02:00
swarm.sh chore(swarm): pin the model matrix on the opencode go/zen catalogs 2026-09-09 11:55:24 +02:00

8b-is Engine — the chaos overworld

8b-is ENGINE

the MMO + game engine of the chaos overworld
one door, many lanes · coherence without collapse · the ternary wire {-1, 0, +1}

Engine · Games · Design v2 · Constellation · Contributing · Roadmap


table of contents


the engine

8b-is Engine is the constellation's game lane grown up: a Rust/Go engine for persistent, sacred-geometry, non-Euclidean worlds — WoW's persistent zones and chat matrix, Diablo's dense swarms and polyhedral loot, the 90s platformers' momentum and bounce, inside a Minecraft-like universe of tetrahedra, cubes, and icosahedra.

Every artifact is a pure function of a seed line. The engine speaks in three symbols: {-1, 0, +1} — the ternary wire at the center of the whole. Replayable ⇒ admissible; the same inputs always produce the same world.

architecture

Subsystem Stack Notes
Core engine Rust, edition 2024 wgpu (Metal/Vulkan), winit, bumpalo frame arenas, 64B cache-aligned entity structs
Network multiplexer Go 1.26 zero-copy sync.Pool (1450B MTU), mmap ring buffers over C-FFI, NATS JetStream mesh
Physics Rapier3D + SDF raymarching analytical SDF collisions (∇f normals), warp tensors for non-Euclidean zones, geodesic vector gravity
EventBus dual-tier Rust lock-free SPSC/MPMC intra-engine; Go/NATS inter-process; 8-bit quantized payloads
I/O HAL everything since the 60s TTY/RS-232 (110–115200 baud), BLE, HID/evdev, mobile touch, Steam Input
UI dual-mode WebGPU glassmorphic + VT100/ANSI terminal fallback
Add-ons Luau via mlua WoW-style Interface/AddOns, Vaked API, capability-gated
Editor LSP vaked-lsp one gateway: clangd + rust-analyzer + gopls + luau-lsp behind one endpoint
Installer scaffold.sh self-contained bash: deps + QWave + project scaffold
VCS jj jujutsu on the git backend — jj st · jj describe · jj git push (wired in by scaffold.sh)
Toolchain just / Taskfile mold/wild linkers, Naga shader validation, wasm32 targets
Deployment K8s + sidecar mesh SpatialNode CRDs, chat zone pods, NATS master bus
Platform macOS + Linux + Steam Steam Deck native Vulkan, macOS Metal, mobile, web

performance doctrine

Zero allocation in the tick loop · frame-bumper arenas · over-relaxed sphere tracing (ω = 1.2) with AABB pre-pass · quarter-res raymarching + temporal reprojection · PGO + Green Tea GC on the Go side · -trimpath -ldflags="-s -w" · fieldalignment · sync.Pool discipline.

Target matrix: <2.1 ms GPU frame @4K · <0.3 ms per 10k entities · 0 allocs/op network · <50 ns event dispatch · <5 µs WASM mod invocation.

the fauna subsystem

Five layers, from skeleton to skin:

  1. Platonic skeleton — non-Euclidean joints: tetrahedra, cubes, icosahedra
  2. Sacred voxel shell — quantized grids, SDF smin blending
  3. 90s kinematics — squish/stretch, spring dampers, spin attacks
  4. Swarm & persona AI — boids + Diablo density + WoW aggro threat tables
  5. Shader & palette — reaction-diffusion skins, HSV quantized neon, emissive sacred runes

the games

PSU NIVERSEQ — the chaos overworld

The flagship. Elder Scrolls-style origin lore on birth (ROOTLORE per root, OATHS, FIRST enemies, ring sayings), four deity bosses — Chenrezig (thousand-armed storm), Tara (star that moves), Yamantaka (wrathful death-binder), Mahākāla (your own shadow) — and the ZEN mechanic: stand still to charge; only ZEN-stun can wound the deity. The first hero is MAHĀKĀLA, the great black one, the lord of the tent.

MAHĀKĀLA — the first hero

POLYHEDRAL SANCTUARY — the first demo

The playable prototype: seeded sacred-geometry critters, stomp-to-split (Diablo), bounce (90s), gold sparkle pickups, /say bubbles, zone banners. One physics, two runtimes — the floor is the JS twin of the Rust engine's fauna stack.

the polyhedral sanctuary

Play it now: sanctuary-floor.html · plenum-floor.html · infinite-floor.html · summit-floor.html

the mini-games lane — Spike Sprint

The door for small games (one door, many lanes) now lives at games/ — first seated: Spike Sprint, a browser endless-runner by shifulegend (MIT, vendored verbatim): tap to hop, hold to fly, and a spiked barrel that is very patient. The lane's conventions live in games/README.md.

the floors

Every floor is a pure function of a seed line — the same artifact, every machine, every time:

Floor The lane
sanctuary-floor the first demo — stomp, split, bounce
plenum-floor the polarized plenum — Ising bridge, MEM|8 survival
infinite-floor the ∞-telescope — the stir
summit-floor the multi-inclined plane — Mach's fixed stars
soil-floor permaculture — the garden
gameforge-keeper the 108-gate hum system — ring blessings
teleport-floor quantum gate teleportation — fidelity 1.000
backyard-ultra-floor loop survival — last one standing
psuniverseq-tutorial the interactive first-walk tutorial
psuniverseq the chaos overworld — Mahākāla, the ZEN mechanic

design v2 — the serverless overworld

The engine's next chapter, scaffolded in 8b-is/public-documents:

the world is a name; the name is a route; the route is the server. Coherence without collapse, now with no server to collapse.

the presence layer (AR/VR)

One WorldState, many WorldSurfaces. Every device is a presence with a sensory profile:

Device Profile The world looks like
Desktop / phone full / touch spatial the chaos overworld, wgpu, glassmorphic HUD
Meta Ray-Ban audio-first the world as a 432Hz binaural layer — the WoW chat matrix becomes the WoW radio matrix; capture is the only eye
Apple Vision Pro room spatial the room is the zone — volumetric fauna, spatial chat bubbles, the tent as the space

the protector node

The 1-bit 42-108D guardian, from the sovereign library's gates (ཧཱུྃ ▽◈▽☸◈◈▽☸◈ … 🕯📿🪷). A lightweight network entity that guards one zone: 1-bit BitNet b1.58 inference (kilobytes, runs on the edge), one vertex of a 42D hypermesh, projecting the 108-fold tent, running the sovereign pass gate — "zero detection, zero pain", the pink mode, the lotus. The gameforge keeper grown up.

the trick library

The demoscene lane promoted to the hot path: branchless abs, the ternary signTrick (the sign IS the trit), isPow2/nextPow2 arena sizing, popcount load metrics, gray-code snapshot deltas for the network, LUT boards over branches, the 4KB/frame add-on discipline. The old machines taught one lesson: every byte counts, and every lookup table is a seed.

the world-as-DNS

The server dissolves into the network. The game world is a DNS namespace — zone.crystal.pocoo.vaked.dev resolves to the zone's Durable Object, its protector node, and its peer set. Cloudflare anycast is the server; moment-to-moment gameplay is P2P (the Destiny lesson: simulate as little on the network as possible); deterministic lockstep where it pays (the 1500-archers lesson). There is no server. There is only the name, the route, and the tent.

the ternary wire mandala


quick-start — local dev

the full E2E bootstrap (zero → running world)

git clone git@github.com:8b-is/8b-is-engine.git && cd 8b-is-engine
./scaffold.sh               # == bootstrap: deps → jj → git-lfs → NATS → verify
./scaffold.sh verify        # probe every lane (tools + engine + mesh + assets)
./scaffold.sh mesh          # start nats-server + run a live NPC actor (the world runs without you)
./scaffold.sh export "the sanctuary at dawn"   # seed → manifest → Blender EEVEE render
./scripts/e2e.sh            # the E2E oneshot: tests + verify + floors + the live lane

scaffold.sh is idempotent and self-contained (macOS + Linux, Silverblue rpm-ostree aware). It installs: jj (VCS) · uv · cargo · go · just · node · gh · wrangler · git-lfs · nats-server · rg/bat/fd/ eza/zoxide/delta · blender · hyperfine/tokei, then wires jj + LFS, builds the vaked-nats actor-mesh sidecar, and verifies every lane.

the day-1 loop

jj st                              # the working copy is a commit
jj describe -m "feat: ..."         # name the change (PR = signature)
jj git push                        # ship to origin + upstream

./sandbox.sh lsp rust-analyzer     # wrap the LSP (bwrap / Apple Container)
./sandbox.sh run docker.io/library/rust:latest -- cargo build   # isolated build

the actor-mesh (NATS)

nats-server -p 4222                # the bus (or ./scaffold.sh mesh)
# the MCP sidecar — publish/subscribe/request on actor subjects:
echo 'Content-Length: ...' | vaked-nats   # or drive via the umbrella
uv run --with nats-py python examples/mesh-npc.py --name ལྷ --seed 42   # a living NPC
uv run --with nats-py python examples/gaia.py --brief "sanctuary·overworld"  # the world-memory ACT
uv run --with nats-py python examples/world-keep.py   # the zone keeper: M folds, H commits, refusals durable
uv run --with nats-py python examples/world-keep.py --replay   # verify fold(seed, H) = M

An actor is a name; a name is a subject; a subject is a route. The mailbox, the supervisor, and the DNS are one. See docs/eventbus-actor-mesh.md.

the creative swarm (DeepSeek V4 vision)

./swarm.sh "the painted-forest dawn zone, ZEN mechanic"   # 5 roles fan out
./swarm.sh --roles visual-artist,ui "the pink tent HUD"   # vision roles only

Five opencode subagents — game-art · game-design · frontend · ui · visual-artist (config in opencode.json). The vision roles run on deepseek/deepseek-v4-flash-vision-exp; all five share one byte-identical prompt prefix so DeepSeek's automatic context caching serves the shared doctrine+palette block as a cache hit. Artifacts land in out/swarm/<role>/.

the MLX coder lanes (local, abliterated, memory-aware)

uv run --project ../mlx-sidecar python sidecar.py memory   # total / free / best fit
uv run --project ../mlx-sidecar python sidecar.py start    # auto-picks a coder that fits your RAM

The fastest top-SWE-score coder your machine can hold, served locally on an OpenAI-compatible port. Catalog: Qwen3-Coder-Next abliterated MLX · Qwen2.5-Coder-7B OBLITERATUS · the 42B abliterated lane.

assets & LFS

Large binaries (sprites, audio, renders) are git-LFS pointers tracked by .gitattributes; the Kenney CC0 packs live under assets/vendor/kenney/ — sources and licenses in CREDITS.md. git lfs pull fetches them on a fresh clone.


host system requirements

dev host (macOS)

Need Minimum Recommended
OS macOS 15 (Apple Containers need 26) macOS 26
Chip Apple Silicon M1 M3/M4 (Metal + MLX)
RAM 16 GB 32 GB+ (the MLX coder lanes: 7B ~6 GB · 30B-A3B ~20 GB · 42B ~24 GB free)
Disk 10 GB free 40 GB (models + Blender + LFS assets)
Toolchain Xcode CLT, Homebrew rustup, uv, jj (all via ./scaffold.sh)
Extras — Blender (the export lane), nats-server, Apple Containers (macOS 26)

dev host (Linux)

  • Any modern distro (Silverblue rpm-ostree aware); ./scaffold.sh uses apt/dnf/pacman + cargo.
  • Sandboxing: bubblewrap (LSP wrapping) + rootless podman (build images).
  • No MLX lane (Apple-only) — use the swarm + the cloud DeepSeek lane there.
  • GPU for the client renderer: Vulkan (wgpu).

the integration targets (build hosts)

Target Where it builds Notes
Blender export macOS/Linux, Blender 3.6+ (EEVEE) ./scaffold.sh export "brief"
Unity any host + the Unity Editor vaked-mcp unity_batch/unity_peek; Unity Cloud SDK lane
Unreal Engine 5 Windows (Uika is Windows-x64) or UE on macOS Uika Rust bindings; vaked-lsp for UE C++
Steam macOS + Linux (+ Windows via Uika/Unity) Steamworks SDK, Steam Input, Steam Deck Vulkan

the game itself (players)

  • Browser floors: any modern browser, no install — the current playable surface (pocoo.vaked.dev).
  • Steam (the shipping lane): macOS (Metal) + Linux/Ubuntu (Vulkan) via wgpu; Steam Deck native Vulkan. UE/Unity/Blender are integration seams (renders of the seed), not shipping requirements — the I/O HAL speaks everything since the 60s/70s, so every future surface is a device class, not a port.

the constellation

The engine is one lane of a larger garden. The links that matter:

Lane Where
The research vault 8b-is — raw research, game studio, EOS-CLA
Public design docs 8b-is/public-documents
The game lane centerfugeq — quantTernEngine, the floors, retro
The sovereign library pocoo.vaked.dev — the protector gates, the miner, the posts
The studio game-studio-vaked — business lane, governance, EOS-CLA v1
The editor LSP vaked-lsp — one gateway, many languages
The browser node qwave — the WebKit-native deployment surface
The fleet nix-base — the NixOS hosts that run the private brain

contributing

The engine is open forever — see CONTRIBUTING.md and the EOS-CLA. The short version:

  • A PR is a signature. By opening a pull request you accept the EOS-CLA: your contribution stays open forever, your liability is bounded (crash-and-burn), and AI swarms are first-class contributors with synthetic provenance.
  • Tables over branches. Deterministic, seeded, zero-surprise. The same inputs always produce the same world.
  • Take the trick, not the engine. Borrow the byte discipline; write your own world.

license

EOS-CLA v1.0 — the Eternal Open Substrate & Contributor Mutual Trust Agreement. Everything stays open for all eternity; the distribution is eternal, the liability is bounded, the loop has an exit.


roadmap

v0.6 — the kit edge — the 1.58-bit lane (BitNet b1.58 models, bit-exact integer GEMM across AVX2/NEON/WASM/Zig/GPU lanes, the seeded dream byte-equal on every surface) + the constellation's install spine: the multi-part installer with the public genesis seal (a gist that attests the world out-of-band), the qdecorators/corelib crates (typed lanes, pretty diagnostics), the Zig kernels (cross-language bit-exact), the python sandboxes (nushell + nix-flakes), and the ultra-graphs. v0.3 shipped the world runs without you (GAIA, the keeper, the floors). See roadmap.md.

Phase Work
v1.x the core engine: Rust tick loop, Go multiplexer, the fauna stack, the floors
v2.0 the Presence Layer — the I/O HAL device classes for glasses + headset
v2.1 the Protector Node — BitNet b1.58 gate, the tent projection
v2.2 the Trick Library — gray-code deltas, nextPow2 arenas in the hot path
v2.3 the World-as-DNS — zone → Durable Object, the resolver, P2P rendezvous
v2.4 the glasses lane live — the world as radio, the walk, the sovereign pass by voice
v2.5 the headset lane live — the room is the zone, volumetric fauna, spatial chat

The full design v2 lives in 8b-is/public-documents/engine-design-v2-serverless-overworld.md.

the research

The MMO engine bibles, deep-researched and applied to this engine:

  • deep-research-mmo-bibles.md — the top 5 books (Gregory, Glazer, Nystrom, Bartle, Real-Time Rendering), the open blogs (Gaffer, Red Blob, 0 FPS, Riot, EVE, Destiny, SpatialOS, PlanetSide 2, Albion), the classic articles
  • applied-to-8b-is.md — every lesson mapped to a concrete engine decision, with the source ledger
  • theory.md — a world as a geometry of admissible continuation, grounded in Flyxion's four conditions + the mental-physics engine (inscription-before-rendering, layers-of-a-persistent-world)
  • world-models.md — the OSS learned-world-model map (Neural MMO, Generative Agents, DIAMOND, DreamerV3) wired beside the deterministic simulator
  • ternary-model-lane.md — the 1.58-bit lane: a BitNet b1.58 base model as a first-class citizen, its i32-accumulation GEMM bit-exact across AMD x86-64 / ARM NEON / WASM / GPU, its .tern checkpoint, its seeded dream
  • the kit lane — the publishable core: qdecorators (decorators, fp primitives, attested I/O, the uqapi typed lanes, pretty diagnostics, the Zig kernels) + the corelib facade — one import for the core
  • rust-dx.md — the fast local loop
  • Bleeding-edge Rust + Go: the language-features gist

the constellation · 0 + 1 · fine touch from within · vaked.dev