# Ich habe React-Native-Listen 8000x schneller gemacht

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

Ja, du hast richtig gelesen: 8000x schneller.

Nicht im Sinne von "deine ganze App ist jetzt 8000x schneller, kauf dir eine Yacht". Leider.

Und ja, ich weiß, das Timing ist lustig.

Wir leben in einer Zeit, in der KI-News so schnell kommen, dass so etwas wie [Claude Fable 5 erscheinen und ein paar Tage später wieder ausgesetzt werden kann](https://www.anthropic.com/news/claude-fable-5-mythos-5). Die Leute streiten über fast AGI-artige Modelle, Exportkontrollen, Agents, die ganze Projekte umsetzen, und so weiter.

Und ich sitze hier und rede darüber, wie man Listen in React Native schneller macht.

Wenn man beides nebeneinanderstellt, klingt das etwas seltsam. Verstehe ich.

Trotzdem finde ich diese Art von Arbeit spannend. Vielleicht ist "Erfindung" ein zu großes Wort, aber ein Framework zu verbessern, das Tausende Apps nutzen, fühlt sich für mich trotzdem bedeutsam an. Nicht alles Nützliche muss wie Science-Fiction aussehen. Manchmal geht es einfach darum, verschwendete Arbeit aus einem Pfad zu entfernen, den fast jede mobile App durchläuft.

Der Gewinn steckt in einem ganz bestimmten Listen-Pfad von React Native: der Render-Window-Arbeit, die entscheidet, welche Zellen gerade existieren sollen. In diesem Benchmark konnte der alte Pfad bei riesigen Listen Sekunden verschwenden, und der neue Pfad drückt das auf wenige Millisekunden.

Meistens sind wir auf der App-Seite. Wir nutzen `FlatList`, `SectionList`, Navigation, Animationen, State-Libraries und den ganzen üblichen Kram. Wir beschweren uns über die Performance, probieren ein paar Props aus, fügen `memo` hinzu, vielleicht noch `getItemLayout`, und machen dann mit unserem Leben weiter.

Aber manchmal liegt das eigentliche Problem eine Ebene unter dem App-Code.

Genau das ist hier passiert.

Ich habe eine Performance-Verbesserung zu `react/react-native` beigetragen, gemergt als [PR #57210](https://github.com/react/react-native/pull/57210). Die Änderung entfernt unnötige Suchen nach Sticky Headern aus dem Pfad, in dem `VirtualizedList` die Render Mask erstellt.

<figure style="max-width:720px; margin:24px auto 30px;">
  <img
    src="/images/blog/react-native-merged-proof/flatlist-merged.jpg"
    alt="GitHub-Timeline, die zeigt, wie der Pull Request zur FlatList-Performance in React Native gemergt wurde"
    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;">In React Native gemergt. Fühlt sich immer noch ein bisschen unwirklich an.</figcaption>
</figure>

In normalen Worten: React Native hat manchmal nach Sticky Headern gesucht, obwohl die Liste gar keine Sticky Header hatte.

Klassischer Computer-Moment.

> Liste: "Ich habe keine Sticky Header."
>
> React Native: "Cool, dann suche ich mal rückwärts nach einem."

Das Schöne ist, dass dieser Pfad gemeinsam genutzt wird. Die Verbesserung betrifft also:

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

Und ja, auch eine ganz normale `FlatList` kann davon profitieren, selbst wenn du überhaupt keine Sticky Header verwendest.

### Was das tatsächlich verbessert

Bevor wir in den Code gehen, lohnt es sich zu sagen, um welche Art von Performance es hier geht.

Die Verbesserung betrifft die JavaScript-Arbeit, die React Native erledigt, bevor es entscheidet, welche Zeilen gerendert werden sollen.

`FlatList` hält ein Render Window. Während du scrollst, springst, in der Nähe eines initialen Index mountest oder dich durch eine große Liste bewegst, muss React Native entscheiden, welche Zellen gerendert werden und welche Teile als Spacer bleiben können.

Diese Entscheidung läuft über `VirtualizedList._createRenderMask`.

Der Gewinn ist also:

- weniger JS-Arbeit bei Updates des Listen-Windows
- weniger Arbeit beim Springen ans Ende einer riesigen Liste
- weniger unnötige Sticky-Header-Logik bei Listen ohne Sticky Header
- schnellere Entscheidungen, bevor die Liste aktualisiert, was auf dem Screen sein soll

In App-Begriffen hilft das dem Teil von `FlatList`, der entscheidet: "Welche Zeilen sollen gerade existieren?"

Bei sehr großen Listen, besonders in der Nähe des Listenendes, kann diese kleine interne Entscheidung zu echten Kosten werden.

Wenn man diese Kosten entfernt, wird der Update-Pfad des Render Windows viel günstiger.

### Was mir aufgefallen ist

`FlatList` ist eine dieser Komponenten, die fast jede React-Native-App irgendwann nutzt.

Von außen sieht sie einfach aus:

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

Aber unter der Haube läuft sie über `VirtualizedList`.

`VirtualizedList` rendert nicht die gesamte Datenquelle. Wenn du 100k Zeilen hast, packt sie nicht 100k Zeilen auf den Screen wie ein tapferer, aber verlorener Soldat. Sie hält ein Render Window und nutzt eine Render Mask, um zu entscheiden, welche Zellen gerade existieren sollen.

Das ist gut.

Das Problem lag im Schritt, in dem die Render Mask erstellt wird.

React Native unterstützt auch Sticky Header. Sticky Header sind besonders, weil das Sticky-Element außerhalb des normalen Viewports liegen kann, aber trotzdem gerendert bleiben muss, weil es optisch oben festklebt.

React Native braucht also Logik wie:

"Finde den nächstgelegenen Sticky Header vor dem Viewport und halte ihn gerendert."

Diese Logik ist korrekt.

Das Ärgerliche war, dass die Suche trotzdem laufen konnte, wenn es gar keine Sticky Header gab.

### Der alte Pfad

Vor dieser Änderung hat `VirtualizedList._createRenderMask` aus `stickyHeaderIndices` ein Set gebaut und den Sticky-Header-Helper aufgerufen.

Vereinfacht sah das so aus:

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

Dann ist der Helper ab der ersten sichtbaren Zelle rückwärts gelaufen:

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

Bei einer kleinen Liste ist das egal.

Bei einer sehr großen Liste wird es schmerzhaft. Wenn der Viewport nahe am Ende einer Liste mit 1 Million Zeilen ist und es keine Sticky Header gibt, kann der Helper trotzdem fast die gesamte Liste rückwärts durchlaufen.

Das ist im Grunde eine große Suche, um nichts zu finden.

Nicht gerade mein Lieblingshobby.

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

### Warum FlatList betroffen ist

Dieser Teil wird leicht übersehen.

Du musst `VirtualizedList` nicht direkt verwenden. `FlatList` baut darauf auf.

Also läuft auch diese Art von Code:

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

weiterhin über `VirtualizedList._createRenderMask`.

Vor der Änderung konnte eine normale Liste ohne `stickyHeaderIndices` trotzdem für die Sticky-Header-Suche bezahlen.

Nach der Änderung prüft React Native, ob es überhaupt Sticky Header gibt, bevor es Sticky-Header-Arbeit erledigt.

Hochmoderne Technologie: erst prüfen, ob es das Ding gibt, bevor man danach sucht.

### Die Änderung

Der erste Teil ist der wichtige für die normale `FlatList` ohne Sticky Header.

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

Wenn es keine Sticky Header gibt, überspringen wir den Helper.

Der zweite Teil verbessert auch den Fall mit Sticky Headern.

Statt rückwärts durch die Item-Indizes zu laufen, durchsucht der Helper die konfigurierten Sticky-Header-Indizes und findet den nächstgelegenen gültigen Sticky Header vor dem 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});
}
```

Die Kosten ändern sich also von:

"Wie weit sind wir vom Anfang der Liste entfernt?"

zu:

"Wie viele Sticky Header sind konfiguriert?"

Das ist eine viel bessere Frage.

### Das Verhalten gleich halten

Das ist der Teil, der kleine Framework-Änderungen weniger klein macht, als sie aussehen.

Man kann nicht einfach optimieren und hoffen, dass alles passt. `stickyHeaderIndices` kann unsortiert sein. Es kann doppelte Werte enthalten. Es kann ungültige Werte enthalten. Es kann eine `ListHeaderComponent` geben, die den Index um eins verschiebt.

All das muss weiterhin funktionieren.

Die Tests decken Fälle ab wie:

- keine `stickyHeaderIndices`
- leere `stickyHeaderIndices`
- unsortierte Sticky-Indizes
- doppelte Sticky-Indizes
- negative Werte
- Dezimalwerte
- Werte nach dem Viewport
- Behandlung des Offsets durch `ListHeaderComponent`

Der letzte Punkt ist wichtig. Sticky-Header-Indizes basieren auf den Child-Indizes der darunterliegenden `ScrollView`. Wenn es einen List Header gibt, ist Item-Index `0` nicht mehr Child-Index `0`.

Kleine Off-by-one-Bugs lieben diese Ecke. Sie wohnen dort mietfrei.

### Benchmark-Ergebnisse

Ich habe den Pfad `VirtualizedList._createRenderMask` direkt mit Fantom Hermes gebenchmarkt, mit 100 Samples pro Fall.

Dieser Benchmark konzentriert sich auf die Render-Window-Entscheidung innerhalb von `VirtualizedList`.

Also nein, das heißt nicht, dass jede `FlatList` in jeder App plötzlich 8000x schneller scrollt. Ich wünschte es. Ich wäre längst unerträglich deswegen.

Es heißt, dass dieser spezielle interne Windowing-Pfad für Listen massiv günstiger geworden ist. Und wenn der Benchmark von Sekunden verschwendeter Arbeit auf wenige Millisekunden fällt, ist das trotzdem ein sehr realer Gewinn.

### Beweis im Simulator

Ich habe außerdem eine kleine Bare-React-Native-App gebaut, um beide Implementierungen im iOS-Simulator zu vergleichen.

Gleiche App. Gleiche `FlatList` mit `1m` Zeilen. Gleiches Setup mit `no sticky headers`.

Der einzige Unterschied ist die installierte Implementierung von `VirtualizedList`. Das sind echte Simulator-Aufnahmen in den Handy-Rahmen, keine statischen Mockup-Screenshots. Die Video-Controls habe ich absichtlich sichtbar gelassen, und der pulsierende Cursor markiert den Tap auf den Benchmark-Button.

Der Benchmark und die Verhaltenstests sind auch im gemergten React-Native-PR enthalten:

- [Fantom-Benchmark-Test](https://github.com/react/react-native/blob/6b3a15b2c0eca3647e4648d4b68bcccd4336d42f/packages/react-native/Libraries/Lists/__tests__/VirtualizedList-stickyHeaders-benchmark-itest.js)
- [Verhaltenstests für VirtualizedList](https://github.com/react/react-native/blob/6b3a15b2c0eca3647e4648d4b68bcccd4336d42f/packages/virtualized-lists/Lists/__tests__/VirtualizedList-test.js)
- [Gemergter 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;">Vorher</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;">▶ Simulator-Video</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"
    >
      Dein Browser unterstützt das Video-Tag nicht.
    </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;">Nachher</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;">▶ Simulator-Video</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"
    >
      Dein Browser unterstützt das Video-Tag nicht.
    </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 der Simulator-Demo wächst der alte Pfad mit der Listengröße. Für 1k Updates des Render Windows sieht das so aus:

- `50k rows`: insgesamt etwa `1.92 s` (`1.9196 ms / call`)
- `500k rows`: insgesamt etwa `18.78 s` (`18.78 ms / call`)
- `1m rows`: insgesamt etwa `38.40 s` (`38.40 ms / call`)

Mit dem optimierten Pfad bleibt dieselbe Demo praktisch flach:

- `50k rows`: insgesamt etwa `3.74 ms` (`0.0037 ms / call`)
- `500k rows`: insgesamt etwa `3.67 ms` (`0.0037 ms / call`)
- `1m rows`: insgesamt etwa `3.73 ms` (`0.0037 ms / call`)

Die Werte pro Aufruf liegen unter einer Sekunde und werden daher in Millisekunden angezeigt. Bei 1.000 Render-Mask-Updates werden Werte über einer Sekunde in Sekunden angezeigt.

| Fall | Ein Update vorher | Ein Update nachher | Speedup | 1.000 Updates vorher | 1.000 Updates nachher |
| --- | ---: | ---: | ---: | ---: | ---: |
| 100k Zeilen, keine Sticky Header | 2.664 ms | 0.0034 ms | 780x | 2.66 s | 3.42 ms |
| 100k Zeilen, leere Sticky Header | 2.632 ms | 0.0033 ms | 800x | 2.63 s | 3.29 ms |
| 100k Zeilen, ein Sticky Header oben | 2.705 ms | 0.0054 ms | 499x | 2.71 s | 5.42 ms |
| 250k Zeilen, keine Sticky Header | 6.543 ms | 0.0035 ms | 1,892x | 6.54 s | 3.46 ms |
| 250k Zeilen, leere Sticky Header | 6.579 ms | 0.0033 ms | 2,024x | 6.58 s | 3.25 ms |
| 250k Zeilen, ein Sticky Header oben | 6.796 ms | 0.0053 ms | 1,294x | 6.80 s | 5.25 ms |
| 500k Zeilen, keine Sticky Header | 13.173 ms | 0.0033 ms | 4,002x | 13.17 s | 3.29 ms |
| 500k Zeilen, leere Sticky Header | 13.073 ms | 0.0033 ms | 3,997x | 13.07 s | 3.27 ms |
| 500k Zeilen, ein Sticky Header oben | 13.444 ms | 0.0054 ms | 2,511x | 13.44 s | 5.35 ms |
| 750k Zeilen, keine Sticky Header | 19.524 ms | 0.0033 ms | 6,008x | 19.52 s | 3.25 ms |
| 750k Zeilen, leere Sticky Header | 19.572 ms | 0.0033 ms | 6,022x | 19.57 s | 3.25 ms |
| 750k Zeilen, ein Sticky Header oben | 20.304 ms | 0.0054 ms | 3,778x | 20.30 s | 5.37 ms |
| 1m Zeilen, keine Sticky Header | 26.190 ms | 0.0033 ms | 8,058x | 26.19 s | 3.25 ms |
| 1m Zeilen, leere Sticky Header | 26.039 ms | 0.0033 ms | 8,012x | 26.04 s | 3.25 ms |
| 1m Zeilen, ein Sticky Header oben | 26.855 ms | 0.0053 ms | 5,075x | 26.86 s | 5.29 ms |

Die Spalte mit 1.000 Updates macht den Unterschied besser spürbar.

Bei 1 Million Zeilen verbringt der alte Pfad ohne Sticky Header etwa 26 Sekunden in diesem Helper für 1.000 Render-Mask-Updates.

Nach der Änderung liegt derselbe Fall bei etwa 3.25 ms.

Das ist Zeit, die aus einem gemeinsam genutzten Listen-Pfad verschwindet, bevor React Native entscheidet, welche Zellen gerendert werden sollen.

### Testplan

Ich wollte, dass das im besten Sinne langweilig ist: gleiches Verhalten, weniger Arbeit.

Deshalb enthielt der Beitrag Verhaltenstests und Benchmark-Abdeckung.

Die wichtigsten Befehle 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
```

Der PR hat drei Dateien geändert:

- die Implementierung von `VirtualizedList`
- gezielte Tests für `VirtualizedList`
- einen Fantom-Benchmark für den Render-Mask-Pfad mit Sticky Headern

Er wurde über den Prozess von Meta importiert und in `react/react-native` gemergt.

### Fazit

Was mir an diesem Beitrag gefällt: App-Entwickler müssen nichts tun.

Kein neues Prop.

Keine Migration.

Kein Workaround.

Wenn eine App eine große `FlatList` ohne Sticky Header nutzt, kann React Native jetzt die Sticky-Header-Suche vermeiden, die von vornherein unnötig war.

Das ist meine Lieblingsart von Framework-Verbesserung.

Kleine Angriffsfläche. Klarer Benchmark. Keine API-Änderung.

Und ein häufig genutzter Pfad wird für alle günstiger.

