Unreal Engine: What It Is, Architecture, and the C++ Language

What is Unreal Engine?

Unreal Engine is a game engine developed by Epic Games, first released in 1998 with the game Unreal. Since its inception, the engine has gone through five major iterations, and the current version, Unreal Engine 5, released in 2022, is a completely redesigned platform for game development, simulations, film production, and architectural visualization.

Unlike other engines, Unreal Engine offers ready-made solutions for Real-Time Ray Tracing and Nanite virtual geometry. These technologies enable creating scenes with millions of polygons without performance loss. Developers get access to the full engine source code in C++, allowing them to modify any aspect for their specific project needs.

The ecosystem includes the Marketplace with thousands of ready-made assets, plugins, and sound effects. Developers can publish projects on 28 platforms, including PlayStation 5, Xbox Series X, Nintendo Switch, iOS, Android, and PC. According to Epic Games (2026), the ecosystem has over 12 million registered developers.

History of Unreal Engine Development

The first version of Unreal Engine (1998) introduced the portal rendering architecture, which efficiently rendered complex scenes. Unreal Engine 2 (2002) added support for sixth-generation consoles and a particle system. Unreal Engine 3 (2006) became the dominant engine of the Xbox 360 and PS3 era thanks to the PhysX physics engine and shader-based material system.

Unreal Engine 4 (2014) rewrote the renderer for PBR (Physically Based Rendering) and introduced Blueprints — a visual programming system. This version made game development accessible to independent studios thanks to a 5% royalty model on revenue. According to Epic Games (2019), over 50% of UE4 projects were created by independent developers.

Unreal Engine 5 (2022) introduced Nanite and Lumen — technologies that eliminated the need for LOD models and pre-baked lighting. According to Digital Foundry (2026), Nanite can render scenes with 10 billion polygons in real-time on current-generation consoles.

Unreal Engine Architecture: Key Modules

Unreal Engine architecture is built on a modular principle, where each subsystem can be replaced or disabled. The Core Engine manages the game lifecycle, memory, and threads. The Renderer handles graphics, the Gameplay Framework handles game logic, and the Editor handles development tools.

Core Engine and Module System

The base layer includes FPlatformMisc for platform abstraction, FMemory for memory management, and FTaskGraph for multithreading. Each module is represented by a UModule class that registers with the loading system. Modules are compiled as separate DLLs on Windows or DYLIBs on macOS, allowing updates without recompiling the entire engine.

The Asset Registry indexes all project resources and provides fast search by tags and metadata. Each asset has a globally unique identifier (FGuid) and can reference other assets through Soft and Hard reference mechanisms. The packaging system bundles assets into optimized Pak archives for the final game build.

The Networking module provides multiplayer support with replication through client-side prediction. According to Epic Games (2025), the Unreal Engine replication architecture supports up to 100 concurrent players on a dedicated server with latency below 50 ms.

Rendering Pipeline

The rendering pipeline supports Forward and Deferred rendering. Deferred Shading is used for most projects: it handles up to 256 light sources per scene. Forward rendering is used for mobile platforms and VR, where low latency is critical. Materials are described through a node graph and compiled into HLSL shaders.

Post-processing includes Temporal Super Resolution (TSR) — Unreal Engine’s own upscaling algorithm that delivers 4K quality from a 1080p render. According to Digital Foundry (2026), TSR outperforms AMD FSR 2.0 by 15–20% in quality at the same performance level. Additional support includes NVIDIA DLSS 3, AMD FSR 3.0, and Intel XeSS.

Gameplay Framework

Gameplay Framework is a class hierarchy that defines the game flow structure. Base classes include UGameInstance (game session), UWorld (world), APlayerController (player control), and APawn (character). Each class has a predefined lifecycle with BeginPlay, Tick, and EndPlay calls.

The component system (UActorComponent) allows building functionality from reusable blocks. The UCharacterMovementComponent handles character movement with gravity, collisions, and network replication. Replacing a component with a custom one allows changing behavior without inheriting from APawn.

The Ability System (GameplayAbilities) provides a framework for RPG mechanics: spells, buffs, and effects with automatic network replication. According to Epic Games (2025), the Ability System is used in 70% of RPG projects on Unreal Engine.

Programming in Unreal Engine: C++ and Blueprints

C++ is the primary language for Unreal Engine: the entire engine is written in C++17, and developers can modify any aspect of it. The code uses its own reflection system (Unreal Reflection System) with UPROPERTY and UFUNCTION markers for editor integration. Classes inherit from UObject and support serialization, replication, and inspection editing.

Actor Class in C++

Every object in the game world inherits from the AActor class. Here is an example of a basic class that moves an object along the X axis:

// MovingActor.h
class AMovingActor : public AActor
{
    GENERATED_BODY()
    
public:
    AMovingActor();
    
    virtual void Tick(float DeltaTime) override;
    
    UPROPERTY(EditAnywhere, Category = "Movement")
    float Speed;
    
private:
    FVector StartLocation;
};

The Speed property with the UPROPERTY(EditAnywhere) marker appears in the Unreal Editor and is automatically serialized when saving the level. The Tick method is called every frame with a DeltaTime parameter, ensuring frame-rate independence. This is the basic pattern for creating interactive objects in the game world.

Blueprints — Visual Programming

