Sim, você leu certo: 8000x mais rápidas.
Não no sentido de "o seu app inteiro agora é 8000x mais rápido, vai comprar um iate". Infelizmente.
E sim, eu sei que o timing é engraçado.
Vivemos uma era em que as notícias de IA andam tão rápido que algo como o Claude Fable 5 pode ser lançado e suspenso poucos dias depois. As pessoas estão discutindo modelos quase AGI, controles de exportação, agentes fazendo projetos inteiros, tudo isso.
E aqui estou eu falando sobre deixar listas do React Native mais rápidas.
Parece meio estranho quando você coloca essas duas coisas lado a lado. Eu entendo.
Mas ainda acho esse tipo de trabalho empolgante. Talvez "invenção" seja uma palavra grande demais, mas melhorar um framework usado por milhares de apps ainda tem significado para mim. Nem toda coisa útil precisa parecer ficção científica. Às vezes é só remover trabalho desperdiçado de um caminho por onde quase todo app mobile passa.
O ganho está em um caminho específico das listas do React Native: o trabalho da render window que decide quais células devem existir neste momento. Naquele benchmark, o caminho antigo podia desperdiçar segundos em listas enormes, e o novo caminho reduz isso para poucos milissegundos.
Na maior parte do tempo, estamos do lado do app. Usamos FlatList, SectionList, navegação, animações, bibliotecas de state e todas as coisas de sempre. Reclamamos da performance, testamos algumas props, adicionamos memo, talvez getItemLayout, e seguimos a vida.
Mas às vezes o problema real está uma camada abaixo do código do app.
Foi o que aconteceu aqui.
Contribuí com uma melhoria de performance para o react/react-native, que foi mergeada como o PR #57210. A mudança remove trabalho desnecessário de busca por sticky headers do caminho de criação da render mask usado pela VirtualizedList.
Em palavras normais: o React Native às vezes procurava sticky headers mesmo quando a lista não tinha nenhum sticky header.
Momento clássico de computador.
Lista: "Não tenho sticky headers."
React Native: "Beleza, deixa eu percorrer tudo de trás para frente para achar um."
A parte boa é que esse caminho é compartilhado. Então a melhoria afeta:
VirtualizedListFlatListVirtualizedSectionListSectionList
E sim, o uso normal de FlatList pode se beneficiar mesmo que você não use sticky headers.
O que isso melhora de fato
Antes de entrar no código, vale dizer de que tipo de performance estamos falando.
A melhoria está no trabalho em JavaScript que o React Native faz antes de decidir quais linhas devem ser renderizadas.
A FlatList mantém uma render window. Enquanto você rola, pula, monta perto de um índice inicial ou se move por uma lista grande, o React Native precisa decidir quais células devem ser renderizadas e quais partes podem ficar como espaçadores.
Essa decisão passa por VirtualizedList._createRenderMask.
Então o ganho é:
- menos trabalho em JS durante as atualizações da janela da lista
- menos trabalho ao pular para perto do fim de uma lista enorme
- menos lógica desnecessária de sticky headers em listas sem sticky headers
- decisões mais rápidas antes de a lista atualizar o que deve aparecer na tela
Em termos de app, isso ajuda a parte da FlatList que decide "quais linhas devem existir agora?".
Em listas muito grandes, principalmente perto do fim, essa pequena decisão interna pode virar um custo real.
Remover esse custo deixa o caminho de atualização da render window muito mais barato.
O que eu percebi
A FlatList é um daqueles componentes que quase todo app React Native usa em algum momento.
Por fora, parece simples:
<FlatList data={items} renderItem={renderItem} />
Mas, por baixo dos panos, ela passa pela VirtualizedList.
A VirtualizedList não renderiza a fonte de dados inteira. Se você tem 100 mil linhas, ela não coloca 100 mil linhas na tela como um soldado corajoso, mas condenado. Ela mantém uma render window e usa uma render mask para decidir quais células devem existir agora.
Isso é bom.
O problema estava dentro da etapa de criação da render mask.
O React Native também suporta sticky headers. Sticky headers são especiais porque o item fixo pode estar fora da viewport normal, mas ainda precisa continuar renderizado, já que visualmente ele fica preso no topo.
Então o React Native precisa de uma lógica assim:
"Encontre o sticky header mais próximo antes da viewport e mantenha ele renderizado."
Essa lógica está correta.
A parte chata era que a busca ainda podia rodar quando não havia sticky headers.
O caminho antigo
Antes dessa mudança, VirtualizedList._createRenderMask criava um set a partir de stickyHeaderIndices e chamava o helper de sticky headers.
A versão simplificada era assim:
const stickyIndicesSet = new Set(props.stickyHeaderIndices);
VirtualizedList._ensureClosestStickyHeader(
props,
stickyIndicesSet,
renderMask,
cellsAroundViewport.first,
);
Depois, o helper percorria a lista de trás para frente a partir da primeira célula visível:
for (let itemIdx = cellIdx - 1; itemIdx >= 0; itemIdx--) {
if (stickyIndicesSet.has(itemIdx + stickyOffset)) {
renderMask.addCells({first: itemIdx, last: itemIdx});
break;
}
}
Em uma lista pequena, tanto faz.
Em uma lista muito grande, vira um sofrimento. Se a viewport está perto do fim de uma lista de 1 milhão de linhas e não há sticky headers, o helper ainda pode percorrer de trás para frente quase a lista inteira.
Basicamente, é fazer uma busca enorme para não achar nada.
Não é o meu hobby favorito.

