Halo-TeaCache v1.0.0 (AMD LTX2)

If you run LTX-2 on an AMD APU, you know the pain already: a 19B diffusion transformer grinding out ~16 seconds per step on a 121-frame clip. TeaCache is the usual answer to that, except the standard implementation crashes on LTX-2 (LTXAV) models. Halo-TeaCache exists to fix exactly that. It's a lean, single-file TeaCache from the AMD community (author bkpaine1, the same person behind the well-circulated AMD Strix Halo AI guide) that patches LTX-2's transformer blocks surgically instead of wrapping the whole model. If you're generating audio-video on an AMD machine, this is the one you reach for. On discrete GPUs it works fine too, just with less of an edge.

What it actually does

LTX-2's transformer is a 48-layer dual-stream block, and here's the thing about denoising: consecutive steps are often working on nearly identical intermediate states. TeaCache exploits that. Before each denoising step it computes a modulated input from the video timestep embedding, then compares the L1 distance to the previous step's version. If the distance is under your threshold, it skips all 48 layers and reuses the cached residual. If not, it runs the full compute and caches the result.

Two details make this version interesting. First, the audio stream is cached alongside video - they're coupled through cross-attention, so you can't safely skip one and not the other, and this node handles both in one shot. Second, there's no cache_device toggle like other TeaCache implementations carry. On AMD unified memory, CPU and GPU share one address space, so the whole "where do I park the cache to avoid PCIe thrash" question disappears. The cache just stays on GPU, which is the whole point of the design.

That makes this a model-patching node, not a model. You wire your LTX-2 model in, a cloned, patched model comes out. No weights, no downloads, no extra Python dependencies - the whole thing runs on the standard library.

The inputs that matter

There are only three knobs, and honestly only one you'll touch.

• rel_l1_thresh (default 0.20) - the cache threshold. Higher means more aggressive skipping: faster, but softer output. Lower means you keep more quality. Zero disables caching entirely. The README's guidance holds up: blurry results → drop to 0.10–0.12; starving for speed → try 0.25–0.30.
• start_percent (default 0.15) - when caching kicks in. Early denoising steps set the structure of the whole clip, so you want full compute there. Keep this in the 0.10–0.20 range.
• end_percent (default 1.0) - when it stops. You'll rarely move this.

The single output is model (a MODEL), which wires straight into your CFGGuider/sampler - the README's instruction is to place the node before the sampler and pass the patched model through.

The honest speed numbers

The author's own benchmark, on a Strix Halo with LTX-2 19B fp8 at 121 frames/24fps: ~16.5s per uncached step, ~10.7s on cached steps, averaging out to ~14.0s/it. Total for 15 steps: 4:07 without, 3:29 with. That's a real ~15% wall-clock win - not a 2x, not a miracle. TeaCache on Wan works the same way: a moderate speedup with a minor quality cost that most people accept. If you're getting blurry faces or mushy motion, the threshold is the first thing to lower before you blame the node.

Install

cd ComfyUI/custom_nodes/
git clone https://github.com/bkpaine1/Halo-TeaCache.git
# restart ComfyUI

ComfyUI Manager can find it under the pack title "Halo-TeaCache" if you'd rather click. There are no extra dependencies and no model downloads - if it's showing up in your node menu as "Halo-TeaCache v1.0.0 (AMD LTX2)", you're done.

Gotchas

• Wrong model? The node checks the class name and expects LTXAVModel or LTXVModel - for LTX-2 or LTXv. Anything else prints a warning and proceeds anyway, which is your cue that output may be garbage. Don't feed it a Wan or Hunyuan model and expect sense.
• Blurry output is almost always the threshold, not the node. Drop rel_l1_thresh.
• Cache state resets at step 0, so you don't get the classic stale-cache-across-runs bug that plagues sloppier patch nodes - one less thing to chase.
• Modest on discrete GPUs. The unified-memory advantage is an AMD APU thing; on a standard dGPU it's just a normal TeaCache, and other implementations may serve you just as well.

One honest caveat: this pack is new and barely seen in the wild (zero impressions, tiny community footprint). The code is short enough to read in one sitting, which is reassuring for something this new. For AMD users who've had LTX-2 feel unusable, it's the difference between waiting out every clip and getting the same draft quality back in a few minutes.