🏰 Load LDM Checkpoint

Ever wanted to run the actual thing Stable Diffusion was built from? Not SD1.5, not a recreation of it - the original 2021 CompVis Latent Diffusion F8 Large text-to-image checkpoint, the txt2img-f8-large model from the Rombach et al. paper whose architecture later became Stable Diffusion. That's what this loader is for. It's the front door to the whole comfyui_compvis_ldm pack, and every other LDM node hangs off what it emits.

Normal checkpoint loaders lean on a .yaml config to know what architecture they're dealing with, and that's where old LDM files usually fall over. This one does it differently: the entire architecture is hard-coded in the pack's Python, so the node takes a bare weights file and rebuilds the model around it. No yaml, no ancient CompVis codebase, no diffusers dependency. Drop a file in, pick it from the dropdown, done.

What it actually loads

The checkpoint is split by key prefix, and three components come out the other side as MODEL, BERT, and VAE:

• MODEL - the UNet (320-channel base with spatial transformers doing cross-attention over the text).
• BERT - the text encoder. This is the big historical difference from SD: a 64-layer BERT transformer with 1280-dim hidden states, not CLIP. SD swapped in CLIP later; this model still runs its own original encoder.
• VAE - the f8 autoencoder. Notable bit: the pack doesn't re-implement it. It instantiates ComfyUI core's own AutoencoderKL, the same class that handles SD1.x's VAE - because this f8 VAE lineage is the ancestor of the SD VAE.

The loader also silently discards model_ema.* weights (training-time weights you don't want at inference), and keeps the noise schedule tensors in fp32 no matter what precision you pick, because the schedule is more stable that way.

The two settings that matter

precision picks the compute dtype: fp32 (default, most stable, ~6 GB), fp16 (half the VRAM and faster on modern GPUs, ~3 GB), or bf16 (best of both for numerical range, but it needs an Ampere+ card - RTX 30xx or newer - and falls back to fp16 with a console warning if your GPU can't do it).

memory_mode decides how aggressively the three components share VRAM. keep loads everything and holds it (fastest, fattest). auto (default) keeps things resident while there's room and offloads to CPU when you're tight. offload moves each component back to CPU after its stage. cpu runs the whole thing without touching the GPU - slow, but it means even a laptop with no VRAM to speak of can produce a 256×256 image eventually.

Start with fp16 + auto. That's the combo that just works on an 8 GB card.

Where the model file lives

Checkpoints go in a dedicated folder, ComfyUI/models/ldm, which the pack creates automatically the first time it loads. Drop the file there and restart ComfyUI so the dropdown refreshes.

Grab one from the HuggingFace repo:

latent-diffusion-f8-large-fp32.safetensors          # ~6 GB, original precision
latent-diffusion-f8-large-fp16.safetensors          # ~3 GB
latent-diffusion-f8-large-bf16.safetensors          # ~3 GB
latent-diffusion-f8-large-jack000-finetuned-fp16.safetensors   # finetune aimed at better composition

The jack000 finetune is the one worth trying once you've seen the base model's wonky compositions - jack000 is a long-time figure in this corner of the scene, and the finetune exists to tighten structure.

Installing the pack

Through ComfyUI Manager, search for comfyui_compvis_ldm (or "CompVis F8 Large") and install. Or the manual route:

cd ComfyUI/custom_nodes
git clone https://github.com/Winlensky/comfyui_compvis_ldm
cd comfyui_compvis_ldm
pip install -r requirements.txt   # almost certainly already installed

Then restart ComfyUI. The requirements - torch, safetensors, transformers, tqdm - are all things a standard ComfyUI install already ships.

Where people get burned

The three outputs use the pack's own custom types (LDM_MODEL, LDM_BERT, LDM_VAE), and nothing outside this pack understands them. You can't feed MODEL into a stock KSampler - this whole pipeline is self-contained, and the moment you try to mix, the sockets won't connect. That's by design; the architecture is too different (BERT conditioning, no CFG machinery) to bolt onto the standard ComfyUI model objects.

Also worth knowing before you judge the output: this model was trained without classifier-free guidance, so there is no negative prompt and no CFG scale anywhere in this pack. Prompt adherence is looser than anything you're used to from SD1.5 onward. That's not a bug in the loader - it's a 2021 model behaving like one.