Home / Uncategorized / CSS random(): como funciona a função nativa de randomização que chegou no Chrome 156

CSS random(): como funciona a função nativa de randomização que chegou no Chrome 156

Em 20 de outubro de 2026 o Chrome 156 entrou no canal estável trazendo a função random() nativa de CSS. O Google anunciou que o Chrome 156 foi liberado no canal estável, cobrindo 353 correções de segurança e introduzindo a função CSS random() para desenvolvedores. O Safari já havia enviado antes, e há sinais positivos da Mozilla para o Firefox. A referência de uso prático mais completa publicada até agora é o artigo de Brecht De Ruyte na Smashing Magazine, do dia anterior ao release.

Este texto não é opinião sobre se randomness pertence a sistemas de design. É uma leitura técnica de como a função resolve valores, onde você vai encostar em comportamento inesperado, e o que a especificação diz que o artigo de divulgação não deixa claro.

Como a função resolve valores

A random() é uma math function que representa um valor aleatório entre um mínimo e um máximo, extraído de uma distribuição uniforme, opcionalmente limitando os valores possíveis a um passo entre esses limites. A assinatura formal, direto do draft do CSSWG, é:

<random()> = random( <random-caching-options>?, <calc-sum>, <calc-sum>, [by <calc-sum>]? )

<random-caching-options> = <dashed-ident> || per-element

Na prática você escreve argumentos separados por vírgula, mínimo e máximo obrigatórios, passo opcional:

/* angulo entre -3deg e 3deg, continuo */
rotate: random(-3deg, 3deg);

/* largura entre 20px e 80px em degraus de 10px */
inline-size: random(20px, 80px, 10px);

Dois detalhes do mecanismo que o leitor que vai implementar precisa saber.

Passo não é arredondamento

É tentador ler random(100px, 200px, 50px) como “sorteia um número e depois arredonda”. Não é. Fornecer um valor de passo não equivale a gerar um valor aleatório e depois arredondar; random(100px, 200px, 50px) gera três valores possíveis (100px, 150px, 200px) todos com chance de 1/3, enquanto round(random(100px, 200px), 50px) gera uma distribuição diferente, com os extremos pesando menos. Se você precisa de distribuição uniforme sobre um conjunto discreto, use o passo. Se precisa de distribuição contínua com uma precisão depois, componha com round().

Nota lateral: o valor máximo pode não aparecer como resultado possível; em random(100px, 200px, 30px), os valores possíveis são 100px, 130px, 160px e 190px. O passo manda, não o teto.

Cada chamada é uma loteria independente, por padrão

Esse é o ponto que mais confunde. Toda vez que você escreve random(), por padrão, é uma amostragem independente. Dois random() no mesmo elemento resolvem para números diferentes. O mesmo random() em cem elementos resolve para o mesmo número, não para cem números.

É invertido do que a intuição sugere. Explica assim: imagine que o navegador tem um dicionário de valores sorteados, chaveado pelo texto literal da chamada. Se você escreve random(0px, 100px) duas vezes, são duas entradas separadas no dicionário, com valores diferentes. Mas se você escreve a mesma chamada em CSS que é aplicada a vários elementos, todos olham para a mesma entrada do dicionário, e todos recebem o mesmo valor. A analogia quebra quando você entra no cache por chave, porque aí a entrada do dicionário é apontada por nome explícito, não pela string da chamada.

É isso que o primeiro argumento, <random-caching-options>, controla. Fornecer um dashed-ident não faz nada por si só, mas torna as listas de argumentos distintas entre dois ou mais random() que seriam idênticos, para que gerem valores distintos. A palavra-chave per-element faz com que a função gere um valor diferente em cada elemento ao qual é aplicada, em vez de resolver para um único valor por uso na stylesheet.

Combinando: se você quer que largura e altura do mesmo card sejam iguais (quadrado), mas que cada card tenha seu próprio quadrado, você precisa dos dois: um dashed-ident em comum para sincronizar as duas propriedades, e per-element para variar entre elementos.

.card {
 /* mesma chave nos dois = largura == altura */
 /* per-element = cada .card tem seu proprio tamanho */
 inline-size: random(--size per-element, 60px, 120px);
 block-size: random(--size per-element, 60px, 120px);
}

Observação de versão: o artigo da Smashing usa element-scoped como palavra-chave. O draft atual do CSSWG usa per-element. Isso cheira a divergência entre especificação e implementação em transição. Antes de colar código em produção, teste qual das duas palavras-chave seu navegador alvo aceita hoje, e envolva o uso num @supports.

Unidades têm que bater

Todos os argumentos passados para random() precisam usar o mesmo tipo de unidade. Você não pode misturar rem com px ou % com em. Se você precisar misturar, embrulhe cada lado num calc() que resolva para o mesmo tipo final.

O que isso significa na prática

O ganho concreto não é “agora dá para fazer coisa aleatória”, porque isso já dava via JavaScript ou via loop em pré-processador. O ganho é tirar o JavaScript do caminho e tirar o CSS gerado inchado do bundle. A função nativa permite randomização por elemento avaliada pelo engine de renderização sem JavaScript, o que significa que o valor é sorteado no momento do style resolution, não depois de o DOM existir e um script rodar.

Consequência prática: zero flash de “tudo alinhado, depois pulou”. Em comparação com a abordagem de setar style="--jitter: 0.37" inline a partir de JS depois do mount, o resultado é instantâneo.

Um caso onde isso pesa de verdade: posicionar N elementos decorativos num hero (partículas, pontos, confete). O código fica assim:

