Split Image Batch

Split Image Batch is the front half of the pack's video recipe: take the frames coming out of Load Video → Get Video Components (or any IMAGE batch) and slice them into chunks, one per GPU branch. Each chunk feeds its own Upscale Image (Model + Start) on its own card, and Merge Image Batch puts the pieces back in order on the far side. It's a simple node with one genuinely useful idea inside.

How it works

It's pure tensor slicing along the batch axis - no pixel work, just frame indices. You tell it how many chunks you want and it hands you that many IMAGE outputs, all 8 sockets exposed, unused ones empty. The info output tells you exactly how the frames got divided (120 frames → 4 parts [30, 30, 30, 30]), which is the quickest way to sanity-check your split.

The part that's worth understanding is mode:

• sequential (default) - contiguous frame ranges: frames 0-29 to part 1, 30-59 to part 2, and so on. Order is tidy, and it's what you want when every card does the same amount of work.
• interleaved - round-robin: frame 0 to part 1, frame 1 to part 2, frame 2 to part 3, frame 3 back to part 1. Every part gets a fair spread of the video. This is the smarter pick when your GPUs aren't the same speed, or when you're worried about load balance - the slowest card still gets an even slice instead of a contiguous worst-case chunk.

There's also an optional frames_per_part input. If you set it above 0, it overrides the num_parts sizing entirely and cuts the batch into chunks of that many frames (still capped at 8 parts), with the last part taking the remainder. Handy when you want each card to chew on a fixed-size batch regardless of how many frames you loaded.

Inputs and outputs

• images - required IMAGE batch: video frames or a stack of images.
• num_parts - INT, default 4, range 1-8. The number of chunks, i.e. the number of GPU branches you're going to wire.
• mode - sequential or interleaved, above.
• frames_per_part - optional INT, default 0 (off).

Outputs: part_1 … part_8 (IMAGE), plus info (STRING, the division summary) and total_frames (INT, just the input batch size echoed back).

Wire each part into its own upscale branch, then into Merge Image Batch in the same order. Keep that order straight - merge is plain concatenation, so part_1's branch must land in merge's part_1 socket or your video comes back scrambled.

Why the 8-part ceiling is a ceiling

This node maxes out at 8 parts, which is why the README's scaling story is a cascade: 8 GPUs → one split of 8; 16 GPUs → split into 2, then each half into 8; 32 GPUs → split into 4, then each quarter into 8. If you actually own 16 cards, that's the pattern - if you own two, don't overthink it, just set num_parts=2.

Install

Same pack, same install:

# ComfyUI Manager → Install Custom Nodes → search "32GPU Video Upscale"
# or:
cd ComfyUI/custom_nodes
git clone https://github.com/WhyNotNN/ComfyUI-32GPU-Video-Upscale.git
# restart ComfyUI

No extra pip dependencies - it's plain torch slicing on ComfyUI's stack. Needs recent ComfyUI with async support for the branches to actually overlap.

Honest notes

If you're not splitting for multiple GPUs, this node adds nothing - the stock Batch to ... / ... to Batch style nodes in core ComfyUI do batch wrangling fine. Its whole reason to exist is the multi-card pipeline, and like the rest of this pack it's early days: a single-commit release with a template README and essentially no community adoption yet. Check the repo before betting a workflow on its behavior.