# Hunyuan Video

Generate high-quality videos with Tencent's open-source Hunyuan Video.

{% hint style="success" %}
All examples can be run on GPU servers rented through [CLORE.AI Marketplace](https://clore.ai/marketplace).
{% endhint %}

## Renting on CLORE.AI

1. Visit [CLORE.AI Marketplace](https://clore.ai/marketplace)
2. Filter by GPU type, VRAM, and price
3. Choose **On-Demand** (fixed rate) or **Spot** (bid price)
4. Configure your order:
   * Select Docker image
   * Set ports (TCP for SSH, HTTP for web UIs)
   * Add environment variables if needed
   * Enter startup command
5. Select payment: **CLORE**, **BTC**, or **USDT/USDC**
6. Create order and wait for deployment

### Access Your Server

* Find connection details in **My Orders**
* Web interfaces: Use the HTTP port URL
* SSH: `ssh -p <port> root@<proxy-address>`

## What is Hunyuan Video?

Hunyuan Video from Tencent offers:

* High-quality text-to-video generation
* 5+ second video clips
* 720p resolution
* Open-source and commercially usable

## Resources

* **Model:** [tencent/HunyuanVideo](https://huggingface.co/tencent/HunyuanVideo)
* **GitHub:** [Tencent/HunyuanVideo](https://github.com/Tencent/HunyuanVideo)
* **Paper:** [HunyuanVideo Paper](https://arxiv.org/abs/2412.03603)

## Recommended Hardware

| Component | Minimum       | Recommended | Optimal    |
| --------- | ------------- | ----------- | ---------- |
| GPU       | RTX 4090 24GB | A100 40GB   | A100 80GB  |
| VRAM      | 24GB          | 40GB        | 80GB       |
| CPU       | 8 cores       | 16 cores    | 32 cores   |
| RAM       | 32GB          | 64GB        | 128GB      |
| Storage   | 100GB NVMe    | 200GB NVMe  | 500GB NVMe |
| Internet  | 500 Mbps      | 1 Gbps      | 1 Gbps     |

## Quick Deploy on CLORE.AI

**Docker Image:**

```
pytorch/pytorch:2.5.1-cuda12.4-cudnn9-devel
```

**Ports:**

```
22/tcp
7860/http
```

**Command:**

```bash
git clone https://github.com/Tencent/HunyuanVideo.git && \
cd HunyuanVideo && \
pip install -r requirements.txt && \
python sample_video.py --prompt "A cat walking in a garden"
```

## Accessing Your Service

After deployment, find your `http_pub` URL in **My Orders**:

1. Go to **My Orders** page
2. Click on your order
3. Find the `http_pub` URL (e.g., `abc123.clorecloud.net`)

Use `https://YOUR_HTTP_PUB_URL` instead of `localhost` in examples below.

## Installation

```bash
git clone https://github.com/Tencent/HunyuanVideo.git
cd HunyuanVideo
pip install -r requirements.txt

# Download models
python download_models.py
```

## What You Can Create

### Marketing Content

* Product showcase videos
* Social media clips
* Promotional animations

### Creative Projects

* Music video concepts
* Short film prototypes
* Art installations

### Education & Training

* Explainer video drafts
* Training material concepts
* Visualization of concepts

## Basic Usage

```python
import torch
from diffusers import HunyuanVideoPipeline
from diffusers.utils import export_to_video

pipe = HunyuanVideoPipeline.from_pretrained(
    "tencent/HunyuanVideo",
    torch_dtype=torch.float16
)
pipe.to("cuda")
pipe.enable_model_cpu_offload()
pipe.vae.enable_tiling()

prompt = "A majestic eagle soaring over snow-capped mountains, cinematic lighting, 4K"

video_frames = pipe(
    prompt=prompt,
    num_frames=45,
    num_inference_steps=50,
    guidance_scale=7.0
).frames[0]

export_to_video(video_frames, "eagle.mp4", fps=15)
```

## Advanced Generation

```python
import torch
from diffusers import HunyuanVideoPipeline
from diffusers.utils import export_to_video

pipe = HunyuanVideoPipeline.from_pretrained(
    "tencent/HunyuanVideo",
    torch_dtype=torch.float16
)
pipe.to("cuda")
pipe.enable_model_cpu_offload()
pipe.vae.enable_tiling()
pipe.vae.enable_slicing()

video_frames = pipe(
    prompt="Time-lapse of a flower blooming, macro photography, detailed petals",
    negative_prompt="blurry, low quality, distorted, ugly",
    num_frames=45,
    height=544,
    width=960,
    num_inference_steps=50,
    guidance_scale=7.0,
    generator=torch.Generator("cuda").manual_seed(42)
).frames[0]

export_to_video(video_frames, "flower_bloom.mp4", fps=15)
```

## Prompt Examples

### Nature & Landscapes

```python
prompts = [
    "Aurora borealis dancing over a frozen lake, time-lapse, ethereal",
    "Ocean waves crashing on volcanic black sand beach, slow motion",
    "Thunderstorm over a wheat field, dramatic lighting, 4K",
    "Cherry blossoms falling in a Japanese garden, spring, peaceful"
]
```

### Sci-Fi & Fantasy

```python
prompts = [
    "Spaceship launching from a futuristic city, cinematic, detailed",
    "Dragon flying through clouds at sunset, epic, fantasy",
    "Robot walking through neon-lit streets, cyberpunk, rain",
    "Magical portal opening in an ancient forest, mystical lights"
]
```

### Abstract & Artistic

```python
prompts = [
    "Ink drops diffusing in water, macro, colorful, abstract",
    "Geometric shapes morphing and transforming, motion graphics",
    "Light painting in darkness, long exposure effect, vibrant"
]
```

## Batch Generation

```python
import os
import torch
from diffusers import HunyuanVideoPipeline
from diffusers.utils import export_to_video

pipe = HunyuanVideoPipeline.from_pretrained("tencent/HunyuanVideo", torch_dtype=torch.float16)
pipe.to("cuda")
pipe.enable_model_cpu_offload()
pipe.vae.enable_tiling()

prompts = [
    "Underwater coral reef with colorful fish swimming",
    "City traffic time-lapse at night, light trails",
    "Butterfly emerging from cocoon, nature documentary"
]

output_dir = "./videos"
os.makedirs(output_dir, exist_ok=True)

for i, prompt in enumerate(prompts):
    print(f"Generating {i+1}/{len(prompts)}: {prompt[:50]}...")

    video_frames = pipe(
        prompt=prompt,
        num_frames=45,
        num_inference_steps=50,
        guidance_scale=7.0
    ).frames[0]

    export_to_video(video_frames, f"{output_dir}/video_{i:03d}.mp4", fps=15)
```

## Gradio Interface

```python
import gradio as gr
import torch
from diffusers import HunyuanVideoPipeline
from diffusers.utils import export_to_video
import tempfile

pipe = HunyuanVideoPipeline.from_pretrained("tencent/HunyuanVideo", torch_dtype=torch.float16)
pipe.to("cuda")
pipe.enable_model_cpu_offload()
pipe.vae.enable_tiling()

def generate(prompt, negative_prompt, num_frames, steps, guidance, seed):
    generator = torch.Generator("cuda").manual_seed(seed) if seed > 0 else None

    video_frames = pipe(
        prompt=prompt,
        negative_prompt=negative_prompt,
        num_frames=num_frames,
        num_inference_steps=steps,
        guidance_scale=guidance,
        generator=generator
    ).frames[0]

    with tempfile.NamedTemporaryFile(suffix=".mp4", delete=False) as f:
        export_to_video(video_frames, f.name, fps=15)
        return f.name

demo = gr.Interface(
    fn=generate,
    inputs=[
        gr.Textbox(label="Prompt", lines=3),
        gr.Textbox(label="Negative Prompt", value="blurry, low quality"),
        gr.Slider(16, 60, value=45, step=1, label="Frames"),
        gr.Slider(20, 100, value=50, step=5, label="Steps"),
        gr.Slider(3, 12, value=7, step=0.5, label="Guidance"),
        gr.Number(value=-1, label="Seed")
    ],
    outputs=gr.Video(label="Generated Video"),
    title="Hunyuan Video - Text to Video on CLORE.AI"
)

demo.launch(server_name="0.0.0.0", server_port=7860)
```

## Performance

| Resolution | Frames | GPU       | Time    |
| ---------- | ------ | --------- | ------- |
| 544x960    | 45     | RTX 4090  | \~5 min |
| 544x960    | 45     | A100 40GB | \~3 min |
| 544x960    | 45     | A100 80GB | \~2 min |
| 720x1280   | 45     | A100 80GB | \~4 min |

## Common Problems & Solutions

### Out of Memory

**Problem:** CUDA out of memory on 24GB GPU

**Solutions:**

```python

# Enable all memory optimizations
pipe.enable_model_cpu_offload()
pipe.enable_sequential_cpu_offload()  # More aggressive
pipe.vae.enable_tiling()
pipe.vae.enable_slicing()

# Reduce frames and resolution
video = pipe(prompt, num_frames=24, height=480, width=720).frames[0]
```

### Slow Generation

**Problem:** Takes too long to generate

**Solutions:**

* Reduce `num_inference_steps` (30-40 still gives good results)
* Reduce `num_frames` (24 frames = 1.6s at 15fps)
* Use A100 GPU for faster processing
* Ensure you have NVMe storage for model loading

### Poor Video Quality

**Problem:** Blurry or inconsistent motion

**Solutions:**

* Increase `num_inference_steps` to 75-100
* Adjust `guidance_scale` (6-8 works best)
* Write more detailed prompts
* Add negative prompts to avoid issues

### Video Artifacts

**Problem:** Flickering or temporal inconsistencies

**Solutions:**

* Use consistent seed for reproducibility
* Avoid prompts with rapid motion
* Post-process with video stabilization

## Troubleshooting

{% hint style="danger" %}
**Out of memory**
{% endhint %}

* Hunyuan requires 24GB+ VRAM minimum
* Use A100 40GB/80GB for best results
* Reduce video length/resolution

### Video generation fails

* Check all model files downloaded correctly
* Ensure enough disk space (100GB+)
* Verify CUDA and PyTorch compatibility

### Poor video quality

* Increase inference steps
* Use more descriptive prompts
* Check input resolution matches expected

### Slow generation

* Video generation is compute-intensive
* Use A100/H100 for faster results
* Consider shorter clips first

## Cost Estimate

Typical CLORE.AI marketplace rates (as of 2024):

| GPU       | Hourly Rate | Daily Rate | 4-Hour Session |
| --------- | ----------- | ---------- | -------------- |
| RTX 3060  | \~$0.03     | \~$0.70    | \~$0.12        |
| RTX 3090  | \~$0.06     | \~$1.50    | \~$0.25        |
| RTX 4090  | \~$0.10     | \~$2.30    | \~$0.40        |
| A100 40GB | \~$0.17     | \~$4.00    | \~$0.70        |
| A100 80GB | \~$0.25     | \~$6.00    | \~$1.00        |

*Prices vary by provider and demand. Check* [*CLORE.AI Marketplace*](https://clore.ai/marketplace) *for current rates.*

**Save money:**

* Use **Spot** market for flexible workloads (often 30-50% cheaper)
* Pay with **CLORE** tokens
* Compare prices across different providers

## Next Steps

* CogVideoX - Alternative T2V
* Wan2.1 Video - Another T2V option
* AnimateDiff - Image animation


---

# Agent Instructions: Querying This Documentation

If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.

Perform an HTTP GET request on the current page URL with the `ask` query parameter:

```
GET https://docs.clore.ai/guides/video-generation/hunyuan-video.md?ask=<question>
```

The question should be specific, self-contained, and written in natural language.
The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.