--- 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 2x](images/mustache_2x.png) **Mustache, 1:1** ![mustache](images/mustache.png) **Shelf, 1:1** ![shelf](images/shelf.png) **Full frame (full precision, shown at half size)** ![full frame](images/full.png) ## 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.