Spin How to Make an RPG in Scratch (Block AI 2026)

Type how to make an rpg in scratch into Google on June 20, 2026 and the SERP is split between two readers. One is a fourteen-year-old who just finished a Scratch arcade game and now wants Dragon Quest. The other is a parent or teacher who needs a real lesson plan for a club. Both want the same thing: a step-by-step path from the blank Scratch stage to a playable RPG with a hero, a town, a dungeon, a turn-based battle screen, and a save file. The honest 2026 path is the Scratch 3.0 block editor at scratch.mit.edu for the game logic, plus a Sorceress catalog for the asset half (hero walk cycle, NPC portraits, enemy sprites, overworld and dungeon tilesets, battle music, combat SFX) — all in one browser tab on a $49 Lifetime account, verified against the live Sorceress source code on June 20, 2026.

What “how to make an rpg in scratch” actually means in 2026

The phrase how to make an rpg in scratch means something very specific in 2026. Scratch is a free, browser-based visual programming language hosted at scratch.mit.edu, designed at the MIT Media Lab in 2007 and now in its 3.0 generation (rewritten in JavaScript on top of HTML5 Canvas). Code is written by snapping coloured Lego-shaped blocks together inside a 480 by 360 pixel stage editor — there is no syntax to mistype, no language to install, no IDE to configure. An RPG in 2026 means a role-playing video game with a stat-driven hero, an overworld map, NPC dialogue, turn-based or action combat, an inventory, levels, and ideally a save system. Combine the two and the goal becomes: ship a playable RPG inside Scratch’s block-based editor that runs in the Scratch player after publish.

The reason this works as a how-to is that the Scratch design surface and the RPG design surface map cleanly onto each other. The 480 by 360 stage holds a Dragon Quest-scale tile world (15 by 11 tiles at 32x32, or 30 by 22 tiles at 16x16). The block library covers every primitive an RPG needs: variables for HP, MP, gold, XP, and level; lists for the inventory and the enemy roster; broadcasts as the message-passing system for state transitions between overworld, dialogue, battle, and menus; my-blocks (custom blocks) for the damage formula and the level-up curve; the costumes tab handles sprite animation; the sounds tab handles music and SFX playback. The only thing Scratch does NOT ship in-engine is asset generation — the cat is the default and the dev brings their own pixel art for everything else. That is exactly the half AI now removes.

The seven pillars of every Scratch RPG — what blocks, what assets

Before opening Scratch, a dev needs a clear pillar list because every pillar maps either to a specific block group (the code half) or a specific Sorceress tool handoff (the asset half). The seven pillars an indie 2026 Scratch RPG actually has to ship are: (1) the overworld — a tile-based map with the hero sprite, NPCs, doors, treasure chests, and an inn or save point; (2) movement and collision — arrow-key input that moves the hero one tile at a time, with collision blocked by impassable tile colours or by sensing-touching-sprite tests; (3) dialogue and NPCs — the say-block speech bubble or a custom dialogue-box sprite with text driven by a list, plus broadcast triggers for shop, heal, save, and story beats; (4) turn-based combat — a battle backdrop, a hero sprite on the left, an enemy sprite on the right, an action menu (Attack, Magic, Item, Run), a damage formula in a my-block, and the broadcasts that drive the state machine; (5) inventory and gold — lists for owned-items and item-counts, a shop-menu sprite that buys and sells, a use-item handler for potions; (6) level and XP — an XP variable that compares against a level curve in a my-block, a level-up broadcast that bumps HP, MP, attack, and defence; (7) save and load — a Cloud Variable for shared projects or a project-local list of variable values for unshared projects, with a save-game broadcast on the inn-rest action.

