Communitygithub.com

TheMystic07/OpenWalc

Design de movimento e animação para interfaces de usuário. Use ao criar micro-interações, transições de página, estados de carregamento ou qualquer animação de UI em plataformas web e mobile.

O que é OpenWalc?

O skill OpenWalc é um guia abrangente para criação de animações intencionais e de alto desempenho em interfaces de usuário. Ele se baseia nos 12 princípios clássicos de animação adaptados para UI e fornece diretrizes detalhadas sobre temporização, duração e funções de easing (aceleração), incluindo valores CSS e recomendações práticas. O conteúdo cobre padrões essenciais como micro-interações (botões, toggles), estados de carregamento (skeleton screens, spinners), transições de página (crossfade, slide, elemento compartilhado) e animações de listas (entrada escalonada, técnica FLIP). Além disso, o skill aborda aspectos críticos de performance (propriedades aceleradas por GPU, técnica FLIP), técnicas de animação com CSS e JavaScript (incluindo exemplos com bibliotecas populares como Framer Motion, GSAP e anime.js), acessibilidade (respeitando preferências de redução de movimento e diretrizes WCAG) e considerações específicas para dispositivos móveis e integração com sistemas de design. A habilidade pode ser utilizada em qualquer ferramenta de IA que suporte a execução de skills baseados em documentação, como Claude Code, Cursor e Codex, funcionando como uma referência consultiva para desenvolvedores e designers que buscam orientação prática e boas práticas para animações de UI.

Funciona com~Claude Code~Codex CLI~Cursor
npx skills add https://github.com/TheMystic07/OpenWalc/tree/HEAD/.agent/skills/ui-animation

Perguntar na sua IA favorita

Abre um novo chat com esta habilidade de agente já pré-carregada.

Documentação

Animação de UI & Design de Movimento

Guia abrangente para criar animações intencionais e de alto desempenho em interfaces de usuário.

Princípios de Animação

Os 12 Princípios da Animação (Aplicados à UI)

PrincípioAplicação em UI
TimingDuração reflete importância/distância
EasingAceleração/desaceleração natural
AntecipaçãoPreparação visual para a ação
Follow-throughMomento continua após a parada
Ação SecundáriaElementos de suporte respondem
EncenaçãoAtrai atenção para o elemento chave
Esmagamento & EsticarInterações saltitantes e divertidas
ExageroEnfatiza feedback importante
ArcoTrajetórias curvas naturais
SobreposiçãoElementos se movem em ritmos diferentes
Desenho SólidoMantém espaço 3D consistente
ApeloMovimento envolvente e agradável

Por que Animar?

PROPÓSITOS FUNCIONAIS:
✓ Guiar a atenção para mudanças importantes
✓ Mostrar relações entre elementos
✓ Fornecer feedback para ações
✓ Comunicar o status do sistema
✓ Reduzir a carga cognitiva
✓ Criar orientação espacial

NÃO PARA:
✗ Decoração pura
✗ Mostrar habilidades
✗ Fazer as coisas parecerem "modernas"
✗ Distrair do conteúdo

Temporização & Duração

Diretrizes de Duração

INSTANTÂNEO (0-100ms):
└─→ Mudanças de estado de botão
└─→ Interruptores
└─→ Micro-feedback

RÁPIDO (100-200ms):
└─→ Efeitos de hover
└─→ Fades simples
└─→ Pequenos movimentos

PADRÃO (200-300ms):
└─→ Maioria das transições de UI
└─→ Abertura/fechamento de modal
└─→ Menus suspensos

LENTO (300-500ms):
└─→ Transições complexas
└─→ Transições de página
└─→ Movimento de elementos grandes

DELIBERADO (500ms+):
└─→ Animações hero
└─→ Carregamento skeleton
└─→ Sequências de onboarding

Temporização Baseada em Distância

Regra: Quanto maior a distância, maior a duração

Pequena (< 100px):   150-200ms
Média (100-300px):   200-300ms
Grande (300-500px):  300-400ms
Tela cheia:          400-500ms

Fórmula:
duracao = tempoBase + (distancia × fator)

Funções de Easing

Easings Padrão

LINEAR
├────────────────────────────┤
Velocidade constante. Raramente natural.
Use: Barras de progresso, ponteiros de relógio

EASE-OUT (Desaceleração)
├═══════════────────────────┤
Início rápido, fim lento.
Use: Elementos entrando na tela

EASE-IN (Aceleração)
├────────────────═══════════┤
Início lento, fim rápido.
Use: Elementos saindo da tela

