Which engine for small 2D games on mobile, web and Steam, if Claude Code writes the code?
Short answer: Godot 4.7 with GDScript. Claude Code built the same small 2D action game in three engines, and each one was then taken as far toward Steam, Google Play, the App Store and the web as a single Windows PC allows. Godot came first overall and on both mobile stores. Pick Phaser 4 instead if the browser is your main platform, and Defold if the smallest possible download or a later console release matters more than anything else. All three builds are playable in your browser.
Transparency: Claude Code, an AI coding agent, ran the benchmarks described here and drafted this article from their results; the author reviewed the text and checked the figures before publication. Editorial responsibility: Buse Florin-Emilian (contact). The question, the platforms and the weights were fixed before any engine was scored, and personal impressions from playing the builds were deliberately left out. Disclosure: the author also wrote the Claude Code plugin for Defold that the Defold session used (section 3).
The short version
- Pick Godot 4.7 (GDScript) if you want one project that ships to Steam, Google Play, the App Store and the web. It scored 4.51 out of 5, against 4.05 for Phaser 4 + Capacitor + Electron and 3.85 for Defold 1.14.
- Claude Code can build a working game in all three. Each engine got a fresh session; all three finished the same 12-point game and a follow-up change with no human help and no invented APIs. Godot needed the fewest tool calls and made no mistakes it had to correct.
- Phaser is the pick for a web-first game (a 1.3 MB web build), but its route to Steam through Electron is heavy (358 MB) and its Steam integration is stale. Defold makes the smallest builds (9 MB on Windows, about 2.5 MB on Android) and has official console support, but scored lowest on graphics and on the agent loop.
- No engine can sign an iPhone build on Windows. Every route ends on a rented Mac in the cloud, which is free for public GitHub repositories. Godot's iOS export was the most App Store-ready of the three.
- Caveats: nothing has run on a phone yet, each engine got one run, and from April 2027 Apple's new SDK means every iOS game must cope with resizable windows.
1. What "best" means here
The premise is that Claude Code writes, builds and tests the game, and the human mostly reviews. So an engine is judged on three things: how efficiently an AI agent gets a correct, working game out of it; how far a Windows PC gets toward each store; and how the result looks when there is no artist and everything on screen comes from code. Only things that could be measured or looked up in documentation and source code count.
The setup is a solo developer on Windows 11 with no Mac, no iPhone and no artist, a project of 3 to 12 months, and a preference for free, open-source tools. Steam, Google Play and the App Store weigh the same; the web build is a bonus. Three engines were measured hands-on. Thirteen more were screened against documented facts (section 10).
The arithmetic is simple and fixed in advance. A check scores 5 if it passes, 3 if it partly passes and 1 if it fails. A measured quantity, such as build size or session time, scores 5 for the best engine and loses 2 points for every tenfold gap to the best. Each engine ran once, so gaps of 0.15 or less are ties.
2. The scores
| Criterion (weight) | Phaser 4.2.1 + Capacitor + Electron | Godot 4.7.2 GDScript | Defold 1.14.0 |
|---|---|---|---|
| Agent build loop (35) | 4.74 | 4.98 | 4.36 |
| Windows/Steam shipping (20) | 2.76 | 4.17 | 4.20 |
| Android shipping and testing (20) | 4.01 | 4.41 | 3.83 |
| iOS shipping and testing from a Windows PC (20) | 3.60 | 4.27 | 3.58 |
| Graphics without an artist (15) | 4.17 | 4.50 | 2.67 |
| Web build (5) | 5.00 | 3.53 | 4.32 |
| Free and open source (5) | 5.00 | 5.00 | 3.00 |
| Weighted total (out of 5) | 4.05 | 4.51 | 3.85 |
The weights follow the premise. The agent loop carries the most (35 of 120) because the agent builds the game. Steam, Android and iOS get 20 each, as three equally important stores. Graphics gets 15 because, with no artist, the engine's drawing defaults and the agent's choices are all you get. The web build and an open-source licence get 5 each, as a bonus and a preference.
Godot's lead over Phaser comes mostly from Steam, where Phaser depends on Electron, and then from iOS, the loop, Android and graphics; Phaser wins only the web column. Its lead over Defold comes from graphics, the loop and the two mobile criteria, plus Defold's non-OSI licence. Defold edges Godot on Steam, by 0.03, thanks to its tiny build. Section 9 shows that no reasonable re-weighting changes the order.
3. The benchmark: one game, three engines
Each engine got one fresh Claude Code session (Opus 5.5) on the same Windows 11 machine on 28 October 2026. The task was "Asteroids-lite", judged against 12 checks: a title screen; a ship that rotates, thrusts with inertia, fires and wraps around the screen; asteroids that split in two twice; scoring, lives and a sound; waves that grow; game over and restart; a seed for repeatable runs; a command-line test; Windows and web builds made from the command line; and an automatic screenshot with a JSON dump of the game state. The same session then received a change request: add a pause menu and power-ups.
| Measured on 28 Oct 2026 | Phaser 4.2.1 + TypeScript | Godot 4.7.2 GDScript | Defold 1.14.0 |
|---|---|---|---|
| Checks passed · human help · invented APIs | 12/12 · 0 · 0 | 12/12 · 0 · 0 | 12/12 · 0 · 0 |
| Session start to finished change request | 23.0 min | 25.2 min | about 30 min |
| Tool calls, whole session | 115 | 81 | about 170 |
| Edit to screenshot, median | 3.83 s | 3.31 s | 5.72 s |
| Failed builds + wrong assumptions corrected | 0 + 1 | 0 + 0 | 1 + 2 |
| Agent loop score | 4.74 | 4.98 | 4.36 |
The headline is that all three worked. Three engines, three complete games, no human help and no hallucinated API. The scored differences are about effort. Godot's agent kept the whole project in plain text: a project file, two tiny scenes, input actions registered in code and a fixed 60 Hz simulation step, which made pause and repeatable tests easy. Phaser's agent checked every call against Phaser's TypeScript definitions, which kept API errors at zero, but its first playtest found that a very short key tap could be missed, and Electron's security settings blocked the test tool from attaching to the packaged app. Defold's agent had a Claude Code plugin for Defold, written by the author of this article (version 0.2.7, open source), that answered every API question for the installed version, yet it still made two wrong assumptions about how GUI nodes draw and needed about twice Godot's tool calls. It was the only engine-specific agent tool in the test: the Godot and Phaser sessions worked with their engines' own command-line tools, and Godot still needed the fewest tool calls.
The spread, 4.36 to 4.98, is narrow. That is the honest reading: all three are workable engines for an AI agent, and the loop separates them by degree, not by kind.
Play the three builds
These are the web builds the three sessions produced, pause menu and power-ups included, unchanged apart from a security header. They need a desktop browser and a keyboard; there are no touch controls yet.
- Phaser 4 build · about 0.35 MB to download
- Godot 4.7 build · about 10 MB to download, so the first load takes a moment
- Defold 1.14 build · about 1.3 MB to download
Download sizes are what this site actually transfers, compressed. The build sizes elsewhere in the article (1.3, 38 and 6.2 MB) are the uncompressed files.
Controls: Enter to start · Left/Right or A/D to rotate · Up or W to thrust · Space to fire · Esc to pause (Resume, Restart, Quit to Title). Destroyed asteroids sometimes drop a power-up: triple shot, a one-hit shield or an extra life. Add ?seed=42 to the address to replay the same asteroid field.
Each folder includes the engine's licence notices in LICENSES.txt. The Godot and Defold builds create a small database in your browser's IndexedDB that their engines use for save files; these games save nothing in it, and nothing is sent anywhere (see the privacy page).
4. Steam
Godot and Defold export native Windows executables. Phaser runs in a browser engine, so reaching Steam means wrapping it in Electron, which bundles Chromium. The measured Windows builds were 358 MB for Phaser + Electron, 104 MB for Godot and 9 MB for Defold.
The Steam integration splits them further. The most-used Steamworks binding for Node, steamworks.js, last shipped a release in August 2024, and the Steam overlay only draws over Electron with a GPU workaround switch (--in-process-gpu). Godot uses the community GodotSteam extension, which is active and moved from GitHub to Codeberg in October 2026; a build for 4.7 had not been confirmed when this was written. Defold's official Steam extension had a release in June 2026, but every Defold native extension, Steam included, is compiled on Defold's free cloud build server, which publishes no service guarantee; the alternative is self-hosting that build server in Docker.
5. Android
All three produced a signed APK and App Bundle from the command line, targeting Android 16 (API 36) with 16 KB page alignment, which are Google Play's current hard rules. Nothing was installed on a phone or emulator in this check; it is build quality only.
| Android, 29–30 Oct 2026 | Phaser + Capacitor | Godot | Defold |
|---|---|---|---|
| Estimated Play download | about 3.1 MB | about 26.4 MB | about 2.5 MB |
| Signed release build time (warm) | 33.9 s | 7.7 s (APK) | 7.3 s (APK and AAB) |
| Extra installs beyond the engine | Android SDK, JDK, Gradle, npm packages | Android SDK, JDK, Gradle | None |
| Game defaults (game category, landscape lock) | Neither set | Both | Both |
| Back gesture, safe area, touch joystick, vibration | Plugins to wire | All built in | No vibration; community touch controls |
| Android score | 4.01 | 4.41 | 3.83 |
Defold builds the best package; Godot ships the most complete Android game. Defold's build was flawless: one command, 7.3 seconds, nothing extra to install. Godot's package is ten times larger because the engine runtime is about 99% of it, and the agent hit three problems on the way to the Play bundle, all fixable: the Gradle daemon made the headless export hang, a template flag used on its own never exits, and a missing project icon prints an error. In exchange, Godot's export already handles the back gesture, system-bar insets, a built-in virtual joystick and vibration, and its community billing plugin moved to Play Billing Library 9.1 in July 2026. Capacitor is the easiest to test on a device (live reload and Chrome DevTools), but its generated manifest lacks the game category and orientation lock, which Android 16 needs before it respects a landscape lock on tablets.
6. iOS from a Windows PC
Signing an App Store build requires Apple's tools on macOS. No engine signs an iOS build on Windows, so the check measured how far each one gets and how ready the result is.
| iOS, 30–31 Oct 2026 | Phaser + Capacitor | Godot | Defold |
|---|---|---|---|
| Furthest point from Windows | Xcode project (13 s) | Xcode project (5.5 s) | Unsigned app, packed as a 1.70 MB .ipa |
| App Store upload defaults (5 checks) | 3/5 | 5/5 | 3/5 |
| Game defaults: landscape only, 120 Hz key, hidden status bar | 0/3 | 3/3 | 2/3 |
| Testing without a Mac | Good | Weakest | Best |
| iOS score | 3.60 | 4.27 | 3.58 |
Defold got furthest: its command-line builder assembled a complete unsigned app on Windows and only stumbled at packing it, which a 0.3-second script fixed. But that app lacks the App Store icon catalog and the export-compliance key, so it still needs work on a Mac. Godot exported a complete Xcode project after one fix (it needs a 1024 px project icon) and ships every key App Store Connect expects: a privacy manifest, the scene life cycle iOS now requires, a launch storyboard, the encryption declaration, a landscape lock and a request for 120 Hz on ProMotion iPhones. Capacitor's template is a generic app's: portrait allowed, status bar visible, and no app privacy manifest. Its web view also caps animation at 60 Hz.
The route without a Mac is the same for every engine: export the project on Windows, let a hosted macOS runner build and sign it, upload it, then test through TestFlight. GitHub's standard macOS runners are free in public repositories and cost $0.062 a minute in private ones after the plan's included credit; Codemagic gives individuals 500 free macOS minutes a month. The upload can run on that Mac or from Windows with Apple's Transporter tool or the App Store Connect API. You still need the Apple Developer Program ($99 a year).
Godot's weak spot is testing without a Mac: its iOS Simulator libraries shipped broken in 4.6.2 and 4.7.1 (the 4.7.2 status is unverified), and on a device the agent gets logs only. Defold is the most testable on paper, with documented Simulator builds for Apple-silicon Macs and an automation extension that compiles for iOS (not yet tried on an iPhone).
April 2027: plan for resizable windows now
Apple announced on 9 September 2026 that from April 2027 every upload must be built with the iOS 27 SDK. Under that SDK, the setting Godot and Defold use to keep a game full-screen no longer stops the system from resizing it, on iPad and on iPhone alike, and the new foldable iPhone Duo makes that concrete. Whatever engine you pick, design the game to render correctly at any window size from day one.
7. The web
All three web builds ran. Phaser's was 1.3 MB, Defold's 6.2 MB and Godot's 38 MB. Godot's web export uses the WebGL 2 Compatibility renderer and GDScript only (C# projects can't export to the web), and runs single-threaded by default. That is fine for itch.io or a demo, but the first load is heavier. If instant play in a browser is the main way people will find your game, Phaser has a real advantage here. You can compare the load times yourself with the three builds above.
8. Pick by priority
| If your priority is… | Pick | Why |
|---|---|---|
| One codebase for Steam and both mobile stores, web as a bonus | Godot 4.7, GDScript | First in every weighting tried, including iOS weighted from zero to three times Steam |
| The browser first (web portals, itch.io, instant play) | Phaser 4, with Capacitor for mobile and Electron for Steam | 1.3 MB web build; it ties Godot once the web carries about 27% of the weight, more than any single store |
| The smallest downloads, or mobile judged only on raw build quality | Defold | 9 MB on Windows, 2.5 MB on Android, an unsigned iOS app from Windows; it draws level with Godot only if graphics and mobile features are ignored |
| A console release later | Defold, or Godot through a porting service | Defold supports Nintendo Switch, PlayStation and, since 1.14.0, Xbox, free for approved developers; Godot reaches consoles through paid third parties such as W4 Games |
| Mobile first, Steam not important | Godot, but also try Flutter + Flame | With Steam's weight at zero Godot still leads, 4.58 to 4.31 |
| You want C# | Godot with GDScript anyway | Godot's C# can't export to the web, and its iOS export is refused on Windows |
9. Does the platform weighting change the answer?
Weighting Steam the same as each mobile store is a choice, so it was checked against the 2025–26 market. By total spending, mobile is far bigger: players spent about $82 billion on mobile games in 2025, with the App Store taking roughly 1.75 times Google Play's game revenue, while Steam took about $17.7 billion. Newzoo's 2026 forecast puts mobile at 57% of the games market, consoles at 22% and PC at 21%.
For a solo indie, though, the picture flips. Mobile money concentrates in big free-to-play games with large advertising budgets; mobile game spending grew 1% in 2025 and fell 2% in the first half of 2026, while Steam grew 15% in 2025 and indie games took about a quarter of it, roughly $4.5 billion. In GDC's 2026 survey, 83% of developers were making PC games. Equal weights sit between these two readings, so the model was re-run with weights taken from each.
| Weights (Steam / Android / iOS) | Phaser | Godot | Defold |
|---|---|---|---|
| Equal, 20 / 20 / 20 (this article) | 4.05 | 4.51 | 3.85 |
| By store game revenue, 10.6 / 18.0 / 31.4 | 4.11 | 4.52 | 3.79 |
| Steam 20, mobile split by spending, 20 / 14.5 / 25.5 | 4.03 | 4.51 | 3.83 |
| Steam ahead, 30 / 10.9 / 19.1 | 3.95 | 4.49 | 3.88 |
| Steam far ahead, 40 / 7.3 / 12.7 | 3.87 | 4.48 | 3.92 |
| Equal, plus a console criterion weighted like Steam | 3.61 | 4.30 | 4.01 |
Godot is first in every row. No Steam weight from 0 to 400 lets another engine overtake it, because Godot is never far behind on any platform. Adding consoles is the only change that helps Defold (scored 5 for official support, Godot 3 for paid porting, Phaser 1 for none), and even then Defold draws level only when consoles weigh about twice as much as Steam.
10. The other engines
Engines without hands-on data were screened against the same hard requirements: a maintained route to Steam, a command-line path to a Play-ready App Bundle, a route to the App Store from Windows that survives Apple's iOS 27 rules, and preferably an open-source licence. Every one that supports iOS needs a Mac somewhere to compile and sign.
| Engine | Why it was not picked |
|---|---|
| Unity 6.3 | Strong mobile plugins and a no-Mac iOS cloud build, but closed source, and its Terms of Service (§17.2(ff)) allow AI agents and command-line tools only through "Authorized Agentic Access" |
| GameMaker | Paid licence for commercial release; its command line documents APK builds only; iOS builds need a physical Mac |
| Flutter + Flame | The best Android agent tooling among code frameworks, but Steam only through a Windows-only Dart wrapper; worth a benchmark for a mobile-led game |
| libGDX | Billing and Steam bindings lag behind; iOS 27 scene support exists only in an unreleased version |
| MonoGame | Open bugs: the gamepad Back input never triggers on Android 16, and iOS 27 SDK builds crash on launch |
| GDevelop | Signs iOS builds in its own cloud, but it is an event-sheet editor with no official command line, and iOS builds need a paid tier |
| Cocos Creator, Solar2D | Builds need the GUI; Cocos also reports an iOS 27 build crash |
| Bevy, Ebitengine | Mobile lifecycle issues still open, or every store rule left to hand-written native code |
| Unreal 5.8 | Signed iOS builds need a Mac, and minute-long C++ iterations are heavy for a small 2D game |
| LÖVE, raylib, pygame-ce | No current route to the App Store |
11. Getting started with Godot and Claude Code
- Pin the version. Use Godot 4.7.2 and its export templates, and don't switch to the 4.8 beta in the middle of a project.
- Keep the project in text. Small scenes, input actions registered in code,
preload()constants instead ofclass_name. Put the game rules in a pure simulation layer with a fixed 60 Hz step and a seeded random generator, so every test is repeatable. - Give the agent a loop it can see. Headless import, unit tests with GUT, then a scripted run that saves a screenshot and a
state.jsonthe agent reads back. The benchmark measured 3.3 seconds from edit to screenshot. - Set a 1024 px opaque project icon on day one. It fixes an Android export error and the iOS export failure.
- Android release builds: set
GRADLE_OPTS=-Dorg.gradle.daemon=false, and pass the build-template flag only together with an export. - iOS: export the Xcode project on Windows and let a GitHub Actions macOS runner build, sign and upload it, with the certificates kept in repository secrets.
- Design for any screen. Stretch mode
canvas_itemswith aspectexpand, the HUD inside the safe area, and screenshots at several sizes, from 20:9 phones to 4:3 iPads.
A short CLAUDE.md carries those rules into every session. This excerpt is the core of the one written for this project:
# CLAUDE.md (excerpt): Godot 4.7.2 + GDScript; Steam, Google Play, App Store, web
## Stack (pinned; never upgrade unless asked)
Godot 4.7.2 stable, run through a wrapper script with a timeout and a saved log. GUT for tests.
No Godot 4.8 beta. No C# (no web export; iOS export is refused off macOS).
## Loop for every change
1. Plan 3-6 steps and name the files you will touch.
2. Edit. Rules live in scripts/sim/ (no Node, Input or rendering calls); drawing and UI in scripts/view/.
3. Run the gate: import, unit tests, smoke screenshot. Fix until green.
4. Open the newest screenshots and state.json. Say whether they match the intent.
5. Report what was NOT verified (phone, iOS, audio, gamepad).
## Godot 4 rules (much of your training data is Godot 3)
- await not yield; CharacterBody2D not KinematicBody2D; instantiate() not instance().
- Never trust an exit code alone: grep the log for SCRIPT ERROR, Parse Error and ERROR.
- Keep config/icon set to the 1024x1024 opaque icon.png.
## Mobile
- Design at 1280x720, stretch canvas_items, aspect expand; HUD inside get_display_safe_area().
- Never assume a fixed window size or orientation; pause if the window resizes mid-play.
- You cannot build or sign iOS here: verify only through the CI run's logs and screenshots.If you pick Defold instead: the plugin the Defold session used is open source at github.com/Infuscy/DefoldClaude (MIT licence; unofficial, and not affiliated with the Defold Foundation). It gives Claude Code the Lua API of your installed Defold version, edits scene files as validated data instead of raw text, and adds build, run, log, screenshot and input tools. It is the author's own project, so weigh it accordingly.
12. Caveats
- One run per engine. The three sessions ran side by side on one machine, and their clocks started at different points. Treat small gaps as ties.
- Nothing has run on a phone. The Android check was build-only and the iOS check export-only; nothing was compiled for iOS. The benchmark game has no touch controls yet.
- Three of Godot's iOS points rest on unverified evidence: 120 Hz under its OpenGL ES renderer, and its Apple plugin's support for 4.7 in purchases and Game Center. Marking all three as partial passes still leaves Godot first, at 4.44.
- GodotSteam's 4.7 build was not confirmed at the time of writing.
- Defold's small Android package was measured on a project with no native extensions; a Defold game that also ships on Steam would most likely build through the cloud server too.
- The graphics score reflects what one agent chose to draw as much as each engine's defaults. Only about 3–5 of the 11 rubric points between Godot and Defold come from defaults.
- Everything is dated 31 October 2026. Engines and store rules change monthly; Google raises the target API every August and Apple the SDK every April.
13. Sources
Engines: Godot: exporting for the web · Godot: exporting for iOS · Godot 4.7.2 iOS Info.plist template · Godot VirtualJoystick · Godot Simulator issue #122379 · GodotSteam · GodotApplePlugins · Defold native extensions · Defold iOS manual · Defold build size · Defold license · Defold PR #13597 (120 Hz) · Defold 1.14.0 release · DefoldClaude plugin (the author's) ·steamworks.js on npm · Electron and the Steam overlay · Capacitor 8.6.0 iOS template · WebKit bug 294338 (60 Hz cap) · W4 Games consoles.
Stores and tooling: Apple Developer News, 9 Sep 2026 · Apple TN3192 · Apple TN3187 · Apple upcoming requirements · Transporter user guide · TestFlight overview · GitHub Actions runner pricing · Codemagic pricing · Google Play target API · Android 16 KB page sizes · Android 16 behaviour changes.
Market: Newzoo 2026 forecast (Game World Observer) · Sensor Tower State of Gaming · TechCrunch on 2025 mobile spending · App Store and Google Play split (Tech Insider) · First half of 2026 (Tech Insider) · Alinea: indie share of Steam in 2025 · GDC 2026 survey (GamingOnLinux).
Other engines: Unity Terms of Service · Unity iOS build process · GameMaker pricing · Flutter iOS deployment · MonoGame #9571 · GDevelop iOS publishing.
Last updated: 31 October 2026. The measurements come from a desktop benchmark on 28 October 2026, an Android build check on 29–30 October and an iOS export check on 30–31 October, all on one Windows 11 PC; the documented checks were read from each engine's docs and source code at the versions named above. The pass, partial and fail calls and the weights were fixed before scoring. AI-assisted drafting was reviewed by the author: a transparency statement under Article 50 of Regulation (EU) 2024/1689 (the AI Act).