Level 1 · Foundations
Godot & 2D Foundations
Meet the Godot editor, learn GDScript, and build real 2D games — movement, collisions, UI, animation, sound and tilemaps. By the end of Level 1 you can build and export a small complete 2D game to desktop.
A · Meet Godot
GD-L1-01Welcome to Godot
What a game engine is, install Godot 4.x, tour the editor, and run your first scene — a label that says hello.
The Scene Tree & the Inspector
Run It & Export It: Your First Playable
B · GDScript fundamentals
Your First Script: Hello from Code
Variables & Types
Maths & Comparisons
Making Decisions: if, elif, else
Repeating Yourself: for & while Loops
Lists of Things: Arrays
Labels & Lookups: Dictionaries
Functions: Your Own Commands
_ready() & _process(): Code That Runs Itself
Tweak Without Code: @export & the Debugger
C · 2D nodes & movement
Meet the 2D World: Node2D & Sprite2D
Showing a Character on Screen
The Input Map: Keys & Actions
Moving with Code: Velocity & delta
CharacterBody2D & move_and_slide()
Top-Down Movement (4 directions)
Platformer Movement: Gravity & Jump
Smooth Controls: Speed, Acceleration & Friction
D · Collisions & physics 2D
What Is a Collision Shape?
Detecting Overlaps with Area2D
Signals: Nodes That Talk to Each Other
Picking Up Coins (Area2D + signals)
Solid Walls & Floors (collision layers)
RigidBody2D: Letting Physics Take Over
Bouncing, Gravity & Mass
Groups: Tagging Many Nodes at Once
E · Scenes, instancing & UI
Reusable Scenes: Make a Prefab
Spawning with instantiate()
Shooting Bullets & Spawning Enemies
Control Nodes: The UI Layer
Labels, Buttons & a Score Display
A CanvasLayer HUD That Stays on Screen
F · Animation & audio
Frame-by-Frame: AnimatedSprite2D
The AnimationPlayer
Tweens: Smooth Movement & Effects
Sound Effects with AudioStreamPlayer
Background Music & Volume
G · TileMaps
Building Levels with TileMaps
TileSets, Collisions & Layers
H · Capstones
Capstone 1: One-Button Arcade Game
Capstone 2: Top-Down Coin Collector
Capstone 3: A Simple Platformer
Capstone 4: Polish, Menu & Export to Desktop
Assessment
Level Assessment
Coming soon
Level 2 · 2D Mastery
2D Mastery, Assets & Data
Architecture and game feel, a shaders intro, save/load, and a local database. Plus a full asset-creation strand — make your own pixel art, sound effects and music with free tools (and free AI tooling, used responsibly).
A · Architecture
Autoloads: Game-Wide Singletons
Signals, Deeper: Custom Signals & Buses
What Is a State Machine?
A Clean Player State Machine (idle / run / jump)
Organising Your Scenes & Folders
Custom Resources: Your Own Data Types
B · Game feel / juice
Juice: Why Games Feel Good
Tweens for Punch & Pop
Screen Shake & Hit-Stop
Particles with GPUParticles2D
Cameras, Zoom & Parallax Backgrounds
Lights & Mood with Light2D
C · Shaders intro
What Is a Shader?
Your First CanvasItem Shader
Uniforms: Controlling a Shader
Effects: Hit-Flash & Dissolve
A Simple Water / Wobble Shader
D · Save/load & settings
Where Games Save Data: user://
Saving with JSON
Loading & Restoring a Game
ConfigFile for Settings
A Settings Menu (volume, fullscreen)
Autosave & Checkpoints
Handling Missing or Broken Save Files
E · Game data & local database
Data-Driven Design: Items as Resources
What Is a Database?
Adding SQLite to Godot
Creating Tables & Inserting Data
Reading Data: Queries
A Local High-Score Leaderboard
An Inventory Backed by Data
F · Asset-creation strand
Free & Fair: CC0 Asset Libraries
Pixel Art Basics (Piskel / LibreSprite)
Colour, Palettes & Style
Sprite Sheets & Animation Frames
Drawing in Krita
Vector & UI Art with Inkscape
Sound Effects with jsfxr & Bfxr
Editing Audio in Audacity
Making Music with Bosca Ceoil / Beepbox
AI Asset Tools: Help & Honest Limits
Importing Assets into Godot
Building a Cohesive Art Style
G · Capstone
Capstone: Design Your 2D Game
Capstone: Build It with Your Own Assets
Capstone: Save System & Data
Capstone: Polish & Export
Assessment
Level Assessment
Coming soon
Level 3 · 3D
3D Game Development
Into the third dimension: 3D scenes, physics and lighting, importing models, animation trees, navigation and AI. Includes a 3D asset strand — model in Blender, plus free AI 3D and music tools. Build a complete 3D game.
A · 3D basics
Welcome to 3D: Scenes & Node3D
Moving in 3D: Transforms & Coordinates
Cameras & the 3D Viewport
Meshes & Primitives (MeshInstance3D)
Navigating & Building a 3D Scene
B · 3D movement & physics
CharacterBody3D: A 3D Player
First-Person Movement & Mouse Look
Third-Person Movement & Camera
Gravity, Jumping & Slopes
Collisions in 3D
Raycasting: Seeing & Shooting
C · Models & materials
Importing 3D Models (glTF)
Materials & StandardMaterial3D
PBR: Realistic Surfaces
Textures & UV Basics
GridMap: Building 3D Levels from Tiles
Combining Meshes & Scenes
Performance: Keeping 3D Light
D · Lighting & environment
Lights in 3D (Directional, Omni, Spot)
The WorldEnvironment
Sky, Fog & Atmosphere
Shadows: Realtime vs Baked
Global Illumination Intro
Setting a Scene's Mood
E · 3D animation
Importing Animated Models
The AnimationPlayer in 3D
AnimationTree & State Machines
Blend Spaces: Walk → Run
Skeletons & Bones (basics)
Triggering Animations from Code
F · 3D gameplay systems
Navigation: NavigationRegion3D
Enemy AI & Pathfinding
Patrol, Chase & Detect
Positional 3D Audio
A 3D HUD & Interaction
Pickups, Doors & Triggers in 3D
G · 3D asset creation
Blender Basics for Game Art
Modelling a Simple Prop
Materials & UV Unwrapping in Blender
Exporting from Blender to Godot
Voxel Art with MagicaVoxel
Free AI 3D Tools & Their Limits
Music & Ambience for a 3D World
H · Capstone
Capstone: Plan Your 3D Game
Capstone: Build the World & Player
Capstone: Enemies, Goals & Audio
Capstone: Polish & Export
Assessment
Level Assessment
Coming soon
Level 4 · Online & Ship
Multiplayer, Backend & Shipping
Build online multiplayer with Godot's high-level networking, stand up a game backend and database (Supabase / Nakama) for accounts and leaderboards, then publish to desktop, mobile and web. The capstone is a shipped multiplayer game in your portfolio.
A · Networking foundations
How Online Multiplayer Works
Client, Server & the Authoritative Model
Latency, Lag & Why It Matters
Godot's Networking, Top to Bottom
Peers, IDs & Who Owns What
B · Godot high-level multiplayer
Hosting & Joining over LAN
Remote Procedure Calls (@rpc)
Sending Player Input Across the Network
MultiplayerSynchronizer: Syncing State
MultiplayerSpawner: Spawning Players
A Two-Player Game (part 1)
A Two-Player Game (part 2)
Handling Joins, Leaves & Disconnects
Keeping the Server in Charge (anti-cheat mindset)
C · Online play
LAN vs Internet: Ports & Relays
WebSocket & WebRTC for Browser Games
A Simple Lobby
Matchmaking Basics
A Headless Dedicated Server
Hosting Your Server for Free (Render / Railway / Fly.io)
D · Backend & databases for games
What a Game Backend Does
Talking to the Web with HTTPRequest
Meet Supabase
Player Accounts & Sign-In
Saving Player Data to the Cloud
Online Leaderboards (part 1)
Online Leaderboards (part 2)
Keeping Keys & Players Safe (RLS)
Meet Nakama: A Game-First Backend
Choosing a Backend for Your Game
E · Publishing: desktop & web
Export Templates & Presets
Exporting for Windows, macOS & Linux
Icons, Names & Versioning
Exporting to the Web (HTML5)
Publishing on itch.io
A Great Store Page
Testing Your Build Before Release
F · Publishing: mobile & stores
Exporting for Android
Touch Controls & Screen Sizes
Performance on Mobile
Publishing to Google Play
iOS & the App Store (what you need)
Steam & Ethical Monetisation (intro)
G · Final capstone
Final Capstone: Design Your Online Game
Final Capstone: Build Multiplayer + Backend
Final Capstone: Ship to Desktop, Web & Mobile
Final Capstone: Portfolio & Showcase
Assessment
Final Assessment + Portfolio Review
Coming soon
Optional Modules · Industry Specialisation
Four 48-lesson modules for students who want to go deeper after L4. Optional— they sit outside the job-ready spine, so the core journey doesn't depend on them. Take any time once the prerequisite level is complete. Titles below are the planned syllabus; authoring follows the core.
Optional · Module 1
Online Multiplayer & Backend at Scale
Production netcode and backend ops, well beyond L4's intro: authoritative servers, lag compensation, matchmaking, Nakama in depth, leaderboards, anti-cheat and live-ops. Prereq: core L4.
A · Netcode foundations
Why Online Is Hard: A Netcode Map
Transports: ENet, WebSocket & WebRTC
Reliable vs Unreliable Messages
Bandwidth, Tick Rate & Snapshots
Designing Your Network Messages
Profiling Network Traffic
B · Authoritative servers & state sync
The Authoritative Server Pattern
Server-Owned Game State
Replicating State to Clients
Delta Compression & Snapshots
Interest Management
Handling Many Players
Server Tick Loop & Fixed Timestep
Reconnection & State Recovery
C · Lag compensation & prediction
Client-Side Prediction
Server Reconciliation
Entity Interpolation
Rollback Netcode: The Idea
A Simple Rollback Example
Hit Registration & Lag Compensation
Testing Under Simulated Lag
D · Matchmaking, lobbies & rooms
Lobbies & Rooms, Properly
A Matchmaking Service
Skill-Based Matchmaking Basics
Party & Invite Systems
Regions & Server Selection
Spectators & Late Joiners
Reconnect to a Match in Progress
E · Nakama in depth
Meet Nakama: Architecture
Running Nakama Locally (Docker)
Authentication & Accounts
Storage & Collections
Realtime Matches in Nakama
Authoritative Match Handlers
RPCs with Nakama
Notifications & Presence
Deploying Nakama (Heroic Cloud / self-host)
F · Leaderboards, tournaments & social
Global & Seasonal Leaderboards
Tournaments & Brackets
Friends & Social Graphs
Chat & Messaging
Cloud Saves & Cross-Device Play
G · Anti-cheat & security
Common Cheats & How to Stop Them
Validate Everything Server-Side
Rate Limiting, Bans & Reporting
H · Scaling, hosting & live-ops
Scaling Servers & Load
Live-Ops: Updates Without Downtime
Capstone
Module Capstone: Ship a Live Multiplayer Game
Coming soon
Optional · Module 2
Technical Art — Shaders, VFX & Advanced 3D
Godot's shading language in depth, compute shaders, post-processing, advanced lighting / GI, VFX and particles, plus optimisation and profiling. Prereq: core L3.
A · Shader foundations
How GPUs Draw: The Pipeline
The Godot Shading Language
Vertex vs Fragment Shaders
Coordinates, UVs & Time
Built-in Uniforms & Varyings
Maths for Shaders (vectors, dot, mix)
Debugging Shaders
B · 2D shader effects
Colour Grading & Tint
Outlines & Glow
Distortion & Heat Haze
Dissolve & Burn
2D Water & Reflections
Animated Sprite Effects
C · 3D shaders & materials
Spatial Shaders Explained
Custom 3D Materials
Normal Maps & Bumpiness
Triplanar & World-Space Mapping
Toon / Cel Shading
Fresnel & Rim Light
Vertex Animation (wind, waves)
Procedural Textures
D · Post-processing & screen effects
Screen-Reading Shaders
Bloom & Tonemapping
Depth of Field
Colour Correction & LUTs
Outline & Edge Detection (3D)
Screen-Space Effects (SSAO, etc.)
A Full Post-Process Stack
E · Advanced lighting & GI
Light Types, Deeper
Shadows: Quality & Cost
Baked Lightmaps
Voxel GI & SDFGI
Reflection Probes
Volumetric Fog & God Rays
F · VFX & particles
GPUParticles, Deeper
Particle Materials & Curves
Trails & Ribbons
Sub-Emitters & Collisions
Mesh & Attractor Particles
Compute Shaders: Intro
A VFX Library for Your Game
G · Optimisation & profiling
The Profiler & Frame Budget
Draw Calls, Batching & LOD
Texture & Memory Budgets
Optimising Shaders
H · Technical-art pipeline
Reusable Materials & Shader Libraries
A Consistent Look Across a Game
Capstone
Module Capstone: A Polished Visual Showcase
Coming soon
Optional · Module 3
Game AI & Procedural Generation
From finite state machines to behaviour trees and GOAP, steering and flocking, navigation in depth, and procedural generation (noise, dungeons, terrain), with a touch of ML for games. Prereq: core L3.
A · AI foundations
What "Game AI" Really Means
Sense → Think → Act
Designing Believable Enemies
Blackboards: Shared AI Memory
Debugging & Visualising AI
B · Finite state machines
FSMs, Robust & Revisited
Hierarchical State Machines
A Guard: Patrol / Alert / Chase
Stack-Based States
When FSMs Stop Scaling
C · Behaviour trees
Behaviour Trees: The Idea
Sequences & Selectors
Conditions & Decorators
Building a BT in Godot
Reusable BT Nodes
A Complex Enemy with a BT
BT vs FSM: Choosing
D · Utility & GOAP
Utility AI: Scoring Choices
A Utility-Driven Companion
GOAP: Goal-Oriented Action Planning
Actions, Goals & the Planner
A GOAP Agent in Godot
Mixing Approaches
E · Movement & steering
Steering Behaviours
Seek, Flee & Arrive
Wander & Patrol Paths
Flocking & Crowds
Obstacle & Wall Avoidance
Formations & Group Movement
F · Navigation & pathfinding, deep
A* From Scratch
NavigationServer, Deeper
Dynamic Obstacles & Re-pathing
Off-Mesh Links & Jumps
Flow Fields for Crowds
Performance: Many Agents
G · Procedural generation
Why Procedural? Random vs Designed
Randomness & Seeds
Noise: Perlin & Simplex
Procedural Terrain
Dungeon Generation (rooms & corridors)
Cellular-Automata Caves
Wave Function Collapse (intro)
Procedural Loot & Encounters
H · Light ML for games
Machine Learning in Games: When & Why
Decision Trees & Simple Learning
Reinforcement Learning: The Idea
A Tiny Learning Agent
Capstone
Module Capstone: A Smart, Generated World
Coming soon
Optional · Module 4
Ship It — Mobile, Polish & Monetisation
The full professional shipping pipeline: Android + iOS in depth, store optimisation, ethical monetisation, analytics, accessibility, localisation, porting and marketing a game. Prereq: core L4.
A · Production polish
From Prototype to Product
Menus, Pause & Game Flow
Settings That Players Expect
Save Slots & Cloud Sync
Error Handling & Crash Safety
A Polish Checklist
B · Accessibility & UX
Why Accessibility Matters
Colour-Blind-Friendly Design
Remappable Controls
Text Size, Subtitles & Readability
Difficulty & Assist Options
Onboarding & Tutorials
C · Localisation
Preparing a Game for Translation
Translation Files in Godot
Fonts & Right-to-Left
Localising for Malaysia & Beyond
D · Mobile: Android deep
The Android Pipeline
SDK, Keystores & Signing
Touch & Gesture Controls
Screen Sizes & Safe Areas
Performance & Battery on Mobile
Permissions & Privacy
APK vs AAB & Build Variants
Testing on Real Devices
E · Mobile: iOS deep
The iOS Pipeline (what you need)
Xcode, Certificates & Provisioning
Building for iPhone & iPad
TestFlight Beta Testing
App Store Requirements
iOS Performance & Quirks
F · Stores & ASO
Choosing Your Stores
Store Listings That Convert
Icons, Screenshots & Trailers
App Store Optimisation (ASO)
Ratings, Reviews & Updates
Steam & Steamworks, Deeper
G · Monetisation, ethically
Monetisation Models (fair vs unfair)
Premium & Paid Games
Ads, Done Respectfully
In-App Purchases
What to Never Do (dark patterns, gambling)
Pricing & Regional Fairness
H · Analytics, marketing & launch
Analytics: Measuring What Matters (privately)
Marketing on a Zero Budget
Building a Community
Your Launch Plan
Post-Launch: Updates & Live Support
Capstone
Module Capstone: Launch a Game to a Store
Coming soon