Video generation model

Self-hosting Open-Sora starts at 52.5GB, not 24

The 11B Open-Sora 2.0 is not a single-4090 model. Here are the official memory numbers, the checkpoint sizes, the licence trap, and the multi-GPU bill — then the card you should actually rent.

Open-Sora · self-hosted

Open-Sora is maintained by HPC-AI Tech, the team behind Colossal-AI, at github.com/hpcaitech/Open-Sora — Apache-2.0, 29.3k stars. The current line is Open-Sora 2.0, released 12 March 2025: an 11B diffusion model the team says cost about $200K to train, and which they benchmark on VBench as on par with the 11B HunyuanVideo and the 30B Step-Video. One checkpoint handles both text-to-video and image-to-video, at 256px or 768px, in 16:9, 9:16, 1:1 or 2.39:1, with frame counts of the form 4k+1 up to 129. Worth knowing up front: no release has landed since 2.0, and 1.3 is kept as its own branch.

The memory numbers are what stop most people. On H100/H800 at 50 sampling steps, the official peaks are 52.5GB for 256×256 on one GPU and 60.3GB for 768×768 on one GPU. The reason is stacking: the 11B backbone alone is a 23.8GB bf16 Open_Sora_v2.safetensors, on top of which sit the T5-v1_1-xxl text encoder and CLIP-ViT-L/14, and the default T2I2V text-to-video pipeline additionally loads a 12B flux1-dev (another 23.8GB) to make the first frame before animating it. So a 24GB RTX 4090 and even a 48GB A6000 both OOM on 2.0 — 48GB misses 52.5GB by just enough to matter. If consumer silicon is the constraint, there is exactly one route: fall back to Open-Sora 1.3, where the backbone is 1.1B with a 259M VAE, and the official H200 measurements are 23–25GB across all of 360p and 24GB rising to 35GB at 113 frames on 720p.

This is precisely the workload where renting beats buying. The weights alone want roughly 114GB of disk — 69.2GB for the hpcai-tech/Open-Sora-v2 repo plus 44.5GB for the official fp32 t5-v1_1-xxl — and getting 768px to a tolerable speed means spreading ColossalAI sequence parallelism across four to eight GPUs. NexGPU has 1,175 verified rentable nodes across 51 countries and regions, 2,498 GPUs and 75 GPU models, up to 14 GPUs per node and 2,152GB of VRAM in the largest one, metered per second and priced per hour with no minimum and no setup fee — stop the instance when the batch is rendered and compute billing stops with it.

01 —

Open-Sora versions and what each one costs in VRAM

Every figure below is measured in the official repo, not estimated

Version	Parameters	VRAM	Context	Notes
Open-Sora 2.0	11B	bf16 single-GPU peak 52.5GB (256px) / 60.3GB (768px)	256px and 768px, up to 129 frames (4k+1)	The current line; one checkpoint covers T2V and I2V. Multi-GPU uses tensor parallelism at 256px and sequence parallelism at 768px, which brings each card down to 44.3GB from four GPUs onward.
Open-Sora 2.0 T2I2V pipeline	11B + Flux.1-dev 12B	Same VRAM as above; 69.2GB of weights total	256px and 768px, via t2i2v_256px.py / t2i2v_768px.py	The recommended text-to-video route: flux1-dev renders the first frame, then Open-Sora animates it. Noticeably better quality than plain T2V, but it drags in a non-commercial licence.
Open-Sora 1.3 (STDiT-v4)	1.1B + 259M VAE	360p 23–25GB / 720p 24–35GB	360p and 720p, up to 113 frames	The only generation that fits consumer cards. At 360p it barely moves, 23GB for a still up to 25GB at 113 frames; 720p only reaches 35GB at full length.
Open-Sora 1.3 i2v (STDiT-v4-i2v)	1.1B	Same class as T2V, 23–25GB at 360p	360p and 720p	A separate checkpoint for image-to-video and video extension. Far lighter than 2.0 for shot extension or bringing a still into motion.
Required components (downloaded separately)	T5-v1_1-xxl + CLIP-ViT-L/14 + hunyuan_vae	t5-v1_1-xxl ships as 44.5GB of fp32 weights (disk)	Hardcoded in config as ./ckpts/google/t5-v1_1-xxl and ./ckpts/openai/clip-vit-large-patch14	Neither ships inside the Open-Sora-v2 repo. You pull the main repo, then still have to fetch these — the path error here is the single most common first-run failure.

