Blog

Hice las listas de React Native 8000 veces más rápidas

20 de junio de 2026 9 min de lectura

Cómo mi PR fusionado en React Native hizo que el trabajo de la ventana de render de FlatList y VirtualizedList sea hasta 8000 veces más rápido.

Hice las listas de React Native 8000 veces más rápidas
React NativeFlatListVirtualizedListRendimientoCódigo abierto

Sí, has leído bien: 8000 veces más rápidas.

No en el sentido de "toda tu app es ahora 8000 veces más rápida, ve a comprarte un yate". Por desgracia.

Y sí, ya sé que el momento tiene gracia.

Vivimos en una época en la que las noticias de IA van tan rápido que algo como Claude Fable 5 puede lanzarse y quedar suspendido unos días después. La gente discute sobre modelos casi AGI, controles de exportación, agentes que hacen proyectos enteros, todo eso.

Y aquí estoy yo, hablando de hacer más rápidas las listas de React Native.

Suena un poco raro cuando pones esas dos cosas una al lado de la otra. Lo entiendo.

Pero este tipo de trabajo me sigue pareciendo emocionante. Quizá "invento" sea una palabra demasiado grande, pero mejorar un framework que usan miles de apps sigue teniendo sentido para mí. No todo lo útil tiene que parecer ciencia ficción. A veces se trata solo de quitar trabajo desperdiciado de un camino que casi todas las apps móviles recorren.

La mejora está dentro de un camino concreto de las listas de React Native: el trabajo de la ventana de render que decide qué celdas deben existir en este momento. En ese benchmark, el camino anterior podía desperdiciar segundos con listas enormes, y el nuevo lo reduce a unos pocos milisegundos.

La mayor parte del tiempo estamos del lado de la app. Usamos FlatList, SectionList, navegación, animaciones, librerías de estado y todo lo habitual. Nos quejamos del rendimiento, probamos algunas props, añadimos memo, quizá getItemLayout, y seguimos con nuestra vida.

Pero a veces el problema real está una capa por debajo del código de la app.

Eso es lo que pasó aquí.

Contribuí con una mejora de rendimiento a react/react-native, fusionada como PR #57210. El cambio elimina trabajo innecesario de búsqueda de sticky headers en el camino de creación de la máscara de render que usa VirtualizedList.

Línea de tiempo de GitHub que muestra el pull request de rendimiento de FlatList fusionado en React Native
Fusionado en React Native. Todavía me parece un poco irreal.

En palabras normales: React Native a veces buscaba sticky headers incluso cuando la lista no tenía ninguno.

Un momento clásico de la informática.

Lista: "No tengo sticky headers".

React Native: "Genial, déjame recorrer hacia atrás para encontrar uno".

Lo bueno es que este camino es compartido. Así que la mejora afecta a:

  • VirtualizedList
  • FlatList
  • VirtualizedSectionList
  • SectionList

Y sí, el uso normal de FlatList puede beneficiarse aunque no uses sticky headers en absoluto.

Qué mejora realmente

Antes de entrar en el código, vale la pena aclarar de qué tipo de rendimiento hablamos.

La mejora está en el trabajo de JavaScript que hace React Native antes de decidir qué filas deben renderizarse.

FlatList mantiene una ventana de render. Mientras haces scroll, saltas, montas cerca de un índice inicial o te mueves por una lista grande, React Native tiene que decidir qué celdas renderizar y qué partes pueden quedarse como espaciadores.

Esa decisión pasa por VirtualizedList._createRenderMask.

Así que la mejora es:

  • menos trabajo de JS durante las actualizaciones de la ventana de la lista
  • menos trabajo al saltar cerca del final de una lista enorme
  • menos lógica innecesaria de sticky headers en listas que no los tienen
  • decisiones más rápidas antes de que la lista actualice lo que debe estar en pantalla

En términos de una app normal, esto ayuda a la parte de FlatList que decide "¿qué filas deberían existir ahora mismo?".

En listas muy grandes, sobre todo cerca del final, esa pequeña decisión interna puede convertirse en un coste real.

Eliminar ese coste abarata mucho el camino de actualización de la ventana de render.

Lo que noté

FlatList es uno de esos componentes que casi todas las apps de React Native usan en algún momento.

Desde fuera parece simple:

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

Pero por debajo pasa por VirtualizedList.

