Cuando esta habilidad se active, comienza siempre tu primera respuesta con el emoji 🧢.
Diseño de Movimiento
Una base de conocimiento enfocada y opinada para implementar animaciones y movimiento en aplicaciones web. Cubre transiciones CSS y keyframes, Framer Motion, GSAP, animaciones impulsadas por scroll y microinteracciones, con código concreto para cada patrón. Cada recomendación prioriza el rendimiento a 60 fps, la accesibilidad y el movimiento con propósito sobre la decoración.
La diferencia entre una animación buena y una mala es la moderación. La mayoría de las interfaces necesitan menos animaciones, no más. Cuando existe movimiento, debe ser rápido, fluido y respetar las preferencias del usuario.
Cuándo usar esta habilidad
Activa esta habilidad cuando el usuario:
- Pida agregar animaciones o transiciones a cualquier elemento de la interfaz
- Necesite animaciones de entrada/salida para componentes que se montan o desmontan
- Quiera implementar transiciones de página o animaciones de cambio de ruta
- Pregunte sobre Framer Motion, GSAP o APIs de animación CSS
- Necesite animaciones impulsadas por scroll o efectos de paralaje
- Quiera estados de carga con pantallas esqueleto o spinners
- Pregunte sobre física de resortes, curvas de easing o temporización de animaciones
- Necesite una línea de tiempo de GSAP para secuencias complejas de múltiples pasos
- Pregunte sobre microinteracciones (hover, presionar, alternar, estados de checkbox)
NO actives esta habilidad para:
- Diseño o estilo CSS puro sin movimiento (usa ultimate-ui en su lugar)
- Renderizado con Canvas o WebGL (usa un recurso específico para gráficos)
Principios clave
-
El movimiento debe tener propósito - Cada animación debe comunicar algo: un cambio de estado, una relación espacial, retroalimentación o jerarquía. El movimiento solo decorativo es ruido. Pregúntate "¿qué le dice esta animación al usuario?" antes de agregarla.
-
Respeta
prefers-reduced-motion- Siempre envuelve las animaciones en una verificación deprefers-reduced-motion. Los usuarios con trastornos vestibulares o epilepsia pueden verse perjudicados por el movimiento. Esto es un requisito de WCAG 2.1 AA, no una sugerencia. -
Anima solo transformaciones y opacidad -
transformyopacityson las únicas propiedades que el navegador puede animar en el hilo del compositor sin provocar un recálculo de diseño o pintura. Animarwidth,height,top,left,marginopaddingcausa tirones. Usatransform: scale/translateen su lugar. -
Resorte > easing lineal - El movimiento natural usa easing basado en física, no velocidad uniforme. Las animaciones con resorte se sienten vivas.
linearse siente robótico. Usaease-outpara entradas,ease-inpara salidas, resorte/rebote para elementos interactivos que responden a la entrada del usuario. -
60 fps o nada - Si una animación pierde fotogramas, elimínala. Una animación entrecortada es peor que ninguna animación. Prueba en una CPU limitada (4x de ralentización en Chrome DevTools). Si baja de 60 fps, simplifícala o elimínala.
Conceptos principales
Propiedades de animación
- Duración: 100-150 ms para micro (hover en botón), 200-300 ms para interfaz (modal, desplegable), 300-500 ms para diseño (transiciones de página). Nunca más de 500 ms para retroalimentación interactiva.
- Easing:
ease-out(inicio rápido, aterrizaje suave) para elementos que entran en la pantalla.ease-in(inicio lento, final rápido) para elementos que salen.ease-in-outpara elementos que se mueven a través de la pantalla. Resorte para elementos interactivos o divertidos. - Retardo: Úsalo con moderación. Escalonar hijos con un máximo de 50-75 ms. La secuencia total de escalonamiento no debe superar los 400 ms o los usuarios sentirán que están esperando.
Animaciones CSS vs JS - guía de decisión
- Usa transiciones CSS para cambios de estado simples activados por clase o pseudo-clase (hover, focus, active). Sin sobrecarga de JS.
- Usa keyframes CSS para animaciones en bucle (spinners, pulsos) y secuencias coreografiadas no vinculadas a la interacción.
- Usa Framer Motion (React) para animaciones de entrada/salida vinculadas al montaje/desmontaje de componentes, movimiento guiado por gestos o animaciones de diseño.
- Usa GSAP para líneas de tiempo complejas de múltiples pasos, animaciones de rutas SVG, secuencias activadas por scroll, o cuando necesites control programático preciso.
Física de resortes
Un resorte tiene dos parámetros clave: stiffness (qué tan rápido acelera) y damping (qué tan rápido se estabiliza). Alta rigidez + alto amortiguamiento = rápido. Baja rigidez + bajo amortiguamiento = rebotante y lento. Para interfaz: rigidez 300-500, amortiguamiento 25-35 da una sensación natural sin rebote excesivo.
Rendimiento - hilo del compositor vs hilo principal
El navegador renderiza en dos etapas: hilo principal (diseño, pintura) y hilo del compositor (transformación, opacidad). Las animaciones en el hilo del compositor se ejecutan a 60 fps incluso cuando el hilo principal está ocupado. Usa siempre transform y opacity. Agrega will-change: transform solo para elementos que sabes que se animarán; el uso excesivo de will-change desperdicia memoria de la GPU.
Tareas comunes
Transiciones CSS y keyframes
/* Tokens de easing reutilizables */
:root {
--ease-out: cubic-bezier(0, 0, 0.2, 1);
--ease-in: cubic-bezier(0.4, 0, 1, 1);
--ease-in-out: cubic-bezier(0.4, 0, 0.2, 1);
--ease-spring: cubic-bezier(0.34, 1.56, 0.64, 1);
--duration-fast: 100ms;
--duration-normal: 200ms;
--duration-slow: 300ms;
}
/* Fundido hacia arriba - contenido que aparece */
@keyframes fade-in-up {
from { opacity: 0; transform: translateY(12px); }
to { opacity: 1; transform: translateY(0); }
}
/* Escalado hacia adentro - modales, popovers */
@keyframes scale-in {
from { opacity: 0; transform: scale(0.95); }
to { opacity: 1; transform: scale(1); }
}
.modal {
animation: scale-in var(--duration-normal) var(--ease-out);
}
/* Hover en tarjeta - efecto de elevación */
.card {
transition: transform var(--duration-fast) var(--ease-out),
box-shadow var(--duration-fast) var(--ease-out);
}
.card:hover {
transform: translateY(-2px);
box-shadow: 0 8px 24px rgba(0, 0, 0, 0.12);
}
Animaciones de entrada/salida con Framer Motion
import { motion, AnimatePresence } from 'framer-motion';
// Variantes de animación reutilizables
const fadeUp = {
initial: { opacity: 0, y: 12 },
animate: { opacity: 1, y: 0 },
exit: { opacity: 0, y: -8 },
transition: { duration: 0.2, ease: [0, 0, 0.2, 1] },
};
const scaleIn = {
initial: { opacity: 0, scale: 0.95 },
animate: { opacity: 1, scale: 1 },
exit: { opacity: 0, scale: 0.95 },
transition: { duration: 0.15, ease: [0, 0, 0.2, 1] },
};
// Componente con entrada/salida
function Notification({ show, message }: { show: boolean; message: string }) {
return (
<AnimatePresence>
{show && (
<motion.div
key="notification"
{...fadeUp}
className="toast"
>
{message}
</motion.div>
)}
</AnimatePresence>
);
}
// Lista escalonada
function AnimatedList({ items }: { items: string[] }) {
return (
<motion.ul
initial="hidden"
animate="visible"
variants={{
hidden: {},
visible: { transition: { staggerChildren: 0.06 } },
}}
>
{items.map((item) => (
<motion.li
key={item}
variants={{
hidden: { opacity: 0, x: -12 },
visible: { opacity: 1, x: 0, transition: { duration: 0.2 } },
}}
>
{item}
</motion.li>
))}
</motion.ul>
);
}
Animaciones impulsadas por scroll con CSS
/* Animaciones nativas impulsadas por scroll CSS (Chrome 115+) */
@keyframes reveal {
from { opacity: 0; transform: translateY(20px); }
to { opacity: 1; transform: translateY(0); }
}
.scroll-reveal {
animation: reveal linear both;
animation-timeline: view();
animation-range: entry 0% entry 25%;
}
/* Barra de progreso vinculada al scroll de la página */
.scroll-progress {
position: fixed;
top: 0;
left: 0;
height: 3px;
background: var(--color-primary-500);
transform-origin: left;
animation: scaleX linear;
animation-timeline: scroll(root);
}
@keyframes scaleX {
from { transform: scaleX(0); }
to { transform: scaleX(1); }
}
/* Fallback de IntersectionObserver para una compatibilidad más amplia con navegadores */
// IntersectionObserver - funciona en todos los navegadores
const observer = new IntersectionObserver(
(entries) => {
entries.forEach((entry) => {
if (entry.isIntersecting) {
entry.target.classList.add('in-view');
observer.unobserve(entry.target); // animar una vez
}
});
},
{ threshold: 0.15 }
);
document.querySelectorAll('[data-reveal]').forEach((el) => observer.observe(el));
[data-reveal] {
opacity: 0;
transform: translateY(16px);
transition: opacity 0.3s var(--ease-out), transform 0.3s var(--ease-out);
}
[data-reveal].in-view {
opacity: 1;
transform: translateY(0);
}
Transiciones de página con AnimatePresence
import { AnimatePresence, motion } from 'framer-motion';
import { usePathname } from 'next/navigation';
const pageVariants = {
initial: { opacity: 0, y: 8 },
animate: { opacity: 1, y: 0, transition: { duration: 0.25, ease: [0, 0, 0.2, 1] } },
exit: { opacity: 0, y: -8, transition: { duration: 0.15, ease: [0.4, 0, 1, 1] } },
};
export function PageTransition({ children }: { children: React.ReactNode }) {
const pathname = usePathname();
return (
<AnimatePresence mode="wait">
<motion.div key={pathname} {...pageVariants}>
{children}
</motion.div>
</AnimatePresence>
);
}
Usa
mode="wait"para que la página que sale se anime completamente antes de que entre la nueva.mode="sync"(predeterminado) puede causar superposición. Mantén las transiciones de página por debajo de 250 ms; los usuarios están esperando ver contenido nuevo.
Microinteracciones - hover, presionar, alternar
import { motion } from 'framer-motion';
// Botón con retroalimentación de presión
function Button({ children, onClick }: React.ComponentProps<'button'>) {
return (
<motion.button
whileHover={{ scale: 1.02 }}
whileTap={{ scale: 0.97 }}
transition={{ type: 'spring', stiffness: 500, damping: 30 }}
onClick={onClick}
>
{children}
</motion.button>
);
}
// Interruptor alternativo animado (CSS)
.toggle {
position: relative;
width: 44px;
height: 24px;
background: var(--color-gray-300);
border-radius: 12px;
transition: background 150ms var(--ease-in-out);
cursor: pointer;
}
.toggle[aria-checked="true"] {
background: var(--color-primary-500);
}
.toggle::after {
content: '';
position: absolute;
top: 2px;
left: 2px;
width: 20px;
height: 20px;
border-radius: 50%;
background: white;
box-shadow: 0 1px 3px rgba(0, 0, 0, 0.2);
transition: transform 200ms var(--ease-spring);
}
.toggle[aria-checked="true"]::after {
transform: translateX(20px);
}
/* Acordeón con truco de grid-template-rows */
.accordion-content {
display: grid;
grid-template-rows: 0fr;
transition: grid-template-rows 200ms var(--ease-out);
}
.accordion-content[data-open="true"] {
grid-template-rows: 1fr;
}
.accordion-content > div {
overflow: hidden;
}
Línea de tiempo de GSAP para secuencias complejas
import gsap from 'gsap';
import { ScrollTrigger } from 'gsap/ScrollTrigger';
gsap.registerPlugin(ScrollTrigger);
// Secuencia de entrada del héroe
function animateHero() {
const tl = gsap.timeline({ defaults: { ease: 'power2.out' } });
tl.from('.hero-badge', { opacity: 0, y: 16, duration: 0.4 })
.from('.hero-headline', { opacity: 0, y: 20, duration: 0.5 }, '-=0.2')
.from('.hero-subtext', { opacity: 0, y: 16, duration: 0.4 }, '-=0.3')
.from('.hero-cta', { opacity: 0, scale: 0.95, duration: 0.35 }, '-=0.2');
return tl;
}
// Tarjetas de características activadas por scroll
gsap.utils.toArray<HTMLElement>('.feature-card').forEach((card, i) => {
gsap.from(card, {
opacity: 0,
y: 32,
duration: 0.5,
delay: i * 0.08,
ease: 'power2.out',
scrollTrigger: {
trigger: card,
start: 'top 85%',
once: true,
},
});
});
El desplazamiento
'-=0.2'en las líneas de tiempo de GSAP crea superposición entre los pasos para una secuencia fluida y cohesiva. Sin él, cada paso se siente desconectado. Superpón entre el 20 y el 40 % de la duración del paso anterior.
Respeta prefers-reduced-motion
/* CSS - regla general como red de seguridad */
@media (prefers-reduced-motion: reduce) {
*,
*::before,
*::after {
animation-duration: 0.01ms !important;
animation-iteration-count: 1 !important;
transition-duration: 0.01ms !important;
scroll-behavior: auto !important;
}
}
// Framer Motion - hook useReducedMotion
import { useReducedMotion } from 'framer-motion';
function AnimatedCard({ children }: { children: React.ReactNode }) {
const prefersReduced = useReducedMotion();
return (
<motion.div
initial={prefersReduced ? false : { opacity: 0, y: 12 }}
animate={{ opacity: 1, y: 0 }}
transition={prefersReduced ? { duration: 0 } : { duration: 0.2 }}
>
{children}
</motion.div>
);
}
// Vanilla JS - verificar preferencia antes de ejecutar GSAP
const prefersReduced = window.matchMedia('(prefers-reduced-motion: reduce)').matches;
if (!prefersReduced) {
animateHero();
}
Antipatrones
| Error | Por qué está mal | Qué hacer en su lugar |
|---|---|---|
Animar width, height, top o left | Provoca un recálculo de diseño en cada fotograma, causa tirones | Usa transform: scale() o transform: translate() en su lugar |
transition: all | Captura propiedades inesperadas, difícil de predecir, riesgo de rendimiento | Enumera propiedades específicas: transition: transform 200ms, opacity 200ms |
| Duración superior a 500 ms para retroalimentación interactiva | Los usuarios sienten que la interfaz está lenta o rota | Mantén botón/hover/alternar por debajo de 200 ms, modal por debajo de 300 ms |
| Usar GSAP para efectos de hover simples | Sobrecarga masiva para algo que CSS maneja de forma nativa | Usa transition CSS para cambios de estado, GSAP solo para líneas de tiempo |
| Retardo de escalonamiento total superior a 500 ms | Los usuarios esperan el contenido en lugar de verlo aparecer | Limita el retardo por elemento a 75 ms, el escalonamiento total a 400 ms |
will-change: transform en todo | Cada will-change crea una capa de GPU; el uso excesivo desperdicia VRAM | Agrégala solo a elementos que sabes que se animarán, elimínala después de la animación |
Referencias
Para obtener orientación detallada sobre temas específicos de movimiento, lee el archivo correspondiente de la carpeta referencias/: