A long-term engineering project · a new standard, started from scratch

Unreal Engine 5 C++: tutorials, architecture, and practice

Learn Unreal Engine 5 C++ with a practical course and engineering tutorials on UObject, memory, gameplay, replication, GAS, and engine source code.

Learn C++ for Unreal Engine 5 through engineering explanations, source-code examples, and practical projects. Each topic explains not "what to use", but "why it exists", "what problem it solves", "how it works under the hood", and "when you shouldn't do it this way". The goal is that after reading a topic, no logical question is left unanswered, and that you learn to arrive at Epic's architectural decisions yourself rather than memorizing them as a list of facts.

Learning

Encyclopedia explains how the engine works to someone who already writes C++. Learning takes you from zero: a gradual path from your first program to professional C++ for Unreal Engine 5.8, with explanations, self-checks, and hands-on assignments.

🎓

Learning: C++ → Unreal Engine 5.8

21 stages (204 lessons) — from Programming Basics to the final multiplayer project Novarium.

How each topic is structured

A flexible standard: 12 mandatory sections for any topic + sections that appear automatically if the topic naturally generates them — without artificial items like "Impact on Multiplayer" in an article about const.

What is it?

A brief orienting statement before the deep dive.

Why does it exist?

Problem → reason, not a fact without context.

What problem does it solve?

A concrete, reproducible scenario of a naive approach breaking.

How does it work?

Constraints → architectural decision → implementation, with examples from Engine Source.

When to use / not to use

Applicability boundaries — without them, a topic breeds cargo cult.

Examples

Fully working code with line-by-line breakdown — pseudocode is forbidden.

Common mistakes

Separately for beginners and mid-level developers, with an explanation of the failure mechanism.

Practice

Assignments that force you to reproduce the reasoning, not copy the example.

FAQ

Questions that an attentive reader actually asks.

Summary

Statements the reader should be able to articulate in their own words.

+ as needed

GC, Reflection, Blueprint, Multiplayer, serialization, performance — if the topic naturally generates them.

Before you start

A compass over the entire course — not a topic, but a way of thinking that repeats in every subsequent topic.

💡

How Unreal Engine Thinks — the engine's philosophy

Twelve cross-cutting "Whys" (UObject, pointers, GC, Reflection, Component, Composition, Modules, Plugins, Subsystem, Gameplay Tags, Data Assets, Primary Assets) in one place — read this page first, and every new course topic will be recognized as a variation of an already familiar line of reasoning, not a new set of facts.

The reference article

The gold standard of quality and depth for the whole project — worth starting with even if you are already an experienced developer.

★

How Unreal Engine Works: not an API, but engineering thinking

Engine → Framework → why UObject → why Reflection → why Garbage Collector → why the macros appeared → how it all connects into a single chain of causes. After this article, the rest of the course reads not as separate facts, but as applications of one and the same way of reasoning.

Roadmap — 9 levels

Nine sequential levels instead of sixteen disconnected clusters — each next level is explained through the previous one, not on its own. The only exception is Level 5: its six applied systems run in parallel, not in order.

Level 0 — How Unreal Thinks

Why the rest of the course exists at all: when Epic's documentation is still enough, and when it's time to open the engine source, and how to physically navigate .h/.cpp files even before you know what UObject is.

Epic Documentation: when it's enough How to Read C++ Code: a minimal vocabulary How to Read an Engine .h File How to Read an Engine .cpp Public/Private/Classes How to Trace a Dependency

Level 1 — Object System

Builds on Level 0 — after it, every UCLASS()/UPROPERTY() is explained as a concrete consequence of Reflection, Garbage Collector, Package, and CDO, not as magic syntax.

UObject: object architecture Class Default Object (CDO) UObject::Outer Reflection Garbage Collector UPROPERTY UFUNCTION UINTERFACE EObjectFlags FName / FString / FText UPackage Asset Registry UStruct: the common class under the hood TSubclassOf<T> Cast<> vs dynamic_cast NewObject / CreateDefaultSubobject UObject in memory

Level 2 — Runtime Objects

Builds on the Object System — first the Actor itself and its components, and only when the question "how to store a list of components" naturally arises, the tools: TArray/TMap and the two disjoint worlds of pointers.

Actor Lifecycle UActorComponent Transform and RootComponent Tick SpawnActor and Destroy Owner and GetOwner() TArray TMap and TSet TSharedPtr / TWeakObjectPtr / GC TSoftObjectPtr World Context Object TActorIterator Collision Architecture Line Trace, Sweep, Overlap Chaos Physics and Gameplay

Level 3 — Gameplay Framework

Builds on Level 2 — the full set of framework roles (Pawn/Controller/Character/GameMode/GameState/GameInstance/Subsystem) and Delegates as a tool, before AI/UI/GAS start silently relying on them.

UWorld Pawn / Controller / PlayerState ACharacter vs APawn GameMode and GameState UGameInstance Subsystems Delegates: Single/Multicast/Dynamic PlayerController from the Inside ULocalPlayer and GameViewportClient UGameplayStatics

Level 4 — Data

Builds on UObject and soft references — how to describe growing content with data, not code, before GAS and AI start building on top of it.

