Unreal Engine 5.3 Release NotesOverview of new and updated features in Unreal Engine 5.3
ON THIS PAGE
Rendering

Worldbuilding

Procedural Content Generation (PCG)

Developer Iteration

Platform

Character and Animation

Virtual Production

Simulation

Audio

UI Systems

Modeling

Content Pipeline

Framework

Engine Content and Templates

Platform SDK Upgrades

Release Notes

Upgrade Notes

What's New?
Unreal Engine 5.3 brings further improvement to the core UE5 toolset. This release delivers improvements in a wide variety of areas, including Rendering, Worldbuilding, Procedural Content Generation (PCG), Animation and Modeling tools, Virtual Production, Simulation, and more.

This release includes improvements submitted by our community of Unreal Engine developers on GitHub. Thank you to each of these contributors to Unreal Engine 5.3:

909185693, 34Pibo, aaronmjacobs, Acren, aijkoopmans, AishaBrown-SMG, aknarts, alexey-pelykh, alwintom, AndreaCatania, AndTikhomirov, ArcEcho, astutejoe, avudnez, baronpumpky, BenVlodgi, BinaerBoy, Bioliquid, BlenderSleuth, bretternst, brycehutchings, c4augustus, CaptainHoke, chalonverse, chrismcr, Cleroth, cneumann, crobertson-d3t, crssnky, David-Vodhanel, dbsigurd, Deathrey, DecoyRS, djethernet1, DomCurry, dorgonman, Drakynfly, DreikaEru, drichardson, dulanw, Dumbeldor, dyanikoglu, Edstub207, erebel55, error454, fieldsJacksonG, FineRedMist, flibitijibibo, foobit, freezernick, gbxAlx, gonfva, hellokenlee, hkzhugc, HSeo, Ilddor, ilkeraktug, ImaginaryBlend, iniside, jackatamazon, JakobLarsson-Embark, jammm, janurbanech13, jcb936, JDCruise, jfgoulet-gearbox, jimsimonz, Johnsel, JonasKjellstrom, jorgenpt, KacperKenjiLesniak, KaosSpectrum, KasumiL5x, KeithRare, kimixuchen, kissSimple, kniteli, KristofMorva, ldisthebest, LennardF1989, Levil0229, lflecunneen, lightbringer, lijenicol, lijie, liuhao0620, loening, LtRandolph, lucyainsworth, MalikuMane, mamoniem, manugulus, marcussvensson92, mariuz, mattiascibien, MaximeDup, microsoftman, MikBou123, mkotlikov, muit, OskarHolmkratz, pepsiandmilk, PhilBax, Phyronnaz, pirskij, praisesolek, projectgheist, QRare, qwe321, RandomInEqualities, Rareden, robert-wallis, RobertVater, roidanton, ryanjon2040, samhocevar, satoshi-iwaki, scorpio20t, Skylonxe, slackba, slonopotamus, Sn-a-ke, SRombauts, steelixb, stlnkm, teessider, tehpola, TheJamsh, TheoHay, Thomasleeee, tianyu2202, tommybear, tonetechnician, ToniSeifert, tuxerr, ukustra, Ultrahead, ungalyant, user37337, Vaei, velvet22, vorixo, Voulz, vsrc, WarmWar, WillmsBenjamin, WinsonSS, xiexbmu, yaakuro, yatagarasu25, yehaike, ZioYuri78, zompi2

Rendering
Nanite
Nanite

Explicit Tangents
Nanite now supports explicit tangents in the data format and runtime. Until now, Nanite has relied on a tangent space that is implicitly derived in the material, based on the screen-space positions and UV gradients. This is computationally convenient, makes tangents free in terms of memory and disk footprint, and works well in practice for many types of meshes, especially highly tessellated ones. However, there have always been cases, especially for low-poly models, where the implicit tangents are too imprecise and custom per-vertex tangents are needed to reach target quality. To support these cases, users can now opt to store and use the original model tangents on a per-asset basis. Enabling this comes at a modest cost of an additional ~10% increase in memory and disk footprint for the asset.

Nanite Spline Meshes (Experimental)
We introduced an initial implementation of the spline mesh component for Nanite meshes. This feature can be enabled by setting r.Nanite.AllowSplineMeshes=1 in a settings .ini file. WARNING: Enabling this feature currently comes with a performance cost that affects culling performance of all of Nanite, and there are currently known issues with incorrect culling under extreme deformation.

Performance improvements for masked materials and Pixel Depth Offset (PDO)
A new sliding window vertex cache for programmable raster results in faster masked materials and PDO. Initial tests show a 20% speed improvement for rasterization of masked foliage.

Nanite Selection Outline
Nanite object selections no longer flicker with TSR/TAA enabled, nor get occluded by other objects, and they render at final resolution.

Nanite Instanced Static Mesh (ISM) / Foliage Instance Selection
We fixed several issues in the editor related to selecting, modifying, or deleting instances of an instanced static mesh or foliage actors that had Nanite enabled.

Fallback Target Setting
We added a Fallback Target setting to Nanite static meshes. This is a menu option that provides more explicit control over which target to reduce to for the fallback mesh: Relative Error or Percent Triangles.

Lumen
Lumen

Lumen Reflections support more than one bounce when hardware ray tracing (HWRT) is enabled with Hit Lighting, and the Max Reflection Bounces setting in the post process volume is set to 2 or greater. This can prevent black areas in reflections when there is enough performance budget to allow it.

Lumen Reflections can now be used without Lumen GI, for games and applications which use static lighting but wish to scale up in reflection quality beyond reflection captures. Standalone Lumen Reflections only work when HWRT is enabled, and it will enable Hit Lighting automatically, as Lumen's surface cache optimization is not available when Lumen GI is disabled.

We made significant Lumen HWRT optimizations, including enabling async compute for HWRT by default on consoles.

The Lumen Overview visualization mode now includes a view of the geometry normals of the Lumen Scene, making it easier to spot issues with the global distance field (in the case of software ray tracing) or Nanite fallback meshes (in the case of HWRT).

We added r.Lumen.Reflections.VisualizeTraces for visualizing and debugging reflection rays.

We fixed Material AO - it was previously applied on top of emissive and direct lighting.

Orthographic Rendering (Experimental)
Orthographic Rendering

Orthographic rendering is a very common way to visualize projects in architecture and manufacturing, and is also used in games as a stylistic camera choice. It has long been available as a camera option in UE, but many rendering features were not supported, making it impractical to use.

