Auto Checkpoint Loader (MultiGPU)

If you've got two GPUs and a combined checkpoint that keeps OOMing, this is the node that finally uses the second card for something. Normal checkpoint loaders dump every part of the file - the UNet, the CLIP text encoder, the VAE - onto your primary GPU, and then all of it fights for the same VRAM during sampling. This one loads the same single .safetensors file, but deliberately parks the MODEL on one card and the CLIP plus VAE on the other. The sampler keeps all of GPU0 for itself; the text encoder and decoder work off the spare card.

It's part of the ComfyUI-AutoMultiGPU pack from nexusfinancial-dev, which also ships the bigger three-engine loaders you'll probably graduate to. This checkpoint loader is the entry point: same idea, simpler shape, no architecture picker.

How it works

The name gives away the mechanism, and the README is telling the truth here: it's "pure PyTorch," zero monkey-patching. Behind the scenes it calls ComfyUI's own load_checkpoint_guess_config() but passes explicit load_device options - cuda:0 for the model, cuda:1 for the encoders and VAE. No layer surgery, no patched ModelPatcher. That's why it's the most stable loader in the pack: it's just ComfyUI core with a smarter device map.

The distribution_mode dropdown decides that map:

• Auto: UNet GPU0 / Encoders GPU1 (default) - the classic split described above.
• Auto: Balanced Free VRAM - checks real-time free VRAM on both cards and puts the heaviest piece (the model) on whichever has more headroom.
• Auto: Split Video (GPU0 Sampler / GPU1 VAE) - for video pipelines where the VAE decode is the memory spike.
• Manual Override - hands control to the manual_unet_device, manual_clip_device, and manual_vae_device inputs below.

One thing worth knowing: if you only have one GPU, it detects that and routes everything to cuda:0. You'll get identical behavior to a stock loader, just with extra steps.

The inputs that matter

Two, really: ckpt_name (the checkpoint dropdown) and distribution_mode. The three manual device inputs only do anything when you've selected Manual Override, so ignore them until then.

Outputs are the usual trio - MODEL, CLIP, VAE - which wire straight into your KSampler, CLIP Text Encode, and VAEDecode exactly like a stock loader. Nothing downstream knows or cares that parts of the file live on different cards.

Installing it

ComfyUI Manager, search ComfyUI-AutoMultiGPU, install, restart. Or the manual route:

cd ComfyUI/custom_nodes
git clone https://github.com/nexusfinancial-dev/ComfyUI-AutoMultiGPU.git
cd ComfyUI-AutoMultiGPU
pip install -r requirements.txt

Its dependencies are just torch>=2.4.0, accelerate>=0.30.0, and safetensors>=0.4.0 - you already have all three in any working ComfyUI install, so this is a light add.

Where people get burned

This node only loads combined checkpoints. If your file is a standalone diffusion model or a GGUF quant, it won't be in this dropdown - use the pack's AutoUNETLoaderMultiGPU or one of the engines instead. And manage expectations: splitting a model across cards is not free speed. On a typical consumer motherboard the second GPU hangs off reduced PCIe lanes, so text encoder transfer can become a bottleneck. This split shines when one card is idling; on a tight two-card rig it's still better than an OOM.