← Back to all projects

UNREAL ENGINE CPP MASTERY

In 1998, Tim Sweeney wrote the first Unreal Engine in C++. Since then, it has become the gold standard for AAA development. While Blueprints allow for rapid prototyping, C++ is where the Dark Arts of game development live: performance optimization, custom engine extensions, and complex networked logic.

Learn Unreal Engine C++: From Zero to Engine Master

Goal: Deeply understand the internal architecture of Unreal Engine 5—what makes it tick, how its reflection system bridges C++ and Blueprints, why it uses a custom memory management system, and how to build high-performance, networked games by mastering the engine’s core C++ systems from first principles.

Why Unreal Engine C++ Matters

In 1998, Tim Sweeney wrote the first Unreal Engine in C++. Since then, it has become the gold standard for AAA development. While Blueprints allow for rapid prototyping, C++ is where the “Dark Arts” of game development live: performance optimization, custom engine extensions, and complex networked logic.

Understanding UE5 C++ architecture unlocks:

  • The Reflection System: How the engine “knows” about your code at runtime.
  • Memory Control: Bypassing or working with the Garbage Collector for performance.
  • Networking Mastery: Building lag-compensated, high-tick-rate multiplayer systems.
  • Engine Extensibility: Building tools that make you and your team 10x more productive.

Core Concept Analysis

1. The UObject Ecosystem (The Reflection System)

Unreal C++ isn’t “vanilla” C++. It’s C++ with a powerful reflection layer. The Unreal Header Tool (UHT) parses your code and generates “glue” code that allows the engine to see your variables, functions, and classes.

+---------------------+      +------------------------+
|   Your C++ Code     |      | Unreal Header Tool     |
| (UCLASS, UPROPERTY) | ---> | (UHT / Header Parser)  |
+---------------------+      +-----------+------------+
                                         |
                                         v
+---------------------+      +------------------------+
| Compiled Binary     | <--- | Generated .gen.cpp     |
| (Machine Code)      |      | (Reflection Metadata)  |
+---------------------+      +------------------------+

2. The Actor & Component Model

UE5 uses a “Composition over Inheritance” model. An AActor is just a container; its behavior is defined by the UActorComponents attached to it.

       [ AActor (The Entity) ]
               |
      +--------+---------+
      |                  |
[ USceneComponent ] [ UActorComponent ]
(Has Transform)      (Logic Only)
      |                  |
  +---+---+          [ UHealthComponent ]
  |       |
[StaticMesh] [Camera]

3. Memory Management: The GC and Smart Pointers

Unlike standard C++, you rarely use std::shared_ptr. Unreal provides its own memory management:

  • UObjects: Managed by Garbage Collection (GC).
  • Non-UObjects: Managed by TSharedPtr, TUniquePtr, or raw pointers (dangerous!).
High Addresses
+-----------------------------+
|    Garbage Collector (GC)   | <--- Tracks UObject references
| (UProperty pointer tracing) |
+-----------------------------+
|    The Heap (Manual)        | <--- TSharedPtr / TUniquePtr
+-----------------------------+
|    The Stack (Automatic)    | <--- Local variables
+-----------------------------+
Low Addresses

4. The Networking Lifecycle (Replication)

In multiplayer, the Server is God. Logic happens on the server, and state is “replicated” to clients.

   [ Server ]               [ Client ]
       |                        |
1. Change Variable              |
2. Mark Dirty                   |
3. Send Packet    ---------->   4. Update Variable
                                5. Call OnRep Function

Core Concept Analysis: The Build Pipeline

Understanding how your code becomes a game is vital. Unreal uses a custom build tool (UBT) and a header tool (UHT).

[ .h / .cpp ] --- (UHT) ---> [ .generated.h / .gen.cpp ]
      |                             |
      +------------+----------------+
                   |
             (C++ Compiler)
                   |
             [ .obj files ]
                   |
               (Linker)
                   |
            [ Game.exe / .dll ]

Concept Summary Table

