Download LTX-2 Model: Hugging Face Files, Sizes & Folder Structure

The first time I went hunting for an LTX-2 download, it wasn’t a grand plan. I just wanted to run a small batch through ComfyUI and kept tripping over the same two frictions: slow downloads that stalled at 92%, and a cryptic “Model not found” message once I finally had the files. Not dramatic. Just the kind of repeated snag that nudges you to stop and tidy the workflow.

I spent a few evenings in early January 2026 testing different sources, formats (NVFP4 vs NVFP8), and folder layouts on a 24GB GPU box. Nothing flashy, just enough runs to see what was solid versus fragile. Here’s the path that reduced the mess for me, with notes you can skim and borrow from.

Official LTX-2 Download Sources (Hugging Face Model Card)

I don’t chase mirrors. If a model matters to my workflow, I want the trail to be boring and reliable. For LTX-2, that means starting at the official Hugging Face model card.

What I look for before I click download:

Publisher: Is it the verified organization or author tied to LTX-2? I check the org badge and that other repos in the namespace look alive and consistent.
License & terms: Some LTX-2 variants are gated or have usage limits. If accepting terms requires a token, I’d rather do it once than debug auth errors later.
Artifacts list: I skim for the main model, any encoders, and a distilled or quantized variant. Clear filenames beat clever ones.
Instructions: If the card links to ComfyUI or node-specific docs, I follow those first. One line about expected folders can save half an hour of guessing.

Practical tip: use the Hugging Face CLI with credentials set. A gated repo won’t pull over raw git-lfs without a token, and that’s the fastest way to end up with partial files and no error until you try to load them.

pip install huggingface_hub git-lfs
huggingface-cli login  # paste your token

I know, obvious. But the number of times I’ve seen a silent 403 turn into “model not found” downstream is… non-zero.

File List & Sizes (main model / encoder / distilled)

I don’t memorize file sizes. I just need a ballpark to plan disk and decide which variant to grab first. Here’s what I’ve actually seen across recent LTX-2 drops. Your repo may differ, always trust the model card over my notes.

Typical artifacts you’ll see:

Main model checkpoint (often .safetensors or a runtime-specific format): ~2.5–6.0 GB. Larger if it includes extra heads or multi-precision; smaller if it’s quantized.
Text/image encoder (CLIP or similar): ~400 MB–1.5 GB. Some builds bundle this; others ship it as a separate file.
VAE or latent adapter (if applicable): ~100–500 MB.
Distilled variant: ~1–3 GB. Faster and lighter, sometimes with slightly softer outputs. Good for prototyping.
Quantized variants (NVFP8/NVFP4): size varies, but expect 30–60% less disk than full precision.

Naming patterns I watch for:

ltx-2.safetensors (main)
ltx-2-encoder.safetensors or open_clip-vit-… (encoder)
ltx-2-vae.safetensors (if separate)
ltx-2-distilled-… (smaller, faster)
ltx-2-nvfp8 / ltx-2-nvfp4 (format-specific)

If disk is tight, I grab the distilled first, validate my pipeline, then pull the full model. It’s not just about speed: cutting down the first run’s cognitive load helps me test prompts and nodes without fighting VRAM immediately.

ComfyUI Folder Structure for LTX-2 (Exact Paths)

This is where I tripped on day one: my files were fine, but ComfyUI didn’t know where to look. Different custom nodes expect slightly different locations, but the defaults below have been safe for me.

On a standard ComfyUI install (no custom node overrides):

Main model checkpoint: ComfyUI/models/checkpoints/LTX-2.safetensors
Text/image encoder (CLIP or similar): ComfyUI/models/clip/LTX-2-encoder.safetensors
- Some builds use open_clip naming: place those in models/clip/ too.
VAE (if separate): ComfyUI/models/vae/LTX-2-vae.safetensors
LoRA/patches (if you use them): ComfyUI/models/loras/

If you’re using nodes that rely on TensorRT or engine files:

