JavaScript → Style → Layout → Paint → Composite
     ↓          ↓       ↓        ↓         ↓
   16.67ms total for 60fps

Composite only (cheap):
- transform
- opacity

Paint (medium):
- color
- background-color
- box-shadow

Layout (expensive):
- width, height
- top, left, right, bottom
- padding, margin
- border-width
- font-size

/* ✅ GOOD: Compositor-only */
.box {
  transition: transform 0.3s ease-out;
}
.box:hover {
  transform: translateX(100px) scale(1.1) rotate(5deg);
}

/* ❌ BAD: Triggers layout */
.box {
  transition: left 0.3s, width 0.3s;
}
.box:hover {
  left: 100px;
  width: 200px;
}

/* ✅ GOOD: Compositor-only */
.fade {
  transition: opacity 0.3s;
}
.fade:hover {
  opacity: 0.5;
}

/* ❌ BAD: Triggers paint */
.fade {
  transition: background-color 0.3s;
}
.fade:hover {
  background-color: rgba(0, 0, 0, 0.5);
}

/* Slide from left */
@keyframes slideInLeft {
  from {
    transform: translateX(-100%);
    opacity: 0;
  }
  to {
    transform: translateX(0);
    opacity: 1;
  }
}

.slide-in {
  animation: slideInLeft 0.3s ease-out;
}

@keyframes fadeIn {
  from {
    opacity: 0;
  }
  to {
    opacity: 1;
  }
}

.fade-in {
  animation: fadeIn 0.3s ease-out;
}

@keyframes scaleUp {
  from {
    transform: scale(0.8);
    opacity: 0;
  }
  to {
    transform: scale(1);
    opacity: 1;
  }
}

.scale-up {
  animation: scaleUp 0.3s cubic-bezier(0.34, 1.56, 0.64, 1);
}

@keyframes rotate {
  from {
    transform: rotate(0deg);
  }
  to {
    transform: rotate(360deg);
  }
}

.spinner {
  animation: rotate 1s linear infinite;
}

@keyframes bounce {
  0%, 100% {
    transform: translateY(0);
  }
  50% {
    transform: translateY(-20px);
  }
}

.bounce {
  animation: bounce 0.6s ease-in-out infinite;
}

/* Prepare for animation */
.animated-element {
  will-change: transform, opacity;
}

/* Remove after animation */
.animated-element:hover {
  will-change: auto;
}

// Use will-change only during animation
function AnimatedBox() {
  const [animating, setAnimating] = useState(false);

  return (
    <div
      style={{
        willChange: animating ? 'transform' : 'auto',
        transform: animating ? 'scale(1.2)' : 'scale(1)',
        transition: 'transform 0.3s',
      }}
      onMouseEnter={() => setAnimating(true)}
      onMouseLeave={() => setAnimating(false)}
    />
  );
}

.gpu-accelerated {
  transform: translateZ(0);  /* Force GPU layer */
  backface-visibility: hidden;  /* Smooth transforms */
}

function animateElement(element: HTMLElement, from: number, to: number, duration: number) {
  const startTime = performance.now();

  function step(currentTime: number) {
    const elapsed = currentTime - startTime;
    const progress = Math.min(elapsed / duration, 1);
    
    // Easing function
    const eased = easeOutCubic(progress);
    
    // Update using transform (compositor-only)
    const value = from + (to - from) * eased;
    element.style.transform = `translateX(${value}px)`;

    if (progress < 1) {
      requestAnimationFrame(step);
    }
  }

  requestAnimationFrame(step);
}

function easeOutCubic(t: number): number {
  return 1 - Math.pow(1 - t, 3);
}

// Usage
animateElement(element, 0, 100, 300);

npm install @react-spring/web

import { useSpring, animated } from '@react-spring/web';

function AnimatedBox() {
  const [isOpen, setIsOpen] = useState(false);

  const styles = useSpring({
    transform: isOpen ? 'translateX(100px) scale(1.2)' : 'translateX(0) scale(1)',
    opacity: isOpen ? 1 : 0.5,
    config: { tension: 280, friction: 60 },
  });

  return (
    <animated.div
      style={styles}
      onClick={() => setIsOpen(!isOpen)}
    >
      Click me
    </animated.div>
  );
}

npm install framer-motion

import { motion } from 'framer-motion';

function AnimatedBox() {
  return (
    <motion.div
      initial={{ opacity: 0, scale: 0.8 }}
      animate={{ opacity: 1, scale: 1 }}
      exit={{ opacity: 0, scale: 0.8 }}
      transition={{ duration: 0.3 }}
    >
      Content
    </motion.div>
  );
}

