Video generation model

Deploy Mochi 1 preview: 20GB to start, 80GB to fine-tune

Genmo's 10B AsymmDiT text-to-video model, fully open under Apache 2.0. Here is the honest VRAM arithmetic across 480p, 163 frames, fp8 and bf16 — plus the exact NexGPU GPU and price for each.

Mochi · self-hosted

Mochi 1 preview is Genmo's open text-to-video model, built around a 10B-parameter Asymmetric Diffusion Transformer (AsymmDiT): 48 layers, 24 attention heads, a 3,072-dimension visual stream against a 1,536-dimension text stream, with non-square QKV and output projections chosen specifically to hold inference memory down. The paired AsymmVAE is only 362M parameters yet compresses 8×8 spatially and 6× temporally into a 12-channel latent space — 128× overall. Prompts go through a single T5-XXL encoder, no second tower. The licence is Apache 2.0, so commercial use needs no conversation with anyone.

The VRAM story has three tiers that span nearly 3×, and the reason is not mysterious: it comes down to what precision you load T5-XXL, the DiT and the VAE in. The official genmo/mochi repo optimises for fidelity — fp32 text encoder and VAE, bf16 DiT pinned to the EFFICIENT_ATTENTION kernel — and needs roughly 60GB on a single GPU, with at least one H100 recommended. The diffusers MochiPipeline in full precision starts at 42GB; switch to variant="bf16" with enable_model_cpu_offload() and vae.enable_tiling() and it drops to 22GB, with a documented slight quality loss. ComfyUI has supported Mochi natively since November 2024, and with Comfy-Org's repackaged mochi_preview_fp8_scaled.safetensors the official figure is under 20GB. What actually OOMs you, though, is usually not sampling but VAE decode: push the frame count and you need tiled decoding, and the official reproduction script's 163-frame full-precision decode is documented at 70GB.

Then there are the things you only learn by hitting them. The pipeline's num_frames defaults to 19 — at 30fps that is a 0.6-second clip, and people assume the model is broken. The fine-tuner requires frame counts in increments of six plus one: 25, 31, 37, all the way to 85. Diffusers explicitly cannot load the fp8 scaled single-file checkpoint, so feeding it the ComfyUI file to from_single_file will always fail. And enabling force_zeros_for_empty_prompt while wrapping the whole pipeline in autocast overflows T5 numerically — the text-encoding step has to run outside autocast in full precision. All of these land on day one of a self-host, which is exactly why it is cheaper to rent a correctly-sized card by the second, burn three hours of trial and error, and only then decide whether to buy hardware.

01 —

The weight paths, and what each one costs in VRAM

There is still only one public checkpoint — mochi-1-preview. Everything below differs by load precision and inference framework.

Version	Parameters	VRAM	Context	Notes
mochi-1-preview (official genmo repo inference)	10B DiT + 362M AsymmVAE	~60GB single GPU; 1×H100 recommended	480×848 · 30fps	The highest-fidelity route: fp32 T5 and VAE, bf16 DiT pinned to EFFICIENT_ATTENTION. Supports splitting the model across multiple GPUs, and --cpu_offload to trade time for memory.
diffusers MochiPipeline, full precision	10B	≥42GB (with cpu_offload + VAE tiling)	num_frames up to 163 (≈5.4s)	Documented as the best-quality, highest-barrier path. Decoding 163 frames of latents in full precision pushes the requirement to 70GB — cut frames or decode in bf16 instead.
diffusers variant="bf16"	10B	~22GB	Defaults: 480×848 / 19 frames / 64 steps / CFG 4.5	The best value Python path, with a documented slight drop in quality. You must call both enable_model_cpu_offload() and vae.enable_tiling(); skipping either blows the budget.
mochi_preview_fp8_scaled.safetensors (Comfy-Org repack)	10B	Under 20GB	256-token prompt limit	Native ComfyUI nodes have supported it since 2024-11-05; the all-in-one checkpoint drops straight into models/checkpoints. Note that diffusers cannot load this fp8 scaled single file.
mochi_preview_bf16.safetensors + t5xxl_fp16 + mochi_vae (split files)	10B	Above the fp8 tier; VAE decode becomes the bottleneck as frames grow	480×848	The split ComfyUI layout — files go to diffusion_models / text_encoders / vae respectively. If memory is tight, the official advice is to swap the bf16 and fp16 files for their fp8 equivalents.
LoRA fine-tuning (demos/fine_tuner)	LoRA on the 10B backbone	~50GB at 37 frames; ~80GB at 85 frames	Frame count must be a multiple of 6 plus 1: 25 / 31 / 37 … 85	The official script is single-GPU only; 1×H100 or A100 80GB recommended. Roughly 1.67 s/it at 37 frames, ~30 minutes for 1,000 steps, with visible style shift by step 200–400.

