FlashVSR UpRes in ComfyUI: Real-Time 2–3x Upscaling

Upscaling video and restoring detail is a common need in AI video workflows. FlashVSR introduces a fast, one-step approach for video super-resolution, and it is particularly interesting for realtime streaming and consumer-grade hardware. I tested it alongside two current alternatives inside ComfyUI to see how it performs now and what to expect.

This article walks through what FlashVSR is, how to run it, the model files you need, current limitations, and how it compares with SeedVR2 and a Wan 2.2 detailer pipeline. I keep the setup and results in the same order they were explored, with clear steps and notes on quality, speed, and tradeoffs.

What Is FlashVSR?

FlashVSR is a video super-resolution framework built on the Wan 2.1 1.3B model. Its standout traits are single-step sampling and a focus on realtime streaming upscales (2x–3x) from low-resolution video. It aims to be friendly to consumer PCs and claims significant speed gains over typical diffusion-based upscalers.

A key technical ingredient in the original implementation is block-sparse attention. This attention method differs from the dense attention used in many video models and is central to the quality FlashVSR showcases in its project materials.

FlashVSR Overview

FlashVSR targets quick, large upscales for streaming and local workflows. You can run it via the official repository or inside ComfyUI. Inside ComfyUI, there are two distinct paths: a fully implemented setup that requires block-sparse attention and an easier wrapper that currently omits the specialized attention, which affects quality.

Below is a quick overview of how it fits into a practical workflow and how it compares to two other methods available in ComfyUI.

Topic	Summary
Purpose	One-step video super-resolution (2x–3x), optimized for speed and streaming
Base model	Wan 2.1, 1.3B parameters
Core method	Block-sparse attention (in the official and full ComfyUI implementation)
Run options	Official repo; ComfyUI full node set; ComfyUI “Wan Videos” wrapper (limited)
Model files	Base model (~5 GB), VAE, LQ project files, optional TC decoder
Current wrapper status	No block-sparse attention or streaming features yet; quality limited
Alternatives in ComfyUI	SeedVR2 (ByteDance) and a Wan 2.2 detailer V2V pipeline
Best current quality (tests)	Wan 2.2 detailer pipeline, with low denoise and modest upscale
Best current speed	FlashVSR (one-step) via the wrapper, but with quality constraints

Key Features of FlashVSR

• Single-step sampling for rapid outputs
• Consumer PC–friendly 1.3B base model
• Targeted for streaming upscales (2x–3x)
• Claims ~12x speed over typical diffusion models in similar tasks
• Designed around block-sparse attention for its core video generation

Ways to Run FlashVSR

There are two primary paths: the official codebase and ComfyUI. ComfyUI itself offers two distinct routes, each with different tradeoffs.

Method 1: Official Repository

• Download the code and model weights from the project repository.
• The code requires block-sparse attention to function correctly.
• Setup includes additional components such as a VAE and auxiliary model files.
• This path matches the project’s intended implementation and quality.

Method 2: ComfyUI

ComfyUI offers a full implementation pathway and a more accessible wrapper. The difference between them is significant.

ComfyUI FlashVSR (Full)

• Uses the full FlashVSR model weights and block-sparse attention.
• Requires installing block-sparse attention support in your ComfyUI environment.
• Also requires DeepSpeed in many setups.
• Once installed, it exposes a proper pipeline inside ComfyUI that mirrors the official implementation.
• Delivers the full potential of FlashVSR when configured correctly.

ComfyUI “Wan Videos” Wrapper (Limited)

• Recently added FlashVSR support but without block-sparse attention or streaming features.
• Converts weights into SafeTensor files and provides custom nodes with simplified naming.
• Useful for quick tests and for exploring the one-step sampling flow.
• Current results do not match the original code due to missing attention implementation.
• Practical for experimentation; performance expected to improve with updates.

Alternative Upscaling Methods in ComfyUI

There are two strong alternatives to consider right now inside ComfyUI if you want refined quality and detail.

SeedVR2 (ByteDance)

• Effective for upscaling to HD.
• Some flicker can occur, often tied to edge sharpening.
• A common workflow is to upscale with SeedVR2 and then finish with a dedicated upscaler to 4K to clean up artifacts.

Wan 2.2 Detailer (Video-to-Video)

• Uses the Wan 2.2 low-noise model as the base.
• Works as a video-to-video pipeline, typically scaling by about 1.5x while restoring detail.
• In tests, this method consistently refined faces, textures, and background elements better than the current FlashVSR wrapper and SeedVR2.
• With a low denoise setting (around 0.2), it preserves temporal stability and structure while boosting clarity.

