Quando esta skill for ativada, sempre comece sua primeira resposta com o emoji 🧢.
Design de Movimento
Uma base de conhecimento focada e opinativa para implementar animações e movimento em aplicações web. Abrange transições CSS e keyframes, Framer Motion, GSAP, animações baseadas em rolagem e micro-interações - com código concreto para cada padrão. Cada recomendação prioriza desempenho a 60fps, acessibilidade e movimento com propósito, em vez de decoração.
A diferença entre uma animação boa e uma ruim é a moderação. A maioria das UIs precisa de menos animações, não mais. Quando o movimento existe, ele deve ser rápido, suave e respeitar as preferências do usuário.
Quando usar esta skill
Ative esta skill quando o usuário:
- Pedir para adicionar animações ou transições a qualquer elemento da UI
- Precisar de animações de entrada/saída para componentes sendo montados ou desmontados
- Quiser implementar transições de página ou animações de mudança de rota
- Perguntar sobre Framer Motion, GSAP ou APIs de animação CSS
- Precisar de animações baseadas em rolagem ou efeitos de paralaxe
- Quiser estados de carregamento com telas de esqueleto ou spinners
- Perguntar sobre física spring, curvas de easing ou temporização de animação
- Precisar de uma timeline GSAP para sequências complexas de múltiplas etapas
- Perguntar sobre micro-interações (hover, press, toggle, estados de checkbox)
NÃO ative esta skill para:
- Layout CSS puro ou estilização sem movimento (use ultimate-ui)
- Renderização Canvas ou WebGL (use um recurso específico para gráficos)
Princípios-chave
-
Movimento deve ter propósito - Cada animação deve comunicar algo: mudança de estado, relação espacial, feedback ou hierarquia. Movimento só para decoração é ruído. Pergunte "O que essa animação diz ao usuário?" antes de adicioná-la.
-
Respeite
prefers-reduced-motion- Sempre envolva animações em uma verificação deprefers-reduced-motion. Usuários com distúrbios vestibulares ou epilepsia podem ser prejudicados por movimento. Isso é um requisito WCAG 2.1 AA, não uma sugestão. -
Anime apenas transform e opacity -
transformeopacitysão as únicas propriedades que o navegador pode animar no thread do compositor sem acionar layout ou pintura. Animarwidth,height,top,left,marginoupaddingcausa jank. Usetransform: scale/translate. -
Spring > easing linear - Movimento natural usa easing baseado em física, não velocidade uniforme. Animações spring parecem vivas.
linearparece robótico. Useease-outpara entradas,ease-inpara saídas, spring/bounce para elementos interativos que respondem à entrada do usuário. -
60fps ou nada - Se uma animação perder quadros, remova-a. Uma animação com jank é pior do que nenhuma animação. Teste em uma CPU limitada (4x de lentidão no Chrome DevTools). Se cair abaixo de 60fps, simplifique ou corte.
Conceitos principais
Propriedades de animação
- Duração: 100-150ms para micro (hover em botão), 200-300ms para UI (modal, dropdown), 300-500ms para layout (transições de página). Nunca acima de 500ms para feedback interativo.
- Easing:
ease-out(começo rápido, pouso suave) para elementos entrando na tela.ease-in(começo lento, fim rápido) para elementos saindo.ease-in-outpara elementos se movendo pela tela. Spring para elementos interativos/divertidos. - Atraso (delay): Use com moderação. Intercale filhos com no máximo 50-75ms. A sequência total de intercalação não deve exceder 400ms, ou os usuários sentirão que estão esperando.
Guia de decisão: CSS vs JS animações
- Use transições CSS para mudanças simples de estado acionadas por classe ou pseudo-classe (hover, focus, active). Zero overhead de JS.
- Use keyframes CSS para animações em loop (spinners, pulsações) e sequências coreografadas não vinculadas à interação.
- Use Framer Motion (React) para animações de entrada/saída vinculadas à montagem/desmontagem de componentes, movimento guiado por gestos ou animações de layout.
- Use GSAP para timelines complexas de múltiplas etapas, animações de caminho SVG, sequências acionadas por rolagem ou quando precisar de controle programático preciso.
Física spring
Uma mola tem dois parâmetros principais: stiffness (rigidez, quão rápido acelera) e damping (amortecimento, quão rapidamente se estabiliza). Rigidez alta + amortecimento alto = rápido. Rigidez baixa + amortecimento baixo = elástico e lento. Para UI: rigidez 300-500, amortecimento 25-35 dá uma sensação natural sem oscilação excessiva.
Desempenho - thread do compositor vs thread principal
O navegador renderiza em dois estágios: thread principal (layout, pintura) e thread do compositor (transform, opacidade). Animações no thread do compositor rodam a 60fps mesmo quando o thread principal está ocupado. Sempre use transform e opacity. Adicione will-change: transform apenas para elementos que você sabe que vão animar - o uso excessivo de will-change desperdiça memória GPU.
Tarefas comuns
Transições e keyframes CSS
/* Tokens de easing reutilizáveis */
: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;
}
/* Fade in up - conteúdo aparecendo */
@keyframes fade-in-up {
from { opacity: 0; transform: translateY(12px); }
to { opacity: 1; transform: translateY(0); }
}
/* Scale in - modais, 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 em card - efeito de elevação */
.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);
}
Animações de entrada/saída com Framer Motion
import { motion, AnimatePresence } from 'framer-motion';
// Variantes de animação reutilizáveis
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 com entrada/saída
function Notification({ show, message }: { show: boolean; message: string }) {
return (
<AnimatePresence>
{show && (
<motion.div
key="notification"
{...fadeUp}
className="toast"
>
{message}
</motion.div>
)}
</AnimatePresence>
);
}
// Lista intercalada
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>
);
}
Animações baseadas em rolagem com CSS
/* Animações nativas CSS acionadas por rolagem (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 progresso vinculada à rolagem da 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 IntersectionObserver para suporte de navegador mais amplo */
// IntersectionObserver - funciona em todos os navegadores
const observer = new IntersectionObserver(
(entries) => {
entries.forEach((entry) => {
if (entry.isIntersecting) {
entry.target.classList.add('in-view');
observer.unobserve(entry.target); // anima uma 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);
}
Transições de página com 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>
);
}
Use
mode="wait"para que a página que está saindo termine completamente de animar antes da nova entrar.mode="sync"(padrão) pode causar sobreposição. Mantenha as transições de página abaixo de 250ms - os usuários estão esperando para ver o novo conteúdo.
Micro-interações - hover, press, toggle
import { motion } from 'framer-motion';
// Botão com feedback de pressão
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>
);
}
// Alternador toggle 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);
}
/* Accordion com truque 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;
}
Timeline GSAP para sequências complexas
import gsap from 'gsap';
import { ScrollTrigger } from 'gsap/ScrollTrigger';
gsap.registerPlugin(ScrollTrigger);
// Sequência de entrada do hero
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;
}
// Cartões de funcionalidades acionados por rolagem
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,
},
});
});
O offset
'-=0.2'nas timelines GSAP cria sobreposição entre as etapas para uma sequência fluida e coesa. Sem ele, cada etapa parece desconectada. Sobreponha em 20-40% da duração da etapa anterior.
Respeite prefers-reduced-motion
/* CSS - regra geral como rede de segurança */
@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 - verifique a preferência antes de executar GSAP
const prefersReduced = window.matchMedia('(prefers-reduced-motion: reduce)').matches;
if (!prefersReduced) {
animateHero();
}
Antipadrões
| Erro | Por que está errado | O que fazer em vez disso |
|---|---|---|
Animar width, height, top ou left | Aciona recálculo de layout a cada quadro, causa jank | Use transform: scale() ou transform: translate() |
transition: all | Captura propriedades inesperadas, difícil de prever, risco de desempenho | Liste propriedades específicas: transition: transform 200ms, opacity 200ms |
| Duração acima de 500ms para feedback interativo | Usuários sentem que a UI está lenta ou quebrada | Mantenha botão/hover/toggle abaixo de 200ms, modal abaixo de 300ms |
| Usar GSAP para efeitos simples de hover | Sobrecarga enorme para algo que CSS trata nativamente | Use transition CSS para mudanças de estado, GSAP apenas para timelines |
| Atraso de intercalação total acima de 500ms | Usuários esperam pelo conteúdo em vez de vê-lo aparecer | Limite o atraso por item a 75ms, intercalação total a 400ms |
will-change: transform em tudo | Cada will-change cria uma camada GPU - uso excessivo desperdiça VRAM | Adicione apenas em elementos que você sabe que vão animar, remova após a animação |
Referências
Para orientação detalhada sobre tópicos específicos de movimento, leia o arquivo relevante da pasta references/:
…
[truncado para tradução]