GPU LayerStyles CrossFade

Chained video clips have a visible join. You generate 81 frames, take the last one as the first frame of the next generation, and something small but unmistakable happens at the boundary - the light shifts a hair, the grain resets, a limb lands somewhere slightly different. GPULayerStyles_CrossFade is the blunt, deterministic fix: overlap the two batches and blend across N frames so the join is a transition instead of a cut.

What it does

It takes two batches and builds one linear ramp between them. The output is exactly start_index + length(images_2) frames long, made of three segments:

1. Everything from images_1 before start_index, copied as-is.
2. A fade of exactly frames frames, where frame 1 is 100% images_1 and frame N is 100% images_2, linear in between.
3. The rest of images_2 after the fade - everything from its frame frames onward.

Anything in images_1 after start_index + frames is discarded. That's worth reading twice: this node doesn't splice two whole clips, it keeps a prefix of the first, uses a window of frames as the transition, and keeps the rest of the second. Frames from images_1 that land inside the fade window are your overlap - you've deliberately double-used them.

The blend is done in float32 with the alpha ramp computed from absolute transition position, not from the chunk being processed, so the weights don't change if the node has to split the work into chunks. Alpha channels fade along with RGB, and there's no clamping, so a fade of a semi-transparent batch stays soft rather than snapping to the edges.

Inputs you set

• images_1, images_2 - the two batches. They must match on height, width and channel count (RGB or RGBA). Frame counts do not have to match.
• start_index - zero-based frame in images_1 where the transition begins. Default 0, negative values rejected, and it must be less than the length of images_1. images_2 always starts from its own frame 0.
• frames - the transition length including both endpoints, minimum 2. It has to fit in what's left of images_1 after start_index and within images_2.
• output_device and batch_size - the pack's standard execution controls. cpu by default; gpu when the next node is also on-device; batch_size chunks frames and auto-halves on allocation failure with a log warning.

One output, image.

Scoring a seam, practically

A frames value of 8–16 at 16fps reads as a deliberate dissolve; 2–4 reads as a soft cut. Going longer than about a second starts looking like a mistake rather than a transition. If the two clips are close - same prompt, same seed lineage, chained generation - you often only need 4–6 frames to kill the flicker, because what you're hiding is a small discontinuity, not a scene change.

Note what this is not: it isn't a morph. There's no optical flow, no motion interpolation. If the two clips have genuinely different content at the join, crossfading them produces the familiar ghosting double-exposure. That's a job for a model that generates a bridge, or a joiner node with a Make Loop toggle - and if you want a loop rather than a splice, TwoBatchLoop handles both boundaries at once.

Install

ComfyUI Manager → search GPU LayerStyles. Or:

cd /path/to/ComfyUI/custom_nodes
git clone https://github.com/lany42/gpu-layerstyles
# restart ComfyUI

No pip step: the pack's runtime dependency list is empty, there are no model files and no API key. It does want Python 3.13+ and a current ComfyUI (comfy_api-era node schema). AGPL-3.0-only. The canonical repo is git.colorized.life, mirrored to GitHub as lany42/gpu-layerstyles.

Getting burned

Out-of-range frames is the classic. The node needs those frames in both batches, so if images_1 has 81 frames and you ask for a 16-frame fade starting at index 70, it errors with the arithmetic spelled out: eleven frames remain in images_1 at that start index. Read the message, lower start_index or frames, and it'll run.

Memory, at the end of a long chain. CrossFade has to reserve the whole output before it starts - a crossfade of two 500-frame 1080p batches is a 500-odd-frame float32 tensor plus the chunk buffers. output_device: cpu puts that in host RAM instead of VRAM, which is the safer default on a GPU you're also sampling on.