Blueprints is a visual scripting system based on a node graph. Each node represents a function call, operation, or event. Blueprints are compiled into native C++ code during the build, providing performance close to pure C++. Developers can mix C++ and Blueprints by calling functions from the visual graph.

Here is an example of creating a dynamic material in C++, which is then used in Blueprints:

// Creating an animated material
UMaterialInstanceDynamic* DynMaterial =
    UMaterialInstanceDynamic::Create(BaseMaterial, this);
 
DynMaterial->SetScalarParameterValue(
    FName("GlowIntensity"), FMath::Sin(RunTime) * 0.5f + 0.5f
);

This code creates a dynamic material instance and updates the GlowIntensity parameter along a sine wave. This approach allows creating animated surfaces — from pulsating light sources to moving water textures — without writing shader code. Materials with dynamic parameters are automatically synchronized with the editor.

Asynchronous Asset Loading

Unreal Engine uses its own thread pool for background tasks. ASyncTask and FThreadSafeQueue ensure safe data transfer between threads. For long-running operations, the FStreamableManager system with asynchronous asset loading and prioritization is used.

// Asynchronous texture loading
TSoftObjectPtr<UTexture2D> TextureRef;
FStreamableManager &Streamable =
    UAssetManager::GetStreamableManager();
 
Streamable.RequestAsyncLoad(
    TextureRef.ToSoftObjectPath(),
    [this]() {
        UTexture2D* Tex = TextureRef.Get();
        ApplyTexture(Tex);
    }
);

The lambda function executes in the main thread after loading completes, eliminating race conditions. The FStreamableManager system supports load prioritization and operation cancellation through handles, which is critical for open-world projects with streaming level loading.

Unreal Engine Editor Tools

Unreal Editor is an integrated development environment with a full set of tools for creating games without writing code. The editor includes the Level Editor for object placement, Material Editor for shaders, Animation Editor for skeletal animation, and Sequencer for cinematic scenes. All changes are displayed in real-time in the viewport window.

Level Editor and Landscapes

The Level Editor allows placing Actors on the scene using transformations. The Landscape tool creates terrain with brushes for raising, lowering, and smoothing. Texture layers are supported for automatic material blending based on height and surface angle.

The Foliage system fills levels with vegetation through procedural placement. Each instance of grass, tree, or rock is randomly rotated and scaled for a natural look. According to Epic Games (2025), the procedural Foliage system supports up to 1 million instances per level without performance loss.

Sequencer and Control Rig

Sequencer is a non-linear editor for creating in-game cutscenes and trailers, working on a track-based principle. Each track controls one parameter: camera position, character animation, sound, or effects. Recording happens directly in the viewport window in real-time.

Control Rig allows animating skeletons directly in the editor without exporting from Maya or Blender. Animators create procedural animations through a visual node graph. According to Epic Games (2026), Control Rig is used in 60% of cinematic projects on Unreal Engine and supports inverse kinematics.

Niagara VFX

Niagara is a next-generation VFX system that replaced Cascade. It supports GPU particles, collision events, and procedural generation. Each effect consists of emitters, modules, and parameters combined into a graph. Niagara allows creating weather systems, magic effects, and explosions with millions of particles.

The Niagara system uses Data Interfaces to interact with physics and the landscape. Particles can respond to collisions with Nanite geometry and catch airflows from Lumen lighting. According to Epic Games (2025), Niagara’s GPU performance is 5–10 times higher than Cascade on CPU.

Unreal Engine Rendering Technologies

Unreal Engine 5 introduced two fundamental technologies: Nanite for geometry and Lumen for lighting. They eliminated traditional trade-offs between quality and performance. Nanite allows using cinematic-quality source assets without manual LOD optimization.

Nanite Virtual Geometry

Nanite is a virtual geometry system that renders billions of polygons in real-time through software rasterization and cluster-based LOD. Unlike traditional approaches, Nanite discards invisible pixels at the micro level, rendering only visible details with sub-pixel precision.

According to Epic Games (2025), Nanite provides a 10–100x increase in geometric detail compared to UE4 at the same performance. The technology supports importing ZBrush models directly and automatically optimizes them for real-time rendering. The limitation is the lack of support for transparent masks and decals.

Lumen Global Illumination

Lumen is a dynamic global illumination system that responds to light source changes in real-time. It uses ray tracing in Signed Distance Fields to calculate indirect lighting. Lumen supports reflections, diffuse light, and color interaction between objects.

Lumen’s performance allows its use on current-generation consoles at 30–60 FPS. According to Digital Foundry (2026), Lumen provides lighting quality comparable to Mental Ray offline rendering. On PCs with RTX 4070 and above, hardware-accelerated ray tracing is available for enhanced quality.

Temporal Super Resolution

Temporal Super Resolution (TSR) is Unreal Engine’s own upscaling algorithm that uses information from previous frames to reconstruct high resolution. TSR works on any GPU supporting Shader Model 5, without dedicated NVIDIA Tensor cores.

Additionally, Unreal Engine 5 supports NVIDIA DLSS 3, AMD FSR 3.0, and Intel XeSS. According to Epic Games (2026), combining TSR with ML-based upscaling provides a performance boost of up to 2.5x while maintaining near-native 4K quality. All technologies are integrated through a unified rendering system.