LTX2 Efficient Sampler Pro 🚀

The regular LTX2EfficientSampler keeps your GPU cool by freezing attention and throttling. This one, LTX2EfficientSamplerPro, goes after a different and arguably more important bottleneck: the feed-forward network. In LTX-2, the FFN expands the hidden dimension 4x - roughly 4096 tokens to 16384 - and that intermediate tensor is where peak VRAM actually lives. The Pro sampler chunks that computation, cutting the memory hit per layer by up to ~8x at the cost of some speed. It's the same pack, same idea, one more lever, and honestly the lever most low-VRAM users actually need.

What's different from the regular sampler

Same core inputs: model, latent_video, positive, negative, seed, steps, cfg, sampler_name, denoise, the optimization_preset list, target_temp, freeze_ratio, thermal_throttle, and context_slice_method. What it drops: frame_stride, attention_window, and the optimization_engine selector - the Pro keeps things simpler. What it adds:

• ffn_chunks - the headline feature, default 8. This splits each FFN's sequence dimension into N chunks and runs them sequentially, so the big 16384-wide intermediate never exists at full size. Higher = less VRAM but slower; 1 disables chunking entirely. On the author's own bug log the machine is an RTX 2060 6GB, so this is tuned for that kind of territory.
• CFGGuider-based sampling - the Pro uses ComfyUI's CFGGuider path, the same one SamplerCustomAdvanced uses. That matters because it properly handles LTX-2's combined audio-video NestedTensor latents, which the plain path trips over. If you're feeding it audio-video latents from LTXVConcatAVLatent, this is the sampler variant that's built for them.
• The same model patching for attention_mask and context slicing (7680 → 4096) that the pack's standalone LTX2ModelPatcher provides, built in.

The FFN chunking itself is credited in the source to ox1111's comfyui_ltx-2_vram_memory_management project - a known technique for LTX-2 specifically - so this isn't a made-up knob; it's a real memory-management trick wrapped in a sampler.

Wiring it up

[UnetLoaderGGUF / UNETLoader] --MODEL--> [LTX2EfficientSamplerPro] --LATENT--> [LTX2TemporalVAEDecode] --IMAGE--> [SaveVideo]
[DualCLIPLoader]               --positive/negative-->/

It outputs a plain LATENT, so it drops into the same graph as the non-Pro sampler. If your latent comes from a combined audio-video source, route it through LTX2SeparateAVLatent first to pull the video half out (or just feed the Pro the combined latent - it's the one that handles it natively).

Installation

The pack installs once and all ten nodes come with it: ComfyUI Manager, search "LTX2 Efficient", or manually:

cd ComfyUI/custom_nodes/
git clone https://github.com/kakachiex2/comfyui-ltx2-efficient
cd comfyui-ltx2-efficient
pip install -r requirements.txt

Then restart. requirements.txt is just pynvml (optional). No model files - you bring your own LTX-2 checkpoint, text encoder, and VAE via ComfyUI-LTXVideo. And note the README's manual clone URL has a typo pointing at a differently-named repo; the command above is the correct one.

Troubleshooting

• Slower than the regular sampler - that's expected and the point: ffn_chunks trades speed for VRAM. If you have headroom, lower it to 4 or 2.
• Still OOM - raise ffn_chunks to 12-16 rather than dropping resolution, then fall back to a leaner optimization_preset if needed.
• Audio-video decode breaks downstream - make sure you're recombining with LTX2CombineAVLatent before hitting a LTXVDecodeAV-style node, or the audio half of the latent is gone.

Is the 🚀 earned? Sort of. It's the same freezing-and-throttling as the base sampler, but the FFN chunking is a real addition that the base node lacks, and the CFGGuider path fixes a genuine audio-video pain point. For anyone on 8GB or less, I'd reach for this one over the plain sampler.