Roadmap

One milestone ≈ a chunk of working sessions. Each ends with something you can actually run and see. Timelines assume solo dev + heavy AI assistance, steady (not full-time) pace.

M0 — World skeleton (single-player) · ~2–4 weeks

Goal: walk around a lit, atmospheric terrain. Prove the look.

Project scaffold, git repo, docs
Godot installed, project opens
First-person / third-person character controller (move, jump, mouse-look)
One flat/heightmap terrain chunk with a material
Atmospheric lighting: directional sun, sky, volumetric fog, tonemapping
Place one low-poly tree + rock to set the mood
Done when: you load the game and walk around a Valheim-ish lit field.

M0.5 — Scenery & world bounds (done)

Mountain-rim boundary (steep cliffs + invisible wall + respawn safety net), covered by tests/test_boundary.gd
Procedural terrain shader (grass/dirt/sand/rock strata/snow), lake + water shader
5 procedural tree types, faceted mossy rocks, cliff outcrops, bushes, logs, stumps
Streamed wind-animated grass + flowers; cloud sky; swimming

M1 — Survival loop (single-player) · ~3–5 weeks

Goal: the core game verbs. Detailed plan in docs/SURVIVAL_DESIGN.md (phases M1a–M1d).

Resource nodes: chop tree → wood, mine rock → stone (M1a)
Inventory + simple hotbar UI, chests (M1a)
Crafting (recipe: wood → tools / building pieces) (M1a)
Pause menu, title screen, world slots, save/load, autosave (M1a)
Health / stamina / hunger / warmth, day-night cycle, fire fuel, cooking, foraging, torches, death + grave (M1b)
Weather (rain, storm, snow), wet/shelter (M1c)
Snap-together building: floor/wall/door/roof/gable, resource cost, support + collapse, dismantling (M1c)
Bed spawn point and sleeping, resource regrowth (M1c)
Creatures (rabbit, deer, boar), hunting, club/spear/bow, butchering, cooked-food buffs, hide cloak (M1d)
Wolves at night with a den and a 3-day grace period, wolf cloak (M1e)
Fishing (rod, perch and trout, grilling) and a mixed diet (M1e)
Hide armour, more recipes, sea fishing (later M1 polish)
Wild flax (fibre plants) (polish)
Iron: nuggets, ore, clay, kiln, smelter, forge, iron tools and arrows, lantern, tool wear and repair (P1)
Stone building: stonecutter, cut stone, stone floors, walls, pillars, stairs, windows, doorways, hearth; wooden stairs, windows, posts, palisade and gate (P2)
The wolf moon and the alpha: breaks wooden doors, iron-banded doors hold, alpha pelt and cloak (P3, part 1)
The bear: raids unattended food, palisades and closed huts keep it out, bear hide rug, bear fat (P3, part 2)
Crows and foxes steal food left out; the barrow, its guards, the coffin and key pieces (P3, part 3)
Hazards: food spoilage (rot speed setting), smoking rack and salt, food poisoning, harsher blizzards, hard winters, lightning on trees (P4)
The standing stones and the Old Stag: a three-phase boss, its antler and trophy, the antler pickaxe (P5)
Iron, stone building and new adversaries: iron nuggets and ore, smelting and a forge, iron tools and durability, cut-stone building, an alpha wolf, a bear, a barrow with guards, spoilage and blizzards (phases P1-P5, docs/PROGRESSION_DESIGN.md)
Tutorial world: a guided first island that teaches gathering, crafting, chopping, food and the mixed diet, hunting, fishing, shelter and the night (phases T1-T4, docs/TUTORIAL_DESIGN.md)
Done when: gather → craft → build a tiny shelter, single-player.

M2 — Multiplayer · ~2–4 months

Goal: self-hosted, authoritative, 2–8 players. Detailed plan in docs/MULTIPLAYER_PLAN.md (hosting on UDP 24242 via Tailscale or port forwarding, player identity and names, server rules for co-op/PvP, and phases M2.0-M2.7).

Server-authoritative online (single-player stays as it is, with no server) (M2.4)
Headless dedicated server, joining, identity handshake, names, player list (M2.1)
ENet transport, player bodies and name tags, local movement checked by the server, interpolation for others (M2.2)
Replicate resource nodes, pickups, building, chests, fires, doors, clock (M2.3)
Persistence: world save/load on the server (M2.3)
Per-player inventory, stats, death, graves and saves on the server (M2.4)
Animals, wolves, hunting, fishing and sleeping on the server (M2.5)
Server rules (PvP, raiding, locks and friends, death penalty, difficulty, wolf grace), chat and admin commands, server console (M2.6)
Host Game from the title screen, backups, launchd and systemd samples, hosting and Tailscale guide (docs/HOSTING.md) (M2.7)
Done when: a friend joins your self-hosted server and you build together.

