Performance vs AG Grid

Wit Grid spent more time in layout than AG Grid on vertical scroll (about 1.5x on the very fast fling). Chrome's layout trace located the cause: both grids render the same rows and cells and neither forces a layout, but every Wit text cell carried two extra layout objects: a content wrapper, and an anonymous flex box inside it (which also stopped long values from ending in an ellipsis).

Fixed for plain text and the fast fling. Cell text is a plain block, and cells of columns without a custom renderer hold their text directly, as AG Grid's do. Over a whole run Wit now dirties fewer layout objects than AG Grid on every vertical scenario (fast fling 87,480 vs 97,740; plain text 38,100 vs 42,300), and layout time is lower on both. Columns with custom DOM renderers are tracked separately below.

With 10 columns drawn by a custom DOM renderer, Wit Grid's layout time was about 10% above AG Grid's in consecutive runs (197 vs 178 ms, 274 vs 243 ms). A custom-renderer cell was three nested flex boxes (cell, portal host, renderer container) where AG Grid's cell holds the renderer directly.

Fixed to parity. The portal host no longer has a box of its own (display: contents), so the renderer container lays out directly in the cell. Layout time is now even with AG Grid within run-to-run noise (318 vs 324 ms and 324 vs 310 ms in two runs), and total main-thread work fell from 0.79x to about 0.70x of AG Grid's.

On the 200-column horizontal scroll Wit Grid spent more time in style recalculation than AG Grid (150 vs 108 ms). Chrome's invalidation tracking showed why: the grid ended and restarted its scroll session between wheel ticks, and each restart toggled a class on the grid container that restyled every row; separately, every visible header's sort indicator was rewritten on every frame.

Fixed. A scroll session now survives a stream of discrete scroll steps, and header indicators are written only when they change: over a run, container toggles fell from 280 to 2 and row restyles from 7,000 to 100. Style time is now below AG Grid's on every scenario. The benchmark sends instant wheel ticks 16 ms apart, which triggered the restart on every tick; wheels with smooth scrolling trigger it less, so real-world gains are smaller than the benchmark shows.

Cells entering during scroll showed a text stand-in, then flipped to the real renderer when scrolling settled: two writes per cell, and each flip changed the cell's content mode, layer visibility and key, forcing style recalculation. AG Grid updates its renderer in place with refresh().

DOM renderers now default to scrollPresentation 'update': an entering cell's update() runs in place within a per-frame budget and is final as drawn. With 10 custom-renderer columns Wit Grid went from about 1.23x AG Grid's main-thread work to 0.88x, ahead in every paired round.

The DOM renderer manager treated a change of isScrolling or phase alone as a reason to call update(), so every mounted DOM renderer ran again when scrolling stopped, even when nothing it draws had changed.

Renderers are updated only when their value, row, column, or editing / focus / selection state changes. A renderer that wants scroll state opts in with capabilities.scrollState.

Rows in the overscan band were written empty when no display snapshot existed, then filled when they scrolled in: a second write, a text node replacement and a content-mode change (a style recalculation) per cell.

Plain text columns fill those cells with their real value. On the plain-text scenario, content-mode changes went from 27,850 to 0 and style recalculation from 212 to 143 ms.

The custom and DOM renderer managers rewrote data-renderer-key and data-cell-key on every rebind, even when unchanged: about 44,000 DOM mutations each in one scroll.

Written only when the key changes.

The same scenario measured 1,534 ms in one run and 3,085 ms in another on a busy machine, with AG Grid moving just as much. Single-grid medians were not trustworthy.

Rounds are now paired and interleaved, and the page reports the per-round Wit/AG ratio with its full spread.

The first benchmark run reported 38% blank samples for Wit Grid on a scrollbar-drag-speed fling. The sampler was measuring before Wit Grid's own frame work had run; AG Grid renders inside the scroll event, so it was always measured after.

The benchmark now samples after each frame's work. Both grids show no main-thread blank area. Compositor-only checkerboarding is not measured by this benchmark.