// List animations
function AnimatedList({ items }: Props) {
  return (
    <motion.div>
      {items.map((item, i) => (
        <motion.div
          key={item.id}
          initial={{ opacity: 0, y: 20 }}
          animate={{ opacity: 1, y: 0 }}
          exit={{ opacity: 0, y: -20 }}
          transition={{ delay: i * 0.1 }}
        >
          {item.name}
        </motion.div>
      ))}
    </motion.div>
  );
}

1. Open DevTools
2. Performance tab
3. Enable "Screenshots"
4. Record animation
5. Look for:
   - Long frames (> 16.67ms)
   - Layout/Paint (should be green "Composite Layers")

let lastTime = performance.now();
let frames = 0;

function measureFPS() {
  frames++;
  const currentTime = performance.now();
  
  if (currentTime >= lastTime + 1000) {
    const fps = Math.round((frames * 1000) / (currentTime - lastTime));
    console.log(`FPS: ${fps}`);
    
    frames = 0;
    lastTime = currentTime;
  }
  
  requestAnimationFrame(measureFPS);
}

measureFPS();

const observer = new PerformanceObserver((list) => {
  list.getEntries().forEach((entry) => {
    // Warn if frame takes too long
    if (entry.duration > 16.67) {
      console.warn('Slow frame:', entry.duration, 'ms');
    }
  });
});

observer.observe({ entryTypes: ['measure'] });

/* Simple hover effect */
.button {
  transform: scale(1);
  transition: transform 0.2s ease-out;
}
.button:hover {
  transform: scale(1.05);
}

/* Loading spinner */
@keyframes spin {
  to { transform: rotate(360deg); }
}

.spinner {
  animation: spin 1s linear infinite;
}

// Drag and drop
import { motion } from 'framer-motion';

function Draggable() {
  return (
    <motion.div
      drag
      dragConstraints={{ left: 0, right: 300, top: 0, bottom: 300 }}
      dragElastic={0.2}
    />
  );
}

// Pause expensive animations while scrolling
let scrollTimeout: NodeJS.Timeout;

window.addEventListener('scroll', () => {
  document.body.classList.add('scrolling');
  
  clearTimeout(scrollTimeout);
  scrollTimeout = setTimeout(() => {
    document.body.classList.remove('scrolling');
  }, 150);
});

/* Disable animations while scrolling */
.scrolling * {
  animation-play-state: paused !important;
  transition: none !important;
}

@media (prefers-reduced-motion: reduce) {
  * {
    animation-duration: 0.01ms !important;
    animation-iteration-count: 1 !important;
    transition-duration: 0.01ms !important;
  }
}

// React hook
function useReducedMotion() {
  const [prefersReducedMotion, setPrefersReducedMotion] = useState(false);

  useEffect(() => {
    const mediaQuery = window.matchMedia('(prefers-reduced-motion: reduce)');
    setPrefersReducedMotion(mediaQuery.matches);

    const handler = (e: MediaQueryListEvent) => {
      setPrefersReducedMotion(e.matches);
    };

    mediaQuery.addEventListener('change', handler);
    return () => mediaQuery.removeEventListener('change', handler);
  }, []);

  return prefersReducedMotion;
}

// Usage
function AnimatedComponent() {
  const reducedMotion = useReducedMotion();

  return (
    <motion.div
      animate={{ opacity: 1 }}
      transition={{ duration: reducedMotion ? 0 : 0.3 }}
    />
  );
}

/* BAD: Triggers layout on every frame */
.box {
  transition: width 0.3s, height 0.3s, top 0.3s, left 0.3s;
}
.box:hover {
  width: 200px;
  height: 200px;
  top: 50px;
  left: 50px;
}

/* GOOD: Compositor-only */
.box {
  transition: transform 0.3s;
}
.box:hover {
  transform: scale(1.5) translate(25px, 25px);
}

/* BAD: Triggers paint */
.box {
  transition: background-color 0.3s, color 0.3s;
}

/* GOOD: Compositor-only */
.box {
  position: relative;
}
.box::before {
  content: '';
  position: absolute;
  inset: 0;
  background: blue;
  opacity: 0;
  transition: opacity 0.3s;
}
.box:hover::before {
  opacity: 1;
}

CSS Transitions/Animations:
- Simple
- Performant
- Limited control

React Spring:
- Physics-based
- Interruptible
- 15 KB

Framer Motion:
- Declarative
- Layout animations
- 30 KB

GSAP:
- Most powerful
- Best timeline control
- 50 KB

Recommendation:
- Simple: CSS
- React apps: Framer Motion or React Spring
- Complex timelines: GSAP