Skip to main content
by artokun · June 16, 2026 · ltx · video · ComfyUI · model highlight Most open video models make you pick two of three: fast, local, or good. LTX-2.3 is the one that gets uncomfortably close to all three — a 22B diffusion transformer that generates synchronized video and audio, ships as a low-VRAM GGUF UNet, and runs entirely locally in ComfyUI with no API key and no per-second cloud bill. This is the video entry in our model-highlight series, and the case for it is simple: it is one of the fastest genuinely-open audio-video models you can self-host today, and the new LTX Director timeline editor turns a single prompt box into something that feels like an actual NLE. Below: what LTX-2.3 actually is (and the version-naming mess), the timeline editor, the GGUF VRAM tiers, how it stacks up against WAN 2.2, the fastest way to install it, and the one import bug everyone hits.
TL;DR — one-command setup. Install comfyui-mcp, apply a ready-to-render ltx-2.3-txt2vid / ltx-2.3-img2vid pack (run the generated install-windows.bat / install-runpod.sh, or apply_manifest --path packs/ltx-2.3-txt2vid/manifest.yaml), then drive the graph from your own Claude session via the Panel. Jump to Install.
Update (June 19, 2026) — the render-verified sharp setup. After actually render-proving these packs end-to-end, we replaced our original GGUF-UNet build with the official Comfy-Org LTX-2.3 two-stage template, because the older path produced soft, mushy video with subtly-wrong faces. If your LTX output looks blurry, this section is why. The setup that renders sharp (1280×704, synced 48 kHz stereo audio, all-core ComfyUI nodes):
  • LTXAVTextEncoderLoader (core comfy_extras) loads gemma plus the full checkpoint together — this is the audio-video encoder that drives both video and the voice track. Do not use DualCLIPLoader(type=ltxv) + a separate text-projection file; that legacy path is what yields mush.
  • Gemma gemma_3_12B_it_fp8_scaled (unpacked) — the fp4_mixed file from community mirrors is both truncated and a packed-fp4 layout the loader can’t reshape (shape [15360,1920] invalid for input 27582328).
  • A gemma abliterated LoRA (gemma-3-12b-it-abliterated_lora_rank64_bf16, strength 1.0) on the text-encoder CLIP — this is the prompt-accuracy / correct-eyes fix. Missing it is the difference between “close” and “right.”
  • The newer dynamic distilled LoRA (ltx_2.3_22b_distilled_1.1_lora_dynamic_fro09_avg_rank_111_bf16, 0.5), not the old …-384-1.1.
  • Two-stage spatial upscale (LTXVLatentUpsampler) — generate small, ×2 upscale + refine. The upscale is the sharpness; a single-stage graph is visibly softer.
  • imageio-ffmpeg in the ComfyUI venv — CreateVideo/SaveVideo fail with “ffmpeg could not be found” without it.
The model files now go in models/checkpoints/ (the full 46 GB ltx-2.3-22b-dev or the ~23 GB fp8 build), not models/unet/. The render-proven specifics live in the ltxv2-video skill.

​
What is LTX-2.3?

LTX-2.3 is a DiT-based video foundation model from Lightricks that does text-to-video (T2V) and image-to-video (I2V), and — uniquely among the fast open models — generates matching audio in the same pass. A few details that matter for running it locally:
  • ~22B parameters, distributed as a GGUF UNet quant of the ltx-2.3-22b-dev model, loaded with UnetLoaderGGUF (from the ComfyUI-GGUF node) rather than the usual CheckpointLoaderSimple.
  • Separate video and audio VAEs (LTX23_video_vae_bf16 and LTX23_audio_vae_bf16). Because the UNet is a bare GGUF, the VAE no longer comes “for free” with a checkpoint — you load it explicitly with VAELoader.
  • A Gemma 3 12B text encoder (gemma_3_12B_it_fp8_scaled), loaded via the core LTXAVTextEncoderLoader node — which bundles the gemma text encoder with LTX-2.3’s audio/text projection, so there’s no separate CLIPLoader or standalone text_projection file to wire.
  • A distilled fast path: apply the distilled LoRA (ltx-2.3-22b-distilled-lora-384-1.1) to the dev UNet for 8-step generation, or run the dev model straight at ~20 steps for higher quality.
  • An x2 spatial latent upscaler (ltx-2.3-spatial-upscaler-x2-1.1) for a two-stage “generate small, upscale in latent space” pipeline, plus an IC-LoRA detailer for refinement.
