/video-upscale

name: video-upscale
description: Upscale and restore video in ComfyUI. Both the quick local path (per-frame ESRGAN like 4x_foolhardy_Remacri via ImageUpscaleWithModel + 4x→2x supersample, with its temporal-flicker tradeoff) and temporal-aware super-resolution (SeedVR2, the newer FlashVSR) with the downscale-first restore pipeline; RIFE/FILM frame interpolation via the BUILT-IN ComfyUI 0.26 FrameInterpolate (rife_v4.26 in models/frame_interpolation/) or the ComfyUI-Frame-Interpolation pack; 2x/4x scaling, VRAM tiers, VHS encode. Captures the classic downscale→SeedVR2→RIFE recipe and the current 2026 recommendation.
globs:
  - "**/*.json"
  - "**/packs/**"

Video Upscaling & Restoration

Overview

"Upscaling video" in ComfyUI splits into three jobs, and the quality win comes from doing them in the right order:

1. Spatial restore + upscale. A temporal-aware model that increases resolution AND cleans compression blocks, blur, and AI-gen mush while keeping frames consistent over time. This is the part a plain image upscaler (ESRGAN, UltimateSDUpscale per-frame) does badly. Per-frame upscalers flicker because each frame is sharpened independently. Use a video model. 2. Frame interpolation (VFI). Synthesize in-between frames to raise fps (e.g. 24→48/60) for smooth motion. Do this after the spatial pass. 3. Encode. Mux frames (plus original audio) back to an MP4.

The two leading temporal restorers in 2026 are SeedVR2 (diffusion-transformer restorer, the proven workhorse) and FlashVSR (newer one-step streaming VSR, faster). Frame interpolation is RIFE (or FILM) via ComfyUI-Frame-Interpolation.

> Verification note: every node/pack/model name below was confirmed against the > GitHub repos and the ComfyUI registry / Manager as of June 2026. Where a name is > approximate or version-dependent it is flagged. Do not substitute a node you > can't confirm is installed. Check with `install_custom_node` (`action: "list"`) / `create_workflow (action:"node_info")`.

---

⭐ Recommended current pipeline (2026)

Downscale → SeedVR2 (temporal restore+upscale) → RIFE (interpolate) → VHS encode. This modernizes the user's classic recipe (below) with the current SeedVR2 node pack and is the path to ship by default. FlashVSR is the faster alternative for the restore stage (see "FlashVSR" section). Swap it in when speed matters more than absolute fidelity.

Node-graph sketch

LoadVideo  ─► GetVideoComponents ─► (IMAGE frames, audio, fps)
                       │
                       ▼
        ImageScaleBy / ImageScale   ◄── DOWNSCALE first (e.g. 0.5×) — clean,
                       │                  small input for the restorer
                       ▼
        SeedVR2 Video Upscaler  ◄── DiT model + VAE + (block swap) + (tiling)
           ├─ "SeedVR2 (Down)Load DiT Model"
           ├─ "SeedVR2 (Down)Load VAE Model"
           └─ ["SeedVR2 Torch Compile Settings"]  (optional speedup)
                       │  (restored, high-res frames)
                       ▼
        RIFE VFI (4.0 - 4.9)   ◄── multiplier 2 (e.g. 24→48 fps)
                       │
                       ▼
        CreateVideo (fps = source × multiplier) ─► SaveVideo
        — or — VHS_VideoCombine (carries audio passthrough)

`LoadVideo` / `GetVideoComponents` / `CreateVideo` / `SaveVideo` are core ComfyUI video nodes (same ones the official comfy.org SeedVR2 template uses). `VHS_LoadVideo` / `VHS_VideoCombine` come from ComfyUI-VideoHelperSuite (installed) and are preferred for the final encode because they pass the original audio through.

Why downscale FIRST (the load-bearing trick)

• The restorer wants a clean low-res input, not a big dirty one. SeedVR2

(and FlashVSR) regenerate detail. Feeding them a small frame forces the model to synthesize sharp detail rather than faithfully magnifying existing compression artifacts and noise. Downscaling first averages away block noise, so the restorer hallucinates clean, coherent texture.

• VRAM and speed headroom. Cost scales with input pixels × frames. Halving each

dimension is ~4× fewer pixels per frame, which buys you a larger temporal batch (the thing that kills flicker, see below) and a bigger target multiple.

• It turns "upscale" into "restore-and-upscale." A 720p source downscaled to

360p then SeedVR2'd to 1080p+ looks much better than 720p→1080p straight, because the model rebuilds rather than stretches.

• Rule of thumb: downscale to 0.5× (or to a ~360 to 480p short side) for messy,

low-bitrate, or AI-gen footage; skip the downscale for already-clean, high-bitrate sources where you only want more pixels.

---

Quick local path (no downloads) — per-frame ESRGAN + built-in RIFE

When the user wants a fast result on what's already installed (no SeedVR2 / FlashVSR multi-GB download), use the ESRGAN upscale models most setups already have. Check first with `list_local_models` (common ones: `4x_foolhardy_Remacri`, the best for realistic footage/water/skin, and `4x-ClearRealityV1` for clean/sharp).

• Upscale: `ImageUpscaleWithModel` with a 4× ESRGAN model, then `ImageScale`

back down to a clean 2× (a 4×→2× supersample). That downscale-after step is the single biggest quality lever here. It averages out per-frame noise.

• Interpolate: the built-in `FrameInterpolate` with RIFE v4.26 (see the

Frame-interpolation section; no custom node on 0.26+).

> **Tradeoff: flicker.** ESRGAN upscalers are per-frame (no temporal > awareness), so they can shimmer or flicker on video, most visible on water and > fine detail. The 4×→2× supersample mitigates it; if it still shimmers, that's the > signal to switch the upscale stage to a temporal model (SeedVR2 / FlashVSR > below), which is the real fix. So: per-frame ESRGAN = quick and local; SeedVR2 = > flicker-free and best. Order is unchanged: upscale the real frames first, then > interpolate.

This is the right default for a "do it now, locally" request; reach for the temporal restorers b