Load Diffusion Model+

"Load Diffusion Model+" (class EnhancedLoadDiffusionModel) is the unglamorous workhorse of the Comfy-WaveSpeed pack: a straight upgrade to ComfyUI's built-in UNet loader that folds weight dtype selection straight into the node. If you've ever had to reach for a separate "load model as FP8" node or fiddle with model options just to run Flux on a 12GB card, you get the appeal immediately. The entire point of this node is that weight_dtype dropdown on the node face.

Everything else in this pack - First Block Cache, Compile Model+ - is a speed layer you stack on top of a loaded model. This node is the foundation those layers sit on.

How it works

It's a thin wrapper around ComfyUI's own comfy.sd.load_diffusion_model, with one addition: it parses your chosen weight_dtype into the correct model options before loading. No new machinery, no patching, no hidden magic. The value is pure convenience and correctness - it makes the dtype explicit instead of relying on whatever a conversion node happened to write into the checkpoint.

One subtlety worth knowing: the fp8_e4m3fn_fast option doesn't just set the dtype, it also flips ComfyUI's fp8_optimizations flag, which is what actually enables fast fp8 path on GPUs that support it. That's why "fast" exists as a separate choice and why it's the one the README's Flux example uses.

The inputs

Only two, and only one of them you'll actually touch:

• unet_name - pick from the .safetensors files in your models/diffusion_models folder (the same list the stock loader shows).
• weight_dtype - the star. Your choices:
  • default - load as the file is written.
  • float32 / float64 / bfloat16 / float16 - explicit full or half precision. bfloat16 is what you want for most modern transformers if you're not doing fp8.
  • fp8_e4m3fn - fp8, near-zero visible quality loss at roughly half the VRAM of fp16.
  • fp8_e4m3fn_fast - same weights, plus the fast-path optimizations. The community default for Flux on 12–16GB cards.
  • fp8_e5m2 - the older, lower-precision fp8 format. Slightly smaller, noticeably rougher; the KB's quantization notes rank it below e4m3. Use only if you must.

The single MODEL output goes to your sampler - or, since you're reading about this pack, straight into Apply First Block Cache and then Compile Model+.

Install

ComfyUI Manager (search "WaveSpeed"), or:

cd ComfyUI/custom_nodes
git clone https://github.com/chengzeyi/Comfy-WaveSpeed.git

Restart, then the nodes appear under the wavespeed category. No models to download, no Python extras - this node in particular needs nothing beyond stock ComfyUI.

Gotchas

Honestly, this is the rare node with almost no failure modes to warn you about, because it defers everything to ComfyUI's own loader. The one real footgun is expecting magic: selecting fp8_e4m3fn_fast on an RTX 3090 doesn't make fp8 fast, because 30-series cards have no fp8 acceleration - you get the VRAM savings but not the speedup. On those cards you're usually better served by bfloat16 or an int8 scheme, which is where the pack's 🚀 Load & Quantize Diffusion Model node comes in.

The other thing to internalize: this is just a loader. If you came here looking for the speedup, you want the sibling nodes. This one just makes sure the model loads in the shape that lets them do their job.