Movie Render Queue & Output

The real-time viewport is optimised for responsiveness - it must draw each frame in milliseconds, so it uses temporal techniques that reuse information across frames. Temporal anti-aliasing (TAA) and Lumen's temporal accumulation look smooth in motion but leave tell-tale artefacts in a captured frame: ghosting behind moving edges, shimmer on fine detail, noise in reflections and shadows that has not had time to resolve. You would never notice while iterating; you absolutely notice in a delivered film paused on a frame.

The old way to grab footage was a screen capture or the legacy Sequencer Render Movie, both of which basically record the compromised viewport. The Movie Render Queue is the modern, high-quality replacement - enable it as a plugin (it ships with Unreal Engine 5), and a Render button appears on the Sequencer. MRQ decouples rendering from the frame budget: it can spend a second or several per frame, rendering each one many times over and averaging the results. That is the core trick - trade real-time speed, which you no longer need for a final, for image quality you do. You keep the viewport for building the shot and switch to MRQ only to deliver it.

It helps to name the artefacts you are trying to remove, because each has a cause. Ghosting and smearing behind moving edges come from temporal anti-aliasing reusing the previous frame's data; shimmer or crawling on thin railings and distant mullions is aliasing the real-time budget could not fully resolve; and grainy noise in soft shadows, reflections and Lumen's indirect light is sampling that never converged inside a single 16-millisecond frame. None of these are bugs to file - they are the honest price of real-time responsiveness, and they are exactly what a slower, sample-accumulating render path erases. That is why the workflow splits cleanly in two: you spend all your building and iterating time in the fast viewport, where these compromises do not matter, and you switch to the Movie Render Queue only at the end, once, to turn the finished sequence into a clean file.

Open the Movie Render Queue, add your Level Sequence as a job, and click the config to add settings. The two that transform quality are the anti-aliasing samples. Spatial Sample Count renders the frame multiple times at slightly jittered sub-pixel positions and averages them - pure supersampling that kills edge aliasing and shimmer. Temporal Sample Count renders several sub-samples across the frame's time slice and averages them, which both anti-aliases and produces natural, filmic motion blur on moving cameras and objects. Multiplying them gives your total samples per frame (for example 8 temporal x 2 spatial = 16); more samples means cleaner and slower. For archviz, something like 8-32 total is a common quality range - push higher for hero frames, lower for drafts.

The other essential is warm-up. Lumen's global illumination, TSR/temporal history, auto-exposure and effects like bloom take a few frames to converge from a cold start; if you render frame one immediately it will be darker, noisier or wrongly exposed. The Engine Warm Up Count (and render-warm-up frames) tells MRQ to run a number of throwaway frames before it starts capturing, so the lighting has settled - values in the tens are typical. Skipping warm-up is the single most common cause of a flickery first second or an opening frame that does not match the rest. You can also add a Console Variables setting to push specific quality cvars for the render (higher Lumen quality, shadow resolution) that would be too heavy to run live.

A sane way to dial this in is to render short test ranges rather than the whole film each time. Pick a few representative frames - one with motion, one with tricky reflections, one with deep shadow - and push the sample count up until the noise just disappears, then stop; every sample beyond 'clean enough' is pure render time you will pay on every frame. High Resolution tiling is a separate setting that renders the frame in tiles and stitches them, which lets you output print-scale stills far larger than your GPU could hold at once, at the cost of longer renders and some care with effects that span tile edges. And keep an eye on the motion-blur amount if you lean on heavy temporal sampling for fast moves - the defaults are sensible, but very fast motion with many temporal samples can smear more than you want, one more reason architectural cameras should move slowly.

Everything above renders through Unreal's normal real-time (deferred) renderer, just with more samples. But MRQ can also render your sequence through the Path Tracer - a physically accurate, ray-traced mode that simulates light bouncing the way an offline engine like V-Ray or Arnold does, producing reference-quality global illumination, soft shadows, accurate reflections and true caustics. It is the same scene and the same cameras; you simply switch the renderer for the final pass.

The trade is exactly the classic one this course keeps returning to: the path tracer is much slower and needs many samples to clear its noise (it converges by accumulating hundreds or thousands of ray samples per pixel), and it requires capable ray-tracing-class GPU hardware. So it is not for interactive work and often not needed at all - Lumen at high settings is convincing for the great majority of archviz. Reach for the path tracer when you want a hero still or a short sequence at absolute reference quality, or to validate that your Lumen lighting matches ground truth. It is the clearest expression of the real-time-versus-offline choice living inside one tool: same project, dial from interactive to reference depending on the deliverable.

The last block of MRQ settings is Output. The professional habit is to render to an image sequence - one file per frame (PNG for 8-bit, or EXR for high-dynamic-range 16/32-bit that preserves everything for grading) - rather than straight to a compressed video. A sequence is robust: if a render crashes at frame 900 you resume from 900 rather than losing the lot, and you can colour-grade or composite the frames before encoding. You then encode the sequence to a delivery video in an editor or with a tool like FFmpeg. MRQ can also output certain video containers directly (including high-quality Apple ProRes), which is convenient for quick turnarounds where you do not need a grading pass.

Set the resolution for the deliverable: 1920x1080 (Full HD) is the safe universal default; 3840x2160 (4K UHD) for a premium or big-screen presentation; and you can render higher with high-resolution tiling for print-scale stills. Match the frame rate to your Sequencer (24fps filmic, 30/60 smoother). Then reason about delivery: an MP4 (H.264/H.265) is the universal shareable video; ProRes is the editing-friendly master; a still frame from an EXR sequence is your print image. Remember the render time budget - samples x warm-up x resolution x frame count adds up, so a few minutes per frame across a 1,500-frame film is real hours; render drafts cheap and fast, and spend the samples only on the final. And keep the honest caveat in view: MRQ makes real-time output beautiful, but a single uncompromising hero still may still be worth a full path-traced or dedicated offline render - choose per deliverable, as always.

Colour management is worth a deliberate thought at output. Rendering to EXR preserves the scene's high-dynamic-range values, so you can grade highlights and shadows in an editor without banding; an 8-bit PNG or a compressed MP4 bakes the look in and leaves far less room to push. If you are handing footage to an editor, a 16-bit EXR sequence or a high-quality ProRes master travels better than a delivery MP4, which you generate last for sharing. Plan the file management too: a 4K EXR sequence for even a short film is many gigabytes, so name the output folder per shot, keep drafts and finals apart, and clear old test renders. Finally, sanity-check the encoded result on the screen it will actually play on - a film graded on a bright studio monitor can look muddy on a laptop or washed out on a projector, and catching that before delivery is the last, easily-forgotten step of a professional render.