Free through lesson 3

Unreal Engine 5 Game Development

From installation through Blueprints, the Gameplay Framework, collisions and damage, materials with Nanite and Lumen, animation and AI, UMG and sound, working with C++, and finally optimization and packaging. Over 50 lessons, you'll build one complete third-person 3D action game, "Lighthouse Isle," where you explore an island at night. The first half uses Blueprints only; the second half drops down into C++.

Start from lesson 1 Unlock every course

Curriculum

The 50 lessons are split into seven chapters. We recommend working through them in order from chapter 1. You build one game, "Lighthouse Isle," across the whole course, so assets you make in one lesson are used in the next. Note: Unreal Engine can't run in the browser, so try everything in the editor you install in lesson 1 (Unreal Engine 5.6; 5.4 and later look almost the same). This course needs the heaviest setup of any course on the site (100 GB or more of free storage and a gaming-class GPU). Lesson 1 walks through the requirements. The prerequisite is basic C# or C, and from chapter 6 on you'll use C++.

Chapter 1 — Getting Unreal Running (lessons 1–8)

Install Unreal Engine and learn how to read the editor and how actors and components work. You'll learn to read and write Blueprints as a language in their own right, and finish by building a door that opens when you touch it.

1

What Is Unreal Engine? (Hardware Requirements and Installing It)

See the finished Lighthouse Isle and a map of all 50 lessons. Check the hardware you need, install UE 5.6 from the Epic Games Launcher, and open your first project.

Free
2

Reading the Editor (Viewport, Outliner, Details Panel, Content Browser)

Learn the editor as four areas, each with its own job. How to move the view, coordinates and units, testing with Play, and the shape of a project folder.

Free
3

Levels and Actors (Placing, Moving, and Building with Components)

Create the Lighthouse Isle level, L_Isle, and place a floor and walls by the numbers. Learn that an actor is a container of components, and assemble BP_Door, a door that swings on a hinge.

Free
4

Blueprint Basics (Event Graph, Nodes, and Execution Pins)

Read Blueprints as "programs you wire together." Execution starts at an event and follows the white exec pins. Make the lighthouse beam, BP_Beacon, turn using BeginPlay and Tick.

🔒 Basic
5

Variables, Functions, and Macros (Handling Values in Blueprints)

Give BP_Beacon variables for its speed and on/off state, and change them per beacon from the level. Split logic into functions, macros and custom events, and learn when to use which.

🔒 Basic
6

Flow Control (Branch, Loops, Sequence, Delay, and Timers)

Split with Branch and Switch, repeat with loops, order with Sequence, and write "later" with Delay and timers. Grasp that a loop finishes within one frame, then make the beam blink.

🔒 Basic
7

Receiving Input (Enhanced Input Actions and Mapping Contexts)

Define "actions" by name instead of checking keys directly. Create an Input Action and an Input Mapping Context, register it at runtime, and toggle the beacon with the E key or a gamepad.

🔒 Basic
8

[Practice] A Door That Opens When You Touch It (Triggers and Timelines)

Add a box trigger to BP_Door from Lesson 3 so it opens over 1 second as you approach and closes as you leave. Generate values over time with a Timeline, tying together Chapter 1's tools.

🔒 Basic

Chapter 2 — The Skeleton of a Game (lessons 9–17)

Following Unreal's framework of GameMode, PlayerController, and Character, you'll make the player walk, attach a camera, and add collisions and damage. Finally, you'll build the game's rule: collect three shards and the gate opens.

9

The Gameplay Framework Map (GameMode, GameState, PlayerController, Pawn)

Unreal splits a game's rules, state, the person playing, and the body into separate classes. Decide where each part of Lighthouse Isle belongs, then create BP_IsleGameMode and assign it to the level.

🔒 Basic
10

Making the Character Walk (Character and CharacterMovementComponent)

Create BP_Player from the Character class and learn its three parts: capsule, mesh, and CharacterMovement. Hook up IA_Move and IA_Look and walk relative to the camera.

