[{"data":1,"prerenderedAt":-1},["ShallowReactive",2],{"project-96064":3},{"id":4,"name":5,"fullName":6,"owner":7,"repo":5,"description":8,"homepage":9,"htmlUrl":9,"language":10,"languages":9,"totalLinesOfCode":9,"stars":11,"forks":12,"watchers":13,"openIssues":14,"contributorsCount":15,"subscribersCount":15,"size":15,"stars1d":15,"stars7d":15,"stars30d":16,"stars90d":15,"forks30d":15,"starsTrendScore":15,"compositeScore":17,"rankGlobal":9,"rankLanguage":9,"license":18,"archived":19,"fork":19,"defaultBranch":20,"hasWiki":21,"hasPages":19,"topics":22,"createdAt":9,"pushedAt":9,"updatedAt":31,"readmeContent":32,"aiSummary":33,"trendingCount":15,"starSnapshotCount":15,"syncStatus":34,"lastSyncTime":35,"discoverSource":36},96064,"ComfyUI-DLSS5-Enhancer","Blueforcer\u002FComfyUI-DLSS5-Enhancer","Blueforcer","NVIDIA DLSS 5 Neural Rendering (NGX feature 18) as ComfyUI nodes. Enhance image batches and video files with the real neural renderer, with optional upscaling.",null,"Python",106,7,1,3,0,5,43.21,"Other",false,"main",true,[23,24,25,26,27,28,29,30],"comfyui","comfyui-nodes","dlss","neural-rendering","nvidia","rtx","upscaling","video-enhancement","2026-09-20 04:01:32","# ComfyUI-DLSS5-Enhancer\n\nRun NVIDIA DLSS 5 Neural Rendering over your frames and videos, inside ComfyUI.\n\nDLSS 5 is NVIDIA's neural rendering pass. In a game it reconstructs the material and lighting\ndetail that real-time rendering has to leave out, such as skin subsurface scattering, light\ntransmission through hair and contact shadows, guided by the engine's own buffers. This node pack\ndrives that same renderer over video frames and image batches, with optional 1.5x to 3x upscaling.\nWithout those buffers what it recovers here is material response: skin, hair and fabric structure.\n\nIt is not a filter that imitates the look. Frames go to the native renderer and come back\nreconstructed.\n\n## Contents\n\n- [How it works](#how-it-works)\n- [Requirements](#requirements)\n- [Installation](#installation)\n- [Nodes](#nodes)\n- [Recommended settings](#recommended-settings)\n- [Example workflows](#example-workflows)\n- [Verification](#verification)\n- [Performance](#performance)\n- [Known limitations](#known-limitations)\n- [Troubleshooting](#troubleshooting)\n- [Project layout](#project-layout)\n- [Licensing and attribution](#licensing-and-attribution)\n\n## How it works\n\nIn games, DLSS 5 runs as \"3D-Guided\" Neural Rendering: the engine hands the model its rendered\nframe together with geometry, texture and lighting buffers, and motion vectors. Video has none of\nthat. What reaches the model here is the decoded frame plus motion vectors estimated from the\nfootage itself, so the guidance is weaker than in a game, and the reconstruction is correspondingly\nmore conservative.\n\nThere is no Python API for any of it. The renderer lives in a native D3D12 process that hosts\nReShade and the RenoDX DLSS 5 add-on and evaluates NGX feature 18. This node pack implements the\nclient side of that worker's binary protocol:\n\n```\n  ComfyUI node\n      |\n      |  RGBA8 frame + FP16 motion vectors + history reset flag\n      v\n  native D3D12 worker\n      (ReShade carrier -> RenoDX DLSS 5 add-on -> NGX feature 18)\n      |\n      |  RGBA8 reconstructed frame\n      v\n  ComfyUI node\n```\n\nEncoded video carries no motion vectors, so they are estimated per frame with dense optical flow\n(OpenCV DIS) and supplied at the render resolution, including automatic history resets on scene\ncuts. Everything else is handled here: session setup, dimension negotiation, frame ordering,\ncancellation and diagnostics.\n\nThe neural components themselves are NVIDIA, ReShade and RenoDX binaries. They are not part of\nthis repository and are not redistributed by it. See\n[Licensing and attribution](#licensing-and-attribution).\n\n## Requirements\n\n| Item | Requirement |\n| --- | --- |\n| GPU | NVIDIA ships DLSS 5 for the RTX 50 series. Through this community runtime it also runs on RTX 40 and 30. RTX 20 and older are refused |\n| Driver | Current NVIDIA GeForce driver |\n| ComfyUI | A build with the V3 node API (`comfy_api.latest`) |\n| Python | `numpy`, `av` and OpenCV. ComfyUI portable normally ships all three; `opencv-python` is deliberately not in `requirements.txt` so it cannot overwrite an existing `opencv-contrib-python` |\n\n## Installation\n\nAll commands below are run from the ComfyUI portable root, the folder containing\n`python_embeded` and `ComfyUI`.\n\n### 1. Install the node pack\n\nIn ComfyUI-Manager, search for \"DLSS5\" and install it there. Or clone it by hand:\n\n```bat\ngit clone https:\u002F\u002Fgithub.com\u002FBlueforcer\u002FComfyUI-DLSS5-Enhancer.git ComfyUI\\custom_nodes\\ComfyUI-DLSS5-Enhancer\npython_embeded\\python.exe -m pip install -r ComfyUI\\custom_nodes\\ComfyUI-DLSS5-Enhancer\\requirements.txt\n```\n\n### 2. Provide the runtime\n\nNothing is downloaded automatically. Run the setup script once:\n\n```bat\npython_embeded\\python.exe ComfyUI\\custom_nodes\\ComfyUI-DLSS5-Enhancer\\install_runtime.py\n```\n\nIt prints the licensing notice, asks for confirmation, downloads the third-party DLSS 5 Visual\nEnhancer release v3.0 from its GitHub releases page (about 467 MB, roughly 700 MB on disk after\nextraction) and extracts only its `bin\u002Fruntime` and `bin\u002Fffmpeg\u002Fbin` contents into the node\nfolder.\n\nIf you already have that application installed, register it instead of downloading again:\n\n```bat\npython_embeded\\python.exe ComfyUI\\custom_nodes\\ComfyUI-DLSS5-Enhancer\\install_runtime.py ^\n    --runtime-dir \"D:\\DLSS 5 Visual Enhancer\\bin\\runtime\"\n```\n\nRelease v3.0 is what this pack is built against; it speaks worker protocol version 4. An older\nrelease fails at session setup with a protocol message.\n\nAdditional flags: `--url` overrides the download, `--yes` skips the prompt for unattended\ninstalls, `--keep-archive` keeps the downloaded zip.\n\n**Antivirus:** the worker is an executable that must keep the file name `nvngx.dll`, because the\nsigned-snippet caller contract checks that name. Running a `.dll` as a process is a pattern\nWindows Defender and SmartScreen flag, so the file may be blocked or quarantined. If the node\nreports that the worker could not be started, add the `runtime` folder to your exclusion list.\n\nThe runtime location is resolved like this:\n\n1. the `runtime_dir` widget on the DLSS5 Settings node. When it is set, nothing else is tried\n2. otherwise, in order: the `DLSS5_RUNTIME_DIR` environment variable, `config.json` written by\n   `install_runtime.py`, and the bundled `runtime\u002F` folder inside the node pack\n\nffmpeg and ffprobe are resolved separately and only when the video node runs, before the render\nstarts, so a missing binary fails immediately rather than after the job: the\n`DLSS5_FFMPEG_DIR` environment variable, the `ffmpeg_dir` key in `config.json`, the bundled\n`ffmpeg\u002Fbin` folder, an `ffmpeg\u002Fbin` folder next to the runtime, and finally `PATH`.\n\n### 3. Restart ComfyUI\n\nThe nodes appear under **image\u002Fupscaling**. If you restart before installing the runtime, they\nload normally and only fail when executed, with a message that says how to install it.\n\n## Nodes\n\n### DLSS5 Settings\n\nCollects the neural rendering controls once and feeds both processing nodes. Several map onto the\ncontrols NVIDIA documents for game developers: `local_structure_strength` and\n`local_tone_strength` are the Structure and Tone intensities, `automatic_mask` is the semantic\nmasking that tells the model which regions are skin, `skin_structure_strength` is the strength\napplied inside that mask, and `dlss_model_preset` selects between models trained with different\nweights. The rest are add-on level controls, and some are inert on current runtime builds, which\nthe table notes.\n\n| Widget | Options or range (default) | Effect |\n| --- | --- | --- |\n| `upscaling_mode` | `1x (DLAA \u002F native)`, `1.5x (Quality)`, `1.724x (Balanced)`, `2x (Performance)`, `3x (Ultra Performance)` (1x) | 1x enhances at source resolution, the others also upscale |\n| `nr_preset` | Default, Preset #1, Preset #2, Preset #3 (Default) | Preset inside the neural rendering model. Measured to have no effect on current runtime builds |\n| `nr_style` | Default, Natural, Cinematic (Default) | Natural stays closer to the source, Cinematic pushes contrast |\n| `nr_intensity` | 0.00 to 2.00 (1.00) | Strength of the neural pass. Values above 1.00 have no further effect on current builds; below 1.00 blends back towards the source |\n| `local_tone_strength` | 0.00 to 2.00 (1.00) | Local tone mapping |\n| `local_structure_strength` | 0.00 to 2.00 (1.50) | Local detail and structure reconstruction |\n| `skin_structure_strength` | -1.00 to 2.00 (2.00) | Skin and pore reconstruction. Only active while `automatic_mask` is on, which is what locates the skin. `-1` leaves the decision to the model |\n| `automatic_mask` | off, on (on) | Let the model detect the regions it treats as skin. Also the gate for `skin_structure_strength` |\n| `dlss_model_preset` | Default, J, K, L, M (M) | Forces a specific model. Default, J and K are the softest; L and M reconstruct markedly more skin and hair texture. If the worker reports it applied a different preset, set this back to Default |\n| `motion` | auto, optical_flow, none (auto) | Motion vectors for temporal accumulation. `auto` skips them for single images |\n| `scene_change_threshold` | 0.01 to 1.00 (0.24) | Mean luminance change above which temporal history resets |\n| `warmup_frames` | 0 to 16 (0) | Extra frames the worker renders before the first output settles |\n| `runtime_dir` | path (empty) | Overrides runtime discovery |\n\n`motion`, `scene_change_threshold`, `warmup_frames` and `runtime_dir` are marked advanced and are\nhidden until advanced widgets are shown.\n\nOutput: `DLSS5_SETTINGS`.\n\n### DLSS5 Enhance Images\n\n`IMAGE` in, `IMAGE` out. The batch order is the temporal order, so feed video frames in playback\norder for temporal accumulation to work. A four channel input keeps its alpha, which is carried\nover rather than reconstructed. The node reports progress and honours the ComfyUI cancel button,\nterminating the worker on interruption.\n\n`verify_neural_rendering` (advanced, default on) fails the run when the ReShade log shows no\nsigned feature-18 execution.\n\n### DLSS5 Enhance Video File\n\nFile in, file out. Decoding, neural rendering and encoding run concurrently through bounded\nqueues, so a long video never enters the workflow as one large batch. Original timestamps,\nchapters and metadata are preserved. With `copy_audio` on, MKV stream copies audio and subtitles\nunchanged, while MP4 and MOV re-encode audio to AAC 192 kbit\u002Fs and drop subtitle tracks.\n\n| Input | Default | Notes |\n| --- | --- | --- |\n| `video_path` | empty | Absolute path to the source file |\n| `codec` | HEVC | H.264 and HEVC use NVENC with a libx264\u002Flibx265 software fallback. AV1 needs NVENC and has no fallback. ProRes Proxy encodes in software |\n| `container` | MKV | MP4, MKV, MOV. ProRes requires MOV or MKV |\n| `quality` | Auto | Auto derives a bitrate from resolution and frame rate, Good doubles it, Best quadruples it, Max encodes at constant quality. Ignored for ProRes Proxy |\n| `filename_prefix` | DLSS5 | A timestamp is appended, existing files are never overwritten. Path separators, drive letters, control characters and a leading dash are rejected |\n| `output_directory` | empty | Empty writes to the ComfyUI output directory. A relative path is resolved inside it and may not escape it; an absolute path is used as given |\n| `max_frames` | 0 | 0 renders everything, any other value renders a preview of that many frames, up to 1000000 |\n| `copy_audio` | on | Mux the source audio into the result; subtitles only with MKV. Chapters and metadata are carried over either way |\n| `verify_neural_rendering` | on (advanced) | Check the ReShade log after the render. The file is written either way |\n\nOutputs: the written path (`STRING`) and the number of rendered frames (`INT`).\n\n## Recommended settings\n\nThe defaults come from measurements on real generated footage, not from taste. The same clip was\nrun through the pack with one control changed at a time, comparing the rendered frame against the\nsource: mean absolute difference, Laplacian detail energy, and high frequency energy as a ringing\nindicator.\n\nWhat that showed on the current runtime build:\n\n- The model reconstructs materials rather than sharpening edges. Overall detail energy drops,\n  because generator noise disappears, while skin, hair and fabric gain structure the source only\n  implied.\n- `dlss_model_preset` matters most. Default, J and K land around 0.56x source detail energy;\n  L reaches 0.70x and M 0.73x, which is visible as pores, brow lines and separated beard hair\n  instead of waxy skin. M is the default.\n- `skin_structure_strength` only works while `automatic_mask` is on. With the mask off, every\n  value produces bit identical output; with it on, 2.0 adds a further measurable step of skin\n  detail. Both are on by default.\n- `nr_intensity` is clamped at 1.0. Values of 1.0, 1.5 and 2.0 produce bit identical output;\n  0.0 and 0.5 blend progressively back towards the source.\n- `nr_preset` produces bit identical output at every value.\n- `local_structure_strength` and `local_tone_strength` work across their full range.\n- `nr_style = Cinematic` deepens shadows and shifts the grade, `Natural` softens. Both change the\n  look rather than the amount of reconstruction.\n\nStarting points:\n\n| Goal | Settings |\n| --- | --- |\n| Clean up generated video, same resolution | Defaults: 1x DLAA, model M, mask on, skin 2.0, structure 1.5 |\n| Clean up and upscale | Same, with `upscaling_mode = 2x (Performance)` |\n| Most realistic faces | Defaults plus `local_structure_strength 2.0` |\n| More contrast and punch | `nr_style = Cinematic`, but check the shadows |\n| Too strong | `nr_intensity 0.6` to `0.7`, or `local_structure_strength 1.0` |\n\nThe neural pass works on what is in the frame. It reconstructs skin and material response, it\ndoes not restore a face that the source no longer contains. For heavily degraded footage, run a\ngenerative restoration pass first and use this node as the final cleanup.\n\n## Example workflows\n\nEnhance a clip inside a workflow, so the frames stay available for compositing. `Load Video` and\n`Video Combine` come from\n[ComfyUI-VideoHelperSuite](https:\u002F\u002Fgithub.com\u002FKosinkadink\u002FComfyUI-VideoHelperSuite):\n\n```\n  VHS Load Video ----+\n                     +--> DLSS5 Enhance Images --> VHS Video Combine\n  DLSS5 Settings ----+\n```\n\nEnhance a long file, holding only a few frames in memory and keeping the audio:\n\n```\n  DLSS5 Settings --> DLSS5 Enhance Video File --> output path\n```\n\nStill images work with any `IMAGE` source. With `motion = auto`, a single image is rendered\nwithout motion vectors automatically.\n\n## Verification\n\nBoth processing nodes inspect the ReShade log after rendering and fail if signed feature 18\nexecution cannot be proven. This matters, because a silent fallback to plain upscaling would be\nindistinguishable from success in the output itself. The check is controlled by\n`verify_neural_rendering` and runs once the worker has exited, since ReShade rewrites its log on\nstart and flushes it on exit. The video node writes and muxes its file before verifying, so a\nfailed check never discards a finished render. The same applies to the worker itself: if it exits\nbadly after every frame was rendered, the node logs a warning and keeps the file. The one case\nthat reports a failure on an otherwise good render is a worker that has to be killed on a close\ntimeout, because it never flushes its log.\n\nTwo log observations are normal and not errors:\n\n- `NR upscaling fell back to native`: current runtime builds decline the low resolution colour\n  contract, so DLSS upscales first and the neural pass then runs at the output resolution. The\n  frames are still upscaled and neurally rendered.\n- `vtable::Hook(Failed to find NVSDK_NGX_D3D12_CreateFeature)`: the add-on probes hook points it\n  does not always need. Successful renders contain these lines too.\n\nGive the worker the GPU. Another process rendering at the same time, such as a second ComfyUI\nqueue item or a game, can keep the signed runtime from initialising, which surfaces as a failed\nverification.\n\nThe protocol and runtime can also be exercised without ComfyUI:\n\n```bat\npython_embeded\\python.exe ComfyUI\\custom_nodes\\ComfyUI-DLSS5-Enhancer\\selftest.py ^\n    --frames 5 --mode \"2x (Performance)\"\n```\n\nThis starts the worker, performs the handshake, sends five synthetic frames and prints the\nnegotiated render and output sizes plus the feature 18 evidence. It is the fastest way to tell a\nruntime or driver problem apart from a workflow problem. It also accepts `--width`, `--height`\nand `--runtime-dir`.\n\n## Performance\n\n- The worker starts once per render, not once per frame. Prefer one long batch over many short\n  ones.\n- Frames are streamed to the worker one at a time, but DLSS5 Enhance Images allocates the whole\n  output batch up front at the upscaled resolution. Peak memory is roughly the input batch plus\n  the batch times the squared upscaling factor. For long videos use DLSS5 Enhance Video File,\n  which never materialises the clip.\n- Optical flow is computed at a width of at most 640 pixels and scaled up, which keeps the guide\n  cost small next to the neural pass. `motion = none` skips it, which suits a static camera, but\n  it is not a way to process unrelated images together; see\n  [Known limitations](#known-limitations).\n- The output long edge is capped at 7680 pixels and the short edge at 4320, in either\n  orientation. The node names a usable mode when a request exceeds that, or says so when even 1x\n  does not fit.\n\nOne measurement, RTX 5090 with driver 610.74, 640x360 to 1280x720 at 2x Performance: about\n4 seconds of worker startup, then roughly 10 frames per second.\n\n## Known limitations\n\n- HDR sources are converted to 8-bit SDR without a tone-mapping operator, so highlights clip\n  and the grade shifts. Convert HDR footage to SDR yourself first for a predictable result.\n  The encoder writes `yuv420p`, or `yuv422p10le` for ProRes Proxy. The video node logs a\n  warning when it detects an HDR transfer function.\n- Sources without a frame count in their metadata, common for MKV, WebM and variable frame rate\n  files, trigger a full counting pass with ffprobe before rendering starts. The node logs a line\n  before doing so, but the queue looks idle while it runs.\n- Only one worker runs at a time per render. Two DLSS nodes executing in parallel will compete\n  for the GPU.\n- `motion = none` sends zero motion and resets the temporal history once, which assumes the\n  batch is one coherent sequence. For a batch of unrelated images, run them separately.\n- `nb_frames` is an estimate in several containers. When the rendered frame count disagrees with\n  a count taken from metadata, the node warns and keeps the render; only a count from the exact\n  ffprobe counting pass is treated as authoritative and fails the run.\n- Running the video node twice with identical inputs replays the cached result and writes no\n  new file. Change an input, or the source file, to render again.\n- Windows only. The worker, the carrier and the add-on are Windows binaries.\n\n## Troubleshooting\n\n| Message | Cause and fix |\n| --- | --- |\n| `No DLSS 5 runtime was found` | Runtime not installed or the path is wrong. Run `install_runtime.py` or set `DLSS5_RUNTIME_DIR` |\n| `The DLSS 5 runtime in ... is incomplete` | Files were deleted or extracted partially. The message lists what is missing |\n| `The native DLSS worker at ... could not be started` | Antivirus is blocking the worker, or the file is not executable. Add the runtime folder to the exclusion list |\n| `nvidia-smi is unavailable` | The NVIDIA driver tools are not on `PATH`, or no NVIDIA GPU is present |\n| `is outside the supported RTX 30\u002F40\u002F50 scope` | An RTX card older than the 30 series |\n| `No supported NVIDIA RTX GPU was detected` | nvidia-smi ran but reported no card with RTX in its name |\n| `OpenCV is required` | Install `opencv-python`, or `opencv-contrib-python` if you already use it |\n| `The PyAV package is required` | Only the video node needs it: `python_embeded\\python.exe -m pip install av` |\n| `needs the tested experimental Ampere pair` | RTX 30 only runs with the verified RenoDX 4.70 and DLSS NR 310.8.SF-v2 files, checked by SHA-256. The message prints the hashes actually installed |\n| `does not speak the version-4 protocol` | The registered runtime is from a different release. Use v3.0 |\n| `ffmpeg\u002Fffprobe were not found` | Only the video node needs them. Set `DLSS5_FFMPEG_DIR` or put them on `PATH` |\n| `DLSS \u003Cmode> is unavailable for ...` | The driver rejected that output size. Choose a lower upscaling mode |\n| `applied DLSS model preset X instead of the requested Y` | The runtime does not support that model. Set `dlss_model_preset` to Default |\n| `crashed inside feature-18 evaluation (access violation)` | Driver and RenoDX or DLSS NR versions do not match. Update the driver and reinstall the runtime |\n| `feature-18 execution was not verified` | The worker ran but produced no neural rendering evidence. Most often another process was using the GPU. Run it again with nothing else rendering |\n| `AV1 NVENC cannot encode ...` | The GPU or driver cannot encode that resolution in AV1. Use H.264 or HEVC |\n\n## Project layout\n\n```\nComfyUI-DLSS5-Enhancer\u002F\n  install_runtime.py     Download or register the native runtime\n  selftest.py            Protocol smoke test without ComfyUI\n  dlss5\u002F\n    protocol.py          Binary wire format (version 4)\n    session.py           Worker lifecycle, handshake, frame streaming\n    motion.py            Optical flow temporal guides and scene cut resets\n    settings.py          Public controls and their native translation\n    paths.py             Runtime discovery and validation\n    diagnostics.py       GPU checks, feature 18 proof, failure analysis\n    imaging.py           IMAGE tensor and RGBA8 conversion, letterboxing\n    media.py             Probing, decoding, NVENC encoding, muxing\n    selftest.py          The smoke test itself\n  nodes\u002F                 The three ComfyUI nodes\n  config.json            Written by install_runtime.py, not tracked\n  runtime\u002F               Native runtime, not tracked\n  ffmpeg\u002F                Bundled ffmpeg, not tracked\n```\n\nTo uninstall, delete the node folder. The runtime, `config.json` and any bundled ffmpeg live\ninside it, so nothing is left behind.\n\n## Licensing and attribution\n\nThe source code in this repository is MIT licensed. See [LICENSE](LICENSE).\n\nThe runtime it drives is not. Those files are NVIDIA, ReShade and RenoDX components plus the\nupstream project's own worker executable, each under its own terms: NVIDIA's DLSS and neural\nrendering libraries are proprietary, ReShade is BSD-3-Clause, the RenoDX DLSS 5 add-on carries its\nown distribution terms, and the worker is built and licensed by the upstream project. Install only\ncomponents you are authorised to use, from sources their licences permit. Nothing of that kind is\nhosted or redistributed here.\n\nThe worker protocol was reimplemented for this pack. The runtime and the original application come\nfrom [Merserk\u002Fdlss5-visual-enhancer](https:\u002F\u002Fgithub.com\u002FMerserk\u002Fdlss5-visual-enhancer), which\nmakes NVIDIA's renderer usable outside a game engine. This project is not affiliated with or\nendorsed by NVIDIA, ReShade, RenoDX or that project.\n","这是一个为ComfyUI设计的插件，将NVIDIA DLSS 5神经渲染（NGX功能18）封装为可视化节点，支持对图像批次与视频文件执行基于真实神经渲染器的画质增强与可选1.5×–3×超分辨率重建。其核心技术依赖本地D3D12进程调用ReShade与RenoDX DLSS 5组件，通过自估计的光流运动矢量提供弱引导式重建，专注恢复皮肤、毛发与织物等材质细节。适用于AI生成内容（AIGC）后处理、短视频画质修复及本地化高清重制等场景，需RTX 30\u002F40\u002F50系列显卡及兼容驱动。",2,"2026-09-09 02:30:08","CREATED_QUERY"]