Distributed Collector

Distributed Collector is the other half of the two-node conversion that turns a normal ComfyUI workflow into a parallel one. Distributed Seed makes each GPU generate something different; Distributed Collector is what pulls all those different results back to the master machine so they land in a single batch you can save. Without it, your workers would happily generate images that never leave their own machines.

Think of it as the funnel. Every participating GPU runs the full workflow, produces its own image or video frames (and optionally audio), and this node is the point where those separate streams merge into one output on the master.

How it works

You place it right after your VAE Decode, on the master's copy of the graph. When the run kicks off, the master dispatches the workflow to each enabled worker, they each render their share, and the Collector waits for their decoded results to come back over the network, then concatenates everything into one batch. Downstream, a single Save Image node sees the whole harvest.

The one behavior to internalize - it's the pack's defining limitation - is that the Collector waits for the slowest participant before it calls the run done. Everything is parallel, but the batch isn't finished until the last, slowest worker reports in. Pair a fast card with a slow one and the fast one sits idle at the end, twiddling its thumbs while the laggard finishes. This is exactly why the pack works best across GPUs of similar speed; a big performance gap turns into dead time rather than a clean sum of throughput.

The inputs and outputs

• load_balance (BOOLEAN, default false) - the one setting worth understanding. Off, work fans out to every enabled participant. On, the Collector routes the run to a single least-busy participant instead of splitting across all of them. That sounds backwards for a parallel tool, but it's the right call when you're firing many small jobs and want each to land whole on whichever card is free, rather than fragmenting one job across a fleet. For the classic "four images at once" pattern, leave it off.
• images (IMAGE, optional) and audio (AUDIO, optional) - the inputs from your decode. Images is the usual one; audio is there so audio workflows (and the video-with-sound case) collect their waveform alongside the frames. They're optional because a given workflow might carry one, the other, or both.

The outputs mirror the inputs: images (IMAGE) and audio (AUDIO). Wire the images output into Save Image (or Video Combine for animation); wire audio out only if you fed audio in.

Installing it

It's part of the ComfyUI-Distributed pack - install the pack and you have it. Via ComfyUI Manager: search ComfyUI-Distributed, install, restart. By hand: cd ComfyUI/custom_nodes && git clone https://github.com/robertvoy/ComfyUI-Distributed.git, then restart ComfyUI. No model downloads, no heavy dependencies. If any of your workers live on other machines or in the cloud, remember to launch the master with --enable-cors-header - without it the master's browser refuses the cross-origin traffic and your workers look "connected" but never deliver.

Where people get burned

• Placed in the wrong spot. It belongs after VAE Decode, collecting finished images, not somewhere mid-graph on latents. Put it late.
• Expecting speed on one image. Collecting from workers gives you more outputs per run, not a single output sooner. The exception in this pack is the distributed upscale node; plain generation is throughput, not latency.
• The slowest-worker tax. If your GPUs are mismatched, the whole batch finishes on the slow card's clock. Nothing's broken - that's the design. Similar cards, or accept the idle time.
• Workers that connect but deliver nothing. Almost always the CORS header or a network/firewall issue between machines rather than the node itself. Confirm the master launched with --enable-cors-header and that the workers are actually reachable before blaming the Collector.
• load_balance switched on by accident. If you enabled it and now only one card seems to work per run, that's it doing its job - flip it back off for fan-out generation.