motion-animate
El diseño decide si un cuadro es bueno. El movimiento decide si se ve caro. La misma composición animada con easing lineal y entradas simultáneas se lee como generada; animada con el vocabulario a continuación se lee como creada.
Recetas de motores: Apéndice A, Apéndice B.
Las cuatro leyes
- Nada es lineal. Cada propiedad se mueve con un ease. El movimiento lineal no existe en el mundo físico y el ojo lo sabe al instante.
- Nada entra a la vez. Los elementos llegan en un orden deliberado con 60–120ms entre ellos. La entrada simultánea es el mayor indicio de movimiento generado.
- La cámara nunca está completamente quieta. Un push o drift lento y continuo debajo de cada composición. Los cuadros estáticos se leen como diapositivas.
- Nada es metronómico. Varía las duraciones y el espaciado entre cortes. Los pulsos uniformes de 1s se sienten automatizados sin importar lo bueno que sea cada pulso.
Tabla de temporización
Valores a 30fps; escala para 60fps. Tiempos en ms.
| Elemento | Duración | Escalonamiento | Ease |
|---|---|---|---|
| Palabra en una línea de texto | 400–550 | 60–90 | out-expo / power3.out |
| Línea de texto (como unidad) | 500–650 | 120–180 | out-cubic / power2.out |
| Icono / elemento UI pequeño | 350–450 | 80–120 | out-back (overshoot ≤1.06) |
| Panel / tarjeta | 550–700 | 140–200 | out-quint / power4.out |
| Objeto principal (scale-in) | 700–900 | — | out-expo |
| Objeto principal (slide-in) | 650–850 | — | out-quint |
| Trazo de línea | 600–1000 | — | in-out-cubic |
| Push de cámara (por escena) | duración completa de la escena | — | out-sine, o lineal si es muy lento |
| Salida (cualquier elemento) | 250–350 | 40–60 | in-cubic |
Las salidas son siempre más rápidas que las entradas, aproximadamente la mitad. Una animación de salida simétrica se siente lenta.
Los movimientos principales
Texto — pop-blur-fade, palabra por palabra
El movimiento característico. Cada propiedad anima junto, por palabra, escalonado.
y: +18px → 0
blur: 12px → 0
opacity: 0 → 1
ease: out-expo, duración 480ms, escalonamiento 70ms
Opcionalmente añade scale: 0.96 → 1. No añadas rotación. No rebotes.
Para una línea larga, escala por palabra, no por carácter — el escalonamiento por carácter se lee como un truco de máquina de escribir y lleva demasiado tiempo. Reserva el escalonamiento por carácter para una sola palabra corta de acento.
Palabra de acento
Ejecuta el mismo movimiento pero retrasado 120–200ms después de sus vecinos y con una propiedad adicional: un cambio de color, un aumento de escala a 1.04, o una barra de resaltado que se revela detrás de ella. Debe aterrizar al último y aterrizar de manera diferente.
Iconos y UI
Pop-fade: scale 0.7 → 1, opacity 0 → 1, out-back con overshoot limitado a 1.06. Cualquier valor por encima de 1.1 se lee como un rebote barato.
Regla secuencial: el elemento ancla entra primero, luego sus dependientes. Una tarjeta entra, luego su icono, luego su etiqueta. Nunca al revés, nunca juntos.
Paneles / tarjetas / glass
y: +40 → 0, opacity 0 → 1, out-quint, 600ms, escalonado 160ms a través de una pila. Añade un destello de luz que cruce el panel 150ms después de que aterrice — el panel llega, luego atrapa la luz.
Objeto principal
Dos opciones, elige según el arquetipo:
- Scale-in:
scale 1.25 → 1.00conrotate 3° → 0°,out-expo, 800ms. Se siente como si se asentara en su lugar. - Slide-in: desde fuera del cuadro con una inclinación de 2° que se resuelve a 0°,
out-quint, 750ms. Se siente entregado.
La sombra proyectada y la textura recortada deben estar parented al héroe para que se muevan con él. Las sombras no parentadas deslizándose independientemente son un fallo grave.
Trazo de línea / dibujo
Anima la longitud del camino 0 → 100%, in-out-cubic, 600–1000ms. Ease de entrada y salida — un dibujo que comienza a máxima velocidad se ve mecánico. Úsalo para conectar una etiqueta a un sujeto, subrayar una palabra de acento, o trazar un gráfico.
Cámara
Debajo de cada composición, una de:
- Push in:
scale 1.00 → 1.08durante todo el beat,out-sine. - Push out:
scale 1.12 → 1.00, más rápido al inicio, asentándose. - Drift: traslación
xoyde 2–4% durante el beat.
Contrato anti-nerviosismo:
- Anima un elemento wrapper, nunca el elemento que posee el layout o el recorte.
- Usa solo
transform— nuncatop/left/width/height. - Escala la capa en movimiento ~6% más allá del cuadro para que los bordes nunca se revelen.
- Establece
will-change: transformy fuerza la composición GPU. - Mantén el recorrido total pequeño. Los movimientos grandes de cámara amplifican cada error de redondeo.
Transiciones entre beats
- Corte duro enmascarado por un impacto SFX — el predeterminado. Los crossfades entre cuadros diseñados ensucian ambos.
- Scale-through — un elemento escala para llenar el cuadro y la siguiente escena se revela dentro de él.
- Wipe por una forma — un círculo o panel escala más allá del borde del cuadro, llevando la siguiente escena.
No hagas crossfade entre dos composiciones diseñadas. No uses un preset de transición prefabricado.
Prohibido
- Easing lineal en algo visible.
- Overshoot de bounce >1.1 (excepción: un estilo intencionalmente juguetón de SaaS/producto, y entonces consistentemente).
- Todos los elementos entrando en el mismo cuadro.
- Duraciones de beat uniformes a través de una edición.
repeat: -1o cualquier bucle infinito — los renders se muestrean por cuadros y deben ser deterministas.Math.random(),Date.now(), o fetch de red dentro de una composición. La misma entrada debe producir el mismo cuadro cada vez.- Movimiento aplicado a un wrapper que el framework ya controla (ver Apéndice B §regla de clip).
Auto-verificación
Reproduce el render a 0.25× de velocidad. Pregunta:
- ¿Algo comienza y se detiene abruptamente? → falta ease.
- ¿Todo aterriza junto? → falta escalonamiento.
- ¿El cuadro se queda completamente quieto? → falta cámara.
- ¿Los beats consecutivos se sienten como un golpe de tambor? → duraciones demasiado uniformes.
- ¿Los bordes de una capa en movimiento se revelan? → no se ha escalado de más.
Apéndice A — Recetas de Remotion
Basado en cuadros, determinista por construcción. Toda la temporización se deriva de useCurrentFrame().
Helper: tiempo en ms, no cuadros
Autorizar en cuadros hardcodea tu fps. Convierte.
import {useVideoConfig, useCurrentFrame, interpolate, Easing} from 'remotion';
const useMs = () => {
const {fps} = useVideoConfig();
return (ms: number) => (ms / 1000) * fps;
};
Mapa de easing
Los nombres en la tabla de temporización, en términos de Remotion:
Easing.out(Easing.exp) // out-expo
Easing.out(Easing.cubic) // out-cubic
Easing.out(Easing.quad) // out-quad
Easing.out(Easing.poly(4)) // out-quint-ish
Easing.inOut(Easing.cubic) // in-out-cubic
Easing.out(Easing.sin) // out-sine
Easing.in(Easing.cubic) // in-cubic (salidas)
Easing.bezier(0.16, 1, 0.3, 1) // el caballo de batalla — expo-ish out
Para overshoot, prefiere un spring sobre Easing.back — es más fácil mantenerlo sutil.
import {spring} from 'remotion';
const s = spring({frame, fps, config: {damping: 200, stiffness: 120, mass: 0.6}});
// damping 200 = sin overshoot visible. Baja a ~14 para un pequeño asentamiento.
Texto — pop-blur-fade, palabra por palabra
const Words: React.FC<{text: string; delay?: number}> = ({text, delay = 0}) => {
const frame = useCurrentFrame();
const ms = useMs();
const STAGGER = ms(70);
const DUR = ms(480);
return (
<span style={{display: 'inline-flex', flexWrap: 'wrap', gap: '0.28em'}}>
{text.split(' ').map((word, i) => {
const local = frame - ms(delay) - i * STAGGER;
const p = interpolate(local, [0, DUR], [0, 1], {
extrapolateLeft: 'clamp',
extrapolateRight: 'clamp',
easing: Easing.bezier(0.16, 1, 0.3, 1),
});
return (
<span
key={i}
style={{
display: 'inline-block',
opacity: p,
filter: `blur(${(1 - p) * 12}px)`,
transform: `translateY(${(1 - p) * 18}px)`,
willChange: 'transform, filter, opacity',
}}
>
{word}
</span>
);
})}
</span>
);
};
La palabra de acento es el mismo componente con delay configurado 120–200ms después más su propio color y un scale(1.04).
Cámara — push siempre activo
Envuelve toda la escena. Escala de más para que los bordes nunca se revelen.
const Camera: React.FC<{children: React.ReactNode; durationInFrames: number}> = ({
children, durationInFrames,
}) => {
const frame = useCurrentFrame();
const scale = interpolate(frame, [0, durationInFrames], [1.0, 1.08], {
extrapolateRight: 'clamp',
easing: Easing.out(Easing.sin),
});
return (
<AbsoluteFill style={{transform: `scale(${scale})`, willChange: 'transform'}}>
{children}
</AbsoluteFill>
);
};
Coloca la cámara encima de la capa de suelo y debajo de cualquier elemento que deba permanecer fijo al borde del cuadro.
Pila de tarjetas escalonadas
const cards = ['One', 'Two', 'Three'];
const ms = useMs();
{cards.map((label, i) => {
const local = frame - i * ms(160);
const p = interpolate(local, [0, ms(600)], [0, 1], {
extrapolateLeft: 'clamp', extrapolateRight: 'clamp',
easing: Easing.out(Easing.poly(4)),
});
return (
<div key={i} style={{
opacity: p,
transform: `translateY(${(1 - p) * 40}px)`,
}}>{label}</div>
);
})}
Salida — la mitad de la entrada
const exitStart = durationInFrames - ms(300);
const out = interpolate(frame, [exitStart, durationInFrames], [1, 0], {
extrapolateLeft: 'clamp', extrapolateRight: 'clamp',
easing: Easing.in(Easing.cubic),
});
Estructura
Usa <Sequence from={...} durationInFrames={...}> por beat, impulsado directamente por la tabla motion-plan. Un Sequence por fila. Las duraciones de los beats provienen del plan, no de números redondos.
<Series>
<Series.Sequence durationInFrames={ms(5200)}><BeatTwo /></Series.Sequence>
<Series.Sequence durationInFrames={ms(2100)}><BeatThree /></Series.Sequence>
</Series>
Determinismo
- Nunca
Math.random()— si necesitas dispersión, semilla a partir del índice del elemento. - Nunca
Date.now()onew Date(). - Nunca fetch dentro de un componente. Precarga con
staticFile()/delayRender(). <Video>/<Audio>deben ser<OffthreadVideo>cuando sea posible para la corrección del render.
Gotchas
filter: blur()en muchos elementos simultáneos es caro — limita los nodos borrosos concurrentes, o pre-difumina en el asset.- Carga de fuentes: usa
@remotion/google-fontsodelayRenderalrededor de unFontFace.load()local, o los primeros cuadros se renderizarán con una fuente de respaldo. interpolatelanza un error si el rango de entrada no es monótonamente creciente — protege los rangos calculados.- Siempre pasa
extrapolateLeft/extrapolateRight: 'clamp'a menos que específicamente quieras que el valor se ejecute más allá del rango.
Apéndice B — Recetas de HyperFrames / GSAP
HyperFrames compone HTML + GSAP y renderiza muestreando cuadros de un navegador headless. El determinismo es obligatorio.
Ejecuta npx hyperframes docs para la API actual. Este archivo es el estándar de movimiento sobre él — consulta el skill hyperframes para el pipeline (init → preview → lint → render).
La regla de clip (rompe los renders si se viola)
Cada elemento temporizado necesita data-start, data-duration, data-track-index y class="clip". El framework posee la visibilidad y transform en .clip.
Nunca apliques GSAP al elemento .clip. Anima un wrapper hijo.
<div class="clip" data-start="4.2" data-duration="5.2" data-track-index="2">
<div class="cam"> <!-- los movimientos de cámara van aquí -->
<div class="inner"> <!-- el movimiento del elemento va aquí -->
<h1 class="headline">…</h1>
</div>
</div>
</div>
Registro de timeline
const tl = gsap.timeline({paused: true});
window.__timelines['main'] = tl; // el id debe coincidir con data-composition-id
Pausado, siempre. El renderizador lo busca.
Mapa de easing
| Nombre de tabla | GSAP |
|---|---|
| out-expo | expo.out |
| out-cubic | power2.out |
| out-quint | power4.out |
| out-back (limitado) | back.out(1.2) |
| in-out-cubic | power2.inOut |
| out-sine | sine.out |
| in-cubic (salidas) | power2.in |
Texto — pop-blur-fade, palabra por palabra
Divide en spans de palabra en tiempo de autoría (no confíes en un divisor en tiempo de ejecución — podría competir con el primer cuadro muestreado).
<h1 class="headline">
<span class="w">What</span> <span class="w">looks</span>
<span class="w accent">like</span> <span class="w">discipline</span>
</h1>
tl.from('.headline .w', {
y: 18,
opacity: 0,
filter: 'blur(12px)',
duration: 0.48,
ease: 'expo.out',
stagger: 0.07,
}, 0);
// la palabra de acento aterriza al último y de manera diferente
tl.from('.headline .accent', {
scale: 0.96,
color: 'var(--surface)',
duration: 0.5,
ease: 'expo.out',
}, 0.18);
Cámara
Anima .cam, nunca .clip.
tl.fromTo('.cam',
{scale: 1.0},
{scale: 1.08, duration: 5.2, ease: 'sine.out', force3D: true},
0);
.cam { will-change: transform; transform: translateZ(0); }
Escala la capa en movimiento ~6% más allá del cuadro para que los bordes nunca se revelen durante un push-out o drift.
Pila de tarjetas escalonadas
tl.from('.card', {
y: 40, opacity: 0,
duration: 0.6, ease: 'power4.out', stagger: 0.16,
}, 1.2);
// el destello de luz aterriza 150ms después del panel
tl.fromTo('.card .sweep', {xPercent: -140}, {
xPercent: 140, duration: 0.7, ease: 'power2.inOut', stagger: 0.16,
}, 1.35);
Dibujo de trazo
tl.fromTo('.connector', {drawSVG: '0%'}, {drawSVG: '100%', duration: 0.8, ease: 'power2.inOut'});
// ¿No tienes DrawSVGPlugin? usa stroke-dasharray/offset:
tl.fromTo('.connector', {strokeDashoffset: 1000}, {strokeDashoffset: 0, duration: 0.8, ease: 'power2.inOut'});
Reglas estrictas
- Solo determinista — nada de
Math.random(), nada deDate.now(), nada de fetch, nada derepeat: -1. - 9:16 = 1080×1920. Establece
#root { container-type: size; }y dimensiona todo encqw/cqh(1cqw = 10.8px), nuncavw/vh. - Los clips adyacentes del mismo track no deben tocarse. Las matemáticas de punto flotante hacen que
3.2 + 0.35 = 3.5500000000000003, lo que se superpone con un clip que comienza en3.55y generaoverlapping_clips_same_track. Deja un espacio, o usa duraciones como0.34. - Audio: los videos están
muted; usa una sola pista de<audio>maestra premezclada (VO + SFX mezclados con ffmpegadelay+amix) en undata-track-indexalto dedicado. Múltiples pistas de audio causan deriva.