🔒 Basic
11

Jumping, Dashing, and Crouching (Tuning Movement Feel with Numbers)

Shape the jump with Jump Z Velocity, Gravity Scale, and Air Control; build a dash by switching Max Walk Speed; and crouch with Crouch. Tune the feel with numbers, not guesswork.

🔒 Basic
12

The Camera (Building a Third-Person View with a SpringArm)

Put a Camera on the end of a SpringArm for a third-person view that doesn't clip into walls. Untangle the three rotations, then add camera lag and field of view.

🔒 Basic
13

How Collision Works (Collision Channels and Block, Overlap, Ignore)

Every object has an Object Type (what it is) and a response to each kind of other object: Block, Overlap, or Ignore. Learn how the pair decides the result, then make a preset for the shards.

🔒 Basic
14

Hit and Overlap Events (Picking Up, Bumping, Pushing)

Pick up light shards with On Component Begin Overlap, detect bumps with On Component Hit, and push physics boxes. Read what each event pin passes in, and prevent shards from being collected twice.

🔒 Basic
15

Communication Between Actors (Casts, Interfaces, Event Dispatchers)

Casts check a type and call directly; interfaces make the same request of any actor; event dispatchers announce what happened to whoever listens. Decide which fits where on Lighthouse Isle.

🔒 Basic
16

Damage and Health (From ApplyDamage to Falling and Respawning)

Apply Damage and Event AnyDamage are the engine's built-in damage contract. Give BP_Player health, make it fall at 0, and have the GameMode bring it back with Restart Player.

🔒 Basic
17

[Practice] Collect the Shards to Open the Gate (Putting the Rules in the GameMode)

BP_IsleGameMode listens to BP_Shard's OnCollected, counts, and opens BP_Gate when enough are collected. Tie this chapter's parts together while keeping the rules out of the shards and the gate.

🔒 Basic

Chapter 3 — Visuals (lessons 18–27)

Build the look with materials, models brought in from Blender, Nanite and Lumen, sky and fog, terrain and foliage, and post-processing. Finally, you'll put together the lighting for Lighthouse Isle at night.

18

Material Basics (PBR Values and the Material Editor)

A surface's look is mostly decided by four inputs: Base Color, Metallic, Roughness, and Normal. Wire nodes in the Material Editor and make the shard glow with Emissive.

🔒 Basic
19

Material Instances and Parameters (Variations from One Parent)

Turn values into parameters on a parent material and mass-produce variations without recompiling. Also use Dynamic Material Instances to change values during play.

🔒 Basic
20

Bringing Models from Blender (FBX Export, Scale, Axes, Collision)

Match Blender's 1 m to Unreal's 1 cm, fix orientation and origin, and export as FBX. Bring your own collision along with UCX_ meshes.

🔒 Basic
21

