Unreal Engine

Unreal Engine is Epic Games' real-time engine and the default choice for high-end 3D. It ships with a rendering stack most studios could not build themselves — Nanite virtualized geometry, Lumen global illumination, a full material editor, and a production animation and cinematics toolchain — plus a gameplay framework that encodes decades of assumptions about how a networked game should be structured.

That framework is the thing to understand first. Where Unity hands you an empty container and lets you invent your own architecture, Unreal hands you GameMode, PlayerController, Pawn, PlayerState, and GameState and expects you to fit into them. The learning curve is steeper as a result, and the payoff is that multiplayer, save systems, and input routing already have a designed home. Fighting the framework is the most common way an Unreal project goes wrong.

TL;DR

Quick Example

A C++ Character with a replicated health value and a Blueprint-implementable event:

The division of labor is the point: C++ owns the authoritative rules, Blueprint owns the presentation, and replication is a property annotation rather than a networking subsystem you write.

Core Concepts

Actors and Components

An Actor without components does nothing visible. A Character is really a bundle: capsule collider, skeletal mesh, movement component, and a spring-arm camera in most templates.

The Gameplay Framework

This is Unreal's biggest architectural difference from other engines, and each class has a specific lifetime and network scope:

The critical consequence: GameMode never exists on a client. Putting authoritative logic anywhere else, or trying to read GameMode client-side, breaks the moment you go multiplayer. Placing state in the right class is most of what makes an Unreal project network-ready by default.

Blueprints vs. C++

The established pattern is C++ base classes, Blueprint subclasses. Define AWeaponBase in C++ with the firing logic and expose tunable UPROPERTY(EditDefaultsOnly) values; create BP_Rifle and BP_Shotgun as Blueprint children that set those values and hook up meshes and effects. Pure-Blueprint projects are viable for small games; pure-C++ projects give up the designer workflow that makes Unreal productive.

⚠️ Warning: Blueprints are binary .uasset files. Two people editing the same Blueprint cannot merge — version control needs file locking (Perforce, or Git LFS with a locking convention) on any team larger than one.

The reflection macros

UPROPERTY is not optional bookkeeping. A raw UObject* pointer without it is invisible to the garbage collector and will be collected out from under you. Common specifiers:

Replication

Unreal's networking model is server-authoritative with client prediction built into CharacterMovementComponent.

Property replication handles state; RPCs handle events. Prefer replicated properties where you can — they're resilient to packet loss and late-joining clients, whereas an unreliable multicast that drops is simply gone. See Multiplayer Netcode for the general theory.

Rendering: Nanite and Lumen

Nanite is virtualized micropolygon geometry. It streams and renders film-quality meshes with effectively no polygon budget, replacing manual LOD authoring for static geometry. Caveats worth knowing before designing a pipeline around it: it applies to opaque static meshes (skeletal mesh support has been expanding), masked and translucent materials reduce its benefit, and it shifts cost from triangle count toward overdraw and material complexity.

Lumen is real-time global illumination and reflections. It removes the lightmap baking step that historically dominated iteration time, letting artists move a light and see bounce lighting immediately. It costs meaningful GPU time and has software and hardware-ray-tracing modes with different quality and cost profiles.

Both are transformative for high-end PC and current-gen console targets, and both are the reason Unreal is a poor fit for low-end mobile — where you'd disable them and lose most of the engine's rendering advantage.

Best Practices

Put authoritative logic on the server, always

HasAuthority() guards every state change that matters. A client-side check is a UI convenience; the server's check is the rule. This holds even in a single-player game, because Unreal runs single-player as a listen server and code written this way ports to multiplayer without a rewrite.

Use the framework classes for what they're for

Match rules in GameMode, replicated match state in GameState, per-player persistent data in PlayerState, input and camera in PlayerController. State placed in the wrong class works in the editor and fails in a networked build — the most common source of "it worked in PIE" bugs.

Prefer soft references for heavy assets

A hard reference pulls the asset — and everything it references — into memory whenever the owning class loads. Reference chains are how a small Blueprint ends up loading half the game.

Keep Tick off unless you need it

Hundreds of Actors ticking to check a condition is a real cost. Use timers, delegates, and event-driven updates instead; where you must tick, consider TickInterval rather than every frame.

Use the Gameplay Ability System for anything combat-shaped

GAS is a heavyweight framework for abilities, attributes, cooldowns, and effects — replicated and predicted out of the box. It has a steep learning curve and is nearly always cheaper than the ad-hoc system a team builds after discovering that abilities need prediction, stacking, and cancellation.

Profile with Unreal Insights, not guesses

stat unit gives the immediate breakdown (Game / Draw / GPU thread) that tells you which processor is the bottleneck. Unreal Insights gives the full timeline. Optimizing the CPU when you're GPU-bound is the standard wasted week.

Establish source control before the first asset

Binary assets, huge file sizes, and derived data mean the setup you get away with on a solo project fails on a team. Perforce is the industry norm; Git with LFS and locking is workable. Retrofitting is far harder than starting correctly.

Common Mistakes

Omitting UPROPERTY on a UObject pointer

Trusting the client

Reading GameMode on a client

Casting to concrete classes everywhere

Doing heavy work in Tick

Building the whole game in Blueprints and porting later

The port rarely happens, and by the time performance forces it, the architecture has been shaped by Blueprint's constraints. Decide the C++/Blueprint boundary early: systems and base classes in C++, composition and content in Blueprint.

FAQ

Do I have to learn C++ to use Unreal?

No — complete games ship in pure Blueprint. But C++ removes several ceilings: performance in hot paths, access to engine subsystems not exposed to Blueprint, cleaner version control, and the ability to define base classes that designers extend. The practical middle ground is reading C++ fluently (the engine source is your best documentation) and writing it for systems while composing in Blueprint. See C++.

Unreal or Unity?

Unity for mobile, 2D, smaller teams, faster iteration, and C#. Unreal for high-fidelity 3D, built-in multiplayer architecture, cinematics, and access to full engine source. Unreal's rendering out of the box is meaningfully ahead; Unity's iteration loop and mobile story are meaningfully better. Team experience and target platform decide it more often than capability.

What does Unreal cost?

The engine is free to use, with a royalty on gross revenue above a per-product threshold, waived for the first tranche of revenue and for games published on the Epic Games Store. Non-game industries have separate seat-based licensing. Terms have changed over time — check Epic's current EULA before modeling a budget.

Why is my project so large and slow to build?

Because of shader permutations and derived data. A fresh project compiles tens of thousands of shaders; the Derived Data Cache stores them, and a shared DDC across a team is the single biggest build-time win available. Cook times scale with content, and full-source engine builds take hours on first compile. This is normal Unreal, not a misconfiguration.

Is Unreal usable for mobile?

Yes, and it's used for high-end mobile titles — but you'll disable Nanite and Lumen, use the mobile renderer, and accept a larger binary than Unity would produce. If mobile is your primary target and you don't need high-end rendering, Unity is generally the more comfortable fit.

What is the Gameplay Ability System actually for?

Any game where actors have abilities with costs, cooldowns, durations, stacking modifiers, and networked prediction — RPGs, MOBAs, shooters with abilities. It's a large framework with a genuine learning cost, but it solves prediction and replication for abilities correctly, which is a problem teams consistently underestimate.

Related Topics

References