SALVAGE OPERATIONS CONTROL
WARD/EN is a programming and salvage game. A drone enters a wreck with no one at the controls, follows the directive you wrote, and sends back only what its uplink can carry. You never steer it live. You write a better plan, and later a crew of drones that talk to each other.
Coming to Steam. While it is in early testing the terminal runs in your browser: no account, no server, saves stay on your machine.
A directive is a small project of .warden files: a
plan in main.warden and the library modules it
includes. Route planning, contact response, sensing and the
recovery routine are all ordinary source, and every line is yours
to change.
Dispatch freezes the directive. From that moment the drone acts on its own inside a wreck you only know from a recovered schematic, with a battery that is the clock and something patrolling the corridors. A fleet is several drones acting on their own at once, each on its directive, talking over a link the wreck can cut.
Cargo in the hold, the report, and the map you now hold of that wreck. A drone that ran dry stays inside. Improving the directive is how you survive; the salvage operation determines what you can risk next.
main.wardenlanguage 2; include "lib/recovery.warden"; enum Order { core_first, recorder_first } fn search(target: site, item: string): boolean { let result = move_to(target, Style.quick, defend); if (result != MoveResult.ARRIVED) { return false; } scan(); if (observed_item(item) == null) { return false; } collect(item); return true; } on start { let seen = observe(); let sites = [seen.sites.POWER, seen.sites.COMMS]; let i = 0; while (i < len(sites)) { if (search(sites[i], "NAV_CORE")) { break; } // A core you cannot bring home is worth nothing. if (observe().energy < reserve_for_home() + 40) { break; } i = i + 1; } log(observe().energy); return_home(Style.quick); }
A small imperative language with the shape you expect and nothing
you have to guess at. The hardware is a handful of calls that each
cost a tick and report a Result; everything above
them, including move_to and its route planner, is
library code you can read, edit and replace.
observe().mission is the contract the ship sends
with the drone: objectives, priorities and the housings that
may hold each item. A plan that reads it flies on any
wreck.
send costs a tick per 32 bytes on a fitted
transceiver, receive reads the inbox, and the
ship holds a message for a drone out of range. A scout
reports; a hauler acts on it.
move_to and decide, step by
step, what a contact means: continue, act, or abort.
include. The
modules are one library per operation: improve a routine once
and every directive that includes it has it.
pure; the controller
refuses any hardware call inside them.
observe() record, the shipped library and the
controller's limits on one page:
the language reference, also
as a PDF for printing.
A directive used to be tested by flying it. The test bench flies it for you, on a handful of prebuilt scenarios, inside the Workbench: clear decks, a roamer on patrol, a survey through a closed door, the training wreck as briefed. The scenarios are pinned, so a plan that fails, fails for a reason you can name.
The sector chart: wrecks, contracts, regions and the intelligence you have bought. Travel and dispatch commit strategic time; reading the chart is free.
Fit, service and buy equipment. What is installed decides which calls a directive may make, how long a step takes and how much energy a sweep draws.
The editor, the operation's shared library and the test bench. Save a directive, assign it to a drone in the bay, and it is the exact program that flies; dispatch keeps its own frozen copy, whatever you change afterwards.
Settlements, cargo, reports and the wreck record you carry forward. Return to a wreck and the drone starts from what the last one learned.
Systems, licences, analysis and upkeep. Industrial regions need the extended drive and a licence; the deep recovery contract needs everything.
A tutorial that flies the loop with a guide, and a fifteen-lesson language course, each lesson a real expedition on the training wreck. Nothing there is saved but your progress.
A full source editor under the CRT glass, or in high-contrast clear coding: file switcher, completion, hover, go-to-definition, references, rename and diagnostics against the fitted drone.
Export a directive and it unpacks into a folder of
.warden files plus a warden.json that
carries the fit and the wreck's site names. The extension gives
you the same completion, navigation, rename and semantic
highlighting in your own editor; pack it and import it back.
A dependency-free language server speaks LSP over stdio and is the game's own language service, so diagnostics never disagree with the Workbench. Neovim, Zed, Helix: point them at the command and edit.
The simulation keeps its own truth: creatures, hidden geometry and intent are private. The Mission station shows the received packet, and so does your directive. A detector sweep pings a body where it was when the sweep crossed it; a scan confirms what the schematic only claimed; a corridor behind machinery thins the signal until the feed drops.
When a carrier drops inside coverage you get a terminal burst and a last position. Outside it you get nothing, and the debrief says so. Recovered drones bring back their hardware, never their onboard buffer.
T0040D01DOOR OPENED / 13, 5 / LOCAL SCAN UPDATED T0058D01POWER / HOUSING EMPTY / LOCALLY OBSERVED T0058D01LOG / POWER is empty, trying COMMS T0091D01MOTION ACQUIRED / R 4.2 / 274° T0094D01Defence discharge / range 2.8 / bearing 271° / ammo 2. T0096D01REPLANNING / ROUTE UPDATED T0141D01OBJECTIVE ACQUIRED / NAV_CORE T0203LINKUPLINK INTERRUPTED / MACHINERY SHIELDING T0231D01EXTRACT / OK / ENERGY 21.06 T0231D01NAV CORE recovered. Drone extracted.
The language course is fifteen lessons, each a pinned expedition on the training wreck. The starter always flies and always misses the goal; the verdict comes from what actually came back, and a hint or the reference solution is one press away. Take them in order, or open any lesson you like.
WARD/EN is a PC game and will ship on Steam. Until then the early test build runs in a desktop browser window: it scales to your screen and is not designed for phones.
The display is a real WebGPU compositor: phosphor persistence, bloom, scanlines and grain in one pass. Current Chrome and Edge have it on by default. Without it the terminal falls back to a CSS display and plays exactly the same.
No account and no server. Operations are saved in your browser's storage and export as JSON backups you can carry between machines; keep one before a browser clean-up, since the test build has no cloud.
Directives are plain text. Export one from the Workbench and it carries the fit and the wreck's site names, so the VS Code extension and the language server see exactly what the game sees. Edit in either place, test it on the bench; the dispatched copy is always the one you saved.
Losses are real in an operation: a stranded drone and its modules stay in the wreck until recovered. The training berth costs nothing and saves nothing but your course progress.
The early test build is open now, in your browser. Start with the tutorial, fly the training wreck, and write your first directive. The Steam release follows.