Unreal Engine Technical Notes

Three goal-setting principles that keep you from quitting UE5, plus a three-phase roadmap from beginner to intermediate. Includes a hands-on mini project you can finish in your first week.

UE5 Core Concepts: Actor, Component, Blueprint, Level, and GameMode

The five core UE5 concepts to learn first: Actor, Component, Blueprint, Level, and GameMode. Their roles and relationships explained with diagrams, plus a hands-on breakdown of the Third Person template using all five terms.

Editor UI Basics: Using the Viewport, Outliner, and Details Panel

The roles of the UE5 editor's four main panels (Viewport, Outliner, Details, Content Browser) and the essential W/E/R/F shortcuts, explained with diagrams. Includes a hands-on run through all four panels.

Five Settings to Check Right After Creating a Project

Five settings to configure right after creating a UE5 project, explained with diagrams: source control and .gitignore, default maps, Enhanced Input, editor language, and lightening the editor load, with the reasoning and steps for each.

Sponsored

Asset Management Basics: Folder Structure and Naming Convention Best Practices

An illustrated guide to UE5 asset management that scales as your project grows: feature-based folder structure, prefix naming conventions, redirectors, and hard vs. soft references.

Getting Free Assets from Fab and Putting Them in Your Project

Basics2026-07-23

An intro to finding free assets on Fab, UE5's official store, and getting them into your project. Covers how the old Marketplace, Quixel, and Sketchfab merged, finding assets with the free filter, reading licenses, adding from Epic Games Launcher's Library, and the Migrate workflow for moving assets from a test project to production. We dress up a bare room with free props.

Debugging with Print String and the Output Log

An illustrated guide to UE5 debugging basics: Blueprint's Print String, the Output Log, and UE_LOG. Covers overwriting messages with Key, choosing a Verbosity, and a hands-on walkthrough of tracking down "it hits but deals no damage".

Seeing the Invisible with Draw Debug and Visual Logger: Ranges, Directions, and Paths On Screen

Basics2026-07-25

You can't tell how far Sphere Radius 800 actually reaches without looking at it. Using Draw Debug Sphere/Line/Cone/String, what Duration means, when the editor's built-in views are enough, and rewinding with Visual Logger — with a hands-on that finds why an AI won't react.

Sponsored

Grey-Boxing in Modeling Mode: Building Level Shapes Without an External DCC

Basics2026-07-23

An intro to grey-boxing, assembling level shapes inside UE alone without Blender. Covers the meaning of the step of checking size, height, and distance before looks, how to enter Modeling Mode (Shift+5), placing Box/Cylinder/Stairs, carving rooms with PolyEdit and Boolean, and a sense of dimensions based on the player capsule. We build a small watchtower as a grey box and make it climbable.

Understanding the Game Framework: The Roles of GameMode, GameState, and PlayerState

Basics2026-02-07

An illustrated guide to how GameMode, GameState, and PlayerState divide the work at the core of UE's Game Framework: how replication works in multiplayer, how a score reaches every screen, and a C++ walkthrough that builds the foundation of a team deathmatch.

Level Transitions in UE5: Open Level, Loading Screens, and Where Your Data Goes

From title to stage to results. The difference between Open Level (by Name) and (by Object Reference), what survives a level change and what doesn't, carrying a score over with GameInstance, and a practical workaround for the "my loading screen never shows" problem.

Managing UE Projects Safely with Git: .gitignore, LFS, and One File Per Actor

The right way to put a UE5 project into Git. Which folders you must never commit, what goes into .gitignore and .gitattributes, why .uasset needs Git LFS, why binaries can't be merged so you protect them with locks, and how One File Per Actor reduces conflicts.

Sponsored

Packaging in UE5: Turn Your Game into an .exe You Can Share

An illustrated walkthrough of UE5's Package Project. Covers the classic black screen caused by a missing Game Default Map, the difference between Development and Shipping, what's inside the output folder, and why unreferenced assets don't make it into the build.

