DONE [x] World struct, perm / route / frame arenas, fixed 60 Hz timestep [x] hot reload: source/host loads build/game.so, reloads on rebuild [x] release: source/release, one static exe [x] stubs: height_at, wind_at, gust_at, cloud_at, route (signatures and units in notes.txt) [x] Windows: compile.bat / format.bat / check.bat, Windows CI job [x] AGENTS.md, README.md, check.sh, CODEOWNERS, pinned Odin dev-2026-11a in CI [x] build modes debug / profile / release, mold linker, build time [x] ols.json, odinfmt.json, .editorconfig, .gitignore, .gitattributes [x] shared pre-commit hook (.githooks), GitHub Actions CI [x] download Belgium OSM data [x] install GDAL (micromamba) [x] extract border, rivers, motorways, cities to geojson [x] bake geojson -> belgium.bin FIRST, TOGETHER (so everyone can work in parallel) [x] weather arena in World (when the snapshot loader exists) Not needed: Weather is a fixed-size value inside World (perm arena), loading copies into it, nothing allocates. [x] in-app profiler: timed blocks per system, on-screen overlay in debug builds (frame ms, update / draw split, route ms, weather load ms, arena usage, last 120 frames graph) [x] headless mode: --headless --snapshot --inputs , prints result as text and exits [x] state dump to text (key + flag) and plain text log with system name and tick [x] keep full debug build under 2 s (compile.sh prints the time). ~0.9 s on 2026-11-21, keep checking [x] add #config(DRIFT_DEBUG / DRIFT_PROFILE) in code, then the matching -define in compile.sh [x] hubs: fixed array of Belgian hubs (start with the 15 cities), baked into belgium.bin [x] bench/ program: times every system, prints min/avg/max, run it before every merge [x] test/ program: fixed snapshot + fixed inputs -> compare routes and maneuvers to stored results NASR: MAP + RENDERING + UI [x] load belgium.bin and draw lines (km -> px: scale + offset) [x] camera: pan + zoom to cursor (mouse wheel / controller) [x] draw cities + names [x] "(c) OpenStreetMap contributors" on screen (Roboto, assets/fonts/) [x] download Copernicus GLO-90 tiles N49-N51, E002-E006 (sea tiles 404, fine): tools/download_dem.sh [x] gdalbuildvrt + gdalwarp to our projection, 250 m cells, raw i16: tools/warp_dem.sh (eqc, lat_ts=50.5, lon_0=2.38, R=6378166.175 = the 111.32 km per degree of the bin, see notes.txt) [x] bake heightmap block into belgium.bin, MAP_VERSION 4 (with a hillshade block) [x] height_at(x, y) bilinear [x] bake hillshade into a texture at build time, draw it as one quad render.odin hill_build / hill_draw, shown with the "3D terrain" map type. [x] build static map meshes once at startup, never per frame [x] day / night theme: one palette struct, swap the pointer (an index: a pointer dangles after reload) [x] wind particles: SoA arrays (x[], y[], age[]), one update loop, one draw batch, fixed count [x] everything stays over Belgium: wind, clouds, ground layers, camera centre, ship, air routes (belgium mask in terrain.odin; 3 route tests updated with nasr's ok) [x] labels: collect into a flat array per frame (temp allocator), cull, draw in one pass [x] immediate mode UI (our own, raygui needs a system lib on Linux), no retained widget tree [x] A* scan animation: replay the expanded-node order Lars records, no extra work in the router design (docs/drift-design.pdf). The doc is look and feel only: names, values and logic come from the code on main (real Belgian names from belgium.bin, LAYER_ALT, ZOOM_MIN / MAX, the NOT DOING list). Moved to the design split: plan screen + layers -> ANDREI, navigate screen -> LARS (banner, sheet) + DARIO (buttons, pad), route strips -> LARS. Shared signatures for all of this: notes.txt "DESIGN INTERFACES". nasr builds the base everyone uses: [x] tokens: Palette fields = the design token table (surface .. pill), night + day values, night is zero [x] map colors: land, city, park, farmland, marsh, beach, water, buildings, roads, sky per theme [x] fonts: embed Figtree + Roboto Mono like Roboto (#47), license next to each, ui_text(w, pos, text, Font, px, color) [x] icons: Material Symbols Rounded as one embedded atlas, license next to it, ui_icon(w, Icon, centre, px, color) [x] ui kit: card + shadow, round button 48 / 64, zoom pill, pill buttons, chip, toggle, segment, tile [x] ui kit: input field, stat chip (with meter), toast 1.6 s, hover = surface-2, 2 px focus ring, 44 px hits [x] screen state: w.screen (Plan / Navigate) + draw order in game.odin (see notes.txt), Esc -> Plan [x] bake land use, road classes (motorway / main / street / track) and buildings from the same OSM extract Land use and road classes baked; buildings do not fit (7.6 M polygons), question #76. [x] map draw: road casings then fills, widths constant on screen (10 / 8 / 6 / 4 px + 2 px casing) [x] map labels: city + river names, motorway shields (OSM ref, e.g. E40), hub markers, start ring, dest pin labels.odin: river names + motorway shields; hub names with the markers; start ring + pin in nav_ui. [x] names: only the real names in belgium.bin (cities, hubs, rivers, motorways), never the doc's examples [x] loading screen: night sky, 38 px cyan ring (0.9 s per turn), fades out in 0.4 s later: [ ] bake 3 detail levels + 10 km cell grid, draw only visible cells [x] 3D terrain view The "3D terrain" map type: hillshade relief under the tilted camera, real heights in height_at. No height mesh. LARS: ROUTING + NAVIGATION [x] 3D grid: 1 km cells x 3 layers (203k nodes), all buffers allocated once, reused per route [x] blocked bitset: terrain + 75 m margin, grid edge, no-fly zones (fixed array, max 8), free start / goal node [x] A*: 8 dirs + up/down, binary heap in a fixed array, no allocation during search [x] cost per mode: fastest (time), greenest (energy), calmest (time x gusts) [x] ground speed: wind along track + sqrt(v^2 - crosswind^2), retry +6 m/s if < 2.5, block if < 1.5 [x] energy: battery 180 kWh start 86%, P(v, g) = 3 + 0.0085 v^3 + 6 g, solar from cloud cover, climb cost [x] path cleanup: skip redundant nodes, Chaikin, ramp to tower top, 40 m terrain clearance [x] metrics: time, kWh, gust index, vs straight-line baseline [x] record expanded-node order into a flat array (for the scan animation) [x] user-reported gust zones (fixed array, max 4), reroute around them [x] gust report: put a zone on the path ahead of the ship (needs navigation state), then reroute [x] reroute: > 190 m off path for 1.2 s -> route from current position, same buffers [x] maneuvers: computed once per route into a flat array (depart, turn, climb/descend, arrive) [x] navigation state: next maneuver, distance, then-card, ETA, all derived from path index [x] autopilot: follow route (lookahead point), outputs Controls struct [x] switch manual <-> autopilot [x] lars: bench: one route < 10 ms, three modes < 30 ms Smooth bench wind (#66, answered): avg route ~7 ms, three modes ~14 ms on the cloud box, 1.6 / 5.2 ms on an M-series Mac. design (route.odin, nav.odin = simulation; nav_ui.odin = drawing): [x] three routes at once: plan_routes(w, from, to, hour) fills w.routes[mode] for all modes [x] route summary per mode: minutes, km, km/h, net kWh, mean wind, tag, one-line "why" (after metrics) [x] route_sample(w, mode, t) -> pos + heading along the path, t 0..1 (Dario's preview camera) [x] maneuver kinds: straight, slight / normal / sharp left + right, climb, descend, depart, arrive [x] maneuver text: instruction + subline + road name = nearest real motorway / river / hub in belgium.bin [x] nav: then-tab only when the maneuver after next is within 700 m [x] nav: banner state flying / rerouting (1.6 s) / arrived ("Docked at " + kWh used) [x] nav: warning ahead from w.no_fly / gust zones ("No-fly zone ahead, climb above m") [x] nav: manual flag, nav_set_manual(w, on) (Dario's keys and button call it) [x] nav_ui: route strips, chosen cyan 14 px, others grey 11 px, 2 px casing, part behind the ship hidden [x] nav_ui: time bubbles on the part of each route furthest from the others, chosen on top, leaf on greenest [x] nav_ui: banner (teal, 96 px icon column, 34 px text) + "Then" tab + rerouting / arrived colors [x] nav_ui: road sign (real name) at the next maneuver, pill 26 px under the ship with the layer (LAYER_ALT) [x] nav_ui: yellow warning pill 170 px from the top [x] nav_ui: sheet: ETA (green + leaf), "km, arrive hh:mm", stat chips (speed, battery, used, solar, height) streets (#67, on dev): [x] lars: more streets: trunk / primary / secondary (tertiary if it fits) from the same pbf, Map_Kind per class [x] road graph: keep junctions, bake nodes + edges, the airship on the ground (a flying car, #68) moves along edges DARIO: SHIP + CONTROLS [x] Windows smoke test: compile.bat debug, run build\drift.exe from the repo root, rebuild once while it runs and check the game reloads ("[host] reloaded game"). Also try compile.bat release. Report what breaks. Result in notes.txt (SMOKE TEST): rebuild while running fails, needs a compile.bat fix from the owner. [x] Controls struct: throttle, turn, climb (-1..1) [x] keyboard WASD + R/F, controller sticks (deadzone) [x] ship_step(dt, controls), fixed timestep 60 Hz (accumulator), pure function of state + controls + world [x] limits: accel +1.2 / -1.6 m/s^2, smoothed turn rate, ceiling 900 m, min 28 m above terrain [x] ship drifts with wind_at, battery drain from Lars's energy model, solar charging [x] warnings as flags in the ship state (terrain, no-fly), UI only reads them [x] docking: within 30 m horizontal, 25 m vertical of the hub tower [x] sim speed 1x / 5x / 15x / 40x = more fixed steps per frame, never a bigger dt Removed again 2026-11-21 (Lars): time always real, speed in km/h. [x] map mode: Controls pan / zoom the camera while there is no ship (WASD, R/F, sticks) [x] drive mode: Controls go to ship_step, camera follows ship, key to switch back to map mode [x] record Controls per step for replay (flat array, a few bytes per step) [x] bench: ship_step cost per step extra: [ ] real no-fly zones: bake airports (CTR), nuclear plants, military areas from one pinned source (waiting: #78) (skeyes eAIP ENR 5.1, dated AIRAC cycle) into belgium.bin, lat / lon -> km with the map projection, ceilings ft -> m, circles (polygons approximated). Copy them into w.no_fly at startup, raise MAX_NO_FLY or keep baked zones in their own array. Source, date and license in notes.txt. [ ] test case with the real baked no-fly zones (after the item above), e.g. a route past Brussels Airport at x 149.0, y 73.4 km. The zones in test/data/no_fly.txt are made-up (#52). Expected files change only with the owner's approval. design (airship.odin = model + drawing, camera.odin = camera, pilot_ui.odin = flying controls on screen): [x] airship model: low-poly mesh built once at startup, sizes and colors from the design doc [x] airship draw: heading + crab angle into the wind, bank in turns, props spin with speed, nav lights [x] airship on the flat map: 70-90 px long, low above the ground, soft shadow ellipse [x] camera.odin: move View + map / drive camera out of game.odin (after #57), Camera3D, zero = whole map [x] camera: ease-out glide on zoom (0.6 s) within ZOOM_MIN / ZOOM_MAX, compass button resets north [x] cam_fit(w, min, max, screen rect): fit routes beside the plan panel in 0.8 s ease-out [x] chase camera: 53 deg tilt behind the ship, turns with heading, small lag; Start dives in 1.2 s [x] preview: camera flies the chosen route in 9 s, ease in + out (uses Lars's route_sample) [x] cam_to_screen(w, pos) -> px, visible: everyone projects with this (labels, bubbles, pills) [x] dario: keys: arrows = WASD, PgUp / PgDn = R / F (done, #69); any of them in navigation calls nav_set_manual(w, true) [x] pilot_ui: button column (compass, overview, sound, wind, report gust), 64 px, right middle No sound button: speech is on the NOT DOING list. [x] pilot_ui: speed circle 74 px, Re-centre pill after a map drag, self-fly 66 px + red Exit / Done pill [x] pilot_ui: sim speed chips 1x 5x 15x 40x in the sheet (replaces the toolbar buttons of #57), removed 2026-11-21 [x] pilot_ui: 3 x 3 control pad (52 px) + key card, only in self-fly, pressed = accent ANDREI: WEATHER + NETWORK [x] Open-Meteo hourly forecast, next 9 hours, grid over Belgium, pressure levels 975/950/925 hPa [x] also fetch gusts and cloud cover [x] store as flat arrays [hour][layer][cell], changing departure hour is an index, not a recompute [x] validate everything (ranges, NaN, missing), reject bad snapshots [x] save snapshot to disk with its hash, load on startup, refresh every 15 min (thread, timeout) [x] wind_at(x, y, layer, hour), gust_at, cloud_at: bilinear, no allocation [x] bench: wind_at cost, snapshot load time network + carpooling (after routing works). Peer to peer: every game is a node, no central server. The central relay (#18, #22, #25) was dropped; reuse its code from those branches, see the issues. [x] ed25519 key pair per user (core:crypto) [x] signed message format: offer, request, accept, review (fixed-size binary, not JSON) [x] offers include hub ids, times, seats, weather snapshot hash [x] message store: by id (sha256), dedupe, expiry, cap per author and total, append-only file (#41) [x] peer sync: swap ids since time T, send what the other side is missing (TCP, timeouts, thread) (#41) [x] peer list: seed nodes in config, learn peers from peers, forget dead ones (#41) [x] headless node: same store + sync without the window, anyone can run one (#41) [x] LAN discovery: broadcast the hello over UDP, nodes on one network find each other without seeds [x] weather snapshot to peers, fetch by sha256, reuse snapshot_check from #22 (#42) [x] matching: filter offers by grid cell + hour, then detour check with the router [x] verify offer route/energy by recomputing it locally [x] energy split: own share + detour cost for passenger [x] accept handshake, live position encrypted between matched users (x25519 + chacha20poly1305), through peers, reuse the crypto from #25 (#43) [x] signed reviews for reputation design (plan_ui.odin = plan screen + layers panel; weather.odin for the wind text): [x] plan panel: 404 px on the left, card A (brand, from / to, modes, departure) + card B (routes, actions) [x] brand bar: logo, "DRIFT", round day / night button (sets w.theme) [x] from / to fields with hub search list (max 320 px), swap button, writes w.plan.from / to [x] hub menu on the map: click a hub -> "Fly from here" / "Fly to here" [x] mode chips: icon + travel time + label for fastest / greenest / calmest, chosen = accent [x] departure list "Leave now" .. "+8 h" -> w.plan.hour (forecast hour index) [x] route rows: 4 px bar, time (green + leaf for greenest), km + speed, why, tag, net kWh + wind in mono [x] wind note: wind_note(w, mode, out) -> one sentence from wind_at along the route ("Wind from the east...") [x] action bar: Preview (Dario's camera) + Start (w.screen = Navigate, Lars's nav_start) [x] layers panel 300 px: toggles wind, gusts, no-fly, solar + wind layer segment (LAYER_ALT labels) [x] ground layers: gust risk (soft orange -> red from gust_at), no-fly hatching of w.no_fly (red) [x] wind particles colored by speed (white < 6, mint < 10, yellow < 14 m/s, coral), 40% in plan, off in nav [x] legend card: wind gradient 120 x 6 px, no-fly hatch, gust color EXTRA (future, not now: C API so the core can be ported to Swift / Kotlin apps) [ ] split repo: core/ (all logic, no raylib, C API) and app/ (desktop raylib frontend) [ ] write drift.h: create/destroy, load_map, load_weather, route start/poll, ship_step, getters [ ] app/ only talks to core through the C API, same as Swift / Kotlin will [ ] core parses weather bytes (drift_load_weather), app/ does the fetch [ ] build core as static lib (-build-mode:lib) and check drift.h links from a tiny C program [ ] iOS: core as static lib with -subtarget:iphone, Swift calls drift.h via a module map [ ] Android: core as .so with -subtarget:android (NDK linker), Kotlin calls it through JNI [ ] native rendering per platform (Metal / Vulkan or raylib), core unchanged RELEASE (single executable) [x] release build compiles the game into the exe, no hot reload dll [x] embed a fallback weather snapshot with #load so the exe runs offline on first start [x] weather cache in the user's data folder, not next to the exe source/release: the exe runs from os.user_data_dir()/Drift, so all of cache/ goes there [ ] curl: link statically or use the OS HTTP API, so the exe has no libcurl dependency [ ] Linux: build on an old glibc (CI, ubuntu 22.04) so it runs on most distros [ ] Windows: static CRT, single .exe [ ] macOS: universal binary (arm64 + x86_64), signed LARS, 2026-11-21 (second list, on lars/all-todos) [x] zooming out stops at Belgium (no square around it, no Netherlands), pan clamped, the ship stays on the map [x] profiler on / off (row in the layers panel, off by default) [x] DRIFT logo top left gone, theme button with the map buttons [x] speed in km/h, no multiplier (sim speed removed) [x] clearer wind particles (more, longer, wider, fading at the map edge) [x] smoother route line (Catmull-Rom), drawn from the ship on [x] natural car motion: bank, pitch, ease between driving and flying [x] transition between driving and flying (landing slide + descent, take-off climb) [x] realistic 3D car (Car Concept, CC BY 4.0) [x] see other cars peer-to-peer: signed positions by gossip, no relay (presence.odin) [x] traffic jams: many cars together make routes go round and slow the ship (test case traffic) [x] fly faster (252 km/h) and climb faster (12 m/s, take-off 10 m/s) [x] 3D buildings in the 15 city centres (buildings.bin.gz) [x] nature around the route: tree clumps in parks and woods, clouds from the forecast cover "zoals in het filmpje": no film was shared, so the look is ours. STREET VIEW (Lars, 2026-11-21: third person between the houses, realistic, detailed, day, lots of green) [x] V: third-person chase camera at real scale, mouse look, never inside a wall (street.odin) [x] free flight with momentum, wind and gusts, hover over ground and roofs (ship_free_step) [x] building collision against real and generated buildings (collide.odin) [x] buildings at real height, towns, trees, the car at real size, HUD [x] BUG: land use and road ribbons did not show in the street view: f32 depth of the km meshes, fixed with layered far depth in the ground shader (notes.txt street.odin) [ ] residential streets, squares and sidewalks between the houses (not in belgium.bin: below tertiary) [x] always day in the street view, natural greens; light only in the whole app (Lars: dark mode gone everywhere) [x] scripted run mode with screenshots (--script: keys per frame, shot, quit) for visual checks test/data/street_standard.txt: tower, street, main road, park, countryside [x] headless test cases for free flight: wall stop, roof landing, top speed, crosswind drift, same output twice (headless free / free_on, test/ run_free_flight) [x] flicker in the street view: anchored meshes (z-fighting), render interpolation (uneven frames), near plane 0.25 m; e2e check test/data/street_flicker.txt [ ] sun lighting with normals, sky with sun, haze, ambient occlusion at wall feet, sun shadows (shadow map) [ ] facades in the shader: floors, windows, doors, shop fronts, brick / plaster / stone per building [ ] roofs: gables for houses, parapets and roof details (solar panels, green roofs) for flat roofs [ ] trees with trunks near the camera, street trees, hedges, instanced; street furniture [ ] other cars (presence) tested in the street view with two nodes TOGETHER, AT THE END [ ] demo run: plan Brussels -> Gent, pick greenest, Preview, Start, report gust, reroute, dock, Done [ ] headless test case for that flow, plus a screenshot of both screens (light only since 2026-11-21) NOT DOING film, procedural world, web stack, touch / responsive layout, speech, shadows on the map (the street view gets them) (extruded buildings, nature and clouds: built after all, Lars 2026-11-21)