Kandinsky 6 en una tarjeta de 16 GB: el video sale, y en español solo el modelo grande pasó mi prueba

Kandinsky 6.0 es un modelo abierto que genera video y audio a la vez: cinco segundos de imagen con su sonido, voces incluidas, desde un texto. Lo publicó Kandinsky Lab con licencia MIT.

Quise saber dos cosas concretas. Si corre en una tarjeta de 16 GB, como la que tengo en casa. Y si habla español, porque un modelo que mueve los labios pero dice otra cosa no sirve para mucho.

Antes de correr dejé escrita una ficha con la pregunta, las métricas y la regla de decisión, y la commiteé. Cada cambio posterior quedó como enmienda fechada en el historial de git, y las dejo todas a la vista. Git muestra en qué orden se commitearon; como los registros de cada corrida no guardan la hora, no prueba por sí solo que cada corrida haya sido posterior a su enmienda.

Qué es exactamente

La familia tiene dos tamaños: Lite, de 3 000 millones de parámetros, y Pro, de 29 000 millones. Cada uno tiene una versión completa, de 50 pasos y guía 5, y una destilada, que hace la misma tarea en 10 pasos con la guía en 1, es decir, sin guía. Trabajan en dos modos: de texto a video con audio, y de texto más una imagen inicial a video con audio.

Por dentro, un codificador de texto Qwen2.5-VL de 7 000 millones de parámetros convierte el prompt en embeddings; un transformer de difusión genera a la vez los latentes del video y del audio; un VAE de video, uno de audio y un vocoder los convierten en cuadros y en sonido a 44,1 kHz. Que el audio quede sincronizado con la imagen es lo que dicen los autores; yo no lo medí.

La receta oficial se quedó sin memoria

Lo medí en una RTX 4080 de 16 GB arrendada, de la misma generación que mi 4070 Ti SUPER pero algo más rápida. Probé cuatro maneras de cargar el modelo Lite destilado:

La receta del README, que va moviendo cada componente a la GPU cuando le toca, se quedó sin memoria; según el registro, al cargar el codificador de texto. Es plausible: los archivos del Qwen2.5-VL suman 15,45 GiB, y la tarjeta reporta 15,57 GiB útiles. Bajarlo a 8 bits tampoco alcanzó. La descarga secuencial, capa por capa, avanzó más y, según el registro, falló en el decodificador de video. El lugar de cada falla lo deduzco de los registros, no de un perfilador, y no medí por qué falló cada una.

Lo que funcionó fue una receta completa: separar el trabajo en dos fases que nunca comparten la tarjeta, pasar el codificador por la GPU de a grupos de capas y decodificar el video por tiles. No medí cuánto aporta cada parte por separado.

En la primera fase, el codificador de texto pasa por la GPU de a grupos de capas y deja los embeddings en bf16; tarda entre 0,7 y 1,3 segundos por prompt, con mediana de 0,7. No comparé numéricamente esos embeddings con los de la receta oficial. En la segunda fase el codificador ya no existe: el transformer, los VAE y el vocoder viven en la GPU, y el VAE de video decodifica por tiles.

Con eso, los 38 clips de texto a video terminaron sin quedarse sin memoria, y PyTorch asignó como máximo 11,24 GiB. En las tres pruebas de velocidad, un clip vertical de 480 × 864 tardó entre 140,4 y 141,1 segundos; uno horizontal, entre 167 y 194. Ese tiempo es generación y decodificación; no incluye la carga de los modelos, de 26 a 31 segundos sumando las dos fases, ni el codificado del texto, ni la exportación a MP4.

Dos costos que no se ven en la VRAM. El proceso llegó a 45,9 GiB de RAM del sistema. Y cuando intenté repetir el modelo Lite en mi propia máquina, de 30 GB de RAM, dejó de responder a mitad del intento; no aislé la causa, así que no puedo afirmar que corra ahí.

La voz, medida

La pregunta del español la fijé así: ocho escenas con una frase corta cada una, dos semillas por escena, en formato vertical. Whisper large-v3 transcribe sin saber el idioma, y comparo con la frase pedida. La regla: el español es usable si el error de palabras mediano no pasa de 0,20 y Whisper reconoce español en al menos 12 de 16 clips.

Como control, las mismas escenas con la frase en inglés. Como piso, las mismas frases leídas por la voz de síntesis que uso en los reels.