Starting in 5.3, orthographic rendering is now supported as experimental. We fixed multiple areas of the engine to achieve parity between perspective and orthographic projections. Most modern features of UE5 should now work, including Lumen, Nanite, and Shadows. This represents ongoing work and we are interested in hearing your feedback trying to use it in your projects.

Sparse Volume Textures (Experimental)
Sparse Volume Textures

With UE 5.3, we introduce a new asset type: the sparse volume texture (SVT). SVTs store baked simulation data representing volumetric media such as smoke, fire, and water. SVTs can be created by importing OpenVDB (.vdb) files created in other 3D applications—single files and animated sequences are supported. Additionally, Niagara fluids are now cached internally to SVTs resulting in significant performance and memory improvements.

An SVT is similar to a 3D texture / volume texture in that it stores texels (voxels) in a 3D data structure and can be indexed with three-dimensional UV coordinates. Unlike regular (dense) volume textures, SVTs only need to spend memory on regions of the volume with "interesting" data, allowing for much larger volumes compared to dense volume textures—or alternatively volumes with the same extent, but using less memory.

Deferred rendering techniques such as heterogeneous volumes, volumetric cloud, and volumetric fog can leverage SVTs by incorporating the suite of sparse volume texture material nodes in their volume-domain materials. Assets rendered with heterogeneous volumes must make use of the new heterogeneous volume component. Deferred rendering features are still limited to the existing feature set of real-time volumes. More complete support for rendering volumes is now available as experimental in the Path Tracer, which can accurately simulate scattering, shadows, and GI. There is also a very simple sparse volume texture viewer component that is mostly used for debugging and works with the Deferred Renderer.

Path Tracer
Path Tracer

(Experimental) The Path Tracer now has initial support for tracing heterogenous volumes such as smoke, fire, and clouds. A heterogeneous volume can be created with the Niagara Fluids plug-in or by instantiating a heterogeneous volume actor, with data driven by a sparse volume texture. VDB files may be imported as sparse volume textures, and can thus be rendered in the Path Tracer. Note: this system is not yet compatible with Sky Atmosphere clouds.

(Experimental) Substrate materials are now supported in the Path Tracer.

Subsurface scattering sampling efficiency has been improved, resulting in less noise in subsurface materials for the same number of ray samples.

The Path Tracer now renders its own depth pass rather than using the one generated by the rasterizer. This results in a more accurate match between the depth and RGB results, improving post-processing passes that rely on depth such as Depth of Field. (This change does not affect 'Reference Depth of Field'.)

DBuffer Decal shading nodes in material graphs are now supported. These nodes have been available since 5.0 and greatly expand the functionality of decals in materials. (Documentation about DBuffer Decal shading nodes will be available upon the release of UE 5.3.)

Post-process material buffers now have additional outputs for use specifically with the Path Tracer. These buffers are accessible through a new node in the material graph called 'Path Tracing Buffer Texture', and provide data for Radiance, Denoised Radiance, Albedo, Normal, and Variance.

Substrate (Experimental)
Substrate

Substrate, released as experimental in 5.2, replaces the fixed suite of shading models such as Default Lit and Clearcoat with a more expressive, modular framework that provides a greater range of surface appearances and a wider parameter space. Performance scales according to complexity and desired budget, with legacy materials having a similar cost to before.

Substrate is still experimental in 5.3. It should not be used for production scenes, but we encourage testing it and are seeking feedback during this phase of development.

UE 5.3 contains many improvements in Substrate's capability, stability, and performance. Some of the changes include:

New Glints and Specular Profile features, primarily useful for automotive applications.

Improved DBuffer shading node support.

A new Fuzz model for high-spec platforms.

We updated the Substrate Material Information tab in the Material Editor to better display material performance and topology information.

We added many bug fixes and performance improvements.

Virtual Shadow Maps
Virtual Shadow Maps

We are removing the beta designation for virtual shadow maps in UE 5.3—we now consider them production-ready. There is still a long development path ahead for VSMs, but the designation reflects the stability and viability of the current working feature set.

VSMs now respect the Nanite cull distance even when shadow caching is enabled. Previously, the cull distance was ignored in shadows if caching was enabled, as it could cause inconsistencies between the primary render and shadow maps. However, this can have a large impact on performance if the content was tuned for heavy culling. Scenes reliant on culling will now have faster shadows but might see shadow artifacts if the cull distances are short enough to see popping in the primary render.

We added a per-primitive flag that gives the user control over shadow invalidation behavior. This provides users with a way to prevent invalidation, for example in cases where the primitive is known to use the World Position Offset setting statically—our systems cannot deduce this automatically at present. The default setting is 'Auto', which retains current behavior unless explicitly changed.

We made additional bug fixes and performance improvements.

Hair
Hair

We added groom streaming support for groom and groom binding assets. This allows faster loading time in editor and in game by loading only what is needed, lowering CPU and GPU memory pressure of groom assets.

We added Continuous LOD for scaling/improving performance when there are a lot of grooms covering a smaller portion of the screen. This setting is off by default and can be enabled with r.HairStrands.ContinuousLOD.

We added experimental support for hair strands in the Deformer graph, including support for writing custom attributes. This is still early in the development process, but will open the door to making groom changes at runtime in the Deformer graph.

We reworked groom attributes to be more flexible and to make it easier to add new optional attributes. We added two new optional attributes (clumpID / AO). Numerical values of groom attributes can now be visualized in the groom editor for easier inspection.

During asset import, point/curve limits are now reported to users, and data is trimmed accordingly. In addition, imported attributes are now clearly displayed at import time, as well as in the groom editor, to visualize what is available for a particular groom asset.

We made many additional bug fixes and performance improvements.

Temporal Super Resolution (TSR)
Temporal Super Resolution

We introduced new functionality for more automated control of the screen percentage in games when dynamic resolution is disabled (primarily on PC platforms). The default heuristic sets the screen percentage based on the optimal TSR convergence rate for the number of pixels displayed. This should result in end users requiring less experimentation to find the best settings for their device.

The editor has several new UX features to aid in understanding and controlling the behavior of the screen percentage in editor and PIE viewports.

We added initial support for 16-bit operations on desktop GPUs where backed by hardware support, including on Radeon RX 5000 series (RDNA) cards and newer.

