Pixels to Worlds

How to design Video Games

43 modules

174 lessons

—

Start the course

Part 1

Course Setup and the Incremental Ladder

Course Setup and the Incremental LadderSign in
Why "Pixels to Worlds"Sign in
How to Use This CourseSign in
The Incremental Ladder (Step 0 to Step 7)Sign in
The Course LensesSign in
Diagram Legend and Notation TypesSign in

Part 2

What Is a Game System?

What Is a Game System?Sign in
Games as Simulations and State MachinesSign in
Input -> Simulation -> RenderingSign in
Engine, Gameplay, Tools, ContentSign in

Part 3

Time, Frames, and Game Loops

Time, Frames, and Game LoopsSign in
Real Time vs Game TimeSign in
Fixed, Variable, and Hybrid TimestepsSign in
Frame Pacing and BudgetsSign in

Part 4

Coordinate Systems and 2D/3D Math

Coordinate Systems and 2D/3D MathSign in
Vectors, Matrices, TransformsSign in
Spaces and ConversionsSign in
Spatial Reasoning as an Engineering SkillSign in

Part 5

Diagramming Game Architectures

Diagramming Game ArchitecturesSign in
Loop and Update-Order DiagramsSign in
Scene Graphs and Entity GraphsSign in
System DiagramsSign in

Part 6

Input, Update, Render: The Core Cycle

Input, Update, Render: The Core CycleSign in
Input ModelsSign in
Separating Input and SimulationSign in
Rendering Sprites and BackgroundsSign in

Part 7

Time Steps and Determinism

Time Steps and DeterminismSign in
Fixed Timestep LogicSign in
Delta Time PitfallsSign in
When Determinism MattersSign in

Part 8

A Simple 2D Arcade Game

A Simple 2D Arcade GameSign in
Minimal ArchitectureSign in
Simple Collision and ResponsesSign in
Extensibility Without Over-EngineeringSign in

Part 9

2D Coordinate Systems, Layers, and Cameras

2D Coordinate Systems, Layers, and CamerasSign in
World vs Screen CoordinatesSign in
Parallax and Layered WorldsSign in
Camera MovementSign in

Part 10

Tiles, Grids, and Platforms

Tiles, Grids, and PlatformsSign in
Tile Maps as DataSign in
Platformer Collision ResolutionSign in
Integrating Tiles with EntitiesSign in

Part 11

2D Collision Systems

2D Collision SystemsSign in
Shapes and Overlap TestsSign in
Broad Phase vs Narrow PhaseSign in
Triggers, Hitboxes, HurtboxesSign in

Part 12

Scene and State Management

Scene and State ManagementSign in
Scene Stacks and TransitionsSign in
Cutscenes and Scripted SequencesSign in
Restarts and CheckpointsSign in

Part 13

UI, HUDs, and Layout Systems

UI, HUDs, and Layout SystemsSign in
UI Space vs World SpaceSign in
Layout and ScalingSign in
Input RoutingSign in

Part 14

Saving, Loading, and Persistence

Saving, Loading, and PersistenceSign in
Serializing State and ProgressSign in
Checkpoints vs SnapshotsSign in
Save Data VersioningSign in

Part 15

3D Coordinate Systems and Transforms

3D Coordinate Systems and TransformsSign in
3D Math PrimitivesSign in
Model/View/ProjectionSign in
Space TaxonomySign in

Part 16

Cameras, Projections, and View Frustums

Cameras, Projections, and View FrustumsSign in
Perspective vs OrthographicSign in
Camera RigsSign in
Visibility and CullingSign in

Part 17

Meshes, Materials, and Lighting

Meshes, Materials, and LightingSign in
Mesh Data and AttributesSign in
Materials and ShadersSign in
Lighting and ShadowsSign in

Part 18

3D Movement and Controls

3D Movement and ControlsSign in
Locomotion in 3DSign in
Camera-Relative ControlsSign in
Uneven Terrain and ObstaclesSign in

Part 19

Entity Models: OO vs ECS

Entity Models: OO vs ECSSign in
Game Objects and ComponentsSign in
ECS Trade-offsSign in
Messaging and EventsSign in

Part 20

Physics Engines and Simulation

Physics Engines and SimulationSign in
Rigid Bodies and ForcesSign in
Collision Shapes and MaterialsSign in
Tuning for FunSign in

Part 21

Animation Systems