El error de palabras puede pasar de 1: cuenta sustituciones, borrados e inserciones contra el largo de la frase pedida, y aquí las transcripciones agregan palabras. Sin escuchar cada clip no puedo separar lo que agregó el modelo de lo que inventó el transcriptor. También castiga cosas que no son errores de pronunciación, como «20» contra «veinte». Mide fidelidad al texto según el transcriptor, no inteligibilidad pura.

UTMOS predicho es una estimación de la nota que pondrían oyentes, entrenado con voces sintéticas. Aquí puntúa la pista completa, con ambiente y silencios incluidos, así que lo dejo como referencia exploratoria y no como medida de naturalidad.

Con Lite destilado, el español no pasa: error mediano 1,06, y Whisper reconoce español en 13 de 16. Así suena:

Whisper transcribió «El servidor respondió en veinte milisegundos» como «El cerebro respondió, resolvió, respondió, en deeto minisegúenes». No es solo el español: en inglés el error mediano fue 0,625, también lejos del umbral. El bot del blog, generado desde una imagen, dijo su frase con errores de 0,08 y 0,15, pero son dos clips y no alcanzan para una regla.

¿Destilación o tamaño?

Con un solo modelo no se puede saber de dónde viene el problema. Así que, antes de correr nada más, agregué una enmienda a la ficha: probar Lite sin destilar, 50 pasos con guía 5, y Pro destilado, el modelo de 29 000 millones, con las mismas ocho escenas y la semilla 0. Después de ver los primeros resultados de Lite sin destilar amplié el diseño con una segunda enmienda: la semilla 1, para llegar a 16 clips por modelo como en la primera ronda, y el control en inglés. El umbral de error no cambió, y la regla final volvió a ser la de la primera ronda, 12 de 16; la primera enmienda la había escalado a 6 de 8 para la semilla 0.

No había una tarjeta de 16 GB con RAM suficiente para Pro, así que usé una RTX 3090 de 24 GB y el protocolo fijaba un límite de 15,57 GiB para la memoria de PyTorch, la capacidad útil que reportaba la 4080. Ese límite controla lo que asigna PyTorch, no toda la memoria de la tarjeta, y su valor efectivo no quedó guardado en cada registro. Así que esto no equivale a correr en una tarjeta física de 16 GB.

Para comparar máquinas repetí un clip de la primera ronda con la misma escena y semilla: la frase transcrita salió idéntica, letra por letra, y tardó 171,8 segundos contra 140,4 en la 4080. Es un control puntual: el audio no fue idéntico (UTMOS 2,13 contra 2,10) y no sirve como factor para convertir tiempos.

Los archivos del transformer de Pro suman 60 GB, casi cuatro veces una tarjeta de 16 GB. Lo dejé en la RAM del sistema y lo hice pasar por la GPU de a bloques, uno por vez. En los 24 clips, PyTorch asignó como máximo 9,09 GiB y reservó 13,65 GiB, y el proceso llegó a 120,25 GiB de RAM. Ese es el máximo del proceso entero, no la memoria por clip ni un mínimo necesario.

Las medianas de la segunda ronda mezclan los clips en español y en inglés. Los segundos por clip no incluyen la carga de los modelos, el codificado del texto ni la exportación; para Pro, la carga del generador tomó entre 52,5 y 59,1 segundos por sesión.

Pro destilado pasa la regla: error mediano 0,15 y español reconocido en los 16 clips. Eso es fidelidad al texto según el transcriptor, no una prueba de naturalidad ni de que cada clip sirva: siete de los dieciséis quedaron sobre 0,20. Lite sin destilar mejora, pero queda en 0,75.

Comparando cada clip con el de Lite destilado de la misma escena y semilla, Pro baja el error en 14 de 16, empata en 1 y empeora en 1; Lite sin destilar lo baja en 11, empata en 3 y empeora en 2. Son ocho escenas con dos semillas cada una, no dieciséis escenas independientes.

Después de ver los resultados revisé cuánto pesaban los números escritos con cifras. Unificando «5», «8» y «20» con sus palabras, las medianas pasan a 0,97, 0,75 y 0,14; los conteos por pares y el resultado de la regla no cambian. Lo informo como análisis posterior, no como métrica principal.

Algunos fallos de Pro son distintos: la transcripción trae la frase bien dicha y después repetida, o con una cola agregada. En una cadena de prueba, dos de seis transcripciones terminaban en algo compatible con «fotorrealista», como si el modelo leyera en voz alta la palabra Photorealistic del prompt; no lo puedo afirmar. Esa cadena corrió en otra máquina arrendada, una RTX 4090 con 252 GB de RAM, y su proceso llegó a 146,52 GiB.