Concept Cluster What You Need to Internalize
UObject System The engine doesn’t “see” C++ without macros. Reflection is the bridge to GC and Blueprints.
Lifecycle Objects have a birth (BeginPlay), life (Tick), and death (EndPlay/GC).
Delegates The “Observer Pattern” of Unreal. How objects talk without knowing each other exists.
Replication Net code is state synchronization. Server is authoritative; clients are mirrors.
GAS The Gameplay Ability System. A framework for complex, networked RPG-style actions.

Deep Dive Reading by Concept

This section maps each concept to specific book chapters. Read these alongside the projects to build strong mental models.

Engine Architecture & Reflection

Concept Book & Chapter
UObject System “Game Engine Architecture” by Jason Gregory — Ch. 14: “The Gameplay Foundation System”
Reflection in C++ “Computer Systems: A Programmer’s Perspective” — Ch. 7: “Linking” (to understand symbols)
UE5 Core “Unreal Engine 5 C++ Cookbook” by William Sherif — Ch. 1: “UE5 Development Setup”

Gameplay Framework

Concept Book & Chapter
Actors/Components “Unreal Engine 5 Shaders and Effects Cookbook” — Ch. 1 (for material interaction)
Input Systems “Game Programming Patterns” by Robert Nystrom — “Command Pattern”

Essential Reading Order

  1. The Foundation (Week 1):
    • Game Programming Patterns Ch. 1-3
    • Unreal Engine Documentation: “UObject System”
  2. The Framework (Week 2):
    • Gregory Ch. 14
    • Unreal Engine Documentation: “Actor Lifecycle”

Project 1: The Spell Registry (Mastering Data Assets)

  • File: UNREAL_ENGINE_CPP_MASTERY.md
  • Main Programming Language: C++
  • Alternative Programming Languages: N/A (UObject is UE-specific)
  • Coolness Level: Level 3: Genuinely Clever
  • Business Potential: 2. The “Micro-SaaS / Pro Tool”
  • Difficulty: Level 1: Beginner
  • Knowledge Area: Reflection System / Data Management
  • Software or Tool: Unreal Engine 5 Editor
  • Main Book: “Game Engine Architecture” by Jason Gregory

What you’ll build: A system that defines spells in C++ using UDataAsset. You’ll create a base USpell class and several subclasses (Fire, Ice) that designers can configure in the editor.

Why it teaches Unreal Architecture: This is the first step into the “Unreal way” of doing C++. You’ll learn how UCLASS, UPROPERTY, and UFUNCTION turn raw C++ into editor-accessible tools. It forces you to understand how Unreal’s reflection system bridges the gap between compiled code and visual design.

Core challenges you’ll face:

  • Defining a UObject hierarchy → maps to understanding inheritance within the engine
  • Exposing data to the Editor → maps to mastering UPROPERTY specifiers (EditAnywhere, BlueprintReadWrite)
  • Object instantiation → maps to understanding that you can’t use ‘new’ for UObjects (must use NewObject)

Real World Outcome

You’ll have a new asset type in the Content Browser. When you right-click and create a “Spell Data Asset”, you can fill in damage, mana cost, and even select a Particle System—all defined in C++.

Example Output (Editor):

[Asset: Fireball_Data]
- Mana Cost: 50.0
- Damage: 120.0
- Visual FX: P_Fireball_Explosion
- Cast Time: 1.5s

The Core Question You’re Answering

“How does the Unreal Editor know that my C++ class exists, and how can I let a designer change my variables without recompiling?”

Before you write any code, sit with this. In standard C++, variables are fixed once compiled. In Unreal, UPROPERTY creates a dynamic link. You are building a bridge between the CPU and the Artist’s mouse.

Project 2: The Health Component (Composition over Inheritance)

  • File: UNREAL_ENGINE_CPP_MASTERY.md
  • Main Programming Language: C++
  • Alternative Programming Languages: N/A
  • Coolness Level: Level 2: Practical but Forgettable
  • Business Potential: 1. The “Resume Gold”
  • Difficulty: Level 2: Intermediate
  • Knowledge Area: Actor Component Architecture
  • Software or Tool: UE5 Component System
  • Main Book: “Game Programming Patterns” by Robert Nystrom

