Wan Flf Video

WAN 2.2 First-Last-Frame (FLF) Video Workflows

Overview

First-Last-Frame (FLF) video generation takes a start image and an end image and generates a smooth video transition between them. The WAN 2.2 I2V (Image-to-Video) 14B model is good at this.

CRITICAL: Dual Hi-Lo Architecture (REQUIRED)

WAN 2.2 I2V uses a split-noise architecture. Unlike WAN 2.1, the 2.2 model was trained with separate HighNoise and LowNoise components that handle different denoising ranges. You MUST use both models in a two-pass KSamplerAdvanced setup. Using a single model produces low-quality, broken output.

• HighNoise model (pass 1, steps 0→N/2) establishes structure, motion, and composition
• LowNoise model (pass 2, steps N/2→N) refines details and keeps fidelity to input frames
• Both passes share the same conditioning from WanFirstLastFrameToVideo
• Pass 1 returns noisy latent → Pass 2 continues from there

NEVER use a single KSampler with only one model for WAN 2.2 I2V.

Two native approaches are available:

1. Native Dual Hi-Lo (Default): WanFirstLastFrameToVideo + dual KSamplerAdvanced two-pass
2. WanVideoWrapper: WanVideoVACEStartToEndFrame + WanVideoVACEEncode + WanVideoSampler (VACE, caching, context windows)

Models

UNET Pairs (Always load BOTH Hi and Lo)

Remix NSFW (Recommended, built-in lightning, fp16):

GGUF Q8 (Alternative, needs external lightning LoRAs):

Official fp8:

Text Encoder

CLIP Vision + VAE

ModelSamplingSD3 (REQUIRED)

WAN 2.2 uses flow matching and requires ModelSamplingSD3 applied to each UNET:

{"class_type": "ModelSamplingSD3", "inputs": {"model": ["<unet>", 0], "shift": 5}}

shift=5 for lightning/Remix models. shift=8 for standard (non-lightning) models.

Lightning LoRAs

Remix NSFW models have lightning baked in. No external LoRA needed.

For GGUF/fp8 models, use paired hi/lo lightning LoRAs:

• wan2.2_i2v_lightx2v_4steps_lora_v1_high_noise.safetensors → HighNoise UNET
• wan2.2_i2v_lightx2v_4steps_lora_v1_low_noise.safetensors → LowNoise UNET

LoRA Stacks (rgthree)

Each model path has two stacked loaders (Common + Specific), each supporting 4 LoRA slots:

Hi path: UNETLoader(HN) → ModelSamplingSD3(shift=5) → Hi Common Stack → Hi Lora Stack → MODEL_HI
Lo path: UNETLoader(LN) → ModelSamplingSD3(shift=5) → Lo Common Stack → Lo Lora Stack → MODEL_LO

Common stacks hold shared LoRAs (quality/style). Specific stacks hold model-variant LoRAs. Set slots to "None" when unused. Even with no LoRAs, include the stacks. They pass CLIP through for text encoding.

Image Resizing (ImageResizeKJv2)

Input frames MUST be resized to the target video resolution before FLF and CLIPVisionEncode. The end frame inherits width/height from the start frame's resize so the dimensions match.

{"class_type": "ImageResizeKJv2", "inputs": {
  "image": ["<load_image>", 0], "width": 480, "height": 720,
  "upscale_method": "nearest-exact", "keep_proportion": "crop",
  "pad_color": "0, 0, 0", "crop_position": "center", "divisible_by": 2
}}

KSamplerAdvanced Two-Pass Settings

Both passes share the same positive/negative conditioning from WanFirstLastFrameToVideo outputs [0] and [1].

For standard (non-lightning) models: steps=20, split at step 10, cfg=4, sampler=euler, scheduler=simple, shift=8.

Negative Prompt (REQUIRED)

Always include a quality negative prompt:

The tones are vibrant, overexposed, static, details are unclear, subtitles, style, work, painting, image, still, overall grayish, worst quality, low quality, JPEG compression artifacts, ugly, incomplete, extra fingers, poorly drawn hands, poorly drawn faces, deformed, disfigured, distorted limbs, merged fingers, motionless image, cluttered background, three legs, many people in the background, walking backwards

Node: WanFirstLastFrameToVideo

Required Inputs:
  - positive: CONDITIONING (from CLIPTextEncode)
  - negative: CONDITIONING (from CLIPTextEncode with negative prompt)
  - vae: VAE
  - width: INT (from ImageResizeKJv2 end frame output[1])
  - height: INT (from ImageResizeKJv2 end frame output[2])
  - length: INT (default 81, step 4) — number of frames
  - batch_size: INT (default 1)

