Make your first game.
Then make it your own.

1. Start and try the example

If SEAS is already open, choose Start → SEAS Workshop. You can also open Terminal and enter workshop.

To run SEAS locally, open a Linux terminal in the seas-desktop folder, run the command below, then open http://127.0.0.1:4173/ in your browser. The project requires Node.js 20 or later.

npm start

While that server is running, this guide is available at http://127.0.0.1:4173/docs/workshop-guide.html. You can also open this HTML file directly without starting SEAS.

1. Open Workshop and click Example. This loads an editable Coin Collector draft. If your current draft has changes, Workshop asks whether to discard them.
2. Select Player in the object list. Its scene properties appear on the left and its behaviour graph appears below the scene.
3. Click Play. A separate window titled Coin Collector — Playtest opens.
4. Click inside the game canvas and use the arrow keys to move. Collect the five yellow squares to increase the score and win.
5. Click the game window’s Restart button to reset it. Close that window to return to editing.

The example has four movement chains, coin collection, a score display, a win condition and solid boundary walls. Inspect its objects and nodes to see how they work.

The factory files are /projects/coin-collector/project.json and /apps/coin-collector/app.json. The first opens the editor; the second launches the published game. Terminal command game-coin-collector launches the published version too.

2. Find your way around

Workshop uses a normal SEAS window. Drag its title bar, resize from the window’s lower-right corner, or maximise it for more room. Scroll the sidebar and graph area to reach controls outside the visible space.

Drag the vertical divider beside the left project/object sidebar or the right node inspector to change its width. Double-click a divider to restore its default width. You can also focus a divider with Tab and use Left/Right arrows to adjust it, Shift for larger steps, Home/End for the width limits, or Enter to reset. Escape cancels an active divider drag. Width limits keep space available for the graph.

Drag the horizontal divider below the scene preview up or down to change its height. With that divider focused, use Up/Down arrows (10 pixels), Shift + Up/Down (40 pixels), or Home/End for the limits. Double-click or Enter restores 43% of the current editor height. The limits retain room for both the preview and behaviour graph. These layout changes stay with this editor window and are not saved in the project.

A leading • in the window title indicates a modified draft. The status bar also shows Modified after edits. Export retains the file externally but does not mark the in-SEAS draft as saved.

3. Create and manage projects

1. Click New.
2. Under Project & scene, enter a display Name, such as Garden Coins.
3. Set Project ID to a filename-safe name, such as garden-coins.
4. Choose the scene dimensions and background. The default scene is 640 × 400 logical pixels.
5. Click outside a text or number field, or press Tab, to commit its value before your next action.

The display name appears in editor/game window titles and installed-game listings. The Project ID determines the default project folder, published package folder and Terminal launcher. It must start with a lowercase letter, then contain only lowercase letters, digits or hyphens, with at most 64 characters.

Good IDs include garden-coins, maze-2 and my-game. Spaces, underscores, uppercase letters and slashes are not accepted.

Make a copy of an existing project

1. Open the source project, or click Example.
2. Change its Name and Project ID.
3. Click Save copy to write the copy to the new ID’s folder.
4. Save the copy to retain it in this browser, or Export a portable copy.

Opening another document resets the document’s undo/redo history. New, Example, Open and Import ask before discarding a modified draft. Closing the editor, ending its task, or powering down SEAS closes it without a save prompt; save/export first.

4. Edit scenes and objects

Scene coordinates

The origin is the scene’s top-left corner. Increasing x moves right; increasing y moves down. Scene width and height are whole numbers from 64 to 4096. The editor starts in Fit mode; game windows scale the canvas to fit. Viewing scale does not change those logical coordinates.

Zoom and pan the preview grid

• Zoom: use the preview’s − and + buttons, or roll the mouse wheel over the grid to zoom around the pointer.
• Fit: shows the whole scene and adjusts as you resize the window or panes.
• 100%: shows one logical scene pixel per CSS pixel. Manual zoom stays fixed when the window or panes resize.
• Pan: drag with the middle mouse button, or focus the canvas and hold Space while dragging with the left button. Scrollbars also let you reach areas outside the visible preview.
• Keyboard: with the canvas focused, + or = zooms in, − zooms out, and 0 restores Fit.

Object movement, grid snapping and the white resize handle still work in logical scene pixels at any zoom. Escape cancels an active object drag. Zoom, pan and pane sizes are separate for each Workshop window. They do not mark the project modified, enter undo history, or appear in saved/exported projects.

Insert a starter object recipe

Click Add recipe above the object list. Choose a Category and Object recipe, adjust its settings, and click Insert recipe. It creates ordinary editable objects and prewired behaviour nodes, with fresh IDs and working references. One Undo removes the whole insertion and any new variables.

Variable dropdowns let you reuse a compatible variable or create one with a name and initial value. Score recipes prefer a number variable named Score or with ID score, and otherwise offer to create one. Reusing preserves the variable’s initial value. Recipes use the actual variable ID in node parameters and text templates.

For a quick game, click New and insert Top-down player, Collectible and Score display. Select the display, append Win at threshold using the same Score variable and threshold 1, then Play and move through the coin. Duplicate or move objects to expand the game. Recipe-created projects save, export, import and publish using the existing format.

Create and select objects

Click + Rectangle or + Text above the object list. A new object is selected automatically. Click an object in the list, or click it on the scene, to select it again. Clicking empty scene space clears the selection. For overlapping objects, canvas selection picks the topmost object under the pointer; use the list to reach one behind it.

Objects are drawn in list order, so later objects cover earlier ones. There is currently no layer-reordering control. New rectangles start at x = 40, y = 80, with a size of 40 × 40 and collision mode none.

Move, resize, duplicate and delete

• Move: select and drag the object on the scene. Release the pointer to commit the edit.
• Resize: select it, then drag the white handle at its lower-right corner.
• Exact editing: change the numerical inspector fields. These fields are not forced onto the grid.
• Grid: with Grid on, dragging snaps to 16 pixels and arrow nudges move by 16 pixels. With Grid off, dragging rounds to whole pixels and arrow nudges move by one pixel.
• Duplicate: click Duplicate in the object inspector. The copy gets a new ID, a name ending in “copy”, a 16-pixel position offset and a copy of the original graph.
• Delete: click Delete object. Other graphs referring to its ID may need fixing before Play or Publish.

Duplicated graphs still target Self correctly. Explicit references to another object keep their existing target IDs; duplicating an object does not automatically retarget those references.

Undo/Redo covers object, variable, connection and node-layout changes, with up to 60 undo entries. It does not restore earlier filesystem saves or publications. After undoing a deletion, select the restored object again if needed.

Collision modes

For a coin pickup, set the player to solid and the coin to trigger. Both must have a mode other than none. Touching edges alone is not an overlap: their rectangular areas must intersect.

Movement does not automatically stop at the scene edges. Add solid walls to keep a solid player inside the scene. Avoid placing solids inside each other initially; Workshop does not push them apart automatically.

Text appearance

Text uses a single line in a sans-serif font. Its height controls font size, clamped from 12 to 96 pixels; its width limits the rendered text width and may compress long strings. Give labels enough width for their longest message. Text does not wrap automatically, and its inspector value is shown literally until a Set Text node replaces it.

5. Use variables and targets

Create a project variable

1. Scroll down the sidebar and expand Variables.
2. Click Add variable.
3. Enter a readable Variable name, select its Type, and set its Initial value.
4. Note the stable ID displayed above its fields, such as variable-1.

Number variables store values such as score, health or a numeric state. Boolean variables store true or false. Variables belong to the whole project, so any object’s graph can use them. Restart restores every variable’s initial value.

Changing a variable’s type resets its initial value to 0 or false. Check graph nodes using that variable after a type change or removal. Compare Number and Change Variable require number variables. Boolean values can be assigned with Set Variable and inserted into text; this release has no Boolean condition node.

Labels and IDs

The variable name is the label in node dropdowns. Text templates use the ID. For a new variable named Score whose ID is variable-1, enter this in a Set Text node:

Score: {variable-1}

The built-in example instead uses ID score, so its template is Score: {score}. Renaming Score to Points does not change its ID or break that template. New variable IDs are generated automatically; there is no ID-editing field in the variable panel.

Choose a target

Other is available only along a chain originating from On Overlap Enter. Using Other on an update, start or key-pressed path fails validation. Choose a text object for Set Text; a rectangle cannot display the result.

6. Build behaviour graphs

Each object owns its own graph. Select the object before adding nodes. A graph is an ordered set of events and actions: an event starts a chain, conditions choose a branch, and actions change the game.

Append a default behaviour graph

Select an object, click Add behaviour in the Behaviours toolbar, choose a recipe and its settings, then click Append behaviour. It adds a wired chain below existing nodes without replacing them or changing the object’s properties. Each append and any new variable share one undo step. Incomplete existing graphs remain editable; invalid recipe settings or exceeded limits leave the draft unchanged.

Contact behaviours require both objects to use solid or trigger collision. For a collectible’s own graph, use the player contact tag and Destroy Self; for a collecting player’s graph, use coin and Destroy Other. Set collision properties in the object inspector. You can edit all inserted nodes and wires normally.

Add and edit a node

1. Select an object in the object list.
2. Choose a node type in the Behaviours palette.
3. Click Add node. The new node is selected.
4. Edit its parameters in the node inspector on the right of the graph.
5. Click a node header to select it later, or drag the header to move it. Scroll the graph horizontally or vertically as needed.

Connect nodes

1. Click an output handle, such as next ●, true ● or false ●.
2. Click the destination action or condition’s ● in handle.
3. A wire appears. Repeat to extend the chain.

Each output connects to at most one destination. Connecting the same output elsewhere replaces its previous wire. To perform several actions, connect them in sequence through their next outputs. A condition has separate true and false outputs; you may leave a branch unconnected when no action is needed.

Event nodes have no input. Each event node begins its own chain; you can add several On Update nodes to one object. Two chains can share an action, but both can execute it when their events fire.

Cancel, disconnect or delete

• Cancel wire clears the output currently selected for wiring.
• To remove a connection, select either end and click the matching Disconnect … button in the node inspector.
• Delete node removes the selected node and all its incoming/outgoing connections.
• Use Undo if you removed the wrong node or wire.

Execution and validation

Graphs follow the connected output path. Moving nodes around changes their layout, not their execution order. Event roots run in creation/stored order, and objects run in list order. Overlap contacts are evaluated after movement, so score-label and win-condition updates usually see a newly collected coin on the next simulation step.

Use On Update for continuous behaviour. On Key Pressed runs once per press; holding a key does not repeatedly fire that event. Move uses pixels per second and advances only for that simulation step, so a Move attached directly to On Key Pressed produces a small single movement rather than continuous travel.

You can save/export an unfinished graph when the document itself is structurally valid. Play and Publish additionally check node parameters, references, types, ports and execution cycles. If validation fails, click an error row to select the affected object and node, correct it, then try again. Cycles are rejected even in disconnected parts of a graph; use On Update to repeat work over time.

7. Every node explained

The palette contains the 13 nodes below. Default parameters are starting values: select your actual variables and targets before playing.

On Start · On Update · On Key Pressed · On Overlap Enter · Key Held · Compare Number · Set Variable · Change Variable · Move · Set Text · Destroy Object · Restart Scene · End Game

8. Build a coin-collecting game

This walkthrough builds a complete arrow-key game from a blank document. The player collects five coins, the score changes, a win message appears, and walls keep the player inside the arena.

Step 1 — Set up the project and score