Animation SystemsSign in
2D Animation: Flipbooks, Transitions, and Layering Animation With Gameplay StateSign in
Skeletal Animation: Rigs, Skinning, and Pipeline ConsistencySign in
Blend Trees and IK Basics: Control Systems for MotionSign in

Part 22

AI Basics: Behavior and Decision Making

AI Basics: Behavior and Decision MakingSign in
FSMs for Enemies: Predictable Behavior With Clear Debugging BoundariesSign in
Behavior Trees and GOAP: Scaling Decision Logic and Handling Combinatoric BehaviorsSign in
Scripts, Data-Driven, and ML-Based Behavior: Choosing the Right Abstraction and Safety LimitsSign in

Part 23

Navigation and Pathfinding

Navigation and PathfindingSign in
Grids vs Navmeshes: Modeling Walkable Space and the Cost of AuthoringSign in
A* and Variants: Heuristics, Performance, and Failure CasesSign in
Dynamic Worlds: Obstacles, Crowds, Steering Behaviors, and Preventing Jittery MotionSign in

Part 24

Level Design and World Structure

Level Design and World StructureSign in
World Structures: Linear, Hub, Open-World, Sandbox and How They Shape SystemsSign in
Pacing and Guidance: Difficulty Curves, Signposting, and Systemic Player LearningSign in
Encounters and Set Pieces: Scripting Versus Systemic Composition and ReuseSign in

Part 25

Assets: Art, Audio, and Data

Assets: Art, Audio, and DataSign in
Art Asset Types: Sprites, Meshes, Textures, Shaders and How Constraints Propagate to RuntimeSign in
Audio Systems: SFX, Music, Mixing, and Reactive Audio as Gameplay FeedbackSign in
Data Schemas: Items, Quests, Enemies, Progression and Why Data Modeling Is a Design ActSign in

Part 26

Editors, Tools, and Workflows

Editors, Tools, and WorkflowsSign in
Level Editors and In-Engine Tools: Authoring as Part of the Product, Not an AfterthoughtSign in
Data-Driven Design vs Hardcoding: Iteration Speed and Risk ContainmentSign in
Collaboration for Content: Version Control, Merges, and Workflows for Non-ProgrammersSign in

Part 27

Build Systems and Content Packaging

Build Systems and Content PackagingSign in
Import, Compression, Bundling: The Asset Pipeline as a Compiler for ContentSign in
Incremental Builds and Hot Reload: Iteration Time as a Strategic AdvantageSign in
Platform Packaging, Patches, DLC: Shipping and Updating Content SafelySign in

Part 28

Modding, Extensibility, and Scripting

Modding, Extensibility, and ScriptingSign in
Scripting for Game Logic: Why Scripting Boundaries Exist and How They Constrain Engine APIsSign in
Modder-Facing APIs: Stability, Safety, and Enabling Creativity Without Breaking SavesSign in
Sandboxing and Compatibility: Community Pipelines, Trust Boundaries, and Long-Term MaintenanceSign in

Part 29

Multiplayer Models and Architectures

Multiplayer Models and ArchitecturesSign in
Game Modes: Co-op, Competitive, Persistent Worlds and Their System ConsequencesSign in
Client-Server, Lockstep, Peer-to-Peer: Architecture Choices and the Failure/Cheat Surfaces They CreateSign in
Trust Boundaries: Authority, Validation, and Designing Against Cheating at a High LevelSign in

Part 30

State, Lag, and Synchronization

State, Lag, and SynchronizationSign in
Replication Basics: Snapshotting, Deltas, and Bandwidth as a Hard BudgetSign in
Prediction and Reconciliation: Making Latency Survivable Without Breaking FairnessSign in
Tick Rates and Scalability: Balancing Responsiveness, Cost, and CorrectnessSign in

Part 31

Matchmaking, Sessions, and Persistence

Matchmaking, Sessions, and PersistenceSign in
Lobbies and Sessions: Lifecycle Management and Failure HandlingSign in
Progress and Inventory Persistence: Consistency, Rollback, and Player TrustSign in
Cross-Play and Cross-Progression: Platform Constraints and Identity BoundariesSign in

Part 32

Online Services and Live Features

Online Services and Live FeaturesSign in
Leaderboards and Social Systems: Fairness, Abuse Surfaces, and IntegritySign in
Telemetry and Experiments: Analytics and A/B Testing Without Compromising GameplaySign in
Live Events and Seasons: Content Rollout Pipelines and Operational ReadinessSign in

Part 33

