Plot How to Make a Roguelike Game (Browser AI 2026)

Type how to make a roguelike game into Google on June 19, 2026 and the SERP is split between two readers. One has played 200 hours of Hades and Slay the Spire and now wants to ship one of their own. The other has just finished a Phaser tutorial, found Berlin Interpretation on Wikipedia, and wants to know which AI tools turn the genre conventions into a real run loop. This guide answers both. The honest 2026 path to make a roguelike game is one prompt-driven coding tab plus six asset layers, all in one Sorceress catalog, verified against the live source on June 19, 2026. Procgen, permadeath, and per-run loot tables are the easy half — the hard half is asset volume, and that is exactly the half AI now removes.

What “how to make a roguelike game” actually means in 2026

The phrase how to make a roguelike game covers a much narrower design space than “how to make a game” in general, and that is good news for an indie dev. The Berlin Interpretation — the canonical 2008 spec the genre still references — locks down five hard pillars (procgen, permadeath, turn-based grid movement, complex meta-content, resource management) and four soft pillars (single-character focus, monster-and-hero parity, tactical combat, exploration). A 2026 dev does not need to meet every pillar. Most modern hits sit on the “roguelite” side of the line, keeping procedural generation and permadeath while replacing turn-based movement with real-time action and adding meta-progression that persists across runs. Both shapes count. What does not count is “random level generator on top of an action game” with no permadeath consequence; the absence of stakes is the failure mode that every reviewer flags.

The reason this matters for a how-to is that the genre constraints collapse the design surface in a way that maps cleanly onto AI generation. A roguelike does not need a 40-hour main quest with branching dialogue trees. It needs ten room templates, eight monster archetypes, twenty item icons, one music loop per biome, and a death screen. That entire content list fits in one Sorceress tab session, and the procgen layer recombines it forever — one biome of hand-curated content stretches across hundreds of runs. The honest 2026 answer to how to make a roguelike game is therefore not “build everything from scratch” but “curate one tight content seed and let procgen + AI generation do the multiplication.”

The seven pillars of every roguelike — what the AI half has to ship

Before picking a tool stack, a dev needs a clear pillar list because every pillar maps to a specific AI handoff. The seven pillars an indie 2026 roguelike actually has to ship are: (1) the run loop — start a run, generate a level, fight, die, restart with optional meta-progression; (2) procedural levels — either fully generative (Spelunky, Caves of Qud) or seeded-template (Hades, Dead Cells); (3) character art — one playable hero, three to eight enemy archetypes, optional NPC vendors; (4) tile art — a tile-based dungeon set with autotile rules; (5) item icons — weapons, consumables, relics, the visual side of the loot table; (6) audio — one to three music loops per biome plus the SFX one-shots that cover hits, pickups, and deaths; (7) UI — an inventory grid, a stat readout, a death screen, and the meta-progression menu if the design uses one. Skip any of these and the run feels broken.

The split between human-curated and AI-generated work falls cleanly along these pillars. Pillars 1 and 2 are code — WizardGenie writes them on prompt with the eight-model coding picker (verified against src/app/_home-v2/_data/tools.ts CODING_MODELS on June 19, 2026: Claude Opus 4.7, Sonnet 4.6, GPT-5.5, Gemini 3.1 Pro, Grok 4.2, DeepSeek V4 Pro, Kimi K2.5, MiniMax M2.7). Pillars 3, 4, 5 are visual asset generation — Quick Sprites for hero and monster walk cycles, Tileset Forge for the dungeon tile set, AI Image Gen for item icons. Pillar 6 is audio generation — Music Gen for biome loops, SFX Gen for hit and pickup sounds, optionally Speech Gen for vendor barks. Pillar 7 is UI markup — back to WizardGenie because the inventory grid is just code wrapped around the asset layers. Every pillar has exactly one Sorceress tool that is its primary handoff, and every handoff produces a web-standard format (PNG, WAV, OGG, JSON) that any modern engine eats.

How to make a roguelike game with the honest 2026 browser AI stack

