Tabulator: one constructor, three package managers, and a two-entry exports map
Interactive Tables and Data Grids for JavaScript
At a glance
- What is it?
- Tabulator turns an HTML table, a JavaScript array or JSON into an interactive grid with a single constructor call, and it ships as a stylesheet plus a script, as an npm package, as a Bower package and from a CDN. The package manifest is the more interesting document: separate rollup build targets, an exports map that exposes the SCSS sources, and a sideEffects list that tells the bundler what not to drop.
- Who is it for?
- Tabulator suits a project that wants a featureful grid quickly, with sorting, filtering, grouping, pagination, editing and layout choices configured rather than coded, and that can include a CSS file and a script tag.
- Can I use it commercially?
- Yes. MIT is a permissive licence: you can use, modify and sell software built on it, as long as you keep its copyright and licence notices.
- Is it still maintained?
- Yes. The repository last received commits 5 days ago.
- What is it written in?
- Mainly JavaScript, according to GitHub's language statistics.
Answers come from the project's GitHub data, last synced on November 15, 2026, and from our analysis. They are not legal advice.
Star history
- tabulator-tables/tabulator7,814 ★ · +42
| Repository | 2026-09-22 | 2026-11-15 |
|---|---|---|
| tabulator-tables/tabulator | 7.8k | 7.8k |
42 Stars in the last 54 days, measured from the daily GitHub snapshot. Compare with other projects
Editorial analysis
The whole setup is a link, a script and one constructor
The README calls setting up Tabulator something that could not be simpler, and the three steps are as short as they claim.
Include the library and the CSS:
<link href="dist/css/tabulator.min.css" rel="stylesheet">
<script type="text/javascript" src="dist/js/tabulator.min.js"></script>Create an element to hold the table:
<div id="example-table"></div>Then turn the element into a table:
var table = new Tabulator("#example-table", {});That last line is the API in full: a CSS selector and a configuration object. Tabulator accepts an HTML table, a JavaScript array or JSON formatted data.
So migrating an existing static HTML table to an interactive grid means pointing a constructor at its container, not rewriting it as a component.
Three installation routes, and the CDN one is a different URL shape
There are three documented ways in, and the third uses the package's dist paths under https://unpkg.com/tabulator-tables/.
With Bower, in the project directory:
bower install tabulator --saveWith NPM:
npm install tabulator-tables --saveNote the two package names differ: Bower installs `tabulator` while NPM installs `tabulator-tables`. That is a small trap for anyone who assumes the two managers take the same name.
With the UNPKG CDN, you include two lines instead of the locally hosted ones:
<link href="https://unpkg.com/tabulator-tables/dist/css/tabulator.min.css" rel="stylesheet">
<script type="text/javascript" src="https://unpkg.com/tabulator-tables/dist/js/tabulator.min.js"></script>So the CSS and the JS are two separate assets in every route, and the CDN URLs as given carry no version, so they do not pin one.
The exports map hands out the SCSS sources, which is unusual
The package manifest is where the shipping decisions are, and one entry is not what you would expect.
"exports": {
".": {
"require": "./dist/js/tabulator.js",
"import": "./dist/js/tabulator_esm.mjs"
},
"./dist/css/*.css": "./dist/css/*.css",
"./dist/js/*.js": "./dist/js/*.js",
"./src/scss/*.scss": "./src/scss/*.scss",
"./src/js/*.js": "./src/js/*.js"
},There are five subpaths, and two of them expose source files: `./src/scss/*.scss` and `./src/js/*.js`. A project that imports the SCSS directly is compiling the library's styles itself rather than consuming the built `tabulator.min.css`, which is how you would change its variables rather than override them after the fact.
The root entry is also split by module system, with `require` pointing at `dist/js/tabulator.js` and `import` at `dist/js/tabulator_esm.mjs`. Alongside it, `main` is `dist/js/tabulator.js`, `module` is `dist/js/tabulator_esm.mjs` and `style` is `dist/css/tabulator.css`.
And `files` publishes `dist/`, `src/`, `LICENSE` and `README.md`, so both the build output and the sources are in the tarball.
sideEffects lists CSS and SCSS, which tells the bundler what to keep
One manifest field decides whether a bundler is allowed to delete an import it thinks is unused:
"sideEffects": [
"**/*.css",
"**/*.scss"
],Listing the stylesheet files as having side effects means an import of the CSS survives tree shaking even when no JavaScript export appears to use it. Without that declaration, a bundler is entitled to drop `import "tabulator-tables/dist/css/tabulator.min.css"` on the grounds that nothing was imported from it.
This is the sort of detail that separates a package that works inside a build tool from one that needs a workaround in every consuming repository. It is two lines in a manifest, and its absence is the kind of bug that only appears in production builds.
The same field is why the SCSS subpath in the exports map matters: a project compiling the library's styles is running that CSS through its own pipeline, and the sideEffects declaration is what keeps that import alive there too.
Five rollup targets, and lint runs before the build
The scripts section shows how the package is produced, and the shape is a single rollup config with an environment variable choosing the output.
`build` runs `rollup -c build/rollup.mjs`, and each development script passes a `TARGET` environment value: `dev` for the general watch, then `css`, `esm`, `umd` and `wrappers` in `dev:css`, `dev:esm`, `dev:umd` and `dev:wrappers`. So the UMD build, the ESM build and the stylesheets are separate rollup targets, which is what lets the same source produce a `require`-able file and an `import`-able file.
The lint command also runs as a prebuild step:
"lint": "eslint src --fix",
"typecheck": "tsc --noEmit",
"prebuild": "eslint src --fix",`prebuild` runs `eslint src --fix` before the build, so a build can modify your working tree. That is a deliberate convention and it is worth knowing before you run a build in a clean checkout with uncommitted work.
There is also a `mise.toml` at the repository root, which is how the tool versions for contributors are pinned.
Unit tests with jest, end-to-end with Playwright, and a build in between
The Testing section documents both suites and the order they need:
# Unit test
npm run test:unit
# E2E test
npm run build # Make sure to build the project first
npx playwright test # Run the tests
# or
npm run test:e2e
# Run all tests
npm run testThe unit tests are jest, wired to `jest.config.js` at the root. The end-to-end tests are Playwright with `playwright.config.js`, and they run against the built output rather than the sources, which is why the comment says to make sure to build the project first.
The combined script encodes that dependency:
"test:e2e": "npm run build && npx playwright test",
"test": "npm run test:unit && npm run test:e2e"So a full `npm test` builds the library, then runs the browser tests against the artefact. For a library whose output is a global script tag plus a stylesheet, testing the artefact rather than the modules is the only version of the test that tells you what a consumer will experience.
Eleven numbered examples are the feature documentation
The README promises packed with useful features and then links the full documentation and demos at tabulator.info. The feature list itself is not in the README; it lives in the examples directory, and the filenames are a table of contents:
`01-basic-table.html`, `02-formatters.html`, `03-sorting-filtering.html`, `04-editing.html`, `05-pagination.html`, `06-grouping-calculations.html`, `07-selection.html`, `08-frozen-responsive.html`, `09-tree-data.html`, `10-full-demo.html`, `11-popup-positioning.html`
Read in order, that is the library's scope stated as eleven problems: start with a table, format values, sort and filter, edit in place, paginate, group with calculated columns, select rows, freeze columns and go responsive, render tree data, see everything at once, and position popups.
`10-full-demo.html` is the one to open first if you are evaluating, because its name marks it as the full demo.
The package is MIT licensed, authored by Oli Folkerd, and the current version is 6.7.1 (2026-10-22), with 6.7.0 on 2026-10-21 and 6.6.1 on 2026-09-30, and the last push to master on 2026-11-01.
Editorial conclusion
Tabulator suits a project that wants a featureful grid quickly, with sorting, filtering, grouping, pagination, editing and layout choices configured rather than coded, and that can include a CSS file and a script tag. It does not suit you if you need a framework-native component with a strict rendering model, since Tabulator manages the DOM inside an element you give it, and it does not suit you if you need a versioned API with a deprecation policy you can read in the repository. Verify three things before you adopt it: which build you import, because the exports map distinguishes require from import and points the ESM build at tabulator_esm.mjs, that the features you need are in the version you pin, with 6.7.1 the current one, and which examples directory entry resembles your case, since examples/01-basic-table.html through examples/11-popup-positioning.html is the project's own feature tour.
Frequently asked questions
what is tabulator
Tabulator is an easy to use interactive table generation JavaScript library that creates interactive tables from any HTML table, JavaScript array or JSON formatted data, with built to work with all the major front end JavaScript frameworks including React, Angular and Vue. The whole setup is a CSS file, a script file and a `new Tabulator("#example-table", {})` call. It is MIT licensed and the current version is 6.7.1.
What is a tabbed table?
In this library the term that matters is data grid, and Tabulator builds one inside an element you supply. The README describes it as interactive tables and data grids for JavaScript, taking an HTML table, a JavaScript array or JSON. Tabs as in tabbed panels are not part of what the README describes, so the package is not what that phrase usually refers to.
tabulator alternatives
The README does not name alternatives and publishes no comparison, so this repository does not settle that question. It does publish its own feature tour as eleven numbered examples, from 01-basic-table.html through 11-popup-positioning.html, plus a full demo page, and the documentation and demos live at tabulator.info. Whether those eleven cover what you need is the comparison worth making yourself.
Official sources
Add this badge to your README
If you maintain this project, the badge below links readers to this analysis and shows its maintenance status from the daily GitHub snapshot. Paste the markdown into your README; add ?metric=license or ?metric=stars to the image URL for a different field.
[](https://hysenlabs.com/projects/tabulator-tables-tabulator)Star history chart for your README
[](https://hysenlabs.com/projects/tabulator-tables-tabulator)Was this useful?