Sim, 66% mais rápidos.
Não no sentido de "todas as telas do seu app renderizam 66% mais rápido". Se fosse isso, ninguém mais ia conseguir conversar comigo.
E sim, eu sei que isso soa engraçado em 2026.
Estamos na era em que as notícias de IA mudam a cada cinco minutos. O Claude Fable 5 foi lançado e suspenso poucos dias depois. As pessoas estão discutindo modelos quase AGI, agentes, apps inteiros sendo gerados e qualquer que seja o próximo benchmark absurdo.
E eu aqui, empolgado com o flattening de styles do React Native.
Justo.
Mas eu ainda amo esse tipo de trabalho. Talvez não seja uma "invenção" no sentido dramático de trailer de filme, mas deixar um caminho compartilhado de um framework mais barato continua sendo uma contribuição real. Muitos apps rodam em cima desses pequenos caminhos internos. Quando um deles fica mais simples e mais rápido, isso continua sendo motivo de alegria.
Este aqui é sobre um caminho compartilhado bem específico do React Native: o flattening de arrays de styles aninhados. O benchmark mostra que esse caminho ficou bem mais barato, e como o flattening de styles é usado em muitos lugares, vale a pena se importar com isso.
Tudo começou com uma coisa bem normal do React Native: styles.
Todo desenvolvedor React Native já escreveu algo assim:
<View style={[styles.container, isActive && styles.active]} />
Nada de especial. Só o dia a dia.
Aí você cria componentes reutilizáveis, passa styles por props, junta styles internos com styles externos e, de repente, a sua prop style não é mais só um array. Ela pode virar um array dentro de outro array, às vezes com mais de um nível de profundidade.
Basicamente:
Você começa com um array de styles limpinho.
Três componentes depois, parece uma mala que alguém fechou sentando em cima.
Contribuí com uma melhoria de performance para o react/react-native, que foi mergeada como o PR #57203. Ela melhora a forma como o React Native lida com arrays de styles aninhados no flattenStyle.
O comportamento continua o mesmo. A diferença é que o React Native evita criar objetos intermediários extras ao fazer o flattening de arrays aninhados.
Por que o flattenStyle importa
À primeira vista, o flattenStyle pode parecer um helper pequeno.
Você pode achar que ele só importa quando alguém chama StyleSheet.flatten manualmente.
Mas o React Native também usa esse caminho internamente. Então ele pode aparecer em lugares como:
TextImageImageBackgroundTextInputTouchableOpacityScrollViewAnimated.ScrollView- props animadas
- instâncias públicas do Fabric
- ferramentas de desenvolvimento, como o element inspector e a resolução de styles do React DevTools
Então, se um array de styles aninhado chega a esses caminhos, melhorar o flattenStyle significa que o React Native faz menos trabalho.
Observação importante: isso não significa que todas as telas de todos os apps ficam 66% mais rápidas.
Seria ótimo. Eu imprimiria o benchmark e colocaria num quadro.
A melhoria é especificamente para o flattening de arrays de styles aninhados. Mesmo assim, é um caminho compartilhado, e caminhos compartilhados são exatamente onde pequenas melhorias internas podem fazer diferença.
Como os styles aninhados acontecem
Aqui vai um exemplo simples:
<View
style={[
styles.container,
[styles.spacing, isActive && styles.active],
props.style,
]}
/>
Esse tipo de coisa acontece naturalmente em componentes de design system.
Um componente adiciona os styles base. Outro adiciona espaçamento. Outro repassa props.style. Talvez um desses valores já seja um array.
Ninguém acorda e diz: "Hoje vou criar arrays de styles aninhados."
Simplesmente acontece.
Aí o React Native precisa normalizar tudo em um único objeto.
Esse é o trabalho do flattenStyle.
A abordagem antiga
Antes da mudança, os arrays de styles aninhados passavam por flattening de forma recursiva.
Parece tranquilo, e funcionava corretamente.
O problema era que arrays aninhados podiam criar objetos temporários já achatados. Depois o React Native precisava juntar esses objetos temporários no resultado final.
A versão simplificada era assim:
const flattened = flattenStyle(style[i]);
if (flattened != null) {
for (const key in flattened) {
result[key] = flattened[key];
}
}
Então, para arrays aninhados, o React Native podia fazer alocações extras e depois cópias extras.
Mesmo resultado, mais trabalho.
É como imprimir um documento, escanear e depois mandar o scan por e-mail para você mesmo.
Tecnicamente funciona.
Emocionalmente, não.

