Image-to-Video Model

Self-host Stable Video Diffusion: a 4.78GB single-file checkpoint, from $0.193/hr on a 24GB card

SVD is a pure image-to-video latent diffusion model. It takes an image, not a prompt. It is also the easiest open video model to fit on a consumer GPU, provided you know which step actually spikes your VRAM.

Stable Video Diffusion · self-hosted

Stable Video Diffusion ships from Stability AI's generative-models repository, with the paper at arXiv:2311.15127. Training splits into three stages: text-to-image pretraining, video pretraining, then high-quality video finetuning, inserting temporal layers into an image latent model and finetuning them. The output is deliberately modest: SVD produces 14 frames, SVD-XT produces 25, both at 576x1024, and the model card states plainly that generated videos are short, at four seconds or less. It cannot be steered by text prompts. That is architectural, not a misconfiguration, so text-to-video means generating a first frame with SD or SDXL and feeding that in.

The model is roughly 2B parameters. The fp32 UNet weighs 6.1GB, which works back to about 1.5B; the CLIP image encoder is 2.53GB fp32, around 630M; the VAE is 391MB. Against the 2026 image-to-video field, LTX-2.5, Wan2.2-I2V-A14B and MiniMax-H3 sit at the 14B tier and win on fidelity. SVD holds a different title: lightest. SVD-XT 1.1 is a single 4.78GB safetensors file. Via the diffusers layout the fp16 set is UNet 3.05GB plus image encoder 1.26GB plus VAE 196MB, about 4.5GB total. The Hugging Face docs are explicit: enable model CPU offload, enable feed-forward chunking, and reduce decode_chunk_size, and the memory requirement drops below 8GB VRAM.

What actually blocks people is never the weight size. It is three things. First, the weights are gated on Hugging Face; you must accept the Stability AI Community License on the page before pulling them, and a script missing a token just returns 401. Second, the SVD-XT 1.0 repo root holds only fp32 files, svd_xt.safetensors at 9.56GB and svd_xt_image_decoder.safetensors at 9.5GB, with no fp16 single file. The fp16 weights live in the diffusers subfolders, and forgetting variant="fp16" is a straight path to OOM. Third, the peak is not UNet denoising, it is the moment the VAE decodes all 25 frames at once. Get decode_chunk_size wrong and every other saving evaporates. NexGPU bills per second and ships PyTorch and ComfyUI among 2,000+ prebuilt images, so clearing all three costs less than a coffee.

01 —

What exists in the SVD family today

One temporal diffusion backbone, differing frame counts, view counts and gating

Version	Parameters	VRAM	Context	Notes
stable-video-diffusion-img2vid (SVD)	~2B (UNet ~1.5B)	fp16 weights ~4.5GB / under 8GB with all tricks / 12GB+ recommended	14 frames, 576x1024	The short, fast tier. Official reference is roughly 100 seconds per clip on an A100 80GB, which makes it the cheapest way to sweep motion_bucket_id and framing.
stable-video-diffusion-img2vid-xt (SVD-XT)	~2B	fp16 weights ~4.5GB / under 8GB with all tricks / 16GB+ without offload	25 frames, 576x1024	Finetuned from SVD out to 25 frames, roughly 180 seconds per clip on an A100 80GB. The repo root carries only a 9.56GB fp32 single file; fp16 comes from the diffusers subfolders.
stable-video-diffusion-img2vid-xt-1-1 (SVD 1.1)	~2B	4.78GB single file / same profile as XT / a 24GB card is the easy answer	25 frames, 1024x576	The current workhorse. Finetuned with fixed conditioning at 6 FPS and motion_bucket_id 127 for consistency, with the caveat that performance outside those fixed settings may vary compared to SVD 1.0. Gated repo on Hugging Face.
SV3D_u / SV3D_p	Same tier as SVD	Not published by Stability; comparable weights, start at 16GB+	21 frames, 576x576	Repurposes the temporal layers for orbital novel-view synthesis. SV3D_u turns a single image into an orbit video; SV3D_p additionally accepts a specified camera path. This is the 3D asset preview branch.
SV4D 2.0	Not published	Not published by Stability; bfloat16 inference, start at 24GB+	48 images = 12 frames x 4 views, 576x576	Video-to-4D. Takes a 12-frame single-view video and emits four novel-view videos at once, with a 5-frames-by-8-views variant; longer sequences are built autoregressively.

02 —

Which GPU to rent for SVD

