How to Make a Video Game With AI (Indie Build 2026)

When a developer types how to make a video game with AI into Google in late 2026, they are not shopping for a chatbot. They want a honest pipeline that goes from an English sentence to something playable — preferably without installing a 10 GB engine, learning C#, or spending Steam-release money on a weekend hobby. This guide is that pipeline. It walks the 2026 state of AI video game creation, the dual-agent coding engine that keeps the token bill honest, where the asset layer hooks in so the art and audio do not become the bottleneck, and the two ship paths that take a browser session to a real playable build.

What people really ask when they search “how to make a video game with ai”

DataForSEO lists how to make a video game with ai at 70 searches per month at a Keyword Difficulty of 40 and a competitive-density score of 0.55, CPC $13.97 (verified 2026-10-01 in tools/research-output.md under the Build a game with AI cluster). The sibling long-tail how to make a game with ai runs at 110 per month at KD 26, and the Roblox variant how to make a roblox game with ai at 140 per month at KD 5. The three queries share a cluster but target different intents: the Roblox query is Studio-specific, the plain “game with AI” query is broad vibe-coding, and the “video game” query is the one this piece addresses — a dedicated indie-style playable build with its own art, audio, and ship path.

Two reader intents sit behind the phrase. First, the honest-feasibility intent: is this actually a thing I can do, or is it a demo-reel pitch that falls apart the moment I try? The 2026 answer is yes for small indie scope (one or two scenes, one core loop, AI-generated or hand-authored assets) and still no for genuinely complex multi-hour games with branching narrative or multiplayer. Second, the stack-selection intent: which AI tools fit together as an actual pipeline, and what does the credit math look like at the end of a weekend? Both audiences land on the same answer — a browser-first toolchain built around a dual-agent coding engine — so this guide covers both.

For sibling pieces already on this blog, what is vibe coding defines the broader movement, prompt to game AI covers the dual-agent architecture in depth, and how to make a 2D game in Python walks the Pygame alternative for devs who prefer a desktop runtime. This page sits one level up from all three — the complete indie video game pipeline, not any one slot of it.

The honest 2026 state of AI video game creation

The 2026 state of making a video game with AI has three unambiguous facts and one quietly honest caveat.

Fact one: AI can write the code for a complete small game loop. A dual-agent coding engine running a frontier Planner (Claude Opus 4.7, GPT-5.5, Gemini 3.1 Pro, Grok 4.2) paired with a cheap Executor (DeepSeek V4 Pro, Kimi K2.5, MiniMax M2.7, Gemini 3.1 Flash) scaffolds a scene manager, sprite groups, input layer, collision detection, and a title screen in a two-hour evening session. The output is real code in a real framework, not a template.

Fact two: AI can generate every category of asset the game needs. Sprites, pixel art, tilesets, PBR textures, 3D meshes, rigged characters, animated sprite sheets, background music, sound effects, and NPC voice lines all have browser-based generators in the current Sorceress suite — and the per-generation cost is in the single-digit cents range for most of them.

Fact three: the output ships. A browser-first video game export compiles to a static dist/ folder with the engine runtime, the game bundle, and the asset directory, which runs on itch.io, GitHub Pages, Cloudflare Pages, or any other static host. Wrap it in Electron or Tauri for a native desktop installer (Electron Fiddle quick-start on version 44.5.1 verified 2026-10-01). The MDN Games reference frames the publish-side benefit directly: HTML5 games have the freedom of distribution, promotion, and monetization on the Web rather than each version being locked into a single store controlled by one company (verified 2026-10-01).

Honest caveat: scope is the single biggest determinant of success. A one-scene arcade shooter ships in an evening. A one-level platformer or top-down adventure ships over a weekend. A three-to-five scene vertical slice ships over two to three weeks of nights-and-weekends. A full RPG with branching narrative and a save system still exceeds what a browser-first AI pipeline can honestly complete on an indie budget — not because the AI cannot write the code, but because the content layer (writing, voice, hundreds of unique sprites) breaks the math for a one-person team.

