---
title: Quick Start
---
TanStack Table is a headless table library. It manages your table's state and logic (sorting, filtering, pagination, selection, and more) while you keep 100% control over the markup and styles. The `@tanstack/table-core` package gives you the framework-agnostic core directly, so you provide the rendering and subscribe to table state changes yourself. This page gets you from install to a rendering vanilla table, then shows how to layer on your first feature.
## Installation
```bash
npm install @tanstack/table-core
```
## Your First Table
The TypeScript module below is complete. Use it with an HTML page that contains `
` and you will see a working table.
```ts
import {
constructTable,
tableFeatures,
type ColumnDef,
} from '@tanstack/table-core'
import { FlexRender } from '@tanstack/table-core/flex-render'
import { storeReactivityBindings } from '@tanstack/table-core/store-reactivity-bindings'
// 1. Define the shape of your data
type Person = {
firstName: string
lastName: string
age: number
}
// 2. Give your data a stable reference
const data: Array = [
{ firstName: 'tanner', lastName: 'linsley', age: 24 },
{ firstName: 'tandy', lastName: 'miller', age: 40 },
{ firstName: 'joe', lastName: 'dirte', age: 45 },
]
// 3. New in v9: declare which features this table uses
const features = tableFeatures({
coreReactivityFeature: storeReactivityBindings(),
})
// 4. Define your columns. Renderers return values or HTML strings.
const columns: Array> = [
{
accessorKey: 'firstName', // accessorKey shorthand
header: 'First Name',
cell: (info) => info.getValue(),
},
{
accessorFn: (row) => row.lastName, // accessorFn alternative with a custom id
id: 'lastName',
header: () => 'Last Name',
cell: (info) => `${info.getValue()}`,
},
{
accessorKey: 'age',
header: () => 'Age',
},
]
// 5. Create the table instance
const table = constructTable({
features,
columns,
data,
})
const app = document.getElementById('app')
if (!app) {
throw new Error('Missing #app element')
}
// 6. Render markup from the table instance APIs
const renderTable = () => {
const tableElement = document.createElement('table')
const thead = document.createElement('thead')
const tbody = document.createElement('tbody')
table.getHeaderGroups().forEach((headerGroup) => {
const tr = document.createElement('tr')
headerGroup.headers.forEach((header) => {
const th = document.createElement('th')
th.innerHTML = header.isPlaceholder
? ''
: String(FlexRender({ header }) ?? '')
tr.appendChild(th)
})
thead.appendChild(tr)
})
table.getRowModel().rows.forEach((row) => {
const tr = document.createElement('tr')
row.getAllCells().forEach((cell) => {
const td = document.createElement('td')
td.innerHTML = String(FlexRender({ cell }) ?? '')
tr.appendChild(td)
})
tbody.appendChild(tr)
})
tableElement.appendChild(thead)
tableElement.appendChild(tbody)
app.replaceChildren(tableElement)
}
table.store.subscribe(() => renderTable())
renderTable()
```
A few things to note:
- `tableFeatures({...})` declares which optional features the table uses. Registering only what you need keeps bundles small and gives TypeScript accurate types for the table instance.
- The core row model is always included automatically. Feature row models (sorting, filtering, pagination) are registered as slots directly on the `tableFeatures({...})` call when you need them.
- Vanilla usage must provide `coreReactivityFeature: storeReactivityBindings()` because there is no framework adapter to wire the core TanStack Store atoms into a rendering system for you.
- `FlexRender` renders the `header`, `cell`, and `footer` definitions from your columns. In vanilla usage, renderers commonly return strings or HTML strings that you place into the DOM.
- Subscribe to `table.store` when your UI should redraw after table state changes.
See the full [Basic example](./examples/basic) for a runnable version with more columns and a footer.
## Add a Feature: Sorting
Features are opt-in in v9. To make columns sortable, register `rowSortingFeature` and the `sortedRowModel` factory in `tableFeatures`, then wire the header click handler.
```ts
import {
constructTable,
createSortedRowModel,
rowSortingFeature,
sortFns,
tableFeatures,
} from '@tanstack/table-core'
import { storeReactivityBindings } from '@tanstack/table-core/store-reactivity-bindings'
const features = tableFeatures({
coreReactivityFeature: storeReactivityBindings(),
rowSortingFeature, // enables sorting APIs and state
sortedRowModel: createSortedRowModel(), // client-side sorting
sortFns,
})
// columns and data unchanged from above
const table = constructTable({
features,
columns,
data,
})
```
```ts
// In renderTable, replace the header rendering with sortable header markup.
table.getHeaderGroups().forEach((headerGroup) => {
const tr = document.createElement('tr')
headerGroup.headers.forEach((header) => {
const th = document.createElement('th')
const button = document.createElement('button')
button.type = 'button'
button.disabled = !header.column.getCanSort()
button.innerHTML = header.isPlaceholder
? ''
: String(FlexRender({ header }) ?? '')
button.innerHTML +=
{
asc: ' 🔼',
desc: ' 🔽',
}[header.column.getIsSorted() as string] ?? ''
button.addEventListener('click', (event) => {
header.column.getToggleSortingHandler()?.(event)
})
th.appendChild(button)
tr.appendChild(th)
})
thead.appendChild(tr)
})
```
Clicking a header now toggles between ascending, descending, and unsorted. Every other feature follows this same pattern: register the feature and its row model factory (if it has one) in `tableFeatures`, then use the APIs it adds to the table, columns, and rows. See the [Sorting example](./examples/sorting) for custom sort functions, multi-sorting, and per-column options.
## Where to Go Next
**Table state.** In v9, table state is backed by TanStack Store atoms. When you use `@tanstack/table-core` directly, you decide when to read state, subscribe to state, and redraw your UI. You usually do not need to manage state yourself. Set `initialState` for starting values and call feature APIs like `table.setSorting(...)` or `table.nextPage()`. When your app should own a state slice, or you want fine-grained subscriptions, read the [Table State Guide](./guide/table-state). It is the foundational guide for vanilla usage.
**Feature examples.** Browse runnable vanilla examples such as [Pagination](./examples/pagination) and [Sorting](./examples/sorting) to see complete DOM rendering setups.
**Core guides.** The framework-agnostic guides cover the main table objects: [Data](../../guide/data), [Column Definitions](../../guide/column-defs), [Table Instance](../../guide/tables), [Rows](../../guide/rows), [Cells](../../guide/cells), and [Header Groups](../../guide/header-groups).