PixelTiledKSampleUpscalerProvider

PixelKSampleUpscalerProvider does the classic upscale-and-resample trick - decode to pixels, upscale, re-encode, run a fresh KSampler pass - but that decode/encode/sample cycle runs on the whole image every step, and at high resolutions that's a fast way to run out of VRAM. PixelTiledKSampleUpscalerProvider is the same recipe with the expensive parts tiled: it swaps in ComfyUI_TiledKSampler for sampling and a tiled VAE decode/encode, so cost tracks tile size instead of canvas size. Per the README, it's "similar to PixelKSampleUpscalerProvider, but it uses ComfyUI_TiledKSampler and Tiled VAE Decoder/Encoder to avoid GPU VRAM issues at high resolutions."

Like its non-tiled sibling, this node doesn't upscale anything by itself - it's a provider. Plug its UPSCALER output into an Iterative Upscale node, which drives the actual loop and calls this provider once per step.

How it works

Each call from Iterative Upscale decodes the current latent (tiled), scales the pixels with scale_method (or an upscale_model_opt if you've supplied one, which does real detail-adding upscaling instead of plain interpolation), re-encodes (tiled), then samples using the tiled KSampler with your tile_width/tile_height/tiling_strategy. That last part matters beyond just VRAM: tiled sampling has its own seam-avoidance logic depending on which tiling_strategy you pick - random denoises the whole image gradually while shuffling tile positions between steps (best at hiding seams, some per-step overhead), padded gives each tile static surrounding context instead (no per-step overhead, more seam-prone), and simple is a plain static grid (fastest, crudest).

This node requires BlenderNeko's ComfyUI_TiledKSampler installed separately - the README states it explicitly for this node. Without it, it either won't load or won't function.

The inputs and outputs that matter

• model / vae / positive / negative - the standard sampler stack, from the checkpoint you generated with.
• seed / steps / cfg / sampler_name / scheduler - usual KSampler controls, applied at each iteration.
• denoise (default 1) - as with any upscale pass, drop this to roughly 0.3–0.5; at 1.0 you're regenerating the region from scratch instead of adding detail.
• tile_width / tile_height (default 512, step 64) - the tile size for both sampling and the VAE round-trip. 512 is a reasonable default for SD 1.5/SDXL-era models; smaller tiles use less VRAM but multiply your tile count and runtime.
• tiling_strategy (random / padded / simple) - how tiles are handled across steps; see above. random is the safest default for hiding seams.
• scale_method (nearest-exact / bilinear / lanczos / area) - resize method when not using an upscale model.
• Optional: upscale_model_opt (an ESRGAN-family model for real detail-adding resize), pk_hook_opt (a PK_HOOK for CFG/denoise/steps scheduling across iterations), tile_cnet_opt / tile_cnet_strength (apply a tile-conditioning ControlNet during the resample, which keeps detail coherent across tile boundaries), and overlap (default 64) - how much adjacent tiles share, to reduce visible seams.

Output is a single UPSCALER - feed it into Iterative Upscale (Latent/on Pixel Space) or Iterative Upscale (Image).

How to install it

Via ComfyUI Manager: search ComfyUI Impact Pack, install, restart. Manually:

cd ComfyUI/custom_nodes
git clone https://github.com/ltdrdata/ComfyUI-Impact-Pack comfyui-impact-pack
cd comfyui-impact-pack
python -m pip install -r requirements.txt   # ComfyUI's python; python_embeded on portable

then restart. Also install BlenderNeko/ComfyUI_TiledKSampler - search "Tiled sampling for ComfyUI" in Manager, or clone it manually alongside Impact Pack. This node genuinely needs it; it's not optional.

Common issues & troubleshooting

Node missing or errors on use. Missing ComfyUI_TiledKSampler. Install it separately - Impact Pack's own installer doesn't pull it in.

No image output. Expected - the only output is UPSCALER. It has to feed an Iterative Upscale node to actually produce a result.

Still running out of VRAM. Lower tile_width/tile_height. A large overlap relative to tile size can eat back some of what tiling saves, so bring that down too if it's still tight.

Detail looks tiled or inconsistent between tiles. Try tiling_strategy: random if you're on simple, raise overlap, or add a tile-conditioning ControlNet via tile_cnet_opt to keep neighboring tiles agreeing with each other.

Do you actually need the tiled version? Only if the non-tiled PixelKSampleUpscalerProvider is OOMing on you. It's otherwise doing more work for the same result, so don't reach for it by default.