Roadmap

We build what a platform cannot work without first, and the more ambitious things after that. Both lists are below, so you can see which is which.

Three states:

State	Means
Shipped	it works today, and there are docs for it
Committed	we are building it; the shape below is what we are building
Intended	we want it and we are not working on it yet

Anything not on this page is not planned. What exists today and what does not is The boundary today.

Shipped works today

Newest first.

The Rust SDK — a public crate, Apache-2.0; published on crates.io, and cargo test runs both halves natively with no game present → Write your first mod
Author input hooks — a mod names its own hooks with default key, pad and mouse bindings, and its client half is called on the press → Input
Dependencies between mods — a mod states [needs] and version ranges; the host pulls the rest in and derives the load order, and a pack pins a suite tested together → Dependencies
Per-mod settings — an operator switches one mod’s author hooks off in configuration → Mod settings
Sound — a mod ships a sound, declares it and plays it, on buses the listener controls → Sound
Operator grants — who may touch whose entities, decided in configuration rather than in code → Grants
Decoration on player bodies — a mod writes a declared row on a body, one holder per row → Body decoration
The session roster — display names and per-player facts a mod can read → Reference
A memory ceiling per mod — an operator sizes the box each mod runs in → Configuration
Per-instance content root — one instance can be pointed at its own content, so two on a machine can differ
Content announced to joining players — a session tells a peer exactly what it runs, and refuses a peer that lacks it
A stated protocol version — a peer speaking a different one is refused, and told so
The enabled mod set — a session runs the mods it lists, in the order it lists them → Enabled mods
Gamemode designation — one mod holds the session’s rule layer → Configuration
Relay pool from the core server — NAT traversal without configuring anything → Connectivity
Session handover from the launcher — the game resumes a session instead of taking a password
Spatial queries — ray and shape probe against the world → Spatial queries
Contact events and trigger volumes — a mod learns when something touched its things → Contact
The signal bus — mods announce facts to each other in bytes, over names their schemas declare → Signals

Committed being built

Dedicated servers

What it will do. Run a session with nobody attached: a host process on a machine you control, started before anyone joins and still running after everyone leaves.

Today. You host from the game with --become-host, and the session lives as long as you stay in it. See Run a server.

Carries over. An instance is configured by config/server.toml, and the host already reads it the way a server needs to — --config points at a file anywhere, [content] root keeps content separate from configuration. A dedicated server changes which process reads that file, not the file.

Mod distribution

What it will do. Package a mod into a single signed file, and install one without copying directories by hand — so a server can hand players the content it runs.

Today. Content is discovered from its install path, and every player installs mods manually. A mod’s identity is settled — author:mod, from where the files sit — so the name you publish under is the name packaging will carry.

Intended not started

We want these. We are not working on them, and nothing here should be planned around.

Composition hooks — mods taking part in each other’s decisions instead of only observing; the structural hooks are already declared in the contract, unfired, so exporting them costs nothing when the mechanism lands
A real UI surface — panels and layout, rather than one line of overlay text
Authoring tools — programs for building worlds and content directly, rather than a modelling package plus a hand-written manifest
Prebuilt scripting shells — eight toolchains already build a working mod, measured end to end → Languages; what remains is shipping each scripting language’s interpreter prebuilt, so a script mod is plain text and a manifest, with no toolchain on the author’s side
Persistence — a key-value store of bytes a mod owns, with where those bytes live (memory, SQLite, Postgres) an operator’s configuration choice behind one unchanging interface
Personas — splitting account from character, so a player can have several, each with its own traits and saved state; the contract already carries the persona id, answering none until this lands
Server mesh — sessions that span more than one host