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

By Tarik Pinarci (https://tarikpinarci.com). Published 2026-06-20. Canonical: https://tarikpinarci.com/pt/blog/improving-flatlist-performance-in-react-native

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](https://www.anthropic.com/news/claude-fable-5-mythos-5). 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](https://github.com/react/react-native/pull/57210). A mudança remove trabalho desnecessário de busca por sticky headers do caminho de criação da render mask usado pela `VirtualizedList`.

<figure style="max-width:720px; margin:24px auto 30px;">
  <img
    src="/images/blog/react-native-merged-proof/flatlist-merged.jpg"
    alt="Linha do tempo do GitHub mostrando o pull request de performance da FlatList mergeado no React Native"
    style="width:100%; border-radius:14px; border:1px solid rgba(255,255,255,0.12);"
  />
  <figcaption style="margin-top:8px; text-align:center; font-size:0.9rem; color:#9ca3af;">Mergeado no React Native. Ainda parece meio irreal.</figcaption>
</figure>

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:

```tsx
<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:

```js
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:

```js
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.

![](https://media.giphy.com/media/FASybzL1ElrxpT2rTq/giphy.gif)

### 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:

```tsx
<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.

```js
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.

```js
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:

- [Teste de benchmark do Fantom](https://github.com/react/react-native/blob/6b3a15b2c0eca3647e4648d4b68bcccd4336d42f/packages/react-native/Libraries/Lists/__tests__/VirtualizedList-stickyHeaders-benchmark-itest.js)
- [Testes de comportamento da VirtualizedList](https://github.com/react/react-native/blob/6b3a15b2c0eca3647e4648d4b68bcccd4336d42f/packages/virtualized-lists/Lists/__tests__/VirtualizedList-test.js)
- [PR #57210 mergeado](https://github.com/react/react-native/pull/57210)

<div style="display:grid; grid-template-columns: repeat(auto-fit, minmax(260px, 1fr)); gap: 36px; margin: 32px 0 42px; align-items:start; perspective:1400px;">
  <figure style="margin:0; transform:rotateY(10deg) rotateX(3deg); transform-style:preserve-3d;">
    <figcaption style="font-weight:700; color:#fca5a5; margin-bottom:14px; text-align:center;">Antes</figcaption>
    <div style="position:relative; max-width:330px; margin:0 auto; aspect-ratio:985/2008; filter:drop-shadow(32px 34px 46px rgba(0,0,0,0.58));">
    <div style="position:absolute; z-index:3; left:10%; top:5.5%; padding:5px 9px; border-radius:999px; background:rgba(0,0,0,0.68); border:1px solid rgba(255,255,255,0.16); color:#f8fafc; font-size:0.72rem; font-weight:700; pointer-events:none;">▶ vídeo do simulador</div>
    <video
      data-autoplay="viewport"
      autoplay
      controls
      playsinline
      muted
      loop
      preload="metadata"
      style="position:absolute; left:5.19%; top:2.17%; width:89.93%; height:95.66%; border-radius:8.8%/4.1%; object-fit:cover; background:#05080f;"
      src="/videos/blog/flatlist-performance/before-release-simplified.mp4"
    >
      Seu navegador não suporta a tag de vídeo.
    </video>
    <div class="flatlist-video-cursor flatlist-video-cursor-before" aria-hidden="true"></div>
    <img
      src="/images/blog/device-frames/iphone-14-pro-black.png"
      alt=""
      loading="lazy"
      style="position:absolute; inset:0; width:100%; height:100%; pointer-events:none;"
    />
    </div>
  </figure>
  <figure style="margin:0; transform:rotateY(-10deg) rotateX(3deg); transform-style:preserve-3d;">
    <figcaption style="font-weight:700; color:#86efac; margin-bottom:14px; text-align:center;">Depois</figcaption>
    <div style="position:relative; max-width:330px; margin:0 auto; aspect-ratio:985/2008; filter:drop-shadow(-32px 34px 46px rgba(0,0,0,0.58));">
    <div style="position:absolute; z-index:3; left:10%; top:5.5%; padding:5px 9px; border-radius:999px; background:rgba(0,0,0,0.68); border:1px solid rgba(255,255,255,0.16); color:#f8fafc; font-size:0.72rem; font-weight:700; pointer-events:none;">▶ vídeo do simulador</div>
    <video
      data-autoplay="viewport"
      autoplay
      controls
      playsinline
      muted
      loop
      preload="metadata"
      style="position:absolute; left:5.19%; top:2.17%; width:89.93%; height:95.66%; border-radius:8.8%/4.1%; object-fit:cover; background:#05080f;"
      src="/videos/blog/flatlist-performance/after-release-simplified.mp4"
    >
      Seu navegador não suporta a tag de vídeo.
    </video>
    <div class="flatlist-video-cursor flatlist-video-cursor-after" aria-hidden="true"></div>
    <img
      src="/images/blog/device-frames/iphone-14-pro-black.png"
      alt=""
      loading="lazy"
      style="position:absolute; inset:0; width:100%; height:100%; pointer-events:none;"
    />
    </div>
  </figure>
</div>

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.

| 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:

```sh
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
```

```sh
yarn fantom packages/react-native/Libraries/Lists/__tests__/FlatList-itest.js packages/react-native/Libraries/Lists/__tests__/SectionList-itest.js --runInBand
```

```sh
yarn flow check
```

```sh
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.

