FL RTX VSR Upscale

What it's for, and what it is not

FL RTX VSR Upscale takes one image or a whole ComfyUI IMAGE video-frame batch and runs it through NVIDIA's RTX Video Super Resolution. If you're used to thinking of every "upscaler" as something that paints in detail from nothing, stop there - this is not that. Upscaling has three genuinely different jobs, and this node does exactly one of them: more pixels, added cheaply and instantly. NVIDIA's VSR is closer in spirit to Lanczos than to a diffusion model; it sharpens, cleans up pixelation, and scales convincingly, but it will not grow you eyelashes or invent fabric weave that was never there.

That's a feature, not a bug. The community has repeatedly read RTX VSR's output as "more natural" than generative upscalers on sources that are already clean - no hallucinated skin texture, no rewritten identity. On an RTX card it's effectively real-time, which is the whole reason it exists in your stack next to SeedVR2-style restorers: those take minutes and add detail, this takes seconds and doesn't. Use VSR when you want pixels and nothing else, and save the detail-inventors for the sources that actually need invention.

How it works

Under the hood the node loops over your frames and runs each through NVIDIA's VideoSuperRes effect, with a couple of engineering touches worth knowing. Frame exchange between PyTorch and the NVIDIA VFX runtime happens on the GPU via DLPack - no round trip to the CPU - which is most of why it's so fast. The native runtime demands 32-byte-aligned rows, but the node handles that alignment internally and returns exactly the dimensions you asked for, so you can feed it arbitrary sizes and not think about it. If your image has an alpha channel it survives too, bilinearly upscaled alongside the RGB. There's a per-frame progress bar in the console, and you can cancel mid-batch.

The settings that matter

• runtime - from FL RTX VSR Runtime Loader. Non-negotiable.
• images - an IMAGE tensor. One image or a decoded video frame batch, same node.
• source_quality (default High Bitrate - High) - the author's tooltip is the whole manual: "High Bitrate preserves clean or generated detail. Standard also removes artifacts from compressed sources." So: High Bitrate rungs for your own generated video, lossless, ProRes or lightly-compressed footage; Standard rungs for visibly compressed sources, at the cost of slightly softening already-clean detail. Each has Low / Medium / High / Ultra tiers.
• scale (default 2x) - 1.33x, 1.5x, 2x, 3x or 4x. The odd fractions aren't a mistake; VSR handles rational scales natively.

Output is a single images IMAGE, same batch count, at the new resolution.

Where people get burned is reaching for this after seeing a gorgeous SeedVR2 demo. Wrong tool. On clean generated video it looks great and takes seconds; on genuinely damaged footage it's an interpolator, not a miracle worker - that's the Restore node's territory first, then this.

Wiring it into image and video flows

For a still, wire any IMAGE in and you're done. For video, feed it a decoded frame batch (however you normally get frames into ComfyUI), then send the returned frames back into your usual video-combine node so you keep the project's frame rate and audio path intact. The repo ships an example image workflow at examples/rtx_vsr_upscale.json if you want a known-good starting point.

Install and gotchas

Search ComfyUI-FL-RTXVSR in ComfyUI Manager, or:

cd ComfyUI/custom_nodes
git clone https://github.com/filliptm/ComfyUI-FL-RTXVSR.git

Restart after. The real constraints are platform: 64-bit Windows 10+, an RTX 20-series-or-newer GPU, a current driver, and Python 3.12+ (the current ComfyUI portable qualifies). There's no pip step - the first time the Runtime Loader runs it downloads and verifies NVIDIA's ~468 MiB VFX package, so budget a first-run wait of a few minutes. Expect pixel-scale results, not detail invention, and you'll be exactly as happy with it as the people who swear by it.