Iterative Upscale (Latent/on Pixel Space)

Upscale a latent 3x in one jump and the model has to hallucinate a lot of missing structure at once, which is how you get mush and repetition. Iterative Upscale (Latent) avoids that by doing it gradually. It splits your total scale factor into several smaller steps and enlarges-then-resamples at each one, so detail gets a chance to develop as the resolution climbs. The result at 3x is noticeably more coherent than a single big leap. This is the node behind Impact Pack's "extreme upscale" workflows.

It works on latents in and out, which makes it a clean stage to drop between your sampler and your final decode.

How it works

You hand it a latent, a target upscale_factor, a number of steps, and - this is the important part - an upscaler. That upscaler is a provider node, not a model file: PixelKSampleUpscalerProvider is the usual one, which decodes to pixels, upscales, re-encodes, and runs a sampling pass. Iterative Upscale calls that provider once per step, dividing the scale factor across the steps so each pass only has to grow the image a little. Give the provider an ESRGAN model and it'll use that model's upscale to do the enlarging cheaply, so the sampler only refines.

The inputs and outputs that matter

• samples (LATENT) - the latent to upscale, straight from your KSampler.
• upscale_factor (default 1.5) - total enlargement. 1.5–2x is the sweet spot for one of these; go higher and add steps.
• steps (default 3) - how many stages the scale is split across. More steps means gentler per-stage growth and better coherence, at the cost of time.
• upscaler (UPSCALER) - the provider that does each stage's actual upscale-and-sample. Required, and the piece people forget: this node does nothing without one wired in.
• step_mode (simple or geometric) - how the scale factor is divided across steps. Geometric ramps the size up multiplicatively rather than in equal increments.

Outputs are the upscaled latent and the vae (passed through so you can decode downstream without re-wiring it).

How to install it

ComfyUI Manager: search ComfyUI Impact Pack, Install, restart.

Manual:

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

Run the pip in ComfyUI's Python environment and restart. You'll want a 4x upscale model in ComfyUI/models/upscale_models to feed the provider; without one the provider falls back to plain interpolation before sampling, which works but throws away the cheap-detail advantage.

Common issues & troubleshooting

"Nothing happens" / a missing input error. The upscaler input is required and it's not a model - it's a provider node. Wire a PixelKSampleUpscalerProvider into it. This is the single most common confusion with iterative upscale: people look for a model dropdown that isn't there.

Out of VRAM at high resolutions. The pixel provider decodes the whole image each step, which gets heavy. Use PixelTiledKSampleUpscalerProvider instead (it tiles the VAE and sampler), and note that needs the ComfyUI_TiledKSampler pack installed.

Working with an image, not a latent? Use Iterative Upscale (Image) instead - it's the same engine wrapped to take pixels in and out (it just runs this node internally).

It reinvented detail you didn't want. Each step is a sampling pass, so it adds content, not just pixels. If your source is already sharp and you only want more resolution, a plain ESRGAN upscale is the right tool and won't rewrite anything.