Upgrading Your Project to a Newer UE Version Without Breaking It

Basics2026-07-25

UE ships a new major version about twice a year. How to decide whether to upgrade a project in progress, the duplicate-first rule, using Switch Unreal Engine Version, what to check in the Output Log right afterward, and the common breakages — with a full hands-on upgrade.

Automated Testing in UE: Stop Breaking What You Weren't Touching

Basics2026-07-25

With ten features, every fix means checking ten things. How to build a UE Functional Test (an Actor you place in a test level that runs and judges itself), write assertions, and run it from Session Frontend — with a hands-on that tests HP going 100 to 80 and deliberately turns it red first.

Building Your Own Editor Tools with Editor Utility Widgets

An introduction to Editor Utility Widgets, which let you extend the editor with Blueprint alone. Build a tool that batch-processes selected Actors at the press of a button, explained with both UI and node graph diagrams. Kill the tedium of bulk renaming and bulk placement.

Sponsored

UE Beginner Capstone: Finish One Complete Coin-Collecting Game

Basics2026-07-21

The capstone that ties every part you've learned into one game. Build a single stage where you collect 20 coins in 60 seconds, covering the coin Actor, score and remaining time in GameState, the HUD, clear/game over, high score saving, and packaging. Finishes with three additions that improve game feel.

Blueprint Variables 101: Class Variables vs Local Variables

Should a Blueprint variable be a Class Variable or a Local Variable? A visual breakdown by scope and lifetime, plus a hands-on section where you deliberately cause a loop accumulation bug and then fix it.

Blueprint Arrays, Sets, and Maps: Choosing the Right Container

When one variable isn't enough, containers take over. A visual guide to the differences between Array (ordered), Set (no duplicates), and Map (look up by key) plus their main nodes, with a hands-on inventory that counts item quantities with a Map.

Function vs Macro: How They Work and When to Use Each

A visual explanation of how Blueprint Functions and Macros differ under the hood. Covers the two decisive differences, whether Delay works and whether execution pins can branch, plus a hands-on skill cooldown built with both tools.

Sponsored

Level Blueprint vs Blueprint Class: The Difference and When to Use Each

A visual explanation of Level Blueprints and Blueprint Classes as a script and a part. Covers the decisive difference in reusability, the golden rule of things go in parts and staging goes in the level, and a hands-on trigger-opens-a-door setup.

Blueprint Components: A Design Pattern for Reusing Features

An illustrated guide to reusing features with custom Blueprint Components. Covers ActorComponent vs SceneComponent, a hands-on health Component you can attach to any Actor, and communication patterns that keep it dependency-free.

3 Ways Actors Communicate: Direct Reference, Interface, and Event Dispatcher

An illustrated guide to the three Blueprint Actor communication methods (Direct Reference, Interface, Event Dispatcher) using the metaphors of a direct line, a letter, and a radio broadcast. Includes a hands-on build that uses all three where they fit best.

How to Implement Event-Driven Design with Event Dispatchers

An illustrated guide to decoupling event sources from handlers with Event Dispatchers. Covers the three-step Blueprint rhythm of create, bind, and call, the crash you get from forgetting Unbind, and multicast delegates in C++.

Sponsored

Loose Coupling with Blueprint Interfaces and Cutting Down on Casting

The real problem with Cast To is hard references. An illustrated look at breaking the dependency chain with Blueprint Interfaces, a hands-on replacement of Cast-heavy damage logic, and verifying the result in the Reference Viewer.

Ditching Event Tick: Designing with Timers and Events

Event Tick runs every frame, and the cost multiplies fast. This article covers event-driven alternatives using Timer, Event Dispatcher, and Collision Events, plus a hands-on rebuild that puts a Tick-heavy guard AI to sleep.

10 Techniques for Organizing Blueprint Graphs

Ten techniques for making spaghetti Blueprints readable again, grouped into splitting, appearance, and names and values. Covers Reroute nodes, alignment shortcuts, naming conventions, and a hands-on 15-minute graph renovation.

