Model reference · open weights

Allegro

Video rhymes-ai Text→video 1 build Open weights 901 dl/mo

Allegro is an open-weight video model from rhymes-ai. Allegro (BF16) weighs 25.3 GB; the smallest configuration that runs it is RTX 4090 24 GB.

  • Allegro is a 2.8B parameter text-to-video model developed by rhymes-ai that generates 6-second videos at 720x1280 resolution and 15 FPS.
  • The model supports English prompts and operates with a context length of 79.2K tokens, equivalent to 88 frames.
  • It is released under the Apache 2.0 license and requires 9.3 GB of GPU memory in BF16 mode when using CPU offloading.

Summary of the rhymes-ai/Allegro model card, 2026-10-01

What it is

Released byrhymes-ai
Released2024-10-16
Parameters2.8B
VRAM25.3 GB for the weights

What it runs on

Memory and cards for Allegro (BF16)

25.3 GBweights, file size
19.0 GBbiggest part
537 MBruntime overhead
CardWeightsMemory
RTX 3060 12 GB … RTX 4060 Ti 16 GBdoes not fit
RTX 3090 24 GBfits (encoders offloaded)23.4 GB
RTX 4090 24 GBfits (encoders offloaded)23.4 GB
RTX 5090 32 GBfits31.0 GB
L40S 48 GBfits44.0 GB
A100 80 GBfits78.2 GB
H100 80 GBfits78.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 rhymes-ai says about Allegro

Read the model card
  • Open Source: Full model weights and code available to the community, Apache 2.0!
  • Versatile Content Creation: Capable of generating a wide range of content, from close-ups of humans and animals to diverse dynamic scenes.
  • High-Quality Output: Generate detailed 6-second videos at 15 FPS with 720x1280 resolution, which can be interpolated to 30 FPS with EMA-VFI.
  • Small and Efficient: Features a 175M parameter VideoVAE and a 2.8B parameter VideoDiT model. Supports multiple precisions (FP32, BF16, FP16) and uses 9.3 GB of GPU memory in BF16 mode with CPU offloading. Context length is 79.2K, equivalent to 88 frames.

Model info

Quick start

  1. Install the necessary requirements.

    • Ensure Python >= 3.10, PyTorch >= 2.4, CUDA >= 12.4.

    • It is recommended to use Anaconda to create a new environment (Python >= 3.10) conda create -n rllegro python=3.10 -y to run the following example.

    • run pip install git+https://github.com/huggingface/diffusers.git torch==2.4.1 transformers==4.40.1 accelerate sentencepiece imageio imageio-ffmpeg beautifulsoup4

  2. Run inference.

    import torch
    from diffusers import AutoencoderKLAllegro, AllegroPipeline
    from diffusers.utils import export_to_video
    vae = AutoencoderKLAllegro.from_pretrained("rhymes-ai/Allegro", subfolder="vae", torch_dtype=torch.float32)
    pipe = AllegroPipeline.from_pretrained(
        "rhymes-ai/Allegro", vae=vae, torch_dtype=torch.bfloat16
    )
    pipe.to("cuda")
    pipe.vae.enable_tiling()
    prompt = "A seaside harbor with bright sunlight and sparkling seawater, with many boats in the water. From an aerial view, the boats vary in size and color, some moving and some stationary. Fishing boats in the water suggest that this location might be a popular spot for docking fishing boats."
    
    positive_prompt = """
    (masterpiece), (best quality), (ultra-detailed), (unwatermarked),
    {}
    emotional, harmonious, vignette, 4k epic detailed, shot on kodak, 35mm photo,
    sharp focus, high budget, cinemascope, moody, epic, gorgeous
    """
    
    negative_prompt = """
    nsfw, lowres, bad anatomy, bad hands, text, error, missing fingers, extra digit, fewer digits, cropped, worst quality,
    low quality, normal quality, jpeg artifacts, signature, watermark, username, blurry.
    """
    
    prompt = prompt.format(prompt.lower().strip())
    
    video = pipe(prompt, negative_prompt=negative_prompt, guidance_scale=7.5, max_sequence_length=512, num_inference_steps=100, generator = torch.Generator(device="cuda:0").manual_seed(42)).frames[0]
    export_to_video(video, "output.mp4", fps=15)
    

    Use pipe.enable_sequential_cpu_offload() to offload the model into CPU for less GPU memory cost (about 9.3G, compared to 27.5G if CPU offload is not enabled), but the inference time will increase significantly.

  3. (Optional) Interpolate the video to 30 FPS.

    It is recommended to use EMA-VFI to interpolate the video from 15 FPS to 30 FPS.

    For better visual quality, please use imageio to save the video.

  4. For faster inference such Context Parallel, PAB, please refer to our github repo.

License

This repo is released under the Apache 2.0 License.

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

Running it yourself

Run it on a rented GPU

Rent a machine by the hour. Runs as it is with diffusers, on the machine, in Python.

# on your rented machine: pip install diffusers transformers accelerate ftfy
import torch
from diffusers import DiffusionPipeline
from diffusers.utils import export_to_video

pipe = DiffusionPipeline.from_pretrained("rhymes-ai/Allegro", torch_dtype=torch.bfloat16).to("cuda")
frames = pipe(prompt="a drone shot over a forest at sunrise").frames[0]
export_to_video(frames, "/workspace/out.mp4", fps=16)
Renting a GPU: connect, tunnels, Python
© 2026 AxForge · EU-hosted AI infrastructure Pricing Docs Trust Privacy Terms