PixelRush

PixelRush is the odd one out in this pack. The other nodes in ComfyUI-DyPE are model patches - they reach inside the transformer's positional encoding to let a DiT like FLUX generate far beyond its training resolution. PixelRush doesn't touch your model at all. It's a cascade refiner: you generate a base image at native resolution, then it adds detail through a sequence of coarse-to-fine refinement passes, each doubling the size, until you've got crisp 4K without ever regenerating the whole thing from noise.

That's a genuinely different approach to the upscaling problem, and it's worth placing it next to the usual suspects. Plain ESRGAN upscalers add pixels and nothing else; hi-res fix regenerates the whole image in a second pass at low denoise, which is where composition drifts and faces get rebuilt. PixelRush splits the difference - it keeps the base structure intact and grows detail into it patch by patch. It also works with any ComfyUI model (SDXL, SD1.5, FLUX, Qwen), which makes it the pack's sensible choice for the SD-era models that the RoPE-extrapolation nodes can't help.

How it works

Each cascade stage runs a partial DDIM inversion to a timestep K, injects noise, then does one denoising step per overlapping latent patch. The patches are blended with Gaussian feathering so seams don't show. Because it operates on patches around the native size, VRAM stays roughly flat instead of ballooning with output resolution - that's the whole trick, and it's why you can reach 4K on a card that can't hold a 4K latent.

Two implementation details matter to how it behaves. First, it calls the diffusion model directly, not through ComfyUI's sampler, and does its own CFG and prediction-type handling for EPS, flow, V-prediction and X0 models - so it works across model families, but it's also why k_timestep has to line up with the model's noise schedule. Second, the inversion + noise injection runs in VAE latent space via injected adapters; that fix ("operate in VAE space") is what killed the old "totally noisy output on SDXL" bug that's still floating around in older threads.

The inputs that matter

You feed it model, vae, positive, negative and a base latent_image at native resolution, then:

• num_cascade_stages - the main lever. 1 = 2× upscale, 2 = 4×, 3 = 8×.
• noise_lambda (default 0.95) - how much invented detail the noise brings in. Lower = more faithful to the base, less new texture; higher = more creative upscale.
• overlap (default 0.5) - patch overlap fraction. 50% is the paper default and blends seams well; crank it toward 0.75 if you see tiling.
• k_timestep (default 249) - the partial-inversion step. It must be a valid timestep in your model's schedule, or the stage comes out garbage.
• patch_h / patch_w (default 0 = auto) - set these around the model's native latent size to keep VRAM flat at higher cascade counts.

Output is a single Refined Latent; VAE-decode it as usual.

Installing it

PixelRush ships inside ComfyUI-DyPE. Via ComfyUI Manager, search "ComfyUI-DyPE" and install; or:

cd ComfyUI/custom_nodes
git clone https://github.com/wildminder/ComfyUI-DyPE.git

Then restart. There are no extra pip dependencies (just torch and numpy, which ComfyUI already ships) and no model downloads.

Where it bites

The cascade approach is slower than a hi-res-fix second pass because every stage re-runs the model across patches - 8× (three stages) is a real time commitment, especially at 50-step defaults. And like every generative upscaler, it invents detail, so identity drift applies: don't expect a recognizable face to survive an 8× run unscathed. If you're coming from DyPE/SEGA, note that PixelRush is not a position-extrapolation method and can be stacked with them - but honestly, for most SDXL/SD1.5 users it's the node in this pack worth reaching for first.