- Rust 39.9%
- JavaScript 36.8%
- HTML 15.6%
- Go 3.4%
- Python 1.4%
- Other 2.3%
| Filename | Latest commit message | Latest commit date |
|---|---|---|
| .github/workflows | ||
| 6502-is | ||
| assets | ||
| client | ||
| crates | ||
| docs | ||
| enthea | ||
| entheai | ||
| examples | ||
| games | ||
| music.vaked.dev | ||
| proto | ||
| scripts | ||
| tools | ||
| .gitattributes | ||
| .gitignore | ||
| Cargo.lock | ||
| Cargo.toml | ||
| CHANGELOG.md | ||
| CONTRIBUTING.md | ||
| CREDITS.md | ||
| GEMINI.md | ||
| LICENSE | ||
| MERGED.md | ||
| opencode.json | ||
| README.md | ||
| sandbox.sh | ||
| scaffold.sh | ||
| SEMVER.md | ||
| swarm.sh | ||
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
- the games
- design v2 — the serverless overworld
- quick-start — local dev
- host system requirements
- the client stack — CSS + HTML + WASM
- Aye world renderer — proposed privacy, shared reflections, and upgrade boundaries
- GAIA — the world-memory
- ultra-cogniM8 — the cognitive substrate, the two memories, the deities
- layer 1 — content creation, ideation → mid-pipeline
- the browser client — mesh.js + the GAIA dashboard + the world dashboard + the dream dashboard
- integration guide — UE · Unity · VSCode
- the constellation
- contributing
- license
- roadmap
- the obliterated lane — unsloth · MLX · GGUF on the top-4 abliterated models: the world-dataset fine-tune, the mirror's 10 GB gates, the colab-mcp flow
- crates-io — the four backbone crates: URLs, API/SDK references, quick-start
- the CPU cousin — Project Zero + the MoE bridge — the dependency-free C ternary engine, and the one-door fix for expert scatter
- the cartography cousin — Stipple + pattern fills — a seed-stable pattern-fill engine (MIT), wired to the world renderer via weave.vaked.dev
- the language cousin — Spherepop + history as identity — nested bubbles, innermost-first pops as admissible continuation, a clean-room zero-dep core in
crates/spherepop, wired intocrates/admissibility(spherepop_instance) as a CT-000 / CT-015 / CT-016 witness - the stock-vs-flow & trilogy witnesses (
seed001_instance+trilogy_instances+governance_trilogy_instances) — Seed 001 stock-vs-flow maintenance ledger (MaintainedStockProjectionvs.FlowOnlyProjection), Flyxion's October 2026 Trilogy I (ROE,TOH,DMA), and Flyxion's October 2026 Governance, Autonomy & Bounded-Charity Trilogy II (CMS: Continuous Microsurgery,SAS: The Surveillance State After Scarcity,TCT: The Charity Trap) wired intocrates/admissibility(29/29tests passing) - the pipeline admissibility gate (
admissibility_gate) — wirescrates/admissibility,crates/spherepop, andcrates/world-coreintocrates/pipeline(seed → GAIA → cast → keeper fold → spherepop → Seed 001 stock-vs-flow → AdmissibilityReceipt+ SHA-256golden_hashstaged alongside the zone manifest;13/13pipeline +23/23admissibility tests passing) - changelog — released tags, keep-a-changelog
- semver — the versioning policy for the backbone
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:
- Platonic skeleton — non-Euclidean joints: tetrahedra, cubes, icosahedra
- Sacred voxel shell — quantized grids, SDF smin blending
- 90s kinematics — squish/stretch, spring dampers, spin attacks
- Swarm & persona AI — boids + Diablo density + WoW aggro threat tables
- 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.
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.
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.
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.shusesapt/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.terncheckpoint, its seeded dream - the kit lane — the publishable core:
qdecorators(decorators, fp primitives, attested I/O, theuqapityped lanes, pretty diagnostics, the Zig kernels) + thecorelibfacade — 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