Self-taught game programming — an open-course route

v0.1

Toolbelt

weeks 1–2 · ~20 h

Get the tools out of the way — shell, editor, version control — and install one engine, so you never lose an evening to setup again.

CourseTimeWhy it's here

The Missing Semester of Your CS EducationMIT ~12 h Shell, editors, version control, debugging and profiling. Lectures 1–6 now; the rest when you hit the need.

Learn Git Branchinginteractive ~4 h Branching and merging as a puzzle game. Game repositories go binary-heavy and messy early — you will need this.

Godot — Getting StartedGodot docs ~4 h Install it, open the editor, run the tour. Free, small, no account, and it exports everywhere.

Build

chore: initialize game-log

A public repository called game-log with a README. One commit per study session from here on — and every prototype gets its own folder, however small.

Done when

You can clone, branch, commit and push without looking anything up
Godot opens, runs an empty scene, and exports a build that launches on your desktop
You can move around the filesystem and run a script from the terminal

v0.2

Programming foundations

weeks 3–12 · ~110 h

Learn to program properly before you learn to program games. Most people stuck on game development are actually stuck on programming.

CourseTimeWhy it's here

CS50x — Introduction to Computer ScienceHarvard ~80 h C, memory, pointers, data structures, algorithms. The memory weeks matter most here — games are one of the last fields where allocation still shows up in your frame time.

Godot — GDScript basicsGodot docs ~20 h A Python-like language you can be productive in inside a week. Learn one engine language well before shopping around.

Pygame documentationPygame ~10 h Optional. If CS50 leaves you wanting raw practice, Pygame hands you a loop and a surface and nothing to hide behind.

Build

feat: pong, from an empty file

Pong with no engine help beyond a draw call — paddles, ball, collision, score, restart. Write it twice: once in Python with Pygame, once in GDScript.

Done when

You can explain what a pointer is and why a dangling one crashes
You wrote a game loop by hand and can say what happens on each frame
Pong keeps score and resets cleanly without restarting the program

v0.3

Finished small games

weeks 13–20 · ~90 h

Finish things. The habit that separates people who ship games from people with forty prototypes is scope discipline, and it is learned early or not at all.

CourseTimeWhy it's here

CS50's Introduction to Game DevelopmentHarvard ~60 h Twelve games rebuilt from scratch — Pong, Flappy, Breakout, Match-3, Zelda, Mario, Angry Birds, Pokémon — in LÖVE and Unity. The best structured game course that is genuinely free.

raylib examplesraylib ~15 h A tiny C library with hundreds of readable examples. Ideal when you want to see how a feature works with no engine in the way.

itch.ioplatform ~15 h Not a course — a habit. Publish every finished game here, however small. A public shelf changes how you scope.

Build

release: three finished games on itch.io

Three complete games with a title screen, a lose state, a restart and a downloadable build. Complete beats ambitious — a finished Breakout teaches more than an abandoned RPG.

Done when

Three games are published and playable by a stranger with no instructions from you
Each has a menu, a fail state and a way to play again
You scoped at least one idea down mid-project and shipped the smaller version

v0.4

Engine fluency

weeks 21–30 · ~110 h

Go deep on one engine rather than shallow on three. Depth transfers between engines; breadth does not.

CourseTimeWhy it's here

Godot documentation — step by stepGodot docs ~40 h Scenes, nodes, signals, resources, the scene tree. Godot rewards reading the manual properly; most of its power is in composition.

Unity LearnUnity ~40 h Take this instead of the Godot track if you are aiming at industry jobs or mobile. Free pathways: Junior Programmer, then Creative Core.

Catlike Coding tutorialsJasper Flick ~20 h The deep end of Unity — meshes, procedural generation, rendering. Rigorous, free, famously well written.

Unreal Engine learningEpic ref The third option. Choose Unreal only if you are aiming at AAA or high-fidelity 3D; the curve is real.

Unity ManualUnity ref Reference, not reading. Learn to search it well.

Build

feat: a vertical slice, one level deep

One polished level of a game you would actually want to play — full loop, placeholder art but final layout, tuned controls. Not a whole game. One level, finished properly.

Done when

You can build a scene from scratch without following a tutorial
You understand your engine's update, physics and render ordering, and where your code runs in it
You can export a working build for at least two platforms

v0.5

Maths, physics and feel

weeks 31–38 · ~90 h

The maths a game needs is small, specific and unavoidable: vectors, matrices, interpolation, and integration over a timestep.

CourseTimeWhy it's here

The Nature of CodeDaniel Shiffman · free book ~35 h Vectors, forces, oscillation, particle systems, autonomous agents. Free to read in full, and the best on-ramp to simulation there is.

Gaffer On GamesGlenn Fiedler ~25 h Fix Your Timestep, integration basics, and the networked-physics series. The reference for why your physics misbehaves at different frame rates.

