Verification Checklist

This checklist covers recommended practice for working with RenderStream and Unreal Engine. Run through it before taking a project to stage, and see Scene Optimisation for alpha, frontplate and split-rendering settings.

Validation Framework

Netflix’s ValidationFramework plugin checks a project for potential nDisplay and RenderStream issues. More broadly, it checks for potential issues in virtual production workflows, such as in-camera VFX (ICVFX) and VR scouting.

The ValidationFramework plugin is installed in the project’s Plugins folder and enabled.
Each automatic fix has been reviewed before it was applied. The framework can fix some issues for you, but those fixes can change how the scene looks.

Supported Unreal Engine versions

The ValidationFramework plugin supports these Unreal Engine versions:

UE4.27+: Supported v1.0.1 only ✅
UE5.0: Testing ❗
UE5.1: Supported v1.1.0+ ✅
UE5.2: Supported v1.2.0+ ✅
UE5.3: Supported v1.3.0+ ✅
UE5.4: Supported v1.4.0+ ✅
UE5.5: Supported v1.5.0+ ✅
UE5.6: Supported v1.6.0+ ✅
UE5.7: Supported v1.7.0+ ✅

Project checks

The RenderStream plugin is in the project’s Plugins folder, and every plugin the project needs (such as nDisplay) is enabled.

Channel Definitions

A RenderStream Channel Definition has been added to each Cine Camera Actor in the scene.

Frontplate

Frontplate cameras are set to Default Visibility Hidden.
Every component that should appear in the frontplate is added to the Force Visible section.
Frontplate channels have Fog and Atmosphere disabled in the Channel Definition’s Show Flag Settings. Don’t remove or disable the fog and atmosphere actors themselves, because the backplate still needs them.

For alpha settings and frontplate channels, see Scene Optimisation.

Preparation for source control push

Before a push to source control, and especially after making any changes, test the Unreal scene by launching RenderStream from Designer:

Check for frame drops during operator camera movements.
Check for frame drops when triggering exposed parameters.
Test every exposed parameter by triggering it from a RenderStream Layer in Designer, to make sure nDisplay and RenderStream handle it as the artists intended.
Test every frontplate object to make sure it renders as the artist intended. Some objects need to be built as Actor Blueprints so that specific lighting can be attached to them, keeping their lighting correct on both the backplate and the frontplate.
Step through all view modes to check for expensive shaders, quad overdraw, light complexity and lightmap density. For more information on view modes, see Epic’s documentation. The view modes most relevant to optimisation are:
- Light Complexity
- Lightmap Density
- Stationary Light Overlap
- Shader Complexity
- Shader Complexity & Quads
- Quad Overdraw
If frame drops persist, use Unreal Insights to find the cause. Documentation on Unreal Insights is available from Epic here.

Derived Data Cache

For information about configuring the Derived Data Cache (DDC) with Disguise, see DDC Setup.

DDC Paks

If you download Unreal Engine from the Epic Games Store, the engine comes with a DDC Pak (.ddp). The DDC Pak contains derived data for all engine content, so you can start working without compiling shaders. Some samples ship with a DDC Pak for the same reason:

Engine DDC Pak, for example EngineDir/DerivedDataCache/Compressed.ddp
Project DDC Pak, for example ProjectDir/DerivedDataCache/Compressed.ddp

Optimisation

Optimisation is a complex subject influenced by multiple variables, including but not limited to:

The mobility of mesh actors and lighting actors
Render settings
The complexity of materials
The number of parent materials used, compared with material instances
The complexity of meshes, and in Unreal Engine 5 whether they are Nanite meshes
The complexity of lighting actors, and how many are in the scene

Profile before changing anything. Unreal Insights shows where the frame time goes, and Unreal Engine’s stat commands report performance figures while you work.

Recommendations

