Sandkit surface map

How this was built

Not from the community type definitions, and not from memory. The game ships dist/js/external-mod-runtime.js and external-mod-worker-runtime.js — the bridges that every mod call actually passes through. Those files are the API.

1. Extract both runtimes from app.asar and parse each namespace group out of the minified source, resolving variable references to their nearest preceding definition.
2. Record, for every method, its argument count and the engine function it delegates to — the third column in the reference tables below.
3. Diff the result against a sandkit.d.ts, in both directions.

The whole pipeline is three commands against your own install, so this page can be regenerated for any build rather than trusted as a snapshot.

Anatomy of a mod

Four surfaces, declared in modinfo.json. Most mods use one; the ones that feel like new game content use three.

Main vs worker

The single most important distinction in this API, and the one that decides where your code has to live.

What can I build?

Read this column first. It is the question people actually arrive with.

Hard limits

Verified in the shipped code, not inferred from silence. These are the ones that change a design.

Events & hooks

Ids found in the shipped bundle (45 in total). Payloads for a handful are remapped into a frozen shape for mods; anything the game does not recognise passes through untouched, which is what makes worker → main custom events work.

Lifecycle & world

Building & structures

Simulation (worker)

Player, input & projectiles

Resources & rendering

Outlined: a guard is required, or the subscription throws.

Hooks

hooks.intercept cancels an engine call before it happens; hooks.modify rewrites its arguments. The ids are a whitelist kept as a literal in the bundle — these are all of them, not a sample. Some ids appear in the event list too: the event fires after the fact and can only watch, the hook runs first and gets a vote.

Interceptors — cancel the call (18)

Modifiers — rewrite the arguments (15)

Outlined ids accept a guard option, so a handler can subscribe to only its own structure, weapon or projectile types instead of filtering every call by hand:

Patching the game

The part most people miss: a plain Workshop mod can already rewrite the game bundle. No loader, no installer, no touching app.asar.

Main API 281 methods

Sorted by size. Open a namespace for its methods, argument count, and the engine function behind each one.

Worker API 88 methods

A quarter the size, and deliberately so: this thread exists to touch cells fast.

Value catalogs

The reference tables above say what a mod can call. These are the values worth passing — collected from the same shipped code, so they regenerate with the game.

Sound ids (63)

Everything the game itself passes to its sound engine, playable via sound.play(id, options) — with calculateDistanceOptionsAtWorld for falloff and rateLimitKey so a hundred machines share one voice.

Structure ambience groups, for the ambienceGroup render field: clearingFrames, conveyors, launchers, shakers, steamTurbines.

gameConfig defaults (81)

What gameConfig.getAll() returns before anything overrides it — including the flags no options screen exposes. customMaps.showCustomMaps and mods.showSubscribedMods ship false: whole features behind a boolean. The procgen subtree is the map generator's own knobs, seed included.

window.electron (65)

The Electron preload bridge. Mod entries run in the same renderer, so all of it is reachable from a mod: openDevTools(), save export and import, the local-mods folder, Workshop subscription management.

Beyond api

sandkit.api is not the whole object a mod is handed. Three more members sit next to it, none of them a method, which is why none of them appears in the tables above — and why a mod cannot draw a single button without one of them.

sandkit.enums (22 / 323)

The game's own enumerations, re-exported member by member. These are the numbers the API expects: ui.update(enums.ComponentId.Hotbar), scene.getActive() === enums.Scene.MainMenu, a key state compared against enums.KeyState.Pressed. Writing the literal instead works right up until a patch renumbers it.

sandkit.react (18.3.1)

A frozen copy of the game's own React. Mod components render inside the game's tree, so hooks work normally — but they have to come from here, because a second copy of React in one tree does not.

sandkit.state (424 / 1362)

The live game state, and the same object as sandkit.engine.state. It is where mods go when the API has no getter — the energy buffer, the open windows, the resource counts. Nothing about its shape is in the shipped code, so this table is measured from a running game: names, types and sizes only, never values.

Three levels deep on this page. The dump goes to 4 and holds 1362 paths in all — data/state.json has the rest. Branches keyed by id rather than shaped — whichever mods are installed, whichever tech a save has — are kept as a node with their children dropped, since walking them describes one machine rather than the game: state.sandkit (1038), state.session.lexicon.entriesById (337), state.store.mods (120), state.store.player.tech (71), state.shared.mods (19), state.session.settings.externalModSettings (14).

Traps

Collected the expensive way, across eight mods.