The browser-first toolchain, panel by panel

Making a video game with AI on Sorceress is a five-panel pipeline: prompt → code → art → audio → ship. Each panel is a single tool or a tight pair, and each hands off to the next with zero format conversion.

Panel 1 — Prompt: a one-paragraph English description with four explicit slots (engine plus version, genre plus core loop, scene list, input plus win-and-lose condition). The prompt is pasted into WizardGenie.

Panel 2 — Code: WizardGenie dual-agent writes the actual game. For 2D the Planner picks Phaser 3, which is a fast, free, and fun open source HTML5 game framework offering WebGL and Canvas rendering across desktop and mobile web browsers, actively developed for over 11 years (verified 2026-10-01 at docs.phaser.io/phaser/getting-started/what-is-phaser). For 3D the Planner picks Three.js (official docs at threejs.org/docs, verified 2026-10-01). For specific graphics requirements, the W3C WebGPU 1.0 Recommendation covers the lower-level path (verified 2026-10-01).

Panel 3 — Art: Quick Sprites for the main sprite roster, AI Image Gen for reference-locked style exploration, Auto-Sprite v2 for motion-driven animation sheets, and 3D Studio for 3D props and characters.

Panel 4 — Audio: Music Gen for the gameplay bed and SFX Gen for the hit-and-pickup effects.

Panel 5 — Ship: HTML5 build to itch.io or Cloudflare Pages for the fast lane, Electron or Tauri for a native desktop installer. For the broader tool overview and which Sorceress tool handles which asset type, see the tools guide.

Dual-agent coding with WizardGenie Planner plus Executor

WizardGenie is Sorceress AI-native game engine and the house option for an AI video game workflow. Its dual-agent architecture is labeled literally on the product page as Dual-agent Planner + Executor with the explainer A smart Planner thinks; a cheap Executor codes. Same quality at roughly a quarter of the token cost. Verified in src/app/wizard-genie/page.tsx line 297 through 299 on 2026-10-01.

The split works like this. The Planner receives the prompt, the project context (what already exists in the file tree), and the current conversation state. It thinks through the architecture — which scenes, which state machines, which sprite groups, which input handlers — and writes a plan. The Executor receives the plan plus the current file contents, and emits the actual code changes. Only the Planner needs frontier-grade reasoning; the Executor just needs to be a competent typist with a big context window.

WizardGenie drives the full current frontier coding lineup for the Planner slot: Claude Opus 4.7, GPT-5.5, Gemini 3.1 Pro, DeepSeek V4 Pro, Kimi K2.5, Grok 4.2, and MiniMax M2.7 (model list verified 2026-10-01 in src/app/_home-v2/_data/tools.ts line 767 through 774). Users bring their own API key or use the fallback trial. The pairing discipline that keeps the token math honest: put an expensive reasoner on the Planner side (Claude Opus 4.7, GPT-5.5, Gemini 3.1 Pro, or Grok 4.2) and a cheap fast typer on the Executor side (DeepSeek V4 Pro, Kimi K2.5, MiniMax M2.7, or Gemini 3.1 Flash). Never put a Pro, Opus, or frontier-priced model on the Executor side — that erases the entire cost advantage that makes the pattern worth running.

The reader-level benefit: a two-hour evening session that scaffolds a complete scene manager, sprite groups, input layer, title screen, and game-over screen for an indie video game runs under a dollar in token cost on this pairing — versus roughly five to ten dollars on a single-frontier generation-two tool. For a deeper look at the specific pairings and the executor-side economics, see best AI model for vibe coding.

WizardGenie runs on both desktop (Windows installer with auto-updater) and web (/wizard-genie/app). The desktop build gives native filesystem access and longer-running agent sessions; the web build is zero-install for a prompt-to-game session on any browser. Pick whichever matches your dev loop — the same dual-agent workflow runs identically on either side.

A prompt that compiles on the first run