NexGPU list rates, matched to what you are actually doing

First run, and iterating on motion_bucket_id and noise_aug_strength
RTX 3090 24GB$0.193/GPU-hr
24GB holds the whole fp16 pipeline resident with no CPU offload at all, at the cheapest Ampere rate on the network, so experimentation costs under twenty cents an hour.
Production runs: 25 frames at 576x1024, decode_chunk_size wide open for speed
RTX 4090 24GB$0.540/GPU-hr
The best price-to-throughput single card for diffusion inference, and it fully realises the 20-25% speedup the docs attribute to compiling the UNet with torch.compile.
Matching the official ~180s benchmark, or grinding a batch queue
A100 PCIE 80GB$0.824/GPU-hr
The model card's line about SVD-XT taking roughly 180 seconds refers to exactly this class of card, so capacity planning against official numbers should not substitute anything else.
SV4D 2.0 producing 48 images across 4 views, or several concurrent jobs per card
RTX A6000 48GB$0.817/GPU-hr
48GB absorbs both the multi-view batch and the VAE decode spike, at essentially the same rate as the A100 PCIE, which makes it the sweet spot for multi-view workflows.

03 —

Four steps to running SVD on NexGPU

From bare instance to your first exported mp4, usually inside fifteen minutes

01
Launch an instance on the PyTorch prebuilt image
Pick an RTX 3090 24GB or RTX 4090 24GB at console.nexgpu.net and select the PyTorch image. Come in over SSH or Jupyter and you are a few video packages away from generating. Do not skip imageio-ffmpeg; export_to_video depends on it to write the file.
```
pip install -U diffusers transformers accelerate imageio-ffmpeg
```
02
Clear the gate and pull SVD-XT 1.1
Visit stabilityai/stable-video-diffusion-img2vid-xt-1-1 on Hugging Face and accept the Stability AI Community License first. It is a gated repo and an unauthenticated pull simply 401s. Then download with your token; the single file is 4.78GB and typically lands in a minute or two on a NexGPU node.
```
hf auth login && hf download stabilityai/stable-video-diffusion-img2vid-xt-1-1 --local-dir ./svd_xt_1_1
```

Generate your first 25-frame clip in diffusers

Three parameters carry the whole run. variant="fp16" decides whether you load the 3.05GB UNet or the 6.1GB one. decode_chunk_size decides your VRAM peak at the VAE decode step. And SVD 1.1 was finetuned at fps=6 with motion_bucket_id=127, so leave those alone on the first pass. If memory is tight, drop decode_chunk_size to 2 or even 1, at the cost of possible flicker.

import torch
from diffusers import StableVideoDiffusionPipeline
from diffusers.utils import load_image, export_to_video
pipe = StableVideoDiffusionPipeline.from_pretrained("./svd_xt_1_1", torch_dtype=torch.float16, variant="fp16")
pipe.enable_model_cpu_offload(); pipe.unet.enable_forward_chunking()
image = load_image("first_frame.png").resize((1024, 576))
frames = pipe(image, decode_chunk_size=2, num_frames=25, fps=6, motion_bucket_id=127).frames[0]
export_to_video(frames, "out.mp4", fps=7)

04
Move to ComfyUI for batching and parameter sweeps
For dozens of clips, ComfyUI beats scripting. Drop the single-file checkpoint into the checkpoints folder (svd.safetensors for 14 frames, svd_xt.safetensors for 25). Wire in the VideoLinearCFGGuidance node, which scales cfg linearly across frames, for example 1.0 rising to 2.5, and is a decisive quality lever for SVD. Raising augmentation_level adds noise to the init image, which also adds motion.
```
mv svd_xt_1_1.safetensors ComfyUI/models/checkpoints/ && python main.py --listen 0.0.0.0
```

What one four-second clip actually costs

Stability published the timings, so the arithmetic is straightforward. The model card states that SVD-XT takes roughly 180 seconds for a 25-frame clip on an A100 80GB, and SVD roughly 100 seconds for 14 frames. NexGPU's A100 PCIE 80GB lists at $0.824/GPU-hour, which is $0.824 / 3600 = $0.000229 per second. One four-second clip is 180 x $0.000229, about $0.041. A hundred clips is roughly $4.12. If you do not need to match the official benchmark, it gets cheaper. The RTX 3090 24GB at $0.193/GPU-hour works out to $0.0000536 per second. Even estimating the same clip conservatively at 240 seconds, that is 240 x $0.0000536, about $0.013 per clip, or $1.29 for a hundred. If you want speed instead, the RTX 4090 24GB at $0.540/GPU-hour with torch.compile's documented 20-25% gain still lands in the low single-digit cents per clip. Add storage and egress. SVD-XT 1.1 is 4.78GB as a single file; with the diffusers fp16 shards and an output directory, a 15GB volume is 15 x $0.414 = $6.21/month. A thousand four-second mp4s is around 2GB of egress, 2 x $0.0081, about $0.016, effectively noise. Note how billing splits: compute stops the second the instance stops, but a storage volume keeps billing until you destroy it. Delete the volume once the parameter sweep is done.

