A 2D and 3D game engine whose editor is an MCP server.
Your AI agent builds the game with the same 181 tools the editor's own UI uses —
then ships it to the web, mini-game platforms, playable ads, desktop and native mobile.
Website ·
Agent ·
Getting Started ·
Documentation ·
QQ群 481923584
Every frame is one MCP tool call into the editor, captured as it happened — no mouse involved.
The Estella editor speaks the Model Context Protocol. Connect Claude Code, Cursor, Codex or any MCP client, and the agent works inside the real editor rather than around it:
It builds — creates projects, spawns entities from the editor's own Create catalog, writes component fields, makes prefabs, paints tilemaps, writes and type-checks scripts.
It looks — takes screenshots of the viewport and the running game, replays a frame draw by draw, compares the game with reference images, and audits what a scene's look lacks.
It plays — enters Play mode, steps time deterministically, sends input and clicks UI by name, runs scripted playtests, then reads the running world back.
It makes assets — images, sound effects, music and 3D models, each answered with a picture of what it made.
It ships — reads project health, exports the game, and drives a build running on a connected phone.
Every call goes through the editor's command surface: each one is one undo step, you watch it happen in the window, and you can take the mouse back at any time. The editor starts read-only; an agent edits only after you allow it in Window → Connect AI Tools…, which also writes the client's MCP config for you.
The tools are not all loaded at once. A session starts with the everyday ones
only, about fifty: read and edit the scene, play and step the game, open and save,
screenshots, logs, undo. The rest sit in the groups below, and the agent lists a group
when the work calls for it (enable_tools { groups: ["look"] }), so a session does not
pay thousands of tokens of tool descriptions for tools it never uses. Long tool guides
work the same way: a description is the short form, and tool_guide reads the rest by
topic. How a kind of task is done end to end (2D and 3D gameplay, UI, animation,
multiplayer, performance, shipping) is a skill the agent reads with skill_guide
before it starts.
| Group | What the agent gets |
|---|---|
| core | scene tree, entities, components, play / step / input, screenshots, logs, undo |
assets · prefab · authoring |
asset documents and import settings, tilemaps, prefabs and variants, physics bodies, UI events |
look · render |
reference images beside the game, light and field sweeps, frame capture and replay, shadows, LOD, bakes |
code · project |
scripts, symbol search, type-check, project settings, health, export |
image · sound · modeling |
draw sprites and textures, compose sound and music, build 3D models from steps |
terrain · tripo |
shape land from steps (ranges, rivers, roads, a coast) and place it in the scene; generate textured 3D models with Tripo AI (your own key and credits) |
play · view · device |
gamepads, time scale, scripted playtests, editor view, and a game running on a connected phone |
How undo works. Tools are sorted by how their effect is taken back, not by what they touch:
| A call that… | is taken back by |
|---|---|
| reads (scene tree, screenshots, logs, stats) | nothing to take back |
| plays, steps or sends input to the game | Stop: the game runs in its own copy of the world and never touches the scene you edit |
| edits the scene or a prefab | Undo: the edit goes through the editor's own history, the one Ctrl+Z walks |
| writes project files (a script, an asset, an image, a material) | Undo as well: the editor keeps each file as it was before the call and puts it back |
| leaves the project or runs code nobody can enumerate (a new project, an export, an editor command, code evaluated in the running game) | not undoable, and marked so |
One call is one step however much it did: a tool that adds six entities and writes two
files is undone by a single Undo, by you with Ctrl+Z or by the agent with its undo
tool. A save is not a step, so undoing never rolls a saved file back under an unchanged
scene.
An MCP server can be bolted onto any editor. What an agent can actually get done depends on what sits behind it.
The protocol is the editor, not a plugin on it. The 181 tools call the pipelines the editor's own menus, inspector and toolbar run, so an agent's edit is the edit a person would have made, and undoes the same way. Calls are schema-checked and permission-gated by the editor itself.
The agent can check its own work. It steps a paused game frame by frame, so "play three seconds, then look" is the same frame every run. It sees the game, not just the log: screenshots, a frame replayed draw call by draw call, the game set beside a reference image, scripted playtests that read the running world back.
The agent can make what the game needs. Sprites, textures, sound effects, music and 3D models come from tools inside the editor, so a prototype does not stop at grey boxes while someone opens five other programs.
Everything is text. Scenes, prefabs and materials are JSON; gameplay is TypeScript. An agent reads and writes the project directly, and every change is a reviewable diff.
It ships where heavier engines struggle. A WebAssembly runtime that loads on a phone browser, seven Chinese mini-game platforms, single-file playable ads for the major ad networks, and native Android / iOS apps — from one project.
It is open. The runtime, SDK, pipeline and CLI are Apache-2.0: no royalties, no seats, no runtime fees. The editor is a free download.
One day on the Amazon Lumberyard Bistro, recorded frame by frame from the running game: a sun that follows the clock, weather that turns from clear to mist, rain and snow, baked bounce light, reflections and volumetric haze. Scene © Amazon Lumberyard, CC BY 4.0, modified.
Space Frigate, a game made with Estella and recorded frame by frame as it runs: flying on thrusters, gunnery, and a jump through a gate to another star system. Every model, texture and sound in it is generated from a recipe.
A fight scene an AI agent built in the editor through MCP, recorded frame by frame as it runs. Both characters, their rigs and animations, the columns, the braziers and the floor texture were generated with Tripo AI by the editor's
tripo tools.
Estella is a C++ engine with a TypeScript SDK. The core runs as WebAssembly on the web and natively on desktop and mobile; game logic is written as ECS systems in TypeScript.
2D — sprites and sprite animation, tilemaps (with LDtk import), Spine 2.1 – 4.3 and
DragonBones, 2D lights and shadows, UI with layout, rich and bitmap text, particles,
Box2D physics, native 2D rigs.
3D — glTF / FBX import, PBR materials, directional / point / spot lights with
shadows, sky atmosphere with time of day and weather, baked lightmaps, light and
reflection probes, SSR, SSGI, height fog, terrain, water, foliage, skeletal animation
with spring bones, navigation, Jolt or PhysX physics, streamed large worlds.
Everywhere — one renderer for 2D and 3D on WebGL 2 and WebGPU, and one project
exports to:
Install. Download the editor for Windows or macOS from
estellaengine.com — always the newest release.
Every build is also on the releases page.
Create a project. Open the editor, click New Project, pick a template.
import {
defineComponent, defineSystem, addSystem,
Query, Mut, Res, Time, LocalTransform
} from 'esengine';
const Speed = defineComponent('Speed', { value: 200 });
addSystem(defineSystem(
[Res(Time), Query(Mut(LocalTransform), Speed)],
(time, query) => {
for (const [entity, transform, speed] of query) {
transform.position.x += speed.value * time.delta;
}
}
)); Press F5 to play — or connect your agent and ask it to do all three.
Everything lives at estellaengine.com/docs.
| Start here | What it covers | |
|---|---|---|
| Quick Start | install the editor, make a project, press play | |
| ECS | components, systems and queries — how game logic is written | |
| AI Agents | connect Claude Code, Cursor or Codex to the editor | |
| Time of Day | a sun and sky that follow the clock | |
| Weather | mist, rain and snow | |
| Exporting | web, desktop, playable ads and the rest, from one project | |
| Mini-game platforms | WeChat, Douyin, Kuaishou, Bilibili, Alipay, Huawei | |
| Android & iOS | native arm64 apps |
Estella does not accept pull requests. Bug reports and feature requests are welcome as issues — see CONTRIBUTING.md for what to include, and for building the engine from source.
Maintainers: see the release procedure for candidate builds, acceptance evidence and publishing.
The engine runtime, SDK, asset pipeline, CLI, project templates and editor plugin API in this repository are licensed under the Apache License, Version 2.0 — free for any purpose, commercial use included. We follow Semantic Versioning and keep a CHANGELOG.
- The visual editor is a separate, free product built on this engine; its source is not public. Everything needed to build, run and ship a game is here — see BUSINESS_MODEL.md.
- Trademarks. The license covers the code, not the "Estella" / "ESEngine" names or logos: say your project uses Estella, but don't ship a fork under that name.
- Spine. The bundled Spine Runtimes are not open source; a game that uses Estella's Spine integration needs its own Spine license. See NOTICE.