Save 4 hours! We auto-setup your workflow! Free!

Drop your workflow.json — we handle every dependency, custom node, and model. Just open the link and run.

Auto-Setup Workflow Json (Free) Now!
ComfyUI > Nodes > ComfyUI-SeedVR2_VideoUpscaler

ComfyUI Extension: ComfyUI-SeedVR2_VideoUpscaler

Repo Name

ComfyUI-SeedVR2_VideoUpscaler

Author
numz (Account age: 5657 days)
Nodes
View all nodes(2)
Latest Updated
2025-12-24
Github Stars
3.0K

How to Install ComfyUI-SeedVR2_VideoUpscaler

Install this extension via the ComfyUI Manager by searching for ComfyUI-SeedVR2_VideoUpscaler
  • 1. Click the Manager button in the main menu
  • 2. Select Custom Nodes Manager button
  • 3. Enter ComfyUI-SeedVR2_VideoUpscaler in the search bar
After installation, click the Restart button to restart ComfyUI. Then, manually refresh your browser to clear the cache and access the updated list of nodes.

Visit ComfyUI Online for ready-to-use ComfyUI environment

  • Free trial available
  • 16GB VRAM to 80GB VRAM GPU machines
  • 400+ preloaded models/nodes
  • Freedom to upload custom models/nodes
  • 200+ ready-to-run workflows
  • 100% private workspace with up to 200GB storage
  • Dedicated Support

Run ComfyUI Online

ComfyUI-SeedVR2_VideoUpscaler Description

ComfyUI-SeedVR2_VideoUpscaler brings SeedVR2 image and video upscaling to ComfyUI, increasing resolution and detail while keeping video frames consistent, with controls for color and memory use.

ComfyUI-SeedVR2_VideoUpscaler Introduction

ComfyUI-SeedVR2_VideoUpscaler brings SeedVR2 video and image upscaling into ComfyUI. You can use it to enlarge a finished image, improve the resolution of video frames, or prepare an image sequence for a higher-resolution export. It is designed to add detail while keeping successive video frames visually consistent.

The extension gives you separate controls for the upscaling model, the image encoder and decoder, and the processing settings. That matters when a project is too large for your graphics card: you can choose a smaller model, process an image in tiles, or move parts of a model out of graphics-card memory. You can also adjust color matching if the enhanced result drifts away from the look of your original.

A version 2.5 walkthrough shows the current four-node workflow described in the supplied documentation. You can also inspect the first workflow example and second workflow example.

How ComfyUI-SeedVR2_VideoUpscaler Works

Think of the process as restoring and enlarging a sequence of pictures:

  1. You supply an image or video frames. In ComfyUI, the main upscaler receives frames as an image batch.
  2. The VAE prepares the frames. A VAE is a model that converts images into a compact working representation and later converts the result back into viewable images.
  3. The DiT enhances them. The diffusion transformer, or DiT, performs the main upscaling work. SeedVR2 uses a one-step diffusion approach.
  4. The VAE turns the enhanced result back into frames. Optional color correction helps the output stay closer to the source.
  5. Your workflow saves the result. Connect the upscaler’s output to the appropriate frame or video-saving nodes.

For video, the extension can consider several frames together rather than treating every frame as an unrelated picture. Imagine checking nearby drawings in an animation before refining one of them: shared context helps details remain more consistent from frame to frame. Batch size determines how many frames are processed together, while temporal overlap helps blend the boundaries between batches.

Upscaling still requires artistic judgment. Compare the output with the source, especially around faces, fine patterns, transparency, and scene changes. More apparent detail is not always a better match for the original artwork.

ComfyUI-SeedVR2_VideoUpscaler Features

The Four ComfyUI Nodes

NodeWhat you use it for
SeedVR2 (Down)Load DiT ModelChoose the main enhancement model and control its graphics-card memory use.
SeedVR2 (Down)Load VAE ModelChoose the image encoder/decoder and enable tiling for large frames.
SeedVR2 Torch Compile SettingsOptionally trade a slower first run for faster repeated processing.
SeedVR2 Video UpscalerConnect your frames and models, then set resolution, frame handling, color correction, and other output controls.

