# SlickGrid: virtual-row rendering for large JavaScript data grids

> SlickGrid is the continuing fork of mleibman/SlickGrid, a JavaScript and TypeScript data grid that keeps only the visible rows in the DOM while the full dataset can be much larger. Version 5.20.2 ships ESM, CJS and IIFE builds and has cut its dependencies to SortableJS alone, with jQuery dropped in v4.

**6pac/SlickGrid** — A lightning fast JavaScript grid/spreadsheet

- Repository: https://github.com/6pac/SlickGrid
- Website: http://6pac.github.io/SlickGrid/
- Stars: 2,073 · Forks: 429
- Language: TypeScript
- License: MIT
- Published: 2026-10-09 · Updated: 2026-10-09 · Language: en
- Canonical page: https://hysenlabs.com/projects/6pac-slickgrid

## The mleibman/SlickGrid original stopped being updated in 2014, and 6pac continues from that codebase

SlickGrid has two GitHub homes, and only one receives updates. The original repository was written by Michael Leibman and lives at mleibman/SlickGrid. That project stopped receiving updates in 2014, and anyone who finds it through an older article or a mid-2010s tutorial lands on code unchanged for over a decade. The 6pac fork picked up that codebase and carried it forward, reaching version 5.20.2 in September 2026.

The design premise is that a table with tens of thousands of rows is slow to render because every row adds DOM nodes that consume memory and layout time. SlickGrid sidesteps that cost by keeping only the visible rows in the document and swapping them as the user scrolls. That mechanism is what the package description calls lightning fast, and it is the primary reason to reach for SlickGrid when the dataset is large. For a small dataset that fits on one screen without scrolling, simpler table components carry less configuration overhead.

Version 5.20.2 is the current release. Source code is written in TypeScript, though TypeScript is not required to use the grid: the dist/browser folder ships pre-built IIFE files that work in a plain script tag without a compile step. Recent releases include 5.20.2 on 2026-09-17, 5.20.1 on 2026-09-15 and 5.20.0 on 2026-09-02, showing a consistent pace of updates.

## jQueryUI left in v3 and jQuery left in v4, with each removal a separate migration step

The dependency history covers three major versions, and each one removed something that was previously mandatory. The mleibman original required both jQuery and jQueryUI, which was standard practice for JavaScript UI work a decade ago but became a meaningful bundle cost as those libraries declined in use.

Version 3 removed jQueryUI and replaced its drag-and-drop functionality with SortableJS. Version 4 went further, making jQuery optional rather than required. jQuery can still be used with v4 or later when a project already has it, but nothing in v4 depends on it. Version 5 migrated the source to TypeScript, retained the IIFE build format, added ES6 and ESM targets, and introduced a new Alpine theme delivered in CSS and SASS.

Each of those major versions breaks compatibility with the one before it. A project running on the mleibman original, v3, v4 and v5 would face four different APIs sharing a name and a virtual-scrolling core. The wiki has dedicated migration pages for each major version, and CHANGELOG.md at the repository root tracks the full release history. Any project that started on the mleibman original and wants to reach v5 crosses three separate migration steps, and none of the wiki pages suggest those steps are small.

## CDN installation loads 3 scripts and 1 stylesheet; npm install slickgrid delivers all three build formats

Two install paths are available. For a page that does not use a bundler, the CDN route pulls from jsdelivr. Three scripts and one stylesheet are needed:

```html
<link rel="stylesheet" href="https://cdn.jsdelivr.net/npm/slickgrid@5.17.0/dist/styles/css/slick-alpine-theme.min.css">
<script src="https://cdn.jsdelivr.net/npm/slickgrid@5.17.0/dist/browser/slick.core.min.js"></script>
<script src="https://cdn.jsdelivr.net/npm/slickgrid@5.17.0/dist/browser/slick.interactions.min.js"></script>
<script src="https://cdn.jsdelivr.net/npm/slickgrid@5.17.0/dist/browser/slick.grid.min.js"></script>
```

After those four resources load, the grid constructor is available as Slick.Grid. Creating a grid follows this pattern:

```js
const grid = new Slick.Grid("#myGrid", dataView, columns, options);
```

For a bundled project, one command covers the install:

```sh
npm install slickgrid
```

With ESM import, SlickGrid and SlickDataView are named exports. The module setup example from the README is:

```js
import 'slickgrid/dist/styles/css/slick-alpine-theme.css';
import { SlickGrid, SlickDataView } from 'slickgrid';
const dataView = new SlickDataView({ inlineFilters: true });
const grid = new SlickGrid("#myGrid", dataView, columns, options);
```

Package.json routes the default ESM path to dist/esm/index.mjs and the CommonJS require path to dist/cjs/index.js, so both formats work without extra configuration. Type declarations sit at dist/types/index.d.ts. CDN URLs in the README example pin version 5.17.0, not the current 5.20.2, so updating those numbers before a production deployment is a step worth taking.

## SortableJS is the only hard dependency, and assigning it to the window object is not automatic

SortableJS handles drag-and-drop and row sorting within the grid. It is the one hard dependency the project documents, and it must be assigned manually because SlickGrid does not load it for you.

For a CDN setup, the SortableJS script tag goes before the SlickGrid scripts:

```js
<script src="https://cdn.jsdelivr.net/npm/sortablejs/Sortable.min.js"></script>
```

For a bundled CJS or ESM setup, assigning the import to the global window is required:

```ts
import Sortable from 'sortablejs';
(window as any).Sortable = Sortable;
```

The `(window as any)` cast is both a TypeScript type escape and a runtime global assignment. Omitting this step produces errors when SlickGrid tries to access Sortable at runtime. That is easy to miss on a first ESM setup, because few ESM packages require a global side-effect assignment in addition to their local import. SortableJS is documented as the only hard dependency, and the wording in the README is unambiguous: 'you have to assign it yourself', with no default assignment provided.

