Helios-Distilled: Real Real-Time Long Video Generation Model

Summary

• Introduction
• Highlights
• Parameters
• Usage for developers
• Reference
• License
• Citation

Introduction

Helios-Distilled is a 14B video generation model that produces up to 60 seconds of high-quality video at 19.5 FPS on a single NVIDIA H100 — without KV-cache, quantization, or anti-drifting hacks. It supports text-to-video, image-to-video, and video continuation in a single model. This is the Distilled variant (3 inference steps), distilled from Helios-Base (50 steps) using Adversarial Hierarchical Distillation. For full technical details, see the paper.

Highlights

1. Without commonly used anti-drifting strategies (e.g., self-forcing, error-banks, keyframe sampling, or inverted sampling), Helios generates minute-scale videos with high quality and strong coherence.
2. Without standard acceleration techniques (e.g., KV-cache, causal masking, sparse/linear attention, TinyVAE, progressive noise schedules, hidden-state caching, or quantization), Helios achieves 19.5 FPS in end-to-end inference on a single H100 GPU.
3. We introduce optimizations that improve both training and inference throughput while reducing memory consumption, enabling image-diffusion-scale batch sizes during training while fitting up to four 14B models within 80 GB of GPU memory.

Parameters

Inputs

• mode - (text): Specifies the generation mode. Supported options: Text-to-Video, Image-to-Video, Video-to-Video
• prompt - (text): A text description that guides the content, style, or motion of the generated video.
• image_input - (image -.png|.jpg|.jpeg): An input image used when the mode is Image-to-Video.
• video_input - (video -.mp4): An input video used when the mode is Video-to-Video.
• height - (integer): The height of the output video in pixels. Range: 1 to 1024.
• width - (integer): The width of the output video in pixels. Range: 1 to 1024.
• num_frames - (integer): The total number of frames to generate. Range: 33 to 231.
• num_inference_steps - (integer): The number of inference steps used during generation. More steps typically improve quality but increase processing time. Range: 1 to 10.
• seed - (integer): Controls randomness for reproducibility. Using the same seed will yield consistent outputs. Range: 0 to 4,294,967,295.
• is_amplify_first_chunk - (bool -True|False): Whether to enhance or emphasize the first segment of the generated video.

Output

• output_video - (video -.mp4): The generated video based on the selected mode and input parameters. The output reflects the provided prompt and/or input media, with the specified resolution and number of frames.

Usage for developers

Below you will find details for running the model on our platform.

Requirements

pip install -r requirements.txt

Code based on AIOZ structure

import torch
import tempfile
import os
from diffusers import AutoencoderKLWan, HeliosDMDScheduler, HeliosPyramidPipeline
from diffusers.utils import export_to_video, load_image, load_video

...

def load_model(model_path: str):
    ...
    
def do_ai_task(
        mode: str,
        prompt: str,
        image_input: Optional[str],
        video_input: Optional[str],
        height: int,
        width: int,
        num_frames: int,
        num_inference_steps: int,
        seed: int,
        is_amplify_first_chunk: bool,
        model_storage_directory: Union[str, Path],
        device: Literal["cpu", "cuda", "gpu"] = "cpu",
        *args, **kwargs) -> Any:
    """Define AI task: load model, pre-process, post-process, etc ..."""
    # Define AI task workflow. Below is an example

    model_path = model_storage_directory + "/Helios-Distilled"
    pipe = load_model(model_path)
    generator = torch.Generator(device="cuda").manual_seed(int(seed))
    
    kwargs = {
        "prompt": prompt,
        "height": int(height),
        "width": int(width),
        "num_frames": int(num_frames),
        "guidance_scale": 1.0,
        "generator": generator,
        "output_type": "np",
        "pyramid_num_inference_steps_list": [
            int(num_inference_steps),
            int(num_inference_steps),
            int(num_inference_steps),
        ],
        "is_amplify_first_chunk": is_amplify_first_chunk,
    }

    ...

    return video_bytes

Reference

This model is the AIOZ AI deployment of the Helios model, developed jointly by PKU-YuanGroup and ByteDance.. See the original repository and paper for full details.

License

This model is released under the Apache-2.0 License, consistent with the original Helios release.

Citation

@article{helios,
  title={Helios: Real Real-Time Long Video Generation Model},
  author={Yuan, Shenghai and Yin, Yuanyang and Li, Zongjian and Huang, Xinwei and Yang, Xiao and Yuan, Li},
  journal={arXiv preprint arXiv:2603.04379},
  year={2026}
}