DLSS Depth Guide (Model Selection)

DLSS Super Resolution is a temporal upscaler, and like every temporal upscaler it wants two things a photo doesn't have: a depth buffer and motion vectors. A game engine hands those over for free. You don't have them, so the DLSS5 pack estimates them from pixels - which means the quality of your depth guide is one of the two things standing between you and a stable upscale. DLSS Depth Guide (Model Selection) is the node where you choose which model produces that guide.

What it actually is

You know the shape of the problem already: Depth Anything V2 has been the default preprocessor since 2024, single-image models flicker on video, the good checkpoints are non-commercial. Same story here, new consumer. The SR bridge doesn't want a pretty map you'll eyeball - it wants a near-bright inverse depth buffer aligned frame-for-frame with the pixels you're upscaling. Depth trails, shimmer and ghosting in the output usually start here.

The pack already ships a plain Depth Anything V2 Guide and a separate Video Depth Anything node. This one folds six backends behind a single model dropdown and adds precision and inference-size controls, which is the whole reason it exists - you can A/B guide models without rewiring the graph.

How it works

Selection drives three different code paths. Depth Anything V2 pulls depth-anything/Depth-Anything-V2-{Small,Base,Large}-hf through Transformers, weights downloaded on first use. YOLO26 goes through the pack's own depth_backend, loads Ultralytics with its depth DepthPredictor, and converts YOLO's metric depth into near-bright inverse depth before normalization so the downstream node sees the same convention as DA-V2. Video Depth Anything Small runs its own temporal windows. In all three cases the guide comes back at the resolution you fed in, so the SR bridge always gets a matching pair with your motion_vectors.

model_info is a plain string report - model, backend (PyTorch or TensorRT), requested vs. effective precision, size used, frame count, setup-inclusive elapsed. Wire it to a note or read the console; it's the fastest way to learn you've been running FP32 on CPU.

The inputs that matter

• images - the still or frame batch you're about to upscale. Guide comes back at this size.
• model - your six options. The tooltip is the author's own comparison, and it's honest: YOLO26 Nano is 6.3M params and fast with lower detail and no temporal consistency; DA-V2 Base/Large are detail comparisons with real VRAM cost; VDA-S is the only one with intrinsic temporal consistency.
• input_size - 0 means the model default (518 for DA-V2/VDA, 768 for YOLO). Drop to 280 or 392 to trade edge detail for speed. DA-V2 sizes target the short side in multiples of 14; YOLO sizes target the long side and round up to 32, so 392 becomes 416.
• temporal_normalization - on by default. One robust depth range across the clip, which kills range pumping. It does not give a single-frame model temporal correspondence, whatever you set it to.
• chunk_size - frames per inference batch. Lower it when you run out of memory.
• engine_path - optional TensorRT .engine for a YOLO26 model only. The node raises if you point it at DA-V2 or VDA, and an engine's precision, shape and batch are frozen at export time.

Outputs are depth (into the SR node's depth input, paired with the same frames' motion guide) and model_info.

Install

ComfyUI Manager, search Experimental DLSS Neural Rendering - the display name, not the repo name. Or:

cd ComfyUI/custom_nodes
git lfs install
git clone https://github.com/HECer/ComfyUI-DLSS5
git lfs pull

Restart. Python deps are modest - numpy, opencv-python, Pillow, py7zr, transformers, torchvision - but the base runtime is a separate step: add DLSS Runtime Setup (One Click) and install the pinned VapourKit runtime before the SR bridge does anything. Windows 10/11 and a recent NVIDIA driver are required; not a Linux-friendly pack. YOLO26 needs Ultralytics installed by you (AGPL-3.0, and only a version exporting ultralytics.models.yolo.depth.DepthPredictor - the author tested 8.4.182).

Where people get burned

The pack's own benchmark tells the story. With YOLO26 Nano FP16 at 392 and 2x SR plus NR, depth took 0.119–0.139 seconds per two-frame batch while SR and NR together took 24–27 seconds. So yes, YOLO is dramatically faster than DA-V2 as a depth model - and it moves your total throughput by roughly nothing. The 4K/30 gate failed at 0.07 source FPS. Buy the guide model for quality and temporal behaviour, not for a speed miracle.

Two other traps. Don't pip install -U ultralytics inside your working ComfyUI env to fix the YOLO path - the pack disables Ultralytics' auto-install for the whole host process, so a botched dependency conflict surfaces later and weirdly. And DA-V2 Base and Large are CC BY-NC; Small is the Apache one, a quiet reason it's the default.