Animação Lottie — Animações Programáticas Baseadas em JSON
Crie logotipos animados, ícones e microinterações como arquivos Lottie JSON leves. Sem necessidade de After Effects — construa animações inteiramente em código.
Visão Geral
- Formato: Lottie JSON (padrão aberto)
- Repositório do Player: github.com/LottieFiles/lottie-player
- Repositório do Editor: github.com/marciogranzotto/lottie-tools (editor web de código aberto)
- Licença: MIT
- Instalação:
npm install lottie-webounpm install @lottiefiles/lottie-player
O que é Lottie?
Lottie é um formato de animação baseado em JSON. As animações são descritas como propriedades com keyframes em um arquivo JSON estruturado. Elas renderizam em qualquer resolução (baseadas em vetores), têm tamanho de arquivo pequeno e funcionam nativamente em web, iOS, Android e React Native.
Estrutura JSON do Lottie
{
"v": "5.7.1", // Versão do Lottie
"fr": 30, // Taxa de quadros
"ip": 0, // Ponto de início (quadro inicial)
"op": 60, // Ponto de fim (quadro final) — 2 segundos a 30 fps
"w": 400, // Largura
"h": 400, // Altura
"assets": [], // Recursos externos (imagens, pré-composições)
"layers": [ // Camadas da animação (de baixo para cima)
{
"ty": 4, // Camada de forma
"nm": "Círculo", // Nome da camada
"ip": 0,
"op": 60,
"st": 0, // Tempo de início
"ks": { // Propriedades de transformação
"o": { "a": 0, "k": 100 }, // Opacidade (estática)
"r": { "a": 0, "k": 0 }, // Rotação
"p": { // Posição (animada)
"a": 1, // a=1 significa animado
"k": [
{ "t": 0, "s": [200, 300], "e": [200, 100], "i": {"x": 0.5, "y": 1}, "o": {"x": 0.5, "y": 0} },
{ "t": 30, "s": [200, 100] }
]
},
"s": { "a": 0, "k": [100, 100] } // Escala
},
"shapes": [...] // Definições de formas
}
]
}
Tipos de Camada
| ty | Tipo | Descrição |
|---|---|---|
| 0 | Precomp | Composição aninhada |
| 1 | Solid | Camada de cor sólida |
| 2 | Image | Camada de imagem |
| 3 | Null | Pai de transformação vazio |
| 4 | Shape | Formas vetoriais (mais comum) |
| 5 | Text | Camada de texto |
Tipos de Forma
| ty | Forma |
|---|---|
| "rc" | Retângulo |
| "el" | Elipse |
| "sr" | Estrela/Polígono |
| "sh" | Caminho (bezier) |
| "fl" | Preenchimento |
| "st" | Contorno |
| "gf" | Preenchimento gradiente |
| "gs" | Contorno gradiente |
| "tr" | Transformação |
| "gr" | Grupo |
Construindo Animações em Código
Círculo com Fade-In Simples
{
"v": "5.7.1",
"fr": 30,
"ip": 0,
"op": 30,
"w": 200,
"h": 200,
"layers": [{
"ty": 4,
"nm": "circulo",
"ip": 0,
"op": 30,
"st": 0,
"ks": {
"o": {
"a": 1,
"k": [
{"t": 0, "s": [0], "e": [100], "i": {"x": [0.4], "y": [1]}, "o": {"x": [0.6], "y": [0]}},
{"t": 20, "s": [100]}
]
},
"r": {"a": 0, "k": 0},
"p": {"a": 0, "k": [100, 100]},
"s": {
"a": 1,
"k": [
{"t": 0, "s": [0, 0], "e": [100, 100], "i": {"x": [0.2, 0.2], "y": [1, 1]}, "o": {"x": [0.8, 0.8], "y": [0, 0]}},
{"t": 25, "s": [100, 100]}
]
}
},
"shapes": [
{
"ty": "gr",
"it": [
{"ty": "el", "p": {"a": 0, "k": [0, 0]}, "s": {"a": 0, "k": [80, 80]}},
{"ty": "fl", "c": {"a": 0, "k": [0.2, 0.5, 1, 1]}, "o": {"a": 0, "k": 100}},
{"ty": "tr", "p": {"a": 0, "k": [0, 0]}, "s": {"a": 0, "k": [100, 100]}}
]
}
]
}]
}
Suavização (Easing) de Keyframes
// Ease in-out (suave)
"i": {"x": [0.42], "y": [1]},
"o": {"x": [0.58], "y": [0]}
// Ease out (desaceleração)
"i": {"x": [0.0], "y": [1]},
"o": {"x": [0.6], "y": [0]}
// Ease in (aceleração)
"i": {"x": [0.4], "y": [1]},
"o": {"x": [1.0], "y": [0]}
// Linear
"i": {"x": [1], "y": [1]},
"o": {"x": [0], "y": [0]}
Geração Programática com JavaScript
function criarAnimacaoLottie({ largura, altura, fps, quadrosDuracao, camadas }) {
return {
v: "5.7.1",
fr: fps,
ip: 0,
op: quadrosDuracao,
w: largura,
h: altura,
assets: [],
layers: camadas,
};
}
function criarCamadaDeForma({ nome, quadroInicio, quadroFim, formas, transformacao }) {
return {
ty: 4,
nm: nome,
ip: quadroInicio,
op: quadroFim,
st: quadroInicio,
ks: transformacao,
shapes: formas,
};
}
// Gerar e salvar
const animacao = criarAnimacaoLottie({
largura: 400, altura: 400, fps: 30, quadrosDuracao: 60,
camadas: [/* ... */],
});
const fs = require("fs");
fs.writeFileSync("animacao.json", JSON.stringify(animacao, null, 2));
Reproduzindo Lottie na Web
<!-- Via CDN -->
<script src="https://unpkg.com/@lottiefiles/lottie-player@latest/dist/lottie-player.js"></script>
<lottie-player src="animacao.json" background="transparent" speed="1" loop autoplay></lottie-player>
// Via npm
import lottie from "lottie-web";
const anim = lottie.loadAnimation({
container: document.getElementById("lottie"),
renderer: "svg",
loop: true,
autoplay: true,
animationData: require("./animacao.json"),
});
Usando Lottie no Remotion
import { Lottie } from "@remotion/lottie";
import animationData from "./animacao.json";
export const MinhaCena: React.FC = () => {
return <Lottie animationData={animationData} />;
};
Instalação: npm install @remotion/lottie
Melhores Práticas
- Mantenha simples — Menos camadas = arquivo menor, melhor desempenho
- Use camadas de forma em vez de camadas de imagem quando possível (vetor = nítido em qualquer tamanho)
- Suavize keyframes — Nunca use easing linear para movimento orgânico
- 30fps é o padrão para animações Lottie na web
- Menos de 2 segundos para microinterações, 3-5 segundos para logotipos
- Teste com lottie-player — Visualize antes de incorporar
- Otimize — Remova propriedades não utilizadas, minimize a precisão dos números
Fonte da Skill do Agente
- Wiggle (skill de animação de logotipo): github.com/talknerdytome-labs/wiggle-claude-skill
- Lottie Tools (editor): github.com/marciogranzotto/lottie-tools
- OmniLottie (geração por IA): github.com/OpenVGLab/OmniLottie