We fixed an inconsistency between TAA and TSR regarding Lumen screen-space traces of emissive surfaces.

We made numerous optimizations and bug fixes.

Render Resource Viewer
Render Resource Viewer

The Render Resource Viewer, introduced in UE 5.2, is a tool that gives full visibility into GPU memory allocations and render resources—such as vertex buffers and index buffers—and which assets they come from, like static and skeletal meshes. This provides artists and developers with information needed to optimize GPU memory and keep their projects within their rendering budget.

New in UE 5.3:

You can now select a render buffer/texture and jump to the source asset in the Content Browser.

Insight Memory Trace now tracks DX12 resources, and Insight Metadata Trace tracks resource owner paths like Render Resource Viewer. These features complement the Render Resource Viewer, which works only in the editor, and allows tracking of the owning asset path, debug name of the render resource, and its owner render class name in packaged builds.

Lighting
Lighting

Lights with ray-traced shadows can now optionally shadow volumetric fog. You can enable this with the console variable r.VolumetricFog.InjectRaytracedLights, which is off by default due to performance costs.

Spot, Point, and Rect lights can now set their intensity units to 'EV' (exposure value), which means you can set intensities in relative "stops", or power-of-two increments.

Worldbuilding
Level Instance Actor Filters
Level Instance Actor Filters

Actor filters allow for per-level-instance variants within World Partition levels. They consist of data layer instances and/or local data layers that are set to support actor filtering with a user-defined default filter inclusion. All actors associated with these pre-configured filters will be included or excluded on streaming generation, depending on the filters default, override, and activation states set within each level instance. Filtered out data is removed from in-game entirely.

Level Streaming Persistence (Experimental)
Level Streaming Persistence is a plugin that manages saving and restoring of specific marked properties on objects contained within a streamed-out/streamed-in level. These properties are defined within the engine configuration (.ini) file.

This provides persistence of properties during gameplay from the in-memory snapshot, as well as across sessions, if implemented through the provided API.

Nanite Landscape
Nanite Landscape

Nanite can now be enabled in landscape actors, at parity with normal landscape rendering. Nanite Landscape meshes are rebuilt in the background in order not to disrupt user workflow while in the editor. Nanite Landscape does not improve landscape resolution, but it allows the user to leverage Nanite runtime features such as GPU culling, automatic geometry streaming, and LODs, and it generally boosts runtime performance, especially for demanding features such as VSM.

Large Landscape Import / Export
We updated landscape import/export to support very large landscapes/resolutions by leveraging World Partition and splitting the import operation into several successive batches.

Landscape Physical Materials Display
Landscape physical materials can now be displayed when showing collisions by using the new CVar landscape.CollisionMesh.ShowPhysicalMaterial. When enabled, it helps users to debug how physical materials are exported, especially when using the Landscape Physical Material Output node.

Landscape LOD Groups
We added LOD groups to enable seamless LOD transition across multiple landscape actors in the same group.

Procedural Content Generation (PCG)
Hierarchical Generation
Hierarchical Generation

Hierarchical Generation allows for execution of different grid sizes within the same PCG graph.

After setting a default grid size in the PCG graph settings, users can start adding Grid Size nodes to define the granularity at which the downstream elements should execute. Data processed at higher grid size can be used at any smaller level.

This hierarchical logic enables users to achieve more optimal procedural generation, especially over large worlds at runtime.

Rule Processing From External Data
Rule Processing From External Data

We now support rule processing from external data, providing feature parity with the City Sample project Rule Processor plugin to manage external data, process it, and produce artifacts on target actors.

This includes:

External data support for Alembic point clouds and data tables

A utility for converting Alembic files to PCG Settings assets

Subgraph Inspection
Subgraph Inspection

We added support for debugging and inspecting PCG subgraphs through the Attribute List view within a parent graph.

Graph Instances Parameters
Graph Instance Parameters

We are introducing a Blueprint API to get and set PCG graph user parameters. Other additions include UX improvements and filtering for supported types.

Custom PCG Elements
Custom PCG Elements

To improve the creation workflows and readability for custom PCG elements, we renamed PCG-specific Blueprint loop functions. We also added new functions to set up and output PCG data collections in order.

Developer Iteration
Multi-Process Cook (Beta)
Multi-Process Cook helps reduce the total time it takes to get a cooked output from a build farm server or on your local workstation by leveraging available CPU cores and memory resources.

Multi-process cook is a beta feature for UE 5.3. Performance gains may vary, depending on the size of the project and how the data is separated. For best results, we recommend you test different CookProcessCount values depending on the project and available hardware specs.

Virtual Assets
Virtual Assets are now production-ready for UE 5.3 and recommended for teams using Perforce version control and a shared Unreal DDC (Derived Data Cache) for best performance.

To recap, virtual assets drastically reduce the size of local project data and sync faster by only synchronizing core asset metadata, and then pulling down the bulk data on demand if needed.

Virtual assets are supported for textures, audio data, and static meshes (including Nanite). Bulk data is compressed using Oodle for additional data size savings.

Should you need to go offline, you can run a precache commandlet when launching your project that will cache virtualized data locally on your machine. There is also an 'Auto fix / re-virtualize assets' check-in script available in the Unreal Automation Tool (UAT) that will catch any assets mistakenly un-virtualized project-wide.

C++20 Default Version
UE 5.3 is now compiled with the latest C++20 standard, and the version is supported in your development environment.

We added C++20 support to the Unreal Build Tool (UBT), and it is controllable with a target or module setting; C++14 is marked deprecated and no longer supported.

All engine modules are compiled by default with C++20, regardless of the target C++ standard. Other modules still support C++17 but can be opted-in to C++20 if desired.

C++ Unreal Header Tool
We removed the C++ Unreal Header Tool from Unreal Engine. Please use the C# Unreal Header Tool.

Platform
XR
XR

Gaze-Tracked Foveated Variable Rate Shading (Experimental)
Performance is of utmost importance when developing XR applications. This experimental feature enables gaze-tracked foveated image generation with OpenXR, reducing the number of total pixels drawn.

Make sure the OpenXR and OpenXR EyeTracking plugins are enabled, and set:

xr.VRS.FoveationLevel 1-3 to enable foveation.

xr.VRS.GazeTrackedFoveation 1 to enable Gaze-Tracked Foveation.

xr.VRS.FoveationPreview 1 to enable preview of the foveation mask.

