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

UE C++ Academy — not a reference, but an engineering school for Unreal Engine

Every topic explains not "what to use," but "why it exists," "what problem it solves," "how it works internally," and "when not to do it." The goal is that after reading a topic, no logical question remains unanswered, and that you learn to arrive at Epic's architectural decisions yourself, rather than memorizing them as a list of facts.

How each topic is structured

A flexible standard: 11 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 short orienting statement before the deep dive.

Why does it exist?

Problem → cause, not a fact without context.

What problem does it solve?

A specific, reproducible scenario where the naive approach breaks.

How does it work?

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

When to use / not use

Boundaries of applicability — without them, a topic breeds cargo cult.

Examples

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

Common mistakes

Separately for beginners and mid-level developers, explaining the mechanism of failure.

Practice

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

FAQ

Questions that actually arise for an attentive reader.

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 — Engine 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 from then on, each new course topic will be recognized as a variation of a familiar line of reasoning, rather than a new set of facts.

Reference article

The gold standard of quality and depth for the entire project — it's worth starting with, even if you're already an experienced developer.

★

How Unreal Engine Works: not API, but engineering thinking

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

Roadmap — 9 Levels

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

Level 0 — How Unreal Thinks

Why the rest of the course exists: 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 a UObject is.

Epic documentation: when it's enough How to read an engine .h file How to read engine .cpp Public/Private/Classes How to trace a dependency

Level 1 — Object System

Builds on Level 0 — after it, any UCLASS()/UPROPERTY() is explained as a specific consequence of Reflection, Garbage Collector, Package, and CDO, not as magical 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 base 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 and its components, and only when the question "how to store the list of components" naturally arises, the tools: TArray/TMap and the two non-overlapping 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 complete set of framework roles (Pawn/Controller/Character/GameMode/GameState/GameInstance/Subsystem) and Delegates as a tool, before AI/UI/GAS start to silently rely 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 as data, not code, before GAS and AI start being built on 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 gameplay 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 to build an interface with UMG, how to manage the screen stack and focus with CommonUI, and how to break the direct connection between the 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 cohesive solution — up to Network Prediction at the intersection 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 of "what the NPC should do" is expressed as a tree of reusable nodes, how tasks and the tree exchange data through a shared storage, 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 doesn't physically fit in memory as a whole is loaded in parts: manually, automatically by grid, and with logical layers on top.

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

5.F — Animation

How the skeletal pose logic is separated into its own object with its own graph, how one-shot actions are played on top of continuous 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 client see the same actor differently, and that's enough to go back and truly close 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 the project between "writing code" and "player runs 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 complete compilation pipeline Inside .generated.h Hot Reload vs Live Coding Packaging: Build+Cook+Stage+Package How a plugin is loaded 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, concluding the course — how not only to write code, but also to diagnose and fix existing code, maintain 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

Optimizing Tick and Timer AsyncTask and ParallelFor Profiling as a way of thinking

Saving

USaveGame

Architecture

Large Project Architecture

Profiling (Advanced)

Trace from the inside Custom Trace Channel CSV Profiler Gameplay Debugger over network LLM: Low Level Memory Tracker GPU profiling Analysis of a single frame

Architectural Patterns

Composition vs inheritance Subsystem Pattern Observer via delegates Factory Pattern: SpawnActor Command Pattern in GAS Dependency Injection in Unreal

Afterword — end-to-end articles

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

✦

Afterword — Engineering Flows

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

Complete game lifecycle The complete asset path The complete input path The complete frame path The complete replication path

Apply it all together

Going through 9 levels in isolation is enough to understand each idea — not enough to feel how dozens of such ideas coexist in one living class. The second, parallel track of the course — the same character, growing alongside the progression through the levels.

🎮

Capstone Project: AAcademyCharacter from Actor to GAS and Animation

One continuously growing project instead of sixteen parallel milestones — almost every level adds a real, working piece of the same survival game: from a bare Actor and components through Enhanced Input, DataAsset items, UMG/MVVM, Multiplayer, GAS abilities and AI enemy to saving and profiling, with the mandatory condition that decisions from previous steps are not rewritten silently, only through explicit refactoring — just as in a real project.

How the old project was used

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