Optional Inputs:
  - clip_vision_start_image: CLIP_VISION_OUTPUT (from CLIPVisionEncode)
  - clip_vision_end_image: CLIP_VISION_OUTPUT (from CLIPVisionEncode)
  - start_image: IMAGE (resized start frame)
  - end_image: IMAGE (resized end frame)

Outputs:
  - [0] positive: CONDITIONING → feed to BOTH Hi and Lo KSamplerAdvanced
  - [1] negative: CONDITIONING → feed to BOTH Hi and Lo KSamplerAdvanced
  - [2] latent: LATENT → feed to Hi Pass only (Lo Pass gets Hi Pass output)

Pipeline Flow

UNETLoader (HighNoise) → ModelSamplingSD3 (shift=5) → Hi Common Stack → Hi Lora Stack → MODEL_HI
UNETLoader (LowNoise) → ModelSamplingSD3 (shift=5) → Lo Common Stack → Lo Lora Stack → MODEL_LO
CLIPLoaderGGUF (wan) → CLIP
  ├─ CLIPTextEncode (positive) → CONDITIONING
  └─ CLIPTextEncode (negative) → CONDITIONING
CLIPVisionLoader → CLIPVisionEncode (start) + CLIPVisionEncode (end)
VAELoader → VAE
LoadImage (start) → ImageResizeKJv2 (480x720) → resized start
LoadImage (end) → ImageResizeKJv2 (match dims) → resized end

WanFirstLastFrameToVideo (positive, negative, vae, clip_vision_start, clip_vision_end,
  start_image, end_image, width/height from resize)
  → modified positive [0], modified negative [1], latent [2]

KSamplerAdvanced (Hi: MODEL_HI, steps 0→2, add_noise=enable, return_leftover=enable)
  → noisy LATENT
KSamplerAdvanced (Lo: MODEL_LO, steps 2→4, add_noise=disable, return_leftover=disable)
  → final LATENT

VAEDecode → IMAGE → VHS_VideoCombine (raw output)
                   → VRAM_Debug → SeedVR2VideoUpscaler (1080p) → VHS_VideoCombine (upscaled)

Complete workflow (API JSON)

The full Native FLF (Remix NSFW + Lightning) graph is in references/workflows.md.

Optional: Video Upscaling with SeedVR2

Add after VAEDecode for AI-powered video upscaling to 1080p. Use VRAM_Debug to free VRAM between generation and upscaling:

{
  "25": { "class_type": "VRAM_Debug", "inputs": {
    "image_pass": ["23", 0], "empty_cache": true, "gc_collect": true, "unload_all_models": true
  }},
  "26": { "class_type": "SeedVR2LoadDiTModel", "inputs": {
    "model": "seedvr2_ema_3b_fp8_e4m3fn.safetensors", "device": "cuda:0",
    "blocks_to_swap": 0, "swap_io_components": false, "cache_model": false, "attention_mode": "sdpa"
  }},
  "27": { "class_type": "SeedVR2LoadVAEModel", "inputs": {
    "model": "ema_vae_fp16.safetensors", "device": "cuda:0",
    "encode_tiled": false, "decode_tiled": false, "cache_model": false
  }},
  "28": { "class_type": "SeedVR2VideoUpscaler", "inputs": {
    "image": ["25", 1], "dit": ["26", 0], "vae": ["27", 0],
    "seed": 0, "resolution": 1080, "max_resolution": 0,
    "batch_size": 5, "uniform_batch_size": false, "color_correction": "lab"
  }},
  "29": { "class_type": "VHS_VideoCombine", "inputs": {
    "images": ["28", 0], "frame_rate": 16, "loop_count": 0,
    "filename_prefix": "wan_flf_upscaled", "format": "video/h264-mp4",
    "pingpong": false, "save_output": true,
    "pix_fmt": "yuv420p", "crf": 19, "save_metadata": true, "trim_to_audio": false
  }}
}

Alternative: GGUF Models with Lightning LoRAs

When using GGUF Q8 models instead of Remix, add paired lightning LoRAs:

Hi path: UnetLoaderGGUF(HN Q8) → ModelSamplingSD3(shift=5) → LoraLoaderModelOnly(hi_noise_lightning) → Hi Common Stack → Hi Lora Stack
Lo path: UnetLoaderGGUF(LN Q8) → ModelSamplingSD3(shift=5) → LoraLoaderModelOnly(lo_noise_lightning) → Lo Common Stack → Lo Lora Stack