Setting Up FlashVSR in ComfyUI (Wrapper Path)

If you want to try FlashVSR inside ComfyUI without installing block-sparse attention, the wrapper is the easiest place to start. Keep in mind the quality limitations described above.

Required Model Files

You’ll need three sets of files for the wrapper:

• Base model
  • FlashVSR base model derived from Wan 2.1 (1.3B)
  • Load this in the model loader as the base in the wrapper
• LQ Project files
  • Additional model components commonly labeled as “LQ project”
  • Typically packaged with clear names in the wrapper’s repository
• Decoder (TC decoder or Wan 2.1 VAE)
  • The TC decoder is a lighter, faster option
  • The original Wan 2.1 VAE yields higher quality but requires more resources

The wrapper repository often repackages raw file names into more readable labels so you can recognize them quickly during setup.

Where to Place Files

• Base model and LQ project files: follow the wrapper’s model directory structure and load via the corresponding loaders in the workflow.
• Decoder:
  • Place the TC decoder inside ComfyUI’s VAE folder.
  • In your workflow, route the latent output to “VAE Decode” using the TC decoder or the Wan 2.1 VAE.

Step-by-Step: Running FlashVSR in the Wrapper

1. Install the wrapper and restart ComfyUI so the nodes appear.
2. Place the base model and LQ project files in the correct folders, following the wrapper’s structure.
3. Put the TC decoder in the VAE folder (or prepare the Wan 2.1 VAE if you prefer higher quality).
4. Load the provided example workflow for FlashVSR in the wrapper.
5. In the model loader nodes, select:
   • Base: FlashVSR base (Wan 2.1 1.3B)
   • LQ project files
   • Decoder: TC decoder or Wan 2.1 VAE
6. Set the output resolution target (2x–3x upscale recommended for this method).
7. Run the pipeline with single-step sampling.

Tip: The wrapper currently lacks block-sparse attention and streaming support, so image contrast may be higher and detail retention may lag behind the official implementation.

Decoder Options: TC Decoder vs. Wan 2.1 VAE

• TC decoder
  • Pros: Faster, lighter
  • Cons: Lower clarity compared to the full VAE
• Wan 2.1 VAE
  • Pros: Higher quality and better detail retention
  • Cons: Heavier load on resources

If you prioritize speed and quick previews, the TC decoder is convenient. For final renders, the Wan 2.1 VAE is recommended for better clarity.

Quality, Speed, and Expectations

FlashVSR’s current wrapper implementation produces very fast outputs due to single-step sampling, but the absence of block-sparse attention affects quality. Expect higher contrast and fewer restored details compared to what the project showcases with the full attention method.

Speed and Single-Step Sampling

• The wrapper demonstrates true single-step video generation.
• Outputs render quickly, which is excellent for iteration and testing.
• For final quality, the official repo or a full ComfyUI implementation of block-sparse attention will be necessary.

Comparison: FlashVSR vs. SeedVR2 vs. Wan 2.2 Detailer

I tested the same input video with three pipelines inside ComfyUI. Here’s how they stack up in the order they were explored.

FlashVSR (Wrapper, current state)

• Very fast one-step outputs.
• Higher contrast, limited detail restoration due to missing block-sparse attention.
• Good for rapid upscale previews and quick turns but not yet matching the quality shown in the project’s examples.

SeedVR2 (ByteDance)

• Upscales to HD with reasonable clarity.
• Some flicker appears, commonly from edge sharpening.
• A common approach is to take the SeedVR2 output and then upscale to 4K using a dedicated upscaler to reduce flicker and refine details.

Wan 2.2 Detailer (Video-to-Video)

• Strong detail refinement across faces, backgrounds, and textures.
• Background elements like text and charts become cleaner and more legible.
• Maintains improvements across frames, with low denoise (~0.2) for stability.
• Provides the best visual quality among the three in current ComfyUI workflows.

Side-by-Side Summary

Method	Strengths	Weaknesses	Best Use Now
FlashVSR (wrapper)	Very fast one-step sampling; easy to run	No block-sparse attention; higher contrast; less detail	Quick tests and previews
SeedVR2	Solid HD upscaling; familiar to many users	Flicker from edge sharpening; may require post-upscaling	Intermediate step before final 4K upscale
Wan 2.2 detailer	Best detail restoration; stable faces and textures	Slower than one-step methods	Highest-quality enhancement inside ComfyUI right now

Notes on Full FlashVSR Implementation

• The project’s examples reflect the intended quality with block-sparse attention and the official model setup.
• Those “crystal-clear” upscaling results hinge on the full attention method and proper configuration.
• The wrapper author notes that sparse attention and streaming are not implemented yet; thus, current wrapper results will not match the original.

