KeyframeBlender

KeyframeBlender is the engine behind the pack's flashy "morph one image into the next" animations. You give it a set of keyframe images and their IP-adapter embeddings, and it produces the full transition video - plus a set of masks that tell a sampler exactly how much to denoise at each frame and where to apply IP-adapter influence. If you've seen those videos where a texture or subject smoothly morphs frame by frame, this is the node that orchestrates the blend.

It's part of eden_comfy_pipelines, Eden.art's 70+ node suite, and it's a genuine video-effects node, not a utility.

What you feed it

• image_frames - your keyframe images, as a stack. These are the "stills" you're morphing between.
• keyframe_ip_adapter_features (EMBEDS) - the IP-adapter embeddings of those keyframes, so the style trajectory matches the visual trajectory.
• n_frames - the total number of output frames, default 50.
• denoise_gamma - 0–5, default 1. A curve-shaping exponent on the denoising mask: values above 1 sharpen the "fully denoised at the keyframe" peaks, values below 1 broaden them.
• ip_adapter_gamma - same idea, but for the IP-adapter attention mask, controlling how concentrated IP-adapter influence is around each keyframe.

The five outputs

This is where the node earns its complexity:

• keyframe_blend (IMAGE) - the raw blended video: each frame is a linear crossfade between neighboring keyframes.
• denoising_masks (MASK) - per-frame masks saying how much to denoise at each position: near 1 at the keyframes (where the model should recreate the reference), falling toward 0 mid-transition (where it should just follow the blend).
• ip_adapter_attention_masks (MASK) - per-frame masks for IP-adapter attention, shaping where style influence applies.
• denoising_mask_curve (IMAGE) - a matplotlib plot of the denoising values across frames, rendered as an image so you can eyeball your curve.
• ip_adapter_trajectory (EMBEDS) - the embeddings interpolated across frames, ready to feed the sampling step.

How it works

The core is interpolation with a twist. Frames are crossfaded between keyframes (a straight alpha blend), and IP-adapter embeddings are interpolated in lockstep. But the denoising mask is built from a triangular profile - it ramps up toward each keyframe and down away from it - so the sampler is told "recreate the keyframe here, drift between them." The two gamma controls reshape that triangle: higher gamma concentrates the effect into narrower peaks. The output curve image is genuinely handy for debugging - you can see whether your transitions are tight or mushy before you burn a sampling run.

The honest setup cost

This is not a beginner node. It expects EMBEDS inputs, which means you need an IP-adapter embedding pipeline feeding it (the pack's moodmix utilities and Get_Prefixed_Imgs / embedding-save nodes are the intended companions), and the outputs only do their thing when wired into a sampler that honors per-frame denoise masks and IP-adapter attention masks. If that sentence made your eyes glaze, start with IMG_blender and Extend_Sequence to learn the concepts, then come back. When it clicks, it's one of the most impressive things in the pack - the community reaction to the pack's texture-morphing workflows (like TextureFlow) was very positive for exactly this kind of result.

Installing it

Standard pack install - ComfyUI Manager (search "eden"), or:

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

Restart ComfyUI. It uses matplotlib (in the pack's requirements) for the curve plot. The node itself downloads no models, but the IP-adapter and video machinery around it will.