UDataAsset UDataTable UAssetManager FGameplayTag UPrimaryDataAsset UPROPERTY(Config) UDeveloperSettings

Level 5 — Systems

Six parallel applied systems, not a sequence — the order between 5.A–5.F is not strict; each builds only on Levels 0–4 (and Network Prediction in GAS also on Level 6, Multiplayer).

5.A — Input

How game intent is separated from the physical key: Input Actions and Mapping Contexts instead of hardcoded Action/Axis Mappings.

Enhanced Input EnhancedInputLocalPlayerSubsystem

5.B — UI

How interfaces are built with UMG, how to manage the screen stack and focus with CommonUI, and how to break the direct link between a widget and game objects with MVVM.

UMG: UUserWidget CommonUI MVVM Slate: under the hood of UMG UUserWidget Lifecycle CommonInput

5.C — Gameplay Ability System

An ability framework on top of UFUNCTION: networking, cancellation, resource costs, and effect compatibility in one consistent solution — all the way to Network Prediction at the boundary with Multiplayer.

GAS: why a framework on top of UFUNCTION AttributeSet GameplayEffect GameplayAbility: lifecycle GameplayTags in GAS Network Prediction in GAS Execution Calculation GameplayModMagnitudeCalculation GameplayCue

5.D — AI

How the decision "what should the NPC do" is expressed as a tree of reusable nodes, how tasks and the tree exchange data through a shared store, and how to declaratively find the best point in the world.

Behavior Tree Blackboard Environment Query System AIPerceptionComponent NavMesh and Navigation System Smart Objects

5.E — World Streaming

How a game world that physically doesn't fit into memory all at once is loaded in parts: manually, automatically by grid, and in logical layers on top of it.

Level Streaming World Partition Data Layers PCG Framework Instanced Foliage HLOD Nanite Lumen

5.F — Animation

How skeleton pose logic is separated into its own object with its own graph, how one-shot actions play on top of persistent blending, and how the pose adapts to geometry at runtime.

UAnimInstance UAnimMontage Inverse Kinematics Animation State Machine Blend Space Linked Anim Layers Motion Warping Root Motion Anim Thread

Level 6 — Multiplayer

Builds on UPROPERTY and Owner/GetOwner() — the server and the client see the same actor differently, and that's enough to come back and really close out Network Prediction from Level 5.

Foundation

Replication: roles and Authority RPC: Server/Client/NetMulticast Network Relevancy Network Dormancy

Advanced

UActorChannel Net Driver Property Replication from the Inside Replication Graph Fast Array Serializer Client-Side Prediction outside GAS Listen vs Dedicated Server Seamless Travel

Level 7 — Engine Internals

A completely new level — what happens to a project between "I wrote the code" and "the player launched the exe": Header Tool, UnrealBuildTool, modules, plugins, serialization, Cook, runtime loading, threads, and memory allocators.

Foundation

Compile: from .cpp to game ★ flagship UnrealBuildTool Modules and .Build.cs Plugins and .uplugin FArchive: serialization Cooker Runtime Loading Game Thread and Task Graph FMalloc: memory allocators

Advanced

UBT: the compilation graph UnrealHeaderTool from the Inside Build.cs and Target.cs The Whole Compilation Pipeline Inside .generated.h Hot Reload vs Live Coding Packaging: Build+Cook+Stage+Package How a Plugin Gets into Memory FMemory and GMalloc Alignment and Cache Lines TArray from the Inside TMap / TSet from the Inside

Level 8 — Production

A completely new level that completes the course — how not only to write code, but to diagnose and fix existing code, stay within the frame budget, save progress, and structure a project that will outlive more than one developer.

Debugging

UE_LOG Visual Logger Gameplay Debugger DrawDebug* Unreal Insights stat commands

Optimization

Tick and Timer Optimization AsyncTask and ParallelFor Profiling as a Way of Thinking

Saving

USaveGame

Architecture

Large Project Architecture

Profiling (Advanced)

Trace from the Inside Your Own Trace Channel CSV Profiler Gameplay Debugger over the Network LLM: Low Level Memory Tracker GPU Profiling Single Frame Analysis

Architectural Patterns

Composition vs Inheritance Subsystem Pattern Observer via Delegates Factory Pattern: SpawnActor Command Pattern in GAS Dependency Injection in Unreal ECS: an architecture where data matters more than objects OOP vs ECS: two architectural answers

Afterword — cross-cutting articles

Not new material, but an exam on whether you can see the system as a whole: five articles tie everything studied separately into end-to-end stories — from a key press to a frame on screen, from process launch to the full game lifecycle.

✦

Afterword — Engineering Flows

Builds on the entire course — each article traces one end-to-end path through events studied separately in Levels 0–8 and assembles them into a single chronology verifiable against the source.

The Full Game Lifecycle The Full Asset Path The Full Input Path The Full Frame Path The Full Replication Path

How the old project was used

The previous project (a folder one level up) has not been deleted and remains reference material — a source of ideas, ready-made explanations, and code examples. Not a single article here is a copy: every topic is analyzed anew, verified, expanded, and brought to the single standard described above.