Using Blueprint Debugger: Breakpoints and Step Execution

When Print String can't keep up with a bug, freeze time and inspect the scene directly. Covers setting breakpoints, choosing between Step Into/Over/Out, and narrowing down with Debug Object, plus a hands-on hunt for a zero-damage bug.

Sponsored

10 Common Blueprint Mistakes and Their Solutions

Overusing Tick, abusing Cast, hammering Get All Actors Of Class. This article sorts 10 common Blueprint mistakes into three groups (slow, fragile, unreadable) and ends with a health check that fixes one of your own Blueprints.

Health and Damage in UE5: Landing Hits with Apply Damage and Event AnyDamage

A visual guide to UE's standard damage pipeline. Covers the three Apply nodes (Damage / Point / Radial), the receiving Event AnyDamage, the difference between Damage Causer and Instigator, splitting attack types with Damage Type, and building the invincibility window that stops enemies from killing you instantly on contact.

Managing State with Enums and Switch: A Blueprint State Machine Primer

bIsAttacking and bIsDead end up true at the same time. Piling on booleans makes the combinations explode until the whole thing breaks. This article illustrates how Blueprint Enum and Switch on Enum narrow state down to one value, with a hands-on enemy AI that patrols, chases, searches, and returns home.

Rotation and Interpolation Basics in UE5: Rotator, Interp To, and Lerp

Blueprint2026-07-25

Your enemy snaps around instantly. Your turret spins the long way. An illustrated guide to Rotator vs. Quaternion in UE5, why rotating from 350 to 10 degrees goes backwards, and when to use RInterp To vs. Lerp, ending with a turret that smoothly swivels to track the player.

Sponsored

The UE5 Timeline Node: Move Doors and Fades Without Tick

A visual guide to the UE5 Timeline node. Covers the four track types (Float/Vector/Color/Event), when to use Play, Reverse, and Stop, curve interpolation modes, the standard pattern of pairing it with Lerp, where Timelines cannot be placed, and building an automatic door.

Getting Started with the Enhanced Input System: Input Actions and Mapping Contexts

Input2025-12-12

A visual guide to UE5's standard Enhanced Input, explained as a split between 'what you want to do' (IA) and 'which key does it' (IMC). Build WASD movement and jumping from scratch, then swap the entire control scheme the moment the player gets into a car.

Building a Key Config Screen in UE5: Rebinding and Saving Keys with Enhanced Input

Input2026-07-20

A visual guide to changing Enhanced Input key assignments at runtime. Mark rebindable rows with Player Mappable Key Settings, capture the pressed key with Input Key Selector, and persist it with Enhanced Input User Settings. Includes a hands-on settings screen that survives a restart.

Gamepad Support: Dead Zones, Device Detection, and Navigating UI with a Pad

Input2026-07-23

An intro to making a keyboard game playable on a gamepad too. Covers the basic of just adding pad keys to an existing Input Action, fixing stick drift that walks on its own with the Dead Zone modifier, handling triggers, detecting which device is in use to swap button prompts, and handing focus to the pad when a menu opens. We make a keyboard-only mini-game work on a gamepad too.

Sponsored

Simple vs Complex Collision and Performance Optimization

Physics2025-12-12

Your character sinks into a mesh, or the framerate tanks the moment you place one. The cause is the shape of the collision. A visual breakdown of Simple vs Complex alongside the four Collision Complexity settings, plus a hands-on fix for a rock you sink into that keeps it cheap.

Designing What Collides With What Using Collision Channels and Profiles

Physics2025-12-12

Custom collision channels are how you get 'friendly bullets pass through, enemy bullets don't.' A table-based breakdown of reading Object Types and Responses, plus a hands-on build of a shield that blocks only enemy fire.

UE5 Character Movement Basics: Speed, Jumping, and Gravity in the Character Movement Component

Physics2026-07-20