The failure mode a first-time “video game with AI” session hits is not the AI cannot write code — it is that the prompt was too vague and the Planner picked an architecture the user did not want. The fix is a prompt template with four explicit slots: engine, genre plus loop, scene structure, input plus win condition. Fill each slot in one sentence; let the Planner handle everything else.

A worked template for an indie browser top-down adventure:

Scaffold a Phaser 3.80 top-down adventure in TypeScript.
Core loop: player explores three rooms, defeats two enemy
types, collects one key per room, reaches the exit tile.
Scenes: BootScene, MenuScene, PlayScene, PauseScene,
GameOverScene, VictoryScene.
Input: arrow keys for movement, Space for attack,
Escape for pause, Enter to confirm menu choices.
Win condition: player reaches the exit tile with
all three keys.
Lose condition: player HP reaches zero.
Assets: load /assets/sprites/*.png and /assets/audio/*.mp3
from static. Use Phasers Arcade physics for collisions,
a scene manager for state, and a single JSON file per
room for the tilemap. Keep main.ts under 60 lines.

Three things make this prompt work. First, naming the engine and version up front (Phaser 3.80, verified 2026-10-01) locks the Planner to a specific API surface and prevents it from drifting toward a different framework between turns. Second, listing scenes explicitly turns the state-machine decision into a filled form rather than a judgment call — the Executor writes exactly six scene files, no fewer and no more. Third, naming the win and lose conditions in one sentence each gives the Planner a concrete success criterion for the generated playtest.

For a 3D indie video game, swap the engine slot to Three.js r168 and keep the other three slots identical in shape. The same template produces a working 3D scene with a controllable hero, three collectible props, and a camera controller.

Generating the sprites, music, SFX, and 3D props

A video game session that only produces code is half a video game. The other half is the asset layer, and this is where the full Sorceress Game Creation Suite earns its slot in an AI video game workflow. WizardGenie ships with the entire asset pipeline embedded directly in the editor — no exporting, no round-tripping — so each generated asset lands in the right folder for the engine the Planner picked.

For 2D sprites, open Quick Sprites. The page sets CREDITS_PER_GEN = 9 credits per generation (verified 2026-10-01 in src/app/quick-sprites/page.tsx line 21). At the public rate of CREDITS_PER_DOLLAR = 100 from src/lib/models.ts line 69, that is nine cents per sprite. A minimum roster for an indie top-down adventure — hero at four facing directions, two enemy types at two poses each, four tile types, UI plate — lands near 100 credits, which is roughly the entire new-account SIGNUP_GRANT = 100 credits defined in src/app/api/admin/credits/route.ts line 12. For style iteration on a locked anchor sprite, send the reference into AI Image Gen which drives Nano Banana Pro, GPT Image 2, Seedream 5 Lite, Flux 2 Pro, and Z-Image Turbo. For motion-driven sprite sheets — walk cycles, attack animations, hit reactions — open Auto-Sprite v2, the three-step image to video to clean sprite sheet pipeline.

For music, open Music Gen. Base cost is MUSIC_CREDIT_COST = 10 credits per track (verified 2026-10-01 in src/app/music-gen/page.tsx line 33). A three-track bed — menu loop, gameplay loop, boss or victory loop — is 30 credits. Download as MP3 and let the Planner wire the load.audio calls into the BootScene.

For sound effects, the Suno Sounds path on SFX Gen costs SUNO_SOUNDS_CREDIT_COST = 2 credits per sound (verified 2026-10-01 in src/app/sfx-gen/page.tsx line 28). A fifteen-SFX pack — attack, hit, pickup, menu-select, menu-confirm, level-up, defeat, victory, step, jump, dash, projectile fire, projectile impact, door, chest — is 30 credits.

For 3D props when the Planner picks Three.js, the Sorceress 3D Studio ladder runs TRELLIS at 8 credits, Hunyuan 3D 2.1 at 15, Meshy 5 at 31, TRELLIS 2 at 40, Tripo v3.1 at 40, Meshy 6 and 7 at 50 base, Rodin 2.0 at 50, Tripo Smart Mesh at 65, and Tripo P2 at 125 credits per generation (ladder verified in src/lib/threed-models.ts on 2026-10-01). A small prop pack is five to seven items; pick TRELLIS for first-pass drafts and Tripo v3.1 or Meshy 7 for the finished hero prop.

From browser session to playable build (HTML5 and desktop)

A browser video game session that only runs inside the WizardGenie preview is not shipped. Two ship paths cover the real distribution surface for an indie video game in late 2026.

The HTML5 build is the fast lane. WizardGenie produces a static dist/ folder with the engine runtime, the game bundle, and the asset directory. Upload the folder to itch.io, GitHub Pages, Cloudflare Pages, or any static host. The game runs inside any modern browser tab — no install, no store listing, no publisher gate. For a jam project or a portfolio piece, this is the ship-today path.

The desktop build is the quality bar. Wrap the HTML5 bundle in a native shell such as Tauri or Electron and ship a native installer. Electron is a framework for building desktop applications using JavaScript, HTML, and CSS that embeds Chromium and Node.js into its binary, allowing one JavaScript codebase to create cross-platform apps that work on Windows, macOS, and Linux (verified 2026-10-01 at electronjs.org/docs/latest). Electron is the heaviest at roughly 120 MB per build but the most proven; Tauri is roughly 10 MB per build but needs a Rust toolchain; NW.js sits in the middle. For a Phaser or Three.js indie video game, pick Tauri unless you have a specific Electron dependency.

WizardGenie own publishing flow does not auto-publish your finished video game to the Sorceress Arcade — that older distribution path from a previous coding system does not exist in WizardGenie today. Export the HTML5 build, host it where you want, and keep the game under your control.

Credit math, caveats, and realistic indie timelines

A complete AI video game build for an indie weekend project costs roughly two to five dollars end to end on Sorceress — the exact number depends on which Planner you pair with which Executor and how many iteration passes the scope needs. The arithmetic that produces that range:

• Asset layer: 100 to 200 credits for a minimum pack (hero plus two enemies plus four tiles plus three-track music bed plus fifteen SFX), which is one to two dollars at CREDITS_PER_DOLLAR = 100. New accounts cover most of this with the SIGNUP_GRANT = 100 credits.
• Planner tokens: a two-hour session with a frontier Planner (Claude Opus 4.7, GPT-5.5, Gemini 3.1 Pro, or Grok 4.2) runs roughly $0.80 to $1.50 in input-plus-output tokens on bring-your-own-key pricing — the Planner only writes plans, not code, so its token volume is small.
• Executor tokens: the Executor does the heavy typing, so its token volume is five to ten times the Planner. At the price of a cheap executor (DeepSeek V4 Pro, Kimi K2.5, MiniMax M2.7, or Gemini 3.1 Flash) that is roughly $0.40 to $1.00 for the same session.

Totals: two to five dollars for a one-weekend indie video game, versus roughly ten to twenty dollars running a single frontier model for everything. The roughly a quarter of the token cost line from the WizardGenie product page is honest marketing — the actual ratio when the Executor is a truly cheap model is closer to one-fifth of the single-frontier cost.

Realistic timelines by scope:

• Evening arcade (one scene, one loop, two to four hours): single-screen shoot-em-up, score-attack puzzle, one-screen platformer.
• Weekend indie (two to six scenes, twelve to twenty hours): one-level top-down adventure, one-level platformer, small roguelike with one biome.
• Two-to-three week vertical slice (five to ten scenes, forty to eighty hours): fully-featured one-biome game with save system, animated menus, and polished art.
• Beyond that: handwork takes over — the AI pipeline writes the code honestly but the content layer (writing, voice, hundreds of sprites, level design) is what breaks the one-person math.

Lock the scope before the first prompt. Refuse to add scenes mid-project. Ship the small thing, then start the next small thing — that is how making a video game with AI goes from a tech demo to a weekly habit.