Communitygithub.com

tinh2/skills-hub-registry

Construye videos programáticos con Remotion (React). Cubre composiciones, animaciones, secuencias, transiciones, incrustación de audio/video, física de resortes, animaciones de texto, generación de voz en off con ElevenLabs TTS, integración FFmpeg, subtítulos, 3D con Three.js, gráficos y renderizado. Basado en las mejores prácticas oficiales de Remotion.

¿Qué es skills-hub-registry?

Esta habilidad permite a un agente de IA crear videos programáticos utilizando Remotion y React. Está diseñada para ayudar en la generación de videos basados en composiciones, animaciones, secuencias y transiciones, siguiendo las mejores prácticas oficiales de Remotion. La habilidad cubre una amplia gama de funcionalidades, incluyendo el uso de `useCurrentFrame()` e `interpolate()` para animaciones, implementación de física de resortes con `spring()`, manejo de secuencias con `<Sequence>` y `<Series>, y aplicación de transiciones complejas con el paquete `@remotion/transitions`. También soporta la incrustación de audio y video, la generación de voz en off mediante la API de ElevenLabs TTS, la integración con FFmpeg para operaciones de conversión de formatos, y el uso de `staticFile()` para la gestión de activos. Es compatible con plataformas como Claude Code, Cursor, Codex y cualquier agente que siga el estándar de SKILL.md. La habilidad se basa en la documentación oficial de Remotion y sus repositorios de habilidades, proporcionando ejemplos de código y patrones comunes como videos basados en escenas y combinación de música de fondo con voz en off.

Compatible con✓Claude Code~Codex CLI✓Cursor
npx skills add https://github.com/tinh2/skills-hub-registry/tree/HEAD/build/remotion

Preguntar en tu IA favorita

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

Documentación

Remotion – Creación de Videos en React

Usa esta habilidad cuando trabajes con código de Remotion. Remotion te permite crear videos programáticamente usando componentes de React.

Configuración del Proyecto

npx create-video@latest mi-video
cd mi-video
npm start        # Vista previa en el navegador
npm run render   # Renderizar a MP4

Composiciones

Un <Composition> define un video renderizable con dimensiones, FPS y duración.

import { Composition } from "remotion";
import { MiVideo } from "./MiVideo";

export const RemotionRoot = () => (
  <Composition
    id="MiVideo"
    component={MiVideo}
    durationInFrames={300}
    fps={30}
    width={1920}
    height={1080}
    defaultProps={{ title: "Hola Mundo" } satisfies MiVideoProps}
  />
);

Usa declaraciones type para las props (no interface) para la seguridad de tipos de defaultProps.

Usa <Folder> para organizar las composiciones en la barra lateral. Usa <Still> para salidas de un solo fotograma (miniaturas, imágenes OG).

Animaciones

TODAS las animaciones DEBEN usar useCurrentFrame(). Las transiciones CSS y las clases de animación de Tailwind están PROHIBIDAS: no se renderizarán correctamente.

import { useCurrentFrame, useVideoConfig, interpolate } from "remotion";

export const Fundido = () => {
  const frame = useCurrentFrame();
  const { fps } = useVideoConfig();

  const opacidad = interpolate(frame, [0, 2 * fps], [0, 1], {
    extrapolateRight: "clamp",
  });

  return <div style={{ opacity: opacidad }}>¡Hola Mundo!</div>;
};

Animaciones con Resortes (Spring)

Los resortes proporcionan movimiento natural. Animan de 0 a 1.

import { spring, useCurrentFrame, useVideoConfig } from "remotion";

const frame = useCurrentFrame();
const { fps } = useVideoConfig();

const escala = spring({ frame, fps });
// Con configuración:
const suave = spring({ frame, fps, config: { damping: 200 } }); // Sin rebote
const rapido = spring({ frame, fps, config: { damping: 20, stiffness: 200 } });
const rebotante = spring({ frame, fps, config: { damping: 8 } });
const pesado  = spring({ frame, fps, config: { damping: 15, stiffness: 80, mass: 2 } });

Usa el parámetro delay para retrasar el inicio del resorte:

const entrada = spring({ frame, fps, delay: 20 });

Interpolación

// Interpolación lineal con sujeción (clamp)
const opacidad = interpolate(frame, [0, 100], [0, 1], {
  extrapolateRight: "clamp",
  extrapolateLeft: "clamp",
});

// Interpolación de múltiples pasos
const y = interpolate(frame, [0, 30, 60, 90], [100, 0, 0, -100]);

Secuenciación

Sequence

Usa <Sequence> para retrasar la aparición de elementos. Usa siempre premountFor para precargar componentes.

import { Sequence } from "remotion";

const { fps } = useVideoConfig();

<Sequence from={1 * fps} durationInFrames={2 * fps} premountFor={1 * fps}>
  <Titulo />
</Sequence>
<Sequence from={2 * fps} durationInFrames={2 * fps} premountFor={1 * fps}>
  <Subtitulo />
</Sequence>

Usa layout="none" para evitar el envoltorio de posicionamiento absoluto.

Series

Usa <Series> para reproducción secuencial sin superposición:

import { Series } from "remotion";

<Series>
  <Series.Sequence durationInFrames={45}><Intro /></Series.Sequence>
  <Series.Sequence durationInFrames={60}><ContenidoPrincipal /></Series.Sequence>
  <Series.Sequence durationInFrames={30}><Outro /></Series.Sequence>
</Series>

Un offset negativo crea transiciones superpuestas:

<Series.Sequence offset={-15} durationInFrames={60}>
  <EscenaB />
</Series.Sequence>

Transiciones

npx remotion add @remotion/transitions
import { TransitionSeries, linearTiming } from "@remotion/transitions";
import { fade } from "@remotion/transitions/fade";
import { slide } from "@remotion/transitions/slide";
import { wipe } from "@remotion/transitions/wipe";

<TransitionSeries>
  <TransitionSeries.Sequence durationInFrames={60}>
    <EscenaA />
  </TransitionSeries.Sequence>
  <TransitionSeries.Transition
    presentation={fade()}
    timing={linearTiming({ durationInFrames: 15 })}
  />
  <TransitionSeries.Sequence durationInFrames={60}>
    <EscenaB />
  </TransitionSeries.Sequence>
</TransitionSeries>

Superposiciones de Fugas de Luz

import { LightLeak } from "@remotion/light-leaks";

<TransitionSeries>
  <TransitionSeries.Sequence durationInFrames={60}>
    <EscenaA />
  </TransitionSeries.Sequence>
  <TransitionSeries.Overlay durationInFrames={20}>
    <LightLeak />
  </TransitionSeries.Overlay>
  <TransitionSeries.Sequence durationInFrames={60}>
    <EscenaB />
  </TransitionSeries.Sequence>
</TransitionSeries>

Una superposición no puede estar adyacente a una transición ni a otra superposición.

Audio

npx remotion add @remotion/media
import { Audio } from "@remotion/media";
import { staticFile } from "remotion";

// Audio básico
<Audio src={staticFile("audio.mp3")} />

// Con recorte (valores en fotogramas)
<Audio src={staticFile("audio.mp3")} trimBefore={2 * fps} trimAfter={10 * fps} />

// Control de volumen
<Audio src={staticFile("audio.mp3")} volume={0.5} />

// Volumen dinámico (callback recibe fotograma)
<Audio src={staticFile("audio.mp3")} volume={(f) =>
  interpolate(f, [0, 30], [0, 1], { extrapolateRight: "clamp" })
} />

// Cambio de velocidad
<Audio src={staticFile("audio.mp3")} playbackRate={1.5} />

// Retrasar inicio del audio
<Sequence from={1 * fps}>
  <Audio src={staticFile("audio.mp3")} />
</Sequence>

Múltiples componentes <Audio> se superponen automáticamente.

Incrustación de Video

import { Video } from "@remotion/media";

// Video básico
<Video src={staticFile("video.mp4")} />

// Con recorte
<Video src={staticFile("video.mp4")} trimBefore={2 * fps} trimAfter={10 * fps} />

// Velocidad, volumen, bucle
<Video src={staticFile("video.mp4")} playbackRate={2} volume={0.5} loop />

// Para rendimiento de renderizado, usa OffthreadVideo
import { OffthreadVideo } from "remotion";
<OffthreadVideo src={staticFile("video.mp4")} />

SIEMPRE usa <OffthreadVideo> para un mejor rendimiento de renderizado. Usa <Video> solo durante la vista previa.

Voz en off con ElevenLabs TTS

Genera voz por escena, luego usa calculateMetadata para dimensionar la composición dinámicamente.

Generar Audio

const respuesta = await fetch(
  `https://api.elevenlabs.io/v1/text-to-speech/${voiceId}`,
  {
    method: "POST",
    headers: {
      "xi-api-key": process.env.ELEVENLABS_API_KEY!,
      "Content-Type": "application/json",
      Accept: "audio/mpeg",
    },
    body: JSON.stringify({
      text: "Bienvenidos al programa.",
      model_id: "eleven_multilingual_v2",
      voice_settings: { stability: 0.5, similarity_boost: 0.75, style: 0.3 },
    }),
  },
);
const bufferAudio = Buffer.from(await respuesta.arrayBuffer());
writeFileSync(`public/vozoff/escena-01.mp3`, bufferAudio);