An illustrated look at why a UE Character moves out of the box, and where to change how it feels. What Max Walk Speed, Jump Z Velocity, Gravity Scale, and Air Control actually control, how Movement Modes switch, and why you should never move a Character with Set Actor Location.

UE5 Line Trace Basics: Using an Invisible Line to Find Out What's There

Physics2026-07-20

An illustrated guide to Line Trace in UE5. The difference between By Channel and By Object Type, how to build Start and End, what you get from the Hit Result, visualizing traces with Draw Debug Type, and when to reach for Multi Trace or Sphere Trace.

Sponsored

Shooting in UE5: Spawn Actor and Projectile Movement Basics

Physics2026-07-20

An illustrated guide to spawning actors at runtime in UE5. The five pins on Spawn Actor from Class, the Collision Handling Override that stops your bullets from appearing, the key Projectile Movement Component parameters, cleaning up with Life Span, and when to use Line Trace instead.

Physics Assets and Ragdolls: Building Death Reactions with Physics

Physics2026-07-23

An intro to solving the problem of defeated enemies vanishing while standing stiff, with ragdolls (collapsing via physics). Covers what a ragdoll really is (stopping animation and switching to per-bone physics), what a Physics Asset is, the three-set for ragdolling in Blueprint (Simulate Physics + Ragdoll profile + stopping Movement), and blasting enemies in the attack direction with Add Impulse. We build a death reaction where the enemy collapses in the direction you shot.

UMG Basics: Building a HUD with Widget Blueprints

UI2025-12-12

An illustrated walkthrough of getting an HP bar on screen with UMG, covering the Create Widget → Add to Viewport flow and how anchors work. Includes a hands-on build of a lightweight HUD that updates only when health changes, without relying on Binding.

UMG Is Slow and Focus Jumps Around: Controlling Selection and Optimizing Performance

UI2025-12-12

Selection gets lost when you use a gamepad, and the frame rate drops when you open a menu. This article illustrates how to fix both of UMG's biggest problems with Navigation settings, Invalidation Box, and Retainer Box, including a hands-on pause menu fix.

Sponsored

Overhead HP Bars and Damage Numbers: Building UI That Follows the World

UI2026-07-23

How to build the HP bar that floats above an enemy and the damage numbers that pop on a hit. Covers the difference between screen-pinned UI (Add to Viewport) and Actor-attached UI (Widget Component), choosing between Screen and World space, updating the bar with Get User Widget Object, and the lightweight screen-projection method for damage numbers. We build a scene where numbers rain during an enemy rush.

Pausing in UE5: Set Game Paused and UI That Moves in a Frozen World

An illustrated walkthrough of building a pause menu in UE5. Covers what Set Game Paused stops and what it doesn't, switching Input Mode and the mouse cursor, and why Enhanced Input goes silent while paused.

UE5 Settings Screens: Changing Resolution, Quality, and Volume with Game User Settings

An illustrated guide to building a UE5 settings screen with Game User Settings. Covers switching resolution and window mode, quality levels via Scalability, the difference between Apply Settings and Save Settings, and why volume takes a separate path.

Building a Dialogue System: Typewriter Text and Branching Choices

An illustrated guide to RPG and visual-novel dialogue: storing lines in a Data Table, revealing them one character at a time in UMG, and branching with choices. Covers two-stage advancing, stopping movement during conversation, and a hands-on branching NPC conversation.

Sponsored

Split-Screen Local Co-op: Building Two-Player Games with Create Player

An introduction to split-screen local multiplayer with UE5's Create Player node. Covers how adding a second player splits the screen automatically, setting the split orientation, and using Owning Player with Add to Player Screen to show UI only on one side. Far easier than going online.

Animation Blueprint Basics: State Machine vs. Blend Space

Animation2025-12-12

Animations snap instead of blending, and your graph fills up with branches. A State Machine switches to a different action, while a Blend Space mixes within the same action. This article breaks down the split with diagrams, plus a hands-on build of Idle/Walk/Run and jumping.

