🎬 RTX Batch Upscale (Simple)

If you've ever upscaled a long video in ComfyUI and watched it OOM at minute two, or come back from dinner to find the queue silently dead, this is the node this pack was built to fix. Most video-processing nodes in ComfyUI take one of two paths: load the whole file into RAM (instant crash), or dump every processed frame to disk as PNGs and stitch them later (great way to murder your SSD's lifespan). RTX Batch Upscale does neither.

It wraps NVIDIA's Video Effects (VFX) SDK - the old Maxine / "AI for Media" stack - into a streaming pipeline. Frames are read in chunks, upscaled on your RTX GPU, and the raw RGB bytes go straight into FFmpeg's memory pipe. Zero temp files, true backpressure, and a watchdog that catches a stalled encoder instead of freezing your queue for four hours. That's the "bulletproof" in the pack's tagline, and for once it's not marketing.

What it is, honestly

Before you commit hours of GPU to this, know what you're getting. RTX Video Super Resolution is a "more pixels" upscaler, not a generative one. The community has been over this ground: it reads closer to a hardware Lanczos than to diffusion-based restorers like SeedVR2 or FlashVSR. On an already-clean source that's a feature - it's fast, real-time, can't hallucinate detail, and people consistently describe its output as more natural than generative upscalers. But it will not invent pores, fix heavy compression, or rescue genuinely soft low-res footage. If your source is a tiny blurry render, reach for a generative restorer instead; if it's decent footage you want bigger, this is the tool, and it'll do in seconds what a diffusion model takes minutes over.

The inputs that matter

• video_path (required) - from the Video Path Picker node. It's a path, not tensors.
• scale_factor (1.0–4.0, default 2.0) - the whole job in one number. 2x is the sensible starting point.
• quality (LOW/MEDIUM/HIGH/ULTRA, default ULTRA) - the VSR quality level. Start at ULTRA; drop if you're tight on VRAM.
• batch_size (default 4) - frames processed on the GPU per pass. Lower = less VRAM. If you're on 6–8GB and hitting OOM, this is the first dial to turn.
• keep_audio (default on) - stream-copies the original audio and subtitle tracks into the upscaled file.

Outputs: output_path (the saved MP4 in output/upscaled_videos/), preview_frames (an IMAGE tensor with three frames - first, middle, last - wire it into a Preview Image node to eyeball the result), and info (a status string with resolution, codec, and render time).

Installing it - the part that actually bites

Install is the easy bit: ComfyUI Manager (search "ComfyUI-RTX-Video-Suite") or

cd ComfyUI/custom_nodes
git clone https://github.com/uczensokratesa/ComfyUI-RTX-Video-Suite.git

then restart. The prerequisites are the trap. You need three things:

1. An NVIDIA RTX GPU with Tensor Cores - Turing, Ampere, Ada, Blackwell or Hopper. Older GTX cards won't do VSR.
2. The nvvfx module. It is not on PyPI under that name. It comes from the NVIDIA VFX SDK, and in practice people install it as the nvidia-vfx pip package. This is the #1 failure mode - the pack loads, prints a warning that nvvfx wasn't found, and the upscale nodes refuse to run until you sort it. Drivers matter too: Windows 570.65+ (595+ for TCC devices), Linux 570.190+ / 580.82+ / 590.44+.
3. FFmpeg on your PATH. The pipeline literally hands raw frames to an ffmpeg subprocess. ffmpeg -version in a terminal is the sanity check.

Common issues

• "RTX upscaling requirements not met!" - the node's way of saying nvvfx or CUDA is missing. Fix the SDK install above, not the node.
• OOM mid-render - drop batch_size to 2 (or 1), and consider MEDIUM quality. Long files stream in chunks, so a 20-minute video shouldn't use more RAM than a 30-second one.
• "ffmpeg not found!" - it's not on PATH, or ComfyUI was started before you installed it. Install, then restart.
• Upscale looks soft - that's the nature of VSR, not a bug. It adds pixels, not detail. Pair it with a DeBlur pass before upscaling if your source is genuinely blurry; the community reports the two-pass combo produces noticeably better results.

There's a standalone CLI in the same repo (python rtx_nodes.py -i input.mp4 -o output.mp4 -s 2.0 -q ULTRA) if you'd rather not open the UI. Same engine, no node graph.