| --- |
| license: apache-2.0 |
| base_model: kopper/RelayVSR |
| library_name: comfyui |
| pipeline_tag: video-to-video |
| tags: |
| - video-super-resolution |
| - upscaling |
| - relayvsr |
| - comfyui |
| - quantized |
| - int8 |
| --- |
| |
| # RelayVSR X4: int8 / W6A8 / W4A8 Wan quants for ComfyUI |
|
|
| Pre-quantized Wan checkpoints for **RelayVSR's original 4x model** ([kopper/RelayVSR](https://huggingface.co/kopper/RelayVSR)), |
| so it runs on **16 GB and 24 GB cards** at full H3 resolution (1280x704 in, 2560x1408 out), and faster than full precision. |
| They are made for the RelayVSR nodes in **[ComfyUI-MAINodes](https://github.com/matlowai/ComfyUI-MAINodes)** |
| ([`relayvsr/README.md`](https://github.com/matlowai/ComfyUI-MAINodes/blob/main/relayvsr/README.md)), which run RelayVSR through |
| [LightX2V](https://github.com/ModelTC/LightX2V) in its own Python. |
|
|
| **Where the originals live:** RelayVSR is by kopperx. Code, paper, project page and demo are on |
| **[github.com/kopperx/RelayVSR](https://github.com/kopperx/RelayVSR)**; its "Model Weights" link is |
| [kopper/RelayVSR](https://huggingface.co/kopper/RelayVSR), which holds the original X4 `wan.safetensors` and |
| `flash.safetensors` without a model card of its own. [lightx2v/RelayVSR_X2](https://huggingface.co/lightx2v/RelayVSR_X2) |
| is the LightX2V team's separate native-2x retrain, not the source of these files. |
|
|
| Use the X4 model even for 2x output: it computes at 4x and resizes, and on our clips it was clearly better than the |
| native X2 model. |
|
|
| ## Pick by card |
|
|
| Download **one** Wan file plus `flash.safetensors` into `ComfyUI/models/relayvsr/RelayVSR/`. On the |
| **RelayVSR • X2 / X4 Settings** node set `variant` = X4, `output_scale` = 2, `execution_mode` = single GPU, and `vram` = |
| the matching tier (or `auto`, which picks the best tier your card fits from the files present). |
|
|
| | card | Wan file | size | `vram` tier | peak VRAM | time per 3 s clip | drift from full precision | |
| |---|---|---|---|---|---|---| |
| | 32 GB | `wan.safetensors` from [kopper/RelayVSR](https://huggingface.co/kopper/RelayVSR) | 10.1 GB | full precision, with Wan block offload | 27.9 GB | 28.4 s | — | |
| | **24 GB+** | `wan_int8_convrot.safetensors` | 5.2 GB | 24 GB+: int8 ConvRot weights + int8 KV | 21.8 GB | **22.0 s** | 53.1 dB | |
| | **16 GB** | `wan_w6a8.safetensors` | 4.2 GB | 16 GB: W6A8 weights + int4 KV | fits a 13.5 GiB cap | 23.0 s | 47.0 dB | |
| | 16 GB, more room | `wan_w4a8.safetensors` | 3.0 GB | 16 GB, most headroom: W4A8 weights + int4 KV | fits a 13.0 GiB cap | 22.8 s | 44.3 dB | |
|
|
| Measured on one RTX 5090: a 3 s (73-frame) MiniMax-H3 clip, 1280x704 -> 2560x1408, the node's default `faithful` quality |
| preset, no offload for the quantized tiers. "Peak" is nvidia-smi. The 16 GB tiers ran under a PyTorch memory cap that |
| leaves room for the CUDA context and a desktop on a 16 GB card. Drift is PSNR between the frames and the full-precision |
| output; above ~45 dB the difference is invisible. On five 3 s clips scored against ground truth (2x from half |
| resolution), every tier scored the same as full precision (35.9-36.0 dB overall, 34.3-34.5 dB on a mustache crop). |
|
|
| Memory is set by resolution, not clip length: most of it is Wan's key/value cache over four keyframes (19.6 GiB in |
| bf16 at this size), which the tiers store as Hadamard-rotated int8 / int4 at run time. That is why smaller weights alone |
| would not take a 12 GB card to this resolution. |
|
|
| ## Pixels |
|
|
| Frame 36 of the test clip, 1:1 crops of the 2560x1408 outputs (top: the input upscaled with plain Lanczos). |
|
|
| **Mustache, 2x nearest-neighbour zoom** |
|
|
|  |
|
|
| **Mustache, 1:1** |
|
|
|  |
|
|
| **Shelf, 1:1** |
|
|
|  |
|
|
| **Full frame (full precision, shown at half size)** |
|
|
|  |
|
|
| ## What's in the files |
|
|
| The 300 linear layers of Wan's 30 blocks are quantized with [comfy-kitchen](https://github.com/Comfy-Org/comfy-kitchen) |
| 0.2.40; everything else (norms, biases, modulation tables, input and output layers) is unchanged bf16, and the original |
| checkpoint metadata is kept, plus a `relayvsr_quant` entry. |
|
|
| - `wan_int8_convrot`: W8A8 ConvRot (256-wide Hadamard groups, per-channel int8 weights, int8 activations). |
| - `wan_w6a8` / `wan_w4a8`: comfy-kitchen grouped W6A8 / W4A8 (6- / 4-bit weights, int8 activations). |
| - `flash.safetensors`: RelayVSR's Flash model, byte-identical to kopper/RelayVSR (re-hosted so one repo has a full set). |
|
|
| Made from `wan.safetensors` (sha256 `638acb6a...2eb98`) with `relayvsr/tools/quantize_wan.py` in ComfyUI-MAINodes. |
| Checksums: [`SHA256SUMS`](SHA256SUMS). The files load only through the MAINodes RelayVSR worker (the quantized tensors |
| are not in LightX2V's own quant layout). |
|
|
| ## Credits and license |
|
|
| RelayVSR by kopperx ([GitHub: code, paper links, project page, demo](https://github.com/kopperx/RelayVSR), |
| [paper](https://arxiv.org/abs/2609.37850), [project page](https://kopperx.github.io/RelayVSR/), |
| [original weights](https://huggingface.co/kopper/RelayVSR)), built on [Wan 2.2](https://github.com/Wan-Video/Wan2.2) and |
| [FlashVSR](https://github.com/OpenImagingLab/FlashVSR); inference via [LightX2V](https://github.com/ModelTC/LightX2V); |
| quantized kernels from [comfy-kitchen](https://github.com/Comfy-Org/comfy-kitchen). |
|
|
| These are derived (quantized) weights, released under Apache-2.0, the license the RelayVSR project states for itself. |
| The original weight repository does not carry its own license field; if its authors publish different terms for the |
| weights, those apply. Quantized by MATLOWAI. |
|
|
