LongCat-Video: Meituan's Open-Source 13.6B Video Generation Model

LongCat-Video is an open-source video generation model released by Meituan's LongCat team. It has 13.6 billion parameters, it handles text-to-video, image-to-video and video-continuation in a single model, and it was built specifically to keep going — producing videos that run for minutes rather than the five-second clips most open models top out at.

It is released under the MIT licence, weights included. That combination — long-form output, one model for three tasks, and a permissive licence — is what makes it worth a closer look, whether you are evaluating it for production or just want to know where open video generation currently stands.

What LongCat-Video actually is

Most open video models are trained to do one thing. You pick a text-to-video checkpoint, and if you later want to animate a still image you fetch a different checkpoint with different weights, different quirks and a different prompt style.

LongCat-Video collapses that. One 13.6B model natively supports three tasks:

• Text-to-Video — a prompt in, a clip out.
• Image-to-Video — a still image becomes the first frame, and the model animates forward from it.
• Video-Continuation — you hand it existing footage and it carries on from where the footage stopped.

The team describes it as a foundational model and calls it their first step toward world models — systems that hold a coherent internal picture of a scene and evolve it over time, rather than producing a handsome but disconnected sequence of frames. That framing explains most of the design decisions below.

Architecturally it is dense, not mixture-of-experts. Every one of its 13.6B parameters is active on every forward pass. Wan 2.2, its closest open-source comparison, is an MoE with 28B total parameters of which 14B activate per pass. Roughly the same compute per step, half the memory footprint for weights.

The four things it does well

1. One architecture, three tasks

Unification is not just a packaging convenience. Because Video-Continuation shares weights with Text-to-Video and Image-to-Video, the model's understanding of “what happens next” feeds directly into how it starts a clip. In practice this means you can chain tasks: generate an opening from a prompt, continue it, continue it again, and stay inside one model the whole way.

2. Long video generation, natively

This is the headline. LongCat-Video is pretrained on the Video-Continuation task rather than having continuation bolted on afterwards. The result, per the team, is minutes-long video without colour drifting or quality degradation.

3. Efficient inference

It targets 720p at 30fps in minutes, using a coarse-to-fine strategy along both the temporal and the spatial axis — generate something rough and short-stride first, then refine detail and fill in frames. Block Sparse Attention cuts the attention cost further, and the benefit grows with resolution, which is exactly where you want the savings.

4. Multi-reward RLHF

The model is tuned with multi-reward Group Relative Policy Optimization (GRPO). Rather than optimising one preference score, several reward signals are balanced at once — the practical reason a model can score well on prompt-following without its motion turning to soup. Meituan reports results comparable to leading open-source models and to recent commercial systems.

Why long video is the hard part

If you have generated video before, you know the failure mode. The first two seconds look great. By second six the colours have warped slightly warmer, textures have started to smear, and by second twelve the subject has quietly become a different person.

This happens because long clips are usually produced by generating a chunk, taking its last frame, and generating the next chunk from that. Every hand-off carries forward the previous chunk's small errors, and the next chunk adds its own. Errors compound. That is colour drift and quality degradation, and it is a property of the method, not of insufficient model size.

LongCat-Video's answer is to make continuation a first-class pretraining objective. A model that has spent its training seeing “here is real footage, produce what genuinely came next” learns to treat prior frames as constraints rather than as a loose style reference. That is what keeps a clip stable minute after minute.

The distinction that matters: most models can be made to output long video. LongCat-Video is trained for it. Those produce very different results at the two-minute mark.

LongCat-Video-Avatar 1.5

Alongside the base model, the team maintains an avatar line for audio-driven human video — you supply audio and a reference, and it generates a character speaking it, lip-synced.

The release history is short and quick:

Version 1.5 is the meaningful upgrade, and its changes are unusually concrete:

