Gamewright

Gamewright Studio

Everything in the Studio

A desktop app for macOS, Windows and Linux, built on Godot, where you make a game by saying what you want and approving what the Director proposes. Here is each part of it and what it does.

The Studio

Your game’s documents on the left, the game playing in the middle, the checks below, and the Director on the right.

  • Documents listed the way you think of a game: its world, characters, items, rules, look and sound, playtests. Names, never file paths or ids.
  • The game plays inside the Studio on the same engine it ships on. Click it to play; click outside and the keys come back to you.
  • Check, Build, Playtest and Play, each one click, each result said in plain words.
  • A pro tool’s habits: panels that fold away, drag to any size and are remembered, menus with every command and its key, every key on a sheet (Ctrl+/), and Ctrl+K to find a document, a section or a command.
  • Start a game from a template’s starter that plays at once, from one of the ten games, or from an empty folder the Director fills. The games you opened are a click away, and each opens on its next steps: build it and play it, playtest it, ask the Director.
  • Change any document by hand: its fields in plain words, each in the control it needs, with its range and what it is for. Each change is yours, checked as you make it, and Ctrl+Z takes it back.
  • Lists too: tags, a recipe’s inputs, a level’s parts, each item added or taken out in place. What the Director proposes shows under the field it would change, with Approve and Reject right there.
  • Paint a level on a canvas, as the game draws it. Export a game as one zip for Linux, Windows, macOS or the web that anyone can play, with nothing else to install.
Gamewright Studio with Tideline open, its items listed with Driftwood chosen, the coast playing, the checks below saying it was checked and built.

The Director

An AI that writes your game as documents, never as code, and only through proposals you decide on.

  • Ask in plain words. Its answer streams in, with each step it takes.
  • Each proposal says what changes from what to what, why, and whether every check still passes, before you are asked.
  • Approve and the game rebuilds and plays; reject and nothing moves. Every change can be undone.
  • It runs on your own Anthropic key, kept in your system’s keychain, and each turn shows what it cost.
  • Or connect your own Claude Code with one command: its proposals show in the Studio the same way.
The Director beside the game with a proposal to make the driftwood easier to see at night: the description from grey to pale, with Approve and Reject. The Director's turn here is scripted, so the picture costs nothing to make.

Six templates, ten games

A template is a genre the engine already knows how to play: its rules, its controls, its screens, its bots. A game pins one and changes what it needs. Each has a starter: the smallest game on it, playable the moment you make it, in its sample’s look and sound, and checked to L2 like every game here.

Games as data

A game is a folder of small JSON documents, a Game Pack, that you can read, diff and keep in git. Every document has a schema; the whole game is checked as one.

The shape of a game

A Game Pack is a genre template plus small JSON documents. Deterministic builders turn it into a world, models and sound; new mechanics grow the engine as kits, so the engine stays one program every game shares.

my-game/
  game.json        template, seed
  theme/ styles/   fiction, look
  archetypes/      entities
  brains/ rules/   behavior
  worlds/ biomes/  generators
  models/ sounds/  recipes
  ui/ input/ camera/
  playtests/       what "done" means
The shape of a Game Pack. Each folder holds JSON documents.

Proof, not promises

Nothing is called done until it has been played: by bots, in frames, in a browser, then by you. The ladder runs from L0 (the documents follow the rules) to L5 (the web build ends in the desktop’s exact state).

Tideline, the first game, was written by hand to prove the engine could run a game from data alone. What it proved, automatically:

  • The same seed makes the same world, on desktop and in the browser.
  • Editing a generator changes the world stamp, and an old save is refused by name.
  • A proof tour plays from the title with no cheats: gather, build the fire, survive the night, win the fight, save and load.
  • Tactics beat stats: a bot that dodges wins at least 80% of 20 seeded fights; one that trades blows loses.
  • A lamp at night gets you noticed from further away than crouching in cover.
  • The web build boots in headless Chromium, has sound after the first key, and keeps its save.
The Studio after the change was approved and playtested: the checks panel says, in plain words, that each rung passed and every check passed.

The engine under it

Godot 4.7, with one player for every game on desktop and in the browser.

A dark coastal hill at night seen from above: a warm campfire and a lantern-lit person, a machine's cold lens, pines and driftwood under the moon.
Tideline at night, rendered by the engine’s own checks.

From the engine

Real frames, rendered offscreen by the engine’s own checks. The same frames render byte for byte the same on every run.

A dark coastal hill at night seen from above: a warm campfire and a lantern-lit person, a machine's cold lens, pines and driftwood under the moon.
Night, rendered by the engine: a warm fire and lamp, a machine's cold lens, a pine crown cut away over the player.
A hacked slate screen showing the carry app: driftwood, knife in hand, lamp, scrap and stone, with a load bar.
The slate UI, drawn from Screen documents. Sound is synthesized from recipes too.
Part of Tideline's generated map from above: sea, sand and shingle beach, turf, a cliff band, heath with pine clusters, and a tarn.
Tideline's coast, generated from data by seed. Every named place has a stored proof that it can be reached.
Models built from recipes: a rusted wreck, a four-legged sentry with an amber lens, a person in a coat, and a campfire, each at four bearings with a silhouette.
Every model is a recipe the Director can write, built by code and pinned by a hash. No imported art.
A pixel-art platformer: a runner in a red shirt reaches a wooden door in a cave, under a panel that reads EVERY LEVEL DONE, 4 gems.
Burrow Run, the platformer template. Its caves are laid out by a generator, and each level ships with the route that proves it can be finished.
A grassy coast from above with a person on a sand path; at lower right, a green mound that is really a sentry machine painted the colour of the turf.
A planted bug: the green mound at lower right is a sentry painted the colour of the turf. The frame check measures it against the ground and fails the build.
A pixel-art visual novel: an old woman in a navy coat and a young man in a yellow oilskin on a pier at dusk, a dialogue box with her line, and keys to reread or go on.
Fog Signal, the fourth template: a visual novel that needed no new simulation kit, only a Dialogue document the bake checks for dead ends.
A grid puzzle in flat colours: a white keeper, orange crates, a yellow berth with one crate home, grey posts, and the level name and turn count.
Pier Pressure, the grid puzzle template: a solver proves every level can be won before it ships, and stores the route a tour replays.

Where it runs

Download the StudioRead the docs