1. Click New. Set Name to My Coin Game and Project ID to my-coin-game.
2. Keep Scene width 640 and Scene height 400. Choose a dark background.
3. Expand Variables and click Add variable. Name it Score, keep Type number and Initial value 0.
4. Note its ID. In a fresh project it is variable-1; use your displayed ID if different.

Step 2 — Create the player and labels

Add the objects in the following order. Use + Rectangle for the Player and + Text for each label. Commit numerical edits with Tab or by clicking elsewhere.

Step 3 — Add four movement chains to Player

Select Player. Add an On Update node, a Key Held node and a Move node. Set Key Held to ArrowRight. Set Move to Target Self, X pixels / second 160 and Y pixels / second 0. Wire On Update’s next output to Key Held’s input, then Key Held’s true output to Move’s input.

Build three more separate chains on the same Player graph. Each needs its own On Update, Key Held and Move nodes.

Leave the false branches unconnected. Drag node headers into separate rows to keep the chains readable. You can Play now to check movement, then close the playtest to continue.

Step 4 — Add five coins

Create a rectangle named Coin 1 with x = 130, y = 175, width/height 18, a yellow colour, Tags coin, and Collision trigger. Duplicate it four times and edit each copy’s name and x value:

Reset y to 175 on every copy. Duplicate offsets both x and y by 16 pixels; changing only x would create a diagonal row. Confirm each copy still has size 18 × 18, tag coin and collision trigger. The coins do not need graphs.

Step 5 — Collect coins on the Player graph

1. Select Player. Add On Overlap Enter, Change Variable and Destroy Object.
2. Set On Overlap Enter’s Other tag to coin.
3. Set Change Variable’s Variable to Score and Amount to 1.
4. Set Destroy Object’s Target to Other (overlap event).
5. Wire the three nodes in order using next outputs.

Keep this chain on Player. On that graph, Self is the player and Other is the touched coin. Destroy Self would remove the player instead.

Step 6 — Show the score

1. Select Score label. Add On Update and Set Text, then wire next to the Set Text input.
2. Set Text object to Self.
3. Enter Score: {variable-1} in the text-template field, substituting your score variable’s actual ID if different.

Place the template in the Set Text node. The text object’s ordinary Text property can remain Score: 0.

Step 7 — Add the win condition

1. Select Win label. Add On Update, Compare Number, Set Text and End Game.
2. In Compare Number, select Score, comparison >= and value 5.
3. In Set Text, choose Self and enter You win!.
4. In End Game, enter a message such as All five coins collected!.
5. Wire On Update next → Compare Number input, Compare Number true → Set Text input, and Set Text next → End Game input.

Step 8 — Add boundary walls

Add four rectangles with the following properties. Use a muted colour, Collision solid and no behaviour nodes. Their names are for your convenience.

Step 9 — Play, retain and publish

1. Click Play. Fix any listed validation errors by selecting the error row.
2. Click the game canvas and use the arrow keys. The player should stop at the walls.
3. Collect all five coins. Each disappears once, Score reaches 5, the label changes and the game ends.
4. Click Restart. The player, all coins, score and label return to their original state.
5. Close the playtest. Click Save, then Export and keep the downloaded file.
6. Click Publish. Launch My Coin Game from Start’s Installed games section, or enter game-my-coin-game in SEAS Terminal.

To extend the game, move the coins, increase movement speed, add obstacles or change the target score. If you change the number of coins, update the Compare Number threshold to match.

9. Playtest and restart

Play validates the current draft and opens a separate game window. It includes unsaved edits, but does not save them. A playtest’s score, movement and destruction never change the editor document.

• Click inside the game canvas to direct keyboard input there. Keyboard gameplay ignores focused buttons and form controls.
• Only the active game window advances gameplay. Switching to Workshop or Terminal, minimising the game, hiding its browser tab or losing browser focus pauses it and clears held keys.
• Resume by activating its window/taskbar button and clicking the canvas. Press movement keys again after returning.
• Restart resets the snapshot that this window originally loaded. It does not fetch later editor changes or a newer published package.
• To test new edits, return to Workshop and click Play again. You may have several separate playtest windows.
• Close a game with its window close button, or use Task Manager → Applications → the game’s row → End Task.