Single-Pass Stereo Rendering for Nanite
Nanite can now render both stereo views in a single pass when Instanced Stereo Rendering is enabled.

Nanite rendering is a multi-step process, and executing these steps for each eye separately is not optimal. Projects with ISR enabled can now have each step of the Nanite pipeline process both eyes at once, reducing the overall rendering time.

You can use r.Nanite.MultipleSceneViewsInOnePass=0 to disable this technique in case you suspect it of introducing a problem.

Stereo Improvements for Lumen Global Illumination
Lumen GI has a number of per-view caches. Since stereo views are so close to each other in terms of position and direction, we can reuse some of the cache between the views.

You can use r.Lumen.StereoOptimizations=0 to disable this in case of any problems.

Handheld AR Improvements
ARCore SDK has been updated to 1.37

ARCore plugin cleanups:

Removed deprecated camera metadata API usage.

Updated to new Cloud Anchor Async API.

Updated to new front/back camera configuration API.

Removed deprecated ARCore-specific Blueprint functions that have cross-platform equivalents.

Fixed ARCore and ARKit ARPins when the tracking to World Transform or World Scale changes.

XRScribe Plugin (Experimental)
This new experimental plugin enables the use of the OpenXR plugin and related code without needing an OpenXR device. The plugin captures OpenXR API interactions between Unreal Engine and the runtime, and can use that capture to emulate devices.

A limited set of OpenXR extensions currently supported by XRScribe OpenXR surface. Hand tracking, gaze tracking, depth layer, and Vive Trackers are not yet supported.

Currently available for Win64 only, but other platforms will be supported in the future.

Emulation currently handles replay of HMD plus device poses, but no input yet.

Plugin built-in captures can be used for quick emulation using CLI (-xremu=mq1 or -xremu=vi).

XRBase Refactor
We refactored the implementation of many XR-related interfaces from the core engine into an XRBase plugin to reduce executable size and memory overhead in non-XR projects. Some XR-related plugins may need to add XRBase as a dependency as a result.

XR_FB_Foveation support (Experimental)

Fixed and dynamic foveation for Meta Quest devices can now be enabled in Project Settings->OpenXR Settings. You can use the following CVars to configure it:

xr.OpenXRFBFoveationLevel (Default=0)

0=None, 1=Low, 2=Medium, 3= High

xr.OpenXRFBFoveationDynamic (Default=False)

True/False

xr.OpenXRFBFoveationVerticalOffset (Default=0)

Other Improvements
Mobile Preview on Vulkan RHI is now using multi-view extension natively instead of Mobile Multi-View emulation.

Packaging for all Meta devices can be achieved by enabling the Package for Meta Quest devices checkbox in the project settings.

Extension plugins to the OpenXR plugin can now access the Layer List.

Mobile Development Requirements and Compatible Hardware
The following are the supported OS versions and minimum hardware for mobile devices supported by Unreal Engine 5.3. For additional information about required SDKs and IDEs, refer to the Platform SDK Upgrades section.

iOS/tvOS/iPadOS
UE 5.3 supports iOS, iPadOS, and tvOS devices with OS that support version target SDK 15 or later. UE 5.3 supports:

A8 AppleTV devices

A8X iPads

A9 devices or newer

The following are the minimum compatible device models for UE 5.2:

iOS 15

iPhone 6S or later

iPod Touch 7th generation

iPadOS 15

iPad 5th generation or later

iPad Air 2* or later

iPad Mini 4* or later

iPad Pro (all models)

tvOS 15

Apple TV HD*

Apple TV 4K (first generation)

Apple TV 4K (second generation)

Android
UE 5.3 supports Android devices meeting the following specifications:

Android 8 or higher

64-bit Arm-based CPU

Compatible GPUs:

Mali T8xx, G71, G72, G76, G77, G78 and G71x series

Adreno 5xx, 6xx or 7xx series

PowerVR GM9xxx series

Xclipse 920

Compatible Graphics APIs:

OpenGL ES 3.2

Vulkan 1.1 on Android 10 or later devices with compatible drivers

Android SDK and JDK Updates
We have streamlined our Android SDK requirements by moving to Android Studio Flamingo 2022.2.1 and using OpenJDK 17.0.6 as our JDK version. Baseline Android support for UE and AGDE now both target the same JDK version, and users do not need separate JAVA_HOME and AGDE_JAVA_HOME environment variables to point at separate JDK installations. Note that with this update, UE now targets the jbr directory for JDK rather than jre.

If you need to support earlier versions of UE than 5.3, but also need to set up UE 5.3 for Android, we recommend the following:

Before you uninstall your previous version of Android Studio, copy the contents of the jre directory to somewhere outside your Android Studio installation to keep them from being overwritten.

Make sure your Android environment variables do not target the SDKs used by earlier versions of UE.

For older versions of UE, use BaseEngine.ini or your Project Settings to manually target your SDKs. In particular, set your JDK directory to the copied jre directory.

See the documentation on setting up Android Studio for UE 5.3 for more details and instructions.

Modernized Xcode Projects
We have updated the way UE handles Xcode projects and workspaces, making it more consistent with modern Xcode workflow conventions. This includes the following changes:

Improved Xcode Project Organization
UE now uses one Xcode workspace per platform.

For example: UnrealGame (Mac) and UnrealGame (IOS).

UE now uses separate projects for each build target type within its workspace.

For example: UnrealGame (Mac), UnrealGameEditor (Mac), and UnrealGame Server (Mac) each would be separate projects under the Mac workspace.

Each project only allows the build configurations it supports. For example, Editor projects do not show the Test or Shipping configurations.

Frameworks are now handled using standard Xcode methods.

Whereas previous versions required developers to manually copy and codesign Frameworks, the build system now automatically discovers and codesigns them.

Improved Packaging and Distribution Process
All data needed to run is bundled inside self-contained .app files for each of Apple's platforms.

This includes macOS, which did not use this paradigm in previous versions of UE.

Automatic codesigning is now the preferred method for handling codesigning in development/debugging builds for both macOS and iOS/iPadOS/tvOS.

You can use Xcode to manage and distribute apps with Xcode archives, which are now the preferred way of creating shipping builds.

Shipping builds create an .xarchive file and a .dSYM file for this purpose.

Improved management of Entitlements and .plist files. Developers can now use templates or customized files for both of these assets.

For more details about these improvements, see our documentation on the modernized Xcode workflow.