What you’ll build: A reusable UHealthComponent that can be attached to any Actor (Player, Enemy, Destructible Barrel) to give it health, damage handling, and death logic.

Why it teaches UE5 Architecture: Instead of putting health logic in the Character class, you’re building a modular “Lego piece”. This teaches you the Component model—the heart of Unreal’s entity architecture.

Core challenges you’ll face:

  • Inter-Component Communication → maps to finding components on an Actor via FindComponentByClass
  • Delegates → maps to broadcasting “OnDeath” events to other systems
  • Component Lifecycle → maps to knowing when BeginPlay triggers for components vs. actors

Real World Outcome

You can drag your UHealthComponent onto a simple Cube actor in the level. Suddenly, that cube can “take damage”. When its health hits 0, it broadcasts an event that you can catch in Blueprints to spawn an explosion.

Example Log Output:

LogTemp: HealthComponent: 'Player_1' took 20 damage. Remaining: 80
LogTemp: HealthComponent: 'Barrel_C_4' took 100 damage.
LogTemp: HealthComponent: 'Barrel_C_4' has DIED. Broadcasting OnDeath...

Project 3: The Game State Manager (Global Orchestration)

  • File: UNREAL_ENGINE_CPP_MASTERY.md
  • Main Programming Language: C++
  • Alternative Programming Languages: N/A
  • Coolness Level: Level 3: Genuinely Clever
  • Business Potential: 3. The “Service & Support” Model
  • Difficulty: Level 2: Intermediate
  • Knowledge Area: Gameplay Framework / Singleton-like Subsystems
  • Software or Tool: GameMode / GameState
  • Main Book: Unreal Engine Documentation: “Gameplay Framework”

What you’ll build: A custom AGameState that tracks the current “Match Score” and “Winning Team” across all players in a session.

Why it teaches UE5 Architecture: It teaches you where data lives. You’ll learn the difference between AGameMode (Server only logic) and AGameState (Data replicated to everyone). This is the foundation of multiplayer architecture.

Core challenges you’ll face:

  • Replication → maps to making sure the score updates on the UI for all players
  • Networking Roles → maps to understanding HasAuthority() vs IsLocallyControlled()
  • Class Hierarchy → maps to extending AGameStateBase correctly

Real World Outcome

A functioning scoreboard that works in a “Listen Server” environment. Player A kills Player B; Player A’s score increments on everyone’s screen simultaneously.

Example Scoreboard UI:

[ MATCH STATS ]
Blue Team: 12
Red Team:  8
Time Remaining: 04:59

Project 4: The Dialogue Graph Editor (Extending the Engine)

  • File: UNREAL_ENGINE_CPP_MASTERY.md
  • Main Programming Language: C++
  • Alternative Programming Languages: N/A
  • Coolness Level: Level 4: Hardcore Tech Flex
  • Business Potential: 5. The “Industry Disruptor”
  • Difficulty: Level 4: Expert
  • Knowledge Area: Editor Modules / Slate UI
  • Software or Tool: Slate Framework / GraphEditor
  • Main Book: Unreal Engine Documentation: “Editor Customization”

What you’ll build: A custom editor window with a node-based graph. You can create dialogue nodes, link them with lines, and save the result as a custom asset type.

Why it teaches UE5 Architecture: This is the “God Tier” of Unreal development. You aren’t just making a game; you’re building a tool inside the engine. It teaches you about Editor Modules, Slate (Unreal’s UI code), and how the Content Browser manages assets.

Core challenges you’ll face:

  • Slate Syntax → maps to learning the declarative C++ UI macros (SNew, SAssignNew)
  • Module Registration → maps to loading your code only in the Editor, not the final game build
  • Graph Serialization → maps to saving the visual layout of nodes so they persist

Real World Outcome

A new “Dialogue” category in the Right-Click menu of the Content Browser. When opened, it pops up a window that looks like the Blueprint editor but is dedicated entirely to your custom dialogue logic.

Visual Outcome (Editor Window):