04 —

Frequently asked questions

How much VRAM does Stable Video Diffusion actually need? Can 8GB run it?

Yes, with the right settings. The fp16 pipeline is about 4.5GB of weights (UNet 3.05GB, CLIP image encoder 1.26GB, VAE 196MB), and the Hugging Face docs state that enabling model CPU offload, UNet feed-forward chunking, and dropping decode_chunk_size to 2 together brings the requirement under 8GB VRAM. You pay for it in speed and occasional flicker. If you would rather not fight for headroom, NexGPU's RTX 3090 24GB is $0.193/GPU-hour and lets you skip every one of those optimisations.

SVD, SVD-XT, or SVD 1.1 — which should I deploy?

SVD emits 14 frames and SVD-XT 25, both at 576x1024, with XT finetuned from SVD. SVD-XT 1.1 is the current workhorse: a 4.78GB single file versus 1.0's 9.56GB fp32 root checkpoint, finetuned with fixed conditioning at 6 FPS and motion_bucket_id 127 for consistency. Stability's own caveat is that behaviour outside those fixed settings may vary compared to SVD 1.0. So use 1.1 on its rails, and if you need aggressive motion parameters, it is worth re-testing 1.0. Running both side by side on two NexGPU RTX 3090 24GB instances costs under forty cents an hour.

Can Stable Video Diffusion be controlled with text prompts?

No. The model card lists it as a limitation: the model cannot be controlled through text, and it cannot render legible text either. SVD is pure image-to-video, conditioned only on the input image plus fps, motion_bucket_id and noise_aug_strength. The standard route to text-to-video is to generate a first frame with SD 1.5 or SDXL and hand that frame to SVD. Both halves run on one NexGPU instance, since AUTOMATIC1111, ComfyUI and Stable Diffusion are all in the prebuilt image catalogue.

Is SVD still worth deploying in 2026, or has it been superseded?

On fidelity, superseded — the trending image-to-video models now are LTX-2.5, Wan2.2-I2V-A14B and MiniMax-H3, all at the 14B tier. What SVD keeps is the lightweight crown: 2B parameters, a 4.78GB single file, a sub-8GB floor. For short loops, product-shot motion and bulk B-roll it still has the best cost-to-output ratio, with mature community workflows and stable inference. The sensible move is to run both lines: SVD on an RTX 3090 24GB for volume, the newer models on an RTX 5090 32GB or A100 SXM4 80GB for quality. Per-second billing makes that comparison nearly free.

What are the commercial licensing terms? Can an agency use it on client work?

It falls under the Stability AI Community License: free for commercial use by organisations and individuals under $1M in annual revenue, regardless of where that revenue comes from; above that threshold you need an Enterprise License. The licence permits derivatives such as finetunes and LoRAs, and you own the outputs. Note that SVD-XT 1.1 is a gated repo, so someone has to click accept before any download works — the step most often missed in CI or unattended scripts. Treat stability.ai/license as authoritative for compliance. On our side, NexGPU is pure infrastructure and claims no rights over your weights or your outputs.

Why does my video barely move, or why do faces come out mangled?

Two separate problems. Motion: raise motion_bucket_id (same parameter name in ComfyUI, higher means more motion) and noise_aug_strength, exposed as augmentation_level in ComfyUI, which adds noise to the conditioning image so it resembles the source less and moves more. The model card acknowledges that it may produce videos without motion or with very slow camera pans. Faces: the card states directly that faces and people in general may not be generated properly. That is a data and 2B-scale ceiling, not something parameters fix. The fastest way to tell a tuning problem from a model limit is to spin up an RTX 4090 24GB on NexGPU at $0.540/GPU-hour and sweep the whole parameter grid in half an hour, for under thirty cents.

Start building on NexGPU

Enterprise R&D team or solo developer — either way, your first job can be running in minutes.