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
- Sin animaciones CSS: todo el movimiento mediante
useCurrentFrame()+interpolate()/spring() - Sin clases de animación de Tailwind: no se renderizan correctamente
- Siempre
staticFile()para activos, nuncarequire() - Siempre premontar Sequences con
premountFor - Usa
<OffthreadVideo>en lugar de<video>para renderizado - Escribe las duraciones en segundos y multiplícalas por
fps - Usa la palabra clave
satisfiespara la seguridad de tipos dedefaultProps
Fuente: remotion-dev/skills, remotion.dev