A GGUF build of SeedVR2 is the same restoration model stored in a more compact form. That sentence explains both why people want it and why it disappoints them. The file takes less memory, which is the only reason to bother; it also runs slower per step, and it can look worse than the checkpoint it replaces. This guide is about the trade, and about the specific mistakes that stop a GGUF checkpoint from loading at all.
What a GGUF build buys you
GGUF is a packaging format that stores weights at reduced precision and unpacks them during inference. The checkpoint on disk is smaller, and the part of it resident in GPU memory is smaller too, because the model does not have to hold every weight at full precision at once. That is the entire benefit: a footprint that fits where a full-precision file does not.
The cost is paid per step. A quantized weight has to be converted back to a usable precision before it can be multiplied, and that conversion happens repeatedly during sampling. The result is a job that uses less memory and takes longer, often noticeably longer, for the same number of steps.
Nothing about the model's behavior changes. It is the same SeedVR2 architecture, the same workflow, the same VAE. Only the storage precision differs.
| 3B INT8 | GGUF build | |
|---|---|---|
| Memory footprint | Low; the reference low-VRAM path | Lower, which is the point |
| Speed per step | The baseline | Slower, because weights are unpacked during the run |
| Quality | The comparison baseline | Depends on the quantization level; verify on your own crop |
| Setup complexity | Two files, two folders | Adds a loader that understands the format |
| Best for | 8GB cards, first installs, batches | A card that cannot hold INT8 at your resolution |
GGUF vs INT8: when each wins
The decision is not "which is better", because they are not competing on quality. They compete on whether your card can hold the checkpoint at all.
Pick 3B INT8 when:
- You are installing SeedVR2 for the first time and want a known baseline. The 3B INT8 path runs in 8GB of VRAM with block swap.
- Your card already fits the checkpoint. If INT8 runs, GGUF mostly buys you slower steps and nothing else.
- You process batches. Per-step time compounds across a whole folder of clips.
- You want the file the ComfyUI install guide is written around.
Pick a GGUF build when:
- INT8 does not fit at the resolution or clip length you need, and reducing resolution is not acceptable.
- You are exploring on a card that was never meant for diffusion video, and finishing slowly beats not finishing.
- You have already tried the INT8 path and hit a hard memory wall rather than a slow job.
The order matters. Try INT8 first, confirm it runs, and only then reach for quantization. Starting with GGUF means debugging two new things at once, the format and the loader, on a machine that has never produced a SeedVR2 frame.
The folder and loader mistakes that break a load
Almost every "GGUF checkpoint will not load" report is one of five things. None of them are model bugs.
| Mistake | What it looks like | Fix |
|---|---|---|
File dropped in ComfyUI/models/checkpoints | The loader cannot find it, or the dropdown is empty | Diffusion checkpoints belong in ComfyUI/models/diffusion_models |
| Standard diffusion loader used on a GGUF file | A load error before sampling, or a node that refuses the file | A GGUF file needs a loader that knows how to unpack it |
VAE not in ComfyUI/models/vae | The workflow fails before the first step | Put seedvr2_ema_vae_fp16.safetensors in ComfyUI/models/vae |
| GGUF loader node missing or stale | The node is red, or absent from the menu | Install or update the node pack that provides the loader |
| File renamed to something tidier | The workflow still points at the old name | Keep the original filename, or update the node to the new one |
The VAE mistake is the one people make twice. The decoder is a separate file from the diffusion checkpoint, and it does not change when you swap checkpoints. If seedvr2_ema_vae_fp16.safetensors is not in ComfyUI/models/vae, nothing downstream matters.
The version mismatch is the second most common. The install guide targets ComfyUI 0.28.0, and custom node packs are written against particular ComfyUI builds. A pack that was current six months ago can load without complaint and then fail on the first sampling step. When a GGUF graph breaks after an update, roll the pack back before you redownload the model.
A load-order checklist
When a GGUF checkpoint refuses to appear, work in this order rather than reinstalling everything.
- Confirm the file is in
ComfyUI/models/diffusion_models, not incheckpointsor in a subfolder you invented. - Confirm
seedvr2_ema_vae_fp16.safetensorsis inComfyUI/models/vae. - Restart ComfyUI so the loader rescans the model folders. A folder refresh is usually enough; a restart is the reliable version.
- Add the GGUF-aware loader node, select the file from its dropdown, and wire the VAE separately. Do not assume a saved workflow still points at the file you just downloaded.
- Run one image or one frame before a clip. A single frame tells you the load works; a ten-minute video tells you nothing until minute nine.
If step 4 fails, the problem is the node pack, not the checkpoint. If step 5 produces an image that looks wrong rather than an error, the problem is the file or its quantization level, and the next section applies.
What to compare before you batch
A GGUF file that loads is not automatically a GGUF file that is good enough. Quantization removes precision, and the place it shows first is fine texture: skin, hair, fabric, foliage, small text. Compare at 100%, on the same crop, at the same target resolution, against the INT8 baseline you already trust.
Two failure shapes are worth naming. The first is plastic texture, where a surface that should have grain comes back smooth and slightly waxy. The second is a shift in small details that the model reconstructed differently rather than worse, which matters on faces and on anything with text. Neither shows up at fit-to-window.
Run the comparison on one frame before a whole clip. If the quantized output fails your crop test, it will fail the batch, and you will have spent the time twice.
When INT8 is the better choice
Most people who ask about GGUF should stay on INT8. It is the low-VRAM option the local path is built around, it runs on 8GB with block swap, and it is the file the guides and workflows assume. GGUF is a workaround for a specific wall, not an upgrade.
The exception is honest: long clips still run out of memory first on the 3B INT8 path, and quantization moves that wall rather than removing it.
Cost: what the hosted path removes
If the reason you are reading about quantization is that your machine cannot hold the model, the hosted path is the other answer. SeedVR2.net runs ByteDance's SeedVR2 models server-side, so there is no checkpoint to download, no loader to match, and no quantization level to choose. You upload a file and the job runs on managed hardware.
Image upscales are flat by target: 2K is 10 credits, 4K is 16, 8K is 25. Video bills per second with a 5-second minimum and a 10-minute maximum per clip. On the standard model:
| Target | Credits per second |
|---|---|
| 720p | 9 |
| 1080p | 9 |
| 2K | 17 |
| 4K | 33 |
Other models cost more; the Ultimate model is 131 credits per second at 4K. Credits come from packs starting at $9.99 for 200, or subscriptions starting at $19/month for 1,200 credits, and a first 2K image plus one standard 720p clip up to 5 seconds are free with a verified email. The pricing page has the full list, and the credit cost guide explains the billing rules.
Estimate the credits for your own job
Pick a resolution and length. The calculator uses the same credit rates as checkout, then shows which pack covers the job.
PricingPage.pricingCalculator.title
PricingPage.pricingCalculator.description
PricingPage.pricingCalculator.estimateTitle
PricingPage.pricingCalculator.creditsValue
PricingPage.pricingCalculator.perVideoSummary
- PricingPage.pricingCalculator.timeLabel
- PricingPage.pricingCalculator.timeValue
- PricingPage.pricingCalculator.sizeLabel
- PricingPage.pricingCalculator.sizeValue
PricingPage.pricingCalculator.videoTimeEstimateHint
PricingPage.pricingCalculator.videoFootageScale
PricingPage.insufficientCredits.failedTaskRefund
PricingPage.pricingCalculator.deliveryHint
PricingPage.pricingCalculator.recommendedPackage
$9.99
PricingPage.pricingCalculator.recommendedPackageHint
The comparison to make is not credits against zero. It is credits against the hours you would spend matching a node pack to a ComfyUI build, plus the electricity for a slow quantized run. For one file, hosted is usually the shorter path. For a repeatable batch on hardware you already own, local wins on marginal cost, and INT8 is the checkpoint to build that batch around.
Limitation
This post does not give per-quantization VRAM figures, speed ratios or quality scores, because exact headroom varies by ComfyUI build, by node pack version, by clip length, by output resolution and by batch size. The 8GB figure in this article applies to the 3B INT8 path with block swap, and long clips still run out of memory first. It also cannot verify every community GGUF repack: a file can load cleanly and still produce output that is worse than the INT8 baseline, which is why the crop comparison is in here rather than a recommendation by name. Treat the checklist as a way to isolate the failure, not as a promise that quantization will fit your machine.