Animation Retargeting Basics: Moving Other People's Animations onto Your Character with IK Rig and IK Retargeter

Animation2025-12-12

Why the animation you downloaded from Mixamo doesn't work on your own character, and how to move it over with IK Rig and IK Retargeter. Covers chain definitions, Auto-Map, matching retarget poses, and fixing arms clipping into the body and feet sliding.

Animation Montage Basics: Playing Attack Motions and Timing Hitboxes with Notifies

Animation2026-07-20

Animation Montage handles the one-shot actions that State Machines struggle with. This article covers the classic stumble of forgetting the Slot node, how to time attack hitboxes with Anim Notify, and how to extend into combos with Sections.

Sponsored

Sequencer Basics: Building Cutscenes and Scripted Moments

Animation2026-07-20

An introduction to building cutscenes with UE5's Sequencer. Covers how it differs from the Timeline node, Level Sequence tracks and keyframe interpolation, Play and On Finished from Blueprint, and stopping input with Set Cinematic Mode. We build a boss-reveal camera sequence end to end.

Motion Matching Basics: Getting Modern Movement with the Game Animation Sample

Animation2026-07-23

An intro to Motion Matching, getting AAA-like smooth movement without fully understanding the theory. Covers the difference in thinking from State Machine, the roles of parts like Pose Search Database and Chooser, getting and touring Epic's official Game Animation Sample (GASP), swapping in your own character via retargeting, and the division with the traditional approach. We put our own character into GASP and try walking, running, and sharp stops.

Building Enemy AI with Behavior Trees: Patrol, Detect, Chase, Attack

AI2025-12-12

Behavior Trees let you build enemy AI without drowning in Branch nodes. This article diagrams the difference between Selector and Sequence, the role of the Blackboard, and when to use Decorators versus Services, with a hands-on build of a patrol-detect-chase-attack enemy from scratch.

NavMesh Settings and Optimization: Killing the Causes of Motionless AI

AI2025-12-12

Your AI won't take a single step, or it snags on walls. The cause is your NavMesh settings. This article covers checking the green floor with the P key, matching Agent settings to your character, and choosing a Runtime Generation mode, with a hands-on fix for AI that won't move.

Sponsored

Getting Enemies to Notice You with AI Perception: Sight, Hearing, and What Happens After Losing You

AI2026-07-20

Your enemy never notices the player, or spots them through walls. This article diagrams how to configure sight and hearing with UE5's AI Perception and receive detection and loss through On Target Perception Updated, with a hands-on build of a guard that searches the last known spot for 5 seconds before returning to patrol.

StateTree Basics: Choosing Between It and Behavior Tree

AI2026-07-23

An intro to StateTree, UE5's newer AI tool. Covers the difference in thinking from Behavior Tree (BT re-selects from the root by priority each time; StateTree transitions from the current state), the cast of State/Task/Condition/Transition, the steps to run it with a StateTree AI Component, and a decision table for which to choose. We rebuild the exact same patrol-chase-return guard from the Behavior Tree article in StateTree and line them up.

EQS Basics: Letting Enemies Choose a Good Position

AI2026-07-23

An intro to EQS (Environment Query System), letting enemies smartly choose where to move. Covers the three stages of generating candidate points, scoring them with tests, and selecting the best, the Generators like Points:Grid and Circle, the Distance/Trace/Dot tests, viewing scores as colored spheres with the EQS Testing Pawn, and using the result from a Behavior Tree's Run EQS Query. We build an enemy that hides behind cover when shot.

Sound Wave vs Sound Cue: Making Footsteps That Don't Sound Repetitive

Audio2025-12-12

The same footstep over and over sounds cheap. A Sound Wave is the audio itself; a Sound Cue is the blueprint for how it plays. This article shows how Random and Modulator kill repetition, with a hands-on footstep Cue built from scratch.

Sponsored

