LTXV Block Loop Patcher

The name is the whole pitch. Every LTX denoise step already walks the entire transformer block stack once. The LTX Block Loop Patcher makes a slice of that stack run again - an echo pass through just the blocks you pick - so you buy more compute exactly where your footage falls apart, without paying for a whole extra step.

Why you'd care: LTX-2.3 is stupidly fast, but its known weak spot is fast motion smudging. The community's usual fixes are more steps or a Wan V2V cleanup pass. More steps cost a full trip through all ~48 blocks. This node spends your compute only in the middle of the model - which is where structure gets refined. The author's framing is honest: early blocks handle rough structure, middle blocks refined structure, high blocks fine detail. Loop the middle, leave the ends alone.

The README even admits it's written by Claude. It's a one-file pack from a handle that goes back to answering attention-weighting questions in the A1111 days, and the code matches the honest branding - there's no magic here, and it says so.

How it works

Under the hood it's a ComfyUI model patch, the standard patches_replace["dit"]["double_block"] hook. When the forward pass hits your loop_end block, the node takes the image state, rewinds it to loop_start, and runs loop_start through loop_end again - as many extra times as you set. Then sampling continues normally. One denoise step, extra passes through the middle.

The interesting engineering is that it's block-swap aware. ComfyUI's low-VRAM swapper assumes every block runs exactly once, in order; an out-of-sequence echo would normally trip it up. This node dispatches the echo through the same hook path the swapper watches, so offloaded blocks reload properly instead of silently corrupting output. It also handles the LTX-2.3 quirk where img is actually a (video, audio) tuple, and only clones that image state when you're running more than one echo. Whoever wrote this thought about the memory math.

Inputs that matter

• loop_range (default 12,18) - the inclusive block range to echo. This is the knob. LTX-2.3 22B has ~48 blocks (0–47); LTX-2 19B has ~28. The author's tests found 10–18 the sweet spot, so 12,18 is a sensible start.
• loop_count (1–8, default 1) - extra echo passes. Each one repeats the whole range, so start at 1 and don't get greedy.
• start_percent / end_percent - the denoising window where looping is active. Keep it early: the author reports late steps with higher blocks never improved anything. Defaults (0→1) are fine, but capping end_percent around 0.5 is worth trying.

One MODEL in, one MODEL out. Wire it between your LTXVideo loader and your sampler - that's the entire wiring job.

Install

Easiest via ComfyUI Manager: search tkNodes, install, restart. Or the manual way:

cd ComfyUI/custom_nodes
git clone https://github.com/throttlekitty/tkNodes
# restart ComfyUI

That's it - no requirements.txt, no extra Python deps, nothing to download. The real prerequisite is the model it patches: LTX-2.3 22B, which on consumer cards means GGUF quants and usually 64GB of system RAM. If you can already run LTX-2.3, this adds nothing but the node.

Gotchas

• It's not free quality. Each echo is another pass through those blocks, so render time grows. And the author says it plainly: sometimes better, sometimes worse. Loop a short range early, A/B against the unpatched version, and keep it only if it wins.
• Watch the console. The node prints [LTXV Block Loop] blocks 12–18, 1 echo pass(es), active 0%–100%. If that line never appears, the patch isn't in your path - check you're sampling the patched model output.
• Stay in range. Loop indices beyond the model's block count don't fix anything and can throw. If you type 18,12 backwards it just swaps them, no harm.
• It's an LTX node. It lives in lightricks/LTXV and uses LTX's sampling math - don't wire it into a Wan or Hunyuan graph expecting magic.