Duración Dinámica

import { CalculateMetadataFunction, staticFile } from "remotion";

const FPS = 30;
const ESCENAS = ["vozoff/escena-01.mp3", "vozoff/escena-02.mp3"];

export const calculateMetadata: CalculateMetadataFunction<Props> = async () => {
  const duraciones = await Promise.all(
    ESCENAS.map((archivo) => getAudioDuration(staticFile(archivo)))
  );
  const totalFotogramas = duraciones.reduce((sum, d) => sum + Math.ceil(d * FPS), 0);
  return { durationInFrames: totalFotogramas };
};

Activos

Coloca los archivos en public/ y refiéreles con staticFile():

import { staticFile, Img } from "remotion";

<Img src={staticFile("logo.png")} />

NUNCA uses require() o import para archivos multimedia. Usa siempre staticFile().

Fuentes

import { loadFont } from "@remotion/google-fonts/Inter";
const { fontFamily } = loadFont();

// O fuentes locales
const { fontFamily } = loadFont({
  url: staticFile("fonts/MiFuente.woff2"),
  display: "swap",
});

FFmpeg en Remotion

FFmpeg está incluido: no es necesaria instalación:

bunx remotion ffmpeg -i input.mp4 output.mp3
bunx remotion ffprobe input.mp4

Para recortar, prefiere las propiedades trimBefore/trimAfter sobre FFmpeg. Usa FFmpeg para conversión de formatos u operaciones que Remotion no puede hacer de forma nativa.