VirtualizedList no renderiza toda la fuente de datos. Si tienes 100k filas, no pone 100k filas en pantalla como un soldado valiente pero condenado. Mantiene una ventana de render y usa una máscara de render para decidir qué celdas deben existir en este momento.

Eso está bien.

El problema estaba dentro del paso de creación de la máscara de render.

React Native también soporta sticky headers. Los sticky headers son especiales porque el elemento fijo puede estar fuera del viewport normal, pero aun así tiene que seguir renderizado porque visualmente está pegado arriba.

Así que React Native necesita una lógica como esta:

"Encuentra el sticky header más cercano antes del viewport y mantenlo renderizado."

Esa lógica es correcta.

Lo molesto era que la búsqueda podía ejecutarse igualmente cuando no había sticky headers.

El camino anterior

Antes de este cambio, VirtualizedList._createRenderMask construía un set a partir de stickyHeaderIndices y llamaba a la función auxiliar de sticky headers.

La versión simplificada era así:

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

Luego la función auxiliar recorría hacia atrás desde la primera celda visible:

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

En una lista pequeña, da igual.

En una lista muy grande, se vuelve doloroso. Si el viewport está cerca del final de una lista de 1 millón de filas y no hay sticky headers, la función auxiliar puede recorrer hacia atrás casi toda la lista.

Básicamente es hacer una gran búsqueda para no encontrar nada.

No es mi pasatiempo favorito.

Por qué afecta a FlatList

Esta parte es fácil de pasar por alto.

No necesitas usar VirtualizedList directamente. FlatList está construido sobre él.

Así que un código como este:

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

sigue pasando por VirtualizedList._createRenderMask.

Antes del cambio, una lista normal sin stickyHeaderIndices podía seguir pagando el trabajo de búsqueda de sticky headers.

Después del cambio, React Native comprueba si de verdad existen sticky headers antes de hacer ese trabajo.

Tecnología muy avanzada: comprobar si algo existe antes de buscarlo.

El cambio

La primera parte es la importante para el uso normal de FlatList sin sticky headers.

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

Si no hay sticky headers, nos saltamos la función auxiliar.

La segunda parte también mejora el caso con sticky headers.

En lugar de recorrer hacia atrás los índices de los elementos, la función auxiliar revisa los índices de sticky headers configurados y encuentra el sticky header válido más cercano antes del 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});
}

Así que el coste pasa de:

"¿A qué distancia estamos del inicio de la lista?"

a:

"¿Cuántos sticky headers hay configurados?"

Esa es una pregunta mucho mejor.

Mantener el mismo comportamiento

Esta es la parte que hace que los cambios pequeños en un framework sean menos pequeños de lo que parecen.

No puedes simplemente optimizar y esperar que todo vaya bien. stickyHeaderIndices puede no estar ordenado. Puede contener valores duplicados. Puede contener valores inválidos. Puede haber un ListHeaderComponent, que desplaza el índice en uno.

Todo eso tiene que seguir funcionando.

Las pruebas cubren casos como:

  • sin stickyHeaderIndices
  • stickyHeaderIndices vacío
  • índices de sticky headers sin ordenar
  • índices de sticky headers duplicados
  • valores negativos
  • valores fraccionarios
  • valores posteriores al viewport
  • manejo del desplazamiento de ListHeaderComponent

Ese último es importante. Los índices de sticky headers se basan en los índices de los hijos del ScrollView subyacente. Cuando existe un encabezado de lista, el índice de elemento 0 ya no es el índice de hijo 0.

A los pequeños errores de desfase por uno les encanta esta zona. Viven ahí sin pagar alquiler.

Resultados del benchmark

Medí el camino de VirtualizedList._createRenderMask directamente con Fantom Hermes, usando 100 muestras por caso.

Este benchmark se centra en el trabajo de decisión de la ventana de render dentro de VirtualizedList.

Así que no, esto no significa que cada FlatList de cada app de repente haga scroll 8000 veces más rápido. Ojalá. Ya sería insoportable hablando de ello.

Significa que este camino interno concreto de ventanas de lista se volvió muchísimo más barato. Y cuando el benchmark pasa de segundos de trabajo desperdiciado a unos pocos milisegundos, sigue siendo una mejora muy real.

Prueba en el simulador

También hice una pequeña app de React Native en flujo bare para comparar ambas implementaciones en el simulador de iOS.

La misma app. La misma FlatList de 1m filas. La misma configuración no sticky headers.

