Stable Diffusion Checkpoints, LoRAs and VAEs Explained (2026)

Download anything for Stable Diffusion and you hit the same wall: the file is called a checkpoint, or a LoRA, or a VAE, and nothing tells you which folder it goes in or why your image looks washed out without it. This guide explains what each file type actually is, how big each one is, where it goes, and why the file extension matters more than most tutorials admit.

Quick answer

• Checkpoint: the main model. Several gigabytes. Everything else is an add-on to it.
• LoRA: a small add-on that nudges the checkpoint toward a style, character or concept. Usually under 500MB.
• VAE: the component that turns the model’s internal representation into actual pixels. About 330MB standalone, and usually already inside the checkpoint.
• Always prefer .safetensors over .ckpt. This is a security choice, not a preference — see below.

The file types, by size

Sizes below are the real file sizes published on Hugging Face, checked 17 September 2026. They explain the hierarchy better than any description: the checkpoint dwarfs everything else.

Two things are worth noticing. A LoRA is roughly 3% the size of the checkpoint it modifies, which is the entire point of the format — you keep one big base model and swap small adapters. And on SD 3.5 the text encoder is larger than the model itself, which is why offloading the text encoder is the single most effective memory trick on that family. That same text encoder sets a hard ceiling on prompt length — see the 77-token limit and what the documentation actually says about prompts. Our image generation VRAM calculator shows what each offload mode saves.

Where each file goes

ComfyUI looks for models under ComfyUI/models/, in a folder per type. Its own documentation gives the layout:

ComfyUI/models/
├── checkpoints/   → the main model
├── loras/         → style and concept add-ons
├── vae/           → standalone VAEs
└── controlnet/    → pose, depth and edge guidance

Put a file in the wrong folder and it simply will not appear in the loader node — ComfyUI does not search other directories. If you want to keep models outside the install (to share them with another front end, or to keep them on a second drive), ComfyUI supports an extra_model_paths.yaml config file in its root directory for exactly that.

ComfyUI’s docs also note there is no uninstall button: removing a model means deleting the file from its folder yourself. New to all this? Start with our guide to running Stable Diffusion locally. Once it is running, Stable Diffusion inpainting shows these files working together in a real workflow, and our ComfyUI VRAM page covers what each model costs to load at every precision.

.safetensors vs .ckpt: a security decision

This is the part most guides skip, and it is the one with real consequences. A .ckpt file is a Python pickle, and Hugging Face’s own security documentation is blunt about what that means: “There are dangerous arbitrary code execution attacks that can be perpetrated when you load a pickle file.” Loading one runs code. It is not just data.

The safetensors format exists to fix that. Hugging Face describes it as “a new simple format for storing tensors safely (as opposed to pickle) and that is still fast (zero-copy)”. It stores weights and nothing executable.

The practical rule: download .safetensors when it is offered, which today is nearly always. Treat a .ckpt from an unknown uploader the way you would treat an unknown .exe.

Single file or a folder of files?

You will meet the same model in two shapes, and both are legitimate:

• Single-file format — the diffusers documentation describes it as storing “all the model (UNet, transformer, text encoder) weights in a single file”, and lists its benefits as “greater compatibility with ComfyUI or Automatic1111” and being easier to download and share. This is what you want for local image generation.
• Diffusers format — each component in its own subfolder. The documented advantages are faster initialisation, because components can be loaded in parallel or individually, and reduced memory use. This is the shape you want when writing Python.

A checkpoint you download for ComfyUI is the single-file kind. That is why one 6.94 GB file is enough to generate an image without downloading a VAE separately. Download size is the thing that bites when you load a built-in template: the median local one pulls 23.4 GB, as our ComfyUI templates breakdown sets out.

So when do you need a separate VAE?

Usually you don’t — the checkpoint normally carries one. The clue is in Stability’s own SDXL repository, which publishes two 6.94 GB checkpoint variants: sd_xl_base_1.0.safetensors and sd_xl_base_1.0_0.9vae.safetensors. Same model, different bundled VAE. If the VAE were a separate requirement, there would be no reason to ship two.

You add a standalone VAE when a model page tells you to, or when output looks washed out, oddly desaturated or blotchy — the classic symptom of a checkpoint with a broken or missing VAE. At 330MB it is a cheap fix to try.

LoRAs: small files, real limits

A LoRA is not a model. It is a set of low-rank adjustments applied on top of the checkpoint’s existing weights, which is why 186MB can meaningfully change a 6.94 GB model’s output. ComfyUI’s documentation groups LoRAs with ControlNets and inpainting models as “smaller helper models” that workflows add to the main checkpoint.

The consequence people trip on: a LoRA is tied to the architecture it was trained for. An SDXL LoRA does nothing useful on an SD 1.5 or Flux checkpoint — the layers it expects are not there. If you want to understand what is happening inside one, or train your own, see our LoRA training VRAM requirements guide.

Why your checkpoint won’t load

• Wrong folder. A checkpoint in loras/ will not appear in the checkpoint loader. This is the most common cause by a distance.
• Still downloading. A truncated multi-gigabyte file often fails with a confusing parse error rather than an obvious one.
• Architecture mismatch. An SDXL LoRA on an SD 1.5 checkpoint, or a Flux VAE on SDXL, will error or produce noise.
• Not enough memory. If it loads and then dies, that is a VRAM problem, not a file problem — see how to increase VRAM.

FAQ

What is a Stable Diffusion checkpoint?

The main model file that does the generating — typically 5–7 GB for SDXL or SD 3.5. Everything else (LoRAs, VAEs, ControlNets) modifies or supports it. ControlNets are the heaviest of those three, at 1.45 GB for SD 1.5 up to 6.6 GB for FLUX; we size them in our guide to ControlNet models.

Do I need a VAE file?

Usually not; most checkpoints include one. Add a standalone VAE if the model page says to, or if your images look washed out or discoloured.

Is .ckpt safe to download?

Treat it with caution. A .ckpt is a Python pickle, and Hugging Face documents that loading one can execute arbitrary code. Prefer .safetensors, which stores only the weights.

Why is a LoRA so much smaller than a checkpoint?

Because it stores small low-rank adjustments to the existing weights rather than a whole model. 186MB against 6.94 GB is a typical ratio. Flux LoRAs span a much wider range in practice, from about 21 MiB to 584 MiB depending on rank — see which Flux base model you can train on.

Can I use an SDXL LoRA with SD 1.5?

No. A LoRA only works on the architecture it was trained against, because it targets specific layers of that model. Every LoRA on Hugging Face declares which architecture that is in a base_model field, and our guide to using Stable Diffusion LoRAs covers checking it, setting strength and stacking two together.

Sources

• ComfyUI documentation: Models (folder layout, helper models, extra model paths)
• Hugging Face: Pickle scanning and Safetensors
• Diffusers: Model formats (single-file vs Diffusers layout)
• File sizes read from the Hugging Face API on 17 September 2026: SDXL base 1.0, SDXL VAE, SD 3.5 Medium

Updated 17 September 2026. File sizes are read from each model’s published files; nothing here is a benchmark.