Load Checkpoint (MultiGPU)

This is the node the pack is actually about. Load Checkpoint (MultiGPU) is the drop-in replacement for ComfyUI's Checkpoint Loader that takes a normal SD/SDXL safetensors checkpoint and shards its UNet across however many GPUs you tell it to. The goal, per the README, is Ollama-style multi-GPU weight sharding for diffusion: make 2×RTX 3090 hang with a 6000 Ada, or 4×8GB cards pretend to be one 32GB card.

Before you get excited, two grounding facts. It shards native safetensors checkpoints - this is not quantization, and the README is explicit that it does not do GGUF or VRAM-reduction. And it runs over plain PCIe with no NVLink required; the author tested on RTX 3070s without NVLink.

How the sharding works

Under the hood it calls ComfyUI's own load_checkpoint_guess_config (so your checkpoint's architecture is detected the normal way), finds the diffusion module, then splits it. For SD/SDXL UNets it walks input_blocks and places them round-robin across your GPUs; output_blocks are placed in reverse order to align with the skip connections; the middle block goes on the last card; and time_embed, label_emb, and out stay on the primary GPU. It injects a custom forward pass that migrates activations between devices at runtime. The CLIP and VAE stay on the primary card - only the UNet is distributed.

Inputs that matter

• ckpt_name - your checkpoint from models/checkpoints. There's a special test_mode entry in the list (more on that below).
• num_gpus - 1–4 or Auto. This is how many cards you want, not an exact list.
• gpu_ids - comma-separated indices in execution order (default 0,1,2,3). This is what the Hardware Validator feeds into the loader.
• clip_name1 / clip_name2 - external text encoders; leave <auto> to use the checkpoint's embedded CLIP.
• clip_loader_type - auto, sdxl, sd3, flux, hunyuan_video, hidream, hunyuan_image.
• vae_name - external VAE if the checkpoint has none bundled.
• safety_ok - the gate from the Hardware Validator; when false, the load aborts.

Outputs

model, clip, vae - the same three sockets as a stock loader, so it slots straight into a normal graph (CLIP encode → sampler → VAE decode). A good pattern: Hardware Validator's gpu_ids → this loader's gpu_ids, and ok → safety_ok.

Installing it

ComfyUI Manager search "Comfy-MultiGPU-Loader", or:

cd ComfyUI/custom_nodes
git clone https://github.com/AngelCookiesLab/Comfy-MultiGPU-Loader
pip install -r requirements.txt   # accelerate only; torch already present

Restart, find it under MultiGPU/Loaders.

Where people get burned

If your checkpoint lacks an embedded CLIP or VAE, the loader raises unless you specify external files - so keep a text encoder and VAE handy. If the multi-GPU setup itself fails, it doesn't hard-crash; it falls back to the primary GPU and reports a ⚠️ notice in the status. And one thing the README is refreshingly honest about: this is early-stage code with known bugs (diagnostics under-report on later runs), the project is sunset/"as-is" with no active support, and only Flux Dev Full fp32 (~22GB) is verified. Expect PCIe sharding to trade speed for capacity - the win here is fitting a model, not going faster.