## Six plugins were added to the fork: RowDetail, CellMenu, ContextMenu, GridMenu, CustomTooltip and GridState

The 6pac fork extended the original with six plugins that did not exist in the mleibman codebase: RowDetail, CellMenu, ContextMenu, GridMenu, CustomTooltip and GridState. Each is a discrete extension that adds behaviour without altering the core rendering engine.

Merging the X-SlickGrid project brought Frozen Columns and Frozen Rows, which the repository refers to as pinning. Frozen columns stay visible on the left side while the user scrolls right, a standard requirement for any wide grid where the first column is an identifier. Frozen rows lock a set of rows to the top of the view in the same way.

The examples folder at the repository root shows the range of these features. Files there include examples for composite editors, drag-and-drop between two separate grids, draggable column grouping, column and row spanning, checkbox row selection, autocomplete editors, Bootstrap 3 header styles and Content Security Policy header setups. More than 25 example HTML files are present. A wiki Examples page links to all of them with descriptions, and a Stackblitz demo covers a subset. That Stackblitz link is also used for submitting bug and feature requests, per the README.

## Angular, React and Vue integration belongs in Slickgrid-Universal, not this base repository

For Angular, React and Vue, the starting point is Slickgrid-Universal at https://github.com/ghiscoding/slickgrid-universal, which provides official wrappers for those frameworks and more. This base repository is the foundation Slickgrid-Universal builds on, but it does not ship React components, Angular modules or Vue composables.

Phrasing from the README is softer than the situation deserves: for specific frameworks you 'may want to take a look at Slickgrid-Universal'. Wiring SlickGrid to React's reconciliation, Angular's zone.js or Vue's reactivity is not something the base ESM build handles. Those are framework lifecycle concerns, and the base grid exposes a JavaScript object whose data and columns the caller sets directly. A developer who bypasses the wrapper path and reaches for the base grid inside a React component ends up writing that wrapper layer themselves.

For plain JavaScript or TypeScript projects with no framework runtime, the base repository is the documented path. ESM build compatibility with most module systems is what the README confirms, and the Vite demo in the vite-demo folder was created to test that build target along with SASS imports.

## Accessibility, server-side pagination and Cypress test coverage are not described in the README

One gap worth checking before adopting the project: no accessibility coverage exists in the README. There is no mention of ARIA roles, no keyboard navigation specification and no guidance on screen-reader behaviour. A grid used in a public-facing application or one subject to accessibility requirements needs additional work that the project does not document.

Server-side pagination is a second undocumented area. Virtual row rendering keeps visible rows in the browser, but no documentation covers requesting additional data pages from a server as the user scrolls toward the end of a loaded batch. That pattern is common for grids backed by large databases, and the absence of documentation does not mean it is impossible, only that you are on your own working it out.

Cypress end-to-end tests are present in the repository, and package.json scripts expose a cypress command for interactive runs and a cypress:ci command for headless CI runs. What those tests cover and where their gaps are is not stated anywhere the README links. A new contributor who wants to understand coverage has to read the spec files directly. CODE_OF_CONDUCT.md and CONTRIBUTING.md are both present at the repository root, so a contribution path exists even if the test scope is not narrated.

## Conclusion

Use SlickGrid when you need virtual row rendering for large tabular datasets in a JavaScript or TypeScript project and SortableJS as the sole dependency is acceptable. Skip it when your project is Angular, React or Vue: the README points those cases to Slickgrid-Universal. Skip it when accessibility is a hard requirement, since the README has no ARIA roles or keyboard navigation coverage. Before adopting, read the CHANGELOG.md and the wiki migration pages for v3, v4 and v5, as each major version introduced breaking changes. The last push was on 2026-10-06, and the vite-demo folder holds a Vite example for testing the ESM build.

## FAQ

### What is SlickGrid?

SlickGrid is a JavaScript and TypeScript data grid that virtualises rows, keeping only the visible ones in the DOM, to handle large datasets without slowing the browser. Version 5.20.2 is the current release, published under the MIT licence, and the active repository is 6pac/SlickGrid.

### How do I install SlickGrid?

It is published on npm under the name slickgrid, so npm install slickgrid adds it to a project. It can also be loaded from jsdelivr as three CDN scripts alongside the Alpine theme stylesheet, without a bundler.

### Does SlickGrid require TypeScript?

TypeScript is not required to use SlickGrid. The dist/browser folder ships pre-built IIFE files that work in a plain script tag with no compile step, and the Stackblitz examples are mostly written in JavaScript.

### Does SlickGrid work with React or Angular?

For Angular, React and Vue, the project's own README points to Slickgrid-Universal, which provides framework-specific wrappers built on the base grid. The base SlickGrid repository ships an ESM build that any module system can import but includes no React components or Angular modules.

### What is the difference between mleibman/SlickGrid and 6pac/SlickGrid?

The mleibman/SlickGrid repository is the original project, which stopped receiving updates in 2014. The 6pac repository is the fork that continued development, reaching version 5.20.2, with TypeScript support, jQuery removed in v4 and several new plugins added.

## Sources

- [6pac/SlickGrid on GitHub](https://github.com/6pac/SlickGrid)
- [License: MIT](https://github.com/6pac/SlickGrid/blob/master/LICENSE)
- [Project website](http://6pac.github.io/SlickGrid/)
- [README](https://github.com/6pac/SlickGrid/blob/master/README.md)
- [Releases](https://github.com/6pac/SlickGrid/releases)

---

Hysen Labs editorial analysis, written from the project's own repository and release notes. Cite the canonical page: https://hysenlabs.com/projects/6pac-slickgrid