02 —

Which GPU to rent

Match the job honestly. Mochi's VAE decode stage does not forgive an optimistic VRAM guess.

ComfyUI with fp8_scaled, prompt iteration and 480p output
RTX 4090 24GB$0.540/GPU-hr
The official figure for the ComfyUI path is under 20GB, and 24GB leaves headroom for VAE decode.
The diffusers bf16 variant, or pushing past 85 frames
RTX 5090 32GB$0.723/GPU-hr
The bf16 path is documented at 22GB; 32GB keeps tiled VAE decode and longer clips off the edge instead of re-running failed jobs.
Official repo single-GPU inference, or 163-frame full-precision decode
A100 PCIE 80GB$0.824/GPU-hr
Both documented ceilings — 60GB for the repo, 70GB for full-precision decode — fit inside 80GB, at under a quarter of the H100 SXM rate.
LoRA fine-tuning, especially the 85-frame tier (script is single-GPU)
A100 SXM4 80GB$1.088/GPU-hr
85-frame fine-tuning needs 80GB, and SXM4 bandwidth keeps that 1.67 s/it curve steady; for pure wall-clock, H100 SXM 80GB is $3.582/GPU-hr.

03 —

Getting Mochi running on NexGPU

Four steps from boot to your first 480p clip. Downloading weights is usually the slow part.

01
Spin up an instance with enough VRAM
Pick your GPU at console.nexgpu.net: RTX 4090 24GB for ComfyUI evaluation, A100 80GB if you are running the official repo or fine-tuning. The library of 2,000+ prebuilt images includes PyTorch and ComfyUI, which saves you the two hours of drivers and CUDA. Once it is up, get in over SSH, Jupyter or the web terminal.
```
ssh root@<your-instance-address>
```
02
Install the genmo/mochi repo
The project uses uv for dependencies, and --no-build-isolation is not optional. flash-attn is an optional speedup; install ffmpeg too, or the final export to mp4 will fail.
```
git clone https://github.com/genmoai/mochi && cd mochi && pip install uv && uv venv .venv && source .venv/bin/activate && uv pip install -e . --no-build-isolation
```
03
Pull the weights onto a persistent volume
The official script fetches the DiT, AsymmVAE and T5-XXL into weights/. This step spends network, not VRAM, so put it on persistent storage and skip the re-download on your next boot. Storage runs at a $0.414/GB-month median; compute billing stops the moment the instance stops, while storage keeps accruing until the volume is destroyed.
```
python3 ./scripts/download_weights.py weights/
```
04
Generate: CLI, Gradio, or diffusers for less VRAM
Add --cpu_offload when memory is tight; swap cli.py for demos/gradio_ui.py to get a web UI with the same flags. Attach a trained adapter with --lora_path <path/to/my_mochi_lora.safetensors>. On a 24–32GB card, take the diffusers route instead: MochiPipeline.from_pretrained("genmo/mochi-1-preview", variant="bf16", dtype=torch.bfloat16) plus enable_model_cpu_offload() and vae.enable_tiling() runs in 22GB — and remember to raise num_frames from its default of 19.
```
python3 ./demos/cli.py --model_dir weights/ --cpu_offload
```

What a Mochi deployment actually costs

