BEFORE YOU BEGIN

How Unreal Engine Thinks

This is not another encyclopedia topic, but a compass above all the others. Twelve "Whys" that the engine resolves with the same way of thinking over and over again — if you understand the train of thought itself once, each subsequent engine system stops being a new set of facts to memorize and becomes a predictable consequence of that same reasoning.

Project rule: less magic after each topic

This encyclopedia has no goal of "showing the API." The goal is that after each chapter, what previously looked like engine magic becomes a logical consequence of the architecture. After the Reflection chapter, it's clear why UCLASS, UPROPERTY, and UFUNCTION are needed. After the lifecycle chapter, it's clear why you can't do certain things in the constructor. After the Gameplay Framework, it's obvious why logic is divided between GameMode, PlayerController, PlayerState, and Character. This page is not a replacement for those topics, but their common denominator: the twelve different "whys" below are actually variations of the same question, asked about different parts of the engine.

The main learning goal

After completing this encyclopedia, the reader should learn to independently make engineering decisions in Unreal Engine — not to remember facts about specific classes, but to be able to: independently design the architecture of a new game system; read the Unreal Engine source code without fear of an unfamiliar file; understand the reasons for the existence of any engine system, even one about which not a single line is written in this encyclopedia; find a solution in an unfamiliar part of the engine by analogy with an already understood way of thinking, rather than by trial and error; understand what compromises stand behind a specific Epic architectural decision — and be able to formulate them in words, not just quote the conclusion.

The main goal of this encyclopedia is to make the Unreal Engine documentation eventually unnecessary for the reader. Not because they memorized everything, but because they learned to reproduce the very reasoning with which the documentation itself was written.

Why is almost everything in gameplay code a UObject?
Because "being a UObject" is not inheritance for inheritance's sake, but a one-time purchase of three things at once: visibility to the Garbage Collector, visibility to Reflection (and therefore to Blueprint/the editor), and a unified serialization mechanism. Writing any of these three systems from scratch for a "lightweight" type without UObject means solving an already-solved problem a second time.
Deep dive → UObject: Object Architecture
Why is almost everything pointers, not values?
UObject is a unit of identity and ownership (via Outer), which the Garbage Collector tracks by the address of a specific object in memory, not by value. Copying a UObject "by value" would either break that identity (two different objects with identical data are not the same thing for GC and Reflection), or secretly still copy by reference — so the engine makes that reference semantics explicit through a pointer, rather than hiding it.
Deep dive → Smart Pointers and GC
Why is there a Garbage Collector?
The graph of game objects at runtime is not a tree with a single owner, but a network of cross-references (an actor references a component, a component references another actor, which references back), in which manually tracking "who was the last to stop referencing" is practically impossible without leaks or premature deallocation. GC solves this by tracking reachability from the root, rather than manually counting references.
Deep dive → Garbage Collector
Why is there Reflection?
The editor, Blueprint, and the serialization system need to know about the fields and functions of your C++ class at runtime — something that C++ fundamentally does not provide (the language has no runtime information about arbitrary class fields). Unreal Header Tool solves this by generating that description in advance, from macros like UPROPERTY, rather than forcing the engine to guess from the binary.
Deep dive → Reflection
Why is there a Component?
Because the capabilities of gameplay entities ("has health," "has inventory") are a "has-a" relationship, not an "is-a" one, and inheritance, which correctly models "is-a," when used to express "has-a" results in a combinatorial explosion of classes for each new independent capability.
Deep dive → UActorComponent
Why Composition, not inheritance?
Because composition is the only one of the three tried approaches (inheritance, interfaces, templates) that simultaneously provides independent enabling/disabling of a capability, physical storage of state, and full Reflection/Blueprint visibility — interfaces provide only a contract without state, templates are invisible to UHT.
Deep dive → UActorComponent
Why are there Modules?
A codebase the size of an engine does not compile in reasonable time and does not have manageable dependency boundaries as a single monolithic binary. A module is a separate compilation unit with its own build file and an explicit list of dependencies on other modules, which allows rebuilding only what actually changed, and physically prevents one part of the engine from pulling along what it doesn't need (for example, editor code into a packaged game).
Article coming soon
Why are there Plugins?
A module is a unit of compilation, but not a unit of distribution. A plugin packages one or more modules together with content and config into a self-contained feature that can be enabled/disabled for a specific project — so extending the engine doesn't require forking or patching the engine source, which would otherwise diverge with every subsequent engine update.
Article coming soon
Why is there a Subsystem?
A homemade singleton/global variable fits poorly with the fact that multiple "worlds" can exist simultaneously in Unreal (editor + Play-In-Editor at the same time, multiple clients in one process during testing) — global state has nowhere to unambiguously "belong." A Subsystem is a UObject with an automatic lifetime managed by the engine and tied to a specific, explicit boundary (Engine/GameInstance/World/LocalPlayer), so it doesn't outlive its boundary and doesn't get confused between parallel worlds.
Article coming soon
Why are there Gameplay Tags?
A growing, branching set of game states and categories fits poorly onto a C++ enum — a new value requires recompilation, and hierarchical relationships ("Status.Debuff.Stun" is a kind of "Status.Debuff") cannot be expressed by an enum at all. FGameplayTag is a hierarchical string with fast comparison, declared as data rather than recompilable code.
Deep dive → FGameplayTag
Why are there Data Assets?
Content characteristics (weapon damage, item weight) hardcoded in C++ or Blueprint constants do not scale to a growing content list and require programmer involvement for every balance change. UDataAsset is an ordinary UObject, but intended specifically for data editable by a designer without rebuilding and without going to a programmer.
Deep dive → UDataAsset
Why are there Primary Assets?
TSoftObjectPtr solves "don't load everything at once," but does not solve "which 50 of 3000 DataAssets are actually needed right now" — managing this through implicit chains of soft references does not scale. A Primary Asset is an explicit registration of a specific UObject in the AssetManager under a stable identifier (type + name), independent of the file path, which provides a single, centrally managed catalog for content loading.
Deep dive → UAssetManager
OOP is the foundation of the course, not the only way to think about architecture

Composition, not inheritance (the card above) is still an object-oriented approach: state and behavior live together, inside a UObject component, just not through a common ancestor, but through ownership. This is the architectural foundation on which the entire course and the engine's own Gameplay Framework are built — and in this encyclopedia it is explained first and in the most detail, without shortcuts.

Unreal also has another, adjacent model — Mass Entity, where data and behavior are separated, rather than collected in an object. This is Entity-Component-System: an approach that wins not "always," but specifically where tens of thousands of homogeneous entities need to be processed identically per frame. The course does not mix these two models — first OOP to the end, and only when it is understood does a separate encyclopedia section show ECS as a comparison, not as a replacement.

💡 Senior Thoughts

When I encounter an unfamiliar engine system for the first time, I don't go read its API in full. I first ask: which of these twelve problems does it solve — and for whom does it play the role of UObject, Reflection, GC, or Component in this specific task? Nine times out of ten, the answer is found faster than the documentation for the system itself.