LDF-VFI Sequence Interpolate

Every other interpolate node in this pack looks at two frames at a time. LDF-VFI Sequence Interpolate looks at your whole sequence - it's a diffusion transformer that models the entire clip's temporal structure and autoregressively generates the frames between, using a skip-concat sampler from the paper. That buys you something real: long-range temporal coherence. No per-pair flicker, no drift across a shot, no seams where one pair ends and the next begins. It buys it at a serious price - ~20GB VRAM, multi-gigabyte weights, and much slower runs - but for footage where temporal consistency is the whole point, it's the difference between "good" and "obviously synthetic."

There's no Segment variant of this node. That's deliberate: externally splitting the sequence would destroy the long-range context the model is built around. Instead it internally chunks long sequences while preserving temporal context, so you don't need a workaround for long clips.

The inputs that matter:

• images + model (from Load LDF-VFI Model) - the essentials. The model's ordering matters: frames must be the actual sequence, in order.
• temporal_factor (default 8) - the native upsampling factor. LDF supports every integer from 2x through 16x, which is unusual; output is F(N−1)+1 frames. This is the headline feature - 16x slow-mo from 24fps is possible here in a way pairwise nodes can't do sanely.
• sampling_steps (16) - diffusion steps per temporal chunk. The official quick start uses 16; fewer is faster but lower quality.
• t_shift (8.0) / t_cond (0.1) - the official quick-start diffusion timestep shift and boundary-noise settings. Leave them at defaults; these are "the paper says so" numbers, not dials to polish.
• seed (42) - seeds both the VAE and diffusion sampling, so runs are repeatable.
• offload_after (on) - returns the ~6.4GB model stack to CPU after generation. Keep it on unless you're doing back-to-back runs and can afford the resident VRAM.
• source_fps / target_fps - optional exact-FPS output, using the smallest sufficient native factor up to 16x.

Two outputs: images (the exact-FPS-selected result) and generated_sequence (the full native-factor sequence before selection - grab this if you want the raw temporal_factor output, e.g. for slow-mo where "exact FPS" isn't the point), plus elapsed_seconds.

Install. Search "Tween" in ComfyUI Manager, or:

cd ComfyUI/custom_nodes
git clone https://github.com/Ethanfel/ComfyUI-Tween
pip install -r requirements.txt

LDF needs PyTorch 2.5+ and a current diffusers/accelerate stack - the pack's requirements install them, but check your torch version if things break. First run downloads ~6.4GB.

Where people get burned: VRAM, mostly - if the VAE stage OOMs, drop vae_batch_size at the loader before touching anything else. And don't compare its runtime to SPEED and panic; this is a different workload and everyone knows it's slow. Use it when coherence matters more than speed - that's the entire argument for it.