Ultimate SD Upscale Distributed (No Upscale)

This is the one node in the ComfyUI-Distributed pack that actually makes a single image finish faster, and that's the whole reason it exists. Everything else in the pack gets you more images in parallel; a distributed upscale takes one big image, chops it into tiles, and farms those tiles out across every GPU you've got. Four cards, roughly a quarter of the wall-clock time. That's the pitch, and for once it's honest.

A little orientation first, because the display name trips people up. The node registers as "Ultimate SD Upscale Distributed (No Upscale)." No Upscale means it does not run the ESRGAN/Lanczos pixel-enlargement step itself - you do that upstream. This node is the second half: the tiled diffusion refinement pass that adds detail back after you've already made the image bigger.

Where it sits in the workflow

Tiled diffusion upscaling is a well-worn category. You split the image into overlapping tiles, run a low-denoise img2img pass on each one, and blend them, which lets you reach 4K on a card that could never diffuse a 4K latent in one shot. Ultimate SD Upscale is the most accessible member of that family. The catch has always been time: every tile is a full sampler run, so a 6x6 grid is 36 little generations in series. Robertvoy's version hands those tiles to workers instead of grinding them one after another.

So the real-world flow, straight from the pack's own example: load your image, enlarge it with a 4x ESRGAN model (or similar), feed that into this node's upscaled_image input, configure your tiles, enable your workers. Speed scales with how many GPUs you add.

Worth saying plainly: this is a speed play, not a quality upgrade. A single-GPU Ultimate SD Upscale produces the same output; you're just paying less wall-clock for it. If you're chasing maximum detail rather than throughput, the community has largely moved to SeedVR2 for the "add detail" job - people report it running faster than Ultimate SD Upscale with better results. Reach for this node when you're already committed to a tiled SD upscale and you happen to own more than one card.

The inputs that matter

Past the required plumbing - upscaled_image, model, positive, negative, vae - the knobs you'll actually tune:

• denoise (default 0.5) - how hard each tile gets re-imagined. This default is on the high side. The standing advice is 0.3–0.5, and above 0.5 the tiles start drifting from the source into patchwork. If your upscale looks like a quilt of slightly-different images, this is why. Drop it to 0.35.
• tile_width / tile_height (default 512) - the tile size the image is diced into. Bigger tiles mean fewer, larger sampler runs and better coherence per tile; smaller tiles spread more evenly across many workers. 512 is a fine start.
• padding (default 32) - overlap between tiles so seams blend instead of hard-edging.
• mask_blur (default 8) - feathering on the blend, same purpose.
• force_uniform_tiles (default on) - keeps every tile the same size, which matters more here than in the single-GPU version because even tiles distribute evenly across workers.
• steps / cfg / sampler_name / scheduler / seed - the sampler settings for the per-tile pass, exactly as you'd set a KSampler. For video upscales the pack author recommends the RES4LYF solvers (res_2, bong schedules) for cleaner results.
• tiled_decode (default off) - decode the VAE in tiles too, to save VRAM on the final assembly. Turn it on if you OOM at the decode step.

The single output is IMAGE - the reassembled, refined result. Send it straight to a Save Image node.

Installing it and the gotchas

Grab the whole pack, not the node alone. In ComfyUI Manager, search ComfyUI-Distributed, install, restart. Or from a terminal: cd ComfyUI/custom_nodes && git clone https://github.com/robertvoy/ComfyUI-Distributed.git, then restart ComfyUI. There are no model downloads or heavy pip dependencies - the "dependency" is literally having multiple NVIDIA GPUs (or cloud workers standing in for them).

The traps are all about the workers, not the node:

• No workers, no benefit. With only the master enabled, this behaves like a slow single-GPU Ultimate SD Upscale. The speedup is entirely in enabling other GPUs in the Distributed panel.
• The slowest card sets the pace. Tiles come back only as fast as your weakest worker finishes its share, so a 5090 paired with a 3060 spends a lot of time waiting. Similar cards distribute best.
• Remote workers need CORS. If any worker lives on another machine, launch the master with --enable-cors-header or the browser silently refuses to talk to them.
• Too-high denoise = seams. Restating it because it's the number one complaint: keep denoise modest and let padding/mask_blur do the blending.