Communitygithub.com

invokard-studio-local

Crear videos con código, completamente en el ordenador del usuario: reels y cortos (9:16, 16:9, 1:1) a partir de sus propias fotos, clips, grabaciones de voz y música, con subtítulos palabra por palabra, titulares animados, gráficos, transiciones de antes/después, cortes al ritmo, tarjetas finales y banda sonora mezclada; y animaciones dibujadas fotograma a fotograma con React (tipografía cinética, anuncios animados, gráficos, 3D, física, partículas). Sin cuentas, sin claves de API, sin descargas en el momento del renderizado.

¿Qué es invokard-studio-local?

Invokard Studio Local es una skill para un agente de IA (como Claude Code) que permite crear videos profesionales directamente en el ordenador del usuario, sin depender de servicios externos, cuentas ni descargas durante el renderizado. Está diseñada para producir reels para redes sociales (9:16), videos horizontales (16:9) y cuadrados (1:1) usando únicamente el material del usuario: fotos, clips, grabaciones de voz y música. La skill se compone de un motor de montaje basado en Python (Pillow + ffmpeg) que compone cada fotograma y mezcla el audio, y un motor de animación que renderiza componentes React fotograma a fotograma (p. ej., tipografía cinética, gráficos animados, 3D, partículas). El flujo de trabajo guía al agente a través de la verificación del sistema, la elección de la ruta (material grabado, voz, animación dibujada o solo texto), la edición con previsualizaciones de imágenes fijas, la extracción de clips, la mezcla de música y efectos, y el renderizado final con verificación de calidad. La skill incluye reglas importantes derivadas de errores reales, como la inspección visual de cada hoja de contactos, la medición real de colores de marca, el respeto de zonas seguras para redes sociales y la prohibición de añadir marcas de terceros. Los casos de uso típicos incluyen: 'haz un reel', 'un video vertical', 'un video 16:9 para YouTube o LinkedIn', 'subtítulos como los de esos reels', 'un video de antes/después', 'corta estos clips al ritmo', 'un anuncio animado', 'gráficos en movimiento', 'anima esto con código', 'un gráfico animado' o 'un video de producto en 3D'. También permite volver a renderizar un video ya creado con esta skill.

Compatible con✓Claude Code~Codex CLI~Cursor
npx skills add https://github.com/Octonove/invokard-studio-local/tree/HEAD/skills/invokard-studio-local

Preguntar en tu IA favorita

Abre un nuevo chat con esta habilidad de agente ya precargada.

Documentación

Invokard Studio Local — del material del usuario al MP4

Escribes un pequeño archivo Python (reel.py) que describe el reel: qué foto o clip está en pantalla y cuándo, qué capas (titular, chips, elementos de lista, gráficos, transiciones, tarjeta final) aparecen sobre él, qué archivo de voz comienza cuándo, y dónde van la música y los efectos. El motor (scripts/reelkit.py) compone cada fotograma con Pillow, los envía a ffmpeg y mezcla el audio. No se edita nada en un editor de video: todo el texto, los recuadros y la animación provienen del motor, por lo que son nítidos, coherentes con la marca y perfectamente sincronizados.

Un segundo motor dibuja: animation/ renderiza componentes React fotograma a fotograma en el Chrome o Edge ya instalado en la máquina (sin interfaz gráfica) y los codifica con ffmpeg. Úsalo para lo que está diseñado en lugar de filmado: tipografía cinética, anuncios animados, gráficos que crecen, un producto en 3D, física, partículas, una foto de producto convertida en anuncio. Su salida es un MP4 (o fotogramas transparentes) que el montaje usa como cualquier clip o capa, así que un reel puede tener ambos (§ 5).

Todo se ejecuta en este ordenador. La skill nunca sube, descarga ni llama a un servicio mientras funciona: las fuentes están incluidas, los efectos de sonido están incluidos y los medios son del usuario. Lee este archivo completo, luego la referencia a la que apunta el paso actual. examples/first-reel/reel.py y examples/animated-reel/reel.py en la carpeta del plugin renderizan reels completos sin ningún medio externo: la forma más rápida de comprobar que una máquina puede renderizar.

0. Verificar la máquina (30 segundos)

python <skill>/scripts/media.py doctor                  # python, ffmpeg, paquetes, fuentes, formato
ffmpeg -version && ffprobe -version

Si falta ffmpeg es una parada obligatoria: indícale al usuario cómo instalarlo (references/troubleshooting.md). Si faltan Pillow o numpy: python -m pip install Pillow numpy (los descarga de PyPI una vez; dilo antes de ejecutarlo).

1. Elegir la ruta

