ComfyUI-DLSS5-NR

Unofficial, experimental ComfyUI integration for NVIDIA DLSS 5 Neural Rendering (NGX feature 18).

The node runs Neural Rendering in-process inside ComfyUI through a small native D3D12 bridge. It does not launch a helper executable and it does not write temporary image files.

ComfyUI IMAGE
    -> Python/ctypes
    -> dlss5nr_bridge.dll
    -> D3D12 + NGX
    -> nvngx_dlssnr.dll (feature 18)
    -> ComfyUI IMAGE

Current v0.3.0 still uses CPU staging for the ComfyUI tensor transfer:

Torch IMAGE -> CPU float32 -> D3D12 RGBA16F -> DLSS NR -> CPU float32 -> Torch IMAGE

There is no subprocess or disk round-trip. CUDA/D3D12 interop is planned as a later optimization.

ComfyUI receives frame-by-frame progress updates while an IMAGE batch is processed.

v0.3.0 uses an explicit motion-vector temporal path and adds per-frame motion estimation through the NVIDIA Optical Flow Accelerator (NVOFA).

Only two batch modes remain:

still images
    Reset=1 for every image
    no temporal history
    no motion-vector resource

temporal
    frame 0: Reset=1 + explicit zero R16G16_FLOAT MV
    frame 1+: Reset=0 + NVIDIA Optical Flow MV from raw previous/current input frames

Temporal flow is estimated from the raw input frames, never from the DLSS-processed output:

previous raw frame ----\
                        > NVIDIA Optical Flow -> current-to-previous MV -> DLSSNR.MVec
current raw frame -----/                                      |
                                                              + DLSS temporal history

Implementation details in v0.3.0:

• private D3D11 device on the same NVIDIA DXGI adapter used by the D3D12/NGX bridge;
• driver-provided nvofapi64.dll (no separate model/download);
• NVOFA output grid: 2x2;
• NVOFA performance level: FAST;
• input to NVOFA: 8-bit luma in B8G8R8A8_UNORM;
• native NVOFA flow: coarse R16G16_SINT, S10.5 fixed-point (1/32 pixel);
• conversion to full-resolution R16G16_FLOAT using nearest-cell reconstruction;
• the DLSSNR MV texture stores normalized UV motion and uses MVecScale=(width,height);
• NVOFA is called with current frame as input and previous frame as reference, producing the current-to-previous reprojection direction used by the temporal contract;
• NVOFA temporal hints are disabled in v0.3.0 so each frame pair is deterministic and a new ComfyUI batch can reset cleanly.

The first frame has no previous frame, so temporal mode bootstraps it with an explicit zero-MV field.

• Windows 10/11 x64
• NVIDIA RTX GPU
• Recent NVIDIA display driver
• NVIDIA Optical Flow driver API (nvofapi64.dll) for temporal mode
• A compatible, legally obtained nvngx_dlssnr.dll
• ComfyUI with Python, PyTorch and NumPy

NVIDIA Optical Flow hardware is available on Turing-generation NVIDIA GPUs and newer; all GeForce RTX generations satisfy that hardware-generation requirement. GPU support for Neural Rendering itself is still determined by the specific nvngx_dlssnr.dll you provide.

A 0xBAD00001 result means the Neural Rendering runtime rejected the feature on the current GPU/runtime/driver combination.

Do not download GitHub's automatically generated Source code.zip if you do not want to compile anything.

1. Open Releases for this repository.

2. Download ComfyUI-DLSS5-NR-vX.Y.Z-windows-x64.zip.

3. Extract the contained ComfyUI-DLSS5-NR folder to:

   ComfyUI/custom_nodes/ComfyUI-DLSS5-NR
   

4. Supply your own compatible NVIDIA Neural Rendering runtime:

   ComfyUI-DLSS5-NR/runtime/nvngx_dlssnr.dll
   

5. Restart ComfyUI.

6. Add experimental -> DLSS 5 NR -> DLSS 5 Neural Rendering (Unofficial).

The release ZIP already contains the project-owned native files:

native/bin/dlss5nr_bridge.dll
runtime/caller/nvngx.dll_comfy.dll

Visual Studio / MSVC is not required for normal installation.

The prebuilt Windows release ZIP intentionally contains only the files needed to run the node. Developer tools, native source code, workflows and extended documentation remain in the repository and GitHub source archives.

Do not normally copy _nvngx.dll yourself. The bridge attempts, in order:

1. runtime/_nvngx.dll as an explicit local override;
2. normal Windows DLL search;
3. automatic discovery in NVIDIA DriverStore packages matching nv*.inf_*.

The project does not redistribute _nvngx.dll.

Do not download or bundle nvofapi64.dll. It is supplied by the NVIDIA display driver and is loaded from the normal Windows driver installation when batch_mode = temporal.

still images does not initialize NVOFA.

Only developers building from source need Visual Studio Build Tools.

Requirements:

• Visual Studio 2022 Build Tools or Visual Studio 2022 with Desktop development with C++
• Windows 10/11 SDK

Run from a normal cmd.exe or PowerShell window:

