Generación de Video e Imagen-a-Video: Sora 2, Veo 3.1, Runway, Open-Source

Audio Sincronizado Nativo

Primer modelo grande con diálogo, foley, ambiente y música integrados en un solo pase. Lip-sync, pisadas que coinciden con el terreno y vehículos con efecto Doppler. Sin pase separado de TTS.

Hasta 1080p, 20s

Sora 2 estándar genera 720p/1080p hasta 20 segundos. Sora 2 Pro empuja más fidelidad y segmentos de 30-60s ideales para anuncios cortos, previs de cine y videos musicales estilizados.

~$0.10–$0.50 / segundo

Precios API: Sora 2 ~$0.10/s en 720p, ~$0.15/s en 1080p. Sora 2 Pro ~$0.30–$0.50/s en 1080p. ChatGPT Pro incluye una cuota mensual; pago por uso más allá. El caching no aplica a video.

Mejor Simulación Física

Mejor manejo de cuerpos rígidos, gravedad, colisiones y fluidos. Continuidad multi-toma más confiable. Aún tiene problemas con interacción mano-objeto fina y renderizado de texto consistente.

API de Videos OpenAI

Endpoint REST POST /v1/videos acepta prompt, imagen de referencia, duración, resolución, aspect ratio. Devuelve job ID; poll /v1/videos/{id} hasta status=completed, luego descarga MP4 + audio. Solo asíncrono.

Marca de Agua C2PA

Todas las salidas llevan metadata criptográfica C2PA identificándolas como generadas por IA. Marca visible en plan gratis; solo metadata en planes pagos. Bloqueo de figuras públicas salvo licencia explícita.

Generación Nativa de Audio

Diálogo, foley, música y ambiente sincronizados con la imagen. El diálogo se especifica textualmente con tags de hablante. Soporta 30+ idiomas.

Multi-Referencia "Ingredients"

Pasas hasta 3 imágenes de referencia (personaje, producto, entorno) y Veo las combina en una toma coherente. Crítico para publicidad consistente con marca, actor, producto y locación.

Controles de Cámara

Directivas explícitas en el prompt: pan-left, dolly-in, orbit-right, crane-up, handheld. Interpreta lenguaje cinematográfico ("Dutch angle", "rack focus") mejor que competidores. 16:9, 9:16, 1:1.

Interpolación Frames-a-Video

Provees frame inicial y final; Veo genera el movimiento entre ellos. Producción basada en storyboard: artistas dibujan los key beats, Veo rellena. Reduce la imprevisibilidad del puro texto-a-video.

API de Vertex AI

Patrón long-running operation: POST a publishers/google/models/veo-3.1:predictLongRunning, poll de operación, fetch del MP4 en GCS. Controlado por IAM, compatible con VPC-SC y auditable — apto para empresas reguladas.

Marca SynthID

Watermark invisible en cada frame y muestra de audio. Sobrevive compresión, recortes y re-codificación. Detectable con SynthID Detector. Obligatorio en todas las salidas Veo.

Runway Gen-4 + Gen-4 Turbo

Lo mejor para consistencia de personajes y mundos entre tomas. La feature "References" fija un actor o locación en una producción entera. 1080p, hasta 10s. ~$0.05/credit, clip de 5s ~$0.25-0.50. API + SDK nativo.

Kling 2.5 (Kuaishou)

El movimiento cinematográfico y la física más fuertes entre los modelos chinos. 1080p hasta 10s, upscale a 4K. Excelente para danza/deportes/acción. ~$0.10/s standard, ~$0.20/s modo Master. API vía Kling Cloud y fal.ai.

Hailuo 02 (MiniMax)

Precios agresivos: ~$0.03–$0.05/s en 720p, ~$0.08/s en 1080p. Buena adherencia a prompts y movimiento estable por el precio. Clips de 6–10s. Ideal para b-roll en volumen, A/B testing y contenido tipo stock.

Pika 2.0 + Pikaffects

Salida estilizada con "Pikaffects" (squish, crush, melt, inflate, explode). Fuerte para social, meme y video musical. Hasta 5s, 1080p. Suscripciones desde $10/mes con créditos.

Agregadores: fal.ai, Replicate

fal.ai y Replicate exponen Runway, Kling, Hailuo, Pika y open-source detrás de una sola API. Útil para ruteo A/B sin facturación separada. Pequeño markup vs. precio directo.

Cuándo Usar Cuál