Open weight, attribute carefully. LTX-2 was released under Apache 2.0, which is genuinely permissive — a real contrast to most “open” video models. LTX-2.3’s exact license and the canonical repo you should pull from (huggingface.co/Lightricks) are worth confirming before commercial use; some community write-ups treat 2.3’s terms as identical to LTX-2’s, which we have not independently verified. Flagging it so you check rather than assume.

​
A quick word on the name (it is not “LTX 3.2”)

You will see this model called “LTX 3.2,” “LTXV2.3,” and a dozen other scrambles. There is no LTX 3.2. The correct name is LTX-2.3 — a point release in the LTX-2 family. The lineage:
  • LTX-Video (2024) — Lightricks’ first open text-to-video model.
  • LTX-2 / LTX-V2 (early 2026) — the ~19B-class DiT audio-video foundation model: the first production-ready open-weight model to generate synchronized audio and video in one pass, up to native 4K @ 50fps and ~20s clips, Apache 2.0.
  • LTX-2.3 (~March 2026) — a ~22B DiT update with a rebuilt VAE (sharper textures, faces, hair, and on-screen text), a much larger text-projection connector for better prompt adherence, improved 9:16 portrait, cleaner synchronized audio, and LoRA support. The big distribution change: 2.3 ships primarily as GGUF UNets plus separate VAE / text-encoder / text-projection files — not one bundled checkpoint.
When someone says “LTX 3.2” or “LTX2.3,” they mean LTX-2.3. We’ll use the correct name throughout.

​
LTX-2.3 vs WAN 2.2

The other open-video model everyone benchmarks against is WAN 2.2. The short version: LTX-2.3’s pitch is throughput and the audio track; WAN 2.2’s is raw quality from its two-expert design. WAN 2.2 gets its own deep-dive on how the high/low-noise experts actually work — see the WAN 2.2 post. For now: if you want fast local clips with sound, LTX-2.3; if you want to push motion quality and don’t mind the cost, WAN 2.2.

​
VRAM and GGUF tiers

The whole point of the GGUF distribution is fitting LTX-2.3’s 22B UNet on consumer cards. Pick the quant that matches your GPU: Keep only the quant you’ll use — the pack lists all three so it’s self-contained, but you don’t need to download every one. The separate VAEs and the FP4 Gemma encoder add a few more GB on top. Plan for 8 GB as a realistic floor (Q4_K_S, small resolution, short clips) and 24 GB for comfortable Q8_0 work with the two-stage upscale.

​
Install LTX-2.3 in ComfyUI

The manual route works: update ComfyUI, install the custom nodes (ComfyUI-GGUF, ComfyUI-LTXVideo, KJNodes, RES4LYF, VideoHelperSuite, and friends), and download each model into the right folder: (Official weights live in the Lightricks HF org; the pack’s installer pulls matching files from a third-party mirror — verify against the official repo if licensing matters to you.)

​
The fast way — comfyui-mcp + the Panel

Cloning a dozen custom nodes and downloading the right GGUF quant plus two VAEs to the right folders is exactly the busywork the comfyui-mcp ltx-2.3 pack removes. One declarative manifest installs the nodes and pulls every model to the correct folder — and the same manifest drives both an MCP-native install and the generated double-click scripts:
Both packs ship a render-verified workflow.json built on the official two-stage template, so there’s nothing to import — load it and generate. The installer clones each custom node and resolves its requirements.txt into the ComfyUI venv (the fix that ended a long tail of “node installed but doesn’t load” failures — details). Because the pack ships with the plugin, your own Claude session can drive the live graph through the Panel — tweak prompts, swap the first-frame image, flip T2V↔I2V, and iterate conversationally with full undo and no extra API keys. Every model URL is CI-validated for reachability and size, so a link never quietly rots.

​
The LTX Director timeline editor