The honest stack to make a roguelike game in 2026 is six tools deep, all reachable from one Sorceress account. Verified against the live source on June 19, 2026, those six are WizardGenie for the run loop and procgen code, Quick Sprites for hero and monster walk cycles, AI Image Gen for item icons and concept art, Tileset Forge for the dungeon tile sets, Music Gen for biome loops, and SFX Gen for hit and pickup one-shots. Optional adds for a 3D roguelike include 3D Studio for image-to-mesh and Auto-Rigging for the skeletal animation pass; both are still reached from the same tab. Bundle pricing is one $49 Lifetime fee plus pay-once credit packs ($10 for 1,000 credits Starter, $20 for 2,000 Creator, $50 for 5,000 Plus, $100 for 10,000 Studio), verified against src/app/plans/page.tsx on June 19, 2026. New accounts ship with 100 starter credits.

The reason this stack works for a roguelike specifically is that the genre’s content list is small and reusable. One Sorceress credit pool funds the code agent calls (the planner-executor pattern routes the heavy reasoning to Opus 4.7 or GPT-5.5 and the bulk typing to a cheap MoE-based executor like DeepSeek V4 Pro or Kimi K2.5, cutting cost to roughly one-fifth of single-frontier billing) AND the asset generation calls in the same session. There is no need to buy a Substance Painter seat to texture a 3D mesh; Material Forge ships PBR maps in the same browser tab. There is no need to install Aseprite, FL Studio, or Audacity; the generative tools cover the same handoffs and export the same formats. The dev never leaves the tab between code work and asset work, which is how a 2026 roguelike scope finishes in two to four weeks instead of two to four months.

Step 1 — prompt WizardGenie for the procgen run loop

The first prompt to WizardGenie sets the run-loop scaffold for the entire project. A reliable opening prompt for a 2026 dev looks like this: “Write a Phaser 4 (or Godot 4 / Unity 6) browser-tab roguelike scaffold with a BSP room generator producing 8 to 12 rooms per floor, weighted-table monster spawning, a tiered loot table with COMMON/RARE/EPIC/LEGENDARY drop weights, turn-based grid movement on a 32-pixel tile, fog-of-war revealed by line-of-sight, and a permadeath save wipe on death.” Pick the Opus 4.7 model from the dropdown for this prompt — the genre algorithm work (BSP partitioning, line-of-sight bitmasks, weighted spawn distribution) wants the heavy reasoner, and Opus 4.7 ships at $5 input / $25 output per million tokens with a 1M context window (verified against the live API documentation on June 19, 2026). The first response will scaffold the project tree, the level generator, the input handler, and the death-and-restart loop.

The second prompt iterates on the procgen specifically because a roguelike lives or dies on level variety. Prompts like “swap BSP for cellular automata for the cave biome” or “add a treasure-room template that always spawns at depth 3, 5, and 7” refine the generator without rewriting the whole loop. Switch to Sonnet 4.6 ($3/$15) or DeepSeek V4 Pro ($0.435/$0.87 per M tokens since the 75% promotional rate became permanent on 2026-05-31, with a 1M default context window and an MIT license) for the iteration phase — the cost ratio matters because a procgen loop typically takes 15 to 25 prompt rounds to feel right. Pair Opus 4.7 as the planner with DeepSeek V4 Pro or Kimi K2.5 as the executor and the whole pass costs roughly one-fifth of putting Opus on both sides. Acceptable executors per Sorceress’s guidance are DeepSeek V4 Pro, Kimi K2.5, MiniMax M2.7, Gemini 3.1 Flash, GPT-5.5 Mini, and Claude Haiku 4.5 (when available); never put a frontier-priced model on the typing side or the cost advantage disappears.

Step 2 — generate hero, monster, and item art in Quick Sprites and AI Image Gen

With the loop scaffolded, the next session is asset generation. The 2D asset pipeline starts with one or two reference images per character — the playable hero in three or four poses, then each monster archetype as a single key frame — then expands those keys into walk cycles and 8-direction frames. Quick Sprites handles the expansion: feed in a hero key, get back an 8-direction walk cycle plus idle, attack, and death frames as a packed sprite sheet at 9 credits per generation. The output is a PNG sprite sheet with a JSON manifest listing frame coordinates — ready for Phaser, Godot 4’s AnimationPlayer, or Unity’s sprite atlas import.

