InfiniteTalk is a Wan 2.1-based lip-sync method, and ComfyUI now supports it natively - the author says faster and better than the earlier KJ implementation, with only minor degradation for two-person shots. The interesting part is the loop: feed the rendered clip back as the next segment's first frame, compute the iteration count from the audio length, and you get near-infinite duration. The episode also updates the LTX-2 distilled talking-head graph.

Evidence note: parameters below were parsed from the workflow JSON shipped with this episode (4 files); anything the video reports about results is attributed to the author.

When this is useful

  • You need a talking clip longer than the ~3-second first window.
  • You have one portrait and one audio track and want a repeatable loop.
  • You want two characters alternating lines from a single image.

How the infinite loop is built

First segment, then extend

The first generation takes 81 frames, about 3.24 seconds at 25 fps - and the author says do not change that frame rate.

The loop is deliberately simple: the previous clip goes into Value 1, Value 1 feeds Talk-to-Video, the output goes to Batch Image, and the rendered clip is wired back into Value 1.

Each extension adds 72 frames (81 minus 9), i.e. about 2.8 seconds per loop.

The loop count is arithmetic, not guesswork

Detect the audio length in milliseconds, subtract 3240 ms (the first 81-frame segment), divide by 2880 ms (each 72-frame extension), and round up. That is the iteration count.

With that, the whole thing is close to automatic: you supply image, audio, start second and length, width and height.

480P, not 720P - and why

The model is the 480P image-to-video build. The author is explicit that the 720P model is unnecessary and gives worse results - on his non-human test character the mouth did not move at all.

SkyReels V3, a newer audio-to-video model, performs roughly on par with the 480P model, so either is fine here.

The graph follows the official example; the author does a vocal separation pass before feeding audio, to keep other noise from disturbing the lip-sync.

Two people: two audios, one image, two masks

The dual graph takes two audio tracks - character 1's lines, then character 2's - and two images that are actually the same image, differentiated by painting each speaker's region in the mask editor.

The author's honest read: two-person output is still mostly "one talks, then the other". True multi-turn dialogue is not there yet; he expects it eventually.

480P looks soft, so he runs FlashVSR upscale over the result - which he says cleans it up a lot.

The LTX-2 distilled talking head

The LTX-2 lip-sync graph is updated from an open-source Hugging Face project that released its workflow.

The first render uses the distilled model - you can see 8 steps in the sigma values. The Camera Control LoRA is critical for keeping the shot stable; bypassing it visibly hurts results, so leave it on.

You load an image and set width, height and frame count; frame rate and length are computed. His example renders 289 frames, and he says ComfyUI's LTX-2 optimisation now makes 500-600 frames per run feasible - effectively near-infinite duration in one pass.

LTX-2 prompts are sensitive, especially for non-human characters; that is also where LTX-2 has a natural edge over portrait-only pipelines.

How to run it

  1. Open the single-person InfiniteTalk graph; load one image and one audio track.
  2. Set the audio start second and the length to process, then width and height.
  3. Run: the first segment is 81 frames at 25 fps (~3.24 s).
  4. Extend by looping - previous clip into Value 1, back through Talk-to-Video and Batch Image.
  5. Compute the loop count as ceil((audio_ms - 3240) / 2880) so the length matches the audio.
  6. For two people, use the dual graph: two audios, the same image twice, two painted masks. Then run FlashVSR to sharpen.
  7. For the LTX-2 route, load an image, set width/height/frames, and leave the Camera Control LoRA on.

Parameter basis

FlashVSR V1.1放大 - 4 nodes

No UNET/CLIP/VAE sampler chain in this graph - it is a processing or composite graph. Node inventory: FlashVSRNode, VHS_LoadVideo, VHS_VideoCombine, LayerUtility: ImageScaleByAspectRatio V2 (4 nodes).

Ltx 2蒸馏对口型 - 106 nodes

Item Value (from JSON)
UNET loader LTXVideo\v2\ltx-2-19b-distilled-fp8_transformer_only.safetensors / default
Dual CLIP gemma_3_12B_it_fp8_scaled.safetensors + ltx-2-19b-embeddings_connector_distill_bf16.safetensors
VAE LTX2_video_vae_bf16.safetensors
Latent size 768x512 · 241 frames · batch 1
LoRA LTX\v2\ltx-2-19b-distilled-lora_resized_dynamic_fro09_avg_rank_175_bf16.safetensors @ 0.6; ltx-2-19b-distilled-lora_resized_dynamic_fro09_avg_rank_175_bf16.safetensors @ 0.6; ltx-2-19b-lora-camera-control-static.safetensors @ 1

单人InfiniteTalk无限时长原生循环 - 68 nodes

Item Value (from JSON)
UNET loader SkyReelsV3-A2V_fp8_scaled_mixed.safetensors / default
CLIP loader umt5_xxl_fp8_e4m3fn_scaled.safetensors / wan
VAE Wan2.1_VAE.pth
BasicScheduler steps 4 · scheduler normal · denoise 1
BasicScheduler steps 4 · scheduler normal · denoise 1
LoRA lightx2v_I2V_14B_480p_cfg_step_distill_rank64_bf16.safetensors @ 1; Wan_2_1_T2V_14B_720p_rCM_lora_average_rank_94_bf16.safetensors @ 0.3

双人InfiniteTalk无限时长原生循环 - 65 nodes

Item Value (from JSON)
UNET loader wan2.1_i2v_720p_scaled_fp8_e4m3_lightx2v_comfyui.safetensors / default
CLIP loader umt5_xxl_fp8_e4m3fn_scaled.safetensors / wan
VAE Wan2.1_VAE.pth
BasicScheduler steps 4 · scheduler normal · denoise 1
BasicScheduler steps 4 · scheduler normal · denoise 1
LoRA Wan_2_1_T2V_14B_720p_rCM_lora_average_rank_94_bf16.safetensors @ 0.3; lightx2v_I2V_14B_480p_cfg_step_distill_rank64_bf16.safetensors @ 1

Honest limits

  • The 25 fps is fixed by the 81-frame / 3.24 s arithmetic; changing it breaks the loop count.
  • Two-person output is still sequential, not true multi-turn dialogue - the author says so.
  • 480P is soft; without an upscale pass the result looks unclear.
  • The loop extends duration, not expressiveness: drift accumulates over many iterations.
  • Frame counts of 500-600 per run are the author's report under ComfyUI's current optimisation, not a hard limit.

Episode resources