# Ik maakte lijsten in React Native 8000 keer sneller

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

Ja, je leest het goed: 8000 keer sneller.

Niet "je hele app is nu 8000 keer sneller, ga maar een jacht kopen" sneller. Helaas.

En ja, ik weet dat de timing grappig is.

We leven in een tijd waarin AI-nieuws zo snel gaat dat iets als [Claude Fable 5 kan lanceren en een paar dagen later weer wordt opgeschort](https://www.anthropic.com/news/claude-fable-5-mythos-5). Mensen discussiëren over modellen die richting AGI gaan, over exportbeperkingen, over agents die complete projecten bouwen, noem maar op.

En hier zit ik dan te vertellen hoe ik lijsten in React Native sneller heb gemaakt.

Als je die twee dingen naast elkaar zet, klinkt dat een beetje vreemd. Dat snap ik.

Toch vind ik dit soort werk nog steeds spannend. Misschien is "uitvinding" een te groot woord, maar een framework verbeteren dat door duizenden apps wordt gebruikt, voelt voor mij nog altijd zinvol. Niet alles wat nuttig is, hoeft op sciencefiction te lijken. Soms gaat het gewoon om verspild werk weghalen uit een pad dat bijna elke mobiele app raakt.

De winst zit in één specifiek pad voor lijsten in React Native: het werk rond het render-venster, dat bepaalt welke cellen er op dit moment moeten bestaan. In die benchmark kon het oude pad bij enorme lijsten seconden verspillen, en het nieuwe pad brengt dat terug tot een paar milliseconden.

Meestal zitten we aan de kant van de app. We gebruiken `FlatList`, `SectionList`, navigatie, animaties, state-libraries en alle gebruikelijke dingen. We klagen over performance, proberen wat props, voegen `memo` toe, misschien ook `getItemLayout`, en gaan daarna verder met ons leven.

Maar soms zit het echte probleem één laag onder de code van je app.

Dat is hier gebeurd.

Ik heb een performanceverbetering bijgedragen aan `react/react-native`, gemerged als [PR #57210](https://github.com/react/react-native/pull/57210). De wijziging haalt onnodig zoekwerk naar sticky headers weg uit het pad waarmee `VirtualizedList` het render-masker opbouwt.

<figure style="max-width:720px; margin:24px auto 30px;">
  <img
    src="/images/blog/react-native-merged-proof/flatlist-merged.jpg"
    alt="GitHub-tijdlijn die laat zien dat de pull request voor FlatList-performance in React Native is gemerged"
    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;">Gemerged in React Native. Voelt nog steeds een beetje onwerkelijk.</figcaption>
</figure>

In gewone woorden: React Native zocht soms naar sticky headers, ook als de lijst helemaal geen sticky headers had.

Typisch computermoment.

> Lijst: "Ik heb geen sticky headers."
>
> React Native: "Prima, dan zoek ik er even achterwaarts eentje."

Het mooie is dat dit pad gedeeld wordt. De verbetering heeft dus effect op:

- `VirtualizedList`
- `FlatList`
- `VirtualizedSectionList`
- `SectionList`

En ja, gewoon gebruik van `FlatList` kan er ook van profiteren, zelfs als je helemaal geen sticky headers gebruikt.

### Wat dit echt verbetert

Voordat we de code induiken, is het goed om te zeggen over wat voor performance het hier gaat.

De verbetering zit in het JavaScript-werk dat React Native doet voordat het beslist welke rijen gerenderd moeten worden.

`FlatList` houdt een render-venster bij. Terwijl je scrolt, springt, mount in de buurt van een initiële index of door een grote lijst beweegt, moet React Native beslissen welke cellen gerenderd moeten worden en welke delen als spacer kunnen blijven.

Die beslissing loopt via `VirtualizedList._createRenderMask`.

De winst is dus:

- minder JS-werk bij updates van het lijstvenster
- minder werk als je naar het einde van een enorme lijst springt
- minder onnodige sticky-headerlogica voor lijsten zonder sticky headers
- snellere beslissingen voordat de lijst bijwerkt wat er op het scherm moet staan

In gewone app-termen helpt dit het deel van `FlatList` dat bepaalt: "welke rijen moeten er nu bestaan?"

Bij heel grote lijsten, vooral dicht bij het einde van de lijst, kan die kleine interne beslissing echt kosten met zich meebrengen.

Door die kosten weg te halen, wordt het pad voor updates van het render-venster veel goedkoper.

### Wat mij opviel

`FlatList` is een van die components die bijna elke React Native-app op een gegeven moment gebruikt.

Van buitenaf ziet het er simpel uit:

```tsx
<FlatList data={items} renderItem={renderItem} />
```

Maar onder de motorkap loopt het via `VirtualizedList`.

`VirtualizedList` rendert niet de hele databron. Als je 100k rijen hebt, zet het niet 100k rijen op het scherm als een dappere maar gedoemde soldaat. Het houdt een render-venster bij en gebruikt een render-masker om te bepalen welke cellen er op dit moment moeten bestaan.

Dat is goed.

Het probleem zat in de stap waarin het render-masker wordt gemaakt.

React Native ondersteunt ook sticky headers. Sticky headers zijn bijzonder, omdat het sticky item buiten de normale viewport kan liggen en toch gerenderd moet blijven, want visueel zit het vast aan de bovenkant.

React Native heeft dus logica nodig als:

"Zoek de dichtstbijzijnde sticky header vóór de viewport en houd die gerenderd."

Die logica klopt.

Het vervelende was dat die zoektocht nog steeds kon draaien als er helemaal geen sticky headers waren.

### Het oude pad

Vóór deze wijziging bouwde `VirtualizedList._createRenderMask` een set op uit `stickyHeaderIndices` en riep het de helper voor sticky headers aan.

De vereenvoudigde versie zag er zo uit:

```js
const stickyIndicesSet = new Set(props.stickyHeaderIndices);
VirtualizedList._ensureClosestStickyHeader(
  props,
  stickyIndicesSet,
  renderMask,
  cellsAroundViewport.first,
);
```

Daarna liep de helper achterwaarts vanaf de eerste zichtbare cel:

```js
for (let itemIdx = cellIdx - 1; itemIdx >= 0; itemIdx--) {
  if (stickyIndicesSet.has(itemIdx + stickyOffset)) {
    renderMask.addCells({first: itemIdx, last: itemIdx});
    break;
  }
}
```

Bij een kleine lijst maakt dat niks uit.

Bij een heel grote lijst wordt het pijnlijk. Als de viewport dicht bij het einde van een lijst met 1 miljoen rijen zit en er geen sticky headers zijn, kan de helper alsnog achterwaarts door bijna de hele lijst lopen.

Dat is in feite een grote zoektocht om niets te vinden.

Niet mijn favoriete hobby.

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

### Waarom FlatList geraakt wordt

Dit deel mis je makkelijk.

Je hoeft `VirtualizedList` niet direct te gebruiken. `FlatList` is erbovenop gebouwd.

Dus dit soort code:

```tsx
<FlatList
  data={bigData}
  renderItem={renderItem}
/>
```

loopt nog steeds via `VirtualizedList._createRenderMask`.

Vóór de wijziging kon een normale lijst zonder `stickyHeaderIndices` nog steeds betalen voor zoekwerk naar sticky headers.

Na de wijziging controleert React Native eerst of er echt sticky headers zijn, voordat het sticky-headerwerk doet.

Zeer geavanceerde technologie: controleren of iets bestaat voordat je ernaar gaat zoeken.

### De wijziging

Het eerste deel is het belangrijkste voor gewoon gebruik van `FlatList` zonder sticky headers.

```js
const stickyHeaderIndices = props.stickyHeaderIndices;
if (stickyHeaderIndices != null && stickyHeaderIndices.length > 0) {
  VirtualizedList._ensureClosestStickyHeader(
    props,
    stickyHeaderIndices,
    renderMask,
    cellsAroundViewport.first,
  );
}
```

Als er geen sticky headers zijn, slaan we de helper over.

Het tweede deel verbetert ook het geval mét sticky headers.

In plaats van achterwaarts door de item-indexen te lopen, scant de helper de ingestelde sticky-header-indexen en vindt hij de dichtstbijzijnde geldige sticky header vóór de 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});
}
```

De kosten veranderen dus van:

"Hoe ver zijn we van het begin van de lijst?"

naar:

"Hoeveel sticky headers zijn er ingesteld?"

Dat is een veel betere vraag om te stellen.

### Hetzelfde gedrag behouden

Dit is het deel waardoor kleine wijzigingen in een framework minder klein zijn dan ze lijken.

Je kunt niet zomaar optimaliseren en hopen dat alles goed gaat. `stickyHeaderIndices` kan ongesorteerd zijn. Er kunnen dubbele waarden in zitten. Er kunnen ongeldige waarden in zitten. Er kan een `ListHeaderComponent` zijn, waardoor de index één opschuift.

Dat moet allemaal blijven werken.

De tests dekken gevallen als:

- geen `stickyHeaderIndices`
- lege `stickyHeaderIndices`
- ongesorteerde sticky-indexen
- dubbele sticky-indexen
- negatieve waarden
- waarden met decimalen
- waarden na de viewport
- afhandeling van de offset door `ListHeaderComponent`

Dat laatste is belangrijk. Sticky-header-indexen zijn gebaseerd op de indexen van de onderliggende children van `ScrollView`. Als er een list header is, is item-index `0` niet meer child-index `0`.

Kleine off-by-one-bugs zijn dol op dit gebied. Ze wonen er gratis.

### Benchmarkresultaten

Ik heb het pad van `VirtualizedList._createRenderMask` direct gebenchmarkt met Fantom Hermes, met 100 samples per geval.

Deze benchmark richt zich op het beslissingswerk rond het render-venster binnen `VirtualizedList`.

Dus nee, dit betekent niet dat elke `FlatList` in elke app ineens 8000 keer sneller scrolt. Was het maar zo. Dan was ik er nu al onuitstaanbaar over.

Het betekent dat dit specifieke interne pad voor het windowen van lijsten enorm veel goedkoper is geworden. En als de benchmark van seconden verspild werk naar een paar milliseconden gaat, is dat nog steeds een heel echte winst.

### Bewijs in de simulator

Ik heb ook een kleine kale React Native-app gemaakt om beide implementaties in de iOS Simulator te vergelijken.

Dezelfde app. Dezelfde `FlatList` met `1m` rijen. Dezelfde opzet met `no sticky headers`.

Het enige verschil is de geïnstalleerde implementatie van `VirtualizedList`. Dit zijn echte opnames uit de simulator binnen de telefoonframes, geen statische mockup-screenshots. Ik heb de videobediening expres zichtbaar gelaten, en de pulserende cursor markeert de tik op de benchmarkknop.

De benchmark en de gedragstests staan ook in de gemergede React Native-PR:

- [Fantom-benchmarktest](https://github.com/react/react-native/blob/6b3a15b2c0eca3647e4648d4b68bcccd4336d42f/packages/react-native/Libraries/Lists/__tests__/VirtualizedList-stickyHeaders-benchmark-itest.js)
- [Gedragstests voor VirtualizedList](https://github.com/react/react-native/blob/6b3a15b2c0eca3647e4648d4b68bcccd4336d42f/packages/virtualized-lists/Lists/__tests__/VirtualizedList-test.js)
- [Gemergede PR #57210](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;">Voor</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;">▶ simulatorvideo</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"
    >
      Je browser ondersteunt de video-tag niet.
    </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;">Na</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;">▶ simulatorvideo</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"
    >
      Je browser ondersteunt de video-tag niet.
    </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>

In de simulatordemo groeit het oude pad mee met de grootte van de lijst. Voor 1k updates van het render-venster ziet dat er zo uit:

- `50k rows`: ongeveer `1.92 s` in totaal (`1.9196 ms / call`)
- `500k rows`: ongeveer `18.78 s` in totaal (`18.78 ms / call`)
- `1m rows`: ongeveer `38.40 s` in totaal (`38.40 ms / call`)

Met het geoptimaliseerde pad blijft dezelfde demo vrijwel vlak:

- `50k rows`: ongeveer `3.74 ms` in totaal (`0.0037 ms / call`)
- `500k rows`: ongeveer `3.67 ms` in totaal (`0.0037 ms / call`)
- `1m rows`: ongeveer `3.73 ms` in totaal (`0.0037 ms / call`)

Waarden per aanroep liggen onder 1 seconde en staan daarom in milliseconden. Voor 1000 updates van het render-masker staan waarden boven 1 seconde in seconden.

| Geval | Eén update voor | Eén update na | Versnelling | 1000 updates voor | 1000 updates na |
| --- | ---: | ---: | ---: | ---: | ---: |
| 100k rijen, geen sticky headers | 2.664 ms | 0.0034 ms | 780x | 2.66 s | 3.42 ms |
| 100k rijen, lege sticky headers | 2.632 ms | 0.0033 ms | 800x | 2.63 s | 3.29 ms |
| 100k rijen, één sticky header bovenaan | 2.705 ms | 0.0054 ms | 499x | 2.71 s | 5.42 ms |
| 250k rijen, geen sticky headers | 6.543 ms | 0.0035 ms | 1,892x | 6.54 s | 3.46 ms |
| 250k rijen, lege sticky headers | 6.579 ms | 0.0033 ms | 2,024x | 6.58 s | 3.25 ms |
| 250k rijen, één sticky header bovenaan | 6.796 ms | 0.0053 ms | 1,294x | 6.80 s | 5.25 ms |
| 500k rijen, geen sticky headers | 13.173 ms | 0.0033 ms | 4,002x | 13.17 s | 3.29 ms |
| 500k rijen, lege sticky headers | 13.073 ms | 0.0033 ms | 3,997x | 13.07 s | 3.27 ms |
| 500k rijen, één sticky header bovenaan | 13.444 ms | 0.0054 ms | 2,511x | 13.44 s | 5.35 ms |
| 750k rijen, geen sticky headers | 19.524 ms | 0.0033 ms | 6,008x | 19.52 s | 3.25 ms |
| 750k rijen, lege sticky headers | 19.572 ms | 0.0033 ms | 6,022x | 19.57 s | 3.25 ms |
| 750k rijen, één sticky header bovenaan | 20.304 ms | 0.0054 ms | 3,778x | 20.30 s | 5.37 ms |
| 1m rijen, geen sticky headers | 26.190 ms | 0.0033 ms | 8,058x | 26.19 s | 3.25 ms |
| 1m rijen, lege sticky headers | 26.039 ms | 0.0033 ms | 8,012x | 26.04 s | 3.25 ms |
| 1m rijen, één sticky header bovenaan | 26.855 ms | 0.0053 ms | 5,075x | 26.86 s | 5.29 ms |

De kolom met 1000 updates maakt het verschil beter voelbaar.

Bij 1 miljoen rijen besteedt het oude pad zonder sticky headers ongeveer 26 seconden in deze helper voor 1000 updates van het render-masker.

Na de wijziging zit hetzelfde geval rond de 3.25 ms.

Dat is tijd die is weggehaald uit een gedeeld lijstpad, nog voordat React Native beslist welke cellen gerenderd moeten worden.

### Testplan

Ik wilde dat dit op de beste manier saai zou zijn: hetzelfde gedrag, minder werk.

Daarom bevatte de bijdrage gedragstests en benchmarkdekking.

De belangrijkste commando's waren:

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

De PR veranderde drie bestanden:

- de implementatie van `VirtualizedList`
- gerichte tests voor `VirtualizedList`
- een Fantom-benchmark voor het render-maskerpad met sticky headers

Hij is via het proces van Meta geïmporteerd en gemerged in `react/react-native`.

### Tot slot

Wat ik mooi vind aan deze bijdrage, is dat app-ontwikkelaars niets hoeven te doen.

Geen nieuwe prop.

Geen migratie.

Geen workaround.

Als een app een grote `FlatList` zonder sticky headers gebruikt, kan React Native nu zoekwerk naar sticky headers overslaan dat in de eerste plaats al onnodig was.

Dat is mijn favoriete soort frameworkverbetering.

Klein oppervlak. Duidelijke benchmark. Geen API-wijziging.

En een veelgebruikt pad wordt voor iedereen goedkoper.

