Model reference · open weights

cmd

Video nvidia Image→video 1 build Non-commercial 107 dl/mo

cmd is an open-weight video model from NVIDIA. cmd (BF16) weighs 75.2 GB; the smallest configuration that runs it is RTX 3060 12 GB.

  • CMD is a causal video diffusion transformer developed by NVIDIA for autoregressive image-to-video generation.
  • Based on the Cosmos-Predict2.5 2B architecture, it generates video in causal chunks using local temporal attention and supports camera-control variants.
  • The model is released under the NVIDIA OneWay Noncommercial License for research and development purposes.

Summary of the nvidia/cmd model card, 2026-10-01

What it is

Released byNVIDIA
Released2026-08-13
VRAM75.2 GB for the weights

What it runs on

Memory and cards for cmd (BF16)

75.2 GBweights, file size
8.6 GBbiggest part
537 MBruntime overhead
CardWeightsMemory
RTX 3060 12 GBfits (encoders offloaded)11.6 GB
RTX 4060 Ti 16 GBfits (encoders offloaded)15.4 GB
RTX 3090 24 GBfits (encoders offloaded)23.4 GB
RTX 4090 24 GBfits (encoders offloaded)23.4 GB
RTX 5090 32 GBfits (encoders offloaded)31.0 GB
L40S 48 GBfits (encoders offloaded)44.0 GB
A100 80 GBtight78.2 GB
H100 80 GBtight78.1 GB
RTX PRO 6000 Blackwell 96 GBfits93.8 GB
DGX Spark (GB10) 128 GB unifiedfits107 GB
H200 141 GBfits138 GB
B200 180 GBfits176 GB

From the model card

What NVIDIA says about cmd

Read the model card

Hmrishav Bandyopadhyay1,2, Xuanchi Ren1, Zijian Huang1, Jay Zhangjie Wu1, Tianshi Cao1, Ruilong Li1, Bryan Chu1, Sanja Fidler1, Yi-Zhe Song2, Zian Wang1

Project Page | Code

Model Overview

Description

Context-Matched Distillation (CMD) is a method for autoregressive video distillation using causal teachers. This repository provides CMD checkpoints based on Cosmos-Predict2.5 2B for causal image-to-video generation.

The release includes chunk-1 and chunk-4 models for short- and long-duration generation, together with camera-control variants. The models use local temporal attention and generate video autoregressively in causal chunks.

This model is for research and development only.

License and Terms of Use

This model is released under the NVIDIA OneWay Noncommercial License. It may only be used for non-commercial research or educational purposes.

Deployment Geography

Global

Intended Use

Primary users include researchers and developers studying:

  • Autoregressive video generation.
  • Causal video distillation.
  • Long-duration video generation.
  • Interactive world models.
  • Camera-controlled video generation.

The checkpoints are not intended for safety-critical applications or uses prohibited by the model license.

Available Checkpoints

CheckpointConfigurationIntended use
chunk1_short_t24_l21.safetensorst24_l21Chunk-1 short-duration generation
chunk4_short_t21_l16.safetensorst21_l16Chunk-4 short-duration generation
chunk1_long_t126_l21.safetensorst126_l21Chunk-1 long-duration generation
chunk4_long_t121_l16.safetensorst121_l16Chunk-4 long-duration generation
chunk1_camera_control_t32_l21.safetensorst32_l21Chunk-1 generation with camera control
chunk4_camera_control_t29_l24.safetensorst29_l24Chunk-4 generation with camera control

In the configuration names, t denotes frame duration and l denotes local attention. Checkpoint names do not include dataset names or training iteration information.

Quick Start

Install the reference implementation:

git clone https://github.com/nv-tlabs/cmd.git
cd cmd

conda create -n causal-cosmos python=3.10 -y
conda activate causal-cosmos
python -m pip install -r requirements.txt
python -m pip install flash-attn --no-build-isolation
python setup.py develop

Download the checkpoints:

hf download nvidia/cmd --local-dir checkpoints

To download one model only:

