Build a Game
Build a game and get it finished and played: settle the core idea and scope, prototype the mechanics, build the systems and content, make it feel good, test it with players and release it.
This roadmap guides you step-by-step through designing, prototyping, refining, and publishing a finished 2D game using Godot Engine for web browsers on itch.io. At roughly 10 hours per week over two to three months, you will work hands-on from initial graybox mechanics to playtesting and public launch. Completing this plan leaves you with a publicly playable 2D game on itch.io, an understanding of core game design loops, and end-to-end experience shipping Godot projects.
By the end: You will have designed, built, polished, and publicly launched a complete 2D browser game on itch.io using Godot, and collected real feedback from outside players.
This is the map — make this roadmap yours
It shows what this journey generally looks like. Tell Kaidoro your version of the goal and it builds the plan around where you are actually starting, what to do first, the hours you really have, and what you have already finished.
Concept Definition and Scope Cutting
Clarify your core gameplay hook and aggressively trim features so the project remains realistic for a solo beginner.
- Write a one-page game design document~3hScope1 resource
Clear constraints up front prevent feature creep and scope bloat from stalling the project.
You'll learn
- Core loop — the repeated cycle of player action, feedback, and reward
- Feature creep — the tendency for a project to expand beyond realistic completion limits
Draft a concise single-page document detailing the primary player action, core obstacle, win/loss condition, and visual aesthetic. Avoid detailing extended lore or massive feature sets.
Done when: you have a written single-page summary answering what the player does every second, minute, and session.
How to work through it
- Identify the core mechanic verb (e.g., jump, dash, reflect)
- Define the primary hazard or challenge
- State the victory condition and failure condition
- List the minimum art and audio assets required
- Define the non-goals and explicit cut list~2hScope
Writing down what you are deliberately not building protects your focus during production.
You'll learn
- Scope management — defining strict boundaries on project deliverables
Create a formal list of features that are explicitly excluded from version 1.0 (such as multiplayer, inventory systems, branching dialogue, or procedural generation).
Done when: you have a documented list of at least five features you will explicitly not build for this release.
How to work through it
- Brainstorm features commonly over-scoped in beginner games
- Write down excluded mechanics and systems
- Store this list alongside your design document for quick reference
Godot Setup and Graybox Prototype
Set up the Godot Engine and build the thinnest end-to-end slice of movement and player interaction using placeholder shapes.
- Install Godot and configure a 2D project~2hBuild1 resource
Establishes your development environment and engine settings correctly from day one.
You'll learn
- Godot 4 — the open-source lightweight game engine used for this project
- Viewport resolution — the base rendering dimensions of your 2D game canvas
Download and install Godot 4, create a new 2D project, and configure project settings for 2D pixel snap and viewport resolution.
Done when: Godot opens a blank 2D scene with correct viewport dimensions and runs without errors when pressing Play.
How to work through it
- Download Godot 4 from the official website
- Create a new project repository and initialize version control with Git
- Configure project display window size and stretch mode to viewport/canvas_items
- Build player movement with CharacterBody2D~5hBuild
Character responsiveness is the foundation every other mechanic relies upon.
You'll learn
- CharacterBody2D — Godot's dedicated node for player-controlled physics bodies
- GDScript — Godot's Python-like scripting language
- InputMap — the engine system mapping physical keys to named actions
Create a player scene using a CharacterBody2D node, attach a script in GDScript, and map keyboard inputs to horizontal movement and jumping or direct 2D motion.
Done when: a placeholder colored rectangle moves and collides properly in response to keyboard input in a test room.
How to work through it
- Set up Input Actions in Godot Project Settings
- Create a CharacterBody2D node with CollisionShape2D and ColorRect
- Write the basic movement velocity and move_and_slide logic in GDScript
- Create static floor and wall bodies to verify collisions
- Implement the primary gameplay interaction~4hBuild
Proves the core interaction functions end-to-end before committing to art or level building.
You'll learn
- Area2D — node used for overlap detection and trigger zones
- Signals — Godot's event system for decoupled node-to-node communication
Build the core interaction mechanic (e.g., collecting an item, attacking, swinging, or dodging an obstacle) using Godot's Area2D node and signals.
Done when: the player interacting with an object triggers a detectable state change printed to the output console or altering the scene.
How to work through it
- Create an Area2D scene with a CollisionShape2D for the interactive object
- Connect the body_entered signal to a custom GDScript function
- Trigger a visible response or print statement upon overlap
- Instantiate multiple interactables in the test arena
Core Gameplay Loop and Game State
Tie your mechanics into a complete game loop with health, scores, objectives, game over states, and restarts.
- Build a health or failure system~4hBuild
Games require clear failure conditions to establish tension and challenge.
You'll learn
- Autoload / Singleton — global persistent scripts accessible across any active scene
- State management — keeping track of dynamic runtime values like lives and score
Track player health or lives in a dedicated game manager script and trigger a failure state when health reaches zero.
Done when: receiving damage reduces player health, and reaching zero halts play and presents a failure state.
How to work through it
- Create an autoload GameManager script to manage global state
- Add damage signals when the player collides with hazards
- Implement invulnerability frames or knockback to avoid instant death loops
- Emit a player_died signal when health drops to zero
- Implement the victory condition and scene restarting~4hBuild
Completes the loop so a play session has an explicit start, end, and restart flow.
You'll learn
- SceneTree — Godot's hierarchy that manages active scenes and scene transitions
Detect when the player completes the objective (e.g., reaches the goal or collects all tokens) and reload or advance the scene.
Done when: completing the objective displays a victory screen and pressing a restart key reloads the level cleanly.
How to work through it
- Track total items collected or destination reached
- Trigger a win screen overlay on goal completion
- Connect a button or key press to get_tree().reload_current_scene()
Level Design and Tilemaps
Build cohesive playable environments by creating TileMaps, placing obstacles, and structuring difficulty progression.
- Set up a TileMap with collisions~5hBuild1 resource
Tilemaps allow rapid authoring of varied level layouts without hardcoding individual physics blocks.
You'll learn
- TileMap / TileSet — Godot 2D grid-based level painting tools
- Physics layers — collision masks determining what objects can collide with each other
Import a 2D tile sheet, configure tile collisions and physics layers in Godot, and paint a complete level layout.
Done when: a multi-screen or single-arena level is painted with functional collision boundaries that prevent falling out of bounds.
How to work through it
- Import 2D sprite sheet with proper texture filtering settings
- Create a TileSet resource and define collision polygons
- Paint the main level geometry using the TileMap editor
- Test player traversal across ramps, platforms, and obstacles
- Structure three progressively difficult levels or challenge waves~6hBuild
Gradual difficulty ramp ensures the game teaches its rules naturally before demanding mastery.
You'll learn
- Level pacing — structuring difficulty curves to maintain player engagement without frustration
Design and assemble at least three distinct stages or escalating difficulty waves that introduce mechanics gradually to the player.
Done when: the player can progress through level 1, level 2, and level 3 sequentially with increasing challenge.
How to work through it
- Design Level 1 focusing purely on basic movement and one obstacle type
- Design Level 2 combining two hazards simultaneously
- Design Level 3 testing mastery with stricter timing or tighter constraints
- Connect scene transitions between levels upon reaching exit triggers
Visuals, Audio, and Game Feel
Transform functional mechanics into an engaging sensory experience by adding animations, sound effects, screenshake, and particle effects.
- Implement sprite animations with AnimatedSprite2D~4hBuild
Visual feedback clarifies player status and creates immediate visual charm.
You'll learn
- AnimatedSprite2D — node handling frame-by-frame 2D animations
- State-driven visuals — synchronizing sprite frames to underlying character physics
Replace placeholder rectangles with animated character sprites for idle, run, jump, and hurt states.
Done when: the character visual switches cleanly between appropriate animations corresponding to movement and actions.
How to work through it
- Import sprite sheets or frame sequences into Godot
- Set up AnimatedSprite2D with named animations
- Update script to switch animation based on velocity and state machine flags
- Add sound effects and background music with AudioStreamPlayer~4hBuild1 resource
Audio is half the player experience and gives critical tactile weight to in-game actions.
You'll learn
- AudioStreamPlayer — Godot node for playing non-positional and positional audio
- Audio Buses — routing channels to control and mix sound categories independently
Integrate audio effects for jumping, collecting items, taking damage, and level completion, along with a looping background music track.
Done when: all primary player interactions have distinct audio feedback and audio volume buses are properly balanced.
How to work through it
- Source or generate CC0 sound effects and music tracks
- Set up AudioStreamPlayer2D and AudioStreamPlayer nodes
- Create Master, Music, and SFX audio buses in Godot Audio Bus Layout
- Trigger sound playback on jump, collect, hurt, and victory events
- Add 'juice' with camera shake, particles, and hit pause~4hBuild
Juice transforms a stiff prototype into a satisfying, responsive game feel.
You'll learn
- Game feel / Juice — the visual and physical tactile feedback of actions
- GPUParticles2D — GPU-accelerated 2D particle emitter in Godot
Implement small visual impact flourishes such as a slight camera trauma shake on damage, dust particles on landing, and brief freeze frames on hits.
Done when: impacts, landings, and pickups produce visible particles and subtle camera response.
How to work through it
- Create a GPUParticles2D node for impact dust and explosions
- Write a simple camera shake function on Camera2D adjusting offset
- Add a brief 0.05-second engine time_scale pause on heavy impacts
User Interface and Menu Systems
Construct clean HUD elements, main menu, pause menu, and audio settings so the game functions as a self-contained product.
- Build an in-game heads-up display (HUD)~4hBuild
Players need reliable real-time status indicators that do not shift across different display sizes.
You'll learn
- CanvasLayer — separate render layer for fixed screen elements
- Control Nodes — Godot's UI system handling layout, margins, and anchors
Design an on-screen display showing current health, score, and level using Godot's Control nodes anchored to the viewport.
Done when: the HUD stays anchored to screen corners regardless of window scaling and updates immediately when game values change.
How to work through it
- Create a CanvasLayer node to render UI independently of camera movement
- Use TextureRect, Label, and ProgressBar Control nodes
- Connect health and score signals to HUD update functions
- Configure Control layout anchors for responsive scaling
- Create main menu, pause menu, and audio volume sliders~5hBuild
Gives the game a polished, complete structure expected of any public release.
You'll learn
- Process Mode — engine setting defining whether nodes run when the SceneTree is paused
- AudioServer — Godot singleton controlling global audio bus parameters
Build a title screen with Start and Instructions buttons, plus an in-game pause menu that can pause process execution and adjust volume levels.
Done when: you can launch the game from the title menu, pause midway with the Escape key, adjust audio sliders, and quit back to menu.
How to work through it
- Create a TitleScreen scene with play and quit buttons
- Build a PauseMenu scene set to process mode 'When Paused'
- Use HSlider nodes linked to AudioServer bus volumes
- Test pausing and unpausing without breaking physics timers
HTML5 Web Export and Performance
Export the game to WebAssembly/HTML5 and test it inside standard desktop browsers.
- Install Godot export templates and configure Web export~3hShip1 resource
Validating the export pipeline early ensures web-specific bugs are found before release day.
You'll learn
- WebAssembly (Wasm) — low-level binary format enabling Godot games to run at near-native speed in browsers
- Export presets — configuration files specifying platform build parameters
Install Godot export templates, set up an HTML5 export preset, and produce an index.html build package.
Done when: exporting generates an index.html, index.js, and index.wasm bundle in a build folder without export errors.
How to work through it
- Download matching version Godot export templates
- Configure Project Export preset for Web (HTML5)
- Set presentation options and thread settings compatible with itch.io
- Run the export process to an output directory
- Test browser playback and optimize asset loading~3hTest
Browsers have strict autoplay policies and input focus quirks that must be tested explicitly.
You'll learn
- Web Audio Autoplay policy — browser security rule requiring user interaction before audio plays
- Local server hosting — serving files via HTTP rather than direct file:// protocol
Host the exported game on a local web server (e.g., using Python http.server or Godot's built-in one-click web runner) and verify audio and controls across browsers.
Done when: the game loads within 10 seconds on a local browser server, keyboard inputs work immediately upon canvas click, and audio plays without stutter.
How to work through it
- Run a local web server to bypass CORS file restrictions
- Test in Chrome and Firefox
- Confirm web canvas auto-focuses on click
- Verify audio resumes after user interaction
Playtesting and Iteration
Conduct structured testing with outside players to identify confusion, balance issues, and bugs before public launch.
- Run three silent playtesting sessions~4hTest
Watching real players reveals blind spots and design assumptions you cannot see yourself.
You'll learn
- Blind playtesting — testing without designer assistance to evaluate natural tutorialization and clarity
Have three people play your web build while you watch over screen share or in person without giving hints, taking notes on where they get stuck or confused.
Done when: you have completed three observation sessions and compiled a list of at least five actionable friction points.
How to work through it
- Send web build link or set up screen share
- Instruct the tester to think out loud and do not intervene
- Record timestamps where players fail, hesitate, or misunderstand instructions
- Compile notes into a prioritized bug and balance list
- Fix critical friction points and balance difficulty~4hBuild
Directly acts on real player data to make the game welcoming and fair.
You'll learn
- Iterative balancing — refining numeric properties based on observed player behavior
Implement fixes for the top three usability or difficulty issues identified during your playtests.
Done when: the identified sticking points are resolved and confirmed working in a fresh export build.
How to work through it
- Tweak jump heights, enemy speed, or hitboxes as needed
- Add visual cues or tutorial prompts if players missed mechanics
- Re-export web build and verify fixes
itch.io Release and Presentation
Package the finished game, design an appealing itch.io project page, and publish the game publicly to the web.
- Create screenshots, cover art, and game description~3hShip
Clear presentation and appealing screenshots determine whether a browsing player clicks to play your game.
You'll learn
- Storefront optimization — presenting visual hooks and clear instructions to attract players
Capture three high-quality gameplay screenshots, create a 630x500 banner/cover image, and write a concise description explaining the controls and story premise.
Done when: you have a finalized cover graphic, 3 screenshots, and formatted markdown description text ready for upload.
How to work through it
- Take clean screenshots highlighting action moments
- Create a cover image with clear game title typography
- Write bullet points for controls and gameplay features
- List asset credits and engine acknowledgments
- Upload zip and configure itch.io HTML5 player~3hShip
The official finish line that transitions your project from a private file to a live public game.
You'll learn
- itch.io HTML5 embedding — configuring browser canvas containers and responsive iframe sizing
Upload your zipped HTML5 export to itch.io, configure the embed viewport dimensions to match your game resolution, and test live in-browser execution.
Done when: your itch.io project page is set to Public and any user can click 'Run Game' and play directly in their browser.
How to work through it
- Compress exported web files into a single .zip file with index.html at root
- Create new project on itch.io with 'HTML' project type
- Upload zip and mark 'This file will be played in the browser'
- Set viewport embed width and height to match Godot settings
- Save and set visibility to Public
Launch Review and First Feedback
Share your game with indie gaming communities, monitor player comments, and reflect on the complete development cycle.
- Share the release link in target game developer communities~2hShip1 resource
Puts your finished work in front of real people outside your personal circle.
You'll learn
- Community outreach — respectfully sharing creative work to build feedback loops
Post your playable itch.io link in relevant communities (e.g., Godot Discord, r/godot, or itch.io release forums) requesting specific feedback on controls and difficulty.
Done when: you have posted your game link to at least two communities with a polite request for play feedback.
How to work through it
- Write a concise post introducing the game theme and engine
- Include a screenshot or animated GIF and direct itch.io link
- Ask targeted questions about game feel and pacing
- Post in community feedback channels
- Write a project post-mortem~2hScope
Writing a post-mortem cements what you learned and prepares you for future, larger projects.
You'll learn
- Post-mortem — reflective analysis of project execution, mistakes, and successes
Document what went well, what took longer than expected, engine quirks encountered, and lessons to apply to your next game.
Done when: you have written a 500+ word retrospective summarizing your technical and design takeaways from the project.
How to work through it
- Review original design doc against the final shipped version
- List three technical things you mastered and three areas to improve
- Record total hours spent across phases
- Archive the repository and release build
How the plan fits together
10 phases in 10 stages. Anything on the same row can be worked on at the same time.
An arrow points from a phase to the work it unlocks: before starting any phase, every phase with an arrow into it has to be finished first.
Resources
14 in this plan's library, beyond the links on individual tasks.
Learning & Documentation
Godot manuals, scripting references, and guides.
- "Your first 2D game" Tutorial Series
Use this official beginner tutorial to learn core Godot engine fundamentals by building a complete 2D game from scratch.
docs.godotengine.org · Godot Engine / Godot Foundation · Tutorial Series · Free · Beginner
- Exporting for the Web
Reference this official guide for WebAssembly export settings, local testing setups, and browser compatibility handling.
docs.godotengine.org · Godot Engine / Godot Foundation · Documentation · Free · Intermediate
- HTML5 Game Publishing Guide
Use this guide to learn packaging rules, viewport dimension embedding, and project visibility configuration on itch.io.
itch.io · itch.io · Documentation · Free · Beginner
- Juice It or Lose It
Watch this classic talk to understand how tweening, sound, screen shake, and particles make simple mechanics feel satisfying.
Martin Jonasson & Petri Purho (GDC Europe) · Conference Talk · Free · Beginner
- Learn GDScript From Zero
Use this interactive browser app to master foundational GDScript programming concepts before scripting game mechanics.
gdquest.github.io · GDQuest · Interactive Web App · Free and open source · Beginner
- The Art of Game Design: A Book of Lenses
Read the chapters on core mechanics, scope, and prototyping to clarify your game concept before opening an engine.
Jesse Schell / CRC Press · Book · ~$45 · Beginner
Tools & Free Assets
Sound generators, pixel tools, and CC0 assets.
- jsfxr (8-Bit Sound Generator)
Use this browser tool to instantly synthesize retro sound effects and export WAV audio files for your game.
sfxr.me · Eric Fredricksen and Chris McCormick · Web Tool · Free and open source · Beginner
- Kenney Asset Packs
Use these high-quality, public domain 2D tilesets and sprites to assemble your levels and test tilemap collisions.
kenney.nl · Kenney · Asset Library · Free (CC0) · Beginner
- Kenney Game Assets (2D & UI Packs)
Use these public domain 2D assets to quickly prototype mechanics and build tilemap levels without creating art from scratch.
kenney.nl · Kenney / Kenney.nl · Asset Pack · Free (public domain / CC0) · Beginner
- Lospec Palette List and Pixel Art Tools
Use this palette directory to maintain consistent color harmony across custom tilemaps and sprites.
lospec.com · Lospec · Web Tool / Asset Repository · Free · Beginner
Communities & Feedback
Forums and groups to share builds and get testers.
- itch.io Creator Community
Consult advice on page layout, game embeds, and post-launch troubleshooting from other indie web game creators.
itch.io · itch.io · Community Forum · Free · Beginner
- Official Godot Engine Forum
Use this official discussion board to get help troubleshooting GDScript errors and 2D physics implementation issues.
forum.godotengine.org · Godot Engine / Godot Foundation · Forum · Free · All Levels
- r/godot
Engage with this developer community for mechanic validation, peer feedback, and launch post-mortems.
reddit.com · Reddit · Community / Subreddit · Free · All Levels
- r/playmygame
Post playable browser builds here to gather external playtesting feedback and bug reports prior to launch.
reddit.com · Reddit · Community / Subreddit · Free · Beginner