Blog

Ik maakte lijsten in React Native 8000 keer sneller

20 juni 2026 9 min leestijd

Hoe mijn gemergede PR in React Native het werk rond het render-venster van FlatList en VirtualizedList tot 8000 keer sneller maakte.

Ik maakte lijsten in React Native 8000 keer sneller
React NativeFlatListVirtualizedListPrestatiesOpen source

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. 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. De wijziging haalt onnodig zoekwerk naar sticky headers weg uit het pad waarmee VirtualizedList het render-masker opbouwt.

GitHub-tijdlijn die laat zien dat de pull request voor FlatList-performance in React Native is gemerged
Gemerged in React Native. Voelt nog steeds een beetje onwerkelijk.

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:

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

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

Daarna liep de helper achterwaarts vanaf de eerste zichtbare cel:

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.

Waarom FlatList geraakt wordt

Dit deel mis je makkelijk.

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

Dus dit soort code:

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

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.

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:

Voor
▶ simulatorvideo
Na
▶ simulatorvideo

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.

GevalEén update voorEén update naVersnelling1000 updates voor1000 updates na
100k rijen, geen sticky headers2.664 ms0.0034 ms780x2.66 s3.42 ms
100k rijen, lege sticky headers2.632 ms0.0033 ms800x2.63 s3.29 ms
100k rijen, één sticky header bovenaan2.705 ms0.0054 ms499x2.71 s5.42 ms
250k rijen, geen sticky headers6.543 ms0.0035 ms1,892x6.54 s3.46 ms
250k rijen, lege sticky headers6.579 ms0.0033 ms2,024x6.58 s3.25 ms
250k rijen, één sticky header bovenaan6.796 ms0.0053 ms1,294x6.80 s5.25 ms
500k rijen, geen sticky headers13.173 ms0.0033 ms4,002x13.17 s3.29 ms
500k rijen, lege sticky headers13.073 ms0.0033 ms3,997x13.07 s3.27 ms
500k rijen, één sticky header bovenaan13.444 ms0.0054 ms2,511x13.44 s5.35 ms
750k rijen, geen sticky headers19.524 ms0.0033 ms6,008x19.52 s3.25 ms
750k rijen, lege sticky headers19.572 ms0.0033 ms6,022x19.57 s3.25 ms
750k rijen, één sticky header bovenaan20.304 ms0.0054 ms3,778x20.30 s5.37 ms
1m rijen, geen sticky headers26.190 ms0.0033 ms8,058x26.19 s3.25 ms
1m rijen, lege sticky headers26.039 ms0.0033 ms8,012x26.04 s3.25 ms
1m rijen, één sticky header bovenaan26.855 ms0.0053 ms5,075x26.86 s5.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:

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

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.