Tiled Image Upscale (With Model)

Run any upscale model on huge images without OOMing

By WASasquatch·Created 3 years ago·Updated 3 days ago· 1,832

upscale_model
image

IMAGE

◄upscale_factor4.0►

◄tile_size512►

◄overlap32►

◄feather0►

◄resample_methodlanczos►

◄clear_comfy_memoryfalse►

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.

CategoryWAS Suite/Image/Upscaling

Inputs (8)

Name	Type	Default	Description
upscale_model	UPSCALE_MODEL		The upscale model to run, from a Load Upscale Model node. Its own scale does not have to match upscale_factor: a 4x model can produce a 2x result.
image	IMAGE		The pictures to enlarge. Each frame of a batch is upscaled in turn, so memory use is set by the tile size rather than by the batch.
upscale_factor	FLOAT	4.01–16	Final size relative to the input. 2.0 doubles both sides, 4.0 quadruples them, 1.0 keeps the original size while still passing the picture through the model.
tile_size	INT	51264–4096	Tile edge in input pixels. Larger tiles are faster and need more video memory; if the card runs out, the tile is halved and the run retried automatically. 512 suits most 8 GB cards.
overlap	INT	320–1024	How far neighbouring tiles overlap, in input pixels. This is the material the cross-fade is made from, so 0 puts a hard join between tiles; 32 to 64 hides it on most models.
feather	INT	00–4096	Width of the cross-fade in output pixels. 0 works it out from the overlap, which is the right answer almost always; raise it only when a faint grid still shows on flat areas such as sky.
resample_method	COMBO	lanczos	How a tile is resized when the model's own scale does not match upscale_factor. `lanczos` keeps the most detail, `area` is the gentlest when shrinking, `nearest-exact` keeps hard pixel edges for pixel art.
clear_comfy_memory	BOOLEAN	false	Whether to unload every other model and empty the caches before upscaling. Turn this on when a large upscale runs out of memory next to a checkpoint that is still resident; it costs the time to reload those models afterwards.

Outputs (1)

Name	Type	Description
IMAGE	IMAGE	The enlarged pictures, at roughly the input size times upscale_factor, clamped to the displayable range.