After End Game, graph events stop. The window’s Restart button remains available. A runtime error appears in the game status area; fix its source graph and open a new playtest.

10. Save, export and restore

Save inside SEAS

SEAS stands for Synthetic Environment and Application System. Earlier Aster exports ending in .aster-project.json remain importable. New exports use .seas-project.json, and the game loader accepts both seas-game and legacy aster-game version-1 packages.

Click Save or press Ctrl+S. A new draft saves as /projects/<project-id>/project.json. An open project saves back to its existing path. The status bar confirms the path or explains a failure.

Save copy uses the current Project ID. If that folder already exists, Workshop offers Replace or Cancel. Replace swaps the entire destination project directory; export anything you want to retain before replacing it. It does not choose an alternative ID automatically.

Export to your computer

1. Click Export. You can export the current draft without saving it first.
2. Find <project-id>.seas-project.json in your browser’s downloads, or the folder chosen in its download prompt.
3. Keep a copy in a real project folder. Use dated filenames if you want separate versions.

The export contains scene objects, variables, graph connections and editor node positions. First-release projects use shapes and text, so the file is self-contained. It exports source, not a published app directory or the current playtest’s score.

Restore after reload or share with someone

1. Open Workshop in the new SEAS session.
2. Click Import and select the exported JSON file from the real computer’s file picker.
3. If validation succeeds, it opens as an unsaved draft. Click Save to retain it in this browser’s /projects.
4. Click Play to test it, or Publish to install its game in this browser.

The recipient of a shared project follows the same Import → Play/Publish workflow in an SEAS installation supporting project schema version 1.

If a mount disappears

Unmounting /projects leaves the open editor draft in memory. Save reports the unavailable path, while Export still works. Use SEAS’s Mount Manager, or Terminal command mount /projects, to reattach the volume. If the original file no longer exists, use Save copy after choosing a suitable ID.

11. Publish and launch games

Publish creates a playable snapshot of the current draft, including unsaved edits. It does not save the editable source or clear its modified status. Save and Export the source separately when you need to keep editing it later.

1. Check the project Name and Project ID.
2. Click Publish. Resolve any graph-validation messages.
3. If /apps/<id> already exists, choose Replace to update it or Cancel to keep it.
4. Read the status bar for the published path and Terminal command.

The package contains app.json (the game’s launch manifest) and game.json (its validated game snapshot). Publishing stages both before replacing the destination folder. A validation failure leaves the previous published package intact.

Four ways to launch a published game

Run these commands inside SEAS’s Terminal, rather than your host Linux shell. The launcher also exists at /bin/game-my-coin-game. Opening game.json alone opens a text document; app.json is the launch entry.

Update an installed game

Edit the source and Publish again, then choose Replace. Already running games retain their old snapshot. Close and relaunch to use the updated game; clicking Restart in an old window still resets its old version. Changing source alone does not update the installed package.

If you want a separate installed game, choose a different Project ID before publishing. Replace overwrites the destination package folder rather than creating a backup.

Inspect or remove a package

Installed lists valid packages and diagnostics for invalid ones. A broken manifest or game document has no launcher. For a project you can still open in Workshop, fix the source and republish.

To remove a first-release package, use SEAS Terminal to remove its two files, then the empty folder:

rm /apps/my-coin-game/app.json
rm /apps/my-coin-game/game.json
rm /apps/my-coin-game

Use the ID of the package you intend to remove. This does not delete its editable /projects source or host export. A game already running can continue from its loaded snapshot.

If /apps is unmounted, publishing and new package launches are unavailable, and installed launchers disappear. Remount with Mount Manager or mount /apps. Loaded game windows can continue when active.

12. More behaviour recipes

Add WASD controls