En estas ocho escenas, Pro destilado fue más fiel al texto que las dos variantes de Lite, y Lite sin destilar también mejoró sin llegar al umbral. Es compatible con una ventaja del modelo grande, pero no permite atribuirla al tamaño ni descartar que la destilación también pese: no tengo un Pro sin destilar en la misma tabla, y cambian a la vez los pasos, la guía, la GPU y la receta de carga.

El truco: video del chico, voz de otro

Si el modelo chico mueve bien la imagen pero dice mal las palabras, se le puede cambiar la voz. Lo probé como demostración, no como medición; la voz y la boca de este resultado no son de Kandinsky:

1. Encadené seis clips de cinco segundos: cada uno parte del último cuadro del anterior, con el mismo personaje descrito en el prompt. Elegí a ojo el primer tramo entre tres semillas. A unos tres minutos por tramo, el personaje se mantuvo reconocible en esta prueba, lo que no garantiza que pase siempre.
2. Quité el audio de Kandinsky y puse encima una narración revisada, dicha por la voz de síntesis del estudio.
3. Pasé el resultado por LatentSync 1.6, de ByteDance, que redibuja la boca para que calce con la voz nueva. Tardó 578 segundos en una RTX 3090 para los treinta segundos. Bajé el modelo del repositorio de la versión 1.6, sin anotar la revisión exacta.

Pegar la voz nueva sin redibujar la boca no funcionó: los labios seguían diciendo otra cosa y se notaba de inmediato. El reel del principio está hecho con esta cadena completa. Que el resultado sirva es una valoración mía de esta pieza, no una medición.

Lo que esta medición no cubre

• Dos máquinas distintas. La primera ronda es de una RTX 4080 de 16 GB; la segunda, de una RTX 3090 con el uso de memoria limitado. El límite solo controla lo que asigna PyTorch, no el contexto de CUDA, así que una tarjeta real de 16 GB tiene algo menos de espacio.
• Muestras chicas. Dieciséis clips por modelo en español; en inglés, dieciséis de Lite destilado y ocho de cada modelo de la segunda ronda. Las comparaciones son descriptivas, sin intervalos de confianza.
• Prompts en español para las dos lenguas. La descripción de cada escena está en español también en el control en inglés: compara esta plantilla, no prompts optimizados para cada idioma.
• Sin evaluación de labios. La ficha prometía revisar a ojo el movimiento de la boca clip por clip, y no lo hice de forma sistemática.
• Trazabilidad incompleta. Cada registro guarda tiempos y memoria, pero no el límite de memoria efectivo, la GPU ni la hora de la corrida; el orden de las enmiendas lo muestra el historial de git, no los registros.
• Tres medidas distintas. El reloj excluye la carga, el codificado del texto y la exportación. El pico de memoria de PyTorch se reinicia antes de generar cada clip. El pico de RAM es el máximo histórico del proceso, carga incluida.
• El error de palabras castiga números escritos con cifras y variantes como «vídeo». No pega igual en todos los clips; el análisis de sensibilidad de más arriba muestra que no cambia ninguna conclusión.
• No probé Pro sin destilar, ni el modelo de superresolución, ni el de mundo.
• Versiones. La primera ronda usó diffusers desde la rama principal del 12 de octubre sin fijar la revisión; la segunda, la revisión 916a5791.

Cuándo lo usaría

Lo usaría para generar video con sonido ambiente en una tarjeta de 16 GB, con el modelo Lite destilado y la receta en dos fases: unos 2 minutos 21 segundos por clip vertical en la 4080 es razonable. Y para clips con diálogo en español, como base de imagen, cambiando la voz y redibujando la boca.

No lo usaría para que el modelo chico hable español por sí solo: en mi banco solo 1 de 16 clips quedó bajo el umbral. El modelo grande fue mucho más fiel al texto, pero un proceso que llegó a 120 GiB de RAM y entre unos 12 y 23 minutos por clip excede lo que tengo en casa.

---

Medido entre el 12 y el 14 de octubre de 2026. Primera ronda en una RTX 4080 de 16 GB arrendada en vast.ai (torch 2.8.0+cu128, diffusers 0.41.0.dev0, transformers 5.19.0). Segunda ronda en una RTX 3090 de 24 GB, con el límite de 15,57 GiB para PyTorch que fijaba el protocolo y que no quedó registrado por corrida (diffusers en la revisión 916a5791). Voz evaluada con faster-whisper large-v3 y UTMOS22 strong. Lipsync con LatentSync 1.6 en otra RTX 3090 arrendada.