Item icons come out of AI Image Gen with a different handoff. A roguelike loot table needs roughly 20 to 40 distinct icons (weapons, potions, scrolls, relics, keys, currencies). Prompt the icon set as a single batch — “fantasy potion-flask icon set, 64x64, dark navy background, one icon per panel” — and the model returns a sheet that the dev slices in Spritesheet Analyzer. Reference the same character and item style across prompts by feeding back the first batch as a style reference; the eight-image generation models in AI Image Gen ship reference-image conditioning and stay on-style across runs (verified against the live image-models lineup on June 19, 2026). Monster art either follows the same Quick Sprites path (for fully-animated enemies) or the AI Image Gen path (for static enemy portraits used in turn-based combat menus).

Step 3 — build dungeon tilesets with Tileset Forge

The dungeon tile set is the visual backbone of every floor. Tileset Forge generates either an 8-direction tile pack (floor, wall, corner-tiles, transition tiles) or a 47-tile blob set with full autotile rules baked in. The 47-tile path is the right pick for a roguelike because procgen layouts produce arbitrary wall shapes — corners, T-junctions, dead ends, single-tile pillars — and a blob set covers all of them with one rule table. Prompt the set with the biome description (“mossy stone dungeon, torch-lit, autotile blob, 32x32 tiles, four floor variants for break-up”) and the tool returns a packed PNG plus a manifest JSON listing each tile’s autotile bitmask. Phaser 4’s tilemap importer and Godot 4’s TileMap node both accept the manifest format directly; Unity needs a one-time custom importer or the asset can be sliced via the built-in sprite editor.

The reason a roguelike specifically benefits from a 47-tile set is content density. One biome — one set of 47 tiles plus four floor variants and a handful of decorations — powers an unlimited number of procgen levels because the autotile rules paint walls automatically based on neighbor adjacency. A dev who ships three biomes (dungeon, cave, forest) ships three Tileset Forge runs. That is the entire visual variety budget for a 20-hour roguelike. The fourth biome is usually a one-off “final floor” that uses a hand-curated set instead, but the first three biomes carry the procgen weight on autotile rules alone. A developer who wants to take a flat AI image and convert it into a tile-grid-snapped sprite sheet can also pull Pixel Snap into the loop — the photo-to-pixel-art conversion handles props, decals, and one-off feature tiles that the main blob set does not cover.

Step 4 — compose the music, SFX, and shop dialogue

Audio is the layer most indie roguelikes get wrong. A silent run feels broken; a generic stock loop running on every floor feels worse. The 2026 fix is one music loop per biome plus one boss-fight loop, generated in Music Gen at 10 credits per loop. A dungeon biome wants a dark ambient bed at 80 to 100 BPM; a cave biome wants an echoey synth pad with sparse percussion; a forest biome wants acoustic-tinged ambient with bird-call samples; the final-floor boss fight wants a driving 140-BPM loop with a clear melodic hook. The model dropdown in Music Gen exposes the current generation roster; pick Suno V5.5 or Stable Audio 2 for ambient beds and a more song-shaped model for the boss fight. Output is WAV or MP3; loops are seamless out of the box.

SFX one-shots come out of SFX Gen at roughly 3 credits per generation. A roguelike needs maybe 25 to 40 unique sounds: sword hit, sword swing-miss, monster death (per archetype), coin pickup, potion drink, level-up jingle, footstep on stone, footstep on wood, treasure chest open, door open, low-health warning, run-end stinger. Batch the prompts in one session — the model stays on a coherent palette when prompts share style words like “chiptune retro” or “modern cinematic 8-bit” or “fantasy SNES-style.” The output is WAV; mix in Sound Studio, the in-tab DAW that ships music, SFX, and dialogue layers in a single timeline. Vendor barks and short death taunts come out of Speech Gen with a per-character voice slot; one or two voice slots per NPC role is enough for a 2026 roguelike scope.

Engine pick — Phaser, Three.js, Godot 4, or Unity for the ship build