iOS Workflows
iOS Workflows

UE 5.3 brings several improvements to development workflows for the iOS platform:

MallocBinned2 memory allocator can be used if your App ID contains the Extended Virtual Addressing entitlement.

Improved packaging and app signing thanks to a modernized XCode projects integration (see Modernized Xcode Projects above).

The Prepare for Debugging command, which streamlines the debugging pipeline, now offers Windows remote (experimental) and secondary Mac workflows. See the documentation on debugging in Xcode and using remote Macs for more details.

The iOS simulator is now supported on Apple Silicon Macs, allowing faster development iteration without devices (experimental).

Mobile Ray Tracing Support on Android (Experimental)
UE 5.3 supports ray tracing for high-end Android devices running the Mobile Desktop Renderer. Supported mobile GPUs include:

Adreno 740

Immortalis-G715

Samsung XClipse Series

To enable mobile ray tracing:

Enable the desktop renderer for your project.

Enable ray tracing.

Add the following to your device profiles:

[Android_Vulkan_SM5 DeviceProfile] 

+CVars=r.Android.DisableVulkanSM5Support=0
This update also includes mobile indline shadow support for ray traced shadows, which only works with deferred shading.

This support is experimental and should not be used for production purposes at this time. However, we welcome feedback from users trying it out!

Mobile Renderer
Mobile Renderer

The mobile renderer now includes several performance and visual quality improvements, notably:

Compute-based landscape vertex culling.

Fog volume support.

Global distance field generation on mobile forward.

Instance rendering improvements (GPU Scene).

Virtual texturing support.

Support for Nanite on Apple M2 Devices (Beta)
Nanite on Apple M2 Devices

Unreal Engine 5.3 brings beta support for Nanite rendering technology on Apple Silicon M2 devices running macOS. This support is enabled by default, with shader model SM6, in the UE macOS binaries downloadable from the Epic Games launcher, whereas the Experimental 5.2 support was only available when building from GitHub sources.

Character and Animation
Dynamic Workflows for Runtime and Non-Linear Cinematics
Dynamic Workflows for Runtime and Non-Linear Cinematics

This release focuses on improvements to runtime workflows and nonlinear organization.

User-Defined Dynamic Bindings
Use the Level Sequence Director Blueprint to define different objects, such as the player pawn, to either be dynamically possessed or spawned by Sequencer during runtime.

Material Section Blending
Similar to other track types, material typed sections can be added to tracks that support materials. This includes material parameter collections and UI animations in UMG.

Takes for Subsequences
Similar to the Shots track, takes for Subsequences can be created and set within Sequencer.

Comments for Takes
Add/edit/view comments to Shot/Subsequence Takes within Sequencer.

Text Track
Text properties can now have tracks in Sequencer, where users can change the value of a text field over time and key it.

Animation Retargeting
Animation Retargeting

This release focuses on quality-of-life improvements for Retargeting.

Toolbar in the Retarget Editor - This provides easy access to Global and Root settings along with the Retarget phases. Makes available mode switches between the Running the Retarget, editing the Retarget Pose, and viewing the Retarget Pose options.

Retarget Poses - Edit a bone's local space to zero out bone rotations.

Create IK rig/IK retargeter assets from a selected skeletal mesh/IK rig in the right mouse context menu.

Thumbnails for IK Rig and IK Retargeter assets.

Animation Authoring
Animation Authoring

Further improvements for animation authoring in this release include:

Smart Bake
Now allows you to target only baking keyframes.

Constraint baking

Space switch baking

Snapper

Collapse sections

Baking transforms

Smart Auto Tangent
New auto tangent that better maintains the curve shape.

Curve Editor Improvements
Improved normalized view

Improved performance with lots of keys

Better handle selection

More accurate marquee select

Fixes to zoom levels when auto frame is off

Motion Blending Improvements
Swap Root Bone works on animations with Root Motion Preview using AnimBP.

Skeletal animation sections can be extended backwards.

Export Improvements
Export control rig animations as a FBX file.

Skeletal Editor (Experimental)
Skeletal Editor

The Skeletal Editor provides a way for users to create skeletons and edit mesh skin weights directly in the Unreal Editor. This tool offers faster iterations by means of the addition of bones to your assets, the deformation of static meshes, and converting them to skeletal meshes, all in one place without the need for importing skeleton data.

Convert static meshes to skeletal meshes

Create and edit skeletons

Add bones

Remove bones

Orient and edit bones

Mirror bones

Create skin weights

Paint Weights brush tool

Edit weights on vertex selection

Flood / Relax / Prune / Average / Normalize operations

Mirror weights

Paint maps

Python API support for bones and weights

Machine Learning (ML) Deformer
Machine Learning Deformer

ML Deformer provides users a way to approximate a complex rig, nonlinear deformers, or any arbitrary deformation by training a machine learning model that runs in real time in UE.

Improvements in UE 5.3 include:

The addition of a masking system for Local Neural Morph Model, which improves the ability of users to work with structured data.

Improvements to the Nearest Neighbor model UI and workflow.

The removal of dependency on the NNI framework.

The ability to create training masks, and visualize the masks per bone / bone group / curve in the viewport.

There is no longer any need to take any manual steps (for instance, installing a Python package) for the Nearest Neighbor and Neural Morph models to train correctly on Windows.

The ability to run trained Neural Morph and Nearest Neighbor models on Linux and macOS (although training errors may be encountered).

Build Control Rigs from Data
We further extended the procedural toolset of Control Rig by providing a way for you to use data outside of the Control Rig graph to procedurally create and modify the rig. This includes:

The ability to query and use external data such as transforms, floats, skeletons, and more to build control rigs procedurally.

A new 'GetUserData' node that will query incoming data.

A new 'Set Shape Library from User Data' node that will swap the shape library currently being referenced.

Virtual Production
SMPTE 2110 for ICVFX
SMPTE 2110 for ICVFX

The Unreal Engine 5.3 release completes the implementation of a next-generation ICVFX stage deployment using an end-to-end SMPTE 2110-based IP video signal flow with nDisplay. SMPTE 2110 support enables productions to maximize the available hardware resources on stage, with this increased efficiency empowering the potential for higher-resolution inner frustums and lower latency.

With a SMPTE 2110-based configuration, productions will be able to:

Render the inner frustum once and share it with the other render nodes in the cluster, avoiding the redundancy of each node re-rendering the inner frustum for determinism.

