ParamQuery Grid: a spreadsheet-style jQuery grid for data-heavy screens

A grid that behaves like a spreadsheet

ParamQuery Grid is described as a lightweight and powerful JavaScript grid plugin that works with Angular, React, Vue, jQuery, Knockout and plain JavaScript, and the repository description notes that it is based on the jQuery UI widget design.

What distinguishes it from a table with sorting is the spreadsheet behaviour. The feature list calls out copy-paste, autofill and drag-to-fill, which are the operations a user brings to a grid after a day in Excel and expects to find. It also lists inline editing with batch, row, custom editors, multiline support and validations, plus state management with undo and redo history.

The data handling is broader than one column type. Sorting is available locally, remotely and custom, for numbers, strings and dates. Filtering works locally and remotely with a header filter row. Paging works with local or remote data sources, and multiple data sources are supported: HTML, Array, XML and JSON. Column and row grouping comes with fixed total rows, and there are frozen rows and columns in the Excel style.

The scale claim in the feature list is 100,000+ records supported efficiently, and the mechanism for that is virtual scrolling and rendering for unlimited rows and columns. That is a rendering strategy rather than a data strategy, so the underlying data still has to be somewhere.

The intended user is a developer building an internal tool, a back office application or a reporting screen, and the author is Paramvir Dhindsa, with copyright from 2012 to 2026.

The GPL v3 edition and what it means for a commercial product

The licence is the first thing to settle, because it determines whether the project is usable at all in your context.

The README titles the project ParamQuery Grid (Community Edition), states it is released under the GPL v3 license, and the package metadata records `GPL-3.0-or-later` with a `GPL-LICENSE.txt` file shipped in the npm package. The homepage is paramquery.com, which hosts the documentation, the API reference, the demos and a PHP integration tutorial, and a separate commercial edition is sold from the same site.

GPL v3 is a strong copyleft licence. If you distribute the grid or a modified version of it, you owe the recipients the corresponding source of the licensed work, and derivative works inherit the obligation. A web application that ships the grid to browsers counts as distribution. Embedding the unmodified library in a proprietary internal application used only by your own employees is a different situation from shipping it to customers, and the boundary between serving a page with the library and shipping a product containing it is exactly where this licence needs careful reading.

This is a description of the terms as published, not legal advice, and the GPL-LICENSE.txt file in the repository is the version that governs. The practical point for an engineering team is that the copyleft is a design constraint on your release process, and it should be evaluated before the grid is chosen, not after the product is built.

The commercial edition exists precisely because of that constraint, and the choice between them is a business decision rather than a technical one.

Installing from npm and wiring up a first grid

The README lists three ways to get the plugin, by CDN, by downloading the package, or via npm, and gives the npm command directly:

npm i pqgridf

The package name is `pqgridf`, which stands for the free edition, and the package version is 3.6.0. The `main` entry points at `pqgrid.min.js` and `types` at `pqgrid.d.ts`, and the `exports` map allows the stylesheet subpath to be imported separately.

A minimal grid is short enough to read in full. You create a container, give it an id, and initialise the plugin with a column model and a data model:

<div id="grid"></div>

<script>
  $(function () {
    var data = [
      { name: "John", age: 28, city: "New York" },
      { name: "Alice", age: 32, city: "London" },
      { name: "Bob", age: 25, city: "Paris" }
    ];

    $("#grid").pqGrid({
      width: "100%",
      height: 400,
      colModel: [
        { title: "Name", dataIndx: "name", width: 150 },
        { title: "Age", dataIndx: "age", width: 100 },
        { title: "City", dataIndx: "city", width: 150 }
      ],
      dataModel: { data: data }
    });
  });
</script>

The shape of the API is the thing to take away. `colModel` describes the columns with a title, a `dataIndx` naming the property in the row object, and a width. `dataModel` carries the rows, here as a plain array of objects. The `dataIndx` indirection is what lets the same column definition work when the data comes from XML or JSON rather than from a JavaScript array, since the property name is resolved at render time rather than being baked into a column definition.

The grid is initialised inside a jQuery ready handler, which is the standard jQuery UI widget pattern the project follows.

Peer dependencies tell you what the plugin expects around it

The `peerDependencies` block in `package.json` is the most useful single piece of information for anyone integrating the grid, and it is more opinionated than a typical library.

The peers are `jquery` at `>=2.2.4 <5`, `@types/jquery` at `>=2.2.4`, `jquery-ui-pack` at `>=1.12.3` with `@types/jqueryui` at the same floor, and `jszip` at `^2.5.0`.

The jQuery range is the one to check first. The upper bound of below 5 leaves room for jQuery 4, and the v3.6.0 release note records jQuery 4 support and a typings file, which is the version that closed that gap. The lower bound of 2.2.4 is old enough to allow jQuery 2 codebases, which is common in the enterprise applications this kind of grid lands in.

The jQuery UI peer is the reason the repository description calls this a plugin based on the jQuery UI widget design. The grid inherits the widget conventions from jQuery UI, so jQuery UI is part of the runtime expectation rather than an optional extra.

The `jszip` peer is tied to the export feature. The feature list promises export to Excel (xlsx), HTML, JSON and CSV, and generating an xlsx file client side means building a zip archive, which is what JSZip provides. The `jsZip-2.5.0/` directory at the top level of the tree and the `jszip-utils-0.0.2/` directory are the vendored helpers for that path, which is a hint that the export code expects a particular version shape.

