🐐 Advanced Upscale Image (using Model)

Here's a small annoyance anyone who's used ComfyUI's built-in "Upscale Image (using Model)" node has run into: ESRGAN-family models upscale by a fixed factor baked into the weights - usually 4x. Want 2.5x instead? You upscale 4x, then bolt on a separate resize node to bring it back down to your actual target. It works, but it's two nodes doing one job, and it's easy to get the intermediate step wrong. Advanced Upscale Image (using Model) folds that whole dance into one node with an arbitrary upscale_by factor.

How it works

You still need an upscale model loaded the normal way (ESRGAN, 4x-UltraSharp, Remacri - whatever you'd normally plug into the stock node). This node runs that model, then rescales the result to hit your exact target factor using a standard resize method. Where it gets "advanced" is in how it orders the two stages when your target is far above or below what the model natively does: stage2_order lets you pick downscale_first (upscale, then shrink to target - faster, slightly less detail) or upscale_first (do more of the resize work before the model pass - slower, a bit sharper). There's also mixed_initial, which blends the source image with an upscaled-then-downscaled version of itself before the main pass, for a small sharpness bump, and tiled_upscale, which processes the image in 2x2 tiles. The README is upfront that tiling here isn't about speed - it's for stability at extreme resolutions where a single giant upscale pass gets flaky.

This is squarely a "more pixels" job in the classic upscaling taxonomy, not a "more detail" one - it's pixel-space model upscaling plus resize, with nothing generative or diffusion-based happening. If you actually need a model to invent detail on a soft or damaged source, you want something like SeedVR2 or a tiled-diffusion + ControlNet-Tile pipeline instead; this node just gets you cleanly from a model's native scale to whatever number you actually asked for.

Inputs and outputs that matter

• upscale_model - your loaded ESRGAN-family model.
• image - the source.
• upscale_by (1–16, default 2, step 0.025) - your actual target multiplier. This is the whole point of the node.
• rescale_method (default lanczos) - the resize algorithm for the intermediate/final resize step: nearest-exact, bilinear, area, bicubic, or lanczos. Lanczos is the safe default for photographic content.
• stage2_order (default downscale_first) and mixed_initial (default on) - leave these alone until you have a reason not to; the defaults are reasonable for most images.
• tiled_upscale (default off) - flip this on if you're hitting instability at very high target resolutions, not for speed.

Three outputs: IMAGE (the result), plus WIDTH and HEIGHT as plain ints - handy if downstream nodes need the exact pixel dimensions without you doing the math yourself.

How to install it

ComfyUI Manager: search "GOAT Nodes", install, restart. Or manually:

cd ComfyUI/custom_nodes
git clone https://github.com/AconexOfficial/ComfyUI_GOAT_Nodes.git

then restart ComfyUI. The node itself needs no extra weights - but you still need an upscale model file (a .pth/.safetensors ESRGAN-style model) in your models/upscale_models folder and loaded via the standard loader node upstream, same as any upscale-model workflow.

Common issues & troubleshooting

No upscale_model input connected throws immediately - this node doesn't ship or auto-download a model, it just runs whatever you feed it. Grab one via ComfyUI Manager's model tab (4x-UltraSharp is the community default for general use) if you don't have one yet.

Extreme upscale_by values are slow, and that's expected. Values near the 16x ceiling on a large source image are a genuinely heavy amount of compute regardless of settings - this isn't a bug, it's the cost of the resolution you asked for. Turn on tiled_upscale if you see instability rather than just slowness at those extremes.

Result looks softer than a plain model upscale. Check stage2_order - downscale_first trades a bit of detail for speed by design. Switch to upscale_first if sharpness matters more than render time.