Why ChatGPT and Claude make better games inside Galatrix
ChatGPT and Claude are excellent at writing code, and asking one for a game is a great way to try an idea. They make even better games inside Galatrix: the AI builds on a complete engine, its work becomes a project you can see and change, and the result exports as a standalone game for the web, desktop or mobile, ready to connect to servers of your own.
Updated · 11 min read
The short answer
Making a game with ChatGPT or Claude works better inside Galatrix, for three reasons.
The engine has already solved most of game development. Rendering, physics, input, cameras, navigation, UI and audio are built, tested and tuned. The AI puts its effort into your game, its levels, rules and feel, instead of rebuilding an engine in every conversation.
You see the project, not just the code. What the AI builds is a game you can look at, play and change by hand in a full editor: objects you can select and move, settings you can adjust, scripts you can open.
You ship a real game, wherever you want it. Every project exports as a standalone game: one HTML file that runs in any browser, a bundle for your web host, or a desktop, Android or iOS project. Standalone games can talk to servers of your own, so online play, leaderboards and chat run on your terms.
What ChatGPT and Claude do well
ChatGPT and Claude are strong partners for the thinking side of making a game. They are especially good at:
- Ideas and design. Talking through a genre, a core loop, a twist, a level layout or a difficulty curve, and offering alternatives when an idea needs work.
- Writing and explaining code. Drafting a function, walking through a piece of code line by line, or tracking down the cause of an error you paste in. They are good teachers for concepts like vectors, game loops and state machines, too.
- Quick prototypes. A small mechanic you can run straight from the chat is a fast way to find out whether an idea is fun.
- Words and numbers. Dialogue, quest text, item names, shop prices, enemy stats and level data, in whatever format you ask for, JSON included.
- Coding agents. Claude Code, Codex and similar tools work across a whole folder of files, run commands, and fix their own mistakes as they go.
Each of these strengths carries into Galatrix, as the two ways to bring them in show.
As the game grows
Ask ChatGPT or Claude for a whole game and you get code, usually one HTML file with the game loop and everything else written into it. It is a good start.
As the game grows, so does the file. It holds everything that game needs, from drawing and physics to the camera, controls and menus, and the conversation becomes the project. Each change comes back as new code to put in place, and how the game plays reaches the AI through your description. Art, sound, performance, online play and packaging for each platform each become projects of their own.
That is the work Galatrix takes off the AI’s hands. You keep the best part, describing what you want in plain words, and the engine and the editor provide the rest.
Side by side
| ChatGPT or Claude alone | Inside Galatrix | |
|---|---|---|
| Where you work | A chat window | A full game editor in your browser, with AI beside you |
| What the AI writes | The whole game, engine parts included | The rules that make the game yours, on a ready engine |
| What you get | Code in the conversation | A project: objects, scripts, assets and settings |
| Making a change | New code to put back in the file | Edits applied to your map, undoable as one step |
| Checking it works | You play it and describe the result | Play it in the editor, then run a test pass against your goal |
| Performance | Tuning to write yourself | Instancing, static batching, quality settings and a profiler |
| Platforms | A web page to package yourself | Web, desktop, Android and iOS from one project |
| Online play | Networking to write from scratch | A WebSocket API for servers of your own |
| With a coding agent | Engine code written in a folder | Editor commands, with the running game to check against |
The tech underneath
Galatrix is a complete web game engine, built on proven open-source libraries:
- Rendering. Three.js on WebGL 2 or WebGPU: a physically based renderer with the lighting, material and post-processing controls a world needs to look art-directed, plus render-to-texture cameras and multi-camera viewports.
- Physics. Rapier, compiled to WebAssembly: rigid bodies, colliders, joints, triggers, ragdolls, and raycasts and overlap queries with layer masks. It simulates identically in the editor and in exported games.
- Scripting. A JavaScript runtime with behaviour classes and the start-and-update lifecycle, coroutines, timers and events, and an API with the names engine developers already know, such as Vector3, Quaternion, Mathf, Time, Input and Physics.
- Input. Keyboard and mouse, touch and multi-touch through the same input API, and gamepads readable from scripts.
- Worlds and characters. Baked navigation with agents that climb ramps and jump gaps, sculpted terrain, block worlds, 2D sprites and tilemaps, animation, particles, weather and UI.
When the AI builds your game, it uses all of this. It places objects that draw, collide and move through the engine, and writes short scripts for what makes the game yours: how the coin spins, what the checkpoint saves, when the round ends. Scripts take the same shape the documentation teaches, so they stay readable as the game grows.
Built to run fast
The engine is tuned for the laptops and phones players already own, and gives you the levers to keep a game smooth:
- Many objects, few draws. With instanced drawing, copies of an object that look alike draw together, while each one still moves, collides and runs its own scripts. At build time, objects marked static merge into shared draw calls.
- Smooth frames. The engine’s per-frame work is written to avoid the memory churn that causes hitches, and systems a game does not use stay out of its frame.
- Quality that fits the device. Render scale, frame-rate cap, shadows and particle density are adjustable, and a game can ship its own graphics menu. Phones get touch controls and a HUD that scales to fit.
- A profiler built in. A frame strip, counters, the scripts that cost the most and the spikes worth chasing.
Standalone builds: ship it anywhere
A standalone build is your game as a self-contained package, running the same engine and scripts you tested in the editor. One project can ship to:
- The web, as one file. A single HTML file with the engine, physics and your scene inside. It opens in any modern browser, even offline, and drops onto any website or game portal.
- The web, as a bundle. The same game as separate files, ready for your own web host or CDN.
- Desktop. A ready-made Tauri project with your game inside, which you build into a desktop app.
- Android and iOS. A ready-made Capacitor project with your game inside, which you build into a mobile app with each platform’s own tools.
Every build comes with the options a release needs:
- Lean downloads. Compress the scene and the engine, minify scripts, and leave out engine modules your game never uses.
- Your code, protected. Obfuscate script sources so the export does not ship readable code.
- Your choice of graphics API. Build for WebGL 2 or WebGPU.
- Settings the host can change. A JSON config travels with the page, editable after the build, and your scripts read it at runtime. One build can serve several sites, each with its own settings.
- Your brand. On a Pro plan, the build carries your own name, or no branding at all.
The AI builds for standalone from the start, too. Choose a standalone game in the game quiz, and the AI builds one with scenes such as a menu and levels.
Online play on your own servers
A standalone game can open WebSocket connections to servers you run: your own multiplayer, leaderboards, chat or level service, or an existing server you already have.
- Your protocol. Sockets carry text and binary frames with no size limit and no conversion, and a game can keep as many open as it needs. Login, messages and reconnects work exactly the way your server expects.
- Steady while in the background. Frames arrive in order even while the tab is hidden, so keep-alives keep flowing.
- Safe by design. Every host a game may reach is listed in its settings, over secure WebSockets. A script from an imported kit, or one an AI wrote, cannot send a player’s browser anywhere you did not list. Plain connections to your own machine are allowed for development.
- Server lists welcome. A game where players type an address can allow any host, and the engine asks the player before the first connection to a new one.
A game with an online mode can check whether sockets are available and keep its offline play working everywhere else.
A full game editor, not a code block
Everything the AI makes, in AI Chat or through the CLI, lands in the editor as ordinary content. Objects appear in the Hierarchy, their settings in the Inspector, and scripts sit attached to the objects that run them.
The editor is a complete tool in its own right:
- Runs in the browser. It opens in a tab, and it installs as a desktop app if you prefer a window of its own.
- Shape the world by hand. Move, rotate and scale tools, snapping, multi-select, parenting, tags and layers, and a command palette for finding any object or command.
- Build once, reuse everywhere. Save anything as a prefab, place copies around the map, and change what differs in each one.
- Code with help, or without code. The Script Editor autocompletes the engine API, and Event Sheets express logic as visual rows.
- Several levels in one project. Menus, levels and other scenes live side by side and share their assets.
You can step in at any moment: drag a platform, change a colour, open a script, save something you like as a prefab. The next time you ask the AI for something, it works from the map as you left it, your changes included.
AI that works inside the project
AI Chat, the editor’s own AI, works from the map you have open: its objects, their components and scripts, and the game’s settings. That is why you can point at things in plain words. “The red platform by the start” or a name from the Hierarchy is enough for the AI to find the right object.
- Edits you can take back. Its changes go in through the same editor commands you use, and Undo turn takes back a whole request as one step. Your edits and the AI’s share one history, so a bold idea is easy to try.
- A reviewer on call. Run a test pass, and a reviewer reads your map against what you said you wanted, along with any script errors the editor has seen, then writes a short list of what to fix. One click hands that list back to the AI.
- A first version that is already a game. The game quiz asks the kind of game, how you win, where it takes place and how it should look, and the AI builds a first playable version with the level, the scripts, the win condition and the HUD.
- Finished games to learn from. Starter kits are complete games to play, take apart, and ask the AI to build on.
Two ways to bring ChatGPT and Claude in
Galatrix and your favourite AI work best as a team: the AI brings ideas and code, and Galatrix turns them into a game you can ship.
Your coding agent, through the CLI
If you work with Claude Code, Codex or another coding agent, the Galatrix CLI connects it to the editor you have open on your computer. Your agent drives the editor, and you watch each change land in the viewport.
Instead of writing an engine in an empty folder, the agent works through the editor, and gets:
- The editor’s full set of actions. The agent can read the catalogue of editor actions and a snapshot of your map, so it knows what the editor can do and what is already there.
- Commands for every part of the game. Objects, components, scripts, materials, terrain, block worlds, UI, animation and levels, one at a time or in batches. Its scene edits undo in the editor like your own.
- A loop it can close by itself. The agent can start the play-test, read script errors from the console and check the running game, then fix what it finds.
- Your files, straight in. Models, textures, sounds, fonts, scripts, data and shaders import from your disk.
- Builds from the terminal. Commands report success or failure in a form scripts and build steps understand, and the agent can export the project and build the standalone game itself.
The agent brings the reasoning, and each command does exactly what it says. The connection is tied to your account and your computer, and you can end it whenever you like.
Ideas, code and data from any chat
- Design in the chat, build in the editor. Work out the idea with ChatGPT or Claude, then give the plan to AI Chat as your brief.
- Bring code you drafted. Galatrix scripts are JavaScript, so logic worked out in a chat fits into the Script Editor. It works the other way too: paste a script into a chat and ask what each line does.
- Prototype there, build here. When a mechanic feels fun in a chat, describe it to AI Chat and it builds it into your map, with the engine, the editor and every export target ready around it.
- Turn words and numbers into game data. Dialogue, item lists and stat tables become data tables in your project, which your scripts read while the game runs.
Where to go next
To try it, start with how to make a game with AI: a few answers in the game quiz give you a playable first version to build on. For a tour of the editor itself, see the editor’s features, and for how Galatrix compares with other engines, Galatrix vs. Unity, Unreal, Godot, GameMaker and Construct 3.
The same project can also be published to play.galatrix.com, where players find it and play it together. The docs below cover standalone builds, networking and the CLI in full.