[ Dialogue Editor: Greeting_Asset ]
(Start) ---> [Node: "Hello!"] ---> <Choice: "Hi" / "Go Away">

Project 5: The Stylized Outliner (Post-Process Pipeline)

  • File: UNREAL_ENGINE_CPP_MASTERY.md
  • Main Programming Language: C++ / HLSL
  • Alternative Programming Languages: N/A
  • Coolness Level: Level 5: Pure Magic (Super Cool)
  • Business Potential: 2. The “Micro-SaaS / Pro Tool”
  • Difficulty: Level 3: Advanced
  • Knowledge Area: Rendering Pipeline / Shaders
  • Software or Tool: PostProcessVolume / Shader Editor
  • Main Book: “Real-Time Rendering” by Akenine-MĂśller

What you’ll build: A custom rendering pass that detects edges in the scene and draws black outlines (like Borderlands). You’ll write a C++ class that injects this material into the engine’s rendering queue.

Why it teaches UE5 Architecture: It forces you to look at the Render Hardware Interface (RHI). You’ll understand the Deferred Rendering pipeline and how the engine processes pixels after the lighting pass.

Core challenges you’ll face:

  • HLSL Integration → maps to writing shader code that runs on the GPU
  • Buffer Sampling → maps to reading from the SceneDepth and Normal buffers
  • RHI Threading → maps to understanding that rendering happens on its own thread

Real World Outcome

Every object in your game world suddenly gets a crisp, toon-shaded outline. You can adjust the “Line Thickness” variable in C++ and see the GPU update the pixels in real-time.

Example Visual Result:

[ Normal Sphere ]  vs  [ Stylized Sphere ]
      (O)                     (O)
   Smooth Shaded        Bold Black Outline

Project 6: The Object Pool Allocator (Memory Control)

  • File: UNREAL_ENGINE_CPP_MASTERY.md
  • Main Programming Language: C++
  • Alternative Programming Languages: N/A
  • Coolness Level: Level 4: Hardcore Tech Flex
  • Business Potential: 1. The “Resume Gold”
  • Difficulty: Level 4: Expert
  • Knowledge Area: Memory Management / Performance
  • Software or Tool: FMemory / Unreal Insights
  • Main Book: “Computer Systems: A Programmer’s Perspective”

What you’ll build: A custom memory allocator for a specific class (e.g., thousands of bullet projectiles). Instead of calling NewObject (expensive) every time, you pre-allocate a block of memory and manage it yourself.

Why it teaches UE5 Architecture: It shows you what’s under the hood of Unreal’s memory system. You’ll learn why the Garbage Collector is great for stability but can be a bottleneck for high-performance simulations.

Core challenges you’ll face:

  • Cache Locality → maps to keeping data packed together for CPU speed
  • Manual Lifetime → maps to ensuring you don’t ‘free’ memory the GC thinks it still owns
  • Profiling → maps to using Unreal Insights to prove your allocator is faster

Real World Outcome

You can spawn 10,000 bullets with zero frame-rate hitching. The “Allocation” graph in Unreal Insights stays flat because you’ve bypassed the standard heap allocation mid-game.

Profiling Output (Insights):

Default Allocator: 2.4ms per frame (Allocation overhead)
Pool Allocator:    0.1ms per frame (Direct access)
Performance Gain:  24x Speedup

Project 7: The Data Synchronizer (UBT Extension)

  • File: UNREAL_ENGINE_CPP_MASTERY.md
  • Main Programming Language: C# (for UBT) / C++
  • Alternative Programming Languages: N/A
  • Coolness Level: Level 3: Genuinely Clever
  • Business Potential: 3. The “Service & Support” Model
  • Difficulty: Level 4: Expert
  • Knowledge Area: Build System / Automation
  • Software or Tool: Unreal Build Tool (UBT)
  • Main Book: Unreal Engine Documentation: “Unreal Build Tool”

What you’ll build: A custom build step in C# that reads a CSV file of game constants and automatically generates a C++ .generated.h file containing those constants before the compiler starts.