For a basic workflow, connect an image or batch of video frames, the DiT loader, and the VAE loader to the main upscaler. Connect its output to the saving step already used in your ComfyUI workflow. The Torch Compile Settings node is optional.

Resolution and Frame Handling

  • resolution sets the target size of the shortest image edge, in pixels. The other edge scales to preserve the original proportions. The documented default is 1080.
  • max_resolution caps the size of either edge. Its documented default, 0, means no cap. A cap can help when a very wide or tall image would otherwise become too large to process.
  • batch_size sets how many frames the model handles together. Use values following 4n + 1: 1, 5, 9, 13, 17, and so on. The documented default is 5. Use 1 for a single image or when video-frame consistency is not needed; for video, the documentation recommends at least 5. Larger batches can improve temporal context but need more graphics-card memory.
  • uniform_batch_size pads a short final batch so it is processed at the same size as earlier batches. This can help avoid an uneven-looking ending, at a small additional memory cost.
  • temporal_overlap blends frames at batch boundaries to reduce visible transitions. Its documented range is 0–16 frames, with 0 as the default.
  • prepend_frames temporarily adds reversed frames at the beginning to reduce start-of-video artifacts. The added frames are removed afterward. Its documented range is 0–32, with 0 as the default.
  • seed controls reproducibility. With the same inputs and settings, the same seed should produce the same result; the documented default is 42.

For example, start a short video with batch_size=5. If you notice a change in appearance where batches meet, try a small temporal_overlap. If the processing runs out of memory, address memory use before dropping to batch_size=1, since that also gives up the intended multi-frame context.

Color and Detail Controls

The main node offers these color_correction choices:

SettingIntended effect
labPerceptual color matching that aims to retain the source colors while preserving detail; recommended in the documentation for high fidelity.
waveletNatural-looking color adjustment with good detail preservation.
wavelet_adaptiveWavelet-based adjustment with targeted saturation correction.
hsvSaturation matching that takes hue into account.
adainStatistical color and style transfer.
noneNo color correction.

The supplied documentation calls LAB a recommended option but lists wavelet as the main node’s default. If the colors of an upscaled shot feel different from the source, compare wavelet and lab on a short section before processing the full video.

Two optional noise controls can help with unwanted artifacts:

  • input_noise_scale adds a controlled amount of noise to the incoming frames. It defaults to 0.0; the documentation suggests trying 0.1–0.3 for artifacts at very high output resolutions.
  • latent_noise_scale adds noise within the model’s working representation. It also defaults to 0.0; the documentation suggests trying 0.05–0.15 if input noise does not help or detail looks excessive.

Change one setting at a time and compare the same frame or short clip. That makes it easier to tell whether an adjustment actually improved your result.

Memory and Speed Controls

BlockSwap moves some DiT model blocks between the GPU and an offload device while processing. It can make a large model usable with less graphics-card memory, but transfers may slow the run. Set offload_device to cpu or another GPU before using blocks_to_swap; 0 disables swapping. You can also enable swap_io_components for additional savings. On Apple Silicon Macs, BlockSwap is automatically disabled because CPU and GPU share unified memory.

VAE tiling divides large frames into smaller pieces during encoding, decoding, or both. Enable encode_tiled if memory runs out during encoding, or decode_tiled if it runs out during decoding. The documented tile-size default is 1024 pixels and tile-overlap default is 128 pixels for each phase. Smaller tiles can reduce memory use; more overlap can help conceal tile seams, but increases processing work.

Offloading and caching offer another tradeoff. A model loader’s offload_device determines where its model rests when it is not actively processing. Its cache_model option keeps the model loaded between workflow runs and requires an offload device. The main node’s separate offload_device controls intermediate data between processing phases; its documented default is cpu.

Attention modes control an internal calculation used by the DiT. sdpa is the default PyTorch option. Flash Attention 2/3 and SageAttention 2/3 are available for supported hardware and software, with fallback behavior when an optional backend is unavailable. If you are unsure which to choose, start with sdpa.

Torch compilation is optional. The author reports potential speedups of 20–40% for the DiT and 15–25% for the VAE, but the first run takes time to compile. It is most useful when you will process many batches, long videos, or many tiles; it may not pay off for one image. The documented starting configuration is the inductor backend, default mode, and fullgraph=False.