Dedicate the resources of an entire render node to the inner frustum to leverage all available resources to display the highest-possible quality on the pixels seen in camera.

Framelock each render node with a native SMPTE 2110 sync policy that ensures Unreal Engine output remaining in phase with the camera.

Output the resulting renders to the LED processors using SMPTE 2110, eliminating the need for a display port and/or HDMI converters.

Virtual Camera
Virtual Camera

Takes Browser
We added the ability to browse for level sequences from the virtual camera and load them for review or as the base for your next recording, as well as to star, flag, or NG sequences to filter the list.

Multiple HUDs from a Single VCam
You can now add multiple output providers to a single VCamComponent each with its own HUD and stream. You can stream an operator's view, a simple burn-in, and a clean plate from one VCam, at the same time.

Time-Scaled Playback and Record
You can now play back and record at non-1:1 speeds. Record at a custom rate and your move will be sped up or slowed down when played back at full speed.

Initial macOS Support (Experimental)
VCamActor now supports streaming from macOS through legacy Remote Session. Virtual Camera Core, VCamComponent, VCamModifier, and VCamOutputProvider are available for use to create custom VCams on macOS versions of UE5. Development remains ongoing to bring Pixel Streaming and full VCam support to macOS.

CineCamera Rig Rail (Beta)
CineCamera Rig Rail

We've added a new rig rail actor tailored towards advanced cinematic and virtual camera workflows.

Plan your Composition
Store camera focus, iris, and zoom in rail points, allowing the rail to drive more complex aspects of your composition.

Drive the Rail
Automate your moves using a number of drive modes:

Manual: Drive your rail position from Sequencer or external input.

Duration: Drive your rail position to complete your move in a set amount of time.

Speed: Drive your rail position at a set speed.

Work with Sequencer
Points are stored by absolute value and can be safely keyed in Sequencer. As a result, the position value of a given point cannot change unless you directly modify the point. If you keyframe a particular position to occur at a given framing, it will not change regardless of how many new points are added before or after.

Visualize Your Speed
See your speed along any point of the rail through a heat map applied to the rail mesh and avoid any surprises when recording a layered move.

Choose your Axis Inheritance
Choose to only inherit subsets of axes from the rig rail. Drive position from the rail while refining rotation or choose to remove the Z axis for a steadier ride.

CineCamera Scene Capture Component (Beta)
CineCamera Scene Capture Component

We've added a Scene Capture component for CineCameras. You can accurately capture a CineCamera component to a render target for use in materials, UMG, and beyond. The feature supports lens distortion, together with CineCamera-specific properties and post-processing.

Anamorphic Lens Calibration Solver (Experimental)
Anamorphic Lens Calibration Solver

We've added an anamorphic lens model and solver to the lens tool to be used with lens assets, making it possible to solve anamorphic lens distortion. Using the lens component, you will also be able to add anamorphic lens model distortion to CineCamera actors to render distortion effects within the engine, making it possible to visualize shots using profiled anamorphic lenses. Manual parameters for the anamorphic lens model can also be adjusted to create anamorphic distortion looks.

OCIO for Texture Conversions
OCIO for Texture Conversions

The introduction of Working Color Space established a foundation for robust color management in Unreal Engine for critical operations such as configuring the input color space for textures, helping to ensure assets look correct regardless of where they may have been authored. Unreal Engine 5.3 expands upon this support with the ability to leverage OpenColorIO for these texture conversions. With this, Unreal Engine adopts an industry-standard framework to maximize consistency across the color pipeline for textures.

nDisplay Multiplayer Actor Replication
nDisplay Multiplayer Actor Replication

We've revised the nDisplay low-level networking architecture so that it can support actor replication in a multiplayer game context.

Transparent to the end user:

The feature can be activated in nDisplay Project Settings using the Cluster Replication Enabled option.

We've added a Multiplayer Server option to Switchboard.

Each nDisplay node becomes a networking client when joining a multiplayer session or game.

In the future, we hope to enable nDisplay Clusters to join a multiplayer session as opposed to individual nodes.

nDisplay Fill Derived Data Cache
nDisplay Fill Derived Data Cache

We've added the ability to "prime" nDisplay systems (stand-alone shaders) before first use by filling the derived data cache in advance. This feature can be triggered locally using the Build Menu or using Switchboard on all cluster Nodes.

The nDisplay cluster is then ready to be started without requiring any further shader compilation. You can schedule this operation offline at a time convenient to you, since it is exposed to Unreal Engine using a command line argument and can be triggered externally.

DMX Control Console UX
DMX Control Console UX

We are improving the new Control Console UI and UX with the following additions:

Two main layout modes:

Default, where only selected patches are visible

Manual, where you can define the fader group positions

A revised search mechanism for quicker DMX fader access

The ability to change fader values using relative or absolute controls

The ability to select which patches are actively sending DMX data

DMX Pixel Mapping UX
DMX Pixel Mapping UX

The DMX Pixel Mapping tool has received a significant facelift and now offers an improved UI and UX, among other fixes:

A new input filter section enables you to downscale, blur, and perform material-based logic on the incoming pixels.

DMX library manipulation is consistent with the new UX provided by the Control Console. This works hand-in-hand with the hierarchy view so that you can see which patches have been added and which remain.

Media IO Media Plate Material System
Media IO Media Plate Material System

We've improved the current media plate actor material system, giving you the ability to:

Pick a material directly from the Media Plate Plugin Content directory using the new auto-populated dropdown.

Browse to the Media Plate Plugin Content directory for quick access.

Also, we enabled the Output Depth and Velocity flag in the default media plate materials for increased TSR/TAA image stability when there is camera movement relative to the media plate actor(s).

Simulation
Chaos Cloth Editor Foundation (Experimental)
Chaos Cloth Editor Foundation

Chaos Cloth for UE 5.3 includes the addition of an experimental Cloth Editor.

The new Cloth Editor enables having multiple garments per character and the same garment across multiple characters in the future. It also provides panel-based workflows which will make it easier to set up and modify clothing setups. It includes the following features:

New base class editor for character physics (cloth/flesh).

First phase of panel-based editor with the Dataflow graph.

Non-destructive workflow.

Cloth is extracted from the skeletal mesh as a separate component.

Extra collision support.

New Skin Weight Transfer tool.

Masks are now replaced by reusable weight maps.

Multiple Materials can be driven by single sim mesh support.