Start with a ComfyUI evaluation round: RTX 4090 24GB at $0.540/GPU-hr for 3 hours of prompt, frame-count and CFG testing is 3 × $0.540 = $1.62. Give the weights and outputs a 40GB volume — at the $0.414/GB-month median that is 40 × $0.414 = $16.56/month, or $16.56 × 3 ÷ 30 ≈ $1.66 if you keep it three days. Pulling 2GB of finished clips down costs 2 × $0.0081 = $0.016 at the median egress rate. Total: about $3.30. Now the fine-tune: the official fine_tuner runs at roughly 1.67 s/it at 37 frames, so 1,000 steps is 1,670 seconds ≈ 0.46 hours; on A100 SXM4 80GB at $1.088/GPU-hr that is 0.46 × $1.088 ≈ $0.51 of pure training, or 1.5 × $1.088 = $1.63 once you include downloading weights and preprocessing. The same 1.5 hours on H100 SXM 80GB is 1.5 × $3.582 = $5.37 — and since the fine-tuning script is single-GPU only, that premium buys wall-clock time and nothing else. Everything is metered per second and priced per hour, with no minimum, no setup fee and no quota request; stop the instance and compute billing stops with it.

04 —

FAQ

What is the minimum VRAM to run Mochi locally?

The lowest documented bar is the ComfyUI path at under 20GB. On the Python side the leanest option is the diffusers bf16 variant at 22GB, provided you enable both enable_model_cpu_offload() and vae.enable_tiling(). Note these are sampling-stage numbers — stretch the frame count and VAE decode becomes the real peak. On NexGPU that maps to an RTX 4090 24GB at $0.540/GPU-hr, billed per second, so an hour of testing costs less than a coffee.

Can a 24GB RTX 4090 run Mochi?

Yes, through native ComfyUI nodes with mochi_preview_fp8_scaled.safetensors — the documented figure is under 20GB. If you want bf16 weights, or want to push past 85 frames, 24GB gets tight at VAE decode; the community answer is tiled decoding or a bigger card. NexGPU's next tiers are ready to go: RTX 5090 32GB at $0.723/GPU-hr and RTX A6000 48GB at $0.817/GPU-hr, with no quota request to switch.

Can Mochi generate 720p?

Not with the public weights. Genmo released only mochi-1-preview, output is 480p, and the pipeline default resolution is 480×848 — the model card states the release generates video at 480p. The practical route to higher resolution is Mochi for the base clip plus a separate video upscaler. That two-stage pipeline is a natural fit for per-second rental: a NexGPU node can carry up to 14 GPUs with a 2,152GB max node VRAM, so both models can live on one machine.

What GPU does Mochi LoRA fine-tuning need, and how fast does it converge?

The official demos/fine_tuner states 1×H100 or A100 with 80GB recommended: 50GB at 37 frames, 80GB at 85 frames, and the script is single-GPU only, so adding cards does not help. At 37 frames it runs about 1.67 s/it, style changes show by step 200–400, and 1,000 steps takes roughly half an hour. That is an A100 SXM4 80GB at $1.088/GPU-hr on NexGPU — under two dollars for a full run.

How long a video can Mochi generate, and what are the frame-count rules?

At 30fps, the official reproduction example reaches 163 frames — about 5.4 seconds — but decoding those 163 frames in full precision needs 70GB of VRAM; 85 frames (~2.8s) is the common working point. Fine-tuning is stricter: frame counts must be a multiple of six plus one, 25, 31, 37 up to 85. And watch the default — the pipeline's num_frames is 19, which is a 0.6-second clip. To explore all of those limits in one session, NexGPU's A100 PCIE 80GB at $0.824/GPU-hr covers you through the 163-frame tier.

Why does diffusers fail to load the ComfyUI fp8 weights?

This is a documented limitation: diffusers does not support loading the FP8 scaled single-file Mochi checkpoints via from_single_file. Use mochi_preview_bf16.safetensors for the single-file route, or just from_pretrained straight off genmo/mochi-1-preview. The related trap is enabling force_zeros_for_empty_prompt while running the whole pipeline under autocast, which overflows the T5 encoder — run text encoding separately in full precision. NexGPU's 2,000+ prebuilt images ship PyTorch, ComfyUI and Stable Diffusion preconfigured, and support is bilingual over Telegram with no ticket queue.

Start building on NexGPU

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