The extension also supports RGB and RGBA inputs, including transparency handling; progress reporting; and an enable_debug option that displays processing and memory details when you need to diagnose a problem. Its standalone command-line mode supports folder processing, long-video streaming, and multi-GPU processing, though the ComfyUI nodes are the more visual way to work.

ComfyUI-SeedVR2_VideoUpscaler Models

The DiT model makes the main creative and performance difference. The VAE model prepares and reconstructs the frames. In general, 3B DiT models are the lighter choice, while 7B models demand more memory and can provide higher-quality results. Precision and quantization affect the memory-versus-quality tradeoff: FP16 is the higher-precision choice; FP8 uses less memory; GGUF Q8 and Q4 provide progressively more aggressive memory savings.

Model or family named in the documentationWhen to consider it
seedvr2_ema_3b_fp16.safetensorsA 3B FP16 choice when you have sufficient graphics-card memory and want the documented best-quality option in the 3B family.
seedvr2_ema_3b_fp8_e4m3fn.safetensorsA lower-memory 3B alternative with documented good quality.
seedvr2_ema_3b-Q8_0.ggufAn 8-bit GGUF 3B option with documented good quality; useful when FP16 needs too much memory.
seedvr2_ema_3b-Q4_K_M.ggufA 4-bit GGUF 3B option for stronger memory savings, with a greater quality tradeoff.
seedvr2_ema_7b_fp16.safetensorsA higher-memory 7B FP16 option for the documented best quality in its family.
seedvr2_ema_7b_fp8_e4m3fn_mixed_block35_fp16.safetensorsA mixed-precision 7B option designed to reduce artifacts while using less memory than full FP16.
seedvr2_ema_7b-Q4_K_M.ggufA lower-memory 7B choice when you want to try the larger model but cannot accommodate its FP16 version.
seedvr2_ema_7b_sharp_*A family of 7B variants intended to produce a sharper-looking result. Compare them with a standard 7B model if natural texture matters more than apparent sharpness.
ema_vae_fp16.safetensorsThe default, recommended VAE listed in the documentation.

The readme also mentions additional 7B sharp models and mixed FP8 variants but does not provide a complete filename-by-filename inventory. Check the model choices presented by your loader. The supplied documentation lists model collections at numz/SeedVR2_comfyUI, AInVFX/SeedVR2_comfyUI, and cmeka/SeedVR2-GGUF.

As a practical starting point, try a 3B model for faster previews or limited memory. Compare a 7B model on a short, representative clip when final quality is the priority. Evaluate hair, fabric, fine lines, faces, and motion rather than judging only a single still frame.

What's New with ComfyUI-SeedVR2_VideoUpscaler

Version 2.5.0, November 7, 2025, was a breaking workflow change: the nodes and command-line parameters were redesigned. Older single-node workflows need to be recreated for the four-node architecture. The version 2.5 tutorial is the relevant walkthrough for that design.

The following release history summarizes the changes included in the supplied readme, newest listed release first. It describes those supplied notes rather than claiming to verify later releases.