See the Panel Cloth Editor Overview for more information about this feature.

Chaos ML Cloth (Experimental)
Chaos ML Cloth

Cloth simulation can be too expensive for many use cases. Artists, engineers, and game designers need alternative, less-expensive runtime solutions to mimic cloth simulation, especially for tighter fitting clothes. Currently, this requires a tedious process of hopping back and forth between DCC to simulate and importing results back into the engine.

For UE 5.3, artists can now simulate and train cloth in engine using the experimental Chaos Cloth Generator plugin.

See the Machine Learning Cloth Simulation Overview for more information about this feature.

Chaos Rigid Bodies and Scene Queries
We made several updates and optimizations to Chaos Physics to give artists, developers, and programmers better simulation results, notably on rigid body simulation and scene queries.

The continual focus on rigid bodies is low-level optimization including SIMD, cache coherency, functional removal, reduction in data copying, and so on.

Scene queries implement a dynamic acceleration structure that is now quicker to update and query.

Chaos Destruction
Fracture editor updates
A new material has been added, to help with fine control when managing and assigning material for a geometry collection.

Fracture Editor Material

The proximity tool has been improved with better visualization control and new contact method for generating the connection graph.

Fracture Editor Proximity Tool

The level statistic now shows aggregate convex information, which is useful when optimizing your geometry collection collisions.

Fracture Editor Level Statistic

Runtime Optimizations
The geometry collection component no longer ticks by default and will only tick after the geometry collection has been damaged. The runtime cost of the tick function has been also reduced.

Data types optimizations at the solver and attributes level have been made, reducing the cost of geometry collection assets on disk as well as the runtime memory cost of their instance.

Numerous optimization have been also done to reduce the overall CPU cost of geometry collection instances allowing for using destruction at larger scales.

A new experimental damage model has been introduce leveraging the physical properties of material and internal topology and connectivity of geometry collections.

Niagara Fluids
Niagara Fluids

We added the ability to transform Niagara Fluid sims after they are cached. This opens up the capability to duplicate a cache multiple times, and to offset the duplicates in time/space to get more complex effects from a single cached sim.

We added data channel support to the 3D Gas simulations. It is an experimental feature that provides a way to source fluid from any CPU system in the level. On the master emitter, the particle source now has two modes: Emitter and Data Channel. Emitter mode reads data from an emitter in the same system. Data Channel mode reads data from a predefined Niagara data channel. That data channel can be written to from the existing Set Fluid Source Attributes module.

Path Tracer now supports heterogeneous volumes, which means fluids can be rendered directly in it.

We added experimental support for SVTs (sparse volume textures); caching fluids now writes directly to SVT, which is an order of magnitude faster.

Niagara Summary View Editor
Niagara Summary View Editor

The Summary View Editor provides a way for users to create custom views of Niagara emitters. Using this, it is possible to expose only the most important settings and inputs for an emitter to end users. One heavy use case for this are the Niagara fluid emitters, which make it easier to make tweaks to achieve desired effects by looking at only a well-organized subset of settings. Users can rearrange and set up categories, sections, individual module inputs, or entire modules, as well as specific properties such as the Sprite material for Sprite renderers.

See the Summary View Quick Start for more information about this feature.

Audio
MetaSound Builder API
The MetaSound Builder API makes it possible to create and change a MetaSound graph through C++ or Blueprint APIs while the game is running in real time. This opens up the possibility of adding/removing MetaSound nodes and modifying connections during gameplay.

Audio Bus Writing
You can now take data from one MetaSound and send it to another MetaSound or to another source bus through a new MetaSound node.

MetaSound Output Watching (Experimental)
MetaSound Output Watching

MetaSound Output Watching provides a way for Blueprint or C++ to watch for changes in the MetaSound graph. This means users can match gameplay and visuals to events happening in MetaSounds. As an example, you can affect gameplay elements and visuals according to a musical beat, or change in audio.

This supports the ability to:

Fire an event when there are value changes on the provided MetaSound output of types float, int32, Bool, and fstring types.

Fire an event when the envelope follower on an audio output changes.

UI Systems
Common UI (Beta)
Common UI

Common UI provides a toolbox for creating rich, multi-layered user interfaces with cross-platform support. It includes:

An input action system specific to UI.

An input-routing system that makes it easier to selectively exclude menus from capturing input.

A styling system that provides style assets for commonly used text/fonts, borders, and buttons.

A library of other commonly used widgets.

Improvements in this release include:

Integration with enhanced inputs

Input debugging

Documentation and content examples

Font DPI Matching in UMG
Font DPI Matching in UMG

Designers can now match their font sizes seamlessly when they convert UI mockups into UMG screens, without worrying about DPI mismatch.

Newly created projects will have the DPI setting defaults to 72 DPI.

Existing projects will remain at 96 DPI.

Switching back and forth between different DPI settings will not affect how fonts are rendered.

See the documentation on Font DPI Scaling for more details.

Viewmodels in Blueprints
Viewmodels in Blueprints

Whereas previous versions of Unreal required designers to create Viewmodels in C++, in UE 5.3 you can now create Viewmodels in Blueprint. This update streamlines the process of creating and binding Viewmodels in various ways.

Extend the MVVMViewmodelBase class to create a new Viewmodel Blueprint.

Create variables as you normally would with Blueprint, then designate them as FieldNotify variables by clicking the bell icon next to their names.

Create FieldNotify functions to handle operations that don't need dedicated variables, then use your FieldNotify variables to trigger them.

Add your Viewmodel to your widget class using the Viewmodels panel.

New click-and-drag functionality makes binding Viewmodels to UI fields quicker and easier.

See the Viewmodel documentation for full instructions on how to use Blueprint-based Viewmodels in your project.

Modeling
Modeling Workflows (Beta)
Modeling Workflows

Artists developing assets require efficient modeling, sculpting, UV editing, and texturing workflows. These workflows are more than just a couple of different tools clicked in a certain order. Every type of interaction needs to be considered in order to reduce the number of mouse clicks, minimize the cursor movement, and provide accurate feedback for the artist.

With this aim in mind, improvements in UE 5.3 include:

New UI
Modeling Mode's main menu, tools palettes, and properties panels have been redesigned. The new UI is more compact, allowing for more efficient and consistent workflows. The new menu also contains a new favorites option, providing a top-level custom menu that can be defined per user.

