Shell Editor

Make a game by asking for it

And keep making it. Say what you want to play and an AI Agent builds it as a real Project: scenes, entities and code that you, your team or the Agent can keep changing.

Request access Read the docs

By invitation for now. Made at Setsnail.

Juggle main.scene M J A Play

Thread

Mia asked A side-view soccer game where you juggle a ball and jump on it to get higher

Made main.scenePlayer, Ball, Goal, ScoreWrote juggle.system.tsPlayed 120 frames to check

Checkpoint kept before this Run

Make the ball bounce higher Ask

Jon

Ball ball.prefab

Position

X 412 Y 168

Rigid body

TypeDynamic

Bounce0.8

Juggle

Kick14

Spin2.5

Keep making it

Not one big HTML file. A Project you keep editing.

A game made from a prompt is often one long file you can only change by asking again. In Shell, the Agent works in the same kind of editor a studio uses, so everything it makes stays open to change.

game.html

To change one thing: ask again, and hope the rest stays.

Hierarchy PitchGoalPlayerBallCoin ×12Score

Player

Jump height14

Run speed6

Spriteplayer.png

To change one thing: select it.

Scenes and an Inspector

Select the player and set its jump to 14. The fields are the game's own components.
Prefabs

Make one coin, place a dozen, and change them all in one place.
With or without the Agent

A change by hand and a change by prompt land in the same scene, and undo takes back either.

MCP built in

An editor your Agent works in, not around

Every Shell Editor has an MCP server inside. The Agent in the Thread uses it, and so can Claude Code on your own machine. It reads the scene, places entities, writes scripts, plays the game a frame at a time and looks at the result.

[N] Agent tools, from the scene to play mode to screenshots.
1 Checkpoint before every Run, so the Project can go back to how it was.
Your own agent connects with a token from your Dashboard.

Claude Code connected to Juggle

> Add a score that counts each kick get_editor_stateinstantiate_prefab code:ui:text Scorewrite src/scripts/score.system.tscheck_code 0 errorsrun_action play.startPausedplay_keys Space ×3screenshot The score reads 3 after three kicks.

Checkpoint before “Add a score that counts each kick” Restore

Real time

Edit together, in the same scene

Invite your team to a Project and work in it at once, the way you would in a design tool. Every Member sees the others' pointers and selections, and every prompt and Run in one Thread.

Presence: who is where, and what they have selected
One Thread: nobody asks the Agent for the same thing twice
Versions: name a moment, and go back to it

Mia

Ana

Jon

Mia moves PlayerAna asks the AgentJon in goal.prefab

Developer friendly

Write code in the browser, or in your own editor

Every script is a TypeScript file. Open it in the editor's Code tab, in the browser. Or keep the Project's code in a folder on your own computer, and edit it in Neovim, VS Code or any editor you like.

In the browser: the Scripts panel and Code tabs, with colours, type errors and hover
Core: the code the game and the editor start from, read only beside your scripts
On your computer: one command keeps a folder in step with the Project both ways, with the editor's types in it
Any editor: Neovim, VS Code or another, since the folder is plain files

Edit on your computer needs Node 20 or later.

# Edit on your computer, in the editor, gives you this line:
npx -y https://app.shell-engine.com/local-<version>.tgz <your Project's address>

# It asks for your token, makes a folder named after the Project,
# and keeps it in step. For a Project called juggle:
code juggle        # VS Code
nvim juggle        # Neovim

Shell ECS

Fast by design, not by tuning

Under the editor runs Shell ECS, an Entity Component System for TypeScript. Components are typed columns in archetype tables, so a system runs over packed numbers instead of chasing objects. Speed is where the engine starts, not a pass at the end.

import { Define, Mut, Rotation, StoreType } from '@shell/engine-2d';

export const Spin = Define.component('spin')
  .withSchema({ speed: { type: StoreType.Float32, default: 2 } })
  .serializable()
  .showInEditor();

export const SpinSystem = Define.system()
  .queries({ spinners: { data: [Spin, Mut(Rotation)] } })
  .update(({ queries, time }) => {
    queries.spinners.forEach((e) => {
      e.$rotation.z += e.$spin.speed * time.delta / 1000;
    });
  });

Data-oriented by default

Archetype storage as a Structure of Arrays keeps component data compact and kind to the cache.
One package per job

Rendering, physics, input, audio, UI and networking come in when a game needs them, not before.
Typed from end to end

A component's schema is its type, in code, in the Inspector and in a saved scene.

Made at Set Snail

14 years. Five iterations. One editor.

Shell is the editor we built for our own games at Set Snail and for the games we make for our clients. Each iteration of the engine taught the next one something. The fifth is the first we share with everyone.

14 years making games
5 iterations of one engine, each built on the last
[N] games shipped for clients and ourselves

[YEARS] [ITERATION 1] [What it added]
[YEARS] [ITERATION 2] [What it added]
[YEARS] [ITERATION 3] [What it added]
[YEARS] [ITERATION 4] [What it added]
Now Shell ECS, the editor, the Agent, editing together

Tested on real games

[GAME TITLE 1] Client game
[GAME TITLE 2] Our own game
[GAME TITLE 3] Client game

Request access

Shell is by invitation while we open it up. Tell us who you are and what you want to make, and we will write back.

Make a game by asking for it

Not one big HTML file. A Project you keep editing.

Scenes and an Inspector

Prefabs

With or without the Agent