hf download nvidia/cmd \
  chunk1_short_t24_l21.safetensors \
  --local-dir checkpoints

Follow the inference instructions in the CMD repository to select the matching model configuration and run generation.

Model Architecture

Architecture type: Causal video diffusion transformer

Base model: Cosmos-Predict2.5 2B

Generation strategy: Block-autoregressive video generation

CMD uses causal temporal attention to generate video sequentially. Chunk-1 and chunk-4 variants provide different autoregressive generation granularities, while the camera-control variants add camera-motion conditioning.

Inputs

Standard checkpoints accept:

  • An initial image.
  • A text prompt.

Camera-control checkpoints additionally accept a camera trajectory in the format expected by the CMD inference pipeline.

Outputs

The model produces an RGB video conditioned on the initial image, text prompt, and, when applicable, camera trajectory. Output duration is determined by the selected t configuration.

Software Integration

  • Framework: PyTorch
  • Checkpoint format: Safetensors
  • Reference implementation: nv-tlabs/cmd
  • Preferred operating system: Linux
  • Recommended hardware: NVIDIA CUDA-capable GPU

The checkpoints must be used with the corresponding model architecture and configuration supplied by the reference implementation.

Training Method

CMD uses a two-stage procedure:

  1. Causal teacher pretraining.
  2. Context-matched distillation.

See the CMD repository and project page for the method and evaluation details.

Limitations

  • Autoregressive errors may accumulate during long rollouts.
  • Visual quality and temporal consistency may degrade over time.
  • Generated motion may be physically implausible.
  • Fine details, text, faces, hands, and rapid motion may contain artifacts.
  • Prompt adherence may vary with scene complexity.
  • Camera-control outputs may deviate from the requested trajectory.
  • Generated content may reflect biases present in the training data.

Users should evaluate the model on data representative of their intended application before deployment.

Ethical Considerations

Generated video may be mistaken for authentic footage. Users should clearly identify synthetic content where appropriate and must not use the model for deception, impersonation, harassment, misinformation, or violations of privacy, intellectual-property, or other applicable rights.

NVIDIA believes Trustworthy AI is a shared responsibility. Developers should ensure that their use of this model complies with applicable laws, policies, licenses, and safety requirements.

Please report model quality, risk, security vulnerabilities, or NVIDIA AI concerns through the NVIDIA support portal.

Citation

If you find this work useful, please cite:

@article{bandyopadhyay2026context,
  title   = {Context-Matched Distillation: Teacher Causality for Autoregressive Video Distillation},
  author  = {Bandyopadhyay, Hmrishav and Ren, Xuanchi and Huang, Zijian
             and Wu, Jay Zhangjie a

Quoted from the model card on Hugging Face. The full card is behind the Hugging Face link above.

How it works

How video models work

Prompt / imagestart pointTemporal diffusionframes over timeVideoMP4 clipA video model generates a sequence of coherent frames from your prompt or a starting image.

Running it yourself

Run it on a rented GPU

Rent a machine by the hour. ComfyUI is installed on it. Open ComfyUI through the tunnel and load the workflow from the model's card on Hugging Face; choose this model's file in its loader.

# on your rented machine (the ssh line is on its page in the console)
# get REPO FILE FOLDER: one file into /workspace/models/FOLDER, where ComfyUI loads it from
get() { hf download "$1" "$2" --local-dir /workspace/hf-files && mkdir -p "/workspace/models/$3" && mv "/workspace/hf-files/$2" "/workspace/models/$3/$4"; }

# the model (4.0 GB)
get nvidia/cmd chunk1_camera_control_t32_l21.safetensors diffusion_models

start-comfyui
Renting a GPU: connect, tunnels, ComfyUI
# on your computer, in a second terminal: ComfyUI in your browser at http://localhost:8188
# HOST and PORT are your machine's, from its page in the console
ssh -L 8188:localhost:8188 dev@HOST -p PORT
© 2026 AxForge · EU-hosted AI infrastructure Pricing Docs Trust Privacy Terms