Blog

Deixei as listas do React Native 8000x mais rápidas

20 de junho de 2026 9 min de leitura

Como o meu PR mergeado no React Native deixou o trabalho da render window da FlatList e da VirtualizedList até 8000x mais rápido.

Deixei as listas do React Native 8000x mais rápidas
React NativeFlatListVirtualizedListPerformanceOpen Source

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.

Linha do tempo do GitHub mostrando o pull request de performance da FlatList mergeado no React Native
Mergeado no React Native. Ainda parece meio irreal.

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:

  • VirtualizedList
  • FlatList
  • VirtualizedSectionList
  • SectionList

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
  • stickyHeaderIndices vazio
  • í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:

Antes
▶ vídeo do simulador
Depois
▶ vídeo do simulador

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 de 1.92 s no total (1.9196 ms / call)
  • 500k rows: cerca de 18.78 s no total (18.78 ms / call)
  • 1m rows: cerca de 38.40 s no total (38.40 ms / call)

Com o caminho otimizado, a mesma demo fica praticamente estável:

  • 50k rows: cerca de 3.74 ms no total (0.0037 ms / call)
  • 500k rows: cerca de 3.67 ms no total (0.0037 ms / call)
  • 1m rows: cerca de 3.73 ms no 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.

CasoUma atualização antesUma atualização depoisGanho1.000 atualizações antes1.000 atualizações depois
100k linhas, sem sticky headers2.664 ms0.0034 ms780x2.66 s3.42 ms
100k linhas, sticky headers vazio2.632 ms0.0033 ms800x2.63 s3.29 ms
100k linhas, um sticky header no topo2.705 ms0.0054 ms499x2.71 s5.42 ms
250k linhas, sem sticky headers6.543 ms0.0035 ms1,892x6.54 s3.46 ms
250k linhas, sticky headers vazio6.579 ms0.0033 ms2,024x6.58 s3.25 ms
250k linhas, um sticky header no topo6.796 ms0.0053 ms1,294x6.80 s5.25 ms
500k linhas, sem sticky headers13.173 ms0.0033 ms4,002x13.17 s3.29 ms
500k linhas, sticky headers vazio13.073 ms0.0033 ms3,997x13.07 s3.27 ms
500k linhas, um sticky header no topo13.444 ms0.0054 ms2,511x13.44 s5.35 ms
750k linhas, sem sticky headers19.524 ms0.0033 ms6,008x19.52 s3.25 ms
750k linhas, sticky headers vazio19.572 ms0.0033 ms6,022x19.57 s3.25 ms
750k linhas, um sticky header no topo20.304 ms0.0054 ms3,778x20.30 s5.37 ms
1m linhas, sem sticky headers26.190 ms0.0033 ms8,058x26.19 s3.25 ms
1m linhas, sticky headers vazio26.039 ms0.0033 ms8,012x26.04 s3.25 ms
1m linhas, um sticky header no topo26.855 ms0.0053 ms5,075x26.86 s5.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.