◎ Radiance Pro Upscale

There are two kinds of upscaler, and the KB's upscaling doc makes the split brutally clear: ones that add pixels (interpolators) and ones that add detail (generative models like SeedVR2 or SUPIR that invent plausible texture and will happily rewrite a face). Most people reach for the generative ones when they'd be better served by a fast, honest interpolator - and a good Lanczos pass is still the community's correct answer for "source already sharp, I just need it bigger." Radiance Pro Upscale is that honest interpolator, done carefully, with Flux-oriented presets and HDR handling.

It's the "more pixels, not more detail" job, and it's the one you want before you print, before you feed a diffusion upscaler a better base, or whenever a model would hallucinate on top of clean data. No weights, no downloads, no GPU model to fit in VRAM - it's math over your tensor.

How it works

Nine kernels, all classic signal processing: lanczos, lanczos4, bicubic, mitchell, catrom, hermite, gaussian, bilinear, nearest. The source ships its own vectorized Lanczos implementation (with a scipy fast path and a numpy fallback) rather than trusting whatever resize the host provides. On top of the kernel it layers sharpening (unsharp-mask style, with a sharpen_radius), detail_enhancement, and antialiasing - the standard trilogy for keeping an upscale crisp without ringing halos.

The Flux presets are the friendly entry: Flux Default (balanced lanczos), Flux Sharp (lanczos4 + more sharpening), Flux Smooth (mitchell + gentle), Flux HDR, Flux Print, Flux Cinematic, and Flux Maximum - each a curated combo of method/sharpen/detail/AA rather than a different algorithm. process_in_linear (on by default) converts to linear, upscales, and converts back, which is the correct way to resize - interpolating gamma-encoded values smears brightness. input_color_space (sRGB/Linear/Auto) tells it what it's starting from.

For big images there's tiling: use_tiles with tile_size and tile_overlap splits the job so a huge upscale doesn't blow memory - the move when you're heading to 4K+ print sizes on limited VRAM.

The inputs that matter

• scale_factor - 0.1 to 8×. Default 2.
• preset - start here. Custom falls back to your manual settings.
• method - the kernel. Lanczos for detail, Mitchell for smoothness.
• sharpening, sharpen_radius, detail_enhancement, antialiasing - the post-kernel quality controls.
• output_bit_depth - 32-bit Float, 16-bit Float, or 8-bit. 32 keeps the pack's float promise; 8-bit if your chain is display-bound.

Outputs: upscaled_image, plus width, height, and an info string describing what it did.

The honest take

Read the KB's upscaling hierarchy before you buy anything bigger. If your source is soft or damaged, Pro Upscale won't fix it - that's a SeedVR2/SUPIR job, and this node can be the cheap base step before those, not a replacement for them. But for already-sharp Flux output that needs to be 2× or 4× for print, this is faster than any model, deterministic, and it can't invent artifacts or faces. The community's strongest upscale comparison even concluded that interpolation reads more "natural" than generative upscalers on clean sources - this is that category, tuned.

Installing

cd ComfyUI/custom_nodes
git clone https://github.com/fxtdstudios/radiance.git
cd radiance
pip install -r requirements.txt   # or requirements_windows.txt / requirements_linux.txt / requirements_mac_silicon.txt

Or search Radiance in ComfyUI Manager. Linux needs libopenexr-dev first; restart after.

Gotchas

Sharpening is where people overdo it: crank sharpening past ~0.8 and you get the classic white halos around edges, because unsharp mask is blur-and-difference and high amounts exaggerate the difference. The presets keep this sane; Custom doesn't protect you from yourself. Second, process_in_linear is correct but changes how a gamma-encoded source responds - if you're on an sRGB image and the result looks lighter or washed compared to the input, that's linear processing doing its job, not a bug. Third, tiling only engages when you turn use_tiles on; a giant single-pass upscale on low VRAM will OOM before you remember it exists.