Al usar FFmpeg para recortar, DEBES volver a codificar para evitar fotogramas congelados:

bunx remotion ffmpeg -ss 00:00:05 -i public/input.mp4 -to 00:00:10 -c:v libx264 -c:a aac public/output.mp4

Renderizado

# Renderizar composición específica
npx remotion render MiVideo output.mp4

# Renderizar un fotograma fijo
npx remotion still MiVideo --frame=100 miniatura.png

# Con propiedades personalizadas
npx remotion render MiVideo output.mp4 --props='{"title": "Personalizado"}'

# Códec específico
npx remotion render MiVideo output.webm --codec=vp8

Patrones Comunes

Video Basado en Escenas

const ESCENAS = [
  { component: EscenaTitulo, duration: 90 },
  { component: EscenaProblema, duration: 150 },
  { component: EscenaSolucion, duration: 120 },
  { component: EscenaCTA, duration: 90 },
];

export const MiVideo = () => {
  let offset = 0;
  return (
    <>
      {ESCENAS.map(({ component: Componente, duration }, i) => {
        const desde = offset;
        offset += duration;
        return (
          <Sequence key={i} from={desde} durationInFrames={duration}>
            <Componente />
          </Sequence>
        );
      })}
    </>
  );
};

Música de Fondo + Voz en off

<>
  {/* Música de fondo a bajo volumen */}
  <Audio src={staticFile("musica/fondo.mp3")} volume={0.12} loop />

  {/* Voces en off de escenas a volumen completo */}
  <Sequence from={0} durationInFrames={fotogramasEscena1}>
    <Audio src={staticFile("vozoff/escena-01.mp3")} volume={1} />
  </Sequence>
  <Sequence from={fotogramasEscena1} durationInFrames={fotogramasEscena2}>
    <Audio src={staticFile("vozoff/escena-02.mp3")} volume={1} />
  </Sequence>
</>

Reglas Clave

  1. Sin animaciones CSS: todo el movimiento mediante useCurrentFrame() + interpolate()/spring()
  2. Sin clases de animación de Tailwind: no se renderizan correctamente
  3. Siempre staticFile() para activos, nunca require()
  4. Siempre premontar Sequences con premountFor
  5. Usa <OffthreadVideo> en lugar de <video> para renderizado
  6. Escribe las duraciones en segundos y multiplícalas por fps
  7. Usa la palabra clave satisfies para la seguridad de tipos de defaultProps

Fuente: remotion-dev/skills, remotion.dev

Skills relacionados