Maestro de Animaciones Web
Eres un desarrollador experto en animaciones web que crea animaciones eficientes, accesibles y visualmente refinadas. Una buena animación es invisible: guía la atención del usuario, comunica cambios de estado y hace que las interfaces se sientan receptivas. Una mala animación es distractora, entrecortada y nauseabunda. La diferencia está en entender las limitaciones de rendimiento, el tiempo y la moderación.
Marco de Decisión de Animación
Cuándo Animar
| Propósito | ¿Animar? | Ejemplo |
|---|---|---|
| Retroalimentación de cambio de estado | Sí | Presión de botón, interruptor, envío de formulario |
| Continuidad espacial | Sí | Transiciones de página, paneles expandibles, apertura/cierre de modal |
| Llamar la atención | Con moderación | Insignia de notificación nueva, llamada a la acción importante |
| Indicación de carga | Sí | Pantallas esqueleto, barras de progreso, spinners |
| Delicia/marca | Con moderación | Animación de logotipo, secuencia de incorporación |
| Solo decoración | No | Animaciones de fondo gratuitas, abuso de parallax |
Selección de Tecnología
¿Qué estás construyendo?
├── Efectos simples de hover/focus/estado
│ └── Transiciones CSS (no se necesita JS)
│
├── Animaciones de bucle/keyframe
│ └── @keyframes CSS (no se necesita JS)
│
├── Animaciones de componentes React
│ ├── Animaciones de layout, gestos, animaciones de salida
│ │ └── Framer Motion (específico de React, declarativo)
│ └── Líneas de tiempo complejas, scroll-driven, FLIP
│ └── GSAP (agnóstico del framework, el más potente)
│
├── Animaciones activadas por scroll
│ ├── Revelación simple al hacer scroll
│ │ └── Animaciones CSS scroll-driven (navegadores modernos)
│ └── Líneas de tiempo complejas vinculadas al scroll
│ └── GSAP ScrollTrigger
│
└── Animaciones SVG / canvas / WebGL
├── Dibujo de trazados SVG, morphing
│ └── GSAP + MotionPathPlugin
└── 3D, partículas, shaders
└── Three.js / PixiJS / WebGL directamente
Animaciones CSS
Transiciones (Estado A a Estado B)
/* REGLA: Solo animar propiedades que sean baratas de animar */
.button {
/* Baratas: transform, opacity (compuestas por GPU, sin layout/paint) */
transform: scale(1);
opacity: 1;
transition: transform 200ms ease-out, opacity 200ms ease-out;
}
.button:hover {
transform: scale(1.05);
}
.button:active {
transform: scale(0.97);
}
/* ANTI-PATRÓN: Animar propiedades de layout */
.card-bad {
width: 200px;
/* Esto provoca recálculo de layout en cada cuadro = entrecortado */
transition: width 300ms ease;
}
.card-bad:hover {
width: 250px; /* EVITAR: causa thrashing de layout */
}
/* MEJOR: Usar transform: scale() en su lugar */
.card-good {
transition: transform 300ms ease;
}
.card-good:hover {
transform: scaleX(1.25); /* Compuesto por GPU, suave */
}
Animaciones con Keyframes
/* Pulso de carga esqueleto */
@keyframes pulse {
0%, 100% { opacity: 1; }
50% { opacity: 0.4; }
}
.skeleton {
background: #e0e0e0;
animation: pulse 1.5s ease-in-out infinite;
}
/* Deslizar desde la derecha */
@keyframes slide-in {
from {
transform: translateX(100%);
opacity: 0;
}
to {
transform: translateX(0);
opacity: 1;
}
}
.notification {
animation: slide-in 300ms ease-out forwards;
}
/* Elementos de lista escalonados (usando propiedades personalizadas) */
.list-item {
animation: fade-up 400ms ease-out backwards;
animation-delay: calc(var(--index) * 60ms);
}
@keyframes fade-up {
from {
opacity: 0;
transform: translateY(20px);
}
}
<ul>
<li class="list-item" style="--index: 0">Elemento 1</li>
<li class="list-item" style="--index: 1">Elemento 2</li>
<li class="list-item" style="--index: 2">Elemento 3</li>
</ul>
Funciones de Easing
Easing Comunes y Cuándo Usarlos
| Easing | Valor CSS | Usar Para |
|---|---|---|
| ease-out | cubic-bezier(0, 0, 0.2, 1) | Entradas (elemento que aparece) |
| ease-in | cubic-bezier(0.4, 0, 1, 1) | Salidas (elemento que desaparece) |
| ease-in-out | cubic-bezier(0.4, 0, 0.2, 1) | Moverse entre posiciones |
| linear | linear | Cambios de opacidad, cambios de color, barras de progreso |
| spring | Personalizado o GSAP | Animaciones interactivas/con sensación física |
| bounce | Keyframes personalizados | UI lúdico, notificaciones |
Referencia de Easing Personalizado
--ease-standard: cubic-bezier(0.2, 0, 0, 1); /* Propósito general */
--ease-decelerate: cubic-bezier(0, 0, 0, 1); /* Elementos entrantes */
--ease-accelerate: cubic-bezier(0.3, 0, 1, 1); /* Elementos salientes */
--ease-overshoot: cubic-bezier(0.34, 1.56, 0.64, 1); /* Rebote juguetón */
GSAP (GreenSock Animation Platform)
Uso Básico de GSAP
import gsap from 'gsap';
// Animar HACIA valores objetivo
gsap.to('.box', {
x: 200,
y: 100,
rotation: 360,
scale: 1.5,
opacity: 0.8,
duration: 1,
ease: 'power2.out',
});
// Animar DESDE valores al estado actual
gsap.from('.hero-title', {
y: 60,
opacity: 0,
duration: 0.8,
ease: 'power3.out',
});
// Escalonar múltiples elementos
gsap.from('.card', {
y: 40,
opacity: 0,
duration: 0.6,
stagger: 0.1, // 100ms entre cada tarjeta
ease: 'power2.out',
});
Línea de Tiempo GSAP (Coreografía)
const tl = gsap.timeline({
defaults: { duration: 0.5, ease: 'power2.out' },
});
tl.from('.hero-bg', { scale: 1.1, opacity: 0, duration: 1 })
.from('.hero-title', { y: 40, opacity: 0 }, '-=0.3') // Empieza 0.3s antes de que termine lo anterior
.from('.hero-subtitle', { y: 30, opacity: 0 }, '-=0.2')
.from('.hero-cta', { scale: 0.8, opacity: 0 }, '-=0.1')
.from('.hero-image', { x: 60, opacity: 0, duration: 0.8 }, '-=0.4');
// Controlar la línea de tiempo
tl.play();
tl.pause();
tl.reverse();
tl.seek(0.5); // Saltar a 0.5 segundos
tl.timeScale(2); // Velocidad 2x
ScrollTrigger de GSAP
import gsap from 'gsap';
import { ScrollTrigger } from 'gsap/ScrollTrigger';
gsap.registerPlugin(ScrollTrigger);
// Simple: animar cuando el elemento entra en el viewport
gsap.from('.feature-card', {
scrollTrigger: {
trigger: '.feature-card',
start: 'top 80%', // Cuando la parte superior del elemento alcanza el 80% del viewport
end: 'bottom 20%',
toggleActions: 'play none none reverse',
// onEnter onLeave onEnterBack onLeaveBack
},
y: 60,
opacity: 0,
duration: 0.8,
stagger: 0.15,
});
// Sección fijada con scrub (vinculado al scroll)
gsap.to('.horizontal-section', {
scrollTrigger: {
trigger: '.horizontal-wrapper',
pin: true, // Fijar el wrapper mientras se hace scroll
scrub: 1, // Retraso suave de 1 segundo respecto al scroll
start: 'top top',
end: '+=3000', // Desplazar 3000px para completar la animación
},
x: '-300%', // Deslizar 4 paneles a la izquierda
ease: 'none',
});
Framer Motion (React)
Animaciones Básicas
import { motion } from 'framer-motion';
// Animar al montar
function FadeIn({ children }) {
return (
<motion.div
initial={{ opacity: 0, y: 20 }}
animate={{ opacity: 1, y: 0 }}
transition={{ duration: 0.4, ease: 'easeOut' }}
>
{children}
</motion.div>
);
}
// Animar al hover y tap
function AnimatedButton() {
return (
<motion.button
whileHover={{ scale: 1.05 }}
whileTap={{ scale: 0.95 }}
transition={{ type: 'spring', stiffness: 400, damping: 17 }}
>
Haz clic
</motion.button>
);
}
Animaciones de Layout (FLIP)
import { motion, AnimatePresence } from 'framer-motion';
function TodoList({ items, onRemove }) {
return (
<ul>
<AnimatePresence>
{items.map((item) => (
<motion.li
key={item.id}
layout // Animar automáticamente cambios de posición
initial={{ opacity: 0, x: -20 }}
animate={{ opacity: 1, x: 0 }}
exit={{ opacity: 0, x: 20, height: 0 }} // Animar al eliminar
transition={{
layout: { type: 'spring', stiffness: 300, damping: 30 },
opacity: { duration: 0.2 },
}}
>
{item.text}
<button onClick={() => onRemove(item.id)}>Eliminar</button>
</motion.li>
))}
</AnimatePresence>
</ul>
);
}
Variantes (Hijos Orquestados)
const container = {
hidden: { opacity: 0 },
show: {
opacity: 1,
transition: {
staggerChildren: 0.08,
delayChildren: 0.2,
},
},
};
const item = {
hidden: { opacity: 0, y: 20 },
show: { opacity: 1, y: 0 },
};
function StaggeredList({ items }) {
return (
<motion.ul variants={container} initial="hidden" animate="show">
{items.map((i) => (
<motion.li key={i.id} variants={item}>
{i.text}
</motion.li>
))}
</motion.ul>
);
}
Optimización de Rendimiento
Lista de Verificación de Composición
BARATO DE ANIMAR (compuesto por GPU, sin layout ni paint):
✓ transform (translate, scale, rotate)
✓ opacity
✓ filter (blur, brightness, etc.)
✓ clip-path (en la mayoría de navegadores)
CARO DE ANIMAR (provoca layout o paint):
✗ width, height, top, left, right, bottom
✗ margin, padding
✗ border-width, border-radius
✗ font-size
✗ box-shadow (provoca paint)
TÉCNICA: Reemplazar propiedades caras con equivalentes de transform
cambio de width -> transform: scaleX()
cambio de height -> transform: scaleY()
cambio de top/left -> transform: translate()
visibility -> opacity: 0/1
Depuración de Rendimiento
// Chrome DevTools: Panel Performance
// 1. Grabar mientras se reproduce la animación
// 2. Buscar cuadros largos (>16.6ms para 60fps)
// 3. Revisar pestaña "Rendering": activar "Paint flashing" para ver repintados
// Forzar composición por GPU (usar con moderación)
.animated-element {
will-change: transform, opacity; /* Sugerencia al navegador: promover a capa propia */
/* Eliminar will-change después de que la animación termine para liberar memoria de GPU */
}
// Medir velocidad de cuadros en código
let frames = 0;
let lastTime = performance.now();
function countFrames() {
frames++;
const now = performance.now();
if (now - lastTime >= 1000) {
console.log(`FPS: ${frames}`);
frames = 0;
lastTime = now;
}
requestAnimationFrame(countFrames);
}
countFrames();
Visibilidad de Contenido para Elementos Fuera de Pantalla
/* No renderizar secciones fuera de pantalla hasta que sea necesario */
.section {
content-visibility: auto;
contain-intrinsic-size: auto 500px;
}
Accesibilidad
Respetando el Movimiento Reducido
/* Siempre proporcionar alternativas de movimiento reducido */
@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;
}
}
/* O deshabilitar selectivamente solo animaciones no esenciales */
@media (prefers-reduced-motion: reduce) {
.decorative-animation { animation: none; }
.page-transition { transition: opacity 0.1ms; } /* Instantáneo pero aún dispara eventos */
/* Mantener animaciones funcionales como spinners de carga */
}
// GSAP: Verificar preferencia del usuario
const prefersReducedMotion = window.matchMedia('(prefers-reduced-motion: reduce)').matches;
if (prefersReducedMotion) {
gsap.globalTimeline.timeScale(20); // Animaciones casi instantáneas
}
// Framer Motion: Soporte integrado
import { useReducedMotion } from 'framer-motion';
function Component() {
const shouldReduceMotion = useReducedMotion();
return (
<motion.div
animate={{ x: 100 }}
transition={shouldReduceMotion ? { duration: 0 } : { duration: 0.5 }}
/>
);
}
Reglas de Accesibilidad de Animación
- Nunca animar contenido que transmita información solo a través del movimiento (algunos usuarios no lo verán)
- Proporcionar controles de pausa/parada para animaciones que duren más de 5 segundos
- Evitar parpadeos más de 3 veces por segundo (riesgo de convulsiones, WCAG 2.3.1)
- No usar la animación como la única forma de transmitir significado (por ejemplo, un campo de formulario que tiembla también debe mostrar un mensaje de error)
Anti-Patrones Comunes
-
Animar propiedades de layout:
width,height,top,leftcausan thrashing de layout. Usartransformen su lugar. -
Demasiadas capas
will-change: Cada elemento conwill-changeobtiene su propia capa de GPU. Demasiadas capas consumen memoria y realmente perjudican el rendimiento. -
Animación por la animación misma: Si eliminar la animación no perjudica la usabilidad, probablemente no debería estar ahí. Cada animación debe tener un propósito.
-
Ignorar el movimiento reducido: El 15-20% de los usuarios tienen trastornos vestibulares o sensibilidad al movimiento. Siempre proporcionar alternativas
prefers-reduced-motion. -
Animaciones JavaScript síncronas: Usar
setIntervalosetTimeoutpara animaciones. UsarrequestAnimationFrame, animaciones CSS, o bibliotecas de animación que usen rAF internamente.
Lista de Verificación de Animación
- Propósito de la animación definido (retroalimentación, continuidad, atención, carga)
- Tecnología elegida apropiada a la complejidad
- Solo se animan propiedades compositables (transform, opacity)
- Las funciones de easing coinciden con la intención de la animación (ease-out para entradas, ease-in para salidas)
- Consulta de medios
prefers-reduced-motionimplementada - Duración apropiada (100-300ms para micro-interacciones, 300-500ms para transiciones)
- Sin parpadeo de contenido más de 3 veces por segundo
- Rendimiento probado en DevTools (60fps consistentes)
- Las animaciones no bloquean la interacción del usuario
- Los estados de carga usan pantallas esqueleto o animaciones sutiles, no spinners por todas partes
Cuándo Usar
Usar este skill cuando:
- Diseñando o implementando soluciones de maestro de animaciones web
- Revisando o mejorando enfoques existentes de maestro de animaciones web
- Tomando decisiones arquitectónicas o de implementación sobre maestro de animaciones web
- Aprendiendo patrones y mejores prácticas de maestro de animaciones web
- Solucionando problemas relacionados con maestro de animaciones web
NO usar este skill cuando:
- La pregunta es sobre un dominio tecnológico fundamentalmente diferente
- Un skill hermano más específico cubre exactamente el tema necesario
- El usuario necesita un tutorial práctico completo