EASE-IN-OUT (Curva S)
├────═══════════════────────┤
Início e fim lentos, meio rápido.
Use: Transições na tela

EASE-OUT-BACK (Ultrapassagem)
├═══════════────────────╗───┤
Ultrapassa, depois estabiliza.
Use: Entradas divertidas, saltos

Valores de Easing em CSS

/* Palavras-chave nativas */
linear: cubic-bezier(0, 0, 1, 1)
ease: cubic-bezier(0.25, 0.1, 0.25, 1)
ease-in: cubic-bezier(0.42, 0, 1, 1)
ease-out: cubic-bezier(0, 0, 0.58, 1)
ease-in-out: cubic-bezier(0.42, 0, 0.58, 1)

/* Padrão Material Design */
standard: cubic-bezier(0.4, 0, 0.2, 1)
decelerate: cubic-bezier(0, 0, 0.2, 1)
accelerate: cubic-bezier(0.4, 0, 1, 1)

/* Personalizado: Snappy */
snappy: cubic-bezier(0.5, 0, 0, 1)

/* Personalizado: Bouncy */
bouncy: cubic-bezier(0.68, -0.55, 0.27, 1.55)

/* Spring-like (use bibliotecas JS) */
spring: { stiffness: 300, damping: 20 }

Quando Usar Cada Um

CenárioEasingPor que
Elemento entrandoease-outChega energeticamente, se acomoda
Elemento saindoease-inGanha impulso para sair
Mudança na telaease-in-outMudança de estado suave
Chamar atençãobounce/springDivertido, perceptível
Fundo/sutilease-outDiscreto

Padrões de Animação

Micro-interações

ESTADOS DO BOTÃO:
┌─────────────────────────────────────────┐
│ Descanso → Hover: scale(1.02), 100ms    │
│ Hover → Ativo: scale(0.98), 50ms        │
│ Ativo → Descanso: scale(1), 150ms ease-out │
└─────────────────────────────────────────┘

INTERRUPTOR:
┌─────────────────────────────────────────┐
│ Polegar: translateX, 200ms ease-out       │
│ Trilha: background-color, 200ms          │
│ Estado: pequeno salto no final             │
└─────────────────────────────────────────┘

CAIXA DE SELEÇÃO:
┌─────────────────────────────────────────┐
│ Marca de seleção: animação stroke-dashoffset │
│ Fundo: escala a partir do centro, 150ms    │
│ Ondulação: círculo expansivo, 300ms         │
└─────────────────────────────────────────┘

Estados de Carregamento

TELAS SKELETON:
┌──────────────────────────┐
│ ▓▓▓▓▓▓▓▓▓▓░░░░░░░░░░░░  │ Efeito shimmer
│ ▓▓▓▓▓▓▓▓▓▓▓▓░░░░░░░░░░  │ Gradiente linear
│ ▓▓▓▓▓▓░░░░░░░░░░░░░░░░  │ Movendo da esquerda para a direita
└──────────────────────────┘

CSS:
background: linear-gradient(
  90deg,
  #f0f0f0 25%,
  #e0e0e0 50%,
  #f0f0f0 75%
);
background-size: 200% 100%;
animation: shimmer 1.5s infinite;

SPINNER:
- Duração: 1-2 segundos por rotação
- Easing: linear (movimento consistente)
- Estilo: Combine com a identidade da marca

Transições de Página

CROSSFADE:
├──────────────────────────────────────────┤
│ Página antiga: opacidade 1 → 0, 200ms      │
│ Nova página: opacidade 0 → 1, 200ms        │
│ Temporização: Sequencial ou sobreposta      │
└──────────────────────────────────────────┘

DESLIZAMENTO:
├──────────────────────────────────────────┤
│ Direção segue a hierarquia de navegação   │
│ Avançar: Desliza para a esquerda (novo da direita) │
│ Voltar: Desliza para a direita (anterior da esquerda) │
│ Duração: 300-400ms                      │
└──────────────────────────────────────────┘

ELEMENTO COMPARTILHADO:
├──────────────────────────────────────────┤
│ Elemento se transforma entre estados      │
│ Posição, tamanho, border-radius mudam     │
│ Cria continuidade entre telas             │
│ Duração: 300-500ms                      │
└──────────────────────────────────────────┘

Animações de Lista

ENTRADA ESCALONADA:
┌─ Item 1 ────────────────┐  atraso: 0ms
├─ Item 2 ────────────────┤  atraso: 50ms
├─ Item 3 ────────────────┤  atraso: 100ms
├─ Item 4 ────────────────┤  atraso: 150ms
└─ Item 5 ────────────────┘  atraso: 200ms