The headline community add-on for LTX-2.3 is LTX Director — a custom node by WhatDreamsCost that drops a real timeline editor inside ComfyUI. Instead of one prompt and one clip, you compose a sequence on a timeline and let the model relay between segments. What it gives you:
  • A functional timeline where you place image, text, and audio segments, then trim, cut, rearrange, and combine them — closer to an indie NLE than a node graph.
  • Prompt Relay — change the prompt across the video, so different stretches of the same clip can describe different action, framing, or mood (granular, per-segment control rather than one global prompt).
  • Multiple keyframes — any number of them, including the classic first / middle / last frame workflows, which is the easiest way to pin a shot’s start and end.
  • Custom audio — import, trim, and combine your own audio clips, instead of relying only on the model’s generated track.
  • Built-in T2V and I2V, with image resize handled for you.
A couple of honest caveats: LTX Director is a third-party node (built fast — its author shipped it in about six days in May 2026), and it needs up-to-date ComfyUI-LTXVideo and ComfyUI-KJNodes to work. Both are installed by the ltx-2.3 pack. It’s framed as Wan- and LTX-compatible, but it’s purpose-built for LTX-2.3 — treat anything beyond that as “try it and see.”

​
Alternate and GGUF base models (including “sulphur”)

Because the UNet is just a GGUF, you can swap in any LTX-2.3-compatible base model by pointing UnetLoaderGGUF at a different file and keeping the rest of the 2.3 graph identical (same 2.3 VAE, Gemma 3 encoder, and text projection). The most-asked-about alternate is the community Sulphur 2 finetune — an uncensored, realism-leaning derivative of LTX-2.3 (22B), marketed as a drop-in replacement inside existing 2.3 graphs. Compatibility caveats worth knowing:
  • It is a finetune, not a new architecture, and it targets the LTX-2.3 stack specifically. It is not LTX-2 (19B) compatible — mixing a 2.3 UNet with a 2.0 VAE/encoder produces garbage.
  • The real base files are sulphur_dev_bf16 (~46 GB) and sulphur_dev_fp8mixed (~29 GB); GGUF quants are published separately (e.g. sulphur_dev-QUANT.gguf). There is no file literally named “sulphur2Base_dev.safetensors” — that’s shorthand.
  • It’s a third-party derivative with its own hosting and license. Verify the repo and terms yourself before downloading; we’re noting it exists, not endorsing a specific mirror.
General rule for any alternate LTX base: confirm the version it was trained on (2.3 22B vs 2.0 19B), keep the matching VAE + text encoder + text projection, and if you only have a LoRA, apply it with LoraLoaderModelOnly instead of swapping the whole UNet.

​
What to make with it

  • Text-to-video with sound — cinematic clips where the matching audio is generated in the same pass, no separate scoring step.
  • Image-to-video — bring a single still to life, with image resize handled by the LTX Director nodes.
  • Multi-segment sequences — compose a timeline, relay the prompt across the clip, and pin first/middle/last keyframes for a directed shot.
  • Fast 8-step drafts — iterate on concepts with the distilled LoRA, then re-render the keepers on the ~20-step dev path with a two-stage latent upscale.

​
Settings that matter

LTX-2.3 uses LTX-specific nodes (LTXVConditioning, EmptyLTXVLatentVideo, LTXVScheduler, SamplerCustomAdvanced) rather than a plain KSampler. Two profiles: Other constraints to respect:
  • Frame count must be 8n + 1 — 49, 81, 97, 121, 161… (121 is the recommended default at 25fps ≈ 5s).
  • Resolution in multiples of 32 — start small (e.g. 768×512), then x2 latent upscale to 1536×1024 in a second stage.
  • Frame rate is conditioned via LTXVConditioning (25fps standard; 24/30 also fine).
  • OOM mitigation: launch ComfyUI with --reserve-vram 10 --cache-none (these are the pack’s default launch_args). On low-VRAM cards, also drop to a smaller quant, reduce frame count, and use a tiled VAE decode (LTXVSpatioTemporalTiledVAEDecode).

