Tiled Image Upscale (With Model)

There are, roughly, two different jobs people call "upscaling": adding pixels to an image that's already sharp, and adding detail to one that isn't. Tiled Image Upscale (With Model) is squarely the first job - it runs whatever ESRGAN-style upscale model you already load (4x-UltraSharp, Remacri, whatever) without inventing anything new. What it adds over just running that model directly is the ability to do it on genuinely large images without your GPU falling over.

How it works

Instead of sending the whole image to the upscale model at once, it splits the image into tile_size chunks, upscales each one separately, and stitches them back together with overlap pixels of shared border and feathering across the seam so tile boundaries don't show. Per the pack's README, it also adaptively shrinks the tile size mid-run if a given tile still runs out of memory - so you don't have to find the perfect safe tile_size by trial and error before starting. After tiling, it resamples the stitched result to hit your final upscale_factor using resample_method.

Worth being clear about what this node doesn't do: unlike Ultimate SD Upscale or Tiled Diffusion + ControlNet Tile, there's no diffusion pass, no VAE encode/decode, no denoising happening per tile. It's a pure pixel-space upscale, just tiled for VRAM safety. That means it's fast and predictable and can't hallucinate detail - exactly the trade-off you want when the source is already clean and you just need it bigger.

The inputs and outputs that matter

• upscale_model (UPSCALE_MODEL) and image - the two required inputs; load the model with ComfyUI's own Load Upscale Model node first.
• upscale_factor (default 4, range 1–16) - "final scale relative to input image size," per its tooltip. Output resolution is roughly input × upscale_factor.
• tile_size (default 512) - bigger tiles are faster but use more VRAM; this is the knob to drop if you're still OOMing.
• overlap (default 32) - higher reduces seams, at the cost of more compute.
• feather (default 0, meaning "auto from overlap") - output-pixel feather width for blending tiles; set it explicitly if the auto value isn't enough.
• resample_method (default lanczos, also nearest-exact/bilinear/area/bicubic) - the kernel used for the final resize to hit upscale_factor.
• clear_comfy_memory (default off) - per its tooltip, unloads other models and does a soft-then-hard cache dump to aggressively free VRAM before running.

Output: a single IMAGE.

For a first run, you'll mostly touch upscale_model and upscale_factor; only reach for tile_size, overlap, and feather if you're actually seeing OOMs or seams.

How to install it

Via ComfyUI Manager: search WAS_Extras, install, restart. Manually:

cd ComfyUI/custom_nodes
git clone https://github.com/WASasquatch/WAS_Extras

Restart ComfyUI. You still need an actual upscale model file (a .pth/.safetensors like 4x-UltraSharp) loaded through ComfyUI's own Load Upscale Model node - this pack doesn't ship or fetch one for you, same as any core upscale workflow.

Common issues & troubleshooting

Still running out of memory after tiling. Drop tile_size further, or flip clear_comfy_memory on to reclaim VRAM from other loaded models before this node runs - that's its own built-in escape hatch for exactly this situation.

Visible seams between tiles. Raise overlap, or set feather explicitly instead of trusting the overlap-derived automatic value.

Output looks flat or plasticky compared to a generative upscaler. That's expected, not a bug - this node adds pixels, not detail. If you want the SUPIR/SeedVR2-style "invent plausible detail" job instead, this is the wrong tool; use this as a cheap, fast, predictable pass and reach for a generative upscaler when the source genuinely needs restoration.

Slower than expected on very large images. Tiling trades throughput for VRAM headroom on purpose. If you have VRAM to spare, raising tile_size runs fewer, bigger tiles and finishes faster.