RTX VSR (TJ)

There's a comparison that keeps happening in this community and it's always the same category error: someone pits a hardware interpolator against a generative restorer, and an entire thread argues about "quality" without anyone naming that they're doing different jobs. The usual pairing is NVIDIA's super resolution against SeedVR2. NVIDIA's output gets called more natural. SeedVR2 gets called better at restoration - pores, lashes, fabric weave. Both are true. They're not competing.

RTX VSR (TJ) is the NVIDIA side of that, wrapped as a normal graph node: fast, hardware, and honest about not adding detail that was never in your frames.

What it does

It's the same VideoSuperRes filter the RTX deblur and denoise nodes in this pack use, configured to actually change the resolution - you give it either a multiplier (scale, 1x to 4x) or exact target dimensions (width/height), and a quality level from LOW to ULTRA. Your output dimensions get snapped to a multiple of 8 before the filter runs, so don't expect a request for exactly 1000px to come back as 1000px. That snapping is not sloppiness; odd and off-grid frame sizes make encoders and latent models miserable.

Under the hood it processes in chunks sized to roughly 16 megapixels of output, frame by frame, and returns the result on CPU. That's why it's fast and why VRAM stays flat as your clip gets longer - the batch path is reported at around 4GB VRAM and 10GB system RAM, which is the headline feature. A two-pass chain of RTX deblur into VSR on video is genuinely in reach of a modest card.

Where it sits in the wider picture matters more than the knobs. It's an interpolator: it will clean up pixelation remarkably well and it won't hallucinate a single eyelash. For video from a decent source on a budget, that's the right tool and the community says so. For a genuinely low-resolution source you want to lift hard - think 256px going to 1024px - a generative restorer beats it, at a compute cost that has been measured in minutes per 720p-to-4K pass on rented datacenter hardware.

Inputs and output

• images - the frame batch.
• resize_type - scale by multiplier (default) or target dimensions. Pick one; the fields for the other mode are simply ignored, so leftover values in them are harmless.
• scale - 1.0 to 4.0, default 2. Used in multiplier mode. The output size is derived from the input's actual dimensions, since that's all it knows.
• width / height - defaults 1920x1080, step 8. Used in target-dimensions mode.
• quality - LOW / MEDIUM / HIGH / ULTRA, default ULTRA. This is the one worth experimenting with early: ULTRA is the slow end, and on already-decent footage the difference is not always visible at viewing distance.
• get_name, setnode_name - this pack's wireless receive slot and published output name (RTX_VSR by default).

Output: upscaled_images - an IMAGE batch, ready for CreateVideo, VHS_VideoCombine, or a save node. Note the name differs from the deblur/denoise siblings, which both output plain images.

Install

cd ComfyUI/custom_nodes
git clone https://github.com/designloves2/ComfyUI-TJ_NODE.git
# restart ComfyUI

Then the runtime: an RTX GPU and NVIDIA's VFX SDK libraries, shipped with the NVIDIA RTX video nodes pack (the README calls it comfyui_nvidia_rtx_nodes). Install that pack even if you never use its own nodes - this one imports its runtime. Missing it gets you a RuntimeError that says so and includes the import error underneath.

Nothing in TJ_NODE's requirements.txt is relevant to this node. And to answer the obvious question of why the pack reimplements these filters instead of patching the NVIDIA pack: that pack is a git checkout, and a dirty tree makes the ONE STUDIO updater skip it permanently.

When it goes wrong

SDK not available, or a missing quality level. Both are the runtime, not the node. The second one reports the NVIDIA SDK version it found, which is your clue that the RTX pack is stale.

Your output size isn't what you typed. Multiples of 8. Always. If you need a specific size downstream, read the real dimensions after a test frame and target something that lands on the grid.

You expected pores. That's SeedVR2's job. Hardware super-resolution cleans and enlarges; it doesn't restore. Naming which of the two you actually need saves a lot of wasted queue time - and if you're doing video, it also saves you from the third job nobody mentions, which is keeping consecutive frames consistent.