Transition Images Multi

This one does exactly what it says, and not much more: it generates the frames of a transition between two or more images. If you've ever wanted a slideshow that doesn't just hard-cut from one still to the next - a fade, a wipe, a door that slides open - this is the node that renders those in-between frames for you, without touching a video editor.

The "Multi" in the name is the useful part. Rather than a fixed two-image-in-one-transition-out node, it uses the inputcount widget (the same pattern KJNodes uses elsewhere in the pack for variable-length inputs): bump the count and matching image_N sockets appear on the node, so you can chain a run of images with a transition generated between each consecutive pair, not just a single crossfade.

The inputs and outputs that matter

• image_1 (required) and image_2 (optional) - your starting images. With inputcount above 2, further image_N sockets appear for additional images in the sequence.
• transition_type - the visual style of the wipe: horizontal slide, vertical slide, box, circle, horizontal door, vertical door, or fade. These read like a standard video-editor wipe library - box and circle expand a shape from a point, the door variants split down the middle and slide apart, fade is a plain crossfade.
• interpolation - the easing curve driving the transition's pace: linear, ease_in, ease_out, ease_in_out, bounce, elastic, glitchy, or exponential_ease_out. Standard animation easing vocabulary, plus one deliberate outlier - glitchy, which trades smoothness for a jittery, broken-looking cut if that's the aesthetic you're after.
• transitioning_frames - how many frames the transition itself spans. Higher means a slower, smoother handoff between images; the practical range depends entirely on your output frame rate.
• blur_radius - softens the wipe edge, useful for the harder-edged transition types (box, circle, the door variants) if a crisp geometric line looks too artificial.
• reverse - flips the transition's direction.
• device - CPU or GPU for where the interpolation math runs. GPU is the one to reach for if you're generating a long sequence with many transitions and it's dragging.

Output is a single IMAGE batch containing the generated transition frames - feed it into a video-combine node (Video Helper Suite's Video Combine, or a Save Animated WebP/GIF node) to actually render it out, or treat it as a batch of stills if that's all you need.

How to install it

Part of the KJNodes pack, no separate download needed. Through ComfyUI Manager: search "KJNodes for ComfyUI," install, restart. Manually: cd ComfyUI/custom_nodes && git clone https://github.com/kijai/ComfyUI-KJNodes, then pip install -r ComfyUI-KJNodes/requirements.txt (portable Windows: python_embeded\python.exe -m pip install -r ...), then restart. Nothing about this specific node needs extra models or heavyweight dependencies beyond what the base pack already installs - it's plain image processing.

Common issues & troubleshooting

More image_N sockets don't show up when you raise inputcount. This is the pack's dynamic-socket pattern - after changing the count, you may need to trigger the node's update (KJNodes' JS extension handles this) rather than expecting sockets to appear from the widget change alone. If sockets still aren't appearing, a ComfyUI frontend update mismatch is the usual suspect - update ComfyUI Manager and the pack together.

Output looks choppy or too abrupt. Raise transitioning_frames - a two- or three-frame transition (the schema's minimum) barely registers as a transition at all at typical video frame rates. Give it more frames to actually be visible.

Hard geometric wipes (box, circle, door types) look like a cheap PowerPoint effect. Increase blur_radius to soften the edge. It's a small change that goes a long way toward making a geometric wipe read as intentional rather than default-template.

It's slow on a long sequence. Switch device from CPU to GPU if you haven't already - this is exactly the kind of per-pixel interpolation work that benefits from it.