Home / Uncategorized / Usando animation-range-start para escalonar animações por scroll

Usando animation-range-start para escalonar animações por scroll

Este artigo aborda uma linha de CSS que resolve um problema frequentemente abordado em tutoriais com fórmulas extensas. O destaque não é apenas a propriedade em si, mas o que ela revela sobre a eficiência de utilizar recursos nativos do navegador.

O que aconteceu

Em 16 de novembro de 2026, Lee Meyer publicou no CSS-Tricks um artigo intitulado Staggering Scroll-Driven Animations with animation-range-start. Este artigo responde a uma proposta anterior do Master.dev, que sugeria uma fórmula genérica para escalonar animações baseadas em qualquer input de progresso, incluindo scroll. Meyer aponta que, para o caso de scroll, o CSS moderno já oferece uma ferramenta eficiente em uma única linha de código.

A propriedade em questão é animation-range-start, introduzida para atrasar animações baseadas em scroll conforme o progresso da rolagem, não do tempo. Antes dela, o uso de animation-delay em animações driven por scroll era ineficaz, pois animation-delay opera em unidades de tempo, enquanto a timeline aqui é definida por posição.

Como funciona por baixo

Scroll timeline não é tempo

Uma animação CSS tradicional opera com base em um relógio, avançando keyframes conforme o tempo passa. Em uma animação driven por scroll, esse relógio é substituído por uma régua que mede o quanto o usuário rolou na página ou quanto um elemento atravessou o viewport, com 0% sendo o início e 100% o fim.

Essa mudança invalida o uso de animation-delay em animações driven por scroll. Para isso, existe um par específico: animation-range, que é uma shorthand para animation-range-start e animation-range-end, aceitando porcentagens ou ranges nomeados como entry, contain, cover e exit.

Os ranges nomeados

Os ranges nomeados correspondem a fases da travessia de um elemento pelo viewport. entry é quando o elemento começa a aparecer; contain é quando está totalmente visível; exit é quando começa a desaparecer; e cover abrange do primeiro ao último pixel visível. A documentação do MDN explica que animation-range-start e animation-range-end aceitam um range nomeado, um valor de porcentagem, ou ambos combinados.

Por exemplo, animation-range-start: contain 25% significa que a animação começa quando o elemento já está contido no viewport e 25% desse período de contenção já passou.

Onde entra sibling-index()

Escalonar animações significa fazer cada item de uma lista começar um pouco depois do anterior. Em animações baseadas em tempo, isso é feito com animation-delay multiplicado pela posição do item. Em animações driven por scroll, é necessário calcular o equivalente em porcentagem de scroll e saber a posição de cada irmão.

A função sibling-index() é útil aqui, pois retorna a posição do elemento atual entre seus irmãos, começando em 1 para o primeiro filho. Isso permite calcular o escalonamento dentro de um calc() no CSS.

A solução de Meyer é:

animation-range-start: contain calc(10% + 2.5% * sibling-index());

Com isso, cada elemento começa sua animação em um ponto escalonado do scroll, sem necessidade de fórmulas complexas ou reinvenção de timelines.

O que isso significa na prática

Para ver isso em ação, crie um HTML com oito spans dentro de um container:

<p class="frase">
 <span>E</span><span>x</span><span>e</span><span>m</span><span>p</span><span>l</span><span>o</span><span>!</span>
</p>

E o CSS correspondente:

@keyframes aparece {
 from { opacity: 0; transform: translateY(0.4em); }
 to { opacity: 1; transform: translateY(0); }
}

.frase span {
 display: inline-block;
 opacity: 0;
 animation: aparece linear both;
 animation-timeline: view();
 animation-range-start: contain calc(10% + 2.5% * sibling-index());
 animation-range-end: contain calc(30% + 2.5% * sibling-index());
}

Note que animation-range-start deve ser declarado após qualquer shorthand animation para evitar resets indesejados.

Easing continua funcionando

Uma vantagem dessa abordagem é que ela preserva o uso de animation-timing-function, permitindo que cada elemento mantenha seu próprio easing, ao contrário de uma abordagem que unifica tudo em uma única timeline.

Onde isso quebra

Existem algumas limitações:

  • Suporte de navegador: sibling-index() ainda é recente, com suporte limitado a navegadores modernos. É necessário usar @supports e fornecer fallbacks para navegadores sem suporte.
  • Elementos escondidos: sibling-index() conta elementos escondidos, podendo afetar o escalonamento.
  • Shadow DOM: Problemas podem ocorrer ao usar sibling-index() com componentes em Shadow DOM.

O que não dá para afirmar ainda

A abordagem de Meyer é eficaz para animações driven por scroll, mas não substitui a fórmula genérica em casos onde o input de progresso não é scroll ou tempo. Além disso, a especificação ainda é um Editor’s Draft, o que significa que a implementação pode variar entre navegadores.

Como testar isso você mesmo

Para testar, use um navegador compatível como Chrome 138+ ou Safari 26.2+. Crie um HTML com uma lista de itens e aplique o CSS mostrado. Role a página para observar o escalonamento. Experimente alterar o valor de 2.5% e veja como isso afeta o timing das animações.

Considere usar a extensão de debug do Bramus para visualizar e ajustar animation-range-start e animation-range-end em tempo real. Sempre forneça um fallback estático ou baseado em tempo para navegadores sem suporte.

Deixe um Comentário

O seu endereço de e-mail não será publicado. Campos obrigatórios são marcados com *