Why it teaches UE5 Architecture: This is meta-programming. You’ll learn how UnrealBuildTool orchestrates the compilation. You’ll understand the “generated code” pattern that Unreal itself uses for its reflection macros.

Core challenges you’ll face:

  • C# for Tooling → maps to working within the UBT’s C# environment
  • File I/O Hooks → maps to finding the right time in the build graph to run your code
  • Header Guards → maps to writing C++ code programmatically that doesn’t break the build

Real World Outcome

You update a “WeaponDamage.csv” file. You hit “Build” in Visual Studio. Suddenly, your C++ code has access to a new FConstants::Sword_Damage variable without you ever typing it in a header.

Generated File Sample:

// AUTO-GENERATED - DO NOT EDIT
#pragma once
namespace GConstants {
    constexpr float Sword_Damage = 15.0f;
    constexpr float Axe_Damage = 25.0f;
}

Project 8: The Multicast Ability (Mastering GAS)

  • File: UNREAL_ENGINE_CPP_MASTERY.md
  • Main Programming Language: C++
  • Alternative Programming Languages: N/A
  • Coolness Level: Level 4: Hardcore Tech Flex
  • Business Potential: 1. The “Resume Gold”
  • Difficulty: Level 4: Expert
  • Knowledge Area: Gameplay Ability System (GAS)
  • Software or Tool: AbilitySystemComponent
  • Main Book: “The GAS Documentation” by Tranek

What you’ll build: A “Meteor Strike” ability using the Gameplay Ability System. It must handle mana cost, cooldown, target selection, and network replication—all in C++.

Why it teaches UE5 Architecture: GAS is the most complex framework in Unreal. It combines reflection, networking, and attribute management. Building an ability in C++ (rather than Blueprints) forces you to understand the UGameplayAbility lifecycle.

Core challenges you’ll face:

  • Attribute Sets → maps to defining Health/Mana variables that GAS can modify
  • Gameplay Tags → maps to using the tag-based state system (e.g., “State.Stunned”)
  • Prediction → maps to making the ability feel instant on the client while the server validates

Real World Outcome

A networked combat system where casting a spell is robust. If the player lags, the server correctly rolls back the ability. The cooldown and mana are perfectly synced across all clients.

Example GAS Debug Window:

[ AbilitySystemComponent ]
- Active Tags: Character.Casting, State.Invulnerable
- Attributes: Health=100, Mana=45 (-5 /sec)
- Active Effects: GE_Regen_C

Project 9: The Secure Save System (FArchive Customization)

  • File: UNREAL_ENGINE_CPP_MASTERY.md
  • Main Programming Language: C++
  • Alternative Programming Languages: N/A
  • Coolness Level: Level 4: Hardcore Tech Flex
  • Business Potential: 3. The “Service & Support” Model
  • Difficulty: Level 3: Advanced
  • Knowledge Area: Serialization / Security
  • Software or Tool: FArchive / FileHelpers
  • Main Book: “The C++ Programming Language” by Bjarne Stroustrup

What you’ll build: A system that saves the game world state into a binary format using FArchive. You’ll add a simple XOR encryption layer to prevent users from editing their save files in Notepad.

Why it teaches UE5 Architecture: It teaches you the Serialization system. You’ll learn how operator<< is overloaded in Unreal to pipe data into files, memory, or network packets.

Core challenges you’ll face:

  • Binary Layout → maps to manually ordering how bytes are written to disk
  • Object References → maps to serializing pointers to actors so they “re-link” on load
  • Encryption Buffers → maps to modifying the data stream as it’s being written

Real World Outcome

A save file that looks like gibberish in a hex editor but loads perfectly in-game. It’s 10x smaller than a JSON or XML save and much faster to load.

Save File Hex (XORed):

0000000: 4D 53 56 01  // MAGIC_HEADER
0000004: FF 34 A2 11  // [Encrypted Data Block]
0000008: 00 00 12 00  // [Encrypted Data Block]

