Video generation model

Self-host VideoCrafter: the 320x512 video diffusion model that fits on one 24GB card

16 frames, 320x512, 50 DDIM steps, single GPU, no offloading. Here is every checkpoint, every dependency trap, and every cent it costs.

VideoCrafter · self-hosted

VideoCrafter is the latent video diffusion (LVDM) family open-sourced by AILab-CVC, the Tencent AI Lab group. It starts with the 256x256 t2v-version-1-1 in April 2023, reaches 576x1024 with VideoCrafter1, and lands on VideoCrafter2 in January 2024. The skeleton is Stable Diffusion 2.1: a 4-channel VAE at 8x downsampling, a frozen OpenCLIP ViT-H text encoder taken at the penultimate layer with context_dim 1024, and a 3D UNet with temporal convolutions and temporal self-attention bolted on, model_channels 320, temporal_length hard-locked at 16, plus an fps conditioning embedding. The VideoCrafter2 paper's pitch is blunt: learn motion from the visually poor WebVid-10M, then finetune the spatial modules alone on synthesized high-quality images to recover appearance.

Do not expect it to keep moving, though. The last substantive code change landed in July 2024; the only commit in 2026 was a community PR fixing "Techinical" to "Technical" in the README (#102). The official Hugging Face Space currently sits in BUILD_ERROR with Gradio pinned at 3.43. The README itself hands off image-to-video, telling you to use DynamiCrafter instead. Further down the same lineage you now have HunyuanVideo 1.5 (8.3B, 14GB minimum with offloading, 480p/720p/1080p). None of that is a knock on the model; it is just what you should know before you pick it.

And yet it still earns its keep. At roughly 1.8B parameters, 16 frames and 320x512, it runs end to end on a single card with no offloading, no multi-GPU orchestration, and no forty-minute wait per clip. It is a permanent fixture on the VBench leaderboard and the base model that consistency-distillation work like T2V-Turbo builds on directly. For ablations, for reproducing published numbers, for having one LVDM baseline that actually runs and is small enough to modify, VideoCrafter is still the cheapest option on the table, provided your GPU architecture agrees with the torch version it pins. That last condition is exactly why renting beats buying here.

01 —

Which checkpoint you actually want

There is no 1024 checkpoint for VideoCrafter2. High resolution means going back to VideoCrafter1.

Version	Parameters	VRAM	Context	Notes
VideoCrafter2 (base_512_v2)	~1.8B total (7.4GB ckpt, fp32, bundles UNet3D + VAE + OpenCLIP)	12.8GB measured on a 4090 for the same-family 320x512 tier; community floor 16-18GB; official demo ran on a 24GB L4	16 frames, 320x512, saved at 8fps = 2 seconds	The default choice today. Clear quality jump over VC1; use_scale: true with scale_b: 0.7 is its own noise-schedule tweak. Tagged Apache-2.0 on Hugging Face.
VideoCrafter1 T2V 1024 (base_1024_v1)	6.34GB ckpt, fp32	18.3GB measured on an RTX 4090 for the same-family 576x1024 tier	16 frames, 576x1024 (72x128 latent)	The only high-resolution text-to-video weight in the entire family. Trained on a 256x256 to 512x320 to 1024x576 curriculum, the last stage 45K steps at batch 64.
VideoCrafter1 T2V 512 (base_512_v1)	6.33GB ckpt, fp32	Same tier as VideoCrafter2, roughly 12.8GB and up	16 frames, 320x512	Only worth downloading for version-to-version comparisons or reproducing VC1 paper numbers. For actual generation there is no reason to pick it over VideoCrafter2.
VideoCrafter1 I2V 512 (i2v_512_v1)	5.22GB ckpt, fp32	Roughly 12.8GB and up, same tier as T2V 512	16 frames, 320x512, image + text dual conditioning	Adds a second cross-attention path over the T2V model, encoding the reference frame through FrozenOpenCLIPImageEmbedderV2. The shipped script defaults to --fps 8 and CFG 12.
DynamiCrafter (the official I2V successor)	Same LVDM family, not a VideoCrafter weight	Measured on a 4090: 18.3GB at 576x1024, 12.8GB at 320x512, 11.9GB at 256x256	16 frames, 1024 long edge (plus a 512 interpolation/looping variant)	VideoCrafter's own README points image-to-video users here, and DynamiCrafter ships the VRAM table plus A100 timings: 75s for 50 steps at 1024, 20s at 512.
t2v-version-1-1 (the original LVDM)	The April 2023 first release	Maintainer's figure at the time: 6.3GB minimum with xformers	256x256	The only weight repo explicitly tagged MIT. Useful for archaeology and extreme low-VRAM sanity checks, nothing else.

02 —

Picking a GPU: modest VRAM, fussy architecture

The official scripts expose no fp16 switch, so inference is fp32 throughout, and that flips the usual selection logic for bf16-native models.

VideoCrafter2 at 320x512, your everyday workhorse
RTX 3090 24GB$0.193/GPU-hr
24GB matches the L4 the official demo ran on, Ampere sm_86 is squarely covered by the torch 2.0.0 stock wheels, and it costs less than the 16GB Tesla T4 ($0.298) while giving you half again as much memory.
VideoCrafter1 at 576x1024, or batching through a prompt set on a deadline
RTX 4090 24GB$0.540/GPU-hr
The 1024 tier measures 18.3GB in the same family, which fits in 24GB with little headroom; the 4090's fp32 throughput cuts per-clip time close to half, so batch jobs often come out cheaper overall.
Batch size above 1, or long-frame experiments where 24GB runs out
Tesla V100 32GB$0.188/GPU-hr
The cheapest 32GB card in the fleet, and because VideoCrafter runs fp32 and never touches bf16 tensor cores, the V100 loses far less here than it would on a modern model.
LoRA finetuning or consistency distillation on top of VideoCrafter2, the T2V-Turbo route
A100 SXM4 80GB$1.088/GPU-hr
Training has to hold temporal-attention activations and optimizer state at once, which wants 80GB and NVLink; nodes take up to 14 GPUs, so scaling out never means changing provider.

03 —

Deploying VideoCrafter2 on NexGPU in four steps

Everything that goes wrong between a blank instance and your first mp4 is a dependency version, so pin Python before anything else.

01
Spin up a card and build a clean Python 3.8.5 environment
Pick the RTX 3090 24GB in the console, boot a PyTorch prebuilt image, SSH in. requirements.txt pins torch==2.0.0, transformers==4.25.1, pytorch_lightning==1.8.3 and open_clip_torch==2.22.0, a combination that cascades into conflicts on Python 3.10+. Building 3.8.5 is by far the least painful path.
```
conda create -n videocrafter python=3.8.5 -y && conda activate videocrafter
```
02
Clone and install
The repo has over 5,000 stars and 413 forks but 74 open issues nobody is triaging, so do not count on upstream fixes. xformers is unpinned; after installing, import it once and confirm it did not quietly drag torch to a newer build.
```
git clone https://github.com/AILab-CVC/VideoCrafter && cd VideoCrafter && pip install -r requirements.txt
```
03
Pull the 7.4GB checkpoint into the exact path the scripts expect
The path checkpoints/base_512_v2/model.ckpt is hardcoded in the shell scripts, and one wrong character means file not found. The repo holds a single model.ckpt, stored fp32 at 7.4GB, which typically lands in a minute or two on a NexGPU node.
```
hf download VideoCrafter/VideoCrafter2 model.ckpt --local-dir checkpoints/base_512_v2
```
04
Run inference, or bring up Gradio
Defaults are 320x512, 16 frames, 50 DDIM steps, CFG 12.0 and --fps 28 (fps is a conditioning embedding, not the save framerate, which is --savefps, default 10). For more speed, flip use_checkpoint from true to false in configs/inference_t2v_512_v2.0.yaml. That is exactly what the official Gradio backend does: it trades gradient checkpointing for VRAM, and a 24GB card absorbs it easily.
```
sh scripts/run_text2video.sh   # or python gradio_app.py for the web UI
```

What a clip actually costs

Take the defaults: 320x512, 16 frames, 50 DDIM steps. The same-family DynamiCrafter512 takes 20 seconds for 50 steps on an A100, so budgeting 45 seconds per clip on an RTX 3090 including decode and disk write is conservative. 3600 / 45 = 80 clips per hour, and $0.193 / 80 comes to about $0.0024 per clip. Sweep a 500-prompt evaluation set: 500 x 45s = 6.25 hours, 6.25 x $0.193 = $1.21. Too slow? Move to the RTX 4090 24GB at $0.540/GPU-hr and the same 500 clips take roughly 3 hours, 3 x $0.540 = $1.62 - half the wall clock for 41 cents more. Storage is separate: the repo plus a 7.4GB checkpoint fits a 20GB volume, and at the $0.414/GB-month median that is $8.28/month. Compute billing stops the second the instance stops; storage keeps running only until you destroy the volume. The 500 output mp4s come to roughly 0.2GB, which at the $0.0081/GB median egress rate is under a cent. Metered per second, no minimum, no setup fee.

04 —

FAQ

How much VRAM does VideoCrafter actually need?

The repo never published a VRAM table, so here are the three real data points you can check: someone hit CUDA OOM on a 10.9GB card (issue #78), with a reply putting the practical floor at 18GB; the DynamiCrafter model the README points you to measures 12.8GB at 320x512 and 18.3GB at 576x1024 on an RTX 4090; and the official Hugging Face demo ran on a 24GB L4. The conclusion is clean: 12GB and under will not work, 16GB is tight, 24GB is safe. NexGPU's RTX 3090 24GB is $0.193/GPU-hr, less than what many people paid for a 16GB card.

VideoCrafter2 or VideoCrafter1 - which should I run?

For quality, VideoCrafter2; its whole training recipe exists to stop WebVid-10M from dragging appearance down. But note that no high-resolution VideoCrafter2 weight was ever released - 320x512 is the only tier. If you need 576x1024 you go back to VideoCrafter1's base_1024_v1 (6.34GB), and for image-to-video you take i2v_512_v1 or follow the README to DynamiCrafter. All of those checkpoints together are under 30GB, so a single 3090 hour on NexGPU is enough to pull them all and compare side by side for about twenty cents.

It is 2026 - is VideoCrafter obsolete?

The code is effectively frozen: last substantive update July 2024, and the only 2026 commit was a README typo fix. The successors on the same lineage are DynamiCrafter and HunyuanVideo 1.5 (8.3B, 14GB minimum with offloading). As a baseline, though, it is very much alive - it sits on VBench, and distillation work like T2V-Turbo uses it as the base model, because it is small, structurally transparent and fast to modify. If you want a real comparison, the simplest move is to rent two NexGPU instances at once, a 3090 for VideoCrafter2 and an A100 80GB for the newer model, and run the same prompt set through both before you commit.

Can I use VideoCrafter commercially?

This is the trap. The GitHub repo has no LICENSE file at all - only a README line saying it is for research and limited to personal, research and non-commercial use. The weights disagree with each other: VideoCrafter2 is tagged Apache-2.0 on Hugging Face, the original t2v-version-1-1 is MIT, and Text2Video-1024, Text2Video-512 and Image2Video-512 carry no license tag whatsoever. Code and weights are telling you different things, so take it to your own counsel before shipping; this page is not legal advice. For the evaluation phase, NexGPU bills per second with no quota request, and you destroy the instance when you are done.

Why won't VideoCrafter install on an RTX 5090?

Because requirements.txt pins torch==2.0.0, a 2023 build whose stock wheels compile no further than Hopper. There is no Blackwell (sm_120) kernel in it, so you get "no kernel image is available" on the first CUDA call. Making a 5090 work means moving to a CUDA 12.8-capable torch and then reworking pytorch_lightning 1.8.3, transformers 4.25.1 and open_clip_torch 2.22.0 along with several lvdm APIs. So our advice cuts against our own price list: run stock VideoCrafter on Ampere or Ada - RTX 3090 at $0.193 or RTX 4090 at $0.540 - and save the RTX 5090 32GB ($0.723) for models that natively support current torch.

Is VideoCrafter limited to 2-second clips, and can I make them longer?

temporal_length is 16, hardcoded in the config, and clips save at 8-10 fps, so one generation is 1.6-2 seconds. inference.py does expose --frames (default -1, meaning follow temporal_length), but the weights were trained at 16 frames and stretching them produces obvious motion drift and collapse. The practical routes are frame interpolation with something like RIFE, or switching to DynamiCrafter's 512_interp variant for interpolation and looping. Those post-processing chains are heavy on I/O and memory fragmentation, so it pays to run generation and interpolation on the same 24GB NexGPU instance and skip the egress on round-tripping files.

Start building on NexGPU

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