Duração total máxima: 500ms
Escalonamento: 30-50ms por item
Animação: translateY + opacidade

REORDENAR:
- Use a técnica FLIP
- Duração: 200-300ms
- Easing: ease-out

Performance

Propriedades Aceleradas por GPU

RÁPIDO (Apenas compositor):
✓ transform: translate, scale, rotate
✓ opacity
✓ filter (com will-change)

LENTO (Dispara layout/pintura):
✗ width, height
✗ margin, padding
✗ top, left, right, bottom
✗ border, border-radius
✗ font-size
✗ box-shadow (repinturas)

OTIMIZAÇÃO:
will-change: transform, opacity;
/* Use com moderação! */

Diretrizes de Performance

/* Bom: Acelerado por GPU */
.elemento-animado {
  transform: translateX(0);
  transition: transform 300ms ease-out;
}
.elemento-animado.movido {
  transform: translateX(100px);
}

/* Ruim: Causa thrashing de layout */
.elemento-animado {
  left: 0;
  transition: left 300ms ease-out;
}
.elemento-animado.movido {
  left: 100px;
}

Técnica FLIP

// Primeiro: Obter a posição inicial
const primeiro = elemento.getBoundingClientRect();

// Último: Aplicar a mudança, obter posição final
elemento.classList.add("movido");
const ultimo = elemento.getBoundingClientRect();

// Inverter: Calcular o delta, aplicar transformação inversa
const deltaX = primeiro.left - ultimo.left;
const deltaY = primeiro.top - ultimo.top;
elemento.style.transform = `translate(${deltaX}px, ${deltaY}px)`;

// Reproduzir: Remover a transformação com transição
requestAnimationFrame(() => {
  elemento.style.transition = "transform 300ms ease-out";
  elemento.style.transform = "";
});

Técnicas de Animação CSS

Animação com Keyframes

@keyframes fadeSlideIn {
  from {
    opacity: 0;
    transform: translateY(20px);
  }
  to {
    opacity: 1;
    transform: translateY(0);
  }
}

.elemento {
  animation: fadeSlideIn 300ms ease-out forwards;
}

/* Com passos */
@keyframes maquinaDeEscrever {
  from {
    width: 0;
  }
  to {
    width: 100%;
  }
}

.texto-digitado {
  animation: maquinaDeEscrever 2s steps(20) forwards;
}

Transição

.botao {
  background: var(--primaria);
  transform: scale(1);
  transition:
    background 150ms ease-out,
    transform 100ms ease-out;
}

.botao:hover {
  background: var(--primaria-hover);
  transform: scale(1.02);
}

.botao:active {
  transform: scale(0.98);
  transition-duration: 50ms;
}

Abreviação de Animação

/* animation: nome duracao timing-function atraso
              contagem-de-iteracao direcao fill-mode play-state */

animation: slideIn 300ms ease-out 100ms 1 normal forwards running;

/* Padrões comuns */
animation: spin 1s linear infinite;
animation: pulse 2s ease-in-out infinite alternate;
animation: fadeIn 300ms ease-out forwards;

Bibliotecas de Animação JavaScript

Comparação

BibliotecaMelhor ParaTamanho do Bundle
CSSTransições simples0kb
Web Animations APINativo, performático0kb
GSAPComplexo, preciso~60kb
Framer MotionEcossistema React~50kb
anime.jsTimeline, SVG~17kb
Motion OneModerno, leve~18kb
LottieExportação do After Effects~50kb

Framer Motion (React)

import { motion, AnimatePresence } from "framer-motion";

// Animação básica
<motion.div
  initial={{ opacity: 0, y: 20 }}
  animate={{ opacity: 1, y: 0 }}
  exit={{ opacity: 0, y: -20 }}
  transition={{ duration: 0.3, ease: "easeOut" }}
>
  Conteúdo
</motion.div>;

// Variantes para animações complexas
const variantesContainer = {
  hidden: { opacity: 0 },
  visible: {
    opacity: 1,
    transition: {
      staggerChildren: 0.1,
    },
  },
};

const variantesItem = {
  hidden: { opacity: 0, y: 20 },
  visible: { opacity: 1, y: 0 },
};

<motion.ul variants={variantesContainer} initial="hidden" animate="visible">
  {items.map((item) => (
    <motion.li key={item.id} variants={variantesItem}>
      {item.nome}
    </motion.li>
  ))}
</motion.ul>;

GSAP

import { gsap } from "gsap";