​
Troubleshooting

  • ComfyUI-LTXVideo fails to import — kornia pad ImportError. This is the bug everyone hits. kornia 0.8.3+ stopped exporting pad from kornia.geometry.transform.pyramid, so the node won’t load. The pack ships the fix: run fix-ltxvideo-kornia.bat (or .sh) from your ComfyUI_windows_portable folder. It patches custom_nodes/ComfyUI-LTXVideo/pyramid_blending.py — removes the broken pad, import, inserts pad = F.pad as a shim, and writes a .bak_kornia_fix backup first. It’s idempotent, so re-running is safe.
  • Torch / CUDA mismatch or a node upgrades torch. The RunPod installer pins a known-good stack (torch 2.4.0 / cu121, torchvision 0.19.0, torchaudio 2.4.0, xformers 0.0.27.post2) and pins ComfyUI-LTXVideo to a specific commit for workflow compatibility. If a node’s requirements.txt quietly upgrades torch and breaks CUDA, reinstall the pinned stack; don’t let nodes bump torch.
  • OOM on 24 GB. Use the --reserve-vram 10 --cache-none launch args, a smaller GGUF quant, fewer frames (81 or 49), and a tiled VAE decode. Always clear VRAM before switching to LTX from another model family.
  • CreateVideo/SaveVideo fails: “ffmpeg … could not be found.” The video mux needs an ffmpeg. Install it into the ComfyUI venv: <comfy-venv>/python -m pip install imageio-ffmpeg, then restart.
  • Output is soft/blurry and faces/eyes look subtly off. You’re on the single-stage or legacy text-encoder path. Use the two-stage template with LTXAVTextEncoderLoader, the gemma abliterated LoRA, and the dynamic distilled LoRA (see the June 19 update above). The two-stage ×2 upscale is the sharpness; the abliterated LoRA fixes accuracy.
  • **graph "succeeds" but writes no video / only a math or text node in outputs.** An output node silently failed validation and got dropped. Check the ComfyUI log for Failed to validate prompt for output N` — usual causes: missing ffmpeg, a model file not in the loader’s list, or a broken connection. (On the MCP side, the converter’s de-virtualization + subgraph-edge fixes removed the common “dangling-link” causes of this.)
  • No audio in the output. With the two-stage template the audio path is built in (the checkpoint carries the audio VAE). On a hand-built GGUF graph you must load the audio VAE (LTX23_audio_vae_bf16) separately.
  • Same seed, different result across machines. Expected — output varies with GPU, driver, CUDA, and ComfyUI version.

​
FAQ

Is it “LTX 3.2”? No. There is no LTX 3.2. The model is LTX-2.3, a point release of the LTX-2 family. Can I run it locally / offline? Yes — fully local in ComfyUI, no API key and no network call at generation time. How much VRAM do I need? ~8 GB floor with the Q4_K_S GGUF at small resolutions; Q5_K_S for 12–16 GB, Q8_0 for 24 GB+. Does it generate audio? Yes — synchronized audio and video in one pass, via a separate audio VAE you load alongside the video VAE. Dev vs distilled — which do I use? Distilled (8 steps, cfg 1.0) for fast drafts; dev (~20 steps, cfg 3) for final quality. What is LTX Director? A community timeline-editor node (by WhatDreamsCost) that adds keyframes, prompt relay across the clip, custom audio, and built-in T2V/I2V to LTX-2.3 inside ComfyUI. Is it really open / free? LTX-2 shipped under Apache 2.0. LTX-2.3’s exact terms are worth confirming on the official Lightricks repo before commercial use — and the “sulphur” finetune is a separate third-party project with its own license.

​
Get it running in one command

  1. Install comfyui-mcp and the Panel — the panel auto-starts a background agent on your Claude subscription (no API keys; sign in with claude once).
  2. Apply the ltx-2.3 pack — GGUF UNet, both VAEs, the Gemma encoder, text projection, upscaler, and LoRAs land in the right folders, validated.
  3. Run the bundled kornia fix, restart, then open the Panel and let the panel’s agent wire the GGUF graph and build prompts for you.
That’s the whole point of the project: expert ComfyUI setups that install in one step and drive themselves from your own agent session. Next in the series: Ideogram 4 — the open-weight text-and-layout king, and the finale of the model-highlight run.