• Whisper-Large replaces Wav2Vec2 as the audio encoder, for more accurate lip synchronisation. Whisper carries far more linguistic context than a raw acoustic encoder, and lip shapes depend on which phoneme is being spoken, not just on how loud the moment is.
• Production-ready physical rationality and temporal stability, with robust long-video generation — the avatar line inherits the base model's staying power.
• Generalises to stylised domains: anime, animals, and complex real-world conditions, not just a person in front of a clean background.
• Single-stream and multi-stream audio, so more than one character can speak in the same generated scene.
• 8-step inference via step distillation. This is the change you feel most — diffusion sampling is the dominant cost, and cutting the step count is close to a linear speed-up.

How it benchmarks

Meituan publishes Mean Opinion Score (MOS) results from human raters on their internal benchmark. Two things to keep in mind before reading them: MOS is subjective by construction, and these are the authors' own numbers. Useful for orientation, not a substitute for testing on your own prompts.

Text-to-Video

On text-to-video LongCat-Video takes the best overall score of the three non-Veo3 systems, edging past both PixVerse-V5 and Wan 2.2 — while running half the active parameters of Wan. Veo3 still leads overall, largely on text alignment and motion.

Image-to-Video

Image-to-video is the weaker showing, and it is worth being straight about it: LongCat-Video comes last on overall quality here, pulled down mainly by motion quality (3.59 against roughly 3.8 for the others). It does take the top visual-quality score, and it beats Wan 2.2 on text alignment by a clear margin — so per-frame fidelity and prompt-following are fine. It is the movement that lags.

The practical read: prefer LongCat-Video when your priority is text-driven generation, or length, or both. If your workload is animating single stills where fluid motion is the whole product, benchmark it against alternatives before committing.

Installation

Clone the repository:

git clone --single-branch --branch main https://github.com/meituan-longcat/LongCat-Video
cd LongCat-Video

Set up the environment. The pinned versions matter here — FlashAttention in particular is fussy about the torch and CUDA it was built against:

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

# install torch (configure according to your CUDA version)
pip install torch==2.6.0+cu124 torchvision==0.21.0+cu124 torchaudio==2.6.0 \
  --index-url https://download.pytorch.org/whl/cu124

# 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

If you also want the avatar models, add:

conda install -c conda-forge librosa
conda install -c conda-forge ffmpeg
pip install -r requirements_avatar.txt

FlashAttention-2 is enabled by default in the model config. You can switch to FlashAttention-3 or xformers by editing ./weights/LongCat-Video/dit/config.json once the alternative is installed — useful if your GPU generation or driver stack is happier with one than the other.

Which model to download

pip install "huggingface_hub[cli]"

huggingface-cli download meituan-longcat/LongCat-Video \
  --local-dir ./weights/LongCat-Video

huggingface-cli download meituan-longcat/LongCat-Video-Avatar \
  --local-dir ./weights/LongCat-Video-Avatar

huggingface-cli download meituan-longcat/LongCat-Video-Avatar-1.5 \
  --local-dir ./weights/LongCat-Video-Avatar-1.5

You do not need all three. Pull the base model for general generation, or Avatar 1.5 for talking characters.

Running each task

Every demo follows the same shape: torchrun, a task script, and a checkpoint directory. Add --nproc_per_node=N and a matching --context_parallel_size=N to shard across GPUs. --enable_compile turns on torch compilation — slower on the first run, faster on every one after.

Text-to-Video

# single GPU
torchrun run_demo_text_to_video.py \
  --checkpoint_dir=./weights/LongCat-Video --enable_compile

# two GPUs
torchrun --nproc_per_node=2 run_demo_text_to_video.py \
  --context_parallel_size=2 \
  --checkpoint_dir=./weights/LongCat-Video --enable_compile

Image-to-Video

torchrun run_demo_image_to_video.py \
  --checkpoint_dir=./weights/LongCat-Video --enable_compile

Video-Continuation

torchrun run_demo_video_continuation.py \
  --checkpoint_dir=./weights/LongCat-Video --enable_compile

Long video

torchrun run_demo_long_video.py \
  --checkpoint_dir=./weights/LongCat-Video --enable_compile

Interactive video

torchrun run_demo_interactive_video.py \
  --checkpoint_dir=./weights/LongCat-Video --enable_compile

Avatar 1.5, single audio stream