ReleaseWhat changed and why it matters
2.5.24 · December 24, 2025Restored Apple Silicon MPS cache clearing after VAE encoding and decoding, addressing a memory-leak regression.
2.5.23 · December 24, 2025Hardened .pth model loading against malicious code execution; fixed FFmpeg writer hangs, GGUF VAE convolution support, VAE-slicing crashes, LAB color-transfer errors, and compatibility issues. Also improved Apple Silicon memory use and the PyTorch 2.9+ memory workaround.
2.5.22 · December 13, 2025Added a standalone FFmpeg video-output option with 10-bit x265 encoding, which can reduce visible gradient banding. Fixed Apple Silicon interpolation and improved cross-platform histogram matching.
2.5.21 · December 12, 2025Fixed GGUF dequantization on MPS and reduced unnecessary Apple Silicon data transfers and cleanup work.
2.5.20 · December 12, 2025Expanded Flash Attention and SageAttention support with fallbacks; improved Apple Silicon compatibility and handling of broken optional attention packages; addressed an AMD ROCm dependency conflict.
2.5.19 · December 10, 2025Improved graphics-card memory reporting and backend detection, reinforced attention fallback, removed unused attention code, and reversed the physical-VRAM limit enforcement introduced in 2.5.14.
2.5.18 · December 9, 2025Added chunked standalone processing for long videos, more memory-efficient multi-GPU streaming, and a fix for large-video transfer errors.
2.5.17 · December 5, 2025Improved detection of bfloat16 support on older GPUs.
2.5.16 · December 5, 2025Added an older-GPU fallback, addressed a quality regression, and exposed environment information in debug output.
2.5.15 · December 3, 2025Fixed Apple Silicon and autocast compatibility issues, improved memory reporting, and addressed a Triton/bitsandbytes compatibility error.
2.5.14 · December 1, 2025Improved MPS device handling and reported GPU-memory overflow or swapping. Its VRAM-limit enforcement was later reversed in 2.5.19.
2.5.13 · November 30, 2025Fixed a newer-Triton import error, added a fallback for long-video memory pressure, and fixed a macOS command-line watermark error.
2.5.12 · November 28, 2025Reversed an operation that had introduced color artifacts on some images.
2.5.11 · November 28, 2025Added a cuDNN attention option; reduced long-video decoding memory spikes; fixed LAB tile-boundary artifacts and color-reference alignment; improved MPS, multi-GPU, debugging, and memory handling.
2.5.10 · November 13, 2025Improved reproducibility with the same seed, repaired model caching with BlockSwap, and expanded model-path debugging.
2.5.9 · November 12, 2025Fixed tile-debug and macOS loading errors, improved Windows log visibility, and added visible version information to help with troubleshooting.
2.5.8 · November 10, 2025Fixed duplicate Windows folder processing, clarified standalone output locations, and preserved transparency in standalone PNG upscaling.
2.5.7 · November 10, 2025Improved compatibility of a three-dimensional convolution memory workaround across platforms.
2.5.6 · November 9, 2025Restored a more natural look for the 7B model after an optimization caused an overly plastic appearance; fixed a RAM leak affecting long videos.
2.5.4 · November 8, 2025Fixed an AdaIN color-correction error and an AMD ROCm convolution error.
2.5.3 · November 8, 2025Fixed Apple Silicon device selection and a Windows error involving MPS detection.
2.5.0 · November 7, 2025Introduced the four-node ComfyUI design, shared model caching, RGBA support, flexible resolution handling, new batch controls, GGUF support, Apple Silicon and AMD improvements, and substantial speed, color, and memory-management work. Existing workflows need recreation.
August 7, 2025Improved debug logging, FP8 handling, model discovery and caching, and memory management.
July 17, 2025Added two sharper-output 7B models.
July 11, 2025Announced an in-depth AInVFX tutorial covering the earlier workflow, BlockSwap, and transparent image sequences.
July 3, 2025Added standalone multi-GPU operation.
June 30, 2025Reduced memory use, fixed a 3B memory leak, made processing interruptible, and removed the Flash Attention dependency.
June 24, 2025Reported processing speed improvements of up to four times.
June 22, 2025Added FP8 compatibility alongside speed and memory improvements.
June 20, 2025Initial release.

The source notes also date a BlockSwap integration entry September 7, 2025. It introduced a memory-saving option especially relevant to lower-VRAM GPUs.

Troubleshooting ComfyUI-SeedVR2_VideoUpscaler

Turn on enable_debug in the main node before diagnosing an unsuccessful run. The processing phase shown in the logs can tell you whether the problem occurred while preparing frames, enhancing them, or turning them back into images. The node screenshots can help you locate the relevant settings.

“Out of memory” during upscaling

  1. Check whether the failure occurs in the DiT upscaling phase.
  2. Try a lower-memory DiT variant, such as FP8 or GGUF.
  3. On a supported non-Mac setup, set the DiT loader’s offload_device to cpu, then increase blocks_to_swap gradually. The documentation suggests starting at 16; higher values save more memory but take longer.
  4. If needed, enable swap_io_components.
  5. Reduce the requested resolution or set max_resolution if the output is still too large. Keep a video batch of at least 5 where possible if you need multi-frame consistency.

On Apple Silicon, BlockSwap is disabled automatically. Focus on model choice, resolution, and VAE tiling instead.