Fuentes

• Kandinsky 6.0 Video: Foundation Models for Synchronized Video and Audio Generation, arXiv:2610.05608. El artículo de la familia, con la arquitectura y los tamaños de Lite y Pro.
• Kandinsky-6.0-Lite-distill-5s-Diffusers. La ficha del modelo que medí en la primera ronda, con la licencia MIT y los ajustes de diez pasos.
• Kandinsky-6.0-Pro-distill-5s-Diffusers. El modelo de 29 000 millones de la segunda ronda.
• Pipeline de Kandinsky 6 en la documentación de diffusers. La receta oficial con descarga por componente, que en mi 4080 se quedó sin memoria.
• LatentSync: Taming Audio-Conditioned Latent Diffusion Models for Lip Sync with SyncNet Supervision, arXiv:2412.09262, y su repositorio. El modelo que redibuja la boca.
• UTMOS: UTokyo-SaruLab System for VoiceMOS Challenge 2022, arXiv:2204.02152. El predictor de calidad de voz, con sus límites.
• faster-whisper. El transcriptor de la evaluación, con large-v3.
• Los scripts, la ficha y los datos crudos. Las cuatro recetas, la evaluación de voz, las dos rondas en JSONL y la cadena del reel. python3 run_k6_2p.py MODELO prompts.json salida.

Preguntas frecuentes

¿Qué es Kandinsky 6.0 Video?

Una familia de modelos de difusión de Kandinsky Lab, con licencia MIT. Según sus autores, genera clips de cinco segundos de video con audio sincronizado a 44,1 kHz, desde texto o desde texto más una imagen. Tiene dos tamaños: Lite, de 3 000 millones de parámetros, y Pro, de 29 000 millones, cada uno con versión destilada de diez pasos.

¿Corre Kandinsky 6.0 en una tarjeta de 16 GB?

El modelo Lite destilado corrió en mi RTX 4080 de 16 GB, pero no con la receta oficial, que se quedó sin memoria; los archivos del codificador de texto Qwen2.5-VL ya suman 15,45 GiB. Lo que funcionó fue una receta en dos fases: primero se calculan los embeddings del texto pasando el codificador por la GPU de a grupos de capas, después se descarta y se genera el video con el VAE por tiles. PyTorch asignó como máximo 11,24 GiB y cada clip vertical tardó unos 141 segundos.

¿Habla español?

En mi banco, las dos variantes Lite no pasaron mi criterio de fidelidad al texto. En dieciséis clips el error mediano de palabras según Whisper fue 1,06 con Lite destilado y 0,75 con Lite sin destilar; las transcripciones cambian, agregan y repiten palabras. Pro destilado bajó a 0,15 y pasó la regla que fijé antes de correr. El costo: en mi prueba, el proceso de Pro llegó a 120 GiB de RAM del sistema y tardó entre unos 12 y 23 minutos por clip.

¿El problema del español es la destilación o el tamaño?

No lo puedo separar. Comparando clip por clip con Lite destilado, Lite sin destilar mejoró en 11 de 16 pares sin llegar al umbral, y Pro destilado mejoró en 14 de 16 y lo pasó. Es compatible con una ventaja del modelo grande, pero sin un Pro sin destilar en la misma tabla no puedo atribuirla al tamaño ni descartar que la destilación también pese.

¿Se puede usar el video del modelo chico con otra voz?

Sí, como truco. Encadené seis clips de cinco segundos, cada uno partiendo del último cuadro del anterior, y reemplacé el audio por una narración revisada con una voz de síntesis en español; LatentSync 1.6 redibuja la boca para que calce con la voz nueva. El reel de este artículo está hecho así. Es una demostración, no una medición.

¿Qué hardware hace falta?

Para Lite, una tarjeta de 16 GB y bastante RAM del sistema: el proceso llegó a 45,9 GiB. Para Pro lo corrí en una RTX 3090 de 24 GB con el límite de memoria de PyTorch en 15,57 GiB que fijaba el protocolo, aunque su valor no quedó registrado en cada corrida, con el transformer en la RAM del sistema pasando a la GPU de a bloques; el proceso llegó a 120,25 GiB de RAM. No es un requisito mínimo medido, es lo que usó esa corrida.