> For the complete documentation index, see [llms.txt](https://docs.clore.ai/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://docs.clore.ai/guides/guides_v2-es/generacion-de-video/framepack.md).

# Generación de video con FramePack

Genera videos de IA con solo 6GB de VRAM usando FramePack en Clore.ai

FramePack es un avance revolucionario en la generación de video con IA: puede crear videos de hasta 2 minutos de duración usando **solo 6 GB de VRAM**. Basado en la arquitectura HunyuanVideo, la innovación clave de FramePack es empaquetar los fotogramas de forma eficiente para que la memoria de la GPU se mantenga constante independientemente de la duración del video. Esto hace que la generación de video con IA sea accesible en GPUs económicas que antes eran demasiado limitadas.

## Características clave

* **Mínimo de 6 GB de VRAM**: Funciona en RTX 3060, RTX 3070, ¡incluso GTX 1060!
* **Videos de hasta 2 minutos**: Uso constante de VRAM sin importar la duración del video
* **Imagen a video**: Anima cualquier imagen con un prompt de texto
* **Interfaz web incluida**: Interfaz basada en Gradio para un uso fácil
* **Basado en HunyuanVideo**: Aprovecha la arquitectura de difusión de video de Tencent
* **Código abierto**: GitHub con desarrollo activo

## Requisitos

| Componente | Mínimo        | Recomendado   |
| ---------- | ------------- | ------------- |
| GPU        | GTX 1060 6 GB | RTX 4090 24GB |
| VRAM       | 6GB           | 12 GB+        |
| RAM        | 16GB          | 32GB          |
| Disco      | 30 GB         | 50 GB         |
| CUDA       | 12.8+         | 12.8+         |
| Python     | 3.10+         | 3.11          |

**GPU recomendada de Clore.ai**: RTX 3080 10 GB ($0.05–0.19/h) — ¡gran calidad a bajo costo!

### Referencia de velocidad

| GPU           | Tiempo por fotograma | Video de 60 fotogramas (\~2 s a 30 fps) |
| ------------- | -------------------- | --------------------------------------- |
| RTX 3060 12GB | \~30 s               | \~30 min                                |
| RTX 3080 10GB | \~18 seg             | \~18 min                                |
| RTX 4080 16GB | \~12 s               | \~12 min                                |
| RTX 4090 24GB | \~8 s                | \~8 min                                 |
| RTX 5090 32GB | \~5 seg              | \~5 min                                 |

## Instalación

```bash
# Clonar repositorio
git clone https://github.com/lllyasviel/FramePack.git
cd FramePack

# Crear entorno conda (recomendado)
conda create -n framepack python=3.11 -y
conda activate framepack

# Instalar dependencias
pip install -r requirements.txt

# Instala PyTorch con CUDA
pip install torch torchvision torchaudio --index-url https://download.pytorch.org/whl/cu128
```

### Configuración de Docker

```bash
docker run --gpus all -p 7860:7860 \
  -v ~/.cache/huggingface:/root/.cache/huggingface \\
  -v ./outputs:/app/outputs \
  ghcr.io/lllyasviel/framepack:latest
```

## Inicio rápido — Interfaz web

La forma más fácil de usar FramePack:

```bash
cd FramePack
python app.py --port 7860

# Para poca VRAM (6 GB):
python app.py --port 7860 --low-vram

# Accede en http://localhost:7860
```

**Flujo de trabajo de la interfaz web:**

1. Sube una imagen de origen (el primer fotograma)
2. Introduce un prompt de texto que describa el movimiento ("la cámara hace zoom lentamente", "la persona camina hacia delante")
3. Establece la duración del video (número de fotogramas)
4. Haz clic en Generar
5. Descarga el MP4

## Uso

FramePack es una **aplicación web de Gradio**, no una biblioteca de Python. La interfaz principal es la interfaz web.

### Flujo de trabajo de la interfaz web

1. Abre `http://localhost:7860` después de iniciarlo
2. Sube una imagen de origen (será el primer fotograma)
3. Introduce un prompt de texto que describa el movimiento deseado
4. Establece el número de fotogramas (más = video más largo)
5. Haz clic en **Generar** → espera → descarga el MP4

### Acceso a la API mediante Gradio Client

Puedes llamar a FramePack mediante programación usando la API de Gradio:

```python
from gradio_client import Client

# Conectar a una instancia de FramePack en ejecución
client = Client("http://localhost:7860")

# Generar video a partir de imagen + prompt
result = client.predict(
    "input_photo.jpg",                              # imagen de origen
    "la persona sonríe y gira lentamente la cabeza", # prompt
    60,                                              # num fotogramas
    7.5,                                             # escala de guía
    30,                                              # pasos de inferencia
    42,                                              # semilla
    api_name="/generate"
)
print(f"Video guardado en: {result}")
```

### Procesamiento por lotes con Gradio Client

```python
from gradio_client import Client
import glob

client = Client("http://localhost:7860")

prompts = [
    ("photo1.jpg", "zoom suave de la cámara con iluminación suave"),
    ("photo2.jpg", "el viento mueve el cabello, las nubes se desplazan"),
    ("photo3.jpg", "alejar lentamente el zoom revelando toda la escena"),
]

for img_path, prompt in prompts:
    result = client.predict(img_path, prompt, 60, 7.5, 30, -1, api_name="/generate")
    print(f"Listo: {img_path} → {result}")
```

## Guía de resolución

| VRAM | Resolución máxima | Calidad                   |
| ---- | ----------------- | ------------------------- |
| 6GB  | 512×512           | Ideal para redes sociales |
| 8GB  | 640×640           | Mejor detalle             |
| 10GB | 512×768           | Vertical/paisaje          |
| 12GB | 768×768           | Alta calidad              |
| 24GB | 1024×768          | Mejor calidad             |

## Consejos para usuarios de Clore.ai

* **Económico**: Este es uno de los pocos modelos de IA de video que funciona en GPUs económicas ($0.03–0.07/h para RTX 3060!)
* **Usa `--low-vram` bandera**: Esencial para GPUs de 6–8 GB — habilita automáticamente la descarga a CPU
* **512×512 está bien**: Para redes sociales (TikTok, Reels), 512 px es perfectamente aceptable
* **Más largo ≠ más VRAM**: A diferencia de otros modelos de video, FramePack mantiene la VRAM constante — genera videos más largos libremente
* **Descargar modelos previamente**: En la primera ejecución se descargan \~15 GB. Ejecútalo una vez y luego tu sesión de Clore tendrá los modelos en caché
* **Combínalo con el escalado**: Genera a 512×512 y luego usa Real-ESRGAN para escalar a 2K/4K

## Consejos para prompts

Los buenos prompts describen **movimiento**, no solo la apariencia:

```
✅ "la cámara hace un paneo lentamente hacia la derecha, revelando un paisaje montañoso"
✅ "la persona parpadea y sonríe suavemente, el viento mueve su cabello"
✅ "alejar lentamente el zoom, mostrando el edificio completo"

❌ "un hermoso atardecer" (no se describe movimiento)
❌ "alta calidad, 4K, detallado" (las palabras de estilo no ayudan mucho)
```

## Solución de problemas

| Problema                                | Solución                                                                                     |
| --------------------------------------- | -------------------------------------------------------------------------------------------- |
| CUDA sin memoria                        | Usa `--low-vram` bandera, reduce la resolución a 512×512                                     |
| Generación muy lenta                    | Normal para GPUs de 6 GB (\~30 s/fotograma). Usa una RTX 4090 para una velocidad 4x          |
| Fotogramas negros/corruptos             | Actualiza PyTorch: `pip install torch --upgrade`                                             |
| La descarga del modelo se queda colgada | Comprueba el espacio en disco (necesita 30 GB libres). Intenta `HF_HUB_ENABLE_HF_TRANSFER=1` |
| La interfaz web no arranca              | Comprueba que el puerto 7860 esté libre: `lsof -i :7860`                                     |

## Lecturas adicionales

* [Repositorio de GitHub](https://github.com/lllyasviel/FramePack)
* [HunyuanVideo (modelo base)](https://github.com/Tencent/HunyuanVideo)
* [Comparación de GPU de Clore.ai](/guides/guides_v2-es/primeros-pasos/gpu-comparison.md) — encuentra la GPU más barata para tus necesidades


---

# Agent Instructions
This documentation is published with GitBook. GitBook is the documentation platform designed so that both humans and AI agents can read, navigate, and reason over technical content effectively. Learn more at gitbook.com.

## 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, and the optional `goal` query parameter:

```
GET https://docs.clore.ai/guides/guides_v2-es/generacion-de-video/framepack.md?ask=<question>&goal=<endgoal>
```

`ask` is the immediate question: it should be specific, self-contained, and written in natural language.
`goal` is optional and describes the broader end goal you are ultimately trying to accomplish on behalf of the user. GitBook uses it to tailor the answer towards what is most useful for that goal.

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.