<!-- https://svgrid.com/docs/help/comparison/ - SvGrid documentation as markdown. Index of every page: https://svgrid.com/llms.txt -->

# Comparison: SvGrid vs AG Grid vs TanStack Table

The three projects solve overlapping problems, and the right choice
depends on the framework you ship on, how much of the grid you want to
build yourself, and your budget. Every number on this page is read from
npm or measured by a script in this repository on the date shown; the
block below is regenerated by `node tools/sync-guide-facts.mjs` and the
per-competitor pages under [/compare/](https://svgrid.com/compare/) list
the sources for every feature claim.

<!-- facts:start ag-grid,tanstack-table -->
> **Facts, checked 12 Sep 2026.** `ag-grid-community` 36.1.0, MIT, last published 5 Aug 2026, 12,400,000 npm downloads in the 30 days to 10 Sep 2026. `@tanstack/svelte-table` 9.2.4, MIT, last published 28 Aug 2026, 231,000 npm downloads in the same window. `@svgrid/grid` 3.0.3, MIT, last published 11 Sep 2026, 16,900 npm downloads in the same window. Bundle, minified and gzipped, each package built alone with Svelte external: SvGrid 3.0.28 99.7 KB JS + 11.3 KB CSS (measured 29 Oct 2026); `ag-grid-community` 36.1.0 317.5 KB JS, no separate stylesheet (measured 12 Sep 2026); `@tanstack/svelte-table` 9.2.4 36.3 KB JS, no separate stylesheet, svelte external (measured 12 Sep 2026). AG Grid pricing, as its site states it: AG Grid Community is free under MIT. AG Grid Enterprise is listed at $999 USD per developer with one year of updates and Zendesk support; the Enterprise Bundle with AG Charts Enterprise is $1,498 USD per developer (https://www.ag-grid.com/license-pricing/, read 12 Sep 2026). TanStack Table pricing, as its site states it: TanStack Table is MIT and free; tanstack.com is sponsor-supported and offers Enterprise Support as private consulting and expert support, with no licence sold for the table (https://tanstack.com/table/latest, read 12 Sep 2026). SvGrid: MIT core; @svgrid/enterprise from $299 per developer per year (Indie, under $1M revenue), $599 for Enterprise. Side by side, with sources: [SvGrid vs AG Grid (community + enterprise)](https://svgrid.com/compare/ag-grid/), [SvGrid vs TanStack Table (Svelte)](https://svgrid.com/compare/tanstack-table/).
<!-- facts:end -->

## TL;DR

| Project               | Lives in                                 | Ships                                                      | Licence                                   |
| --------------------- | ---------------------------------------- | ---------------------------------------------------------- | ----------------------------------------- |
| **SvGrid**            | Svelte 5                                 | Headless core + Svelte render component + Enterprise pack   | MIT (Community) / commercial (Enterprise) |
| **AG Grid Community** | React, Angular, Vue, plain JS            | Full grid + renderer; Svelte through community integrations | MIT                                       |
| **AG Grid Enterprise**| same                                     | Adds the set filter, range selection, master/detail, tree, grouping, pivot, charts, Excel export, server-side row model | Commercial, per developer |
| **TanStack Table**    | React, Vue, Svelte, Solid, Qwik, Lit, JS | Headless engine **only**; the Svelte adapter is Svelte 5    | MIT                                       |

The bundle sizes and prices are in the facts block above, with the date
they were read and the method behind the sizes.

## When SvGrid is the right choice

- You're on **Svelte 5** and want a grid that uses the runtime's idioms
  (snippets for cells, `$state` for data, `$derived` for aggregates) -
  not a React-port pretending to be Svelte.
- You want a **headless core you can render yourself** AND a
  default-styled component for the 80% case. Most "headless" libraries
  make you write the markup; most "monolith" libraries make you fight
  the markup. SvGrid does both in one package.
- You need **clean theming via CSS custom properties** and a documented
  `--sg-*` token surface, not a hard-coded class soup.
- You ship under **strict CSP** (no `eval`, no `new Function`, no
  inline scripts). SvGrid runs clean; AG Grid Community does too.
  TanStack Table is engine-only so the question doesn't apply.
- You want **SSR markup that is meaningful before hydration** (good
  first paint, SEO, SvelteKit `+page.server` integration). SvGrid +
  TanStack Table both qualify. AG Grid renders client-side.
- You want the features AG Grid sells as Enterprise - the set filter,
  range selection, master/detail, tree data, grouping with aggregation,
  integrated charts, flat server-side infinite scroll - **in the MIT
  core**. (Server-side grouping, tree, pivot and transactions are
  Enterprise in both.)

## When AG Grid is the right choice

- You're on **React, Angular, or Vue**, not Svelte. SvGrid is
  Svelte-only, and ag-grid.com points Svelte users to community-built
  integrations rather than an official package.
- You need a push-based **viewport row model** for a real-time trading
  blotter, where the server streams the visible window over a socket.
  SvGrid's server-side row model covers sort, filter, grouping, tree,
  pivot, transactions and select-all across unloaded rows, and its
  real-time page merges deltas into loaded rows, but it does not have the
  viewport model.
- You need **custom tool panels**. SvGrid's tool panel is a fixed
  Columns + Filters pair. Custom filter components are covered by a
  column's `customFilter`.
- You need **AG Charts** for maps, network graphs, 3D or a canvas renderer.
  SvGrid's chart is SVG with decimation, and it ships 29 types, a configurable
  axis model, synchronized charts, a financial toolkit with indicator panes
  and drawing tools, a builder and PDF export in the MIT core; it does not
  draw maps.
- You want a vendor with **a decade of enterprise procurement paperwork**
  already on file.

## When TanStack Table is the right choice

- You want a **rendering-framework-agnostic engine** so the same
  business logic powers React + Svelte + Solid surfaces in your
  monorepo.
- You're already in the TanStack ecosystem (Query, Router, Form,
  Virtual) and want one mental model.
- You're happy writing **all the markup yourself** - the row recycling,
  the keyboard map, the ARIA roles, the focus management, the
  drag-to-resize. That's the cost of "engine only".

## Feature parity at a glance

Yes: shipped in that edition. Partial: needs extra work or a companion
package. No: not available. The AG Grid columns follow ag-grid.com's
Community vs Enterprise page and its Set Filter, Tree Data and CSV export
pages; the dated list of those sources is on the
[SvGrid vs AG Grid](https://svgrid.com/compare/ag-grid/) page, and the
TanStack sources on [SvGrid vs TanStack Table](https://svgrid.com/compare/tanstack-table/).

|                                 | SvGrid Community | SvGrid Enterprise | AG Grid Community | AG Grid Enterprise | TanStack Table |
| ------------------------------- | ---------------- | ----------------- | ----------------- | ------------------ | -------------- |
| Headless core (engine only)     | Yes              | Yes               | No                | No                 | Yes            |
| Default render component        | Yes (Svelte 5)   | Yes               | Yes (each framework) | Yes             | No             |
| Sort (multi-column)             | Yes              | Yes               | Yes               | Yes                | Yes (engine)   |
| Filter menu (operator + facet)  | Yes              | Yes               | Partial (text and number filters; the set filter is Enterprise) | Yes | No |
| Filter row                      | Yes              | Yes               | Yes               | Yes                | No             |
| Pagination                      | Yes              | Yes               | Yes               | Yes                | Yes (engine)   |
| Grouping + aggregation          | Yes              | Yes               | No (Enterprise)   | Yes                | Yes (engine)   |
| Tree / expand-collapse rows     | Yes              | Yes               | No (Enterprise)   | Yes                | Yes (engine)   |
| Master/detail                   | Yes              | Yes               | No (Enterprise)   | Yes                | No             |
| Cell range selection + copy/paste | Yes            | Yes               | No (Enterprise)   | Yes                | No             |
| Fill handle                     | Yes              | Yes               | No (Enterprise)   | Yes                | No             |
| Inline editing (typed editors)  | Yes              | Yes               | Yes               | Yes                | No             |
| Column virtualization           | Yes              | Yes               | Yes               | Yes                | No             |
| Row virtualization              | Yes              | Yes               | Yes               | Yes                | Partial (pair with TanStack Virtual) |
| Column pinning (left/right)     | Yes              | Yes               | Yes               | Yes                | No             |
| Column tool panel               | Yes              | Yes               | No (Enterprise)   | Yes                | No             |
| Context menu                    | Yes              | Yes               | No (Enterprise)   | Yes                | No             |
| Fit-to-width with shrink        | Yes              | Yes               | Partial           | Yes                | No             |
| WAI-ARIA grid pattern           | Yes              | Yes               | Yes               | Yes                | No (your markup) |
| Server-side data, flat (sort / filter / paging / infinite scroll) | Yes (built in) | Yes (built in) | Yes (infinite row model) | Yes (built in) | Partial (manual flags) |
| Server-side row model (lazy grouping, tree, pivot, transactions, select-all across unloaded rows) | No (Enterprise) | Yes (built in) | No (Enterprise) | Yes (built in) | No |
| Global search over server-side data | Yes (`filterModel.global`) | Yes | No (the quick filter is client-side only) | No | n/a |
| CSP-clean (no eval, no inline)  | Yes              | Yes               | Yes               | Yes                | n/a            |
| Meaningful SSR markup           | Yes              | Yes               | No                | No                 | depends on your markup |
| CSV / TSV / JSON export         | Yes              | Yes               | Yes (CSV)         | Yes                | No             |
| Excel (.xlsx) / PDF export      | No               | Yes               | No                | Yes (Excel)        | No             |
| Print                           | No               | Yes               | No                | No                 | No             |
| Excel / CSV import              | No               | Yes               | No                | No                 | No             |
| In-grid AI helpers (bring your own model) | Yes    | Yes               | No                | No                 | No             |
| MCP server for AI assistants    | Yes (`@svgrid/mcp`) | Yes            | Yes (`ag-mcp`)    | Yes                | No (agent skills ship in the package) |
| Pivot table                     | No               | Yes               | No                | Yes                | No (custom)    |
| Integrated charts               | Yes (29 types, builder, financial toolkit) | Yes | No           | Yes (AG Charts)    | No             |
| Support response time           | GitHub (best-effort) | 1 business day; 1h sev-1 on Enterprise | GitHub (best-effort) | no number published | GitHub; paid Enterprise Support offered |
| Theming via CSS variables       | Yes (`--sg-*`)   | Yes               | Yes (theme builder) | Yes              | n/a            |
| Source button per demo          | Yes (gallery)    | Yes               | No                | No                 | No             |

## Bundle size

The facts block at the top of the page has the gzipped size of each
package, measured by the same method: each package built alone with Vite
in library mode, minified, gzip level 9, Svelte external because it is a
peer dependency. SvGrid's own number comes from `pnpm size:json`
(`packages/grid/scripts/measure-size.mjs`), the competitors' from
`pnpm competitors:measure`; both write `docs/_data` and the block is
regenerated from there, so the page cannot quote a size nobody measured.

What the SvGrid number contains: the whole render component -
virtualization, Excel-style filters, inline editing, grouping, tree,
master/detail, cell selection and accessibility - in one import, plus a
separate stylesheet. Charts, date and time editors, menus and export split
into `import()` chunks that load on demand rather than shipping in the
initial bundle; the headless core on its own is a small fraction of the
render component, and `@svgrid/enterprise` features are separate subpath
imports. The per-entry breakdown, including the headless core and the
lazy chunks, is in the [bundle size reference](https://svgrid.com/docs/help/bundle-size/).

What the AG Grid number contains: `createGrid` with every Community
module registered and the Quartz theme, whose CSS ships inside the script
under the theming API, so there is no separate stylesheet to add. The
TanStack number is the whole Svelte adapter with its engine: no
virtualizer, filter UI or editors, because a headless library has none.

## Measured performance

A vendor's own benchmark is worth nothing unless you can rerun it, so the
harness is in the repository and takes an adapter per grid. Adding another
grid is about forty lines in `examples/src/bench/adapters.ts` and nothing
else.

```bash
# headless, prints the table and writes tests/perf/.last-compare.json
BENCH_REPEATS=7 BENCH_GRIDS=svgrid,aggrid,svar,tanstack pnpm bench:compare

# move that run into docs/_data/competitors.json, then regenerate this page
node tools/record-benchmarks.mjs && node tools/sync-guide-facts.mjs

# or drive it by hand
pnpm --filter @svgrid/grid-example-gallery dev   # then open /bench.html
```

Each operation is timed until the grid's DOM reflects it, plus one frame:

- **Mount** - fresh container, create the grid, until rows are painted.
- **Sort** - change the sort on one column, until the new order is painted.
  Text sorts `name` (tens of thousands of distinct values), numeric sorts
  `amount`.
- **Filter** - apply a `contains` filter to one column.
- **Scroll** - 180 frames at 60 px/frame, sampling frame intervals.

### Results

The table is generated from the ledger by `tools/sync-guide-facts.mjs`;
the versions and the date are part of it.

<!-- bench:start -->
Measured 28 Oct 2026 with `pnpm bench:compare` (tests/perf/compare.spec.ts, recorded by tools/record-benchmarks.mjs): 100,000 rows x 9 columns; 1000 x 520 px container, 32 px rows, 140 px columns, each grid with its default theme; fastest of 3 samples per operation, each grid in a fresh page; Chromium through Playwright, headless; win32 10.0.26200 x64, Intel(R) Core(TM) Ultra 7 255U; a developer workstation, not a dedicated bench rig; tick: 1,000 of the rows replaced per tick with a new amount, the grid sorted by amount, on the update path each grid provides, timed until the changed cells paint; 180 ticks after 10 to warm up. Lower is better.

| Operation | SvGrid | AG Grid Community | SVAR Svelte DataGrid | TanStack Table, minimal DOM |
| --- | --- | --- | --- | --- |
| Mount | 30.7 ms | 67 ms | 11.4 ms | 170.2 ms |
| Sort, text column | 77.4 ms | 213.9 ms | 135.4 ms | 360.9 ms |
| Sort, numeric column | 32.8 ms | 216.7 ms | 141.7 ms | 178.2 ms |
| Filter, one column (indicative only, see below) | 34.5 ms | 148.8 ms | 26.1 ms | 51.1 ms |
| Scroll, p95 frame | 34.3 ms | 34.5 ms | 34.6 ms | 34.3 ms |
| Live tick, 1,000 rows replaced, sorted by that column, p95 | 48.6 ms | 259.2 ms | 152.2 ms | 563.4 ms |
| Main-thread work per 60 px scroll step, mean | 3.5 ms | 4.5 ms | 3 ms | 2.9 ms |
| Frames dropped while scrolling, of 180 | 0 | 0 | 0 | 0 |
| Ticks over one 60 Hz frame, of 180 | 115 | 180 | 180 | 180 |
| Rows kept in the DOM (virtualization on) | 36 | 36 | 19 | 27 |
| JS heap the grid adds, mounted, after GC | 5.7 MB | 42.1 MB | 2.3 MB | 109.9 MB |
| JS heap the grid adds, after sorting and filtering, after GC | 17.6 MB | 26.2 MB | 3.9 MB | 113.3 MB |
| Elements created per scroll frame | 0 | 30.1 | 16.8 | 18.7 |
| Elements re-inserted per scroll frame (rows recycled) | 37.3 | 35.8 | 0 | 0 |

Versions: `@svgrid/grid` 3.0.25, `ag-grid-community` 36.1.0, `wx-svelte-grid` 2.7.0, `@tanstack/svelte-table` 9.2.4.
<!-- bench:end -->

Read that as: **SvGrid sorts and keeps a live sort current faster than the
other three, scrolling is level across all four, and SVAR is ahead on mount
and memory** - it paints its first rows in under half of SvGrid's time and
holds the least heap. Every grid scrolls at the display rate here, so the
p95 frame reads the same for all four; the work row under it is what a
slower machine or a 120 Hz display would feel. There TanStack and SVAR do
the least per scroll step, about half a millisecond under SvGrid, and AG
Grid the most. The row varies from run to run, so read the order of the
first three as close, not settled. SvGrid makes its row objects the first time a
sort or filter reads every row rather than at mount, which is why its two
heap rows differ. The TanStack renderer pays for building a row object per
record before it can draw anything. Anyone claiming a single headline
number for a grid comparison is selling something.

**The heap rows are the JS heap after a forced garbage collection, less the
same page with the data built and no grid,** so the 100,000 rows themselves
count against no one. The two DOM rows are counted over 60 untimed scroll
frames after the timed ones. "Created" is elements that did not exist
before; "re-inserted" is elements the grid already had and moved, which is
how a keyed list recycles a row from one end of the window to the other.
SvGrid creates none and moves the two rows that cross the edge each frame;
a grid that rewrote its rows in place would score 0 on both.

**The filter row is not a like-for-like comparison and is shown only because
hiding a number we win looks worse than explaining it.** The grids' single-
column filter APIs differ: the harness drives AG Grid's quick filter, which
searches every column and is strictly more work than the single-column
`contains` SvGrid performs, while SVAR and TanStack run a predicate over the
one column. Do not read a ratio into that row.

**The TanStack column is an engine plus the least DOM an app could draw.**
TanStack Table renders nothing, so its adapter draws the row model through
a fixed-height windowed table with no virtualizer library, no filter UI and
no editors. Its mount and sort numbers include creating the engine's row
objects for every record; the grids around it do the same work inside their
own models.

Sorting is where SvGrid's distance comes from, and it is not subtle: SvGrid
resolves each sort clause once and precomputes a key array, and for a
column whose distinct values are far fewer than its rows it collates the
distinct values once and sorts by rank. Mounting is the other direction -
see the accounting in [benchmarks](https://svgrid.com/docs/help/benchmarks/).

At 1,000,000 rows the harness runs one grid per invocation
(`BENCH_ROWS=1000000 BENCH_GRIDS=<one> BENCH_TICKS=30`); TanStack's
adapter does not finish at that size. Those runs are not in the table
because only a run that measured every grid together is comparable.

Two methodology notes, both of which were bugs in this harness before they
were notes, and both of which changed the numbers by more than any code
change did:

- **Each grid runs in a fresh page.** They used to run one after another in
  the same one, where the first warmed the JIT, fragmented the heap and
  left a hundred thousand rows of garbage for the next. Back-to-back runs
  on an idle machine disagreed with themselves by a factor of two.
  That order effect is gone, but this workstation still varies by about
  2x between whole runs taken minutes apart, for every grid at once, so
  compare the columns of one run and not one run against another.
- **Operations are timed until the DOM changes, not for a fixed two
  frames.** The old fixed wait put a two-frame floor under every number -
  an operation that recomputed nothing at all measured the floor, and a
  mount whose rows were already in the DOM measured pure waiting - which
  flattered whichever grid was slower.
- **Each figure is the fastest of the samples, not the median.** Noise
  only ever adds time, so the minimum is the cleanest estimate of what the
  machine can do, and medians on this box drifted by a third between
  consecutive runs - more than most of the differences being measured.
  Applied identically to every grid.

What this table deliberately does not include:

- **Features the grids do not measure the same way.** Grouping, pivot,
  editing and export all differ enough in shape that a single timing would
  compare two different amounts of work. The filter row above is the one
  case we publish anyway, labelled, rather than quietly dropping a result
  that happens to favour us.
- **Any grid we cannot license for this.** The harness is grid-agnostic on
  purpose, but some commercial grids licence their software in ways that
  restrict using it to produce competitive claims. Where that is the case
  we do not ship an adapter, and we would rather have an obviously
  incomplete table than a legally dubious one. Run your own shortlist.
- **Your workload.** One dataset shape, one machine, one browser, default
  configuration for every grid. If a grid decision rides on this, clone the
  harness and put your own data in it.

## Migrating from AG Grid

The most common starting point. See
[Migrating from AG Grid](https://svgrid.com/docs/help/migrating-from-ag-grid/) for a side-by-side
translation of column defs, features, filtering, editing, and the
imperative API. The example that guide is built around runs here:

> Live demo: AG Grid ↔ sv-grid side-by-side - https://svgrid.com/demos/139-migration-from-ag-grid/

## Migrating from TanStack Table

The map is one-to-one - SvGrid's headless core speaks the vocabulary
TanStack Table v9 introduced. The big differences:

- Replace `createTable(opts)` with `createSvGrid(opts)`. Same state
  machine, same features object.
- Replace the row-model factories with the same names from
  `@svgrid/grid`.
- The render layer changes - TanStack hands you `FlexRender` + the
  row model; SvGrid lets you keep that headless approach OR drop in
  the default `<SvGrid>` component.

The headless demo below drives a plain `<table>` from `createSvGrid`, the
way a TanStack app would:

> Live demo: Headless -> your own table - https://svgrid.com/demos/186-headless-table/

And the same rows through the render component, which is the part TanStack
leaves to you. The example runs against these rows:

```svelte
<script lang="ts">
  import { SvGrid, type GridColumns } from '@svgrid/grid'

  type Order = {
    id: number
    customer: string
    region: string
    status: string
    amount: number
  }

  const orders: Order[] = [
    { id: 1, customer: 'Ada Lovelace',   region: 'EMEA', status: 'open',    amount: 1240 },
    { id: 2, customer: 'Grace Hopper',   region: 'AMER', status: 'shipped', amount: 860 },
    { id: 3, customer: 'Linus Torvalds', region: 'EMEA', status: 'closed',  amount: 2210 },
    { id: 4, customer: 'Radia Perlman',  region: 'APAC', status: 'open',    amount: 430 },
    { id: 5, customer: 'Barbara Liskov', region: 'AMER', status: 'pending', amount: 1780 },
  ]

  let rows = $state<Order[]>(orders)

  const columns: GridColumns<Order> = [
    { field: 'customer', header: 'Customer', width: 180 },
    { field: 'region',   header: 'Region',   width: 110 },
    { field: 'status',   header: 'Status',   width: 110 },
    { field: 'amount',   header: 'Amount',   width: 120, editorType: 'number', format: { type: 'currency', currency: 'USD' } },
  ]
</script>
```

```svelte
<SvGrid data={rows} {columns} sortable filterable selectable />
```

## Pricing

SvGrid Community is MIT - free for commercial use, no attribution
required at runtime. SvGrid Enterprise is a per-developer licence: $599
per developer per year for the enterprise grid or $999 with the
spreadsheet and Studio, both for unlimited applications; see
<https://svgrid.com/pricing/> for what each tier adds.

AG Grid Community is MIT. AG Grid Enterprise is priced per developer with
one year of updates; the figure ag-grid.com listed on the date we read it
is in the facts block at the top of this page, and the
[SvGrid vs AG Grid](https://svgrid.com/compare/ag-grid/) page carries the
link. Compare what each paid tier adds before comparing prices: most of
what AG Grid sells as Enterprise is in SvGrid's free core.

TanStack Table is MIT and sponsor-funded; tanstack.com offers paid
Enterprise Support as private consulting.

## Frequently asked questions

### What is the best data grid for Svelte 5?

For a Svelte-5-native grid with a batteries-included render component, SvGrid is
built around runes and snippets. TanStack Table is a strong headless-only
choice if you want to build the DOM layer yourself across frameworks, and its
v9 Svelte adapter targets Svelte 5. AG Grid is the most feature-complete but
lives in React, Angular and Vue first and reaches Svelte through
community-built integrations.

### Is SvGrid a good AG Grid alternative?

Yes, for Svelte projects. SvGrid is a fraction of AG Grid Community's
measured size on a Svelte page (the facts block has both numbers and the
method), is MIT-licensed for commercial use, and offers `@svgrid/enterprise`
for export, print, import and pivot at a per-developer price. On the
benchmark above it sorts a hundred-thousand-row column faster on both
column types and scrolls level; AG Grid mounts quicker. It does not match
every AG Grid Enterprise feature - see the
[missing-features list](https://svgrid.com/docs/help/missing-features/) for the gaps.

### SvGrid vs TanStack Table - which should I pick?

Pick SvGrid if you want virtualization, Excel-style filters, selection, and
inline editing working out of the box on Svelte 5. Pick TanStack Table if you
want a framework-agnostic headless engine and are happy to build the rendering,
virtualization, and editing UI yourself. Both are MIT-licensed.

### Does the TanStack Svelte adapter support Svelte 5?

Yes. The `@tanstack/svelte-table` v9 line declares a Svelte 5 peer range
and passes data through getters rather than stores; the facts block above
shows the version read from npm. The earlier `createSvelteTable` constructor
is gone in v9.

### Does AG Grid have an MCP server like SvGrid?

Yes. `ag-mcp` (MIT) gives an assistant AG Grid's docs, examples and
version-specific upgrade prompts. `@svgrid/mcp` does the same for SvGrid
and adds a code checker that validates props and imports against the real
API surface, a scaffold tool and a preview. Neither is an in-grid feature;
SvGrid's natural-language filter, smart fill and summarise helpers are, and
they ship free in `@svgrid/grid` with a model provider you register.

### How big is the SvGrid bundle?

The facts block at the top of this page has the measured gzipped size of the
full `<SvGrid>` render component and its stylesheet, read from
`docs/_data/svgrid-size.json`, which `pnpm size:json` writes. The
[bundle size reference](https://svgrid.com/docs/help/bundle-size/) breaks it down by entry:
the headless core on its own, the core subpath, the charts, and the lazy
chunks that load on demand.

## See also

- [Why headless?](https://svgrid.com/docs/why-headless/) - the design decision behind
  SvGrid's two-layer architecture.
- [Migrating from AG Grid](https://svgrid.com/docs/help/migrating-from-ag-grid/) - the
  practical recipe.
- [Migrating from TanStack Table](https://svgrid.com/docs/help/migrating-from-tanstack-table/) - the
  one-to-one API map.
- [Benchmarks](https://svgrid.com/docs/help/benchmarks/) - how the numbers are produced and what
  they leave out.
- [Enterprise feature pack](https://github.com/sv-grid/sv-grid/blob/main/docs/enterprise/README.md) - what SvGrid charges for.
- [Missing features](https://svgrid.com/docs/help/missing-features/) - the honest gap list
  versus AG Grid Enterprise.
- [All comparisons](https://svgrid.com/compare/) - one page per grid, with
  dated sources for every claim.

---

SvGrid is the Svelte 5 data grid (`npm install @svgrid/grid`, MIT). This page: https://svgrid.com/docs/help/comparison/ . All docs: https://svgrid.com/llms.txt