“Out of memory” during encoding or decoding

  1. Read the debug output to identify Encoding or Decoding.
  2. In the VAE loader, enable encode_tiled for an encoding failure or decode_tiled for a decoding failure.
  3. If memory still runs out, lower the corresponding tile size from its documented 1024-pixel default; the readme suggests trying 768 or 512.
  4. Test a short section before committing to a full video.

Visible tile seams or changes between frame batches

  1. If you see lines between image tiles, increase the relevant VAE tile overlap from its documented 128-pixel default and compare the result.
  2. If you see a change in appearance over time where frame batches meet, try temporal_overlap.
  3. If only the last part of a video looks different, try uniform_batch_size, particularly when using large batches.
  4. If the first frames have artifacts, try a small prepend_frames value.
  5. Recheck the result in motion; a boundary may be hard to judge from one still frame.

Output colors or textures do not match the source

  1. Compare the same short clip with wavelet and lab color correction. Try none as a reference when you need to see what the model produced without correction.
  2. If a high-resolution result has artifacts, try a small input_noise_scale value within the documented 0.1–0.3 suggestion.
  3. If that does not help, compare a small latent_noise_scale value within the documented 0.05–0.15 suggestion.
  4. If a 7B sharp model looks too harsh for the artwork, compare it with a non-sharp model. Change one setting per test so you can identify the cause.

A workflow or optional speed setting fails

  1. If the workflow was built before version 2.5.0, recreate it with the separate DiT loader, VAE loader, and main upscaler. Do not expect the older single-node layout to match.
  2. If an optional attention mode fails, return attention_mode to sdpa, the documented default, and test again.
  3. If compilation fails or makes a short task slower overall, disconnect the optional Torch Compile Settings node and test the basic workflow.
  4. Keep the displayed extension version and debug output available when seeking help in the project’s Issues or Discussions.

Frequently Asked Questions

Can I upscale a single image?
Yes. Set batch_size=1 when processing one image. Multi-frame consistency is not needed for a still.

What batch sizes are valid?
Use the documented 4n + 1 sequence: 1, 5, 9, 13, 17, and so on. For video consistency, the documentation recommends at least 5.

Which model should I try first with limited graphics-card memory?
Start with a 3B FP8 or GGUF model, then consider offloading and VAE tiling as needed. The documentation presents GGUF Q4_K_M with BlockSwap and tiling as an option for systems with 8 GB of VRAM or less, although actual capacity depends on your frames and settings.

Will a sharper model always make better art?
No. A sharp variant emphasizes apparent detail; compare it against a standard model for the texture and style of your particular shot.

Does the extension preserve transparency?
The supplied documentation describes RGB and RGBA support and edge-guided alpha upscaling. Check your saving workflow as well when exporting transparent results.

Why is the first run with torch compilation slow?
Compilation performs preparatory work on the first run. Its reported speed gains are intended for repeated work, such as long videos, many batches, or many tiles.

Can I process a long video?
The extension describes memory-conscious processing for videos of varying lengths. Its standalone mode also offers chunked streaming for long files. Processing time and memory needs still depend on resolution, model choice, and settings.

Learn More about ComfyUI-SeedVR2_VideoUpscaler

  • Version 2.5 deep-dive video: Start here for the four-node workflow, model choices, low-memory strategies, transparency, and image and video examples.
  • Earlier tutorial: Useful background on BlockSwap and memory management, but it shows the older single-node interface, not the version 2.5 layout.
  • Project source and documentation: Consult the author’s repository for the extension and its supporting materials.
  • SeedVR project: Read about the underlying SeedVR work.
  • Project Discussions: Ask workflow questions and learn how other artists use the extension.
  • Project Issues: Check known problems or report a reproducible bug. Include the version, model, settings, processing phase, and relevant debug output.

ComfyUI-SeedVR2_VideoUpscaler Related Nodes

RunComfy
Copyright 2025 RunComfy. All Rights Reserved.

RunComfy is the premier ComfyUI platform, offering ComfyUI online environment and services, along with ComfyUI workflows featuring stunning visuals. RunComfy also provides AI Models, enabling artists to harness the latest AI tools to create incredible art.