Tool Presets
Creators and developers can now make custom presets for modeling tools. The custom presets provide a way for artists to store multiple options for tools, and access them quickly from the tool icon.

Element Selection
Direct mesh element selection provides for a more consistent and optimized workflow. The existing method of selection requires the artist to select the mesh first, then the specific tool, and finally the element before invoking the operation. The new element selection workflow enables artists to select the mesh, select the element, and then invoke an operation without any need to use an intermediate tool like PolyEdit or TriEdit.

Modeling Tools (Beta)
Modeling Tools

The Modeling Mode's toolset continues to develop. For UE 5.3, we added some requested enhancements to the toolset, in addition to new tools that use splines. The new element selection mode is also supported with a set of dedicated tools.

Spline Tools
We've added new tools to the Create menu that provide creators with a way to draw new splines, and use them for revolves and flat mesh operations.

Element Selection Tools
The Element Selection workflow leverages a new menu of tools that work directly with the selection. The palette includes common tools such as Extrude, Bevel, Offset, Inset, and Insert Loops. There is also quick access to PolyGroup and Triangle Edit.

LOD Support
The Bake Transform and Edit Pivot tools can now optionally update all LODs with the new transform or pivot.

Vertex Color Paint
We added a new tool for painting vertex color. The new tool enables users to paint, fill, and blend colors to multiple or specific channels.

Other Improvements
We made additional improvements to the Edit Normals, Weld, Bake Texture, and Generate PolyGroups tools.

To learn more about the available tools see Modeling Tools.

UV Tool (Beta)
UV Tool

UVs are a critical component when working with meshes, not only for final rendering but also as a vital part of level design. For UE 5.3, we added two important new features to the UV Editor:

UV Editor Distortion Display
The UV Editor now has optional display modes for distortion. This provides for an interactive representation of the level of texel stretch or density.

UV Auto Layout
The tool now has support for texel density normalization. This option attempts to resize individual islands to maintain a constant, average density over the entire layout.

To learn more about UV tools see, UV Editor.

Geometry Scripting (Beta)
Geometry Scripting provides technical artists a toolkit for creating custom modeling tools and workflows. In 5.3 Geometry Scripting is now beta and continues to expand with the following additions and improvements:

Enhanced skeletal mesh interoperability provided by several new nodes:

CopyBonesFromMesh

TransferBoneWeightsFromMesh

GetRootBoneName

GetBoneChildren

GetAllBonesInfo

GetBonesInfo

DiscardBonesFromMesh

New functions for managing 2D polygons and paths, including computing offsets and their booleans:

Polygons Difference

Polygons Union

Polygon Intersection

And many more, there is a large library of functions.

Delaunay triangulation to create a mesh that interpolates points:

Append Delaunay Triangulation 2d

Geodesics on mesh surfaces:

GetShortestSurfacePath

GetShortestVertexPath

To learn more about Geometry Scripting and the available functions, see Geometry Scripting User Guide and Geometry Scripting Reference.

Content Pipeline
Interchange Import / Re-Import
Interchange Import / Re-Import

In this release, the Interchange Framework includes the following improvements:

We added a new custom asset type to provide a way to re-import whole scenes.

The Interchange UI now supports overrides of pipeline stack per translator. This provides an extra layer of configurability and is used in default settings: for example, the glTF asset pipeline stack will override the default asset pipeline stack (used for FBX and OBJ).

For glTF import, you can now choose to have the editor either generate materials or use predefined material instances. You can also override those instances for more user control over glTF rendering.

USD MaterialX (Experimental)
USD MaterialX

Unreal Engine 5.3 offers the ability to use USD with MaterialX for streamlined workflows and content creation between DCCs and Unreal Engine. It is now possible to import a USD file with MaterialX shading networks directly in the engine.

Additionally, you can now open USD files with MaterialX shading networks in the USD Stage Editor while interacting directly with the contents of the USD file.

MaterialX support in Unreal Engine was introduced with 5.1 and is still experimental.

USD Materials and Textures
USD Materials and Textures

For Unreal Engine 5.3, there have been a few changes to how textures and materials are handled to improve the display of USD assets:

We added support for multiple UV sets on the same material.

We added support for simple UV transforms on preview surface materials. If you are loading a preview surface using any math nodes to transform the texture, it will now display correctly.

We added the ability to interactively change USD materials in the USD stage editor Details panel and see the result live in the viewport. Previously, the user would be required to save the USD file and reopen it in order to see any changes.

USD Animation
USD Animation

Direct Geometry Cache Import
We added the ability to directly import cached geometry into UE from a USD file. Prior to this, you could only load the USD file on the stage and play back the geometry cache animation from there.

Support for Transient Actors in Sequencer
We added support for transient actors in Sequencer. This provides a way for you to add elements from the USD stage actor to Sequencer, reload the USD file or to close and reopen Unreal Engine, and Sequencer will remain connected to the elements being animated from the USD stage actor. This also means you can now maintain sparse key animation curves that will drive the elements from the USD stage actor being animated, and the baked animation can be exported to a new USD file. USD stage actors can now be exported as well, so animation of their elements can be exported as overrides on the referenced stages.

Framework
Smart Objects - World Partition Support
Smart Objects and World Partition

Smart Objects now work seamlessly with World Partition, data layers, and persistent levels. We also improved Smart Objects to support using navmesh and physics for slots availability.

Blueprint Type Change Auto-Casting
Blueprint Type Change Auto-Casting

Deprecating code-based Blueprint-visible properties and changing the type of the properties can include challenges such as failures when rewiring old pins. This leads to orphaned pins and compilation errors.

In UE 5.3, if both types have an auto-cast function available, a cast node will automatically be created and added into the graph. Additionally, notes will be created whenever a new cast node was added, which serves as a notice that users might want to update their API to use the new type change.

Data Asset Merging
Data Asset Merging

As a first step towards adding functionality beyond what the Diff tool offers, we started investigating a data merge solution. This first version provides support for manually merging data assets when conflicts cannot be auto-resolved.

Currently only data assets are supported, but we hope to support more types of data in the future.

Review Tool Swarm Comments
Review Tool Swarm Comments

The Review Tool introduced in 5.2 now has direct Swarm integration when using P4 as source control, so the diffs you perform from there will directly show the comments in the editor. You can have comments for each change made, but also leave global review notes. We use simple metadata tagging in Swarm to link the comment to the right section of the diff.