RTX Upscale Image

RTX Upscale Image is the payoff node of this pack: you hand it an image and a loaded engine, it hands you a bigger image. If you've been burned by the whole "upscaler" question before, know exactly which job this one does: it's a pixel upscaler, not a detail restorer. It adds no content, cannot hallucinate, and won't invent a face. What it does is make an already-sharp image bigger - fast, on NVIDIA hardware.

That's the honest framing from the wider upscaling landscape. If your source is soft, low-res, or damaged and you want it to look better, this is the wrong tool - you want something generative like SeedVR2. If your source already has the detail and you just need more pixels on an RTX card, this is the one. That's the same lane as plain ESRGAN, but compiled to Tensor Cores so a 4x upscale runs in milliseconds rather than seconds.

How it actually works

The node takes your images and engine, plus a scale_by factor of 2x, 3x, 4x, or custom. Here's the quirk worth knowing: the engine itself always produces a 4x output - that's baked into the model. So a "2x" request runs the full 4x engine and then downsamples the result to half size. Same GPU work as a 4x run, smaller output. Not a bug, just how a single-compiled-engine design handles variable factors; the resampling picks area-mode downscaling when shrinking and bicubic when growing. If you're choosing between 2x and 4x on speed grounds, the speed isn't there - pick the factor you actually need, not the cheap-sounding one.

When scale_by is custom, the optional width and height inputs (default 1024, both) set your exact target dimensions instead of a multiple. Every run is bounds-checked: inputs must be between 256 and 1280 px per side - push past that and the node raises a clear error, which is your signal to widen the envelope via the Dynamic Shape Config node and rebuild.

One beginner-friendly detail: this works in pixel space. The input is a regular IMAGE tensor and the output (upscaled_images) is a regular IMAGE too - no VAE in or out. Wire it straight into a Save Image node.

The three inputs you'll actually set

• images - whatever you're upscaling, straight from your generation or a Load Image node.
• engine - from RTX Engine Loader. Only engines built for a shape range that covers your image size will work.
• scale_by - 2x / 3x / 4x, or custom to unlock the width/height fields.

Install & troubleshooting

Same pack-wide setup as its siblings: this repo isn't in the ComfyUI Manager registry yet, so install via Manager's "Install via Git URL" with https://github.com/ThreadsOfFate/ComfyUI-Upscaler-TensorRT-RTX.git, or git clone into custom_nodes and pip install -r requirements.txt in ComfyUI's Python. You need an RTX GPU (Tensor Cores are required) and the NVIDIA CUDA Toolkit installed. Drop your chosen .onnx upscaler (e.g. 4x-UltraSharp, 4x_NMKD-Siax_200k) into ComfyUI/models/onnx.

The common failure modes, in order of frequency: an error that your image dimension is outside 256–1280 (fix the shape config, rebuild the engine); a first-run build that takes minutes and looks frozen (it's compiling, watch the TQDM bar); VRAM blowups during that build on big max settings (shrink them); and - worth pre-empting - engines silently rebuilding after a driver or tensorrt_rtx update. None of it is exotic, but the first build and the VRAM ceiling are the two things that send people to Reddit, and both are settings problems rather than breakage.