compare
DHTMLX Alternative That Drops In With a Script Tag
Last updated 9 September 2026
No build step, no bundler, no runtime dependencies. Add a stylesheet and a script, write a tag, and the grid is on the page. That makes it a fit for the same places DHTMLX suits: internal tools, admin panels, and .NET, Java or jQuery apps where a front-end build pipeline was never the plan. Here is what it takes, and what it costs.
Build on localhost, free See the script-tag setup
No key, no countdown, no sales call.
If you need the suite, stay on DHTMLX
One thing to settle first, so the rest of the page is useful. DHTMLX list a broad component suite beyond the grid on their own site, with a long track record behind it. If you need that wider component set from a single vendor, that breadth is a genuine reason to stay, and nothing here will talk you out of it. Lattice Grid is a data grid. The case for it is depth in the grid and the shape of the licence, not breadth across a suite, so if the suite is why you are on DHTMLX, this comparison is not for you.
Drops in with a script tag
This is the part that is genuinely different, and it is the reason to read on. There is no compile step and nothing to add to a bundler, because there is no bundler in the loop. Add the stylesheet and the module, write the tag, and you have a working grid. This runs when pasted onto a plain page:
<link rel="stylesheet" href="https://cdn.latticegrid.dev/lattice-grid@1.104.0/lattice-grid.min.css">
<script type="module" src="https://cdn.latticegrid.dev/lattice-grid@1.104.0/modules/webcomponent.esm.min.js"></script>
<lattice-grid
row-key="id"
columns='[{"field":"invoice","title":"Invoice"},{"field":"amount","title":"Amount","type":"number"}]'
rows='[{"id":1,"invoice":"INV-1001","amount":465.32}]'
></lattice-grid>
That is the whole setup on a page without a build. Scalar settings go on as
attributes; for real data you set the rows and
columns properties in a line of script, or call
createGrid on an element directly. Either way there are no
runtime dependencies to resolve and nothing to transpile, so it drops onto a
server-rendered page the same way a chart widget would.
The web component guide covers the no-build setup in full, including how to pass structured data as properties.
Nothing is gated. Start there.
The whole grid runs on localhost, free: every feature, no key, no countdown, no sales call. Deploy it somewhere without a key and it still renders everything, with a small trial watermark. So the honest first move is to build the screen, show it to whoever asked for it, and deal with the money afterwards.
The live grid below is running through the DHTMLX compatibility module: the
calling code uses a Grid shaped like dhx.Grid, with a Lattice
Grid underneath. It is one import swap for a lot of DHTMLX code. Sort a
column, edit a cell, and see it behave. See its size next to every other
module in the module map.
What it costs here, and how to compare it
Lattice Grid is one number per domain, with the developer count and the project count left out of it entirely: a named domain is $1,000 and a wildcard is $10,000, each with unlimited developers, no project cap and a year of updates and support, paid once. Add a hostname and you add a licence; add people or applications on the same hostname and nothing changes.
| What you are buying | Lattice Grid, per domain |
|---|---|
| Price | $1,000 for a named domain, $10,000 for a wildcard, paid once |
| Developers | Unlimited, including contractors and build agents |
| Applications on that hostname | No cap |
| What the price is attached to | The hostname you serve the grid from |
| Support and updates | One year included, renewing optional, what you shipped keeps working |
| Evaluation | Free on localhost, every feature, no key, no time limit |
To put that beside DHTMLX, read their current tiers and figures on dhtmlx.com and ours on our pricing page, then work both out for the team, the applications and the hostnames you actually have. We do not restate their numbers here, because a price copied onto our page is out of date the moment theirs moves. What is worth comparing is what each price is attached to: ours is attached to the hostname, so it does not move when the team or the project list does.
Lattice Grid pricing is on our own pricing page; a licence includes one year of support and renewing is optional. Development on localhost is free, with every feature and no key.
Where the grids line up
Both are capable, commercially supported grids. The difference is the shape of the licence and how it reaches the page.
| Capability | DHTMLX | Lattice Grid |
|---|---|---|
| Licence unit | See their pricing | The domain you serve from |
| Price when the team grows | See their pricing | Unchanged |
| Price when you add an application | See their pricing | Unchanged, on the same hostname |
| Sorting, filtering, grouping | See their docs | Included |
| Editing and validation | See their docs | Included, one undo stack |
| Excel export | See their docs | Included, no extra dependency |
| Runtime dependencies | See their docs | None |
| Build step required | See their docs | None; a script tag mounts it |
Everything in the Lattice Grid column is in the release shipping today. Their side is theirs to publish and theirs to change, so read it on dhtmlx.com rather than taking a snapshot of ours.
The part most grids leave to you
These are the tools that matter once the grid stops being a page you build and becomes the screen somebody uses all day. They are in the one edition here. If they matter to you, look for each of them by name on any grid you are weighing, ours included.
| Capability | In Lattice Grid |
|---|---|
| Statistics layer | Median, p95, deviation and a full column profile over the filtered rows |
| Value diagnostics | A live read on the shape and health of the data you are looking at |
| Charts from grid rows | 35 types, drawn from the grid's own filtered rows, with no second library |
| Presentation mode | Scale to a room, saved views as slides, spotlight rows, still live |
| Redaction and annotations | Mask a column, or draw over the grid, for a screen share |
| Unit types | IP as 32-bit, durations, unit families, hex, JSON as columns |
Moving from DHTMLX
The move is more tractable here than for most grids, because of that
compatibility module: a Grid class shaped like dhx.Grid, with the
same constructor and the same data, selection,
history, export and events namespaces,
so much of your existing DHTMLX code runs with an import swap. Where you move
to the native API instead, the concepts line up closely:
| DHTMLX concept | Lattice Grid equivalent |
|---|---|
new dhx.Grid(el, config) | createGrid(el, config) |
columns: [{ id, header }] | columns: [{ field, title }] |
data / grid.data.parse() | rows |
grid.data.add() | grid.rows.apply() |
grid.events.on() | the grid's event API |
The only reliable way to size the move is to build the real screen against your own data. On localhost that is free. If it looks worth doing, tell us what you are coming from and we will help with the migration. Get in touch.
Common questions
Do I need a build step or a bundler to use Lattice Grid?
No. Add one stylesheet and one script to the page and write a tag, or call createGrid on an element. It is vanilla JavaScript with no runtime dependencies, so it runs on a Rails, Django, Laravel, .NET or plain server-rendered page with nothing to compile. There are optional adapters for React, Vue and Svelte if you want them, but they are not required.
How does the licensing differ from DHTMLX?
Lattice Grid is $1,000 for a named domain or $10,000 for a wildcard, paid once, with unlimited developers and no per-project cap. The price is tied to where the grid runs, not to how many people or how many apps use it, and every figure is on our pricing page. DHTMLX publish their current tiers on dhtmlx.com; read them there and compare the two on the day you buy, because a price is the thing most likely to have moved since anyone wrote about it.
Is Lattice Grid a drop-in replacement for the DHTMLX grid?
Close, and closer than most. A compatibility module exposes a Grid shaped like dhx.Grid, with the same constructor and the same data, selection, history, export and events namespaces, so a good deal of DHTMLX calling code runs against Lattice Grid underneath with an import swap. Where you use it directly it is a different API, so it is a translation rather than a redesign, and every feature runs free on localhost so you can size the move first.
Build it on localhost. Decide afterwards.
Every feature, no key, no time limit. License the domain when you are ready to ship.
Or see the pricing, open the demos, or compare against AG Grid and Handsontable.