02 —

Which GPU to rent, by version and resolution

Matched against official peak VRAM with headroom — no card is recommended that only just fits

Open-Sora 1.3 at 360p, single-GPU shot drafting
RTX 5090 32GB$0.723/GPU-hour
Official H200 figures put 360p at 23–25GB throughout, so 32GB leaves real headroom; a 24GB 4090 runs right on the edge past 97 frames and OOMs easily.
Open-Sora 1.3 at 720p, full 113-frame shots
RTX A6000 48GB$0.817/GPU-hour
720p peaks at 35GB when frames are maxed out, so 48GB clears it on one card and you never have to shard for the sake of a few frames.
Open-Sora 2.0 at 256px on one GPU, quality validation
A100 PCIE 80GB$0.824/GPU-hour
256px peaks at 52.5GB on a single card. A 48GB A6000 misses it by a hair, which makes 80GB the entry rung for running 2.0 without sharding.
Open-Sora 2.0 at 768px for finals, sequence-parallel
H100 SXM 80GB × 4–8$3.582/GPU-hour
Measured at 466s on four GPUs and 276s on eight, holding 44.3GB per card. One GPU also works, but at 1656s — nearly 28 minutes per clip.

03 —

Getting Open-Sora running on NexGPU from scratch

Four steps; the commands are straight out of the official repo

01
Start an instance and build the environment
Boot a PyTorch image from the 2,000+ prebuilt set and SSH in. Note that xformers is pinned to 0.0.27.post2 on the cu121 wheel index — do not helpfully upgrade it. flash-attn compiles from source and the first install takes a long while; let it finish before moving on.
```
conda create -n opensora python=3.10 && conda activate opensora && git clone https://github.com/hpcaitech/Open-Sora && cd Open-Sora && pip install -v . && pip install xformers==0.0.27.post2 --index-url https://download.pytorch.org/whl/cu121 && pip install flash-attn --no-build-isolation
```
02
Pull the weights and budget the disk
The main repo is 69.2GB: Open_Sora_v2.safetensors at 23.8GB, flux1-dev.safetensors at 23.8GB, flux1-dev-ae.safetensors at 335MB and hunyuan_vae.safetensors at 493MB. T5 and CLIP are not included and must be fetched to the paths the config expects. Call it 114GB all in.
```
pip install "huggingface_hub[cli]" && huggingface-cli download hpcai-tech/Open-Sora-v2 --local-dir ./ckpts
```
03
Render your first 256px clip on one GPU
Use t2i2v_256px.py to prove the environment works. --motion-score controls how much movement you get, higher meaning more aggressive; 4 is the value in the official example. On an H100 this lands in about 60 seconds at a 52.5GB peak.
```
torchrun --nproc_per_node 1 --standalone scripts/diffusion/inference.py configs/diffusion/inference/t2i2v_256px.py --save-dir samples --prompt "raining, sea" --motion-score 4
```
04
Scale to multiple GPUs for 768px finals
768px spreads memory with ColossalAI sequence parallelism; nproc_per_node maps directly onto the GPUs you rented and each card settles at 44.3GB. Add --offload True to push weights into host RAM when memory is tight, at the cost of speed. For image-to-video, switch to 256px.py with --cond_type i2v_head --ref your.png.
```
torchrun --nproc_per_node 8 --standalone scripts/diffusion/inference.py configs/diffusion/inference/768px.py --save-dir samples --prompt "raining, sea" --offload True
```

What one 768px clip actually costs