Project 10: The Gradient Designer (Custom Property Types)

  • File: UNREAL_ENGINE_CPP_MASTERY.md
  • Main Programming Language: C++ / Slate
  • Alternative Programming Languages: N/A
  • Coolness Level: Level 3: Genuinely Clever
  • Business Potential: 2. The “Micro-SaaS / Pro Tool”
  • Difficulty: Level 5: Master
  • Knowledge Area: Reflection / Property Customization
  • Software or Tool: IPropertyTypeCustomization
  • Main Book: Unreal Engine Documentation: “Property Customization”

What you’ll build: A custom USTRUCT called FColorGradient and a corresponding Slate UI that replaces the default text fields with a visual gradient slider in the Details panel.

Why it teaches UE5 Architecture: It shows you how the Details panel works. You’ll learn how to intercept Unreal’s reflection system to provide a better UI for specific data types. This is how you make your C++ systems “Designer Friendly”.

Core challenges you’ll face:

  • Property Handles → maps to accessing and setting values through the IPropertyHandle interface
  • Slate Drawing → maps to drawing custom shapes and colors directly in a UI widget
  • Transaction System → maps to making sure “Undo” (Ctrl+Z) works with your custom UI

Real World Outcome

In the Details panel for any Actor with a FColorGradient property, instead of seeing an array of floats, the designer sees a beautiful visual slider where they can click to add color keys.

Example Details UI:

[ My Color Gradient ]
[ ■----■----■----■ ]  <-- Visual Slider
[ 0.0  0.5  0.8  1.0 ]

Project 11: The Level Heatmap (FEditorViewportClient)

  • File: UNREAL_ENGINE_CPP_MASTERY.md
  • Main Programming Language: C++
  • Alternative Programming Languages: N/A
  • Coolness Level: Level 4: Hardcore Tech Flex
  • Business Potential: 2. The “Micro-SaaS / Pro Tool”
  • Difficulty: Level 5: Master
  • Knowledge Area: Editor Viewports / Rendering
  • Software or Tool: FEditorViewportClient / FCanvas
  • Main Book: Unreal Engine Documentation: “Editor Viewports”

What you’ll build: A custom editor viewport that visualizes “Player Death Heatmaps”. It overlays colored circles on the level map based on data from your analytics system.

Why it teaches UE5 Architecture: This is a deep dive into how the Editor renders its 3D windows. You’ll learn to draw custom debug geometry and handle camera input in a specialized viewport context.

Core challenges you’ll face:

  • Canvas Drawing → maps to drawing 2D overlays on top of a 3D scene
  • Viewport Interaction → maps to overriding mouse input to “pick” data points in 3D space
  • Performance → maps to efficiently drawing thousands of data points without lagging the editor

Real World Outcome

A new “Heatmap” tab in the editor. When enabled, the level glows with red and blue circles indicating where players are dying most frequently, helping you balance the level design.

Visual Outcome:

[ Level Viewport ]
(Room A) -- [Red Glow: High Death Count]
(Room B) -- [Blue Glow: Low Death Count]

Project 12: The Global Event Bus (Engine Subsystems)

  • File: UNREAL_ENGINE_CPP_MASTERY.md
  • Main Programming Language: C++
  • Alternative Programming Languages: N/A
  • Coolness Level: Level 3: Genuinely Clever
  • Business Potential: 4. The “Open Core” Infrastructure
  • Difficulty: Level 3: Advanced
  • Knowledge Area: Global State / Lifecycle Management
  • Software or Tool: UEngineSubsystem
  • Main Book: Unreal Engine Documentation: “Subsystems”

What you’ll build: A UEngineSubsystem that acts as a central hub for all game events (e.g., “ObjectiveComplete”, “PlayerLeveledUp”). Any object in the game can subscribe to this bus.

Why it teaches UE5 Architecture: It teaches you the modern alternative to Singletons. You’ll learn how to create global services that manage their own lifecycle and are automatically created by the engine.

Core challenges you’ll face:

  • Global Lifecycle → maps to knowing when a subsystem initializes vs a GameInstance
  • Multicast Delegates → maps to broadcasting events to an unknown number of listeners
  • Memory Safety → maps to ensuring that destroyed objects don’t stay subscribed to the bus (avoiding crashes)