Red Blob GamesAmit Patel ~30 h Interactive explanations of pathfinding, A*, hex grids and noise. Read them with the sliders — that is the point.

Build

feat: it finally feels right

Take your v0.4 slice and tune it: fixed timestep, coyote time, input buffering, camera lerp, screen shake, easing on every transition. Same game, transformed.

Done when

Your game behaves identically at 30, 60 and 144 fps
You can implement A* on a grid without copying it
You can name five specific changes you made to improve game feel, and why each worked

v0.6

Graphics and shaders

weeks 39–48 · ~120 h

Understand the pipeline underneath the engine — what a draw call is, what the GPU does with it, and how to write the small programs that run per pixel.

CourseTimeWhy it's here

LearnOpenGLJoey de Vries ~50 h The clearest modern graphics course anywhere, and free. Getting Started through Advanced Lighting; PBR if you want it.

The Book of ShadersPatricio Gonzalez Vivo ~25 h Fragment shaders from first principles, live-editable in the page. Where shader intuition actually comes from.

Scratchapixelfree ~25 h The maths under rendering — rasterisation, ray tracing, shading models — derived rather than asserted.

MIT 6.837 Computer GraphicsMIT OCW ~20 h Lectures and assignments if you want the university treatment. Do the assignments or skip the course.

Build

feat: shaders written, not downloaded

A small renderer of your own — spinning lit mesh, texture, camera — plus five original shaders in your engine: dissolve, outline, water, hologram, and one of your own design.

Done when

You can explain the vertex → fragment path and what happens at each stage
You wrote a lighting model rather than dragging one onto a material
You can debug a shader that renders black instead of guessing at it

v0.7

Architecture that survives

weeks 49–56 · ~90 h

Small games forgive bad structure. The game you actually want to make will not. Learn the patterns the field converged on, and why it did.

CourseTimeWhy it's here

Game Programming PatternsRobert Nystrom · free book ~30 h Component, state machine, object pool, event queue, service locator, update method. Free in full, and the single most useful book on this list.

Handmade HeroCasey Muratori ~40 h A complete game written from scratch on stream — no engine, no libraries. Watch selectively: platform layer, memory arenas, the debug system. It rewires how you think about dependencies.

GDC Vault — free talksGDC ~20 h Postmortems and technical talks from people who shipped. Search for games you admire and watch what went wrong.

Build

refactor: it survives its own success

Refactor your vertical slice onto a real architecture — data-driven entities, a decoupled event system, saved state, and a debug overlay you can toggle inside a release build.

Done when

You can add a new enemy type without editing more than two files
Your game state saves and reloads exactly
You have an in-game debug overlay showing frame time and entity counts

v0.9

Ship, playtest, iterate

weeks 45–68 · alongside · ~60 h

Runs in parallel from v0.6 onward. Shipping is a skill practised separately from making, and playtesting is the only reliable source of truth about your game.

CourseTimeWhy it's here

GDC Vault — free talksGDC ~20 h Search “playtesting” and “postmortem”. Learn how studios run tests before you run yours badly.

itch.ioplatform ~20 h Devlogs, jams, and a page that sells the game in one screenshot. Enter at least one game jam.

Godot — exporting and deploymentGodot docs ~20 h Export templates, platform quirks, build size. Automate this early; manual builds are where release-day bugs live.

Build

chore: release pipeline

A repeatable build: one command produces versioned builds for two platforms, and a devlog entry goes out with each release.

Done when

You have watched a stranger play, in silence, taking notes
You entered a game jam and submitted before the deadline
A new build reaches players in under fifteen minutes of your time

v1.0

Capstone

weeks 57–68 · ~120 h

One game, finished, public, and played by strangers. This is the portfolio piece — the only artefact that reliably gets a game programmer hired.

CourseTimeWhy it's here

Your engine's manualreference — No new courses. You are building now; the manual is a lookup, not a curriculum.

itch.iorelease — Ship here first. Page, screenshots, a GIF, an honest description, and a downloadable build for two platforms.

GDC Vault — free talksGDC ref Watch a postmortem of a game the size of yours before you start, and another after you ship.

Build

release: v1.0

A finished game of deliberately modest scope — two to four hours of play, or twenty minutes done extremely well. Trailer, itch page, and a written postmortem in your game-log.

Done when

A stranger played it to completion without you in the room
It runs on two platforms from a single build process
You wrote a postmortem naming what you cut and what you would do differently
The source is public and someone else could build it from the README

From first pixel to shipped game.

The road, to scale

Ground rules that make this work

Toolbelt

Programming foundations

Finished small games

Engine fluency

Maths, physics and feel

Graphics and shaders

Architecture that survives

Ship, playtest, iterate

Capstone

Reference shelf