A mudança
A nova implementação percorre os arrays aninhados escrevendo diretamente em um único objeto de resultado.
Em vez de achatar um array aninhado em um objeto temporário e depois copiar esse objeto de novo, o passo recursivo escreve no mesmo objeto de resultado.
O comportamento importante continua igual:
- styles em objeto continuam funcionando
- valores falsy continuam sendo ignorados
- arrays aninhados continuam funcionando
- styles posteriores continuam sobrescrevendo os anteriores
Esse último ponto importa muito.
A ordem dos styles faz parte da API do React Native. Isto aqui precisa continuar funcionando exatamente como os desenvolvedores esperam:
<View style={[styles.base, styles.override]} />
Se os dois styles definem a mesma chave, styles.override precisa vencer.
Performance é ótima, mas não se ela mudar silenciosamente o comportamento dos styles. Esse seria o pior tipo de "otimização".
Um exemplo rápido
Pegue esta estrutura de styles:
[
{color: "red", margin: 4},
[
{color: "blue"},
[{padding: 8}],
],
]
O resultado final deve ser:
{
color: "blue",
margin: 4,
padding: 8,
}
A implementação antiga podia criar objetos temporários ao resolver os arrays aninhados.
A nova implementação chega ao mesmo resultado escrevendo em um único objeto.
Mesma saída.
Menos trabalho.
Essa é a ideia toda.
Resultados do benchmark
Criei um pequeno projeto de benchmark fora do repositório do React Native para comparar a implementação antiga e a nova de forma isolada:
tarikfp/rn-style-flatten-benchmark
Estes foram os resultados do PR:
| Cenário | Antes | Depois | Mudança |
|---|---|---|---|
| array de style único aninhado | 294.79 ms | 98.73 ms | 66.5% mais rápido |
| array de styles mesclados aninhado | 278.54 ms | 122.06 ms | 56.2% mais rápido |
Os números ficam abaixo de 1 segundo, então milissegundos são mais fáceis de ler aqui.
De novo: este benchmark mede o trabalho do flattenStyle em arrays de styles aninhados. Ele não afirma que a renderização de um app inteiro fica 66% mais rápida.
Essa distinção importa.
Benchmarks são úteis, mas só quando são honestos sobre o que medem.
Validação
A contribuição incluiu testes unitários focados no flattenStyle.
Os testes cobrem o comportamento que não deveria mudar:
- styles em objeto
- entradas falsy
- arrays de styles aninhados
- ordem de sobrescrita
O app de benchmark também tinha as suas próprias verificações:
yarn test
yarn lint
yarn workspace style-flatten-benchmark-app tsc --noEmit
yarn bench:compare
E o comando de testes do React Native foi:
yarn test packages/react-native/Libraries/StyleSheet/__tests__/flattenStyle-test.js --runInBand
O app de benchmark também foi buildado e instalado no simulador iOS.
Considerações finais
Esse é o tipo de mudança que eu gosto em código de framework.
Os desenvolvedores não precisam aprender uma API nova. Não precisam reescrever componentes. Não precisam adicionar alguma prop mágica e torcer pelo melhor.
O React Native simplesmente faz menos trabalho em um caso que já existe em apps reais.
Sem mudança de comportamento.
Sem migração.
Sem drama.
Só menos objetos temporários em um caminho compartilhado.
Às vezes, a vitória é só isso.