The engine choice is downstream of the run loop, not upstream. Once WizardGenie has scaffolded the procgen and asset glue, any of four engines can ship the build. Phaser 4 is the right pick for a 2D browser-tab roguelike: zero install, ships to itch.io as a single index.html, the Phaser community has 10+ years of roguelike-friendly examples (camera follow, tilemap, weighted RNG). Three.js covers the 3D browser-tab path for a roguelike with isometric or first-person dungeon framing — pair it with the GLB output from 3D Studio and an auto-rigged hero from Auto-Rigging. Godot 4 ships free, exports to Steam and itch.io natively, and handles both the 2D and 3D paths with one project; it is the strongest desktop pick. Unity is the right pick only if the dev needs console certification (Switch, PlayStation, Xbox) or wants the Unity Asset Store as a content backstop.

The asset pipeline does not change with the engine choice. Quick Sprites PNG + manifest, Tileset Forge PNG + autotile JSON, Music Gen WAV/MP3, SFX Gen WAV all load into all four engines without conversion. The handoff that does change is the run loop scaffold language: WizardGenie writes TypeScript for Phaser, JavaScript for Three.js, GDScript or C# for Godot 4, and C# for Unity. Pick the engine first, name the engine in the WizardGenie prompt, and the eight-model picker writes the right scaffold language without further plumbing. The dev never has to translate code by hand.

Save format, meta-progression, and the death-and-restart loop

Permadeath is a hard rule in pure roguelikes and a softened-with-meta-progression rule in roguelites. The implementation difference is one save-file flag. WizardGenie writes both shapes on prompt: the pure version wipes the save on death (only daily-best stats persist), the roguelite version persists a meta-progression layer (currency carries over, optional unlocks, optional permanent stat boosts). A 2026 indie roguelike almost always picks the roguelite shape because the meta-progression hook drives session-after-session retention — Hades, Dead Cells, Slay the Spire, and Returnal all sit on the roguelite side. Tell WizardGenie which shape to ship in the first prompt and the save schema falls out automatically.

The death screen is its own piece of UX work. A good 2026 roguelike death screen shows the run summary (depth reached, gold earned, items collected, monsters killed), the meta-progression delta (currency added to the meta layer), and a restart button that lands the player back at the meta-progression menu rather than dumping them into a fresh run. WizardGenie writes the React or Phaser DOM markup for this screen on prompt; the visual styling pulls from the same color palette as the in-game UI. Death is the most-seen screen in the entire game — the player sees it dozens of times per session — so it is worth ten minutes of design polish, not five.

The verdict on how to make a roguelike game in 2026

The honest verdict on how to make a roguelike game in 2026 is that the genre has finally crossed the line where one indie dev with one Sorceress account can ship a release-quality run loop in under a month. The five hard pillars of a roguelike (procgen, permadeath, turn-based or real-time combat, run-based progression, asset variety) all map cleanly onto AI handoffs that did not exist in 2023. WizardGenie’s eight-model picker writes the procgen and combat code in one tab; Quick Sprites + Tileset Forge + AI Image Gen ship the visual half; Music Gen + SFX Gen + Sound Studio + Speech Gen handle the audio half; 3D Studio + Auto-Rigging + Material Forge cover the optional 3D path. Every layer has a credit cost displayed inline before the run, every output is a web-standard format, and the bundle costs $49 once plus pay-once credit packs that never expire (verified against src/app/plans/page.tsx on June 19, 2026). For comparison, the closest reference build — a Sorceress user shipped their first game in three weeks — used this same catalog end-to-end with no other paid subscriptions.

The honest path forward is one focused biome at a time. Pick the engine target (browser-tab Phaser is the easiest first ship, Godot 4 is the easiest desktop), prompt WizardGenie for the run loop, generate the first biome’s seven content pieces (hero, three monsters, ten items, one tile set, one music loop, eight SFX, one death screen), playtest until the loop feels honest, then add biomes two and three on the same content multiplier. The dev who tries to ship four biomes and twelve hero classes on day one will fail at scope; the dev who ships one biome plus one boss fight in week one and then iterates will ship a real roguelike in a month. The genre rewards focus, and AI generation now handles the piece that used to break that focus — the asset volume.

For the next step, the natural follow-ups are how to make an RPG game if the dev wants to broaden the design surface, how to make a roguelike in Godot if the engine pick is locked to Godot 4 specifically, or the best vibe-coding tools for building games if the dev is still picking between WizardGenie and the alternative coding-agent surfaces. The WizardGenie tab is the single entry point that turns this whole guide into a project folder.