C2C Multi-GPU Split

ComfyUI has never had a good answer to "I own two GPUs." A second card doesn't extend your VRAM - nothing pools memory across cards - so the usual outcome is one card at 100% and one keeping the room warm. The community's read on it: data parallelism (two renders at once) is the reliable win, and splitting a single generation is the fiddly one.

C2C Multi-GPU Split is that second thing, done as a node. Wire it into a model chain and one generation gets spread across the GPUs in the box.

Two splits wearing one node

Batch items, any model. Every model call carries a batch - cond and uncond when CFG is above 1, an image batch, the tiles coming out of a Tile Split. Those items go to different GPUs and never talk to each other, so on 8 GPUs with CFG you get cond and uncond on four cards each. It reuses ComfyUI core's own per-GPU clones (the mechanism behind core's MultiGPU CFG Split), so weights load once per card.

Tokens, for Wan 2.1/2.2 and MiniMax H3. These models have an adapter, so the node goes further: inside each GPU group, the token sequence itself is cut before the first transformer block and gathered after the last one, and every self-attention call is split. That's Ulysses (all-to-all over attention heads), Ring (K/V blocks passed around), or USP, which is the hybrid the auto setting reaches for: Ulysses as far as your head count and your fast links allow, Ring for the rest.

It works on Windows because there are no collectives under the hood - just threads and .to(device) tensor moves, using P2P / NVLink where the cards have it. Deliberate: NCCL isn't available on a Windows torch build and gloo can't create a device there, so anything depending on torch.distributed was dead on arrival for people with two consumer cards.

The inputs you actually set

model is the chain you're feeding. gpus takes 0 for "all that ComfyUI sees," which is what you want on the first run. strategy stays on auto unless you know your hardware - ulysses with NVLink between the cards, ring when they're on plain PCIe.

The number that decides whether splitting helps is min_tokens_per_gpu (default 1024): a call with fewer tokens per GPU than this runs on one card, because below that the exchange costs more than it saves. Optional fast_link_gpus is only for a partial NVLink topology; leave it at 0 at first.

Two outputs: model into your sampler, and plan, a STRING describing what it decided - how many GPUs went into the batch split, how many into Ulysses, what it refused. Read it; it's the only window into the planner.

Installing it

Manager → search CustomNodePacks, or:

cd ComfyUI/custom_nodes
git clone https://github.com/Code2Collapse/ComfyUI-CustomNodePacks.git

Read requirements.txt rather than running it: it pulls opencolorio, timm, einops and friends, none of which this node needs. Restart, check for the pack's 115 nodes loaded (… C2C Distributed 2 …) line, then add C2C GPU Inventory to the same graph: it tells you what your box can actually do. With one GPU you can still test the plumbing - C2C_DISTRIBUTED_SIMULATE=2 runs two ranks on the device you have, slower and at twice the model memory, so a setup check and never a benchmark.

Where people get burned

It has to go last in the model chain. After LoRA loaders, after attention-patch nodes. If a later node patches the transformer blocks or sets its own attention override, the node refuses at run time and names the patch rather than producing a quietly wrong image. A Sage or flash override set before it is kept.

It does not add VRAM. Each GPU holds a full model copy, same as core's CFG split. A model that doesn't fit on one 16 GB card still doesn't fit on two.

ControlNet is refused, GGUF and some custom loaders are refused (core's clones need a loader that can reload itself - use a core loader), and models without a sequence adapter - Flux, SDXL, VACE, Wan Animate - get the batch split only. Still a real speed-up with CFG above 1, just not the token-level one.

The planner hedges rather than failing: heads not divisible by the Ulysses degree means Ring or fewer GPUs, a batch that doesn't divide the GPU count means tokens get split instead.

And the honest caveat: per the pack's own design notes the speed-up has not been measured, because measuring it needs a machine with two or more GPUs. Correctness is what was measured - Ulysses at 2 and 4 GPUs came out bit-identical to the unsplit model, Ring and USP within the precision's own rounding. Go in ready to measure, because on PCIe links it may well not be faster.