Runtime44 Upscaler

Runtime44 Upscaler is the pack's headliner: a pixel-space upscaler that runs an upscale model (ESRGAN-family) over your image in tiles, with a genuinely thoughtful OOM fallback. It's squarely in the "more pixels" camp of upscaling - it adds resolution, not hallucinated detail, and it's fast. If you're looking at this node you're probably doing the standard hi-res pipeline: upscale the render, then (optionally) run a low-denoise sampler pass over the result to add detail back.

This is the category-one job from the upscaling playbook: the source already has the detail you want, you just need it bigger. A 4x ESRGAN model via this node, Lanczos for anything non-integer, tiles so it fits on modest VRAM. It's the kind of thing the stock "Upscale Image (using Model)" node also does - the differentiators here are the tiling, the exact-multiplier handling, and the auto-fallback.

How it works

The node loads your upscale_model, moves it to the GPU, and runs tiled_scale - the image is processed in overlapping tiles (32px overlap) so you can upscale a big image on a small card. Two details make it smarter than the naive version:

• It hits your exact target. The model has a native scale (most ESRGAN models are 4x). If your upscale_by isn't the model's scale, it upscales by the model's factor first, then Lanczos-resizes to land exactly on upscale_by.
• OOM is handled for you. If a tile blows the VRAM budget, the node automatically halves tile_size and retries, down to a 128px floor. It prints [R44] progress lines so you can watch it work.

Inputs are upscale_model (load one via the standard "Load Upscale Model" node, files live in ComfyUI/models/upscale_models), image, upscale_by (default 4, your final multiplier), and tile_size (default 512, min 128). Output is a single IMAGE at the new resolution. upscale_by = 0 is a no-op passthrough.

The two things people trip on

upscale_by is the total, not the model's scale. If you load a 4x model and set upscale_by to 2, you get 2x - the extra is shaved off with Lanczos. Beginners set it to 4 because the model is "4x" and get a 4x result; that's fine. The trap is the opposite: expecting upscale_by to be "how many times to apply the model." It isn't - it's the target multiplier.

It will not add detail. This is a pixel upscaler. Upscale a soft or out-of-focus render and you get a bigger soft render. If your source is genuinely soft, the playbook says fix that before upscaling (or downscale to ~0.35MP and rebuild), not after. For the "bigger, please" case - sharp source, want a 2K or 4K version for print - this node is exactly right.

Pair it with the pack's Iterative Upscale Factor if you want a multi-stage chain instead of one big jump, or follow it with a low-denoise KSampler pass for the hi-res-fix detail step.

Installing

Part of Runtime44 ComfyUI Nodes, under "image/upscaling":

cd ComfyUI/custom_nodes
git clone https://github.com/runtime44/comfyui_r44_nodes
cd comfyui_r44_nodes
python -m pip install -r requirements.txt   # or: uv pip install -r requirements.txt

Restart ComfyUI, or install via ComfyUI Manager (search "Runtime44"). No upscale model ships with the pack - you'll grab one separately (4x-UltraSharp, Remacri, or a RealESRGAN variant) and drop it in models/upscale_models. The pack pulls the heavy CUDA wheels (cupy-cuda12x, cucim) in its requirements, though this node itself doesn't use them. The repo's been quiet since mid-2024; the tiled-upscale mechanics it wraps are ComfyUI core, so it keeps working fine regardless.