Multiply the official 768×768 timings by our rates and you get a counterintuitive result. Eight H100 SXM 80GB: 8 × $3.582 = $28.656/hour, and 276s is 0.0767 hours, so $2.20 per clip. Four GPUs: 4 × $3.582 = $14.328/hour × 0.1294 hours = $1.85. Two GPUs: $7.164/hour × 0.2397 hours = $1.72. One GPU: $3.582 × 0.46 hours = $1.65. More GPUs means faster but pricier per clip — eight cards are 6× quicker than one for only 33% more money per clip. Use eight when a deadline is real; use one or two when you are grinding out volume. To go cheaper still, drop to 256px on an A100 PCIE 80GB at $0.824/hour: even allowing a conservative three minutes per clip, that is $0.824 × 0.05 = $0.04, four cents a draft. Storage is separate — roughly 114GB of weights at the $0.414/GB-month median is about $47/month. Compute billing stops the moment the instance stops; storage keeps billing until you destroy it.

04 —

Frequently asked questions

How much VRAM does Open-Sora need? Will a 24GB RTX 4090 run it?

It depends on the version. Open-Sora 2.0, no: the measured single-GPU peaks are 52.5GB at 256px and 60.3GB at 768px, so a 24GB card is nowhere close and even a 48GB A6000 falls short. Open-Sora 1.3, yes: 360p stays at 23–25GB, though a 4090 is uncomfortably tight past 97 frames. The safe pairing is 1.3 on a NexGPU RTX 5090 32GB at $0.723/GPU-hour and 2.0 on an A100 PCIE 80GB at $0.824/GPU-hour, billed per second so you can test one clip at a time.

Is Open-Sora related to OpenAI's Sora?

Not at all. Open-Sora is an independent open-source project from HPC-AI Tech aimed at reproducing that class of video generation, with code and weights fully published under Apache-2.0. OpenAI's Sora is a closed commercial product and ships no weights. If you need to self-host, modify the architecture, or keep training on your own footage, Open-Sora is the route — and its hardware profile lands squarely on NexGPU's 80GB cards and multi-GPU nodes.

Are there GGUF, INT4 or FP8 quantised builds of Open-Sora?

Not officially. The repo config sets dtype to bf16, and hpcai-tech publishes only bf16 safetensors on Hugging Face with no quantised checkpoints at all, so treat any "runs in 12GB after quantisation" claim with suspicion. The two supported ways to save memory are --offload True, which moves weights to host RAM, and multi-GPU parallelism, which brings each card to 44.3GB. Renting an A100 PCIE 80GB from NexGPU at $0.824/GPU-hour costs far less than the hours you would spend fighting quantisation.

It's Apache-2.0 — does that mean I can use it commercially?

The code and Open-Sora's own weights are Apache-2.0, but the default text-to-video pipeline has a catch: t2i2v_*.py loads flux1-dev.safetensors, and FLUX.1 [dev] carries a non-commercial licence. For commercial work you either swap the first-frame generator for a permissively licensed model, or take the T2V/I2V path through 256px.py / 768px.py and skip Flux entirely. Get your own counsel on the licence question; on the compute side, NexGPU instances are dedicated, and your weights and footage stay inside your instance.

How much disk should I provision, and how is storage billed?

The hpcai-tech/Open-Sora-v2 repo totals 69.2GB — a 23.8GB backbone, 23.8GB of flux1-dev, and about 828MB across the two VAEs — and the official fp32 t5-v1_1-xxl adds 44.5GB. With CLIP and your rendered output, 130GB is comfortable. NexGPU storage runs a $0.414/GB-month median, so roughly 114GB of weights is about $47/month, with egress at a $0.0081/GB median. Remember that compute stops billing when the instance stops but storage bills until destroyed — pull your renders off and clear the volume.

Nothing has shipped since Open-Sora 2.0. Is it still worth deploying?

2.0 landed in March 2025 and the repo has not cut a release since. That said, it remains one of very few projects to open-source an 11B-class video model together with its training code under Apache-2.0, which keeps it useful as a base for fine-tuning, architecture research and controllable-video work, and the $200K training cost is a published, reproducible figure. The fastest way to judge whether it suits your use case is to spin up an A100 PCIE 80GB on NexGPU at $0.824/GPU-hour, render a handful of 256px clips, and stop the instance if it doesn't — that experiment costs pennies.

Start building on NexGPU

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