Use Oodle Texture compression to reduce package size and loading times. Smaller packages can also reduce frame-time spikes (hitches) when content loads during playback, for example through level streaming or World Partition.
Consider baking as much lighting as possible with GPU Lightmass, and avoid real-time ray-traced effects. GPU Lightmass requires Support Hardware Ray Tracing (Project Settings › Rendering › Hardware Ray Tracing), but Ray Traced Shadows and Ray Traced Skylight can stay disabled.
Use as few lights as possible. Rect Lights set to Stationary or Movable are typically much more expensive to render than Point Lights or Spot Lights with the same mobility, partly from shadow casting. Where the lighting doesn’t change, set Rect Lights to Static and bake them. The forward renderer doesn’t support Rect Lights, so if the project uses it (for example, for MSAA), use Spot Lights or Point Lights instead.
Disable Cast Shadows on individual Light Actors when they’re not needed.
Keep Reflection Capture Resolution (Project Settings › Rendering) at 512 or lower unless the scene needs sharper reflections. It sets the cubemap resolution for every reflection capture, and very high values can affect memory and performance.
If the frame isn’t split across render nodes, consider Temporal Super Resolution (TSR), and lower your screen percentage when using it.
If the frame is split across render nodes, temporal anti-aliasing (TAA, Temporal Upsampling or TSR) can produce ghosting or seams near tile borders. Where this happens, use FXAA instead, or MSAA if the project uses the forward renderer. See split rendering limitations.
If you’re using Lumen with tiled rendering, check for seams: Lumen’s screen-space traces are clipped at each tile’s border.
Don’t rely on Screen Space Global Illumination (SSGI) when the frame is split across render nodes. It only sees the pixels in each tile, so it can cause seams along the split. Baked lighting avoids the Lumen and SSGI seams. See Global illumination.

Nanite

Enable Nanite by default for static meshes, including foliage, trees and dense environment geometry. Nanite supports masked materials and foliage, with settings such as Preserve Area. The exceptions are:

Translucent materials: Nanite doesn’t render standard translucent passes.
World Position Offset (WPO): for meshes animated with WPO, such as heavily animated foliage, set a World Position Offset Disable Distance. Meshes that animate have to be redrawn into the Virtual Shadow Map, which invalidates its cache and adds GPU cost. The disable distance stops WPO on distant meshes, where the animation is too small to see. To keep WPO animation on a mesh but stop it invalidating the shadow cache, set Shadow Cache Invalidation Behavior to Rigid on the mesh component. The shadow may then no longer match the animation.
Very simple meshes: basic primitives, such as simple boxes, gain little from Nanite.

Optimise the amount of draw calls

UE[4] calculates scene visibility to cull objects that will not appear in the final image of the frame. However, if the post-culled scene still contains thousands of objects, then draw calls can become a performance issue. Even if we render meshes with low polygon count, if there are too many draw calls, it can become the primary performance bottleneck because of the CPU side cost associated with setting up each draw call for the GPU. Both UE4 and the GPU driver do work per draw call.

However, reducing draw calls is a balancing act. If you decide to reduce draw calls by using few larger meshes instead of many small ones, you lose the culling granularity that you get from smaller models.

Consider merging actors to reduce draw calls.
A merged mesh has one draw call per material, so merging reduces draw calls most when the merged actors share materials.
Use the console variable editor.

General onsite advice

If an object can’t be seen, don’t render it.
Trees can be the biggest challenge, especially when filling a scene with them. High-poly tree assets with multiple material slots add draw calls (one per material slot) and GPU cost.
A visual LOD system can help, with better assets closer to the camera and lower-quality ones behind. A treeline texture plane is useful for the background.
Disabling all shadows and systematically re-enabling them can create the desired effect with a lighter-weight project. To compensate for highlights appearing flat as a result, alter the light function on the Directional Light to fake slight foliage shadows.
Replacing the Sky Atmosphere and Volumetric Cloud actors with a sphere that has an unlit material works well when the time of day doesn’t change in a scene.
To reduce volumetric fog artefacts such as banding, lower the View Distance in the Volumetric Fog settings of the Exponential Height Fog component, so its depth slices cover a shorter distance. Larger values extend the fog further but expose under-sampling artefacts. These console variables also control how the fog volume is sampled:
- r.VolumetricFog.GridSizeZ: the number of depth slices. Higher values give better quality but cost more.
- r.VolumetricFog.GridPixelSize: the size of each fog cell in screen pixels. For example, 8 means one cell covers an 8 × 8 block of pixels. Lower values give sharper fog around geometry but cost more.
- r.VolumetricFog.DepthDistributionScale: how the depth slices are spaced with distance from the camera. The slices are packed more tightly near the camera.
Fast-changing lights, such as lights animated through exposed parameters, can leave lighting trails in volumetric fog. This is a side effect of the fog’s temporal reprojection. To remove a light’s contribution to the fog, set the light’s Volumetric Scattering Intensity to 0.