LC RTX Super Resolution ⚡

Why you'd reach for it

NVIDIA's RTX Video Super Resolution is a hardware upscaler sitting idle in most RTX cards. It's not a diffusion model and it will never invent a pore - the KB's upscaling doc quotes the community's own read that "NVIDIA's is more like Lanczos, it's an interpolation method, not generative." What it does is clean up compressed, blocky sources and enlarge them, fast, with output most people find more natural than a generative pass on an already-decent image. The year's biggest head-to-head (+821, SeedVR2 vs RTX) had the top comment picking NVIDIA at +513.

This node puts that in a graph. Four modes, upscale up to 4x, and it does the two things the raw SDK doesn't: it can hold a size in megapixels instead of a multiplier, and strength blends the result back toward a plain bicubic resize, because the installed SDK has no strength control of its own.

How it works

The heavy lifting is in the pack's shared lc_rtx helper, which speaks both the old nvvfx.effects API and the newer one. Elsewhere in the pack it falls back to lanczos when RTX isn't available; through this node it runs strict and raises instead - a node promising RTX shouldn't quietly do something else.

Frames go through one at a time on the GPU with results collected in system RAM. That's a deliberate fix for a real problem: a long clip at 2x is tens of gigabytes, and holding it all in VRAM pushed it into shared memory and looked like a freeze.

Sizes get rounded to multiples of 8 for the SDK, then snapped to the exact size you asked for. The same-size modes - denoise and deblur - pad the frame out to the 8-grid and crop back, because a width off that grid comes back skewed by a row.

One hard rule: RTX VSR only ever enlarges. Ask for a smaller output and the node raises. Use a normal resize node for downscales.

The inputs that matter

• mode - upscale for typical compressed images and video; upscale (clean source) for lossless or high-bitrate sources, which skips the artifact clean-up; denoise and deblur at the same size. The community's favourite trick is chaining two of these: deblur first to sharpen, then upscale. Two of these nodes, same graph.
• quality - LOW to ULTRA, default ULTRA. LOW is fastest, ULTRA keeps the most detail.
• scale / megapixels - scale is a plain multiplier for the upscale modes and is ignored by denoise and deblur. Set megapixels above 0 to aim at a total size instead (shape kept, still capped at 4x).
• strength - 1 is the full RTX result, lower lerps toward a plain bicubic enlargement. Useful when the RTX pass looks too clean or too contrasty against your source.
• mask (optional) - resized along with the picture, so it still lines up downstream. This is the bit that makes the node usable in a masked pipeline at all.

What comes out

image is the result, mask is your mask at the new size (empty when you didn't wire one), and width / height are the actual output dimensions - worth wiring into a note node or a save naming scheme, because the 8-grid rounding means they may not be exactly what you typed.

Install

The pack first, via Manager (ComfyUI LC123 Nodes) or:

cd ComfyUI/custom_nodes
git clone https://github.com/lonecatone23/ComfyUI_LC123_nodes

Then the one real dependency, and it's a chunky one - around 800 MB:

# use ComfyUI's own python, not your system one
python -m pip install nvidia-vfx

The node face can run that pip for you and show the log, which is friendlier than it sounds. Either way restart ComfyUI afterwards - the SDK loads at startup, so installing it into a running process doesn't help until you do.

Common issues

"Needs an NVIDIA RTX card and the nvidia-vfx package." That's the strict-mode error. Either nvidia-vfx isn't installed, or your torch isn't on CUDA (a --cpu launch, or a ROCm card). The pack also logs [LC123] RTX upscale unavailable (…) to the console when the import fails, so check there first.

It raised on a downscale. Working as designed. RTX VSR only enlarges or holds size.

The output size isn't what I typed. Megapixels mode caps the factor at 4x and everything goes through the multiple-of-8 grid - read the width/height outputs rather than assuming.

Results look plasticky compared to a model upscale. That's the interpolator doing its job. Want invented pores and lashes? That's SeedVR2's category; these are different jobs, not competitors.

A 4x pass over a long clip eats RAM. Frames stream through the card one at a time with the results held in system memory, so the whole enlarged clip exists before it's handed on. Split the clip and rejoin it.