A game dev roadmap is an ordered plan of skills and projects that takes you from “I want to make games” to a finished game someone else can play. The honest version is shorter than the giant skill charts floating around: learn enough to build, build tiny things, finish them, then grow. This guide lays out six phases, a 12-week worked plan, the mistakes that stall most beginners, and where AI tools now fit into the path.
What a game dev roadmap should actually do
Game development is a multidisciplinary craft. As the Wikipedia overview of video game development describes, it combines programming, design, art, audio, testing and production. That breadth is exactly why roadmaps go wrong. Many of them try to list every discipline at once: learn C++, linear algebra, shaders, 3D modelling, animation, music theory, networking. A beginner looks at that wall and quits, or spends a year on tutorials without finishing anything.
A useful game dev roadmap does three things:
- Puts skills in order. You learn what the next project needs, not everything a senior developer knows.
- Forces finished games early. Finishing teaches scope, bug fixing and polish, which no tutorial covers.
- Fits your goal. A hobbyist making jam games, a solo indie aiming to sell a game and a student aiming for a studio job need different end points.
Before you start, decide which of those three you are. You can change your mind later, but the choice tells you when to stop going wide and start going deep.
The game dev roadmap in six phases
Here is the full game dev roadmap. Each phase ends with something you can show, not just something you read.
Phase 1: Pick a target game and a goal
Write one sentence describing the kind of game you want to make eventually (“a top-down action RPG”, “a cosy farming game”, “a mobile puzzle game”). Then write a second sentence describing a tiny version you could make soon. This target shapes every later choice: 2D or 3D, which engine, which art skills. Skip this and you will drift between tutorials for unrelated genres.
Phase 2: Learn programming fundamentals
You need variables, conditions, loops, functions, arrays and objects. You also need the single most important idea in games: the game loop, a function that runs many times per second, reads input, updates the world and draws the result. JavaScript is a good first language because it runs in every browser with nothing to install. Python and C# are also fine. Do not spend months here; a few weeks of daily practice is enough to move on.
Phase 3: Learn one engine
A game engine is a software framework that handles rendering, input, physics, audio and asset loading so you can focus on your game. Common choices include Unity, Unreal, GameMaker and Godot, which is open source under the MIT License. Pick one that suits your target game and stay with it for at least your first three projects. Engine-hopping is the most common way beginners lose months.
Phase 4: Ship tiny games
Remake small classics: Pong, Breakout, Flappy Bird, Snake, a single-screen platformer. Each should take days, not weeks. Then enter a game jam, a timed event where you build a game around a theme. Our guide to the Brackeys Game Jam explains how jams run and how to scope for one. Jams teach you to cut features, which is the most valuable skill in this whole roadmap.
Phase 5: Build one portfolio project
Now make something bigger: a vertical slice, meaning one polished level or area that shows the full experience of your target game. This is where you learn level design, save systems, menus, audio mixing and playtesting with strangers.
Phase 6: Specialise or go indie
If you want a studio job, pick a lane (gameplay programming, technical art, level design, animation, audio) and build two or three focused portfolio pieces in it. If you want to go indie, your next step is a small commercial game and learning store pages, trailers and marketing. Either way, the earlier phases never stop: you keep shipping.

Which skills to learn first (and which to skip)
The order of skills depends on your goal. This table shows a sensible focus for each common path through a game dev roadmap.
| Goal | Learn first | Learn later | Safe to skip at first |
|---|---|---|---|
| Hobbyist / jam games | Basic code, one 2D engine, scoping | Simple pixel art, sound effects | Shaders, networking, advanced math |
| Solo indie (selling games) | Code, one engine, finishing, playtesting | Art direction, audio, marketing | Writing your own engine |
| Studio job (programmer) | A language used in the industry, data structures, engine scripting | Math for games, optimisation, tools | Making your own art assets |
| Studio job (artist) | Art fundamentals, one 2D or 3D package, engine import | Rigging, animation, materials | Deep programming |
| Vibe coder (AI-first) | Reading code, describing features precisely, debugging | Core programming concepts in depth | Memorising syntax |
Notice what most rows skip: building your own engine. It is a fantastic learning project for later, and our HTML5 canvas engine walkthrough shows one way to do it, but it is a detour if your goal is to make games.
A first program worth writing
The fastest way through phase 2 is to write a game loop yourself once. Put a canvas element with the id game on a page, then add this script. It moves a square with the arrow keys using delta time, the seconds elapsed since the last frame, so speed stays the same on fast and slow screens.
const canvas = document.getElementById("game");
const ctx = canvas.getContext("2d");
canvas.width = 480;
canvas.height = 320;
const player = { x: 230, y: 150, size: 20, speed: 200 };
const keys = {};
window.addEventListener("keydown", (e) => { keys[e.key] = true; });
window.addEventListener("keyup", (e) => { keys[e.key] = false; });
let last = performance.now();
function loop(now) {
const dt = (now - last) / 1000;
last = now;
if (keys["ArrowLeft"]) player.x -= player.speed * dt;
if (keys["ArrowRight"]) player.x += player.speed * dt;
if (keys["ArrowUp"]) player.y -= player.speed * dt;
if (keys["ArrowDown"]) player.y += player.speed * dt;
player.x = Math.max(0, Math.min(canvas.width - player.size, player.x));
player.y = Math.max(0, Math.min(canvas.height - player.size, player.y));
ctx.fillStyle = "#101828";
ctx.fillRect(0, 0, canvas.width, canvas.height);
ctx.fillStyle = "#f5c542";
ctx.fillRect(player.x, player.y, player.size, player.size);
requestAnimationFrame(loop);
}
requestAnimationFrame(loop);
Read every line until you could explain it to a friend. Input, update, draw, repeat: every engine you ever use is doing a more sophisticated version of this.