build_native.bat

The builder locates MSVC and the Windows SDK directly; a Developer Command Prompt is not required.

Outputs:

native/bin/dlss5nr_bridge.dll
runtime/caller/nvngx.dll_comfy.dll

The bridge now links the standard Windows d3d11.lib in addition to D3D12/DXGI. nvofapi64.dll is loaded dynamically at runtime and is not linked or redistributed.

Output resolution is identical to input resolution. This node is Neural Rendering/post-processing, not DLSS Super Resolution.

DLSS 5 NR Runtime Info reports:

• plugin version;
• native bridge version;
• selected GPU name/index;
• whether the NVIDIA Optical Flow D3D11 API is visible;
• temporal NVOFA grid/performance settings;
• runtime directory;
• size and SHA-256 of the supplied nvngx_dlssnr.dll.

Use it first when diagnosing a new runtime/GPU combination.

If you are a normal user, you probably installed GitHub's Source code archive instead of the prebuilt Windows release ZIP. Download the release asset. Developers can run build_native.bat.

Place your compatible runtime at:

runtime/nvngx_dlssnr.dll

This repository intentionally does not provide download links or mirrors for proprietary/leaked NVIDIA binaries.

The bridge searches NVIDIA DriverStore automatically. As a diagnostic fallback:

Get-ChildItem "$env:SystemRoot\System32\DriverStore\FileRepository" -Filter _nvngx.dll -Recurse -ErrorAction SilentlyContinue |
  Sort-Object LastWriteTime -Descending |
  Select-Object FullName, LastWriteTime, Length

A matching driver copy can be placed at runtime/_nvngx.dll as a local override. Do not rename nvngx_dlss.dll; it is a different component.

This only affects temporal mode. Verify that a recent NVIDIA display driver is installed. Run diagnose_runtime.bat; it reports the driver copy under %SystemRoot%\System32 when present.

Do not download nvofapi64.dll from third-party DLL sites.

Attach the complete ComfyUI exception and DLSS 5 NR Runtime Info output to an issue. The native bridge includes the driver's own NVOF last-error text when available.

Feature not supported by the supplied Neural Rendering runtime on the selected GPU/driver combination. Use a runtime that legitimately supports your configuration.

The observed Neural Rendering snippet rejected the caller. The release includes the project-owned thin caller helper expected by this integration. If this occurs with an untouched release ZIP, open an issue and attach the full ComfyUI error log plus the Runtime Info output.

Try channel_order = RGBA or BGRA. auto compares both interpretations against the source and normally selects the plausible one.

v0.3.0 uses only still images and temporal; the older temporal sequence / temporal sequence (legacy no MV) values are no longer valid. Delete and re-add the node, or change the saved widget to one of the two current values:

still images
temporal

Tags matching v* trigger the Windows release workflow. GitHub Actions:

1. checks that NVIDIA proprietary DLLs were not committed;
2. builds the native bridge, NVIDIA Optical Flow integration and caller helper on windows-latest;
3. assembles a clean user ZIP with the prebuilt project-owned DLLs;
4. writes a SHA-256 checksum;
5. creates the GitHub Release.

See docs/PUBLISHING.md.

Useful references include:

• NVIDIA DLSS / NGX public repository: https://github.com/NVIDIA/DLSS
• NVIDIA Optical Flow SDK public repository: https://github.com/NVIDIA/NVIDIAOpticalFlowSDK
• NVIDIA Optical Flow programming guide: https://docs.nvidia.com/video-technologies/optical-flow-sdk/nvofa-programming-guide/index.html
• Zonnery experimental DLSS 5 NR player/reference: https://github.com/Zonnery/dlss5-nr-player
• NIGos DLSS5 bridge: https://github.com/NIGos/dlss5-bridge
• NVIDIA RTX nodes for ComfyUI: https://github.com/Comfy-Org/Nvidia_RTX_Nodes_ComfyUI

The NVOF D3D11 function-table integration and measured flow-direction/normalization behavior were informed by the MIT-licensed NIGos dlss5-bridge; attribution is retained in THIRD_PARTY_NOTICES.md.

No NVIDIA runtime DLLs or NVIDIA SDK headers are vendored in this repository.

The project's original source code is MIT licensed. NVIDIA trademarks, SDK/API names and proprietary binaries are owned by NVIDIA and are not covered by this project's MIT license.

This project does not redistribute:

• _nvngx.dll
• nvngx_dlssnr.dll
• nvofapi64.dll
• other NVIDIA runtime binaries
• NVIDIA NGX/Optical Flow SDK headers

The integration uses undocumented/pre-release Neural Rendering behavior, including a thin caller-forwarding helper and observed project/application identifiers. Before distributing or using this project, review the terms that apply to the NVIDIA software/runtime you use. See THIRD_PARTY_NOTICES.md and docs/LEGAL_NOTES.md.

v0.3.0 is the first stable project release with the explicit motion-vector temporal path and NVIDIA Optical Flow for real frame-to-frame motion. The integration remains unofficial and experimental with respect to the NVIDIA Neural Rendering interface.