Cuando esta skill se activa, comienza siempre tu primera respuesta con el emoji :clapper:.
Video Remotion
Remotion es un framework para crear videos programáticamente usando React. En lugar de editores basados en línea de tiempo, escribes composiciones como componentes de React donde cada cuadro es una función del número de cuadro actual. Esto te otorga el poder completo de TypeScript, paquetes npm y una arquitectura basada en componentes para construir videos, desde explicaciones animadas y clips para redes sociales hasta visualizaciones basadas en datos y videos personalizados a escala.
Esta skill cubre la configuración del proyecto, la estructura de composición, las animaciones basadas en cuadros con interpolate y spring, la secuenciación de escenas, la gestión de assets, la integración de audio, los videos parametrizados con esquemas Zod y el renderizado a MP4/WebM a través de CLI o APIs programáticas.
Cuándo usar esta skill
Activa esta skill cuando el usuario:
- Quiere crear un video programáticamente usando React/TypeScript
- Pregunta sobre composiciones Remotion, useCurrentFrame o useVideoConfig
- Necesita animar texto, elementos o transiciones entre escenas
- Quiere renderizar un video a MP4, WebM o GIF desde código
- Pregunta sobre animaciones spring, interpolate o temporización basada en cuadros
- Necesita configurar un nuevo proyecto Remotion desde cero
- Quiere agregar audio, imágenes o fuentes a un video Remotion
- Pregunta sobre generación de video parametrizada/basada en datos
- Necesita configurar Remotion Studio para previsualizar composiciones
NO actives esta skill para:
- Preguntas generales de React no relacionadas con la creación de videos - usa skills de React
- Edición de video con herramientas de línea de tiempo tradicionales (Premiere, DaVinci, FFmpeg CLI)
- Animaciones CSS para páginas web - usa skills de animación/diseño de movimiento
- Reproducción o transmisión de video en aplicaciones web - usa skills de reproductor multimedia
Principios clave
-
Cada cuadro es una función pura - Un componente Remotion recibe el cuadro actual a través de
useCurrentFrame()y debe renderizar de manera determinista para ese cuadro. Sin efectos secundarios, sin aleatoriedad sin semillas, sin dependencia del tiempo de pared. El mismo número de cuadro siempre debe producir la misma salida visual. -
Las composiciones son la unidad de video - Cada
<Composition>define un video con dimensiones explícitas (ancho, alto), velocidad de cuadros (fps) y duración (durationInFrames). Piensa en las composiciones como "páginas" en tu proyecto: una por variante de video o escena que se puede renderizar de forma independiente. -
Interpolate para todo - La función
interpolate()asigna números de cuadro a cualquier valor numérico (opacidad, posición, escala, canales de color). Combinado conextrapolateRight: 'clamp', es el caballo de batalla para todas las animaciones. Usaspring()cuando necesites aceleración basada en física. -
Sequence para desplazamientos de tiempo - Usa
<Sequence from={cuadro}>para retrasar cuándo los hijos comienzan a aparecer, y<Series>para reproducir hijos uno tras otro. Nunca uses setTimeout o matemática de cuadros manual para la secuenciación; los primitivos declarativos lo manejan correctamente en la vista previa y el renderizado. -
Los assets son estáticos, los datos son dinámicos - Coloca imágenes, fuentes y archivos de audio en la carpeta
public/y refiérelos constaticFile(). Para datos dinámicos (respuestas de API, registros de base de datos), usadelayRender()/continueRender()para pausar el renderizado hasta que los datos se carguen.
Conceptos centrales
Estructura de composición
Cada proyecto de Remotion tiene un archivo raíz que registra las composiciones:
import { Composition } from 'remotion';
import { MyVideo } from './MyVideo';
export const RemotionRoot: React.FC = () => {
return (
<Composition
id="MyVideo"
component={MyVideo}
durationInFrames={150}
fps={30}
width={1920}
height={1080}
/>
);
};
Temporización basada en cuadros
Toda la temporización en Remotion se expresa en cuadros, no en segundos. Para convertir:
- Segundos a cuadros:
segundos * fps - Cuadros a segundos:
cuadro / fps
A 30 fps, un video de 5 segundos son 150 cuadros. El cuadro 0 es el primer cuadro.
Modelo de animación
Remotion proporciona dos primitivos de animación centrales:
| Primitivo | Caso de uso | Ejemplo |
|---|---|---|
interpolate() | Mapeo lineal/limitado de cuadro a valor | Fundido, deslizamiento, escalado |
spring() | Animación basada en física con amortiguación/masa | Entradas con rebote, movimiento natural |
Ambos devuelven un número que aplicas a estilos (opacidad, transform, etc.).
Tareas comunes
1. Configurar un nuevo proyecto Remotion
npx create-video@latest
Esto crea un proyecto con TypeScript, una composición de ejemplo y Remotion Studio configurado. La estructura del proyecto será:
mi-video/
src/
Root.tsx # Registra todas las composiciones
MyComp.tsx # Tu primer componente de composición
public/ # Assets estáticos (imágenes, fuentes, audio)
remotion.config.ts # Configuración de Remotion
package.json
Inicia el estudio de vista previa con:
npx remotion studio
2. Crear una composición básica con useCurrentFrame
import { AbsoluteFill, useCurrentFrame, useVideoConfig, interpolate } from 'remotion';
export const FadeInText: React.FC = () => {
const frame = useCurrentFrame();
const { fps } = useVideoConfig();
const opacity = interpolate(frame, [0, 30], [0, 1], {
extrapolateRight: 'clamp',
});
const translateY = interpolate(frame, [0, 30], [20, 0], {
extrapolateRight: 'clamp',
});
return (
<AbsoluteFill
style={{
justifyContent: 'center',
alignItems: 'center',
backgroundColor: '#0f0f0f',
}}
>
<h1
style={{
fontSize: 80,
color: 'white',
opacity,
transform: `translateY(${translateY}px)`,
}}
>
Hola Remotion
</h1>
</AbsoluteFill>
);
};
3. Animar texto palabra por palabra
Divide el texto en palabras y escalona la aparición de cada palabra usando <Sequence>:
import { AbsoluteFill, Sequence, useCurrentFrame, interpolate } from 'remotion';
const AnimatedWord: React.FC<{ children: string }> = ({ children }) => {
const frame = useCurrentFrame();
const opacity = interpolate(frame, [0, 15], [0, 1], {
extrapolateRight: 'clamp',
});
const translateY = interpolate(frame, [0, 15], [10, 0], {
extrapolateRight: 'clamp',
});
return (
<span
style={{
display: 'inline-block',
opacity,
transform: `translateY(${translateY}px)`,
marginRight: 12,
}}
>
{children}
</span>
);
};
export const WordByWord: React.FC<{ text: string }> = ({ text }) => {
const words = text.split(' ');
return (
<AbsoluteFill
style={{
justifyContent: 'center',
alignItems: 'center',
backgroundColor: '#1a1a2e',
flexWrap: 'wrap',
padding: 100,
}}
>
{words.map((word, i) => (
<Sequence key={i} from={i * 8}>
<AnimatedWord>{word}</AnimatedWord>
</Sequence>
))}
</AbsoluteFill>
);
};
4. Animaciones de elementos con spring
Usa spring() para animaciones basadas en física que se sientan naturales:
import { AbsoluteFill, useCurrentFrame, useVideoConfig, spring } from 'remotion';
export const SpringCard: React.FC = () => {
const frame = useCurrentFrame();
const { fps } = useVideoConfig();
const scale = spring({
frame,
fps,
config: { damping: 200, stiffness: 100, mass: 0.5 },
});
const slideUp = spring({
frame: frame - 10,
fps,
config: { damping: 12, stiffness: 100 },
});
return (
<AbsoluteFill style={{ justifyContent: 'center', alignItems: 'center', backgroundColor: '#0d1117' }}>
<div
style={{
width: 400,
height: 250,
backgroundColor: '#161b22',
borderRadius: 16,
transform: `scale(${scale}) translateY(${(1 - slideUp) * 50}px)`,
}}
>
<p style={{ color: 'white', fontSize: 32 }}>Animación Spring</p>
</div>
</AbsoluteFill>
);
};
5. Transiciones de escena con Sequence y Series
Usa <Sequence> para escenas superpuestas y <Series> para reproducción secuencial:
import { AbsoluteFill, Sequence, Series, useCurrentFrame, interpolate } from 'remotion';
const Scene: React.FC<{ color: string; title: string }> = ({ color, title }) => {
const frame = useCurrentFrame();
const opacity = interpolate(frame, [0, 20], [0, 1], {
extrapolateRight: 'clamp',
});
return (
<AbsoluteFill style={{ backgroundColor: color, justifyContent: 'center', alignItems: 'center' }}>
<h1 style={{ color: 'white', fontSize: 72, opacity }}>{title}</h1>
</AbsoluteFill>
);
};
export const MultiScene: React.FC = () => {
return (
<AbsoluteFill>
<Series>
<Series.Sequence durationInFrames={60}>
<Scene color="#e63946" title="Escena Uno" />
</Series.Sequence>
<Series.Sequence durationInFrames={60}>
<Scene color="#457b9d" title="Escena Dos" />
</Series.Sequence>
<Series.Sequence durationInFrames={60}>
<Scene color="#2a9d8f" title="Escena Tres" />
</Series.Sequence>
</Series>
</AbsoluteFill>
);
};
6. Manejo de assets (imágenes, fuentes, staticFile)
Referencia a assets estáticos desde la carpeta public/ usando staticFile():
import { AbsoluteFill, Img, staticFile } from 'remotion';
export const AssetDemo: React.FC = () => {
return (
<AbsoluteFill style={{ justifyContent: 'center', alignItems: 'center' }}>
<Img
src={staticFile('logo.png')}
style={{ width: 300, height: 300 }}
/>
</AbsoluteFill>
);
};
Carga fuentes personalizadas con @remotion/google-fonts o CSS @font-face:
import { loadFont } from '@remotion/google-fonts/Inter';
const { fontFamily } = loadFont();
export const FontDemo: React.FC = () => {
return (
<AbsoluteFill style={{ justifyContent: 'center', alignItems: 'center' }}>
<h1 style={{ fontFamily, fontSize: 64, color: 'white' }}>
Fuente Personalizada
</h1>
</AbsoluteFill>
);
};
7. Integración de audio
Agrega audio con control de volumen y temporización:
import { AbsoluteFill, Audio, Sequence, staticFile, interpolate } from 'remotion';
export const WithAudio: React.FC = () => {
return (
<AbsoluteFill style={{ backgroundColor: '#000' }}>
<Audio
src={staticFile('background-music.mp3')}
volume={(f) =>
interpolate(f, [0, 30, 120, 150], [0, 0.8, 0.8, 0], {
extrapolateLeft: 'clamp',
extrapolateRight: 'clamp',
})
}
/>
<Sequence from={15}>
<Audio src={staticFile('whoosh.mp3')} volume={0.5} />
</Sequence>
</AbsoluteFill>
);
};
8. Renderizado de videos
Renderiza a MP4 desde la línea de comandos:
# Renderizar composición predeterminada
npx remotion render src/index.ts MyVideo out/video.mp4
# Renderizar en resolución 4K
npx remotion render src/index.ts MyVideo out/video.mp4 --width 3840 --height 2160
# Renderizar a WebM
npx remotion render src/index.ts MyVideo out/video.webm --codec vp8
# Renderizar un rango de cuadros específico
npx remotion render src/index.ts MyVideo out/video.mp4 --frames 0-90
# Renderizar con props personalizadas
npx remotion render src/index.ts MyVideo out/video.mp4 --props '{"title": "Hola"}'
Para renderizado programático, consulta references/rendering-guide.md.
Antipatrones / errores comunes
| Error | Por qué está mal | Qué hacer en su lugar |
|---|---|---|
Usar Math.random() sin una semilla | Produce una salida diferente por cuadro durante el renderizado | Usa una semilla determinista o random() de Remotion |
Usar setTimeout / setInterval | Rompe el renderizado basado en cuadros: los temporizadores no avanzan por cuadro | Usa useCurrentFrame() y matemática de cuadros para toda la temporización |
Falta extrapolateRight: 'clamp' | Los valores sobrepasan el rango objetivo en cuadros posteriores | Siempre agrega { extrapolateRight: 'clamp' } a interpolate() |
| Codificar fps en cálculos de cuadros | Se rompe cuando cambia el fps de la composición | Usa useVideoConfig().fps para derivar la temporización |
Usar <Video> para la salida renderizada | Rendimiento de renderizado más lento debido a la sobrecarga de búsqueda | Usa <OffthreadVideo> para un mejor rendimiento de renderizado |
Olvidar delayRender() para datos asíncronos | Renderiza antes de que los datos se carguen, mostrando cuadros vacíos o rotos | Llama a delayRender() inmediatamente, continueRender() cuando esté listo |
| Estilos en línea con valores no deterministas | Parpadeos o inconsistencia entre la vista previa y el renderizado | Deriva todos los valores de estilo solo del número de cuadro |
| Composición única gigante | Difícil de mantener e imposible de renderizar escenas de forma independiente | Divide en múltiples composiciones o usa Series para escenas |
Advertencias
-
El valor predeterminado de extrapolateRight es 'extend' - Si escribes
interpolate(frame, [0, 30], [0, 1])sin limitar, el valor seguirá aumentando más allá de 1 después del cuadro 30 (por ejemplo, el cuadro 60 da una opacidad de 2). Siempre pasa{ extrapolateRight: 'clamp' }a menos que tengas la intención de extrapolar. -
spring() comienza desde el cuadro 0 de su contexto - Cuando usas
spring()dentro de un<Sequence from={60}>, el cuadro pasado a spring se reinicia a 0 en el cuadro 60 del padre. Si pasas el cuadro sin procesar del padre, la animación ya estará completa. UsauseCurrentFrame()dentro del hijo de Sequence, no un cuadro del padre. -
Las rutas de staticFile() son relativas a public/ - Llamar a
staticFile('images/logo.png')buscapublic/images/logo.png. Usar rutas absolutas o rutas fuera depublic/fallará silenciosamente en la vista previa y generará un error durante el renderizado. Asegúrate de que todos los assets estén en el directoriopublic/. -
delayRender tiene un tiempo de espera de 30 segundos - Si tu operación asíncrona (llamada API, carga de fuente) tarda más de 30 segundos, el renderizado se abortará. Aumenta el tiempo de espera con
delayRender('Cargando datos', { timeoutInMilliseconds: 60000 })para operaciones lentas. -
Las dimensiones de la composición deben ser números pares - Los códecs de video (H.264, VP8) requieren ancho y alto pares. Remotion lanzará un error si proporcionas dimensiones impares. Siempre verifica que
ancho % 2 === 0yalto % 2 === 0. -
La gravedad de spring acelera en lugar de frenar - A diferencia del mundo real donde la gravedad acelera hacia abajo, la función
spring()de Remotion desacelera desde su estado inicial hasta el estado final. Si quieres una animación similar a una caída, invierte el rango de tu animación (por ejemplo, comienza desde abajo y termina en su lugar) o usainterpolate()con una función de aceleración. -
Los componentes dentro de Series se montan cuando comienza su segmento - No asumas que los componentes de Series están montados durante todo el video. Cualquier hook
useCurrentFrame()dentro de un hijo de Series comienza desde 0 cuando comienza el segmento de ese hijo. Para superposiciones entre segmentos, usa<Sequence>en lugar de<Series.Sequence>.