3D Sound and Mixing in UE5: Distance Falloff and Turning Down Just the Music

Audio2026-07-20

Sounds don't get quieter with distance, and you can't turn down just the music. This article covers UE5's distance falloff via Sound Attenuation, grouping volume with Sound Class and Sound Mix, and Submix and reverb, with a hands-on audio settings screen.

MetaSounds in UE5: How It Differs from Sound Cue and How to Change Sound from Outside

Audio2026-07-20

MetaSounds explained against Sound Cue. Where Sound Cue picks source audio, MetaSounds builds and processes sound. Covers creating a MetaSound Source, the Wave Player and Random nodes, trigger versus audio wires, and passing Inputs in to change a sound while it plays.

Music That Shifts When Combat Starts: Interactive Music with MetaSounds

Audio2026-07-25

Treating your soundtrack as stackable layers instead of one finished song. The difference between vertical layering and horizontal transitions, running several Wave Players at once in MetaSounds and moving only their gain, and pushing a value in with Set Float Parameter — with a hands-on where a combat layer fades in as an enemy spots you.

Material Basics: The Four PBR Pins and Material Instances

Rendering2025-12-12

You applied a texture and it still looks cheap, because every pin except Base Color is empty. This article explains what Metallic, Roughness, and Normal do, then walks through parameterizing a material and mass-producing color variants with Material Instances.

Sponsored

UE5 Lighting Basics: Four Light Types, Lumen, and Fixing a Dark Screen

A visual guide to UE5 lighting: choosing between Directional, Point, Spot, and Rect lights, what Mobility actually decides, Lumen being on by default, and how to stop auto exposure, the usual culprit behind a screen that stays dark.

Post Process Volume Basics: Setting the Mood with Exposure and Color

Rendering2025-12-12

You placed one and nothing happened, then dark areas brightened on their own. This article untangles the two classic Post Process Volume pitfalls, explains Unbound and Priority, and walks through building a cave that visibly changes the air when you enter.

Handling High-Poly Meshes with Nanite: No More Manual LODs

Rendering2026-02-07

Nanite frees you from trimming polygons to hit a budget. This article breaks down how it works, the three ways to enable it, and the limits that trip people up (like no Translucent support), plus a hands-on where you line up high-poly meshes and inspect them in visualization mode.

Building a Third-Person Camera with Spring Arm: Follow, Wall Avoidance, and Over-the-Shoulder

An illustrated guide to UE5's third-person camera built on Spring Arm. Covers the difference between Target Arm Length and Socket Offset, how Do Collision Test prevents clipping through walls, and the three flags that decide whether the body or the camera turns.

Sponsored

Niagara for Beginners: Modify a Template to Build an Explosion Effect

An illustrated guide to Niagara in UE5. Covers the System / Emitter / Module hierarchy, stack execution order, building from a template, the modules you'll actually touch, how materials fit in, and firing it from Blueprint with Spawn System at Location.

Hit Flash in UE5: Changing Colors at Runtime with Dynamic Material Instances

Changing material values at runtime requires a Dynamic Material Instance. This article illustrates how it differs from a regular Material Instance, how to use Create Dynamic Material Instance, Convert to Parameter on the parent material, and how to hold onto the instance instead of rebuilding it every frame. Includes a hands-on hit flash.

Landscape Basics: Build Terrain and Grow Vegetation on It

An introduction to building outdoor terrain with UE5's Landscape. Sculpt hills, paint grass and dirt with Layer Blend, and scatter trees with Foliage. Also covers the classic reason paint layers won't apply (no Layer Info) and why characters can't climb your hills (Walkable Floor Angle).

PCG Basics: Auto-Placing Forests and Paths by Rules

Rendering2026-07-23

An intro to PCG (Procedural Content Generation), scattering the decoration of a wide outdoor map by rules instead of by hand. Covers the division with the Foliage tool, the steps to grow trees with PCG Volume and Surface Sampler / Static Mesh Spawner, excluding cliffs with a slope filter, and Difference to remove trees only along a spline. We grow a forest on a hill with a graph that keeps trees off the path.

