Free through lesson 3

Godot for Beginners

From installation through scenes and nodes, GDScript, input and physics, collisions and signals, tilemaps, the HUD and save data, a first look at 3D, and exporting. Over 30 lessons, you'll build one complete 2D game and publish it so anyone can play it in a browser. Every version number, output, error message, and exported file size is measured from actually running Godot 4.7.2.

Start from lesson 1 Unlock every course

Curriculum

The 30 lessons are split into six chapters. We recommend working through them in order from chapter 1, but feel free to jump to whatever interests you. Note: GDScript can't run in the browser, so try the code in the Godot 4.7.2 editor you install in lesson 1. Only the lesson comparing GDScript with Python lets you run the Python versions right on the page. The prerequisite is basic Python; GDScript looks a lot like Python.

Chapter 1 — Getting Godot Running (lessons 1–5)

Install Godot and learn how to read the editor and how scenes and nodes work. By the end, you'll be able to explain GDScript's syntax and how it differs from Python in your own words.

1

What Is Godot? (Install It and Make Sure It Runs)

See what a game engine handles for you, install Godot 4.7.2, and run a GDScript file from the terminal without opening the GUI.

Free
2

Reading the Editor and the Shape of a Project

Learn the screen as four areas. A project is really just one text file, project.godot, with two entry points: res:// and user://.

Free
3

Scenes and Nodes (Building a Game as a Tree)

Nodes are parts; a scene is a tree of parts. Walk it with get_node and handle nodes in bulk with groups. Some methods only work once a node is in the tree.

Free
4

GDScript Syntax (Variables, Functions, Control Flow)

Indented blocks, type inference with :=, match, dictionaries and arrays. Then we measure whether adding types makes code faster.

🔒 Basic
5

Differences from Python (Same Look, Different Results)

7 / 2 gives a different answer. Booleans are spelled differently. No comprehensions. Run both languages side by side to catch the traps Python users fall into.

🔒 Basic

Chapter 2 — Making Things Move (lessons 6–12)

Take input, make a character walk and jump, and have it pick up coins. Finally, learn to connect nodes loosely with signals.

6

Attaching a Script (_ready and _process)

Scripts are the only way to add behavior to a node. _ready runs once, _process every frame, _physics_process 60 times a second. Plus why you multiply by delta.

🔒 Basic
7

Handling Input (InputMap and Actions)

Don't check key codes directly. Go through action names, and keyboard and gamepad work with the same code. Covers get_axis and get_vector.

🔒 Basic
8

Sprite2D and Coordinates (Drawing, Placing, Layering)

Y points down. Positions are relative to the parent; global_position is the absolute position on screen. Draw order follows the order in the tree.

🔒 Basic
9

Walking with CharacterBody2D (move_and_slide)

Set velocity and call move_and_slide(), which takes no arguments. Why the body slides along walls, and adding acceleration with move_toward.

🔒 Basic
10

Gravity and Jumping (is_on_floor and Picking a Jump Speed)

Add gravity to velocity.y every frame. You can calculate jump height from the initial speed. Use is_on_floor so holding the button doesn't keep you flying.

🔒 Basic
11

Collision Detection with Area2D (Picking Up Coins)

Use Area2D when you only want to know that something touched, without pushing back. body_entered vs. area_entered, and queue_free after pickup.

🔒 Basic
12