There are no runtime `dependencies` and no `devDependencies` listed at all, so nothing is pulled in behind your back.

Framework wrappers and the files in the tree

The repository carries integration directories for the frameworks the feature list names, with `angular/`, `knockout/`, `php/` and `pqTouch/` at the top level, and the README lists jQuery, Angular, React, Vue and Knockout under framework integration.

The distinction worth understanding is between a wrapper and a rewrite. A React or Vue wrapper for a jQuery plugin does not make the plugin idiomatic in that framework, it makes it mountable. The grid's behaviour, its DOM structure and its event model remain those of a jQuery UI widget, and the wrapper's job is to create the container, initialise the widget and clean it up on unmount. That is a workable pattern for a component that owns its own DOM subtree, which a grid does, but it means React users are working with an imperative widget inside a declarative tree, and the usual consequences follow.

Other directories tell their own story. `localize/` and the `i18n` feature relate to internationalisation. `themes/` holds the theme support the feature list mentions. `images/` and `pqTouch/` point at touch support and the icon assets. `pqgrid.dev.js` and `pqgrid.min.js` are the development and production builds, with matching CSS files including a separate `pqgrid.ui.*` pair for the jQuery UI themed variants. The `pqgrid.d.ts` file is the TypeScript typings, referenced by the package `types` entry, and the `.d.ts` reference in the v3.6.0 release note indicates it is a recent addition rather than a long-standing feature.

The `package.json` `files` array shows exactly what the npm package contains, and it is a curated list of images, the localisation files, the themes, the touch support, the licence, the changelog, the typings, the JavaScript and the CSS. The `ChangeLog.txt` file is shipped, which is unusual and useful for a library that has been in the wild for more than a decade.

Where ParamQuery Grid is the wrong choice

The clearest wrong-tool case is a read-only table. If your screen shows a list with a sort control and a search box, a grid plugin with editing, grouping, frozen panes, nested grids and undo history is a large dependency for a small requirement, and the jQuery and jQuery UI peers come with it.

The second case is a dataset that genuinely cannot be held in the browser and cannot be paged in a way your backend supports cleanly. The grid offers local and remote modes for sorting, filtering and paging, but a remote mode means your server has to implement a query protocol that the grid understands, with the same sort and filter semantics, and that is work that has to be designed rather than configured. An application that already renders server-side tables with its own pagination does not need this.

The third case is a modern front-end stack that has moved off jQuery. The plugin requires jQuery and jQuery UI at runtime. In a codebase that has no jQuery, adding it back for one component is a decision with a lasting cost, and the React and Vue wrappers do not change that dependency.

The fourth is a closed-source product, which the licence already covers above.

The alternative worth naming is a purpose-built component in the framework you already use, which is the right answer for most new React or Vue applications. The difference in approach is fundamental. A framework-native table component renders from your state and re-renders when it changes, so sorting and filtering are transformations of data you already hold. ParamQuery Grid holds its own model, manages its own DOM, and exposes an imperative API, which is why it can deliver Excel-like behaviours such as autofill and multi-cell paste that a declarative grid rarely attempts. The trade is between a component that fits your architecture and a component that does more than your architecture needs.

Release history and the jQuery 4 upgrade

The version history tells you how this project is maintained, and the shape is unusual.

Version 3.5.0 was tagged on 2021-07-08 and 3.5.1 on 2021-07-13, a five-day gap between two patch-level releases. Then there is a long silence, and v3.6.0 appears on 2026-08-07, with the last push to the default branch on the same day. The v3.6.0 note reads jQuery 4 support and typings file.

So the project was quiet for roughly five years and then released a version whose headline feature is compatibility with the current jQuery. Read one way, that is a maintenance release that unblocks adoption on a modern jQuery. Read another way, it is a sign that the plugin's development was sporadic, and the README's own emphasis on the Community Edition and the presence of a paid edition should be weighed alongside that.

The typings file deserves a specific mention, because the absence of TypeScript definitions was a genuine barrier to adoption of a grid of this size, and the `types` field now points at `pqgrid.d.ts` with the `exports` map providing types for the root entry.

The repository is not archived, and the last push was on 2026-08-07. Anyone considering it should judge it on that basis rather than on the earlier 3.5.x cadence, and should read the shipped `ChangeLog.txt` to see what changed between the two lines.

The cross-browser support claim in the feature list, which includes IE11, dates from the same era, and a plugin that lists IE11 among its targets is a plugin whose code style you can expect to read.

Editorial conclusion

Adopt ParamQuery Grid when your application needs a grid that behaves like a spreadsheet rather than like a list, when the dataset can be held in the browser or paged from a server, and when you are prepared to meet the GPL v3 terms by publishing source for derived work. Do not adopt it for a read-only table where a plain markup table or a server-rendered list would do, and do not adopt it inside a closed-source commercial product without checking the copyleft obligations first, because the free edition is GPL. Before you build, confirm that your users' jQuery version falls in the declared peer range of at least 2.2.4 and below 5, and note that the last push was on 2026-08-07, with the current release v3.6.0 adding jQuery 4 support and a typings file.

Frequently asked questions

Official sources

1. Issues
2. License: GPL-3.0
3. paramquery/grid on GitHub
4. README
5. Releases