Sponsored

Making Hits Feel Good in UE5: Hitstop, Camera Shake, and Knockback

Solve the "my attacks don't feel like they connect" problem by layering effects. Covers the difference between Global and Custom Time Dilation for hitstop (including how timers get caught in the crossfire), Camera Shake with Start Camera Shake, and knockback via Launch Character, while delegating light, sound, and numbers to dedicated articles so you can focus on the mix.

Minimaps and Security Cameras with Render Targets: Putting a Camera Feed on Your UI

Rendering2026-07-25

How Scene Capture Component 2D and Texture Render Target 2D let you paint a camera feed onto UI or a material. Building a minimap, choosing Orthographic vs. Perspective, and controlling the cost of drawing the scene a second time — with a hands-on that builds both a minimap and a security monitor.

Grouping Data with Structs: Including the Value-Type Trap

Data2025-12-12

Too many variables make your graph unreadable. Group related values into a Struct. This guide illustrates Make/Break, the value-type trap where editing an array element seems to do nothing, and a hands-on walkthrough of designing item data.

Managing Parameters with Data Tables: Tune Your Game in CSV

Data2025-12-12

Stop opening Blueprints every time you tweak a number. This guide illustrates Data Tables built from a struct row shape and how to bulk-edit them in CSV, with a hands-on walkthrough of managing enemy parameters in a table and loading them on spawn.

Sponsored

Building Enemies and Items Data-Driven with Data Assets

Data2025-12-12

An illustrated guide to creating Data Assets and when to use them: the Blueprint-only workflow, how they compare with Data Tables, a hands-on build where one BP_Enemy covers every enemy type, and async loading with Primary Data Assets.

Implementing Save and Load with Save Game

Data2026-02-07

An illustrated guide to implementing save and load in Blueprint with UE's Save Game: the three steps of making, filling, and opening the box, a hands-on checkpoint respawn, why you must not save Actor references, and async saving.

Versioning Save Data: Shipping Updates Without Breaking Old Saves

Data2026-07-25

What happens to old saves when you add a variable to a SaveGame class? UE's default behavior (new variables fill with defaults), the real dangers of removing or retyping, why SaveVersion belongs there from day one, and the shape of a migration step — with a hands-on that adds a variable without breaking old saves.

Checkpoints and Respawning: Making a Game You Can Retry After Dying

Data2026-07-23

An intro to building the die-then-revive loop in UE5. Covers the four beats of death (effect, disable input, wait, revive), a checkpoint Actor that remembers your last spot, the two respawn methods (rebuild vs. reposition), handling the void with a Kill Volume, and the design call of resetting HP but keeping coins. We build a platformer where falling into lava sends you back to the last flag.

Sponsored

Carrying Data with Game Instance: The Storage That Survives Level Changes

Your score reset to 0 after a level change. Game Instance is the one container in UE5 that lives for the whole session. Covers creating it, registering it in Project Settings, reading and writing via Get Game Instance and Cast, Init/Shutdown, what belongs there and what does not, and how it differs from Save Game and Subsystems.

Building an Inventory System: Separate the Definition from What You Own

Build an inventory starting from splitting item definitions and owned state. Define items with Data Assets, hold counts in a Map, split it into an Inventory Component, and notify the UI with an Event Dispatcher, plus a hands-on minimal inventory where picking up, holding, using, and depleting all come full circle.

Building a Quest and Objective System: Making "Kill 3 Slimes" Work

Build the objective "kill 3 slimes" out of three parts: the definition (Data Asset), the progress state (GameInstance), and notification (Dispatcher). Narrow states to four with an Enum, advance the count from an enemy-death event, and separate reaching the goal from completing it to block double completion, with a hands-on quest that counts up as you kill.

Localization Basics: Shipping Your Game in Multiple Languages with the Localization Dashboard