.dot {
 position: absolute;
 top: random(0%, 100%);
 left: random(0%, 100%);
}

Esse snippet, basicamente o exemplo das release notes do próprio Chrome (web authors can use random() to scatter elements randomly within their container), substitui um loop Sass que cuspia cem regras :nth-child(n) ou um bloco de JavaScript que calculava top e left no load. É menos CSS para transferir, menos JavaScript para parsear, e a decisão vive onde a estilização vive.

Para situações onde a estética do produto pode absorver pequena variação, isso é liberdade real. Rodei durante anos teste A/B num fluxo de assinatura onde a mesma API, o mesmo backend, servia duas interfaces diferentes e a receita saía mensuravelmente diferente entre elas. A lição que fica é que microvariação visual, feita de propósito e medida, mexe no comportamento do usuário. Com random() dá para introduzir essa microvariação sem precisar subir uma camada de JavaScript só para isso. O que não significa que agora todo elemento deva ter jitter. Significa que o custo de experimentar com uma versão levemente “orgânica” caiu.

Onde quebra

Alvos interativos tortos são hostis. Se você rotaciona um botão em random(-3deg, 3deg) e não endireita no :hover e :focus-visible, você acabou de criar um alvo de clique que não é retângulo alinhado. Em touch, pior ainda. Botão não é polaroid. A regra simples: se um elemento recebe clique, teclado ou arrasto, ele não é candidato a jitter permanente. No máximo, jitter em repouso que zera na interação.

Preferência de movimento reduzido. Jitter angular, mesmo sem animação, causa desconforto para parte da base. Trate @media (prefers-reduced-motion: reduce) como obrigação, não enfeite, e nesse ramo zere o rotate também, não só a animação. Quem desligou movimento normalmente também não quer texto tortinho.

Acessibilidade de leitura letra por letra. Se você está animando ou randomizando por caractere, provavelmente está quebrando o texto em <span>. Leitor de tela vai soletrar. Solução: coloca aria-label com a palavra inteira no container e aria-hidden="true" no wrapper visual. Isso vale para qualquer efeito por letra, não é especificidade do random().

Suporte ainda em rollout. No momento desta publicação Safari enviou, Chrome está liberando o 156, Firefox ainda não. Isso quer dizer que todo uso tem que vir atrás de @supports, com baseline sem randomness para quem não suporta:

.badge { rotate: 0deg; }

@supports (rotate: random(-2deg, 2deg)) {
 .badge { rotate: random(-2.5deg, 2.5deg); }
}

Sistema de design que não impõe limite acaba vazando. Trabalhei num construtor de landing page que tirou a criação de página da fila da engenharia, com redução de mais de 70% no esforço de desenvolvimento por página. O preço de dar liberdade de montagem para quem não é dev é aceitar que vai sair página fora do design system, a menos que o próprio builder imponha o limite. random() tem o mesmo risco em escala menor: se você expõe a função como token livre, alguém vai colocar random(-45deg, 45deg) num card de dashboard. Encapsule em custom properties com faixas pré-aprovadas (--tilt-subtle, --tilt-playful) em vez de expor a chamada bruta.

O que ainda não dá para afirmar

Quando a semente muda. A spec diz que os valores precisam parecer independentes, mas o método exato para gerar o número aleatório é definido pelo UA; a correlação entre dois valores aleatórios distintos não deveria ser facilmente detectável, mas a especificação intencionalmente não especifica o que isso significa em termos de força criptográfica. Na prática: não assuma reprodutibilidade entre navegadores, nem entre versões do mesmo navegador. E não espere que o valor seja estável entre reloads sem intervenção explícita.

Interação com style containment e re-renderização. Não encontrei na documentação pública uma afirmação clara sobre quando exatamente o valor é recomputado: ao recalcular estilo, ao reaplicar a regra, ao reinserir o elemento no DOM. Isso provavelmente vai variar entre engines nas primeiras versões. Se seu caso depende do valor não mudar depois do primeiro paint, teste explicitamente.

random-item(). A irmã da random() que sorteia de uma lista de tokens (cores, keywords) está na spec mas não tem suporte de navegador ainda. Para sortear de uma paleta discreta hoje, continua sendo custom property setada via JavaScript ou classe aleatória no servidor.

Como testar isso você mesmo

Caminho mínimo, cinco minutos, Chrome 156 ou Safari recente:

  1. Crie um HTML com dez <div class="card"></div>, cada um com conteúdo de texto curto.
  2. Aplique este CSS:
    .card {
     display: inline-block;
     width: 160px; height: 100px;
     margin: 12px;
     background: #eee;
     rotate: random(-4deg, 4deg);
     transition: rotate .2s;
    }
    .card:hover { rotate: 0deg; }
  3. Recarregue a página algumas vezes. Confirme que os ângulos mudam entre reloads.
  4. Agora troque para rotate: random(--same, -4deg, 4deg); e observe que todos os cards rotacionam para o mesmo ângulo. Esse é o default do cache.
  5. Troque de novo para rotate: random(--same per-element, -4deg, 4deg); (ou element-scoped, dependendo da versão) e observe que voltam a variar entre cards, mas agora o nome --same pode ser reusado em outra propriedade do mesmo card para sincronizar com ela.

Esse é o experimento inteiro. Depois que você viu os quatro estados (independente, compartilhado global, compartilhado por elemento, compartilhado entre propriedades do mesmo elemento), você entendeu o mecanismo. O resto é escolher onde aplicar sem transformar o produto em feira de artesanato.

Deixe um Comentário

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