Here --stage_1 picks the entry task: at2v for audio + text, ai2v for audio + image. --use_distill enables the 8-step path and --use_int8 quantises to save memory.

# audio + text to video
torchrun --nproc_per_node=2 run_demo_avatar_single_audio_to_video.py \
  --context_parallel_size=2 \
  --checkpoint_dir=./weights/LongCat-Video-Avatar-1.5 \
  --stage_1=at2v --input_json=assets/avatar/single_example_1.json \
  --use_distill --model_type avatar-v1.5 --use_int8

# audio + image to video, then continue for 5 segments
torchrun --nproc_per_node=2 run_demo_avatar_single_audio_to_video.py \
  --context_parallel_size=2 \
  --checkpoint_dir=./weights/LongCat-Video-Avatar-1.5 \
  --stage_1=ai2v --input_json=assets/avatar/single_example_1.json \
  --num_segments=5 --ref_img_index=10 --mask_frame_range=3 \
  --use_distill --model_type avatar-v1.5 --use_int8

Avatar 1.5, multiple audio streams

torchrun --nproc_per_node=2 run_demo_avatar_multi_audio_to_video.py \
  --context_parallel_size=2 \
  --checkpoint_dir=./weights/LongCat-Video-Avatar-1.5 \
  --input_json=assets/avatar/multi_example_1.json \
  --use_distill --model_type avatar-v1.5 --use_int8

The Streamlit demo

For clicking around instead of writing flags:

streamlit run ./run_streamlit.py --server.fileWatcherType none --server.headless=false

Making it faster

Three levers, roughly in order of payoff:

1. Step distillation (Avatar 1.5). Eight steps instead of the usual dozens. Free, already in the checkpoint, enabled with --use_distill.
2. Caching. The community project CacheDiT supports LongCat-Video with DBCache and TaylorSeer, reporting close to 1.7× speed-up without obvious precision loss. Diffusion transformers repeat a lot of near-identical work between adjacent steps; caching skips it.
3. Context parallelism. --context_parallel_size=N splits the sequence across N GPUs. This is how you attack long clips specifically, since the sequence dimension is what grows with duration.

Add --use_int8 when memory rather than time is your constraint.

Licence and responsible use

The weights are released under the MIT Licence, and contributions to the repository are MIT unless stated otherwise. MIT is about as permissive as it gets: commercial use, modification and redistribution are all fine, provided the licence notice travels with the code.

Two caveats worth reading properly:

• The licence does not grant rights to Meituan trademarks or patents. You can ship products built on the model; you cannot brand them as Meituan's.
• The team is explicit that the model has not been evaluated for every downstream application. Their guidance is to assess accuracy, safety and fairness before deploying in sensitive or high-risk settings, and to comply with applicable law on data protection, privacy and content safety.

That second point deserves real weight for the avatar models in particular. A system that generates a convincing person speaking supplied audio is a synthetic-media tool, and the consent, disclosure and likeness questions that come with it are yours to answer, not the licence's.

Who should actually use this

Good fit if:

• You need clips longer than a few seconds and are tired of stitching around drift.
• You want text-to-video quality competitive with larger open models at a smaller active-parameter count.
• You need audio-driven characters and want lip sync that holds up over a long take.
• A permissive licence with downloadable weights is a hard requirement — on-premise, air-gapped, or simply no per-second API bill.
• You want one model to maintain instead of three.

Look elsewhere if:

• Your workload is dominated by image-to-video where motion quality is the deliverable — that is this model's weakest published result.
• You have no CUDA GPUs available. The published path assumes torch with CUDA 12.4 and FlashAttention.
• You want top-of-the-league overall quality regardless of cost or openness, in which case the proprietary systems still lead on several axes.

Frequently asked questions

Sources and further reading

• LongCat-Video on GitHub — code, demo scripts and the official README.
• LongCat-Video Technical Report (arXiv:2510.22200).
• LongCat-Video-Avatar 1.5 Technical Report (arXiv:2605.26486).
• meituan-longcat on Hugging Face — all three checkpoints.

The team credits the Wan, UMT5-XXL, Diffusers and Hugging Face projects for their open research, and can be reached at longcat-team@meituan.com.