El material es…RutaReferencia
Clips o fotos del usuarioA · Metraje: hojas de contactos → seleccionar segmentos → cortar al ritmo → antes/después → tarjeta finalreferences/footage.md
Un guion que el usuario pueda grabarB · Voz: el usuario graba un archivo por oración → subtítulos palabra por palabra → cortes en las palabrasreferences/production.md
Un anuncio, un título, un gráfico, un producto para mostrar, sin metrajeC · Dibujado: un proyecto de animación (React) → imagen fija del fotograma clave → fotogramas → renderizarreferences/animation.md
Solo texto y músicaD · Texto en pantalla: el guion del cliente como texto animado sobre fondos dibujados o fotos, cortado al ritmoreferences/production.md § Subtítulos

Las rutas se mezclan: un reel de metraje puede llevar la voz del usuario; cualquier reel puede llevar capas dibujadas, un gráfico dibujado o una tarjeta final dibujada (§ 5).

2. Flujo de trabajo

  1. Carpeta de trabajo — python scripts/new_reel.py <carpeta> --brand studio|lime|forest|mono --title "…" [--format 16:9|1:1]. Crea img/ vid/ frames/ vo/ music/ sfx/ ref/ out/ review/ y un reel.py a partir de la plantilla; el formato (9:16 a menos que se indique lo contrario) se establece al principio con rk.set_format(). Marca: pieces.Brand.from_logo('ref/logo.png') mide los colores reales; imprímelos y mira primero el archivo del logotipo (las carpetas están llenas de nombres de archivo engañosos).
  2. Guion — 85-100 palabras para 35-45 s. Gancho en la primera oración, una idea por oración, un final que haga eco del gancho. Solo afirma lo que está en el material del usuario: sin cifras nuevas, sin promesas nuevas. Si el usuario dio el guion, úsalo textualmente.
  3. Voz — el usuario la graba, un archivo por oración (vo/v01.m4a, v02…; mp3, wav y m4a funcionan todos): una nota de voz del teléfono es suficiente. Cómo pedirla y qué hacer mientras aún no está grabada está en references/production.md § Voz. Luego python scripts/media.py voice <carpeta>: duraciones y tramos con voz; cada temporización y corte se deriva de ellos. ¿Sin voz (guion en pantalla, solo música)? Saltar al 4.
  4. Imágenes y clips — las fotos del usuario en img/, los clips en vid/. python scripts/media.py sheet-img <carpeta> y sheet-footage los muestran en una sola hoja: MÍRALA antes de elegir. Los fondos, tarjetas y gráficos dibujados provienen de las piezas o del motor de animación.
  5. Editar primero con imágenes fijas — escribe reel.py usando pieces.source(nombre, 'img/x.png') y ejecuta python reel.py --preview. Mira review/preview.jpg. Ajusta el ritmo, el encuadre y las capas ANTES de renderizar. Este paso es donde se hace el reel; no lo apresures.
  6. Clips — media.py extract corta los segmentos del metraje real que el reel usa en frames/<nombre>/; media.py frames convierte clips completos. Revisa la hoja de movimiento (media.py sheet-motion <carpeta>).
  7. Música y efectos — la pista del usuario en music/ (una de la que tenga los derechos), o ninguna. El motor la recorta desde el primer ataque y la baja bajo la voz. Los efectos están incluidos: pieces.sfx('whoosh'|'pop'|'shimmer'|'chime'| 'typing'|'shutter'|'coaster'|'fridge'). Corta al ritmo cuando no haya voz: media.py beats → references/footage.md.
  8. Renderizar y verificar — python reel.py, luego python scripts/media.py verify out/reel.mp4: especificaciones, sonoridad (objetivo −14 LUFS) y una hoja de contactos extraída del MP4 final. Mira esa hoja. Luego mira 2-3 fotogramas completos (media.py frame out/reel.mp4 <t>) en los momentos importantes: un cambio de subtítulo, la transición, la tarjeta final.
  9. Entregar — out/reel.mp4 + out/cover.jpg (reel.cover(t, 'out/cover.jpg')) + texto de pie de foto y hashtags en un .md + las fuentes (reel.py, img/, vo/, music/, ref/; nunca frames/). No publiques nada: lo hace el usuario. Informa de lo que no pudiste verificar (no puedes escuchar la mezcla: dilo y proporciona los números de sonoridad).

