LongCat-Video

LongCat-Video

Makes videos from a text prompt, from a still image, or by continuing an existing clip, with one 13.6B model. Aims at long clips at 720p and 30 fps, for developers and researchers with GPUs.

Made by meituan-longcat on Hugging Face. These notes are Mindket's, written from its model page and model card; the model's own files and license are on Hugging Face.

About

What it is: LongCat-Video is a 13.6 billion parameter video generation model from Meituan's LongCat team. A single set of weights covers three tasks: it turns text into video, animates an image, or extends a clip. It was pretrained on continuation, which is how the authors say it keeps color and quality steady across clips that run for minutes. They call it a first step toward world models.

Who it suits: Developers and researchers who run video models on their own GPUs and want a single model for several video tasks. It is code you run from a command line, so it suits people comfortable with Python and conda.

Industry | Who uses it | How they use it | Example
Media | Video creators | Make clips from text or a still image | A short scene from a written prompt
Software | Developers | Build video generation into a tool | A service that animates a product picture
Research | Video model researchers | Study long video generation | Checking how a clip holds its color over minutes
Marketing | Marketing teams | Draft video concepts from a prompt | A concept clip for a campaign

You can skip it if you have no suitable GPU, or if you want a hosted tool with no setup, since you run everything from code here.

Where to use it:

• A command line with torchrun, on one GPU or on two
• A conda environment with Python 3.10
• A machine whose PyTorch build matches its CUDA version
• Windows, macOS or Linux with Python, to download the files

Use case | Who | What they get back
Text to video | Creators | A video made from a written prompt
Image to video | Designers | A video that starts from your picture
Video continuation | Researchers | A longer clip that extends an existing one

How to set it up:

• conda, with a Python 3.10 environment
• A PyTorch build that matches your CUDA version, installed as the card describes
• The LongCat-Video code from its GitHub repository, since the demo scripts live there
• FlashAttention-2, which the model config enables by default

1. Get the code from the project's GitHub repository and open its folder. The clone command holds a web address, so it is not copied here.
2. Create the conda environment and activate it.
3. Install PyTorch for your CUDA version. Its command holds a web address, so follow the card.
4. Install flash-attn and the other requirements.
5. Download the model weights into a weights folder.

conda create -n longcat-video python=3.10
conda activate longcat-video

# install flash-attn-2
pip install ninja
pip install psutil
pip install packaging
pip install flash_attn==2.7.4.post1

# install other requirements
pip install -r requirements.txt

pip install "huggingface_hub[cli]"
huggingface-cli download meituan-longcat/LongCat-Video --local-dir ./weights/LongCat-Video

How to use it: Run one of the three demo scripts with torchrun and point it at the weights folder. For two GPUs, add the process count and the context parallel size. The visible card text does not show where the prompt goes, so check the demo script itself.

# Single-GPU inference
torchrun run_demo_text_to_video.py --checkpoint_dir=./weights/LongCat-Video --enable_compile

# Multi-GPU inference
torchrun --nproc_per_node=2 run_demo_text_to_video.py --context_parallel_size=2 --checkpoint_dir=./weights/LongCat-Video --enable_compile

# Single-GPU inference
torchrun run_demo_image_to_video.py --checkpoint_dir=./weights/LongCat-Video --enable_compile

# Single-GPU inference
torchrun run_demo_video_continuation.py --checkpoint_dir=./weights/LongCat-Video --enable_compile

Tool | What it does
run_demo_text_to_video.py | Makes a video from a text prompt
run_demo_image_to_video.py | Makes a video that starts from an image
run_demo_video_continuation.py | Extends an existing video clip
torchrun | Starts a run on one GPU or on several

Example: You run the text to video demo on a single GPU and point it at the weights folder. The script produces a video from its prompt. The authors say 720p clips at 30 fps take minutes to generate.

For newcomers and experts: If you are new, start with the text to video demo on a single GPU and leave the other two scripts for later. Expect a long setup, since it needs a conda environment, a matching PyTorch build and flash-attn.

If you know the field: the authors build one framework for all three tasks, so the same weights serve each. Speed comes from coarse-to-fine generation along both time and space, plus Block Sparse Attention at high resolutions. Training adds multi-reward Group Relative Policy Optimization, and you can switch FlashAttention-2 to FlashAttention-3 or xformers in the model config.

Text, image or video clip
LongCat-Video, 13.6B parameters
Coarse-to-fine generation
720p video at 30 fps

Good to know: The authors say their tests put the model on par with leading open-source video models, and with some commercial ones. Those are their own results, so check them against your needs.

• Size: 13.6B parameters
• Output: 720p at 30 fps, as the card describes
• Languages: English and Chinese
• Attention: FlashAttention-2 by default
• License: MIT
• Cost to run: none named, though it needs GPU hardware
• Data it reaches: model files downloaded to your computer, and the project code from GitHub
• Not for: machines without a suitable GPU, since the card shows only GPU runs

On Hugging Face, 13 November 2026

• Task: text to video
• Library: diffusers
• Formats: Safetensors
• Downloads in the last 30 days: 3,135
• Likes: 594
• License: mit
• Languages: en, zh
• Quantized versions: 8
• Fine-tunes: 3
• Tags: diffusers, safetensors, transformers, image-to-video, video-continuation, text-to-video

Links

• Model: https://huggingface.co/meituan-longcat/LongCat-Video
• Files: https://huggingface.co/meituan-longcat/LongCat-Video/tree/main

Get the model

Download its files with Hugging Face's command line:

pip install -U huggingface_hub
hf download meituan-longcat/LongCat-Video

Then follow the usage in its model card. Nothing in this kit runs by itself.