Real World Outcome

A clean, decoupled architecture. Your Quest actor doesn’t need to know about the Player. It just says EventBus->Broadcast("QuestComplete"), and the UI and Achievement systems (which were listening) react instantly.

Log Output:

LogEventBus: Broadcasting event: Mission_1_Complete
LogAchievements: Achievement UNLOCKED: 'First Steps'
LogUI: Displaying Toast: 'Mission Complete!'

Project Comparison Table

Project Difficulty Time Depth of Understanding Fun Factor
1. Spell Registry Level 1 Weekend High (Reflection) 3/5
2. Health Component Level 2 Weekend High (Composition) 4/5
3. Game State Level 2 1 Week High (Networking) 3/5
4. Dialogue Editor Level 4 3 Weeks Extreme (Editor/Slate) 5/5
5. Stylized Outliner Level 3 1 Week High (Rendering) 5/5
6. Pool Allocator Level 4 2 Weeks Extreme (Memory) 3/5
7. UBT Extension Level 4 1 Week High (Build Sys) 4/5
8. GAS Ability Level 4 2 Weeks Extreme (Framework) 5/5
9. Secure Save Level 3 1 Week High (Serialization) 3/5
10. Gradient Designer Level 5 2 Weeks Extreme (Reflection) 4/5
11. Heatmap Viewport Level 5 3 Weeks Extreme (Editor/Draw) 5/5
12. Global Event Bus Level 3 Weekend High (Subsystems) 4/5

Recommendation

If you are a C++ pro but new to Unreal: Start with Project 6 (Pool Allocator). It will speak your language (memory) while introducing you to the engine’s constraints.

If you want to build a career in AAA: Focus on Project 8 (GAS) and Project 4 (Dialogue Editor). These are the specific skills lead engineers look for.

If you are an Indie Dev: Master Project 1 (Data Assets) and Project 12 (Event Bus). They will save you months of technical debt.

Final Overall Project: The “Battle Royale” Engine Core

What you’ll build: A framework for a multiplayer competitive game that combines every project above.

  • Backend: Custom Subsystem (#12) for match matchmaking.
  • Gameplay: GAS-based combat (#8) with reusable components (#2).
  • Tooling: A custom Map Editor (#11) and Dialogue system (#4) for NPC interactions.
  • Optimization: Custom memory pooling (#6) for high player counts.
  • Persistence: Encrypted binary saves (#9) for persistent rankings.

Summary

This learning path covers Unreal Engine 5 C++ through 12 hands-on projects. Here’s the complete list:

# Project Name Main Language Difficulty Time Estimate
1 Spell Registry C++ Level 1 Weekend
2 Health Component C++ Level 2 Weekend
3 Game State Manager C++ Level 2 1 Week
4 Dialogue Graph Editor C++ / Slate Level 4 3 Weeks
5 Stylized Outliner C++ / HLSL Level 3 1 Week
6 Object Pool Allocator C++ Level 4 2 Weeks
7 Data Synchronizer C# / C++ Level 4 1 Week
8 Multicast Ability C++ (GAS) Level 4 2 Weeks
9 Secure Save System C++ Level 3 1 Week
10 Gradient Designer C++ / Slate Level 5 2 Weeks
11 Level Heatmap C++ Level 5 3 Weeks
12 Global Event Bus C++ Level 3 Weekend

For beginners: Start with projects #1, #2, #12. For intermediate: Jump to projects #3, #5, #9. For advanced: Focus on projects #4, #6, #8, #10, #11.

Expected Outcomes

After completing these projects, you will:

  • Understand every Unreal C++ Macro (UCLASS, UPROPERTY, etc.) from a compiler’s perspective.
  • Be able to build custom tools and graph editors inside the Unreal Engine.
  • Master the Gameplay Ability System (GAS) for high-end combat.
  • Write custom shaders and rendering passes in C++.
  • Control memory allocation and garbage collection for 144FPS performance.
  • Build robust, networked game states for multiplayer.

You’ll have built 12 working projects that demonstrate deep understanding of Unreal Engine 5 from first principles.