Wan2.2 Storyboard: First-Mid-Mid-Last (GGUF 5B)

Want a video that actually goes somewhere instead of drifting around one image? That's the pitch here. Wan22StoryboardGGUF is a latent-builder for Wan 2.2 that lets you lock up to four keyframes - start, two middles, end - and have the sampler animate between them. It's built for the 5B GGUF crowd on 8GB cards, and it's one of those rare nodes where the "low VRAM" claim mostly holds up, because the math is doing the heavy lifting, not your GPU.

The trick: it never runs the model

This node doesn't generate anything. It builds the LATENT and its noise_mask, and then a regular KSampler does the denoising. It's the same move the native Wan image-to-video nodes use - encode a frame into a latent slot, zero the mask there so the sampler leaves it alone, treat everything else as "inpaint between these anchors" - just spread across four slots instead of one.

Here's what happens when it runs:

• It figures out the timeline. length_seconds × fps + 1 gives the raw frame count, then snaps it down to the nearest 4n + 1. That's not pedantry: Wan's 3D causal VAE compresses time 4×, so frame counts that don't land on 4n + 1 decode short, crash, or come back with the wrong length. This node handles that so you don't have to.
• It allocates the Wan 2.2 latent - [batch, 48, t, h/16, w/16], 48 channels being a Wan 2.2 signature - and stamps it with the correct latent scale via comfy.latent_formats.Wan22().
• Each keyframe you plug in gets upscaled to your target resolution, VAE-encoded, and written into its latent slot. The end image also bleeds into the last couple of latent frames, so the final frame is locked too.
• Between encodes it calls soft_empty_cache() - that proactive cache clearing is the actual "8GB optimization" here, not tiling (the README mentions tiled VAE, but it's not in the code; the per-frame encode + cache clear is what keeps 768×1280 feasible).

The output is one LATENT carrying both samples and a noise_mask. Wire it into a KSampler, then VAE Decode, then your video save node.

The inputs that actually matter

Everything except the images is required, and only a few deserve your attention:

• width / height - defaults to 768×1280, the vertical resolution the README recommends for 8GB. Both step by 16.
• length_seconds / fps - your clip duration and rate. More below, because fps is a trap.
• start_image, middle_image_1, middle_image_2, end_image - all optional IMAGE slots. With all four, the node spaces them evenly across the timeline (first, ~⅓, ~⅔, last); with just start and end you get a clean two-keyframe animation. They're genuinely optional - you can feed none and get a plain text-to-video latent, which makes this a decent drop-in empty-latent node too.
• positive / negative - normal conditioning from a CLIP Text Encode using a Wan text encoder, plus vae - the Wan VAE. You bring those yourself.

Install

It's a two-file pack with zero dependencies beyond ComfyUI core, so this is the easiest install you'll do all week:

cd ComfyUI/custom_nodes
git clone https://github.com/chrishill197724-gif/ComfyUI-Wan22-GGUF-Storyboard

Restart ComfyUI and it appears under WanVideo/Storyboard in the node menu. (The README's manual instructions - create the folder, drop in the two .py files - are just the same thing done by hand; ComfyUI Manager can grab it by the repo URL too.) It downloads nothing itself. You still need the actual model stack from elsewhere: the Wan 2.2 5B checkpoint (GGUF quant is the point), its VAE, and the text encoder.

The fps gotcha and other honest warnings

The README's one "crucial step" is real: set fps here to the exact same number as your video combine/save node. This node is the Director of the frame count, so if the two disagree you get choppy or sped-up output. Second gotcha: because frame counts snap to the 4n + 1 grid, your clip can come out a hair shorter than length_seconds says - 5.0s at 24fps is 121 frames (a perfect 4n + 1), but pick something awkward and expect a few frames shaved. The README's starter recipe (768×1280, 24fps, 5–7s, CFG 6, 35 steps with WanVideoNAG) is a sane place to begin.

Full honesty: this is a tiny, brand-new, one-node pack from a hobbyist - 3 search impressions is "just made it." The idea is sound and mirrors how the ecosystem already drives Wan video (Kijai's WanVideoWrapper and native ComfyUI use the same anchored-latent approach), but you're not getting years of battle-testing. For a quick first/last-frame-controlled clip on a mid-range card, it's a fun, free experiment that costs nothing to try.