Security and Abuse Prevention

Security and Abuse PreventionSign in
Anti-Cheat Strategies: Client Hardening, Server Authority, and Trade-offsSign in
Rate Limiting and Moderation Tools: Abuse Detection, Enforcement, and Player SafetySign in
Privacy and Compliance Basics: Data Minimization and Operational Constraints for Live GamesSign in

Part 34

Game Engine Architecture

Game Engine ArchitectureSign in
Core Subsystems: Rendering, Physics, Audio, Input, Scripting, UI, and How They CoordinateSign in
The Main Loop with Many Systems: Update Ordering, Dependencies, and Debug VisibilitySign in
Plugins and Extensibility: Evolving Engines Without Rewriting the WorldSign in

Part 35

Cross-Platform Design and Performance Budgets

Cross-Platform Design and Performance BudgetsSign in
Platform Differences: PC, Console, Mobile, Web, and What They Imply for ArchitectureSign in
CPU, GPU, and Memory Budgets: Planning for Bottlenecks Rather Than Reacting to ThemSign in
Input, Resolution, and Profiles: Device Variability and Maintaining Consistent FeelSign in

Part 36

Telemetry, Balancing, and Live Ops

Telemetry, Balancing, and Live OpsSign in
Instrumentation for Decisions: Measuring What Players Experience, Not Just What Code DoesSign in
Balancing Systems: Rewards, Difficulty, Economies, and Designing for ChangeSign in
Live Ops Operations: Deployments, Rollbacks, Incident Handling, and Sustaining UptimeSign in

Part 37

Production, Teams, and Pipelines

Production, Teams, and PipelinesSign in
Roles and Interfaces: Engineering, Design, Art, Audio, QA, Production, and How Work FlowsSign in
Milestones and Deliverables: Prototypes, Vertical Slices, Alpha, Beta, Launch as Risk-Reduction StepsSign in
Technical Debt and Roadmaps: Refactoring, Post-Launch Plans, and Sustaining VelocitySign in

Part 38

Ethically Designing Engagement and Monetization

Ethically Designing Engagement and MonetizationSign in
Player-First Design: Avoiding Exploitative Patterns and Designing for Long-Term TrustSign in
Monetization Models: Cosmetic Versus Gameplay-Affecting and the Systems They Force You to BuildSign in
Communities and Reputation: Moderation, Communication, and Why Ethics Is Operational WorkSign in

Part 39

Game Loop and Simulation Patterns

Game Loop and Simulation PatternsSign in
Timesteps and Sampling: Fixed/Variable, Interpolation/Extrapolation, and Their ArtifactsSign in
Determinism Strategies: Deterministic Cores, Non-Deterministic Edges, and Debugging BenefitsSign in
Time Control Systems: Pausing, Time Scaling, Rewind, and the Architectural PrerequisitesSign in

Part 40

Architectural Patterns in Games

Architectural Patterns in GamesSign in
Scene Graph vs ECS vs Data-Oriented: Choosing a World Model That Matches Scale and ToolingSign in
Service Locator, Event Bus, DI: Dependency Patterns as Engine-Scale Coordination ToolsSign in
Scripting Boundaries and Engine APIs: Designing Stable Surfaces for Gameplay and ModsSign in

Part 41

UX, Feedback, and Game Feel

UX, Feedback, and Game FeelSign in
Responsiveness: Input Buffering, Latency Masking, and Perceived ControlSign in
"Juice" as System Design: Particles, Screen Shake, Sound, Haptics, and Budget-Aware ImplementationSign in
Accessibility and Options: Remapping, Difficulty, Visual/Audio Aids as First-Class FeaturesSign in

Part 42

Performance, Profiling, and Optimization

Performance, Profiling, and OptimizationSign in
CPU vs GPU Bottlenecks: Identifying the Limiter and Avoiding the Wrong OptimizationsSign in
Profiling and Hot Paths: Tools, Measurement Discipline, and Optimization PrioritiesSign in
Content-Side Optimization: LODs, Draw Calls, Occlusion, and Why Content Is Often the BottleneckSign in

Part 43

Reusable Patterns for Game Systems

Reusable Patterns for Game SystemsSign in
Common Systems: Inventory, Quests, Dialogue, Progression, and Their Data ModelsSign in
State Machines, Timelines, Events: Reusable Control Patterns Across GenresSign in
Portability of Patterns: Reusing Systems Across Platforms and Genres Without OverfittingSign in

Course overview