Load Sana Diffusion Model

Sana is NVIDIA's answer to "what if a diffusion transformer didn't need a heavyweight GPU to be fast." This node is the front door: point it at a downloaded Sana checkpoint and pick the size and precision, and you get a model ready to feed the rest of this pack's Sana-specific nodes (skip-block caching, the Sana VAE, the Gemma text loader). It's a small, unglamorous loader node, but it's the one every Sana workflow in this pack starts from.

What it is and why you'd reach for it

When Sana first showed up, the reaction on ComfyUI-adjacent communities was closer to disbelief than the usual "new model dropped" shrug - one early tester's reaction was that the speed "reminds me of the sd1.5 days," a genuine callback to when generation felt instant compared to the multi-second waits people had gotten used to with larger models. That reputation is the whole reason this node and its siblings exist in this pack: shenduldh added Sana support specifically to chase the same "get your 1024x1024 images within 2s" goal the README states outright, using the same caching and skip-block machinery already built for Flux.

How it works

The node reads a Sana diffusion checkpoint (a .pth file, not the .safetensors format Flux uses) off disk, matches it against the architecture size you specify, and optionally casts its weights to a target precision on load. Nothing fancy beyond that - it's a loader, not a patcher.

The inputs and outputs that matter

• model_name - a dropdown populated from whatever .pth files you've placed in models/diffusion_models. Empty until you've downloaded one.
• model_type - either SanaMS_1600M_P1_D20 or SanaMS_600M_P1_D28, the two published Sana architecture sizes. This has to match whichever checkpoint you actually downloaded, or loading will fail or produce garbage - check the filename against NVIDIA's Model Zoo page before picking.
• weight_dtype - default, fp32, fp16, bf16, fp8_e4m3fn, fp8_e4m3fn_fast, or fp8_e5m2. This is Sana's quantization dial: fp8 halves VRAM at close to no visible quality cost on most models, which is the community's general-purpose recommendation for large diffusion models - worth trying first if you're VRAM constrained, since Sana is already small enough that this may not even be necessary.
• convert_model_dtype (boolean, default true) - whether to actively cast the checkpoint's weights to your chosen weight_dtype at load time, versus loading them as stored. Leave it on unless you have a specific reason to keep the checkpoint's native precision untouched.

Output is a MODEL - feed it straight into the pack's Sana caching node or your sampler.

How to install it

• ComfyUI Manager - search "ComfyUI-Lightning", install, restart.
• Manual - cd ComfyUI/custom_nodes && git clone https://github.com/shenduldh/ComfyUI-Lightning, then restart.

Then the actual work: download a Sana diffusion checkpoint from the Model Zoo and put the .pth file into models/diffusion_models. You'll also need the matching Gemma text encoder and DCAE VAE (their own loader nodes, and their own downloads) for a complete Sana pipeline - this node alone only gets you the diffusion model.

Common issues & troubleshooting

model_name dropdown is empty. You haven't put a .pth file in models/diffusion_models yet, or ComfyUI hasn't rescanned since you added one - restart or refresh the node list after copying the file in.

Loading errors or the model behaves strangely. Mismatched model_type against your actual checkpoint is the most likely cause - confirm which of the two Sana sizes you downloaded and select the matching option exactly.

fp8 gives visibly worse output than expected. Sana is already a small model (600M or 1.6B parameters, tiny by current standards), so it has less headroom for aggressive quantization to hide inside than a 12B-parameter model like Flux does. If quality matters more than the VRAM savings and you have room, try bf16 or fp16 instead - the whole appeal of Sana is that it doesn't need aggressive quantization to run comfortably in the first place.