Veo 3.1: lo mejor + audio (la API de Sora 2 se retira en septiembre 2026). Runway Gen-4/4.5: continuidad de personajes. Kling 2.5/3.0: acción cinematográfica. Hailuo 02: volumen barato. Pika 2.0: creatividad social/estilizada.

Wan 2.5 (Alibaba)

DiT (Diffusion Transformer) de 14B parámetros. 1080p hasta 10s. Wan 2.5 agrega audio nativo, acercándose a Sora 2 y Veo 3.1. Apache 2.0. Corre en 24GB con offloading; 48GB recomendado para 1080p. ComfyUI + Diffusers.

HunyuanVideo (Tencent)

13B parámetros, doble encoder de texto (LLM + CLIP). 720p, clips 5–15s. Mejor calidad open-source en VBench. Variante I2V fuerte. Apache 2.0. Necesita 60GB en precisión completa; FP8 + offloading corre en 24GB.

LTX-Video (Lightricks)

DiT de 2B optimizado para velocidad. Tiempo real 5s @ 768x512 en RTX 4090 (~5s gen para 5s output). Open RAIL-M. Mejor opción para UIs interactivas, pipelines batch y prototipado rápido. T2V + I2V + V2V.

Mochi 1 (Genmo)

AsymmDiT de 10B. Fuerte fidelidad de movimiento y adherencia a prompts. Base 480p con upsampler HD. Apache 2.0. ~24GB con sequential offloading. Comunidad activa de fine-tunes en Hugging Face.

CogVideoX-5B (Zhipu)

5B parámetros, 720x480, clips 6s. El ecosistema más maduro para fine-tuning con LoRA — entrenable en 1x A100 40GB. Apache 2.0. Variante CogVideoX-5B-I2V. Excelente baseline para personalización.

ComfyUI y Diffusers

Los cinco modelos vienen con nodos custom de ComfyUI (editor de grafo visual, iteración rápida) y pipelines Diffusers de Hugging Face (API Pythonic, batch). xformers, SageAttention y TeaCache aceleran la inferencia 2–3x.

Motion Brush

Pintas una máscara sobre la imagen y le asignas un vector de dirección + intensidad. La región pintada se anima en esa dirección mientras el resto queda estático. Pionero en Runway Gen-2/3, ahora en Kling, Pika y nodos ComfyUI para HunyuanVideo I2V.

Consistencia de Personaje

Runway "References", Kling "Custom Character", Veo "Ingredients" te permiten subir 1-5 imágenes de un rostro/actor/producto y fijar identidad en toda la producción. Para open-source, entrena un LoRA de CogVideoX o HunyuanVideo (~30 imágenes, 1-2 horas en A100).

Keyframes Inicio + Fin

Provees primer y último frame; el modelo interpola el movimiento. Veo "Frames-to-Video", Kling "Start & End Frame", LTX-Video "Image Conditioning". Elimina ambigüedad — el modelo solo inventa los in-betweens.

Control de Trayectoria de Cámara

Especificas movimiento de cámara (pan, dolly, zoom, orbit) independiente del sujeto. Runway "Camera Controls" y Kling "Cinematic Lens Movement" exponen sliders. ComfyUI expone tensores de trayectoria por frame.

Extensión y Looping

Pasas el último frame de un clip como inicio del siguiente para encadenar tomas a 30-60s. Modo "Loop" fuerza que el último frame coincida con el primero — ideal para reels, anuncios y backgrounds animados.

Upscaling e Interpolación

Genera a 720p/24fps, luego upscalea con Topaz Video AI / SeedVR2 a 4K, e interpola a 60fps con RIFE / Practical-RIFE. Pipeline común: generación base barata → post-proceso de alta calidad para entrega.

RTX 5090 (32GB) — Sweet Spot

32GB GDDR7 + tensor cores Blackwell. Corre HunyuanVideo y Wan 2.5 en 720p sin offloading. Wan 2.5 5s @ 720p en ~90s. LTX-Video en tiempo real. ~$2,000 retail. La mejor opción de placa única en 2026.

RTX 4090 (24GB) — Mainstream

24GB GDDR6X. Mochi 1 y CogVideoX-5B corren nativos. HunyuanVideo y Wan 2.5 requieren FP8 + offloading. Wan 2.5 5s @ 720p en ~3-5 min. LTX-Video 5s en ~5-10s. Excelente valor a ~$1,600 usada.

RTX 3090 (24GB) — Económica

Misma VRAM que la 4090 a mitad de precio (~$700 usada). 30-50% más lenta que la 4090. Aún corre todos los modelos open-source con offloading. La entrada más costo-efectiva.

