Program Video Games
Program Video Games
Structured Game Programming
The System Stack—a method for structuring your games so they don't fall apart 2 weeks in.
Before PVG, I could only see the end result. After, I could see the intermediate states of the code—start from known quantities and add things I could already picture.
— Raphaël Duchaîne (duchainer.itch.io)
Save $150 vs. $497 launch price • 14-day no-questions refund
Get instant access to:
Coming next:
Over 20,000 games released on Steam in 2025. Fewer than 3% cracked 1,000 reviews.
It's easier than ever to make games—we have libraries, engines, and now AI.
But there's a trap most devs fall into: **The Week 2 Wall**.
The Week 2 Wall feels like this:
That's why I built Program Video Games. I shipped my first public playtest on Steam—and I skipped my own method partway through (I got too excited).
Now I'm rebuilding the whole engine for release—using the method properly this time.
The System Stack is what I use to layout the game's structure before writing code. No more 2 week restarts.
And once your game is structured, new features don't break the old ones.
150 gamedevs (like you) have already joined me to get past the Week 2 Wall. I'd love for you to give it a try.
Cheers,
— Dylan Falconer
The Core Framework
Most code bases turn into an unmaintainable web of cross-dependencies. The System Stack enforces a strict, hierarchical blueprint based on low-coupling principles. Systems below never know about systems above them.
Providing deterministic execution paths that stay stable way past Week 2.
Just by skimming through some of the lessons I got a great overview of the concepts and patterns used in games (like event buffers or command buffers for inter-system communication). It gave me the structural clarity to write my own custom 2D physics engine using generational IDs.
— Stefan Partheym (github.com/stefanpartheym)
I'm not here to convince you not to use an engine—if using one does what you need, don't buy this course.
But if you've used one and still felt lost—like the engine is a black box and was making decisions you didn't understand—that's the problem this course fixes.
Engines hide structure from you. That's the trade you make: convenience now, no control later.
This course teaches you the structure the engine was hiding, so you actually understand what your game is doing.
Odin probably won't get you a job—that's not why you're here.
Odin is simple. It gets out of the way so you can learn structure, not language trivia.
No fighting with linker errors, no debugging crazy macros, no long build times. You write code and see what it does.
And the structural thinking transfers. Learn how to think about structure, and you can do it in C, C++, Zig, or Rust—whatever you like. The method isn't about language.
Probably because the course taught you to build one specific thing, then left you stuck the moment you tried to build something on your own.
Tutorial hell is finishing the tutorial and not knowing how to start your own game.
This course is built differently. You're learning a method (the System Stack) you apply across 4 genres. By the end you can structure your game, not just copy mine.
Lifetime access means no clock. Weekly calls mean when you're stuck, you talk to me and get unstuck instead of abandoning the project.
I won't pretend you'll ship games if you don't put the work in. But you won't get stuck because you don't know where things go—and that's the wall most people quit at.
14-day no-questions refund