PixelKSampleUpscalerProviderPipe

Iterative Upscale is the loop; this node is the engine that runs inside it. Per the README, PixelKSampleUpscalerProvider "converts latent to pixels using VAEDecode, performs upscaling, converts back to latent using VAEEncode, and then performs k-sampling. This upscaler can be attached to nodes such as Iterative Upscale for use." PixelKSampleUpscalerProviderPipe is the pipe-flavored version - same job, but it takes a basic_pipe (model/clip/vae/positive/negative bundled) instead of those five inputs listed separately, matching the convention most of Impact Pack's upscaler-provider nodes follow.

This is the standard, whole-image upscaler for iterative upscaling - no mask splitting, no per-region SEGS work, just: enlarge the pixels, then run a fresh k-sampling pass at the new size to re-add detail an interpolation alone can't produce. If you only need one thing detailed evenly across the whole frame during an upscale, this is the plain, general-purpose choice, as distinct from the SEGS-flavored upscalers built for targeting specific detected regions.

How it works

Each time Iterative Upscale calls into this provider for a step, it decodes the current latent to pixels, resizes with scale_method (optionally using upscale_model_opt - an ESRGAN-family model - to do the actual pixel enlargement instead of plain interpolation, which meaningfully cuts how many iterative steps you need), re-encodes to latent, then runs a k-sampling pass with the seed/steps/cfg/sampler_name/scheduler/denoise you've set. use_tiled_vae swaps the decode/encode for a tiled version to control VRAM. tile_cnet_opt and tile_cnet_strength let you apply a ControlNet (typically a tile-conditioning ControlNet) during the resample, which helps keep detail coherent instead of diverging tile-to-tile at high resolutions.

The inputs and outputs that matter

• basic_pipe (required) - model/clip/vae/positive/negative, bundled.
• seed / steps / cfg / sampler_name / scheduler / denoise - the k-sampling controls applied at each iteration step. Defaults: steps 20, cfg 8, denoise 1. In practice, denoise on an upscale pass is usually run much lower than 1 - a full-denoise resample at each step tends to drift the image away from the original rather than just adding detail to it.
• scale_method (nearest-exact / bilinear / lanczos / area) - resize method, used when upscale_model_opt isn't provided (or as the downscale-to-target step after an upscale-model pass).
• use_tiled_vae (default false) and tile_size (default 512) - VRAM controls for the internal VAE round-trip.
• Optional: upscale_model_opt (a real ESRGAN-family upscale model - the recommended path over plain interpolation for genuine added detail), pk_hook_opt (a PK_HOOK for scheduling CFG/denoise/steps across iterations), scheduler_func_opt, and tile_cnet_opt/tile_cnet_strength for tile-conditioned ControlNet during resampling.

Output is a single UPSCALER - a plugin object, not an image. Feed it into Iterative Upscale (Latent/on Pixel Space) or Iterative Upscale (Image), which drives the actual loop.

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. For upscale_model_opt, get an ESRGAN-family model (4x-UltraSharp, Remacri, or similar) into ComfyUI/models/upscale_models - that's separate from the base pack install.

Common issues & troubleshooting

Connected it but nothing happens. This node only produces an UPSCALER plugin - it must feed into an Iterative Upscale node to actually run.

Upscaled image looks like a different picture, not a bigger version of the original. denoise is too high for an upscale pass. Bring it down substantially (0.2–0.4 is a common range) so the k-sampling step adds detail rather than regenerating the image.

Detail looks tiled or inconsistent at high resolutions. Add a tile-conditioning ControlNet via tile_cnet_opt (with a reasonable tile_cnet_strength) to help each tile agree with its neighbors during resampling, or reduce your scale-per-step so each iteration has less ground to cover.

Ran out of VRAM. Enable use_tiled_vae and consider lowering tile_size. This provider does a real decode/upscale/encode/sample cycle at every step, so it's meaningfully heavier than a plain interpolation-only upscale.

Not using an upscale model, resize looks soft. scale_method alone (Lanczos, bilinear, etc.) is a plain interpolation - it adds no real detail. If you want genuinely sharper results, plug an ESRGAN-family model into upscale_model_opt.