Nanite (Where You Can Stop Worrying About Polygon Counts, and Where You Can't)

Nanite draws high-density static meshes only as much as is visible. It suits rocks and cliffs, not translucency or deforming shapes. Covers enabling it and checking it works.

🔒 Basic
22

Lumen (Dynamic Global Illumination and Reflections)

Lumen computes bounced light and reflections live, without baking. Covers software vs. hardware ray tracing, how it behaves on Mac, and fixing light leaks.

🔒 Basic
23

Light Types and Mobility (Directional, Point, Spot, Rect, and Sky Light)

When to use each of the five light types, and the difference between Static, Stationary, and Movable. With Lumen, Movable is the default choice. We also build the lighthouse's rotating beam.

🔒 Basic
24

Sky, Atmosphere, and Fog (Sky Atmosphere, Volumetric Cloud, Height Fog)

A sky whose color follows the Directional Light, volumetric clouds, and fog that thickens with height. Build the night island's backdrop and make the lighthouse beams show up in the fog.

🔒 Basic
25

Landscape and Foliage (Shaping the Island and Scattering Grass and Rocks)

Sculpt the island's terrain with Landscape and paint grass, rock, and sand layers. Grass grows automatically with a Landscape Grass Type; rocks are placed by hand in Foliage mode.

🔒 Basic
26

Post Processing (Exposure, Bloom, Color Grading)

Adjust exposure and color on the finished image like a camera does. How to stop auto exposure from making night look like day, using bloom to make shards glow, and color adjustment.

🔒 Basic
27

[Hands-on] Lighting Lighthouse Isle at Night (Assembling the Lighting)

Finish the night lighting by setting moon, sky, fog, and exposure first, then adding the shard and lighthouse lights. Also build the LightUp event that lights the lighthouse.

🔒 Basic

Chapter 4 — Bringing It to Life (lessons 28–35)

Put together character animation with blend spaces and state machines, and add attacks with montages. You'll learn physics, navigation meshes, and behavior trees, and finish by building the AI for a warden that patrols the island.

28

Skeletal Mesh and Animation Basics (Skeletons and Sequences)

Learn that animation is split into three assets: the boned mesh, the bone hierarchy, and the motion data. Then swap BP_Player's capsule look for a mannequin.

🔒 Basic
29

Animation Blueprints and Blend Spaces (From Walking to Running)

Build ABP_Player, which reads speed every frame, and BS_Locomotion, which blends idle, walk, and run over speeds 0-600, then tune the numbers to stop foot sliding.

🔒 Basic
30

State Machines (Idle/Move, Jump, Fall, Land)

Put a Locomotion state machine in the AnimGraph and split ground, jump start, fall, and land into states and transition rules, written only with variables gathered in the Event Graph.

🔒 Basic
31

Montages and Notifies (Syncing the Swing with the Moment of Impact)

Turn the attack into the montage AM_Attack layered through a Slot, check for hits only at the Anim Notify, and feed ApplyDamage. Also covers swinging with the upper body only.

🔒 Basic
32

Physics (Simulation, Constraints, and Chaos Destruction)

Roll crates with Simulate Physics, swing a hanging lantern with a Physics Constraint, and break an old fence with a Geometry Collection. Also make a ragdoll for the fallen player.

🔒 Basic
33

Navmesh and AI Movement (AIController and MoveTo)

Lay down the walkable area with a NavMeshBoundsVolume, drive BP_Warden with BP_WardenAIController, and use AI MoveTo to visit patrol points in order.

🔒 Basic
34

Behavior Trees and Blackboards (Patrol, Detect, Chase)

Split decisions into BT_Warden and memory into BB_Warden. Use Selector and Sequence plus custom tasks, decorators, and services to switch between patrolling and chasing.

🔒 Basic
35

[Practice] Build a Warden That Patrols the Island (Detecting with AI Perception)

Give BP_WardenAIController AI Perception sight, and finish a warden that chases when it spots you, searches where it lost you, and attacks when it catches up.

🔒 Basic

Chapter 5 — UI and Sound (lessons 36–41)

Build the HUD and menus with UMG, add screen transitions and saving, and make sounds play. Finally, you'll run the whole flow from the title screen to the ending in one go.

36

UMG Basics (Widget Blueprints and Anchors)

On-screen UI is built with UMG Widget Blueprints. Place parts on a Canvas Panel, use anchors to decide which part of the screen they hang from, and let DPI scaling absorb resolution differences.

🔒 Basic
37

Building the HUD (Updating Health and Shard Count with Events)

Connect the health bar and shard count to real values. Instead of property bindings that read every frame, update only on change with event dispatchers, and let the player controller own the HUD.

🔒 Basic
38

Menus and Screen Flow (Title, Pause, and Switching Input Modes)

Make a title level and WBP_Title, then move to the island with Open Level. Build pause from Set Game Paused plus switching input modes (UI Only / Game Only / Game and UI).

🔒 Basic
39

Saving and Loading (SaveGame Objects)

Make BP_IsleSave holding only the values you want to keep, and read and write it with Save Game to Slot, Load Game from Slot, and Does Save Game Exist. The Game Instance carries it across levels.

🔒 Basic
40

Sound Basics (Sound Waves, Attenuation, and MetaSounds)

Sound assets come in three layers: Sound Wave, Sound Cue, and MetaSound Source. Play sounds in 2D or 3D, fade them with distance via Attenuation, and vary footsteps with MetaSounds.

🔒 Basic
41

[Practice] From Title to Clear (Finishing with BGM and the Mixer)

Wire up the whole flow: light the lighthouse, show the clear screen, return to the title. Group BGM, effects, and ambience with Sound Classes and Mixes, and shift the balance at pause and clear.

🔒 Basic

Chapter 6 — Dropping Down to C++ (lessons 42–47)

Add C++ to the project you built with Blueprints. You'll learn what UCLASS and UPROPERTY mean, how garbage collection works, how to split work between Blueprints and C++, and how builds work, and finish by moving the health system into a C++ component.

42

Turning the Project into C++ (IDEs and the Build Flow)

Add C++ to Lighthouse Isle, which so far is Blueprint-only. Set up an IDE, create the LighthouseIsle module with New C++ Class, and learn the flow from build to editor launch.

🔒 Basic
43

Your First C++ Actor (UCLASS, UPROPERTY, UFUNCTION)

Write ALighthouseLamp, the lighthouse's rotating beam, in C++. See what the UCLASS, UPROPERTY, and UFUNCTION markers make visible to the editor and Blueprints.

🔒 Basic
44

Reflection and Garbage Collection (UObject and TObjectPtr)

The reflection data UHT generates powers the Details panel, Blueprints, saving, and GC. Learn why you hold UObjects with UPROPERTY, and when to use TObjectPtr versus TWeakObjectPtr.

🔒 Basic
45

Dividing Work Between Blueprints and C++ (BlueprintCallable and BlueprintImplementableEvent)

Let Blueprints call C++ and C++ call Blueprints. Tie the lighthouse lighting to its effects with BlueprintImplementableEvent, BlueprintNativeEvent, and dynamic delegates.

🔒 Basic
46

Modules and Builds (.Build.cs, Live Coding, and Common Build Errors)

Declare the engine features you use as dependencies in .Build.cs. Separate changes Live Coding can handle from ones that need closing the editor and rebuilding, and learn to read common build errors.

🔒 Basic
47

[Practice] Moving the Health Component to C++

Move BP_Player's health, held in Blueprints since lesson 16, into a C++ UHealthComponent. Receive damage via OnTakeAnyDamage and notify the HUD and death logic with delegates.

🔒 Basic

Chapter 7 — Finishing and Shipping (lessons 48–50)

Track down what's slowing the game with the profiler and fix it, then package it into a form you can distribute. Finally, look back over the whole course while comparing Unreal with Unity and Godot.

48

Optimization and Profiling (stat Commands and Unreal Insights)

When Lighthouse Isle runs slowly, use stat unit to find whether Game, Draw, or GPU is the bottleneck, then drill down with Unreal Insights. Also: common causes and scalability.

🔒 Basic
49

Packaging (Release Builds and Per-Platform Requirements)

Make Lighthouse Isle launch on a PC without the editor: Development vs. Shipping, which maps to include, Mac signing and notarization, and Windows prerequisites.

🔒 Basic
50

How Unreal Differs from Unity and Godot (Wrap-Up and What's Next)

Map Unreal concepts to Unity and Godot, decide which engine fits which job, think about licensing, look ahead to GAS, replication, and PCG, and look back on all 50 lessons.

🔒 Basic

Once you've finished all 50 lessons, try the same ideas in another engine with the Unity Game Dev Intro Course or Godot for Beginners, or learn to make your own models and animations in Blender Python for Beginners. A membership unlocks every course.