The split between Scratch blocks and Sorceress asset handoffs falls cleanly along these pillars. Pillars 1, 2, 3, 4 (logic side), 5, 6, and 7 are blocks — WizardGenie writes the plan and explains each block stack with the eight-model coding picker (verified against src/app/_home-v2/_data/tools.ts CODING_MODELS on June 20, 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 1 (visual side), 3 (NPC portrait side), and 4 (battle backdrop and enemy art side) are visual assets — Quick Sprites for hero and enemy walk cycles, AI Image Gen for NPC portraits and shop signage, Tileset Forge for the overworld and dungeon tile sets, and True Pixel for palette-locking every output to a consistent retro look. The audio half — the overworld theme, the battle loop, the boss theme, the menu chime, the level-up sting, the sword-hit, the magic-spark, the victory fanfare — comes out of Music Gen and SFX Gen. Every Sorceress output is PNG, WAV, or MP3, and Scratch’s Upload Sprite and Upload Sound buttons accept all three.

How to make an RPG in Scratch with the honest 2026 browser AI stack

The honest stack to make an RPG in Scratch in 2026 is one Scratch tab plus one Sorceress tab. Verified against the live source on June 20, 2026, the Sorceress side is eight tools deep, all reachable from one account: WizardGenie for the variable, broadcast, and custom-block plan; Quick Sprites for hero and enemy walk cycles at 9 credits per sprite sheet; AI Image Gen for NPC portraits, shop signage, and battle backdrops; True Pixel for palette-locking every output to one of eight presets (PICO-8 16, SWEETIE-16, Endesga 32, Game Boy, CGA, NES 54, Grayscale 8, 1-Bit, verified against src/app/pixel-art/page.tsx on June 20, 2026); Tileset Forge for the overworld and dungeon tile sets; Music Gen for the overworld, battle, and boss loops at 10 credits per generation (each generation returns 2 variations, verified against src/app/music-gen/page.tsx on June 20, 2026); SFX Gen for combat and menu one-shots at 3 credits per sound; and Sound Studio as the in-tab DAW for trimming and mastering before drop-in. 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 20, 2026. New accounts ship with 100 starter credits, enough to draft the hero walk cycle and one tileset before topping up.

The reason this stack works for an RPG in Scratch specifically is that Scratch removes the asset pipeline assumptions a desktop engine would force. There is no Aseprite seat to buy for the sprite work, no FL Studio install for the music, no Audacity for SFX clean-up — the in-browser Sorceress catalog covers every handoff, every output drops into Scratch via the bottom-right Upload Sprite and Upload Sound buttons, and the dev never leaves the browser between the Sorceress tab and the Scratch tab. The eight-model coding picker in WizardGenie matters for the planning half because RPG state machines are the hardest part to get right on the first pass — 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 single-frontier billing (the mixture-of-experts economics that make the dual-agent pattern worth deploying). 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; never put a frontier-priced model on the typing side or the cost advantage disappears.

Step 1 — open Scratch and prompt WizardGenie for the variable, block, and broadcast plan

The first move is to open Scratch 3.0 in one browser tab (scratch.mit.edu, new project) and WizardGenie in another (sorceress.games/wizard-genie/app). Before snapping a single block, prompt WizardGenie for the full structural plan. A reliable opening prompt looks like this: “I am building an RPG in Scratch 3.0. Write me the complete variable plan, broadcast plan, and custom-block plan for a Dragon Quest-style game with one playable hero, three towns, two dungeons, four enemy archetypes, one boss, fifteen items, a turn-based battle loop with Attack/Magic/Item/Run, an inventory, and an inn-based save system. List every variable name, every broadcast name, every custom-block name, and tell me which Scratch sprite or backdrop should hold each script.” Pick the Claude Opus 4.7 model from the dropdown for this prompt — RPG state machines reward the heavy reasoner, and Opus 4.7 ships at $5 input / $25 output per million tokens with a 1M context window. The first response will hand back something like: variables HP, MAX_HP, MP, MAX_MP, GOLD, XP, LEVEL, SCENE, HERO_X, HERO_Y; broadcasts enter_battle, choose_action, enemy_turn, end_battle, level_up, open_shop, save_game, load_game; my-blocks damage(attacker_attack, defender_defense), heal(amount), level_curve(current_level), save_state, load_state.

The second prompt scopes the battle state machine specifically because turn-based combat is where most beginner Scratch RPGs collapse. Prompts like “write the exact Scratch block stack for the battle-state variable transitions: overworld > battle_menu > enemy_turn > battle_victory or battle_defeat > overworld, with the menu sprites (Attack, Magic, Item, Run) using when-this-sprite-clicked hat blocks that branch on the battle-state and broadcast choose_action with the chosen action stored in a global last_action variable” produce a step-by-step block list that maps one-to-one to the Scratch editor. Switch to Claude Sonnet 4.6 ($3/$15) or DeepSeek V4 Pro for the iteration phase because the planning is done and the typing-side cost matters more than the reasoning depth. The eight-model picker (Claude Opus 4.7 for the hard reasoning, GPT-5.5 for code review, Gemini 3.1 Pro for 1M-context refactors, DeepSeek V4 Pro and Kimi K2.5 for cheap fast iteration, Grok 4.2, MiniMax M2.7, Sonnet 4.6) lets the dev pick the right tool for each prompt round without leaving the tab.

Step 2 — generate hero, NPC, and enemy sprites in Quick Sprites, AI Image Gen, and True Pixel

With the block plan written, the next session is asset generation. The Scratch RPG sprite pipeline starts with the hero. Prompt Quick Sprites with a one-sentence hero description in a Four-Angle Walking template at 48 by 48 pixels: “heroic young swordsman in blue cloak and silver armour, brown hair, pixel art, four-direction walk cycle, transparent background.” The output is a packed PNG sprite sheet at 9 credits per generation (verified against src/app/quick-sprites/page.tsx CREDITS_PER_GEN constant on June 20, 2026). Run the same template for each of the four enemy archetypes (slime, skeleton, bat, goblin) and an optional final boss. Five sprite sheets at 9 credits each is 45 credits total — well inside the 100 starter credit allotment for new accounts.

NPC portraits and shop signage come out of AI Image Gen with a different handoff. A Dragon Quest-scale town needs roughly six to ten NPCs (merchant, healer, innkeeper, king, captain of the guard, two villagers, an elderly sage, a child, a mysterious stranger). Prompt them as a single batch with a consistent style word and reference image so the model stays on-style: “NPC portrait set, 32x32 pixel art, fantasy RPG, transparent background, palette PICO-8, one merchant in red apron, one healer in white robe, one innkeeper with kitchen apron, one king with crown and red cape.” Pass each output through True Pixel to lock the palette to PICO-8 16 (or Endesga 32 for SNES-era polish, or NES 54 for the canonical Dragon Quest look). Pick one palette and stick with it across the hero, NPCs, enemies, tiles, item icons, menu chrome, and battle backdrops — the whole game should read as a single coherent pixel art picture, not a collage of different art styles.

Step 3 — paint overworld and dungeon tilesets in Tileset Forge

The tile set is the visual backbone of every Scratch RPG. A 32x32 tile fills a 15-tile-wide overworld neatly inside Scratch’s 480 pixel stage; a 16x16 tile doubles the resolution to 30 tiles wide for a Final Fantasy-IV-scale map. Tileset Forge generates either an 8-direction tile pack (floor, wall, four corner tiles, transition tiles) or a 47-tile blob set with full autotile rules baked in for arbitrary surface shapes. For an RPG specifically, the 8-direction set is usually enough for the overworld (grass, paths, water edges, mountain edges, trees, town gates) and the dungeon (stone floor, stone wall, torch sconces, door tiles, treasure-chest tile, exit tile). Prompt the overworld set with a one-sentence biome description (“grass and dirt path overworld tileset, 32x32 tiles, NES palette, one grass variant, two path variants, three tree variants, one water-edge variant, one mountain-edge variant”) and the dungeon set separately (“torch-lit dungeon stone tileset, 32x32 tiles, dark NES palette, stone floor, stone wall, four corner pieces, one torch sconce, one door, one treasure chest, one staircase”). The tool returns packed PNGs at roughly 6 credits per set.

The Scratch import for a tileset is a two-step move because Scratch does not have a native tilemap node. Step one: upload the tileset PNG via the Upload Sprite button, then split it into individual costumes in the Costumes tab (rectangle marquee around each tile, Copy, Paste as new costume, name each costume tile-grass-1, tile-path-1, tile-tree-1, etc.). Step two: write a tile-painting script that uses the stamp block to paint each tile at the right x,y position. The hero sprite then moves one tile-width at a time on arrow-key press, and a sensing-touching-color test on the tile colours blocks movement onto impassable tiles. This is the canonical Scratch tile-based overworld pattern, documented on the Scratch Wiki and used in every shipped Scratch RPG of note. For a one-off prop or feature decoration that the main tileset does not cover (a unique sign, a destructible barrel, a sparkle particle), pull True Pixel on a single AI Image Gen render — the photo-to-pixel-art conversion handles props that do not deserve their own tileset run.

Step 4 — compose overworld and battle music in Music Gen, fight SFX in SFX Gen

Audio is the layer most Scratch RPGs ship without, and the absence kills the mood faster than any other shortcut. A silent Scratch overworld feels broken; a silent Scratch battle feels worse. The 2026 fix is three music loops total from Music Gen at 10 credits per generation (each generation returns two variations, verified against src/app/music-gen/page.tsx on June 20, 2026). Loop one is the overworld theme — prompt “heroic Dragon Quest-style overworld march, NES chiptune, 100 BPM, looping” in Create mode and pick the V5.5 model for the default quality bar. Loop two is the battle loop — “epic turn-based battle music, NES chiptune, 130 BPM, looping, urgent but not overwhelming.” Loop three is the boss theme — “final boss battle music, NES chiptune, 140 BPM, looping, dramatic with a clear melodic hook.” Three loops at 10 credits each is 30 credits total. Drop the WAV exports into Scratch via the bottom-right Choose a Sound button on each backdrop or sprite (the overworld backdrop owns the overworld theme, the battle backdrop owns the battle and boss loops).

SFX one-shots come out of SFX Gen at 3 credits per sound (verified against src/app/sfx-gen/page.tsx SFX_CREDIT_COST constant on June 20, 2026). A Scratch RPG needs roughly eight to twelve SFX: sword hit, magic spark, heal spell, hurt, level up, menu chime, item pickup, treasure chest open, footstep, victory fanfare, defeat sting, save chime. Batch the prompts in one session and use a consistent style word (“NES chiptune,” “8-bit retro,” “Sega Genesis-style”) so the model stays on a coherent palette. Eight SFX at 3 credits each is 24 credits. Trim and fade in Sound Studio, the in-tab DAW for music, SFX, and dialogue clean-up. Total audio pack: 30 credits music plus 24 credits SFX = 54 credits, which fits inside one $10 Starter credit pack (1,000 credits) with 946 credits left over for the next RPG.

Step 5 — wire the turn-based battle loop with Scratch variables, broadcasts, and lists

The turn-based battle loop is the heart of every RPG, and Scratch handles it cleanly with three primitives: a battle-state variable, a broadcast for each state transition, and a list for the enemy roster. When the overworld script detects a random encounter (a one-in-128 chance on each tile-step, the canonical Dragon Quest rate) or a boss-trigger sprite, it broadcasts enter_battle. The battle-state variable receives battle_menu; the overworld backdrop and sprites hide; the battle backdrop and the hero-on-the-left and enemy-on-the-right sprites show. The four menu sprites (Attack, Magic, Item, Run) each have a when-this-sprite-clicked hat block that branches on the battle-state — if state is battle_menu, set last_action to the chosen verb and broadcast choose_action. The choose_action handler runs the damage formula via a my-block (custom block) and broadcasts enemy_turn if the enemy is still alive, battle_victory if the enemy is dead.

The damage formula itself lives in a my-block with three blocks: set damage to hero_attack minus enemy_defense, add pick-random-1-to-4 to damage, if damage is less than 1, set damage to 1. This is the canonical Final Fantasy-I damage formula simplified for Scratch, balances cleanly for a level-1-to-level-20 player progression, and gives every action a meaningful but non-deterministic result. The enemy-turn handler picks a hard-coded attack for a beginner build (always attack with enemy_attack) or a weighted random for a polished one (70 percent attack, 20 percent strong attack, 10 percent special move). Damage applied. If hero HP drops to zero, broadcast battle_defeat and load the last save. Otherwise broadcast back to battle_menu. On battle_victory, add the enemy_xp to the hero XP variable, compare against a level curve in another my-block (level 2 at 100 XP, level 3 at 250 XP, level 4 at 500 XP, doubling roughly thereafter), and if the threshold is crossed broadcast level_up which bumps max_hp, max_mp, attack, and defence by small amounts. Save state lives in a list of variable values written on each inn rest or each manual save action; Cloud Variables work for shared projects, project-local lists work for unshared. The whole battle loop is roughly 80 to 120 blocks across three to four sprites, ships in two to three evenings, and uses the same orange variables, yellow broadcasts, and purple my-blocks every Scratch project ships with.

The verdict on how to make an RPG in Scratch in 2026

The honest verdict on how to make an RPG in Scratch in 2026 is that the genre has finally crossed the line where one indie dev (or one ambitious teenage Scratcher) with one Sorceress account can ship a release-quality RPG in three or four focused weeks. The seven pillars of a Scratch RPG (overworld, movement, dialogue, combat, inventory, levels, save) all map cleanly onto either Scratch’s block library or onto an AI handoff that did not exist in 2023. WizardGenie’s eight-model coding picker writes the variable, broadcast, and custom-block plan in one tab; Quick Sprites, AI Image Gen, True Pixel, and Tileset Forge ship the visual half; Music Gen, SFX Gen, and Sound Studio handle the audio half. Every layer has a credit cost displayed inline before the run, every output is a PNG or WAV that Scratch’s Upload Sprite and Upload Sound buttons accept, and the bundle costs $49 once plus pay-once credit packs that never expire (verified against src/app/plans/page.tsx on June 20, 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 tight scope at a time. Pick the scope first — one playable hero, three towns, two dungeons, four enemy archetypes, one boss, fifteen items, twenty hand-tuned battle encounters — then build the first town and the first dungeon end-to-end in week one (overworld map, three NPCs with dialogue, one battle, the inn-save, the first level-up). Playtest, fix what feels wrong, and only then extend to the second town and dungeon in week two. The dev who tries to ship four continents and twelve character classes on day one will fail at scope; the dev who ships one town and one battle in week one and then iterates will ship a real Scratch RPG in a month. The genre rewards focus on the first hour of gameplay, 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 the full browser-engine path beyond Scratch, how to make an RPG in Godot if the project outgrows the Scratch stage size, how to make a Scratch platformer if the next project is action-oriented, or how to make a 2D platformer game for the Phaser side. The WizardGenie tab is the single entry point that turns this whole guide into a Scratch project folder.