ComfyUI Multi-GPU Guide (2026): Native CFG Split, ComfyUI-MultiGPU, Two Instances and Real Speed-Ups

Two GPUs in one PC used to be almost useless for ComfyUI. Each workflow ran on one card while the other sat idle.

That changed in 2026. ComfyUI now has built-in multi-GPU nodes that split sampling across matching cards, and custom node packs can spread a big model over two GPUs or run separate jobs in parallel.

This guide explains the four ways to use two or more GPUs, which one fits your cards, the exact setup steps, and what kind of speed-up to expect.

The Four Ways to Use Multiple GPUs

Native MultiGPU CFG Split (Identical GPUs)

Comfy-Org merged Kosinkadink’s “MultiGPU Work Units” pull request (#7063) on 26 May 2026. It added these core nodes:

• MultiGPU CFG Split (internal name MultiGPU_WorkUnits): splits sampling across GPUs.
• MultiGPU Options: tunes load balancing for uneven setups.
• Select Model / CLIP / VAE Device: moves a loaded model, text encoder or VAE to a chosen GPU.

How it works

With CFG above 1, every sampling step runs the model twice: once for your prompt and once for the negative prompt. The node sends each pass to a different GPU at the same time, so a step takes roughly half as long.

That also explains the limits. At CFG 1 there is only one pass, so distilled 4-8 step models and Turbo LoRAs gain nothing.

Setup step by step

1. Update ComfyUI to a build from after 26 May 2026 (Manager > Update ComfyUI, or git pull).
2. Check both GPUs are visible: run nvidia-smi. ComfyUI detects them automatically at startup.
3. Add the MultiGPU CFG Split node between your model loader and the KSampler. If other nodes (LoRA loaders, patches) also use the model, put this node last, right before the sampler.
4. Set max_gpus to the number of identical cards (default 2).
5. Keep CFG above 1 and run. Both GPUs should show load in Task Manager or nvidia-smi while sampling.

Supported models (per Comfy’s docs)

LTX-2.3, Wan 2.2, FLUX.2 Klein (base versions), Z-Image, Stable Diffusion 3.5 Large, Hunyuan Video, Qwen-Image-Edit-2511, Hunyuan-3D-v2.1 and SDXL.

Warning: Comfy’s docs say mixing different GPU models is not supported for this node. Both cards should be the same model, Ampere (RTX 30) or newer, for example 2x RTX 3090 or 2x RTX 5080.

ComfyUI-MultiGPU: Fit Bigger Models

The ComfyUI-MultiGPU pack by pollockjj (now v2) solves a different problem: a model that will not fit in one card’s VRAM.

• Simple split: put the diffusion model on GPU 0 and the text encoder and VAE on GPU 1, freeing GPU 0 for the latent work.
• DisTorch2: spread one big model’s layers across GPUs and system RAM. It supports any .safetensors model and GGUF files.

Install

1. Install from ComfyUI Manager (search “ComfyUI-MultiGPU”), or clone it:

   cd ComfyUI/custom_nodes
   git clone https://github.com/pollockjj/ComfyUI-MultiGPU

2. Restart ComfyUI. The pack lives in ComfyUI/custom_nodes/ComfyUI-MultiGPU/.
3. Swap your loaders for the MultiGPU versions. Each one adds a device input.

DisTorch2 settings

• Normal mode: one virtual_vram_gb slider moves that many GB of the model to a donor device (RAM or the other GPU).
• Expert mode, bytes (recommended): cuda:0,2.5gb;cpu,* keeps 2.5 GB on GPU 0 and the rest in RAM.
• Expert mode, ratio: cuda:0,25%;cpu,75%.
• Two GPUs, no RAM: for example cuda:0,10gb;cuda:1,* (same syntax, second GPU as the donor).

Note: this is a fitting tool, not a speed tool. Layers still run one after another, and moving data between devices adds overhead. Use it when the alternative is an out-of-memory error.

It pairs well with GGUF models; see my ComfyUI-GGUF guide for the files and loader.

One ComfyUI Per GPU (Mixed GPUs)

The simplest and most robust method: run two ComfyUI servers, each pinned to one card, on different ports. It works with any mix of GPUs and any model, including CFG 1 distilled ones.

1. Fix the GPU numbering. Set CUDA_DEVICE_ORDER=PCI_BUS_ID so IDs match nvidia-smi.
2. Start instance 1 on GPU 0:

   python main.py --cuda-device 0 --port 8188

3. Start instance 2 on GPU 1 in a second terminal:

   python main.py --cuda-device 1 --port 8189

4. Open both at http://127.0.0.1:8188 and http://127.0.0.1:8189. The console prints “Set cuda device to: 1” for the second one.

On the Windows portable build, copy run_nvidia_gpu.bat to run_gpu1.bat and add --cuda-device 1 --port 8189 to the end of the python line.

Tip: both instances read the same ComfyUI/models/ folders, so you do not need two copies of your models. Each one does need enough system RAM to load its own copy, so 64 GB+ RAM helps.

All launch flags are explained in my ComfyUI command line arguments cheat sheet.

ComfyUI-Distributed: Parallel Batches and Upscales

ComfyUI-Distributed (robertvoy) automates the “one instance per GPU” idea from a single interface. It can also use GPUs on other PCs or cloud machines.

• Distributed Seed: gives every worker a different seed.
• Distributed Collector: brings all results back to the main UI. Its load_balance option sends each queued run to the next free GPU.
• Ultimate SD Upscale Distributed: splits upscale tiles across workers, the one case where a single image gets faster.

Install by cloning https://github.com/robertvoy/ComfyUI-Distributed into ComfyUI/custom_nodes/ and restarting. Local workers on extra GPUs are set up automatically on first launch.

Warning: for remote workers you must add --enable-cors-header. Never expose the ComfyUI port to the internet; use a VPN or secure tunnel.

Real Speed-Ups You Can Expect

Comfy’s own docs quote “up to 1.95x” for CFG Split. Gains shrink on light workloads, where splitting overhead can even make things slower.

Which Method for Your Setup

• 2x identical cards (e.g. 2x RTX 5080), Wan 2.2 or LTX at CFG > 1: native MultiGPU CFG Split.
• 2x identical cards, distilled 4-step workflows: two instances, one per GPU, for double throughput.
• Mixed cards (e.g. 5080 + 3060): two instances, or ComfyUI-Distributed with load_balance.
• A video model that runs out of memory on 16 GB: ComfyUI-MultiGPU with the text encoder on the second card. See also my Wan 2.2 on 16 GB guide.
• Big upscales: ComfyUI-Distributed’s tiled upscaler.

Hardware Tips for a 2-GPU ComfyUI PC

• PCIe lanes: x8/x8 is fine for these methods; data between cards is small compared with the compute.
• Power: two RTX 5080s need a quality 1,200 W+ PSU with enough native 12V-2×6 connectors.
• Cooling: leave a slot gap or use a case with strong airflow; the top card runs hot.
• System RAM: 64 GB minimum, 128 GB if you run two instances with video models.
• Same card vs bigger card: one 32 GB card still beats two 16 GB cards for models that need 20+ GB in one piece. My RTX 5090 vs 2x RTX 5080 comparison covers that trade-off.

Troubleshooting

Only one GPU shows activity with CFG Split

Check CFG is above 1, that the node sits directly before the sampler, and that both cards are the same model. Run nvidia-smi during sampling to confirm.

Two GPUs are slower than one

The workload is too light (small images, few steps), so overhead wins. Use CFG Split for heavy video jobs and separate instances for quick images.

Out of memory after updating ComfyUI

Some later commits caused memory regressions with multi-GPU. Update again to the newest build, or temporarily remove the MultiGPU node and report the commit on GitHub.

The wrong card is used

Set CUDA_DEVICE_ORDER=PCI_BUS_ID before launch and match the IDs to nvidia-smi. Note that --cuda-device overrides any CUDA_VISIBLE_DEVICES value.

Second instance will not start

Port 8188 is taken. Give each instance its own --port. If the page loads but jobs fail, see my ComfyUI Reconnecting fix.

DisTorch2 is very slow

Too much of the model is in system RAM. Give the GPU a bigger share in expert mode, or use a smaller GGUF quant.

My Take

The native node is the big news. For anyone with two matching cards, like my own 2x RTX 5080 rig, heavy Wan or LTX jobs at normal CFG can now finish close to twice as fast with one extra node.

For the fast distilled workflows most people use day to day, running one ComfyUI per GPU is still the better deal: twice the output, zero compatibility worries.

And if your real problem is VRAM, not speed, ComfyUI-MultiGPU is the tool. Just do not expect two 16 GB cards to behave like one 32 GB card.

FAQ

Does ComfyUI support multiple GPUs?

Yes. Since a May 2026 update, ComfyUI has built-in MultiGPU nodes that split sampling across identical GPUs. Custom nodes add model splitting and distributed batches.

Can ComfyUI combine VRAM from two GPUs?

Not transparently. ComfyUI-MultiGPU can place different parts of a model on each card, but the cards do not act as one big pool.

Does multi-GPU speed up a single image?

Only with the native CFG Split node at CFG above 1, or for tiled upscales with ComfyUI-Distributed. Other methods give more images at once, not a faster single image.

Can I use two different GPUs in ComfyUI?

Yes, with one ComfyUI instance per GPU, ComfyUI-Distributed or ComfyUI-MultiGPU. The native CFG Split node needs identical cards.

How do I choose which GPU ComfyUI uses?

Start it with --cuda-device 1 (or 0). Set CUDA_DEVICE_ORDER=PCI_BUS_ID so the numbers match nvidia-smi.

Why does MultiGPU CFG Split not help my Turbo workflow?

Distilled models run at CFG 1, which has only one model pass per step, so there is nothing to split between GPUs.

Is two RTX 5080s better than one RTX 5090 for ComfyUI?

For throughput and CFG-split video jobs, two can be faster. For single models that need more than 16 GB in one piece, the 32 GB RTX 5090 is simpler and often better.

Sources

• ComfyUI docs: MultiGPU CFG Split node
• GitHub: Comfy-Org/ComfyUI PR #7063, MultiGPU Work Units
• GitHub: pollockjj/ComfyUI-MultiGPU
• GitHub: robertvoy/ComfyUI-Distributed
• AI Hardware Zukan: ComfyUI dual-GPU tests