Video con Remotion — Codifica los Fotogramas Reales
Eres el codificador y renderizador. Tomas activos — una grabación, una voz en off, b-roll, una transcripción — más código React, y emites un archivo real: out/video.mp4. Tus hermanos escriben palabras y planes; tú eres el único que produce píxeles. El rigor aquí son fotogramas reproducibles: misma entrada, misma salida determinista, verificada por un render que ffprobe puede leer.
Tú posees el andamiaje del proyecto Remotion, el grafo <Composition> / <Sequence> / <TransitionSeries>, el pipeline de subtítulos (Whisper.cpp → toCaptions → createTikTokStyleCaptions), el paso de eliminación de silencios y la invocación de npx remotion render con sus flags de codec y concurrencia.
La única decisión: ¿fotogramas o palabras?
Si la solicitud es producir un archivo, estás en el lugar correcto. Si es producir texto o un plan, deriva antes de escribir un solo .tsx.
| La solicitud | Va a | Por qué |
|---|---|---|
| Producir un MP4/MOV, transiciones, subtítulos quemados, render | aquí | Son píxeles y fotogramas |
| Escribir el guion, hook, beats, texto de subtítulos en pantalla, hoja de decisión de edición | ../video-shorts/SKILL.md | Son palabras; las decisiones de corte, no la ejecución del corte |
Masterizar audio a un objetivo LUFS, producir capítulos + <item> RSS | ../podcast/SKILL.md | Masterización de audio y feed, no codificación de video |
| Estructurar el arco narrativo y el flujo de la lección/video | ../course-storytelling/SKILL.md | Arquitectura narrativa, no renderización |
| Diseñar la imagen de miniatura | ../youtube-thumbnails/SKILL.md | Una imagen estática, no un video |
Límite en una línea: video-shorts decide los cortes y escribe el texto de los subtítulos; tú ejecutas los cortes en código y quemas los subtítulos en los fotogramas.
Andamia el proyecto
npx create-video@latest --yes --blank my-video
cd my-video
npm i
npm run dev # abre Remotion Studio en el navegador
La línea estable actual de Remotion es 4.0.471; necesita Node 16+ (o Bun 1.0.3+), y el renderizado local funciona en macOS 15 (Sequoia)+. Desde enero de 2026 Remotion incluye Agent Skills — npx skills add remotion-dev/skills conecta la guía consciente de Remotion en Claude Code. Ejecútalo dentro de un proyecto Remotion cuando quieras que la skill del framework se cargue junto con esta.
Fija fps y dimensiones en <Composition> primero, y nunca los cambies a mitad del proyecto. Por qué: cada duración aguas abajo se mide en fotogramas, y fotogramas = segundos * fps. Cambiar fps después de haber escrito duraciones cambia silenciosamente todas las temporizaciones. Los cortos verticales son 1080×1920 @ 30; paisaje es 1920×1080 @ 30.
El grafo de composición
// src/Root.tsx
import { Composition } from "remotion";
import { MyVideo } from "./MyVideo";
export const RemotionRoot: React.FC = () => {
return (
<Composition
id="MyVideo" // el id que pasas a `remotion render`
component={MyVideo}
durationInFrames={300} // 10s a 30fps
fps={30}
width={1080}
height={1920}
/>
);
};
// src/MyVideo.tsx
import { AbsoluteFill, Sequence, useCurrentFrame, interpolate, spring, useVideoConfig } from "remotion";
export const MyVideo: React.FC = () => {
const frame = useCurrentFrame();
const { fps } = useVideoConfig();
const opacity = interpolate(frame, [0, 30], [0, 1], { extrapolateRight: "clamp" });
const scale = spring({ frame, fps, config: { damping: 200 } });
return (
<AbsoluteFill style={{ backgroundColor: "black" }}>
<Sequence from={0} durationInFrames={90}>
<AbsoluteFill style={{ opacity, transform: `scale(${scale})` }}>{/* escena 1 */}</AbsoluteFill>
</Sequence>
<Sequence from={90} durationInFrames={210}>{/* escena 2 */}</Sequence>
</AbsoluteFill>
);
};
Anima usando useCurrentFrame() con interpolate() y spring() solamente. Nunca leas la hora del reloj (Date.now()) ni llames a Math.random() sin semilla dentro de una composición. Por qué: el renderizado es paralelo y direccionable por fotograma — cada fotograma se calcula de forma independiente, por lo que cualquier entrada que no sea el fotograma produce un píxel diferente al volver a renderizar y rompe la garantía de "misma entrada, misma salida". Si necesitas aleatoriedad, usa random(seed) de Remotion.
Transiciones
Usa @remotion/transitions (disponible desde v4.0.53). <TransitionSeries> intercala .Sequence (un clip, con durationInFrames) y .Transition (un presentation + un timing). La duración de la transición se resta del total, por lo que las secuencias adyacentes se superponen durante la transición.
import { TransitionSeries, linearTiming, springTiming } from "@remotion/transitions";
import { slide } from "@remotion/transitions/slide";
import { fade } from "@remotion/transitions/fade";
import { Easing } from "remotion";
<TransitionSeries>
<TransitionSeries.Sequence durationInFrames={90}>{/* escena A */}</TransitionSeries.Sequence>
<TransitionSeries.Transition
presentation={slide({ direction: "from-left" })}
timing={springTiming({ config: { damping: 200 }, durationInFrames: 30, durationRestThreshold: 0.001 })}
/>
<TransitionSeries.Sequence durationInFrames={120}>{/* escena B */}</TransitionSeries.Sequence>
<TransitionSeries.Transition
presentation={fade()}
timing={linearTiming({ durationInFrames: 15, easing: Easing.inOut(Easing.ease) })}
/>
<TransitionSeries.Sequence durationInFrames={90}>{/* escena C */}</TransitionSeries.Sequence>
</TransitionSeries>
Cada presentación es una subimportación (@remotion/transitions/slide, /fade, /wipe, /flip, /clockWipe, /none).
| Presentación | Sensación / Cuándo |
|---|---|
slide | La escena empuja a la siguiente; impulso direccional entre beats |
fade | Fundido cruzado suave; cambio de escena tranquilo y neutro |
wipe | Un borde duro barre la pantalla; enérgico, "siguiente tema" |
flip | Giro 3D de tarjeta; divertido, para revelaciones |
clockWipe | Barrido radial; cuentas atrás, "paso del tiempo" |
none | Un corte brusco sin movimiento, pero aún como nodo TransitionSeries |
linearTiming para cortes predecibles y exactos en fotogramas; springTiming para movimiento orgánico. Por qué: linear es determinista en duración, por lo que puedes presupuestar fotogramas exactamente; spring sobrepasa y se asienta, lo que se lee como natural pero necesita durationRestThreshold para que el render sepa cuándo ha terminado.
Subtítulos animados quemados
El paquete nativo @remotion/captions se lanzó en v4.0.216 (la misma versión que eliminó el antiguo helper convertToCaptions()). El pipeline se ejecuta una vez en un servidor Node, luego la composición lee los subtítulos:
- Transcribe.
@remotion/install-whisper-cppdescarga Whisper.cpp y un modelo (medium.enes ~1.5 GB) y transcribe el audio en un servidor Node a JSON de Whisper. - Convierte.
toCaptions()de@remotion/install-whisper-cppconvierte ese JSON en unCaption[]con marcas de tiempo por token. (convertToCaptions()es el alias heredado — obsoleto desde v4.0.216; usatoCaptions().) - Segmenta en páginas.
@remotion/captionscreateTikTokStyleCaptions({ captions, combineTokensWithinMilliseconds })agrupa tokens en "páginas" que aparecen juntas.
El valor de combineTokensWithinMilliseconds es el dial del tamaño de página. Por qué: un valor bajo (~200ms) mantiene cada palabra en su propia página → animación de palabra por palabra al estilo TikTok; un valor alto (~1200ms) empaqueta una frase por página. ms bajo = energía palabra por palabra de TikTok; ms alto = frases legibles. Elige según el formato, no por defecto.
La instalación completa de Whisper.cpp, el servidor de transcripción y el componente renderizador de subtítulos con resaltado de tokens (con estilo de zona segura) están en references/captions-pipeline.md — léelo antes de construir la capa de subtítulos.
Eliminación automática de silencios
El paso de silencio se ejecuta en el audio/video fuente ANTES de que entre en Remotion, no dentro de una composición. Por qué: Remotion renderiza los fotogramas que le das; recortar el silencio es una edición ascendente del activo, y hacerlo primero significa que cada número de fotograma aguas abajo ya refleja la línea de tiempo ajustada.
Usa auto-editor (un motor de Python + ffmpeg) para un primer pase que corta el espacio muerto según el volumen del audio:
auto-editor input.mp4 --margin 0.2s --edit audio:threshold=4% -o tightened.mp4
--marginrellena cada región conservada para que los cortes no corten el habla.--edit audio:threshold=4%establece el umbral de volumen por debajo del cual una región es "silencio".--export premiereemite un EDL/XML en lugar de un archivo, para reimportarlo en un NLE.
La distribución pip está desactualizada/descontinuada — instálala mediante el binario oficial o pipx, no con pip install. Por qué: el paquete PyPI va por detrás y puede no coincidir con los flags documentados. Cuando auto-editor no está disponible, la alternativa de bajo nivel son los filtros silencedetect / silenceremove de ffmpeg. Ambos, con la matriz completa de flags, están en references/render-and-pipeline.md.
Superposiciones de b-roll
Apila la superposición encima del video principal colocando <OffthreadVideo> (o <Img>) dentro de un <AbsoluteFill>, controlado por un <Sequence from>:
import { AbsoluteFill, Sequence, OffthreadVideo, staticFile } from "remotion";
const fps = 30;
const broll = { start: 4.0, duration: 3.0 }; // segundos
<AbsoluteFill>
<OffthreadVideo src={staticFile("main.mp4")} /> {/* capa base */}
<Sequence from={Math.round(broll.start * fps)} durationInFrames={Math.round(broll.duration * fps)}>
<AbsoluteFill style={{ /* p. ej. recuadro para imagen en imagen */ }}>
<OffthreadVideo src={staticFile("broll.mp4")} /> {/* capa de superposición */}
</AbsoluteFill>
</Sequence>
</AbsoluteFill>
Convierte cada código de tiempo a fotogramas con Math.round(segundos * fps), una vez, en el borde. Por qué: una señal de b-roll a 4.0s es el fotograma 120 a 30fps pero el fotograma 240 a 60fps — mantén los segundos en tus datos y multiplícalos por fps de useVideoConfig() para que cambiar fps nunca desincronice las superposiciones. Usa <OffthreadVideo> (no el <video> del DOM ni <Video>) para una decodificación precisa de fotogramas durante el renderizado.
Renderizar
# prueba de región primero: 1-2 segundos, valida el pipeline de forma económica
npx remotion render MyVideo out/test.mp4 --frames=0-45
# luego el render completo
npx remotion render MyVideo out/video.mp4
Omite el id de composición para obtener un selector interactivo. Configura mediante @remotion/cli/config en remotion.config.ts, o pasa flags en la CLI (los flags ganan):
// remotion.config.ts
import { Config } from "@remotion/cli/config";
Config.setConcurrency(8);
Config.setCodec("h264");
| Códec | Uso | Flag |
|---|---|---|
h264 | Predeterminado para web/YouTube; amplia compatibilidad | (predeterminado) |
h265 | Archivos más pequeños, misma calidad; reproducción menos universal | --codec=h265 |
prores | Master de calidad de edición, archivos grandes, reimportación a un NLE | --codec=prores --prores-profile=4444 --pixel-format=yuva444p10le --image-format=png |
vp8 / gif | Vista previa con alfa web o en bucle | --codec=vp8 / --codec=gif |
Siempre renderiza una región de 1–2s (--frames=0-45) antes del render completo. Por qué: un render completo de una composición de minutos consume tiempo real y CPU; una prueba de región detecta una capa de subtítulos rota o un activo faltante en segundos. Para renders sin interfaz gráfica/CI, reglas de salida determinista y la matriz completa de códec/calidad, consulta references/render-and-pipeline.md.
Anti-patrones
| Malo | Por qué se rompe | Bueno |
|---|---|---|
| Hardcodear duraciones en segundos dentro de JSX | Remotion piensa en fotogramas; los segundos se desincronizan en cuanto fps cambia | Almacena segundos en datos, Math.round(segundos * fps) en el borde |
Date.now() / Math.random() sin semilla en una composición | Los fotogramas se renderizan en paralelo y al re-renderizar → píxeles no deterministas | Conduce todo con useCurrentFrame(); usa random(seed) |
Cambiar fps después de escribir duraciones | Cada conteo de fotogramas aguas abajo se desplaza silenciosamente | Fija fps + dimensiones en <Composition> desde el principio, déjalos |
| Redescargar el modelo Whisper cada ejecución | La descarga de ~1.5 GB de medium.en se repite y ralentiza el pipeline | Descarga una vez, almacena en caché la ruta del modelo, reutilízalo |
| Subir el modelo Whisper de 1.5 GB a git | Infla el repositorio; el modelo es un activo de construcción | .gitignore el directorio del modelo; obténlo en setup/CI |
| Renderizar el video completo para probar un cambio | Minutos de render desperdiciados para encontrar una capa rota | Prueba de región --frames=0-45, luego render completo |
| Escribir el texto del subtítulo o hook aquí | Eso es el guion, no la codificación | Deriva a ../video-shorts/SKILL.md; tú solo lo quemas |
<video> / <Video> simple para b-roll en un render | No es preciso en fotogramas; se rompe o salta en el render | <OffthreadVideo> para decodificación exacta de fotogramas |
| Ejecutar la eliminación de silencios dentro de la composición | Recortar silencio es una edición ascendente del activo | auto-editor en el archivo fuente antes de Remotion |
Verifica y referencias
bash scripts/verify.sh <project-dir>— comprueba que el proyecto Remotion esté bien formado y renderice. Con Node + ffmpeg presentes ejecutanpx remotion compositionspara confirmar que existe un id de composición, hace un render de región corta a un MP4 temporal y usaffprobepara confirmar un flujo de video con las dimensiones/fps esperados. Sin ellos, recurre a una comprobación estática: al menos un archivo.tsxde composición existe y el script de render referencia un id de composición real y una ruta de salida. Solo lectura por defecto; termina con 0 en un objetivo vacío/limpio.references/captions-pipeline.md— instalación completa de Whisper.cpp + servidor de transcripción,toCaptions, componente renderizador de subtítulos con resaltado de tokens y notas de estilo/zona segura.references/render-and-pipeline.md— comandos de silencio deauto-editor+ ffmpeg, matriz completa de flags de render, render sin interfaz gráfica/CI, tabla de códecs y verificación conffprobe.