// Tween básico
gsap.to(".elemento", {
  x: 100,
  opacity: 1,
  duration: 0.3,
  ease: "power2.out",
});

// Timeline
const tl = gsap.timeline();
tl.from(".cabecalho", { y: -100, duration: 0.5 })
  .from(".conteudo", { opacity: 0, duration: 0.3 }, "-=0.2")
  .from(".botao", { scale: 0.8, duration: 0.2 });

// ScrollTrigger
gsap.registerPlugin(ScrollTrigger);
gsap.to(".parallax", {
  y: -100,
  scrollTrigger: {
    trigger: ".secao",
    start: "top center",
    end: "bottom center",
    scrub: true,
  },
});

Acessibilidade

Respeitando as Preferências do Usuário

/* Reduzir movimento para usuários que preferem */
@media (prefers-reduced-motion: reduce) {
  *,
  *::before,
  *::after {
    animation-duration: 0.01ms !important;
    animation-iteration-count: 1 !important;
    transition-duration: 0.01ms !important;
  }
}

/* Ou fornecer alternativas mais simples */
@media (prefers-reduced-motion: reduce) {
  .elemento-animado {
    /* Substituir movimento por opacidade */
    animation: none;
    transition: opacity 200ms ease;
  }
}

Práticas de Animação Seguras

EVITAR para distúrbios vestibulares:
✗ Efeitos de parallax scrolling
✗ Animações de zoom/escala
✗ Elementos girando/rotacionando
✗ Animações reproduzidas automaticamente
✗ Flashes (>3 vezes/segundo)

Alternativas SEGURAS:
✓ Fades de opacidade
✓ Transições de cor
✓ Mudanças sutis de posição
✓ Animações iniciadas pelo usuário

Diretrizes WCAG

2.2.2 Pausar, Parar, Ocultar:
- Conteúdo que se atualiza automaticamente pode ser pausado
- Sem limites de tempo para leitura

2.3.1 Três Flashes:
- Nada pisca mais de 3x por segundo

2.3.3 Animação de Interações:
- Movimento pode ser desabilitado
- Animações acionadas respeitam preferências

Considerações para Dispositivos Móveis

Feedback de Toque

/* Estilo de feedback de toque iOS */
.botao {
  -webkit-tap-highlight-color: transparent;
  touch-action: manipulation;
}

.botao:active {
  opacity: 0.7;
  transition: opacity 50ms;
}

/* Efeito de ondulação */
.ondulacao {
  position: relative;
  overflow: hidden;
}

.ondulacao::after {
  content: "";
  position: absolute;
  background: rgba(255, 255, 255, 0.3);
  border-radius: 50%;
  transform: scale(0);
  animation: ondulacao 400ms ease-out;
}

Convenções de Plataforma

PlataformaEstilo de Animação
iOSFísica spring, 300-500ms, sutil
AndroidMovimento Material, 200-300ms, enfatizado
WebVariado, tipicamente 200-400ms

Integração com Sistema de Design

Tokens de Animação

:root {
  /* Durações */
  --duracao-instante: 100ms;
  --duracao-rapida: 150ms;
  --duracao-normal: 250ms;
  --duracao-lenta: 400ms;
  --duracao-mais-lenta: 600ms;

  /* Easings */
  --ease-padrao: cubic-bezier(0.4, 0, 0.2, 1);
  --ease-in: cubic-bezier(0.4, 0, 1, 1);
  --ease-out: cubic-bezier(0, 0, 0.2, 1);
  --ease-bounce: cubic-bezier(0.68, -0.55, 0.27, 1.55);

  /* Combinados */
  --transicao-padrao: var(--duracao-normal) var(--ease-padrao);
  --transicao-rapida: var(--duracao-rapida) var(--ease-out);
}

/* Uso */
.elemento {
  transition: transform var(--transicao-padrao);
}

Melhores Práticas

FAÇA:

  • Anime com propósito (feedback, orientação)
  • Use propriedades aceleradas por GPU
  • Mantenha as durações abaixo de 500ms
  • Combine a animação com a personalidade da marca
  • Respeite prefers-reduced-motion
  • Teste em dispositivos de baixo custo
  • Use um sistema de temporização consistente

NÃO FAÇA:

  • Anime apenas por decoração
  • Bloqueie a interação do usuário
  • Use saltos/ultrapassagens excessivas
  • Crie gatilhos de enjoo de movimento
  • Esqueça animações de saída
  • Ignore métricas de performance

…

[truncado para tradução]

Individual skills in this repo

This repo contains 2 individual skills — each has its own dedicated page.

Habilidades Relacionadas