RTX 6000 Ada / Pro 6000 (48-96GB)

48GB (6000 Ada) o 96GB (Pro 6000 Blackwell). Elimina todo offloading. HunyuanVideo y Wan 2.5 en 1080p sin compromiso. 4-7x más cara que 4090/5090 pero el único camino de placa única a producción 1080p+.

Cloud: Runpod / Vast.ai

A100 80GB ~$1.20-1.80/hr, H100 80GB ~$2-3/hr. Levantas una instancia ComfyUI on-demand, generas, apagas. Más barato que una 5090 para sub-50 horas/mes. Templates ComfyUI pre-armados.

Stack de Optimización VRAM

Cuantización FP8 (Q8_0 GGUF para video), SageAttention, TeaCache, VAE tiling, sequential CPU offload, torch.compile. Combinado: HunyuanVideo en 12GB (RTX 4070), Wan 2.5 en 16GB. 2-3x más lento pero accesible.

El Audio Importa

Solo Sora 2, Veo 3.1 y Wan 2.5 generan audio nativo. El resto necesita un pase separado de TTS + foley + música. Audio nativo recorta post-producción de horas a minutos en contenido corto.

Calidad Top (VBench)

A inicios de 2026: Sora 2 Pro y Veo 3.1 lideran, seguidos de cerca por Kling 2.5 y Runway Gen-4. Wan 2.5 y HunyuanVideo son los mejores open-source, dentro del 5-10% de Kling en la mayoría de métricas VBench.

Pipelines de Alto Volumen

¿Generas 1000+ clips/día? Hailuo 02 ($0.03-0.08/s) o LTX-Video self-hosted en 4-8 GPUs. Las APIs cerradas chocan con rate limits y presupuestos. Open-source gana en $/clip a escala.

Compliance Empresarial

Vertex AI Veo 3.1 es la única opción con VPC-SC, IAM, audit logs y residencia de datos garantizada de fábrica. Open-source en VPC privada cubre el resto. Sora 2 tiene tier empresarial con manejo más estricto.

Watermarking y Procedencia

Sora (C2PA) y Veo (SynthID) incrustan procedencia criptográfica. La mayoría de open-source no — debes agregar tags C2PA aguas abajo si tu plataforma exige declarar contenido AI (EU AI Act, YouTube, Meta).

Árbol de Decisión Rápido

¿Audio + máxima calidad? Veo 3.1 (la API de Sora 2 se retira en septiembre 2026). ¿Consistencia de personajes? Runway Gen-4/4.5. ¿Acción cinematográfica? Kling 2.5/3.0. ¿B-roll barato? Hailuo 02. ¿Privacidad + customización? Self-host Wan 2.5 o HunyuanVideo en 5090.

Runway Gen-4 Imagen-a-Video (Python)

Envía imagen + prompt, poll para completar, descarga MP4. Async-friendly con eventos SSE. Instalación: pip install runwayml.

from runwayml import RunwayML
import time, requests, base64

client = RunwayML()  # uses RUNWAYML_API_SECRET

# Encode source image as data URI
with open("hero.jpg", "rb") as f:
    img_b64 = base64.b64encode(f.read()).decode()
prompt_image = f"data:image/jpeg;base64,{img_b64}"

# Submit Gen-4 image-to-video job
task = client.image_to_video.create(
    model="gen4_turbo",
    prompt_image=prompt_image,
    prompt_text="Slow camera dolly-in, warm sunset light, "
                "subject smiles, hair moves in the wind",
    duration=5,             # 5 or 10 seconds
    ratio="1280:720",
)

# Poll until complete
while True:
    task = client.tasks.retrieve(task.id)
    if task.status in ("SUCCEEDED", "FAILED"):
        break
    time.sleep(5)

if task.status == "SUCCEEDED":
    url = task.output[0]
    open("out.mp4", "wb").write(requests.get(url).content)
    print("Saved out.mp4")

OpenAI Sora 2 Generate (Python)

OpenAI Videos API. Envías prompt, poll del job, fetch del video. Audio nativo está activo por defecto en Sora 2.

from openai import OpenAI
import time, requests

client = OpenAI()

job = client.videos.create(
    model="sora-2",
    prompt="A golden retriever surfs a small wave at sunset, "
           "GoPro POV, water splashes, dog barks happily",
    size="1280x720",
    duration_seconds=8,
    # input_image="data:image/png;base64,..."  # optional I2V
)

