NVIDIA NRD: real-time denoising for path traced rendering

What NRD is and what problem it solves in a renderer

NVIDIA Real-time Denoisers, NRD, is described as an API-agnostic, spatio-temporal library designed for high-quality denoising of noisy signals, focusing primarily on, but not limited to, one path per pixel path tracing.

The two words that matter in that sentence are spatio-temporal. Spatial filtering alone blurs an image, which removes noise but also removes detail the sample count was supposed to produce. Temporal filtering alone smears. A spatio-temporal denoiser uses information across both space and time, so it can borrow detail from previous frames, where more samples have accumulated, and apply it to the current frame.

The way NRD does that is through guides. It uses per-pixel G-buffer data, normal, roughness, viewZ and motion vector, to resolve noise on opaque surfaces. Those guides tell the filter which pixels belong to the same surface and how they have moved, which is what stops the filter from bleeding one object's shading across the silhouette of another.

The library is engineered to handle both static and dynamic lighting, and the README is clear about the scope. It says NRD is used in more than fifteen AAA game titles and in ProVis applications, naming Autodesk Aurora, Enscape and Lumion among them.

Two claims in the README are worth holding apart. The first is that the modern SH mode achieves quality comparable with DLSS-RR while being a non-AI alternative. The second is that it holds its own in an AI-dominated world. The first is a comparison with a named product; the second is a framing statement. Both are the project's own claims, and neither is a benchmark you can verify from the repository.

The three denoisers and what each one handles

NRD contains three denoisers, and they divide the work by signal type rather than by quality tier.

REBLUR is a recurrent blur based denoiser. It is the general workhorse: diffuse and specular radiance, with spherical harmonics variants that are actually spherical Gaussian, as the README clarifies. It also handles ambient and specular occlusion variants, and a directional occlusion variant for ambient directional occlusion.

RELAX is an A-trous based denoiser designed for RTXDI, the RTX Direct Illumination model. It handles diffuse and specular radiance with the same SH or SG variants.

SIGMA is a per-light shadow-only denoiser. It handles shadows from an infinite light source such as the sun or the moon, or from a local light source such as an omni or a spot, and it has a separate variant for shadows with translucency.

The split tells you something about the intended pipeline. SIGMA operates on a single light's shadow contribution, which is a small, well-defined signal. RELAX and REBLUR operate on the accumulated radiance of the frame, which is where the heaviest noise lives, and the A-trous wavelet structure of RELAX is what lets it filter at multiple scales while keeping edges.

The README gives performance figures on an RTX 4080 at 1440p native resolution with default settings, a specific normal encoding and a 3x3 area hit distance reconstruction mode. REBLUR diffuse and specular takes 2.55 milliseconds, or 3.40 in SH mode, with the anttifirefly option adding zero to two percent. RELAX takes 3.25 milliseconds, or 4.80 in SH mode, with antifirefly adding seven to ten percent. SIGMA shadow is 0.40 milliseconds and the translucency variant 0.45.

Those numbers are for one GPU and one configuration. What they show is the relative cost, and that ant-firefly filtering is not free.

Two integration routes, and the host/shader split

NRD is distributed both as source and as a ready-to-use precompiled library, and it can be integrated into any D3D12, Vulkan or D3D11 engine by two routes.

The first is the NRI-based integration layer, provided as part of the SDK. In this case the engine exposes native GAPI pointers for certain object types. NRI is the abstraction layer that lets one codebase target several graphics APIs, and the integration layer handles the API-specific plumbing for you.

The second is a native implementation of the NRD API using the engine's own capabilities, which is the route for an engine that already has everything it needs and wants to avoid pulling in the integration layer.

The workflow divides into host code and shader code, and this is the part that needs planning before you write code.

On the host side, you build with NRD_NRI turned on, use the integration layer, understand the inputs, set inputs and outputs through a ResourceSnapshot, and on each frame call NewFrame, SetCommonSettings, SetDenoiserSettings and Denoise.

On the shader side, you include NRD.hlsli and use the front end helpers, NRD_FrontEnd_Spec variants and NRD_FrontEnd_TrimHitDistance, in your path tracer, then use the pack functions, RELAX, REBLUR and SIGMA front end pack helpers along with REBLUR_FrontEnd_GetNormHitDist, to pack the noisy inputs. NRD_MaterialFactors converts noisy irradiance into radiance before packing, which removes the materials, and the same helper converts denoised radiance back to irradiance after unpacking, which puts them back. The back end unpack functions handle the outputs, and for the SH denoisers you apply the SG or SH resolve and re-jittering.

That material round trip is the concept that catches newcomers. The denoiser works on radiance, and the renderer works on irradiance times the material, so the conversion happens twice, and getting the order wrong produces an image that looks denoised and is subtly wrong.

Building the SDK and the options that matter

The build needs CMake 3.30 or newer, and there are two routes.

The first is the explicit one: clone the project with its submodules, then generate and build with CMake. To produce a binary with a static MSVC runtime, you add `-DCMAKE_MSVC_RUNTIME_LIBRARY="MultiThreaded$<$<CONFIG:Debug>:Debug>"` when deploying. That flag matters for distribution, since a precompiled library that assumes a particular runtime redistributable is a common source of deployment friction.