Por que a FlatList é afetada
Essa parte passa despercebida com facilidade.
Você não precisa usar a VirtualizedList diretamente. A FlatList é construída em cima dela.
Então este tipo de código:
<FlatList
data={bigData}
renderItem={renderItem}
/>
continua passando por VirtualizedList._createRenderMask.
Antes da mudança, uma lista normal sem stickyHeaderIndices ainda podia pagar pelo trabalho de busca de sticky headers.
Depois da mudança, o React Native verifica se os sticky headers realmente existem antes de fazer qualquer trabalho com eles.
Tecnologia muito avançada: verificar se a coisa existe antes de procurar por ela.
A mudança
A primeira parte é a mais importante para o uso normal de FlatList sem sticky headers.
const stickyHeaderIndices = props.stickyHeaderIndices;
if (stickyHeaderIndices != null && stickyHeaderIndices.length > 0) {
VirtualizedList._ensureClosestStickyHeader(
props,
stickyHeaderIndices,
renderMask,
cellsAroundViewport.first,
);
}
Se não há sticky headers, pulamos o helper.
A segunda parte também melhora o caso com sticky headers.
Em vez de percorrer os índices dos itens de trás para frente, o helper varre os índices de sticky headers configurados e encontra o sticky header válido mais próximo antes da viewport.
const stickyOffset = props.ListHeaderComponent ? 1 : 0;
const targetStickyIndex = cellIdx + stickyOffset;
let closestStickyIndex = null;
for (let itemIdx = 0; itemIdx < stickyHeaderIndices.length; itemIdx++) {
const stickyIndex = stickyHeaderIndices[itemIdx];
if (
Number.isInteger(stickyIndex) &&
stickyIndex < targetStickyIndex &&
stickyIndex >= stickyOffset &&
(closestStickyIndex == null || stickyIndex > closestStickyIndex)
) {
closestStickyIndex = stickyIndex;
}
}
if (closestStickyIndex != null) {
const itemIdx = closestStickyIndex - stickyOffset;
renderMask.addCells({first: itemIdx, last: itemIdx});
}
Então o custo muda de:
"Quão longe estamos do começo da lista?"
para:
"Quantos sticky headers estão configurados?"
Essa é uma pergunta muito melhor de se fazer.
Mantendo o comportamento igual
É esta parte que faz pequenas mudanças em frameworks serem menos pequenas do que parecem.
Você não pode simplesmente otimizar e torcer para tudo dar certo. stickyHeaderIndices pode estar fora de ordem. Pode ter valores duplicados. Pode ter valores inválidos. Pode existir um ListHeaderComponent, que desloca o índice em um.
Tudo isso ainda precisa funcionar.
Os testes cobrem casos como:
- sem
stickyHeaderIndices stickyHeaderIndicesvazio- índices de sticky fora de ordem
- índices de sticky duplicados
- valores negativos
- valores fracionários
- valores depois da viewport
- tratamento do deslocamento do
ListHeaderComponent
Esse último é importante. Os índices de sticky headers se baseiam nos índices dos filhos da ScrollView por baixo. Quando existe um header de lista, o item de índice 0 não é mais o filho de índice 0.
Pequenos bugs de off-by-one adoram essa área. Eles moram lá de graça.
Resultados do benchmark
Fiz o benchmark do caminho VirtualizedList._createRenderMask diretamente com o Fantom Hermes, usando 100 amostras por caso.
Esse benchmark foca no trabalho de decisão da render window dentro da VirtualizedList.
Então não, isso não significa que toda FlatList de todo app de repente rola 8000x mais rápido. Quem me dera. Eu já estaria insuportável com isso.
Significa que esse caminho interno específico de janelamento da lista ficou muito mais barato. E quando o benchmark sai de segundos de trabalho desperdiçado para poucos milissegundos, isso continua sendo uma vitória bem real.
Prova no simulador
Também criei um pequeno app React Native bare para comparar as duas implementações no iOS Simulator.
Mesmo app. Mesma FlatList com 1m de linhas. Mesmo setup no sticky headers.
A única diferença é a implementação de VirtualizedList instalada. Estas são gravações reais do simulador dentro das molduras de celular, não screenshots estáticos de mockup. Deixei os controles de vídeo visíveis de propósito, e o pulso do cursor marca o toque no botão do benchmark.
O benchmark e os testes de comportamento também estão no PR mergeado do React Native:
Na demo do simulador, o caminho antigo cresce com o tamanho da lista. Para 1.000 atualizações da render window, fica assim:
50k rows: cerca de1.92 sno total (1.9196 ms / call)500k rows: cerca de18.78 sno total (18.78 ms / call)1m rows: cerca de38.40 sno total (38.40 ms / call)
Com o caminho otimizado, a mesma demo fica praticamente estável:
50k rows: cerca de3.74 msno total (0.0037 ms / call)500k rows: cerca de3.67 msno total (0.0037 ms / call)1m rows: cerca de3.73 msno total (0.0037 ms / call)
Os valores por chamada ficam abaixo de 1 segundo, então aparecem em milissegundos. Para 1.000 atualizações da render mask, os valores acima de 1 segundo aparecem em segundos.
| Caso | Uma atualização antes | Uma atualização depois | Ganho | 1.000 atualizações antes | 1.000 atualizações depois |
|---|---|---|---|---|---|
| 100k linhas, sem sticky headers | 2.664 ms | 0.0034 ms | 780x | 2.66 s | 3.42 ms |
| 100k linhas, sticky headers vazio | 2.632 ms | 0.0033 ms | 800x | 2.63 s | 3.29 ms |
| 100k linhas, um sticky header no topo | 2.705 ms | 0.0054 ms | 499x | 2.71 s | 5.42 ms |
| 250k linhas, sem sticky headers | 6.543 ms | 0.0035 ms | 1,892x | 6.54 s | 3.46 ms |
| 250k linhas, sticky headers vazio | 6.579 ms | 0.0033 ms | 2,024x | 6.58 s | 3.25 ms |
| 250k linhas, um sticky header no topo | 6.796 ms | 0.0053 ms | 1,294x | 6.80 s | 5.25 ms |
| 500k linhas, sem sticky headers | 13.173 ms | 0.0033 ms | 4,002x | 13.17 s | 3.29 ms |
| 500k linhas, sticky headers vazio | 13.073 ms | 0.0033 ms | 3,997x | 13.07 s | 3.27 ms |
| 500k linhas, um sticky header no topo | 13.444 ms | 0.0054 ms | 2,511x | 13.44 s | 5.35 ms |
| 750k linhas, sem sticky headers | 19.524 ms | 0.0033 ms | 6,008x | 19.52 s | 3.25 ms |
| 750k linhas, sticky headers vazio | 19.572 ms | 0.0033 ms | 6,022x | 19.57 s | 3.25 ms |
| 750k linhas, um sticky header no topo | 20.304 ms | 0.0054 ms | 3,778x | 20.30 s | 5.37 ms |
| 1m linhas, sem sticky headers | 26.190 ms | 0.0033 ms | 8,058x | 26.19 s | 3.25 ms |
| 1m linhas, sticky headers vazio | 26.039 ms | 0.0033 ms | 8,012x | 26.04 s | 3.25 ms |
| 1m linhas, um sticky header no topo | 26.855 ms | 0.0053 ms | 5,075x | 26.86 s | 5.29 ms |
A coluna de 1.000 atualizações deixa a diferença mais fácil de sentir.
Com 1 milhão de linhas, o caminho antigo sem sticky headers gasta cerca de 26 segundos nesse helper para 1.000 atualizações da render mask.
Depois da mudança, o mesmo caso fica em torno de 3.25 ms.
É tempo removido de um caminho compartilhado das listas antes de o React Native decidir quais células devem ser renderizadas.
Plano de testes
Eu queria que isso fosse entediante no melhor sentido: mesmo comportamento, menos trabalho.
Então a contribuição incluiu testes de comportamento e cobertura de benchmark.
Os principais comandos foram:
yarn jest packages/virtualized-lists/Lists/__tests__/VirtualizedList-test.js packages/virtualized-lists/Lists/__tests__/VirtualizedSectionList-test.js packages/react-native/Libraries/Lists/__tests__/FlatList-test.js --runInBand
yarn fantom packages/react-native/Libraries/Lists/__tests__/FlatList-itest.js packages/react-native/Libraries/Lists/__tests__/SectionList-itest.js --runInBand
yarn flow check
yarn fantom --benchmarks packages/react-native/Libraries/Lists/__tests__/VirtualizedList-stickyHeaders-benchmark-itest.js --runInBand
O PR alterou três arquivos:
- a implementação da
VirtualizedList - testes focados da
VirtualizedList - um benchmark Fantom para o caminho da render mask com sticky headers
Ele foi importado pelo processo da Meta e mergeado no react/react-native.
Considerações finais
O que eu gosto nessa contribuição é que os desenvolvedores de apps não precisam fazer nada.
Nenhuma prop nova.
Nenhuma migração.
Nenhuma gambiarra.
Se um app usa uma FlatList grande sem sticky headers, o React Native agora consegue evitar um trabalho de busca de sticky headers que nunca foi necessário.
Esse é o meu tipo favorito de melhoria em framework.
Pouca superfície. Benchmark claro. Nenhuma mudança de API.
E um caminho comum fica mais barato para todo mundo.