3. Reglas que provienen de errores reales

  • Mira cada hoja. imgs.jpg, motion.jpg, preview.jpg, la hoja verify. Un renderizado no supervisado no se entrega.
  • Logotipos. Nunca confíes en un nombre de archivo. Ábrelo. Si es pequeño, reconstruye la marca denominativa como texto con los colores medidos.
  • Marcas de terceros. Nunca añadas un logotipo o identidad que no sea del usuario (p. ej., el fabricante de un producto que vende). Una marca puede aparecer porque está en el propio metraje del usuario; nunca se añade.
  • Los cortes provienen de la voz, nunca a ojo: caps.word_time(clave, i) y los tramos de media.py voice.
  • Clips cortos. Nunca reduzcas la velocidad de un clip por debajo de speed=0.8 (las fuentes a 24 fps fluctúan); para alargarlo, coloca un Still de un fotograma del mismo clip antes, con el zoom igualado.
  • Zonas seguras. Instagram cubre aproximadamente 220 px en la parte superior y 360 px en la inferior. Titulares y chips entre y=230 e y=520; subtítulos en y≈1440; nada importante por debajo de y≈1560. Tipo mínimo 30 px (chips secundarios 36-44, titulares 70+). 16:9 y 1:1 (1080 px de alto): titulares desde y≈110, subtítulos en y≈880, nada importante por debajo de y≈1000. Las piezas toman estos valores predeterminados de rk.LAYOUT; escribe las posiciones como números solo cuando las necesites, nunca copiadas de un reel 9:16.
  • Formatos. rk.set_format('16:9') (o REELKIT_FORMAT=16:9) va primero, antes de from reelkit import W, H y antes de cualquier fuente o capa. Extrae los clips para el formato: media.py frames <trabajo> --format 16:9.
  • Subtítulos sobre fondos claros necesitan pieces.bottom_gradient(marca) como PRIMERA capa.
  • La música en los clips del usuario no es de su propiedad para reutilizarla. Los sonidos reales (una lavadora, un motor) se pueden cortar del metraje con media.py sound; una canción que suena de fondo en un clip no es una licencia para usarla.

4. El motor en una pantalla (referencia completa: references/api.md)

import reelkit as rk; rk.set_format('9:16')                    # '16:9' / '1:1': primero, W y H se copian al importar
from reelkit import W, H, Reel, Captions, Still, Clip, Func, blit, text_img, pill, lerp, clamp01, eo, eio, eback
import pieces as pz; from pieces import source, sfx
rk.set_base(carpeta); B = pz.BRANDS['lime'].activate()          # o pz.Brand.from_logo('ref/logo.png').activate()
reel = Reel('nombre'); caps = Captions(size=70, y=1440, maxw=920); reel.caps = caps    # 16:9 / 1:1: Captions(size=62)
t_end = reel.vo('vo/v01.m4a', 0.30)                            # devuelve dónde termina la oración
caps.line('v01', 'Oración con *palabras* *clave*, / siguiente bloque.', 'vo/v01.m4a', 0.30)  # *hl* · / salto · mostrado|hablado
t = caps.word_time('v01', 2)                                    # el segundo en que se dice la 3.ª palabra → cortar aquí
reel.shot(0.0, t, source('hero', 'img/hero.jpg', z=(1.0, 1.06), c=(.5, .45)))
reel.shot(t, 5.0, Clip('hero', speed=1.0, start=0.25, z=(1.14, 1.24)))  # frames/hero/ de media.py extract
GRAD = pz.bottom_gradient(B); reel.ov(0.0, 5.0, lambda c, tl, dur, T: c.alpha_composite(GRAD))   # capa: (lienzo, tl, dur, t)
reel.ov(0.0, t, pz.headline(B, 'KICKER', 'Línea de gancho', 'FRASE CLAVE'))
reel.ov(t, 5.0, pz.list_item(B, 1, 3, 'ELEMENTO', 'Beneficio en una línea'))
reel.ov(0.0, 4.0, pz.text_layer('Guion del cliente *resaltado*'))                   # texto en pantalla sin voz
SITIO = pz.browser_frame('img/site.png', 1000, url='site.com')                      # construir imágenes una vez, fuera de las capas
reel.ov(t, 5.0, lambda c, tl, dur, T: pz.appear(c, SITIO, W / 2, H * .4, tl, 0))   # captura de pantalla aparece
reel.shot(5.0, 8.0, pz.wipe_scene(antes_src, despues_src, B, hold=1.0))            # antes/después
reel.shot(8.0, 11.0, pz.outro_save(B, 'img/hero.jpg', 'ref/logo.png', cta='Reserva una llamada · sitio.com'))
reel.sfx(sfx('whoosh'), t - 0.12, 0.32); reel.sfx(sfx('chime'), 8.3, 0.30)
reel.preview([0.5, 2.0, 4.5, 6.0, 9.0], 'review/preview.jpg', cols=5, scale=0.22)
reel.render('out/reel.mp4', 11.0, music='music/base.mp3', music_gain=0.24); reel.cover(1.2, 'out/cover.jpg')

