PixelKSampleUpscalerProvider

First thing to get straight, because it trips up everyone: this node doesn't upscale anything on its own. Run it by itself and you get nothing useful. It's a provider - it hands out an UPSCALER object that describes how to enlarge one step, and you plug that into an Iterative Upscale node (Latent or Image), which actually drives the process. Think of it as the recipe, not the oven.

The recipe it describes is the classic detail-adding upscale: take your latent, VAE-decode it to pixels, scale the pixels up, VAE-encode back to latent, and run a fresh KSampler pass on it. That resample pass is where new detail comes from - the same idea as hi-res fix, just packaged so Iterative Upscale can call it once per step as it walks your image up to the target size in stages. Impact Pack is better known for face detailing, but this iterative-upscale rung is a whole separate part of the pack that a lot of workflows lean on.

How it works

Iterative Upscale splits your total scale factor (say 3x) into several smaller steps and calls this provider on each one. Each call decodes, upscales by the step amount, re-encodes, and samples. Doing it in stages instead of one giant jump keeps the model from hallucinating garbage at a resolution it was never trained for. If you feed it an upscale_model_opt (an ESRGAN-family model), it uses that model to do the pixel enlargement first, which per the README can drastically cut how many iterative steps you need.

The inputs and outputs that matter

The node carries a full sampler stack because every step is a sampling pass. You'll wire in model, vae, positive, and negative from the same checkpoint you generated with, then set the usual steps, cfg, sampler_name, and scheduler.

• denoise - the one to actually think about. It defaults to 1.0, which is full regeneration and almost never what you want for an upscale. Drop it to roughly 0.3–0.5 so each pass sharpens and adds texture without redrawing the whole image. This is the single most common mistake in the whole upscaling category.
• scale_method - how the pixels get resized (nearest-exact, bilinear, lanczos, area). lanczos is the safe default.
• upscale_model_opt (optional) - drop a 4x ESRGAN model here to do the heavy lifting and shorten the iteration count.
• use_tiled_vae / tile_size - turn tiling on if you OOM at high resolution.
• pk_hook_opt (optional) - accepts a PK_HOOK so you can schedule cfg/denoise/steps across iterations. Advanced; leave it empty until you need it.

The single output is UPSCALER, and it only connects to nodes that accept one - Iterative Upscale being the obvious target.

How to install it

It ships in the Impact Pack, so you install the pack, not the node. Easiest path is ComfyUI Manager: search ComfyUI Impact Pack, hit Install, restart. Manually:

cd ComfyUI/custom_nodes
git clone https://github.com/ltdrdata/ComfyUI-Impact-Pack comfyui-impact-pack
cd comfyui-impact-pack
pip install -r requirements.txt

then restart. On the portable build use ..\..\..\python_embeded\python.exe -m pip instead of pip. First launch downloads a SAM model automatically; nothing extra is needed for this node specifically.

Common issues & troubleshooting

"Where's my image output?" There isn't one. The only output is UPSCALER. If you want a picture, that goes into Iterative Upscale, and the upscale node produces the result.

You run out of VRAM at high resolution. Either flip use_tiled_vae on, or switch to the sibling PixelTiledKSampleUpscalerProvider, which is built exactly for this - it uses a tiled KSampler and tiled VAE to survive large canvases.

The upscale changes your image too much. Your denoise is too high. At 1.0 you're regenerating; pull it down toward 0.3–0.4. And keep the prompt and checkpoint the same as the original generation, or the style will drift on every pass.