LoRA files:

• Unknown\no tags\wan2.2_i2v_lightx2v_4steps_lora_v1_high_noise.safetensors
• Unknown\no tags\wan2.2_i2v_lightx2v_4steps_lora_v1_low_noise.safetensors

Approach 2: WanVideoWrapper (Advanced Control)

Uses the WanVideoWrapper custom node pack for more control over conditioning, caching, context windows, and advanced features.

Key Differences from Native

• Uses WANVIDEOMODEL type instead of generic MODEL
• Uses WANVIDIMAGE_EMBEDS for conditioning instead of CONDITIONING
• Has own sampler (WanVideoSampler) with shift parameter and scheduler options
• Supports TeaCache, MagCache, EasyCache for speed optimization
• Supports context windows for longer videos
• VACE module provides more flexible frame conditioning

VACE-Based FLF Pipeline

WanVideoModelLoader → WANVIDEOMODEL
WanVideoVAELoader → WANVAE
WanVideoTextEncode → WANVIDEOTEXTEMBEDS
WanVideoClipVisionEncode (start + end images) → WANVIDIMAGE_CLIPEMBEDS

WanVideoVACEStartToEndFrame (start_image, end_image, num_frames=81)
  → images batch, masks

WanVideoVACEEncode (vae, input_frames, input_masks, width, height, num_frames)
  → WANVIDIMAGE_EMBEDS (vace_embeds)

WanVideoSampler (model, image_embeds, text_embeds, steps, cfg, shift, scheduler)
  → LATENT

WanVideoDecode (vae, samples) → IMAGE → VHS_VideoCombine → MP4

WanVideoSampler Settings

When to Use WanVideoWrapper vs Native

Recommendation: use Native dual hi-lo for standard FLF transitions. Use WanVideoWrapper when you need caching, context windows, VRAM management, or advanced conditioning.

⚠️ CRITICAL: merge_loras=false with fp8-scaled models

When loading a LoRA through WanVideoLoraSelect → WanVideoModelLoader's lora input on an fp8-quantized model (quantization=fp8_e4m3fn_scaled, e.g. the official wan2.2_i2v_high/low_noise_14B_fp8_scaled weights), you MUST set the WanVideoLoraSelect widget merge_loras=false.

• merge_loras=true (the node default) tries to bake the LoRA deltas into the already-quantized fp8 weights. That merge path hard-crashes ComfyUI during LoRA loading. The process dies with no Python traceback (so panel_get_errors / the frontend show nothing; only a process restart/OOM-style symptom). This is the #1 cause of a "crashed on lora loading" report with the wrapper.
• merge_loras=false applies the LoRA as a runtime patch during the forward pass instead of merging. It is fp8-safe with negligible speed cost. This is the correct setting for the lightx2v 4-step lightning LoRAs (hi + lo) on the fp8 hi/lo I2V models.
• It also pairs cleanly with block swap: WanVideoBlockSwap (e.g. 20 to 30 of 40 blocks → RAM) + merge_loras=false is the verified combo for fp8 14B I2V at 720p/81f on a 24GB card. (If you instead use a non-quantized bf16/fp16 model, merge_loras=true is fine.)

Separately, at 720p/81f enable enable_vae_tiling=true on WanVideoDecode. The full-frame decode is the other common uncaught-OOM crash point.

Resolution & Frame Count

Standard Resolutions

Width and height must be divisible by 16. Use ImageResizeKJv2 with divisible_by: 2 and keep_proportion: crop.

Frame Count

• 81 frames at 16fps = ~5 seconds (default, recommended)
• 49 frames at 16fps = ~3 seconds (faster, less motion)
• 121 frames at 16fps = ~7.5 seconds (longer, more VRAM)
• Frame count should be 4n + 1 (1, 5, 9, ..., 49, 81, 121)

Frame Rate

Standard: 16 fps for WAN 2.2 output.

Video Output

VHS_VideoCombine

{
  "class_type": "VHS_VideoCombine",
  "inputs": {
    "images": ["<vae_decode>", 0],
    "frame_rate": 16,
    "loop_count": 0,
    "filename_prefix": "wan_flf",
    "format": "video/h264-mp4",
    "pingpong": false,
    "save_output": true,
    "pix_fmt": "yuv420p",
    "crf": 19,
    "save_metadata": true,
    "trim_to_audio": false
  }
}

VRAM Considerations