Signals (Don't Wire Nodes Directly Together)

The emitter doesn't know who's listening. Use connect, bind, CONNECT_ONE_SHOT, and await to keep dependencies flowing one way.

🔒 Basic

Chapter 3 — Turning It into a Game (lessons 13–19)

Split the game into screens, carry the score across them, spawn enemies automatically, build stages from tiles, and play sounds. This chapter gives you everything a playable game needs.

13

Switching Scenes (From Title Screen to Game)

change_scene_to_file schedules a swap for the next frame. The old scene is removed entirely, so values you want to keep need somewhere to live.

🔒 Basic
14

Keeping Score and State in an Autoload

Place one node that survives scene changes. You can reach it by name from anywhere, but if you put everything in it, everything depends on it.

🔒 Basic
15

Spawning Enemies with PackedScene (instantiate and queue_free)

Load a scene as a blueprint and create instances with instantiate(). Add with add_child, remove with queue_free. Anything that comes and goes follows this pattern.

🔒 Basic
16

Spawning Enemies Automatically (Timer and Randomness)

Use a Timer for fixed intervals and RandomNumberGenerator for variety. Fix the seed and enemies appear in the same order every time, so you can reproduce bugs.

🔒 Basic
17

Building Stages with TileMapLayer

Since Godot 4.3, TileMap has been split into TileMapLayer. Converting between cell and world coordinates, adding collisions, and finding the used area.

🔒 Basic
18

Collision Layers and Masks (Check Here When Things Don't Collide)

layer is "what I am"; mask is "what I look for." They're stored as bits, so you can check them as numbers. Plus RayCast2D for checking the ground and line of sight.

🔒 Basic
19

Playing Sound (AudioStreamPlayer and Buses)

2D sound and non-positional sound use different nodes. Playing sounds at once takes a special setup. Volume is in dB, and half volume is -6 dB.

🔒 Basic

Chapter 4 — UI and Saving (lessons 20–24)

Build a HUD and menus with Control nodes, and let players pick up where they left off after closing the game. Finally, move tuning numbers out of your scripts.

20

Control Nodes and Anchors (Layouts That Survive Screen Resizes)

Build UI with Control, not Node2D. Anchors say "which part of the screen to measure from"; offsets say "how far to shift from there."

🔒 Basic
21

Building a HUD (CanvasLayer and Score Display)

Put the HUD in a CanvasLayer to detach it from the camera, and update values through signals. Ends with an HP bar built from ProgressBar's ratio.

🔒 Basic
22

Menu Screens (Buttons, Focus, Pausing)

Button's pressed signal, automatic layout with Containers, and focus so menus work with a gamepad. Ends with process_mode for a pause menu.

🔒 Basic
23

Save Data (JSON and user://)

You can only write to user://. JSON is readable, but every number becomes a float. Use store_var to keep types. Plus handling corrupted files.

🔒 Basic
24

@export and Resource (Getting Numbers Out of Your Code)

@export variables show up in the Inspector. Bundle enemy parameters into a Resource and they become data you can swap in the editor.

🔒 Basic

Chapter 5 — A Taste of 3D (lessons 25–27)

See for yourself that what you learned in 2D carries straight over to 3D. The chapter ends with a hands-on exercise: make a 3D character walk and land.

25

Building a 3D Scene (Mapping What You Learned in 2D)

Node names just gain a 3, and the ideas stay the same. But units change from pixels to meters, and default gravity goes from 980 to 9.8.

🔒 Basic
26

Cameras and Lights (Why Your 3D Scene Is Pitch Black)

Seeing nothing in 3D almost always comes down to three causes: no camera, no light, or no environment. Call look_at after adding the node to the tree.

🔒 Basic
27

[Hands-On] Making a Box Walk in 3D (CharacterBody3D)

Port your 2D movement code to 3D. Adjust the numbers to the new units and convert input to a Vector3. Then measure the box falling and landing.

🔒 Basic

Chapter 6 — Shipping It (lessons 28–30)

Export for desktop and for the web, and get a URL other people can play at. Finally, sort out when to choose Godot versus Unity or Unreal, and set yourself up for your next game.

28

Exporting (Making Something Others Can Play)

Install export templates, create a preset, and export from the command line. When it fails, the error message tells you exactly how to fix it.

🔒 Basic
29

Publishing to the Web

A browser-playable build is the easiest to share, with three conditions: rendering method limits, a 37 MB wasm file, and server headers.

🔒 Basic
30

Godot vs. Unity and Unreal, and What's Next

It's not about which engine is better, but what you're making and your situation. An honest list of where Godot fits and where it doesn't. A wrap-up of all 30 lessons.

🔒 Basic

Once you've finished all 30 lessons, try the Unity Game Dev Intro Course, where you build a complete 3D racing game, or Blender Python for Beginners, where you learn to make your own characters and backgrounds. A membership unlocks every course.