M3 — Addon SDK + sandbox · ~2–3 months

Goal: the differentiator. Easy, safe mods.

Embed sandboxed Lua VM in the server
Capped API surface (events + safe world queries/commands)
Per-addon CPU/time + memory quotas
Addon manifest format (declare items/recipes/prefabs as data)
2–3 example addons (a new craftable item; a "welcome" message on join; a custom spawn rule)
SDK docs for modders
Done when: a modder drops an addon folder in and it safely adds content, and a deliberately-malicious test addon is contained (can't read files, can't hang the server).

M4 — Content & polish · ongoing

More biomes, creatures, items, building pieces
PvP / raiding rules, building damage
Better UI, settings, controls. Done so far: volume sliders, tips and update settings in the pause menu; Q drops items; K/M put any bag row on the 1-8 keys (0.3.0); the map on N, filling in as you explore, and a compass along the top (0.4.0, Gitea issue #1).
More places: the worldlets and the journey (docs/WORLDLETS_DESIGN.md). Done (0.4.0): W0-W3 and J1, the Cove reached down the cliff tunnel (single-player). (0.5.0): J3, the journey on a server: a server per land, players in different lands at once, chat, the player list, admin and sleep across lands. (0.6.0, a playtest): the Cove's own: the wreck, a treasure dig for each player and its drowned crew, crabs, gulls, and a rowing boat moored at the pier; Report a bug in the pause menu. Next J2, then J4 (the Highlands by sail).
Audio, music, weather. Done (0.2.0-0.2.1): mood music (calm, night, storm, danger, boss) that crossfades with what's happening, ambience (CC0 birdsong, crickets, owls, fire), sound effects for every action (Kenney CC0 plus synthesised), creature voices, Old Tam's spoken lines (Kokoro). Sources and licences: assets/audio/CREDITS.md; tools in tools/audio/ and tools/voice/.
Help: the player guide on the download site (tools/site/), written sections plus item, recipe, creature, fish and server-setting tables made from the game's own data each build. The trailer (tools/trailer/).
Packaged builds for Win/Mac/Linux (+ Mac signing/notarisation). First cut done: tools/export.sh makes a universal macOS .app (ad-hoc signed, not notarised) and a Windows x86_64 .exe + .pck (unsigned), zipped in build/. The same build runs a dedicated server (--headless -- --server). Still to do: notarising (Apple Developer account), Windows signing, the game icon on the .exe (rcedit), Linux, and the update check below.
Updates: the game (and a dedicated server) needs to notice when a new version is out, download what's needed and install it. See below.
A single-player web version (Paul, Nov 2026: after the playtest): play straight from the download page, with "Download for the full game and multiplayer" beside it. Godot's web export, single-threaded, on the Compatibility renderer (WebGL 2). What we found (0.6.1):
- The look: rendered with that renderer (build/web_look/, from tools/site/shots.gd run with --rendering-method gl_compatibility), it's still clearly the game, but harsher: no volumetric fog or haze, no SSAO/SSIL (darker, sharper shadows), deeper greens. Night and fire light hold up. The sea renders flat white: shaders/water.gdshader needs a Compatibility path. Ordinary distance fog would bring some atmosphere back; grass density and tree counts likely need a lower setting for browsers (speed not measured yet).
- Single-player only: browsers can't use ENet (UDP), and can't start the Host Game or per-land server processes. Joining from a browser would mean a WebSocket transport on the server, served over wss:// (a certificate per server): a separate, bigger job, if ever.
- Saves go in the browser's storage (IndexedDB): kept, but per browser and lost if site data is cleared. Maybe an export/import button.
- Input: the pointer lock needs a click, and Esc releases it in the browser, so the pause menu needs another key too (P).
- Size and hosting: the engine (godot.wasm, 39.5 MB) plus the game data (about 22 MB) download first, then cache. Cloudflare Pages refuses files over 25 MiB, so the .wasm has to live elsewhere (the Gitea release, or another host) or be split.
- Size of the job: one step to build it and see how it runs, another to fix the water, tune the graphics and controls, and put it on the page.
Cloud saves (Paul, Nov 2026: with the web version, and useful before it, desktop to desktop): carry a single-player world between the desktop game and the browser, both ways.
- In the game: pause menu Save to cloud (a cloud name and a password the first time; after that it can upload on each save: autosave, sleep, quit); title screen Load from cloud (name and password, pick a world, it downloads and you carry on). What travels: the world folder (meta.json, world.json), its explored map (maps/), and which of Old Tam's tips you've seen. Not online worlds (they live on their server).
- Size: a world is 8-32 KB on disk, a few KB compressed: uploads are instant and storage is next to free.
- Where: a Cloudflare Worker beside the site (/api/...), saves in R2 (or D1). Free tier is plenty. (Paul's own server would do, but is one more service to keep running.)
- Safety: passwords never stored, only a salted hash (PBKDF2, WebCrypto in the Worker); HTTPS only; wrong guesses lock a name out for a while; a size cap and a world count per name. Option: encrypt the save with the password in the game before upload, so the server holds only ciphertext (but a forgotten password loses the cloud copy; the local copy is unaffected).
- Playing in two places: each upload carries a counter. If the cloud's copy is newer than the one you last downloaded, the game asks ("The cloud has a newer save (from the web, 20 minutes ago): use that, or keep this one?") instead of overwriting it.
- Versions: the same save format on desktop and web; a save from a newer version than the game says so rather than loading it badly.
- Size of the job: one step for the Worker and storage (with tests), one for the game side (name and password, the buttons, the newer-copy question). Paul creates the Worker and its storage in his Cloudflare account; the code and setup steps come with it.
Later, maybe: Android tablets (Nov 2026: left for now). Most input is already named actions, so a touch layer (stick, look, contextual buttons) is possible; the Mobile renderer has the same lost effects as the web, and a tablet can join but not host (no server processes).

Updates (to design with the packaged builds)

Needed because every network change bumps the protocol (12 as of P5), and an out-of-date game can't join an up-to-date server: today that means git pull and a restart on every machine.

Built so far (the check): scripts/core/updates.gd asks the feed in Project Settings (cinderwild/updates/feed, now the git server's releases/latest API; Gitea, Forgejo and GitHub answer alike) once at start-up. It reads the release's version.json asset (written by tools/export.sh: version, protocol, per-platform file, sha256 and size). The title screen shows the version bottom left and, when a newer one is out, a card with its notes and Download (this platform's zip, or the release page). A "Different game version" refusal now names the server's version and protocol and says whether you or the server needs updating; a dedicated server says in its log when it's behind (check_updates in server.json). Pause menu: Check for updates at start. Tests and bots never touch the network. Still to do: downloading, verifying and swapping it in (below).

To publish a release: bump config/version in project.godot and the four version numbers in export_presets.cfg, run NOTES="..." tools/export.sh, and make a release on the git server (tag v<version>) with the two zips and build/version.json attached. The repo (or at least its releases) must be readable without logging in.

Knowing there's an update: the game checks a small version file (version number, protocol, per-platform download URLs and checksums) at start-up and from the title screen. The server checks too. When joining a server with a newer protocol, the "different game version" refusal should offer to update instead of just saying so.
Getting it: download only what changed where possible (the game's .pck data separately from the engine binary, which rarely changes), to a staging folder, verified by checksum (and signature) before anything is replaced.
Installing it: swap in the new files on the next start (a tiny launcher or a restart-and-replace step), keep the previous version to roll back to if the new one fails to start. Mac: signed and notarised so Gatekeeper accepts it; Windows: signed. Worlds, profiles and server config live in user data, so they're never touched; saves stay readable by newer versions (they already load older saves).
Servers: a headless server can update itself at a quiet moment (nobody on, or after warning players), or an admin runs an update command; the launchd/systemd service files restart it.
Where updates come from: GitHub Releases is the simple start (the version file and builds attached to a release); itch.io's butler or Steam would handle it for us if the game ships there.
Addons (M3) will want the same: a version per addon and the server telling players which addons (and versions) it needs.

Honest overall estimate

A genuinely playable self-hosted survival game with a working sandboxed addon SDK is roughly 6–12 months of steady solo work with AI help. The M0–M1 vertical slice (a few weeks) is what proves the concept and keeps you motivated.

15 KiB Raw Blame History Unescape Escape