Search landscape & user intent (brief)

Search intent across the given keywords (react-list, React virtualized list, react-list tutorial, etc.) clusters into three clear categories: informational (how virtualization works, examples, tutorials), transactional/comparative (which library to choose, installation, setup), and problem-solving (performance optimization, variable height items, infinite scroll). Expect mixed intent queries where users look for both “how to” and “which tool.”

Top resources competing in English-language SERPs typically include: official docs (React, library READMEs), blog tutorials and deep-dives (e.g., dev.to, CSS-Tricks), and GitHub repos for libraries like react-window and react-virtualized. Articles often balance code samples, step-by-step setup, and performance benchmarks.

Depth-wise, winners provide runnable examples (codesandbox, GitHub), performance metrics, and advanced patterns (variable-height rows, cell measurement, infinite scroll). So to outrank, deliver clear setup + copy-paste examples + pragmatic optimization tips and FAQs that answer voice-search style queries.

Core techniques and recommended libraries

Virtualization (a.k.a. windowing) reduces DOM nodes by rendering only visible items. Conceptually, you compute a visible window around the scroll viewport, render items inside that window, and update as the user scrolls. That alone usually reduces render time and memory usage dramatically for lists with thousands of items.

There are two mainstream approaches: fixed-size windowing (fast, simple) and variable-size windowing (more complex—requires measurement or estimation). Choose fixed when items share a consistent height; choose variable when item heights vary significantly (e.g., dynamic content, rich media).

Popular, battle-tested libraries to avoid reinventing the wheel:

• react-window — minimal, high-performance, best for fixed-size items and basic variable-size support.
• react-virtualized — feature-rich (CellMeasurer, MultiGrid) for complex use cases; heavier weight.
• react-virtuoso — excellent for variable heights and built-in infinite scrolling behaviors.

For a hands-on deep dive on advanced virtualization tactics (measurement, caching, variable heights), see this community article: Advanced list virtualization with react-list.

Getting started: installation and a minimal example

Install your chosen package via npm or yarn. For most cases start with react-window because it gives a tiny footprint and predictable behavior:

npm install react-window
# or
yarn add react-window

Here is a minimal fixed-height example using react-window’s FixedSizeList. Copy-paste-friendly and suitable as a base for infinite scroll and virtualization experiments.

import { FixedSizeList as List } from 'react-window';

function Row({ index, style }) {
  return <div style={style}>Row #{index}</div>;
}

<List
  height={500}
  itemCount={10000}
  itemSize={35}
  width={'100%'}
>
  {Row}
</List>

Explanation: set a viewport height (500px), itemCount (total items), and itemSize (fixed row height). react-window will only mount the items visible inside the 500px viewport plus a small overscan. This is the simplest path to immediate performance wins when your items have consistent heights.

Advanced: variable heights, measuring and infinite scroll

Variable-height lists require either measurement or a virtualization engine that can handle dynamic sizing. The two common strategies are: (1) measure items on first render and cache heights (CellMeasurer-like), or (2) use libraries that internally handle variable heights (e.g., react-virtuoso).

If you prefer react-window, pair it with VariableSizeList and an estimator/cacher for item sizes. You’ll call listRef.resetAfterIndex(index) when a measured item changes size so the list reflows correctly. That pattern keeps reflows minimal but requires careful caching to avoid layout thrashing.

Infinite scroll pairs naturally with virtualization: load the next page when the user nears the end of the virtual window, append to your items array, and the virtualizer updates counts without re-rendering the entire list. Keep loading and rendering decoupled—render a placeholder (skeleton) for items still loading and avoid blocking the main thread during fetches.

Practical performance optimization checklist

Here are the high-impact steps I use when a list starts to lag. These focus on reducing renders, avoiding layout thrash, and minimizing main-thread work:

• Avoid anonymous inline functions for item renderers — memoize rows with React.memo and stable props.
• Prefer transform-based scroll containers (if applicable) and avoid heavy paint work per item (shadows, gradients) during scroll.
• Use overscan judiciously (small positive integer) to balance perceived smoothness vs extra renders.

Additional tips: use requestIdleCallback or setTimeout to defer non-urgent DOM work (analytics, measurement). Use virtualization only for large lists—small lists add complexity without benefits. Profile with browser devtools: look at scripting and paint time; if scripting dominates, reduce JS work per row; if paint dominates, simplify styles.

Finally, keep the component tree for each row shallow. Expensive child components should be lazily rendered or replaced with lightweight placeholders inside virtualized rows to minimize mount cost.

Useful links & referenced resources

Anchor backlinks (keyword → resource):

react-window,
react-virtualized,
react-virtuoso,
advanced list virtualization with react-list.

FAQ

How do I handle variable-height items in a virtualized React list?

Use a library that supports variable heights (e.g., react-virtuoso) or react-window’s VariableSizeList plus a measurement strategy. Measure heights on first render, cache them, and call resetAfterIndex(index) when a size changes so the list reflows correctly. Avoid repeated synchronous measurements—batch or debounce them to prevent layout thrash.

Which library is best for React list virtualization?

It depends: for tiny bundle + predictable fixed-height rows use react-window. For complex grids, measurement helpers and advanced features, react-virtualized remains robust. For dynamic, variable-height content and built-in infinite scroll patterns, consider react-virtuoso.

How can I implement infinite scroll with virtualization?

Detect when the user scrolls near the end of the virtual window (e.g., index >= items.length – threshold) and trigger a fetch for the next page. Append new items to your data array and update itemCount. Keep the fetch asynchronous and render skeleton items for pending content to avoid layout shifts. Libraries like react-virtuoso have built-in support for this pattern, simplifying edge cases.

Final semantic core (human-readable summary)

Primary targets: react-list, React list virtualization, react-list example, React virtualized list. Secondary targets: performance-related queries, variable-height handling and infinite scroll. Use the JSON-like block above to implement internal tagging, alt texts and anchor texts across the page.