Las capas son funciones f(lienzo, t_local, duración, t_global) que dibujan RGBA sobre el lienzo con blit. Las fuentes son objetos con .frame(t_local, duración) que devuelven una imagen RGB del tamaño del lienzo (W x H): Still, Clip, Func(f), y las escenas en pieces (wipe_scene, outro_save, outro_fan, blur_in). Easing: eo (out), eio (in-out), eback (pop). Construye las imágenes (degradados, tarjetas, fotogramas) una vez fuera de la función de capa; el texto y las píldoras se almacenan en caché.

5. Animación dibujada (referencia completa: references/animation.md)

Configurar una vez: Node.js 18+, luego npm install dentro de <skill>/animation (descarga los paquetes del motor desde npm una vez; dilo antes de ejecutarlo) y node <skill>/animation/cli.mjs doctor. Un proyecto es una carpeta con package.json, src/index.jsx (registerRoot + una <Composition> por video) y public/ para sus archivos. Los componentes importan de 'invokard-studio': useCurrentFrame, spring, interpolate, Sequence, Img + staticFile, OffthreadVideo, 3D de 'invokard-studio/three', y fuentes de 'invokard-studio/google-fonts/<Familia>' — solo las quince familias incluidas: Inter, Outfit, Figtree, Poppins, Montserrat, Space Grotesk, Barlow, Barlow Condensed, Oswald, Anton, Bebas Neue, Playfair Display, Fraunces, Shrikhand, Caveat. Otro tipo de letra: el usuario coloca su archivo en public/ y lo declaras con @font-face.

node <skill>/animation/cli.mjs still  src/index.jsx Ad out/ad.png --frame 120     # 1. diseñar el fotograma clave
node <skill>/animation/cli.mjs frames src/index.jsx Ad out/ad --frames 0,34,68,102,136,170,204,239   # 2. el movimiento
node <skill>/animation/cli.mjs render src/index.jsx Ad out/ad.mp4 --props data.json # 3. el video (todos los fotogramas)

Cada fotograma se calcula a partir de su número (sin Math.random, sin relojes, sin animaciones CSS): los fotogramas se dibujan fuera de orden en varias pestañas. Mira cada imagen fija y cada hoja de fotogramas que renderices, como haces con los reels. En un reel:

import animation as an                                                          # scripts/animation.py
an.render('anim/src/index.jsx', 'Title', rk.P('anim/title'), transparent=True)  # fotogramas PNG con alfa
reel.ov(t0, t1, an.layer(rk.P('anim/title')))                                   # dibujado sobre el montaje
reel.shot(t2, t3, an.clip('anim/src/index.jsx', 'EndCard', 'tarjetafinal'))      # un plano dibujado, cortado como un clip

examples/animated-reel/ en la carpeta del plugin es un reel completo que hace ambas cosas, sin medios externos.

6. Lista de verificación de la entrega

  • out/reel.mp4 es 1080x1920 (o 1920x1080 / 1080x1080 según lo solicitado), 30 fps, H.264 + AAC, −14 LUFS ± 1, pico ≤ −1 dBFS (media.py verify)
  • Se revisaron la hoja de verificación y 2-3 fotogramas completos; los subtítulos nunca quedan por debajo de y≈1560 ni sobre un rostro/producto
  • Cada afirmación en pantalla está en el material del usuario; los colores de la marca se midieron, no se adivinaron
  • out/cover.jpg se lee dentro del recorte central 4:5 del feed
  • Las fuentes se entregan sin frames/; no se publicó nada

7. Lo que esta build no hace

No genera imágenes, clips de video, voces, música ni modelos 3D con IA, y no llama a ningún servicio en línea. Cuando una solicitud necesite alguno de esos, dilo claramente en el plan: el video se puede hacer ahora con las propias fotos, clips y grabaciones del usuario, con animación dibujada (títulos, gráficos, productos en 3D, ilustraciones hechas de formas), o con archivos que el usuario traiga de donde quiera. No recomiendes un producto o servicio en particular.

Referencias

  • references/production.md — la voz del usuario, subtítulos, zonas seguras, audio, marcas.
  • references/footage.md — reels a partir de los clips del usuario: hojas de contactos, extracción, cuadrícula de ritmo, empalme de música, transición, tarjeta final.
  • references/animation.md — el motor de animación: proyecto, comandos, API, fuentes incluidas, montaje + animación, solución de problemas.
  • references/api.md — cada función de reelkit.py, pieces.py y media.py con sus argumentos, y las posiciones predeterminadas por formato.
  • references/troubleshooting.md — ffmpeg, fuentes, consola de Windows, renders largos.

Skills relacionados