while True:
    job = client.videos.retrieve(job.id)
    if job.status in ("completed", "failed"):
        break
    time.sleep(5)

if job.status == "completed":
    url = job.output[0].url
    open("sora.mp4", "wb").write(requests.get(url).content)

Google Veo 3.1 (Vertex AI)

Patrón long-running operation. Instalación: pip install google-genai. Auth vía gcloud auth application-default login.

from google import genai
from google.genai import types
import time

client = genai.Client(
    vertexai=True, project="my-proj", location="us-central1"
)

op = client.models.generate_videos(
    model="veo-3.1-generate-preview",
    prompt='A barista pulls an espresso shot, steam rises, '
           'narrator says "Single origin, slow extracted."',
    config=types.GenerateVideosConfig(
        aspect_ratio="16:9",
        duration_seconds=8,
        number_of_videos=1,
        generate_audio=True,        # native audio
    ),
)

while not op.done:
    time.sleep(10)
    op = client.operations.get(op)

video = op.response.generated_videos[0].video
client.files.download(file=video)
video.save("veo.mp4")

ComfyUI: Wan 2.5 / HunyuanVideo

ComfyUI es la UI estándar basada en grafos para video open-source. Instala nodos custom para el modelo, suelta el JSON del workflow, dale a Queue.

# Install ComfyUI on a Linux box with RTX 4090/5090
git clone https://github.com/comfyanonymous/ComfyUI
cd ComfyUI && pip install -r requirements.txt

# Install model-specific nodes via ComfyUI Manager
# - ComfyUI-WanVideoWrapper      (Wan 2.5)
# - ComfyUI-HunyuanVideoWrapper  (HunyuanVideo)
# - ComfyUI-LTXVideo             (LTX-Video)
# - ComfyUI-MochiWrapper         (Mochi 1)
# - ComfyUI-CogVideoXWrapper     (CogVideoX-5B)

# Download weights to models/diffusion_models/
huggingface-cli download Wan-AI/Wan2.5-T2V-14B \
  --local-dir models/diffusion_models/Wan2.5

# Launch
python main.py --listen 0.0.0.0 --port 8188

# Drag a workflow .json onto the UI:
# https://github.com/kijai/ComfyUI-WanVideoWrapper/tree/main/example_workflows

Diffusers: HunyuanVideo (Python)

Pipeline puro Python para batch jobs y CI/CD. Las optimizaciones de memoria permiten correr HunyuanVideo en una sola placa de 24GB.

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

pipe = HunyuanVideoPipeline.from_pretrained(
    "tencent/HunyuanVideo",
    torch_dtype=torch.bfloat16,
)
pipe.vae.enable_tiling()
pipe.enable_sequential_cpu_offload()  # fits on 24GB VRAM

video = pipe(
    prompt="A cat dressed as a wizard casts a sparkling spell, "
           "soft volumetric lighting, cinematic 35mm",
    height=720, width=1280,
    num_frames=85,        # ~3.5s at 24fps
    num_inference_steps=30,
    guidance_scale=6.0,
).frames[0]

export_to_video(video, "wizard_cat.mp4", fps=24)

API Headless de ComfyUI (Python)

Maneja ComfyUI desde código de producción vía su API websocket+HTTP. Envías un workflow JSON, obtienes el filename, descargas el MP4.

import json, requests, websocket, uuid

CUI = "http://localhost:8188"
client_id = str(uuid.uuid4())

# Load a workflow exported via "Save (API Format)" in ComfyUI
workflow = json.load(open("ltx_video_i2v.json"))

# Override the prompt and source image
workflow["6"]["inputs"]["text"] = "Subject smiles, sunset light"
workflow["10"]["inputs"]["image"] = "hero.jpg"

# Queue the prompt
r = requests.post(f"{CUI}/prompt",
    json={"prompt": workflow, "client_id": client_id})
prompt_id = r.json()["prompt_id"]

# Listen for completion via websocket
ws = websocket.create_connection(
    f"ws://localhost:8188/ws?clientId={client_id}")
while True:
    msg = json.loads(ws.recv())
    if msg.get("type") == "executed" and \
       msg["data"].get("prompt_id") == prompt_id:
        break

# Fetch the resulting video from /history
hist = requests.get(f"{CUI}/history/{prompt_id}").json()
video = hist[prompt_id]["outputs"]["12"]["gifs"][0]
url = f"{CUI}/view?filename={video['filename']}" \
      f"&subfolder={video['subfolder']}&type=output"
open("out.mp4", "wb").write(requests.get(url).content)