✂ Frame Set Splitter

Frame Set Splitter [DVB] cuts a FRAME_SET into two halves so you can stop wrestling one giant batch. The author's own framing is that it exists to divide work - the README is blunt: "Useful to divide work (reduce memory requirements in some cases)." If you've ever run a 100-frame AnimateDiff batch and watched VRAM become a suggestion, you know why that matters. Split once, process each half through a lighter pass, and the timeline survives.

It splits by the number of existing frames, not by index range - so if your set has gaps or offset indices, each half keeps its real indices and frame rate intact. Nothing gets renumbered, nothing gets re-timed. It's a clean cut through the sequence, and each half is still a proper FRAME_SET, which means both outputs can flow into anything else in this pack or out through Unwrap Frame Set [DVB] to the wider graph.

The inputs that matter

Only two, and only one needs thought:

• frames - the FRAME_SET in.
• overlap (default 0, min 0) - how many frames to share across the seam. The overlap is split between the two halves: roughly half the overlap frames are appended to the end of first_half from second_half, and the rest are prepended to second_half from first_half. The result is that both halves contain the seam frames, which is exactly what you want if the next stage is a crossfade transition (the pack ships Blended Transition [DVB] and Frame Set Append [DVB] for stitching halves back together).

That's it. You won't find a "split ratio" - it's always 50/50 by frame count, and overlap is the only knob.

Outputs

• first_half - a FRAME_SET with the first half of the frames (plus any overlap).
• second_half - the rest.

Both preserve the original frame rate and indices. Wire each half down a different branch - a different prompt, a different LoRA, a different model pass - and you can treat them as independent animations that still share a timeline. That's the real trick of this node: it's not just a memory hack, it's how you do per-segment variation without hand-cutting frame ranges.

Installing

It's part of the Dream Video Batches pack (author: Alt Key Project / Dream Project). Install once, get every node in the pack:

cd ComfyUI/custom_nodes
git clone https://github.com/alt-key-project/comfyui-dream-video-batches.git
cd comfyui-dream-video-batches
pip install -r requirements.txt

Or skip all that and search "Dream Video Batches" in ComfyUI Manager. Restart after install either way. No model downloads - this pack is pure frame math, no weights.

Where people get burned

Two things trip people up. First, because it splits by existing-frame count, a set with gaps won't split where you expect by index. If you've offset indices, the split lands at the halfway count, not the halfway index - check the outputs before building the rest of the graph on assumptions. Second, the memory win is real but not magic: both halves still live in RAM as tensors while the split runs, so the win shows up when you process each half through a memory-hungry node (sampling, upscaling) separately, not at the moment of the split itself. And remember the pack's universal rule: a FRAME_SET output won't plug into a stock output node - run each half through Unwrap Frame Set [DVB] before it hits Save Video.