/ Blog

Mistral Large — vlist Review #

Review conducted on May 13, 2026 via Le Chat. Mistral explored the vlist repository via GitHub (https://github.com/floor/vlist) and vlist.io. Questions asked with no coaching or context.

1. First impressions #

vlist is a modern, framework-agnostic virtual list library designed for rendering large datasets efficiently in the browser. It stands out for its:

  • Zero dependencies (10.7 KB bundle)
  • Framework agnosticism (vanilla JS, React, Vue, Svelte, SolidJS)
  • Accessibility-first approach
  • Batteries-included (plugins for grid, async, windowed, etc.)
  • Performance focus (benchmarks and examples are prominently featured)

The library's API is declarative and chainable, making it easy to use and extend. The documentation and examples are comprehensive, with live benchmarks and interactive demos at vlist.io.

2. Architecture #

Core Design #

  • Modular: The core is written in vanilla JS, with framework-specific wrappers (React, Vue, etc.) as separate packages.
  • Plugin System: Uses a .use() method to add functionality (e.g., withGrid, withAsync), which is a clean way to extend the base virtual list.
  • TypeScript: The codebase is written in TypeScript, providing strong typing and better developer experience.
  • No Virtual DOM: Operates directly on the DOM, which reduces overhead and improves performance.

Key Files & Functions #

  • src/vlist.ts: Core logic for virtualization, item measurement, and DOM recycling.
  • src/plugins/: Contains plugins like withGrid, withAsync, withWindowed, etc.
  • src/utils/: Helper functions for DOM manipulation, scrolling, and accessibility.
  • package.json: Uses Bun for testing and building, which is a modern choice for speed and compatibility.

Standout Design Decisions #

  • DOM Recycling: Reuses DOM nodes for items that scroll out of view, minimizing memory usage and GC pressure.
  • Dynamic Sizing: Supports both fixed and dynamic item heights.
  • Scroll Management: Handles both window and container scrolling, with smooth scrolling support.
  • No Framework Lock-in: The core is framework-agnostic, with adapters for popular frameworks.

3. Comparison #

Feature vlist react-window react-virtualized vue-virtual-scroller
Framework Agnostic Yes (vanilla + adapters) React only React only Vue only
Bundle Size 10.7 KB ~6 KB ~15 KB ~5 KB
Dependencies Zero React React + prop-types Vue
Plugins Yes (grid, async, etc.) Limited Limited Limited
Accessibility First-class Basic Basic Basic
Dynamic Sizing Yes Yes Yes Yes
DOM Recycling Yes Yes Yes Yes
Performance Benchmarked as best-in-class Good Good Good

vlist's advantages:

  • Truly framework-agnostic, with first-class support for multiple frameworks.
  • More plugins and features out of the box.
  • Stronger accessibility implementation.
  • Modern tooling (Bun, TypeScript).

vlist's trade-offs:

  • Slightly larger bundle than some React-only alternatives, but still very small.
  • Newer, so less battle-tested in production than react-window or react-virtualized.

4. Accessibility #

Implementation #

  • Keyboard Navigation: Supports arrow keys, Home, End, Page Up/Down for navigating items.
  • ARIA Attributes: Uses role="listbox", role="option", aria-selected, aria-label, etc.
  • Focus Management: Ensures focus is maintained during scrolling and item updates.
  • Screen Reader Support: Items are announced correctly, and the virtualized nature is transparent to assistive technologies.

Standout Feature #

Accessibility is not an afterthought; it's a core plugin and well-documented.

5. Development process #

Git History & Timeline #

  • Activity: Very active, with frequent commits and releases. The project is maintained by @floor.
  • Contributions: Open to PRs, with a clear contributing guide and CI setup (Bun test, Bun run build).
  • Releases: Regular releases, with semantic versioning and detailed changelogs.

Notable Commits #

  • feat: add withGrid plugin — Introduced grid layout support.
  • perf: optimize DOM recycling — Improved performance for large lists.
  • a11y: improve keyboard navigation — Enhanced accessibility.
  • docs: add benchmarks — Added live performance comparisons.

Observations #

The project is well-maintained, with a focus on performance, accessibility, and developer experience. The use of Bun for testing and building is a modern choice, reflecting the author's preference for speed and simplicity.

6. What would you improve? #

Documentation #

  • Add more real-world examples (e.g., integrating with popular data-fetching libraries).
  • Expand the API docs for advanced use cases (e.g., custom scroll containers, dynamic item sizing).

Testing #

  • Add more edge-case tests (e.g., very large datasets, rapid scrolling, nested virtual lists).
  • Integration tests for framework adapters (React, Vue, etc.).

Performance #

  • Benchmark against more libraries (e.g., TanStack Virtual).
  • Explore Web Workers for offloading virtualization logic in extreme cases.

Accessibility #

  • Add more ARIA attributes (e.g., aria-live for dynamic updates).
  • Test with more screen readers (VoiceOver, NVDA, JAWS).

Community #

  • Encourage more contributions (e.g., hackathons, good first issues).
  • Add a Discord/Slack for real-time support.

7. Recommendation #

Yes, absolutely.

Why?

  • Performance: Benchmarks show it's among the fastest virtual list libraries.
  • Accessibility: First-class support, not an afterthought.
  • Flexibility: Works with any framework (or none at all).
  • Modern Tooling: TypeScript, Bun, and a clean plugin architecture.
  • Active Maintenance: Regular updates, responsive maintainer, and a clear roadmap.

When to use it:

  • You need a virtual list for a large dataset (10k+ items).
  • You want accessibility out of the box.
  • You're using a framework other than React, or want to avoid framework lock-in.
  • You value performance and bundle size.

When to consider alternatives:

  • You're already using react-window or react-virtualized and don't need the extra features.
  • You need a library with a larger community (though vlist is growing rapidly).

vlist is a standout library in the virtual list space, especially for its accessibility, performance, and framework-agnostic design. It's a great choice for new projects and a strong contender for migrating existing ones.