ComfyUI/models/trt/ltx-2/*.engine
ComfyUI/models/unet/ltx-2/*.engine

Two boring but useful habits:

Match filenames exactly to what your node expects. I keep names short and remove spaces.
After moving files, use ComfyUI’s model refresh or restart. Hot reload works sometimes: a full restart is more consistent.

If you use an external disk or a shared models folder, set ComfyUI’s Extra Model Paths so it doesn’t quietly scan the wrong drive. Case sensitivity on Linux has bitten me more than once.

NVFP4 vs NVFP8 Weights: Which to Download

I was curious whether NVFP4 was worth the extra compression. Short answer: maybe, if you’re squeezed on VRAM and your nodes actually support it.

Here’s how it felt in practice on my box (Hopper-class GPU, January 2026 builds):

NVFP8

Balance: Good middle ground. Noticeably lower memory than full precision with minimal output drift.
Compatibility: Better. More nodes and runtimes accept FP8 than FP4 right now.
When I pick it: Everyday runs where I want stability over the smallest footprint.

NVFP4

Footprint: Smaller. It let me bump resolution or context a notch where FP8 wouldn’t.
Drift: Slightly more artifacts or softness on edge cases. Not always, but just enough that I notice.
Compatibility: Pickier. Some loaders fall back or fail if they don’t detect the right kernels.
When I pick it: Quick drafts, grid searches, or when the workflow is strictly supported by the node’s FP4 path.

One more thing: these formats usually assume you’re on an NVIDIA stack that can accelerate them properly. If your node doesn’t explicitly say “NVFP4/NVFP8 supported,” I default to the full precision or a distilled .safetensors build. Chasing marginal gains isn’t worth the mysterious crash mid-render.

LTX-2 Download Acceleration & Checksum Verification Tips

I treat big model pulls like any other large file job: speed it up, then verify.

Acceleration that actually helped:

Hugging Face transfer acceleration: set env var HF_HUB_ENABLE_HF_TRANSFER=1 before using huggingface_hub. This turns on their accelerated backend where available.

aria2c for parallel chunks:

aria2c -x 16 -s 16 -k 1M -c

The -c flag resumes partial downloads cleanly when my connection hiccups at 97%.

git-lfs tuned pulls

git lfs install then git clone.
Following the Git LFS installation guide, if it’s a huge repo, I sometimes use sparse-checkout to avoid pulling examples I won’t use.

Verification I actually do (and don’t skip anymore)

Compare SHA256 from the model card (or the repo’s .sha256 files) against your local file.

macOS/Linux: shasum -a 256
Windows: certutil -hashfile SHA256

File size sanity check

If the expected size is 4.2 GB and I see 3.3 GB, I stop there. Partial files occasionally “load,” then throw garbage errors later.

Small habit that saves time: I keep a tiny README.txt next to the model files with the origin URL, date, and hash. When I revisit three months later, I don’t have to reverse-engineer my past self’s choices.

”Model Not Found” Fixes

This error ate an hour I won’t get back. Here are the fixes that actually moved the needle for me:

Wrong folder: ComfyUI expects checkpoints in models/checkpoints/, encoders in models/clip/, and VAEs in models/vae/. Put them anywhere else and the scanner may ignore them.
Filename mismatch: Some nodes look for a specific basename. If the node says ltx-2.safetensors, don’t call it LTX-2 (final).safetensors. I rename aggressively.
Case sensitivity: ltx-2.safetensors ≠ LTX-2.safetensors on Linux. Ask me how I know.
Cache indexing: Refresh models or restart ComfyUI after moving files. The index isn’t always real-time.
Missing dependency: If the node expects an external encoder and you only downloaded the main model, you’ll get a vague error. Pull the encoder listed on the model card and try again.
Gated model without token: If you cloned without logging in (or your token expired), local files can be stubs. Re-login with huggingface-cli login and re-pull.
Custom nodes and alternate paths: Some nodes override default folders. Check their README for expected paths or env vars. When in doubt, drop a symbolic link from your shared models dir to the expected local path.

When I’m stuck, I temporarily point the node to a known-good, tiny model just to confirm the loader works. If the small one loads, the bug lives in the LTX-2 files, not my environment.

Skip LTX-2 Downloads Using WaveSpeed

I tried a different route on a travel laptop: skip local downloads entirely and run LTX-2 through WaveSpeed. It streams or hosts the weights remotely so you can wire up a ComfyUI-like graph without parking 10+ GB on your disk. What worked for me:

Onboarding was light. I pointed the graph to their LTX-2 endpoint and didn’t touch local folders.
Cold starts were slower (first run spins up a session), but warm runs felt normal for small batches.
It kept my laptop fan from howling. That alone made it useful on the road.

Trade-offs I noticed:

Latency: There’s a small overhead, more obvious with lots of short runs. For long renders, I stopped noticing.
Control: You give up some version pinning. They keep models patched, which is nice, until you want to reproduce an older result.
Cost/quotas: It’s not “free like a download.” If you’re on a tight budget or need heavy batch work, local still wins.
Privacy: I keep sensitive prompts and assets local. For public or test work, I’m fine.

Who might like this: folks testing LTX-2 on underpowered machines, or anyone who wants to sketch a workflow before committing to a full local setup. If you’re VRAM-rich and care about exact reproducibility, local installs still feel better.

I didn’t expect to like it, but for quick experiments, skipping the download was a small relief.