The second is the script route, with one script per stage:

Scripts/<Platform>/1-Deploy
Scripts/<Platform>/2-Build
Scripts/<Platform>/3-PrepareSDK
Scripts/<Platform>/4-Clean

The platform is Windows or Linux, and you use the .bat files on Windows and run the .sh scripts with bash on Linux.

The CMake options are where most of the practical decisions sit. NRD_NRI pulls, builds and includes NRI in the SDK package and is required to use the integration layer, and it is off by default. Three options control shader embedding: NRD_EMBEDS_DXBC_SHADERS and NRD_EMBEDS_DXIL_SHADERS, both on by default on Windows, and NRD_EMBEDS_SPIRV_SHADERS, on by default everywhere. NRD_SHADERS_PATH overrides the shader output path.

The compile-time switches are described as switches you should prefer to disable, to increase performance, which is an unusual framing and a useful one. NRD_STATIC_LIBRARY builds a static library. NRD_NORMAL_ENCODING and NRD_ROUGHNESS_ENCODING set the encoding for the entire library rather than per call. NRD_SUPPORTS_VIEWPORT_OFFSET enables the input and output rect origin settings, off by default. NRD_SUPPORTS_CHECKERBOARD is the last one shown in the README, cut off mid-description.

The last group is the shading backends. A backend you do not ship should not cost you shader memory or build time, and the compile-time switches are how you avoid that.

Where NRD stops: volumetrics, transparency and the sample workaround

The README states the limitation directly. NRD is not natively designed for volumetrics or transparency.

That is a bigger constraint than it first sounds. Volumetric fog, smoke and participating media produce noise with a very different spatial structure from opaque surfaces, and a denoiser that assumes opaque geometry with valid depth and normal guides cannot handle them correctly. Any project whose visual appeal depends on volumetrics is outside what NRD does well.

Transparency has a workaround rather than a fix. The NRD sample demonstrates a denoising-free glass rendering path that combines SHARC, reprojection of the currently denoised frame, and dithering, delivering the result through TAA or upscaling. The idea is that glass is handled by a different path entirely, with the denoised frame reprojected to supply the background and dithering used to break up the residual artefacts. It works, according to the README, and it is more machinery than the direct path.

Two further limits are worth naming. The performance figures are for one GPU, one resolution and one configuration, and the ant-firefly overhead varies from zero to two percent for REBLUR but seven to ten percent for RELAX, so the configuration that removes fireflies on a difficult scene is a real cost. And the whole design assumes G-buffer guides exist, so a renderer without normals, roughness, viewZ and motion vectors would have to produce them before it could use NRD at all, which is a pipeline change rather than a library call.

The README also notes that the NRD sample repository has a simplex branch, recommended, which focuses on path tracing and NRD best practices with less code and less preprocessor, and a main branch with everything needed for NRD development, testing and maintaining.

NRD against DLSS-RR and against a plain temporal filter

Two comparisons matter for anyone choosing a denoiser.

The first is against DLSS-RR, the ray-tracing reconstruction mode in the same product family. The README's claim is that NRD's modern SH mode achieves quality comparable with DLSS-RR while offering a non-AI alternative. The distinction that matters in practice is not accuracy but behaviour. A learned reconstruction model has a failure mode that a signal-processing filter does not: it produces plausible output for inputs unlike anything in its training distribution, and you cannot easily tell when that has happened. A filter based on recurrence, wavelets and temporal accumulation degrades in ways that are visible, usually as ghosting or blur, which you can diagnose.

That is the argument for a non-AI denoiser, and it is a real argument even when quality is otherwise equal. If your scene has unusual materials, unusual lighting or a camera cut, a learned model is where you will look first when something goes wrong.

The second comparison is against writing your own temporal filter, or using a simpler one. A path traced frame can be denoised with an exponential moving average over history, with a variance estimate to guide the blur. That is far less work than integrating NRD and produces a blurrier, ghostier image. NRD's contribution is the quality of the spatial filtering, using the G-buffer guides to keep detail that a plain accumulation would smear, and the per-light approach of SIGMA.

The trade is size and complexity. NRD is a library with shaders, a host integration layer, a set of per-frame calls and a build with several options. A hand-rolled accumulation filter is a few dozen lines in your own path tracer. If you need a good image and have the engineering budget, NRD is the better result; if you need a result this week, the simple filter may be the only realistic option, and it can be upgraded later.

Editorial conclusion

Adopt NRD when you are path tracing in real time on NVIDIA hardware and want a denoiser that does not depend on a learned model, particularly when your pipeline already produces normal, roughness, viewZ and motion vector guides. Do not adopt it for volumetrics or transparency, since the README is explicit that it is not natively designed for those. Verify first that your engine can expose the native pointers the NRI integration layer needs, that your graphics API is D3D12, Vulkan or D3D11, and that the shaders your backend needs are the ones you enabled at build time.

Frequently asked questions

Official sources

1. Issues
2. NVIDIA-RTX/NRD on GitHub
3. README
4. Releases