On the Player graph, add separate On Update → Key Held → true → Move chains using KeyD (right), KeyA (left), KeyW (up) and KeyS (down), with the speeds from the tutorial. You may keep the arrow chains too; holding two keys mapped to the same direction runs both movement actions and doubles that direction’s movement.

Make a hazard end the game

Add a trigger rectangle with tag hazard. On Player, add On Overlap Enter with Other tag hazard and connect next to End Game. Set its Message to You hit a hazard.. Use the game window’s Restart button to try again.

Add a restart key while playing

Add this chain to Player. It resets the running scene when Enter is pressed. Once End Game stops gameplay, use the Restart button instead.

Gate movement using a number variable

Create a number variable named Enabled with initial value 1. Insert Compare Number between On Update and Key Held, test Enabled == 1, and connect its true output to Key Held. Another event can set Enabled to 0 using Set Variable to disable that movement chain.

Display a Boolean flag

Create a Boolean variable, note its ID, and use a text object with On Update → Set Text. A template such as Switch: {variable-2} displays true/false. Add On Key Pressed: Space → Set Variable on another object to set the flag to true. There is no automatic toggle node; use separate keys to assign true and false if needed.

13. Keyboard reference

These shortcuts use Ctrl. Text inputs retain their own text-editing behaviour for undo; use the toolbar to undo a whole document edit while a field has focus.

These are available inputs, not automatic game controls. Your graphs must connect them to actions. Modified shortcuts involving Ctrl, Alt or Meta are ignored by gameplay input.

14. Troubleshooting

Read Workshop’s bottom status bar after Save, Export, Import or Publish. Graph problems appear in a sheet when you click Play/Publish; select an error row to jump to the affected object/node. Runtime messages appear in the game window.

15. Current scope and limits

The first release supports one scene, coloured rectangles, single-line text, keyboard input, rectangular solid/trigger collisions, number/Boolean variables and the 13 allowlisted behaviour nodes.

It currently has no sprite/image import, animation, audio, multiple scenes, scrolling camera, gravity, platformer controller, mouse/touch/gamepad behaviour nodes, expression language, generated script execution, automatic unsaved-draft recovery or standalone game-export button. Publishing installs a game within SEAS; it does not produce an independent host application.

Keep a scene manageable and export backups as you edit. Limits are checked by the document/runtime validators; adding another object or node beyond a limit may leave a draft that needs simplifying before saving or playing.

16. Files and version reference

The visual controls create these files for you. This reference helps you recognise the source and launch entries when browsing SEAS.

/projects/my-coin-game/
    project.json       Editable project source

/apps/my-coin-game/
    app.json           Package manifest; open this to launch
    game.json          Published game snapshot

my-coin-game.seas-project.json
                      Export downloaded to your host computer

Project documents use schemaVersion: 1. They contain a stable project ID and name, scene settings, variables, objects and per-object graphs. Object/node/variable IDs use the same lowercase letter/digit/hyphen form as Project ID. Object IDs self and other are reserved.

An object graph contains event roots, nodes and edges. Each node stores its type, parameters and editor position. Each edge stores its source node, output port and destination node. Publishing removes node editor positions from the game snapshot; it keeps the initial game state.

Package manifests have a separate package schema version and runtime version. A typical manifest is:

{
  "schemaVersion": 1,
  "id": "my-coin-game",
  "title": "My Coin Game",
  "kind": "seas-game",
  "runtimeVersion": 1,
  "entry": "game.json"
}

Discovery checks immediate /apps child folders with app.json. The manifest ID must match its folder and game document, and the entry must be game.json. Packages nested more deeply are not discovered. Unsupported versions are reported rather than silently converted.

Source files versus the factory image

SEAS loads its factory filesystem from rootfs.zip and applies this browser’s saved changes during boot. For a project bundled for every visitor, update the factory image itself; browser storage and exports belong to individual users and do not change rootfs.zip.

For everyday authoring, use Save and Publish to keep files in this browser. Keep a host project export or Control Panel backup for portability and recovery.