La única diferencia es la implementación de VirtualizedList instalada. Son grabaciones reales del simulador dentro de los marcos del teléfono, no capturas estáticas de maquetas. Dejé los controles del video visibles a propósito, y el pulso del cursor marca el toque en el botón del benchmark.

El benchmark y las pruebas de comportamiento también están en el PR fusionado de React Native:

Antes
▶ video del simulador
Después
▶ video del simulador

En la demo del simulador, el camino anterior crece con el tamaño de la lista. Para 1k actualizaciones de la ventana de render, se ve así:

  • 50k rows: unos 1.92 s en total (1.9196 ms / call)
  • 500k rows: unos 18.78 s en total (18.78 ms / call)
  • 1m rows: unos 38.40 s en total (38.40 ms / call)

Con el camino optimizado, la misma demo se mantiene prácticamente plana:

  • 50k rows: unos 3.74 ms en total (0.0037 ms / call)
  • 500k rows: unos 3.67 ms en total (0.0037 ms / call)
  • 1m rows: unos 3.73 ms en total (0.0037 ms / call)

Los valores por llamada están por debajo de 1 segundo, así que se muestran en milisegundos. Para 1,000 actualizaciones de la máscara de render, los valores por encima de 1 segundo se muestran en segundos.

CasoUna actualización antesUna actualización despuésAceleración1,000 actualizaciones antes1,000 actualizaciones después
100k filas, sin sticky headers2.664 ms0.0034 ms780x2.66 s3.42 ms
100k filas, sticky headers vacíos2.632 ms0.0033 ms800x2.63 s3.29 ms
100k filas, un sticky header arriba2.705 ms0.0054 ms499x2.71 s5.42 ms
250k filas, sin sticky headers6.543 ms0.0035 ms1,892x6.54 s3.46 ms
250k filas, sticky headers vacíos6.579 ms0.0033 ms2,024x6.58 s3.25 ms
250k filas, un sticky header arriba6.796 ms0.0053 ms1,294x6.80 s5.25 ms
500k filas, sin sticky headers13.173 ms0.0033 ms4,002x13.17 s3.29 ms
500k filas, sticky headers vacíos13.073 ms0.0033 ms3,997x13.07 s3.27 ms
500k filas, un sticky header arriba13.444 ms0.0054 ms2,511x13.44 s5.35 ms
750k filas, sin sticky headers19.524 ms0.0033 ms6,008x19.52 s3.25 ms
750k filas, sticky headers vacíos19.572 ms0.0033 ms6,022x19.57 s3.25 ms
750k filas, un sticky header arriba20.304 ms0.0054 ms3,778x20.30 s5.37 ms
1m filas, sin sticky headers26.190 ms0.0033 ms8,058x26.19 s3.25 ms
1m filas, sticky headers vacíos26.039 ms0.0033 ms8,012x26.04 s3.25 ms
1m filas, un sticky header arriba26.855 ms0.0053 ms5,075x26.86 s5.29 ms

La columna de 1,000 actualizaciones hace que la diferencia se sienta más.

Con 1 millón de filas, el camino anterior sin sticky headers pasa unos 26 segundos en esta función auxiliar para 1,000 actualizaciones de la máscara de render.

Después del cambio, el mismo caso ronda los 3.25 ms.

Es tiempo eliminado de un camino compartido de listas antes de que React Native decida qué celdas renderizar.

Plan de pruebas

Quería que esto fuera aburrido en el mejor sentido: el mismo comportamiento, menos trabajo.

Así que la contribución incluyó pruebas de comportamiento y cobertura de benchmark.

Los comandos principales fueron:

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

El PR cambió tres archivos:

  • la implementación de VirtualizedList
  • pruebas enfocadas de VirtualizedList
  • un benchmark de Fantom para el camino de la máscara de render con sticky headers

Se importó mediante el proceso de Meta y se fusionó en react/react-native.

Reflexiones finales

Lo que me gusta de esta contribución es que los desarrolladores de apps no tienen que hacer nada.

Ninguna prop nueva.

Ninguna migración.

Ningún parche.

Si una app usa una FlatList grande sin sticky headers, React Native ahora puede evitar un trabajo de búsqueda de sticky headers que para empezar era innecesario.

Ese es mi tipo favorito de mejora en un framework.

Poca superficie. Un benchmark claro. Ningún cambio de API.

Y un camino común se vuelve más barato para todos.