Parallel Anything (True Multi-GPU)

If you have two GPUs in one machine, you've probably stared at nvidia-smi wondering why ComfyUI only ever lights up one of them. ComfyUI's model management runs the diffusion model on a single device and offloads stragglers to RAM; there's no built-in way to make two cards share a generation. Parallel Anything is the node that changes that - with a catch you should hear before you install it.

What it actually does

This is model replication (data parallelism), not the model-parallelism you might be hoping for. Instead of splitting layers across cards, it makes an independent, full copy of the model on every device in your chain and runs them all at once, each card chewing on a chunk of the batch. That means N× VRAM for roughly N× throughput - a model that barely fits one card won't be saved by a second card, it'll just need both to be big.

The author tested it on Z-Image, FLUX.1, and Wan 2.2, and it's built around the transformer blocks those DiT models share. It shipped in February 2026 and got a nod in the March "ComfyUI releases you missed" roundup - a small footprint for a pack that scratches a very specific itch.

How it works

The source is more honest than the marketing. On the first run the node pulls the diffusion_model out of the ComfyUI wrapper, applies any LoRA patches so every replica carries them, then deep-copies the weights to each device in the chain. Your model's forward gets swapped for a parallel_forward that decides at runtime:

• Batch ≥ number of devices - splits the batch by your percentage weights and runs each chunk on its own GPU replica, each on its own CUDA stream, in a thread pool. Then it synchronizes and concatenates results back on the lead device.
• Batch == 1 - flips into pipeline mode and hands blocks of the model to the other devices instead.
• Batch too small, or a card OOMs - quietly falls back to a single device.

There's also an auto_vram_balance toggle that re-weights the split using each card's free VRAM, and the node clones/detaches tensors precisely to dodge PyTorch's "Inference tensors do not track version counter" error - the classic way multi-GPU ComfyUI crashes.

The inputs that matter

Only two are required:

• model - your MODEL from Load Checkpoint, after your LoRA chain. Place the node right before the KSampler.
• device_chain - the DEVICE_CHAIN output from the Parallel Device nodes, where you already said which GPUs to use.

The optional toggles are mostly set-and-forget: workload_split (enable multi-device processing), auto_vram_balance, purge_cache, and purge_models (the last one aggressively unloads everything on cleanup - nice when you want VRAM back, fiddly when you don't).

The single output is still a plain model, so the KSampler downstream doesn't care anything happened.

Install

cd ComfyUI/custom_nodes
git clone https://github.com/FearL0rd/ComfyUI-ParallelAnything.git

Restart ComfyUI. ComfyUI Manager finds it under "ComfyUI-ParallelAnything" if you'd rather click. Dependencies are basically nothing - requirements.txt is just torch, which you already have.

Where people get burned

• VRAM doubles. Each GPU must independently hold the full model.
• Batch size must exceed the device count, and 8–16 is the sweet spot. Single-image gens fall back to one card and gain nothing.
• PCIe is the ceiling. The README's own benchmark: 26.0 s/it on one 3090, 12.91 with a V100 + 3090 - the ideal ~2× - only because those cards shared a root complex. On separate NUMA nodes you can lose the race entirely.
• Mixed architectures wait. A 4090 + 3090 runs at the 3090's pace; use percentages (say 60/40) to compensate. Pre-Ampere cards get flash attention disabled automatically.
• "Expected all tensors to be on the same device … cuda:0 … cuda:1" after changing percentages on a second run: restart ComfyUI or add --cache-none to your startup args.

It's inference-only (no gradient sync), load balancing is static per run, and it's genuinely pointless on a single-GPU box. But if you've got identical cards and you batch, this is the rare thing that makes the second fan spin.