Upscaling video to 4K used to mean leaving your PC running overnight. ReCaVSR changes that. It is a new one-step 4x video super-resolution model from researchers at USTC, and it now runs natively inside ComfyUI through a custom node pack that landed this week.
In this guide I cover what ReCaVSR is, which files to download and where they go, how to install the nodes, every setting on the upscale node, real VRAM and speed numbers, how it compares with RelayVSR and SeedVR2, and fixes for the problems you are most likely to hit.
- What: a one-step 4x video upscaler built on Wan2.2 TI2V-5B. It works through the video in blocks (21 frames, then 8 at a time) with a single denoising step each, then a fast FlashDecoder streams frames out.
- Nodes: PedroMarinhoDev/ComfyUI-ReCaVSR. Install from ComfyUI Manager or with
comfy node install comfyui-recavsr. - Files: put
transformer_int8_convrot.safetensors(6.27 GB) or the bf16transformer.safetensors(10.6 GB), plusprompt.safetensorsandflashdecoder.safetensors, inComfyUI/models/recavsr/. - VRAM: about 12 GB for 360p to 1440p portrait clips with int8; about 19-21 GB for 960×480 to 3840×1920.
- Speed: a 149-frame clip to 3840×1920 took 36 s on an RTX 4090 with int8. You need Triton for those speeds.
New to ComfyUI? My ComfyUI beginner guide covers install, models, nodes and fixes in one place.
What ReCaVSR Is
ReCaVSR is a video super-resolution (VSR) model from a USTC research team. The code lives at kopperx/ReCaVSR and the weights at kopper/ReCaVSR on Hugging Face. The paper is on arXiv as 2609.37831.
Most diffusion upscalers run many denoising steps per frame, which is why they are slow. ReCaVSR was trained to do the job in one step. Here is how it works in plain words:
- Base model: it is built on Wan2.2 TI2V-5B, the small Wan 2.2 video model, so it already understands motion and how things look from frame to frame.
- Blocks of frames: it handles the first block of 21 frames, then moves on in blocks of 8. Each block gets a single step. A cache carries information forward, so details stay steady between blocks instead of flickering.
- FlashDecoder: instead of the heavy Wan VAE, a small 229 MB decoder turns the result back into pixels and streams frames out as it goes. The node author measured it at 25-40x faster than the VAE.
- Scale: it was trained for 4x. The node also documents 2x and 1.5x output.
The ComfyUI port by PedroMarinhoDev added an int8 version of the transformer, Triton kernels, KV offload for smaller cards, and a ready template. It keeps your clip’s audio and frame rate.
Licences: the node code is GPL-3.0 and the ported model code is Apache-2.0. The weights repo does not state a licence at the time of writing, so check it before using the output commercially.
Hardware Requirements
| Item | Requirement | Notes |
|---|---|---|
| GPU | NVIDIA, compute capability 7.5+ for int8 | RTX 20 series and newer. Fast kernels need 8.0+ (RTX 30 series and newer). |
| VRAM | About 12 GB for short 1440p portrait clips | 19-24 GB for 4K-wide output. KV offload helps on 8-12 GB cards. |
| Triton | Strongly recommended | Without it, the node falls back to much slower code (common on Windows). |
| Disk | About 6.5 GB (int8) or 11 GB (bf16) | Plus 2.6 GB if you also want the Wan2.2 VAE. |
| Tested on | ComfyUI 0.44.0, PyTorch 2.14.1, CUDA 13.2, Linux | Newer ComfyUI should work. Update first if nodes fail to load. |
If your ComfyUI is older, follow my guide to updating ComfyUI first.
Install the ComfyUI-ReCaVSR Nodes
You have three ways to install. Pick one.
Option 1: ComfyUI Manager (easiest)
- Open Manager and click Custom Nodes Manager.
- Search for
ReCaVSR video super-resolution. - Click Install, then restart ComfyUI.
No Manager yet? See how to install ComfyUI Manager.
Option 2: comfy-cli
comfy node install comfyui-recavsrOption 3: git clone
cd ComfyUI/custom_nodes
git clone https://github.com/PedroMarinhoDev/ComfyUI-ReCaVSR
cd ComfyUI-ReCaVSR
pip install -r requirements.txtUse the same Python that runs ComfyUI. For the portable Windows build that means python_embeded\python.exe -m pip install -r requirements.txt from the ComfyUI folder.
Install Triton (for speed)
On Linux, Triton normally comes with PyTorch. On Windows, install the community triton-windows package that matches your PyTorch version:
python_embeded\python.exe -m pip install -U "triton-windows"Restart ComfyUI and check the console. The node prints a warning if it falls back to the slow path.
Model Files and Folders
Create the folder ComfyUI/models/recavsr/ and put these files in it:
| File | Size | Folder | Source |
|---|---|---|---|
transformer_int8_convrot.safetensors (recommended) |
6.27 GB | models/recavsr/ |
PedroMarinhoDev/ReCaVSR-ComfyUI |
transformer.safetensors (bf16, full quality) |
10.6 GB | models/recavsr/ |
kopper/ReCaVSR |
prompt.safetensors |
4.2 MB | models/recavsr/ |
kopper/ReCaVSR |
flashdecoder.safetensors |
229 MB | models/recavsr/ |
kopper/ReCaVSR |
wan2.2_vae.safetensors (optional) |
about 2.6 GB | models/vae/ |
Only for decoder = vae |
You need only one transformer. Pick int8 unless you have 24 GB and want the original weights.
Download from the command line with the Hugging Face CLI. Run these from your ComfyUI/models/ folder:
hf download kopper/ReCaVSR prompt.safetensors flashdecoder.safetensors --local-dir recavsr
hf download PedroMarinhoDev/ReCaVSR-ComfyUI recavsr/transformer_int8_convrot.safetensors --local-dir .The second command keeps the recavsr/ folder from the repo, so the file lands in models/recavsr/. Your folder should look like this:
ComfyUI/models/recavsr/
transformer_int8_convrot.safetensors
prompt.safetensors
flashdecoder.safetensorsRun the 4x Template Workflow
The node pack ships a template, so you do not need to build anything.
- Open Templates (or Workflow, Browse Templates) and find ComfyUI-ReCaVSR.
- Open recavsr_video_4x. It is three steps: Load Video, then ReCaVSR Upscale Video, then Save Video. A ReCaVSR Model Loader feeds the upscale node.
- In the Model Loader, choose your transformer file.
- In Load Video, pick your clip. Start with a short one (5-6 seconds) to test.
- Click Run. The first run takes longer, because Triton compiles kernels for your output size (10-30 seconds). Later runs at the same size skip that.
The output keeps the source frame rate and audio track. That makes it easy to drop straight into an edit.
Every Setting Explained
| Setting | Options | What it does | Start with |
|---|---|---|---|
| scale | 4, 2, 1.5 | Output size. The model was trained at 4x; 2x and 1.5x are documented by the node. | 4 |
| color_fix | none, adain, wavelet | Pulls colours back toward the source if the output drifts. Wavelet keeps fine detail; adain matches overall tone. | wavelet |
| seed | any number | Small changes to fine texture. Keep it fixed when comparing settings. | fixed |
| decoder | flashdecoder, vae | FlashDecoder is 25-40x faster and uses less memory. VAE needs the extra Wan2.2 VAE file. | flashdecoder |
| kernels | fast, exact | Fast uses Triton kernels (compute 8.0+). Exact is the reference maths, slower. | fast |
| kv_offload | on, off | Moves the frame cache to system RAM to save VRAM, at some speed cost. | off; on for 8-12 GB |
VRAM and Speed Numbers
These figures come from the node author’s own tests. Times are listed as RTX 3090 / RTX 4090.
| Job | Weights | Peak VRAM | Time (3090 / 4090) |
|---|---|---|---|
| 960×480 to 3840×1920, 149 frames | bf16 | 23.5 GB | 111 s / 49 s |
| 960×480 to 3840×1920, 149 frames | int8 | 18.6 / 21.2 GB | 67 s / 36 s |
| 360×360 to 1440×1440, 180 frames | bf16 | 15.7 GB | 33 s / 17 s |
| 360×360 to 1440×1440, 180 frames | int8 | 11.7 GB | 23 s / 15 s |
The author also limited memory to simulate 12 GB and 8 GB cards. The int8 portrait job still finished in about 23 s and 27 s.
How VRAM grows: working memory needs about 2.6 MB per 32×32 tile of output. That is roughly 5 GB of activations at 1440×1440 and 18 GB at 3840×1920, on top of the weights. So the biggest lever is output size, not clip length.
What this means for your card:
- 8-12 GB: int8 plus kv_offload, small inputs (up to about 360p to 1440p).
- 16 GB: int8 for 1080p-class output is comfortable.
- 24 GB+: 4K-wide output with int8, or bf16 if you want the original weights.
ReCaVSR vs RelayVSR vs SeedVR2
There is no official side-by-side test of these three, so treat this as a guide to what each was built for, not a quality ranking.
| ReCaVSR | RelayVSR | SeedVR2 | |
|---|---|---|---|
| Scale | 4x (2x, 1.5x documented) | 2x | Any target resolution |
| Steps | One step per block | One step, keyframes only (every 15th frame) | One step |
| Base | Wan2.2 TI2V-5B | Wan-based (LightX2V) | Own DiT (3B / 7B) |
| Best for | Low-res clips to 4K fast | Doubling already decent clips | Images and video, flexible sizes |
| Our guide | This page | RelayVSR x2 guide | ComfyUI upscale guide |
A practical approach: try ReCaVSR when you start from a small or AI-generated clip and need a big jump, and keep RelayVSR for a quick 2x on clips that already look clean.
Tips for Best Results
- Upscale AI video at its native size. If your Wan or LTX clip is 480p, upscale the 480p file directly. Do not resize it first.
- Test on 2-3 seconds. Settle on color_fix and seed with a short clip, then run the full one.
- Keep output size in check. VRAM follows output pixels. A 720p source at 4x is 2880p wide, which needs a lot of memory.
- Use wavelet colour fix if skin tones or skies shift.
- Close other GPU apps. Browsers with hardware acceleration and other models in memory take VRAM you need.
- Frame interpolation goes after. If you also want 60 fps, upscale first and interpolate second; see our ComfyUI speed guide for general speed tips.
Troubleshooting
| Problem | Fix |
|---|---|
| ReCaVSR nodes are red or missing | Restart ComfyUI after install. Check the console for import errors and run pip install -r requirements.txt with ComfyUI’s own Python. |
| Model Loader shows no files | Files must be in ComfyUI/models/recavsr/, not in a sub-folder. Refresh the browser after moving them. |
| Very slow, console says Triton not found | Install Triton (triton-windows on Windows) matching your PyTorch, then restart. |
| First run pauses for 10-30 s | Normal. Triton compiles kernels for each new output size once. |
| CUDA out of memory | Switch to int8, turn on kv_offload, or use a smaller input or scale 2. |
| int8 error on an older GPU | int8 needs compute 7.5+ (RTX 20 series or newer). On GTX cards use bf16 with exact kernels, if VRAM allows. |
| “fast” kernels fail on RTX 20 series | Fast kernels need compute 8.0+. Set kernels to exact. |
| Colours look washed out or shifted | Set color_fix to wavelet or adain. |
| decoder = vae fails | Download wan2.2_vae.safetensors into models/vae/, or switch back to flashdecoder. |
| No audio in the output | Make sure the audio output of Load Video is connected to Save Video, as in the template. |
For general node problems, my ComfyUI beginner guide has a full fixes section.
FAQ
Is ReCaVSR free?
The code is open source (GPL-3.0 node, Apache-2.0 ported model code) and the weights are free to download. The weights repo does not list a licence yet, so check before commercial use.
Can I run ReCaVSR on 8 GB of VRAM?
For small jobs, yes. The author’s simulated 8 GB test ran a 360p to 1440p portrait clip with int8 in about 27 seconds. Turn on kv_offload and keep the output size small.
Does it work on AMD or Mac?
The node was tested on NVIDIA with CUDA. The int8 path and fast kernels are built for NVIDIA. AMD and Apple Silicon are not covered by the author’s tests.
Does it keep audio?
Yes. The template passes the audio and frame rate from Load Video to Save Video.
Can it upscale images?
It is a video model. For still images, use the tools in our ComfyUI image upscale guide.
Is it better than SeedVR2?
No one has published a fair head-to-head yet. ReCaVSR is aimed at fast 4x jumps on video; SeedVR2 is more flexible on target size. Try both on a short clip of your own footage.
Sources
- GitHub: PedroMarinhoDev/ComfyUI-ReCaVSR (install, settings, VRAM and speed tests)
- Hugging Face: kopper/ReCaVSR (bf16 transformer, prompt, FlashDecoder)
- Hugging Face: PedroMarinhoDev/ReCaVSR-ComfyUI (int8 transformer)
- GitHub: kopperx/ReCaVSR (official code and paper)
- ComfyUI Wiki: ReCaVSR in ComfyUI
