Learn C++ for Unreal Engine 5
Learn C++ from scratch, then Unreal Engine 5 programming: practical exercises, memory, OOP, gameplay, replication, GAS, and engine architecture.
Learn C++ programming from scratch and gradually move to code inside Unreal Engine — with hands-on practice in every lesson. This is not a rigidly linear course: each topic is self-contained, explains itself, and ends with a small on-page task, and you can work through them at your own pace. Encyclopedia sits alongside it — the same material, but deeper: that's where Learning links you when a topic outgrows a single lesson.
Learning and Encyclopedia are two tracks of the same site, sharing an account, a theme, and a language switcher. As soon as a Learning lesson introduces an Unreal concept, it links to the corresponding deep-dive Encyclopedia article — not duplicating it, but complementing it with practice on the way to that topic.
The entire path above (00…19) is built around C++ and Unreal architecture on AActor/UActorComponent — it is the only required route of the course, and nothing in it requires ECS. At the bottom of this page there is also an ECS Bonus Track — an optional 7-lesson branch for those who have completed Stage 03 (OOP) and want to broaden their architectural thinking by comparing it with Data-Oriented Design and Mass Entity. An honest explanation of why the course draws this line is in the "OOP — the course's foundation, not the only way to think about architecture" section on the Engine Philosophy page.
Path: C++ → Unreal Gateway
- What a Program Is and How It Runs
- Statements and Expressions
- How a Programmer Thinks
- Variables, Identifiers, and Types
- Fundamental Data Types
- Operators: arithmetic, comparison, logic
- Conditions: if, else, switch
- Loops: while, do-while, for
- Functions: parameters, arguments, return
- Scope, Input, and Final Practice
- Why Classes Are Needed
- Methods, access modifiers, encapsulation
- Constructor, parameters, initializer list
- this, destructor, object lifetime
- Composition and Aggregation
- Inheritance, Base and Derived Class
- virtual, override, polymorphism
- Abstract class, pure virtual function, interface
- Composition vs inheritance, ownership, object relationships
- Character class hierarchy: Stage capstone
- auto and Type Deduction
- nullptr in Modern C++, Lambda Expressions
- Lambda captures, std::function
- unique_ptr, make_unique
- shared_ptr, make_shared, weak_ptr
- Ownership, RAII, resource lifetime
- Copy vs Move, std::move
- std::optional and std::variant
- constexpr, noexcept, modern C++
- Capstone Stage 04: A party without a single raw new/delete
- Header/Source, declaration and definition, #pragma once
- #include, Include Order, Forward Declaration
- Translation unit, namespace, the :: operator
- Linkage, Circular Dependencies
- Coupling, cohesion, dependency direction
- System composition, interface-oriented design
- Function pointers, callbacks
- Event Model, the Delegate as a Concept
- Manager and System as Architectural Roles
- Module Boundaries, SOLID in Practice
- Refactoring: bad and good architecture
- Project organization, preparing for a Pure C++ project
- Compile-time, Link-time, and Runtime Errors
- Debugging: breakpoints, call stack, variables
- Unreal Project: .uproject, Source, structure
- Build: Build.cs and Target.cs
- Modules: IModuleInterface, IMPLEMENT_MODULE
- UHT: Unreal Header Tool, .generated.h
- Reflection: what “reflection” means in Unreal
- UCLASS: Blueprintable, Abstract specifiers
- UPROPERTY: Specifiers, GC, and Pointers
- UFUNCTION: BlueprintCallable, BlueprintPure
- USTRUCT: The F Prefix and How It Differs from UCLASS
- UENUM: BlueprintType and the mandatory uint8
- UObject: the root of Unreal's reflected hierarchy
- Garbage Collection: mark-and-sweep instead of delete
- CDO: Class Default Object — the reference instance of a class
- Outer: organizational ownership, not lifetime
- Creating UObject: NewObject and CreateDefaultSubobject
- Pointers to UObject: UObject*, TObjectPtr, TWeakObjectPtr
- The Complete UObject Lifecycle — Stage 08 Capstone
- UWorld: the game world container
- AActor: the base class finally explained
- UActorComponent: composition, engineered for Unreal
- Transform: FTransform, USceneComponent, hierarchy
- Collision: channels, Overlap vs Block, events
- SpawnActor: why AActor doesn't use NewObject
- Destroy(): the end of an actor's life — Stage 09 capstone
- APawn: an actor meant to be controlled
- ACharacter: Pawn with ready-made movement
- AController: who controls the Pawn
- APlayerController: the live player at the keyboard
- APlayerState: what survives respawn
- AGameModeBase: rules that don't exist on the client
- AGameStateBase: the public snapshot of the rules
- UGameInstance: What Survives a Level Change
- Subsystems: objects the engine creates itself
- Delegates: events instead of direct calls
- The Input Problem: Why BindAction/BindAxis Is Not Enough
- UInputAction: the action as a file asset
- UInputMappingContext: Which Key Fires the Action
- Modifiers: how to change the raw input value
- Triggers: when exactly an action counts as triggered
- EnhancedInputLocalPlayerSubsystem: How a Context Becomes Active
- RemoveMappingContext: removing a context and checking whether it is active
- FModifyContextOptions: clean context switching
- Gameplay input: get the action value and move the character
- UI input: switching between character control and the interface
- Controller → Character: How Input Survives a Character Change
- Input architecture: how it all comes together as a system
- Why GAS: why bool/float fields stop working
- AbilitySystemComponent: the component hub for abilities
- AttributeSet: Attributes as Managed Data
- GameplayAbility: ability as a class
- Activation: how an ability actually launches
- GameplayEffect: the declarative way to change attributes
- Duration: when an effect stops working
- GameplayTags in GAS: Tags and Tag Requirements
- Cost: ability cost as a GameplayEffect
- Cooldown: ability recharge
- Ability Tasks: asynchronous waiting inside an ability
- GameplayCue: visual and audio effects
- Execution Calculation: attribute-dependent modifiers
- Modifier Magnitude Calculation: an easy way to compute a single modifier
- Prediction: networked ability prediction
- Multiplayer GAS: HasAuthority() and RPC
- Debugging GAS: showdebug abilitysystem and live diagnostics
- Capstone Stage 14: the complete ability
- Why AI: why bool flags for NPCs stop working
- AAIController: Starting the Behavior Tree
- Blackboard: the tree's shared memory
- BT Nodes: Task, Decorator, Service
- EQS: querying points in the world
- AI Perception: where PlayerDistance actually comes from
- Navigation: MoveTo and NavMesh
- Smart Objects: find, claim, release
- Capstone Stage 15: complete AGuardAIController
- Why World: Why One Level Can't Handle a Large Map
- Level Streaming: loading and unloading entire levels
- World Partition: automatic streaming grid
- Data Layers: Switchable Content Groups
- PCG: procedural content placement
- Foliage: runtime tree instances
- HLOD: an actor's participation in far-geometry simplification
- Capstone Stage 16: The open world of Novarium
- Why Animation: why one animation is not enough for a character
- AnimInstance: who controls skeletal animation
- AnimMontage: one-shot clip playback on top of the pose
- Root Motion: Movement Baked into the Animation
- Motion Warping: fitting animation-driven movement to the scene
- State Machine: a state graph instead of a string label
- Blend Space: one state, multiple clips by speed and direction
- Linked Anim Layers: swappable modules on top of one AnimInstance
- Animation Thread: the game thread and worker thread inside AnimInstance
- Capstone Stage 17: Novarium animation system
- Why Multiplayer: the network GAS hasn't fully told you about
- Ownership: who on the network is responsible for this actor
- Replication Conditions: not for everyone and not always
- Relevancy: the third dimension of visibility
- Prediction Basics: client acts immediately, server confirms
- Capstone Stage 18: Networked Novarium Item
- Why Engine Internals: what actually happens when you press Build
- Build: the same module, different dependencies in different targets
- UnrealBuildTool: why editing one header sometimes rebuilds half the project
- Modules: why the engine is a hundred modules, not one monolithic binary
- UHT: GENERATED_BODY() — not code, but a promise of code that doesn't exist yet
- Plugins: why GAS is off by default, and Enhanced Input is not
- Serialization: How SaveGameToSlot() Turns UPROPERTY into Bytes
- Cooking: package selection and platform-specific content preparation
- Loading: What Actually Happens Between LoadPrimaryAsset and the Callback
- Threading: Game Thread and Safe Background Work
- Memory: where the bytes for NewObject/SpawnActor physically come from
- Containers: how TArray actually grows
- Capstone Stage 19: one inventory through the whole engine pipeline