Frame Count and Practical Limits

• In current experiments, pipelines can handle a few hundred frames comfortably.
• For longer sequences, plan to process in chunks and maintain consistent settings across batches.

Additional Trials and Observations

• Upscaling to 2K with the wrapper did not add detail beyond the original; it primarily increased resolution.
• In some scenes, the wrapper output raised contrast noticeably (makeup tones, eye shadow), which can overemphasize color separation.
• Treat FlashVSR (wrapper) as a fast upscaler rather than a detail enhancer until the attention method is supported.

Practical Workflow Recommendations

You can combine these methods to get practical results today without waiting for updates.

Approach 1: Quality First, Then Scale

• Use the Wan 2.2 detailer pipeline to refine textures, faces, and backgrounds at a modest upscale (e.g., 1.5x).
• Keep denoise low (~0.2) for stability and consistency.
• Once details are improved, pass the output through a final upscaler if you need 2K or 4K.

Approach 2: SeedVR2 + Final Upscaler

• Run SeedVR2 to boost to HD.
• Address flicker and sharpen artifacts by running a high-quality final upscaler to 4K.
• This two-stage process often cleans up edges and stabilizes fine features.

Approach 3: FlashVSR (Wrapper) + Detail Enhancer

• If you need rapid iteration, run FlashVSR (wrapper) for quick 2x–3x previews.
• Follow with a detail-oriented upscaler or the Wan 2.2 detailer to add clarity.
• This preserves speed early in the workflow while still allowing for a quality pass later.

Step-by-Step: Wan 2.2 Detailer V2V Setup

This method has delivered the most consistent gains in clarity in current ComfyUI tests.

1. Load the Wan 2.2 low-noise model as your base.
2. Set up a video-to-video process with an initial upscale around 1.5x.
3. Keep denoise low (about 0.2) to retain structure while enhancing detail.
4. Render to 720p or 1080p depending on your GPU and timeline.
5. Optionally, run a final upscale to 2K or 4K with your preferred upscaler.

Tips:

• Use consistent parameters across cuts to maintain continuity.
• Check faces, text, and background patterns at multiple timestamps to ensure stability.

Step-by-Step: SeedVR2 with Cleanup

For users who already rely on SeedVR2, this is a practical path.

1. Run SeedVR2 to upscale the source to HD.
2. Review for flicker or excessive edge sharpening.
3. Pass the result into a high-quality upscaler to reach 2K or 4K.
4. Inspect motion-heavy regions and fine lines; adjust sharpening or noise reduction as needed.

Step-by-Step: FlashVSR (Wrapper) Quick Test

Use this when you want to test framing, scale, or motion handling quickly.

1. Load the FlashVSR base model (Wan 2.1 1.3B) in the wrapper.
2. Add the LQ project files as required by the workflow.
3. Select the TC decoder for speed or the Wan 2.1 VAE for better clarity.
4. Set an upscale target (2x–3x).
5. Run with single-step sampling for fast output.
6. If contrast is too high, reduce post-sharpening or adjust color grading after the render.

FAQs

• Does FlashVSR add detail?
  In the wrapper’s current state, it primarily increases resolution. The full implementation with block-sparse attention is required to match the project’s showcased clarity.

• Can I use the Wan 2.1 VAE with FlashVSR?
  Yes. It often produces better clarity than the lightweight TC decoder, at the cost of speed.

• Why does the wrapper look different from the project examples?
  The wrapper does not include block-sparse attention or streaming features yet. Those omissions affect detail and temporal behavior.

• Which method gives the best quality today inside ComfyUI?
  The Wan 2.2 detailer V2V pipeline has produced the most consistent quality in tests, especially for faces and fine textures.

Conclusion

FlashVSR is fast and practical, with true single-step sampling that makes quick iteration easy. The official implementation relies on block-sparse attention, and that is where its best results come from. The current ComfyUI wrapper is a useful preview but does not yet match the original code’s quality.

If you need refined detail today inside ComfyUI, the Wan 2.2 detailer pipeline remains the most reliable choice. SeedVR2 is a solid upscaler for HD, often followed by a high-quality 4K pass to manage flicker. FlashVSR’s wrapper is best for speed tests and early iterations; for final upscales and clarity, pair it with a detail-oriented pass or wait for a wrapper update that adds the required attention method.

The standout trait of FlashVSR remains its one-step generation. As soon as the attention method is available in the wrapper or you install the full implementation, FlashVSR will better align with its intended quality while keeping its hallmark speed.