The grid and workspace layer for operational apps. Start with an editable table, then add a review step, a board, server validation, bulk actions — each one reuses the rules and behavior you already defined. You make the product decisions; Wit keeps them consistent.
For developers building operational software — review queues, CRMs, work orders, inventory — inside their own product, on their own data, backend and policies.
In most stacks each new surface brings its own copy of the rules, its own preview and its own idea of what is saved — and the glue between them is yours to maintain. With Wit, each addition reuses what is already there, so the behavior you can stop thinking about grows with every feature.
prepare shows the exact effect; commit applies exactly that, or refuses it as stale.push answers per record: refusals roll back with the server’s reason, marked in every view.action, the server’s answer is an event.Every operational app runs into the same questions once people review, save and fix records together. Wit answers them centrally, so your app doesn’t re-answer them in every screen. Where an answer is still being hardened, we say so.
The server can refuse single records of a bulk change. Those roll back with its reason, marked in the table, on cards and in the inspector; the rest are saved, and what is still queued stays queued.
A reviewed change commits exactly as it was previewed, or is refused as stale when its records changed in the meantime. It is never applied blind.
Next: a review also goes stale when the rules or permissions change while it is open.
Every save reports what happened to each change it sent: saved, refused with the server’s reason, or still queued.
Next: a strict boundary, so edits made while a save is in flight wait for the next one, and manual saving sends only on Save.
Each change carries the value it was based on, so a server conflict keeps both sides for a person to settle instead of overwriting either.
Next: a slow validation result about an older value never replaces a newer one.
A pivot cell opens exactly its records in the table, as filters you can act on; a chart drills down to its records.
Next: measures with their own condition (“won deals only”) open only their contributors.
You keep control of everything that makes your product yours. Wit owns the consistency between the pieces — and is explicit about where its responsibility ends.
Deliberate boundaries: one grid is one table, and its views are projections of it. The workspace is optional and loads only when used. Wit names each action and reports each outcome; where the audit lives is your call.
A polished table is easy to demo. What matters is what happens when a review, a policy change and a server’s answer meet. The approval desk at the top of this page plays it end to end.
The dialog shows exactly which invoices change and how, before anything is written.
Every invoice is checked again at once; the ones now over it are marked in every view.
The request is your accounts-payable system’s own body, with each decision named.
That invoice rolls back with its reason; the others are saved; nothing else is lost.
The audit trail says who approved what, where, and what the server answered.
The grid stands on its own. When a record also needs to be a card, a calendar event or a Gantt bar, Wit Grid keeps it one record — the same filters, selection, permissions, validation and undo in every view. You declare a rule once; you don’t wire each view to the others.
Dense operations: pinned columns, grouping with totals, spreadsheet editing.
Workflows with WIP limits, swimlanes and rules for what a column needs.
Scheduling by month, week or hour; drag to reschedule, drop to plan.
Dependencies, baselines, constraints and the critical path.
Visual records with covers, sections and your own card layout.
Counts and totals by any field, with drill-down to the records.
Rows by some fields, columns from the values of others, every cell an aggregate. Pivoting is grid state, not a plugin — filtered, live, saved with views, exported and drilled into like everything else.
Any field across or down: dates by month or quarter, numbers by range, the top values with the rest as Other.
Share of the grand, row or column total, running totals, change from the last column, rank.
Shade cells by value; double-click one to list its records and open any in the inspector.
Pivot millions of rows on your server: one answer per pivot, groups opened in the browser.
Column groups merged, totals kept, every number typed in its format.
A field list to drag into, Pivot by column in every header, a Pivot tab saved with your views.
Same Chrome, same data, real input. Head to head against AG Grid on scroll, and against our own previous engine on live data — every number on this page comes from a recorded benchmark run.
AG Grid Community 36.2.0 with its defaults, same Chrome and data, real input, 5 paired rounds (30 Sep 2026); live data against our own previous engine, median per tick, one machine. Full scoreboard and method
Rows and columns: 100,000 × 1,000 keeps a few hundred cells in the DOM.
A centralized engine with targeted subscriptions repaints the cell that changed — never the tree.
Custom cells as React components or plain DOM renderers — part of the engine, never an afterthought.
Native text selection, accessibility roles, CSS theming and browser find all keep working.
Wit Grid treats editing as a core workflow, not an event callback sprinkled onto cells: every keystroke, paste and drag goes through one validated, undoable pipeline.
Arrows, Tab, Enter, F2, type-to-edit — the way spreadsheet users expect.
Select ranges, drag the handle to fill a series.
To and from Excel and Sheets, with types, validation and one undo step.
Every gesture is one transaction: validated, undoable, reported.
Rules per column and per row; refused writes are explained, not dropped.
People add fields, links, lookups, rollups and formulas themselves.
Configuration for the common cases — columns, views, record roles, rules and permissions. An API for everything else. Your own components where they matter — cell renderers and editors in React or plain DOM, card displays, slots, sidebar panels and commands. Underneath, Wit handles rendering, editing, validation, history and sync.
import {
Grid,
selectType,
personType,
currencyType,
} from '@witbybit/wit-grid-react';
const columns = [
{ field: 'deal', header: 'Deal', width: 240, pinned: 'left' },
{ field: 'stage', header: 'Stage', type: selectType(STAGES, { variant: 'fill' }) },
{ field: 'owner', header: 'Owner', type: personType({ people: REPS }) },
{ field: 'amount', header: 'Amount', type: currencyType({ decimals: 0 }) },
];
export function Deals({ rows }) {
return (
<Grid
rowModelType="client"
rows={rows}
columns={columns}
getRowId={(row) => row.id}
rowSelection="multiple"
/>
);
}GridApiState, editing, selection, undo, clipboard, exportColumnDefTypes, renderers, editors, validation, value gettersRow modelsclient · infinite · server, one UIEventsTyped; local and collaborators’ changes told apartWorkspaceViews, summary, slots, parts, extensionsPersistenceSaved views, layouts, fieldsThemingTokens, density, built-in themesStart with local data. Grow into server-driven datasets without replacing the UI layer: stable row identity, the same sorting, filtering and grouping contracts, cache and refresh controls.
An array in memory: sort, filter, group and edit instantly.
rowModelType='client'Pages loaded as people scroll, with loading rows in between.
rowModelType='infinite'The server sorts, filters, groups and pivots; the grid asks for blocks.
rowModelType='server'Wit Grid does not just display data. It helps people trust it.
Inline errors where the value is, a list of what is wrong, and gates on submit.
Values that must be unique are checked across the whole dataset.
A collaborator’s change to the cell you are editing is caught and resolved, not lost.
Who changed what, per record, alongside comments and files.
Wit Grid should disappear into your product until people need its power.
Colours, radii, density and fonts — or one of the built-in themes as a start.
Compact to comfortable, light and dark, switched live.
Hide toolbars and parts, add your own panels, slots and card widgets.
A cell in a form or the whole page — the same engine either way.
Wit Grid is a toolkit for your own product — not a hosted app builder you embed, and not someone else’s app.
| Need | Basic table | Spreadsheet | Grid component | Wit Grid |
|---|---|---|---|---|
| Large datasets | No | Limited | Yes | Yes |
| Built into your own app | Yes | No | Yes | Yes |
| Spreadsheet-grade editing | No | Yes | Yes | Yes |
| Multi-view workspace | No | Limited | Rare | Yes |
| Same records across table, board, calendar, Gantt | No | No | Rare | Yes |
| Server-scale row models | No | No | Yes | Yes |
| Pivot tables, client and server, in the core | No | Yes | Varies | Yes |
| Your own workflows and widgets | Medium | Low | Medium | High |
| New features reuse your rules and policies | No | Partly | Rare | Yes |
| Per-record outcome when your server refuses part of a save | No | No | No | Yes |
Operational software needs dense data, editing, validation, boards, timelines, charts, permissions and live updates — usually stitched together from separate libraries that each keep their own copy of the records. With Wit each of these starts as a grid; the board, calendar and inspector read and write the same records, so an edit, a refusal or an undo means the same thing everywhere.
Pipelines with a workflow, what-if forecasts, weighted totals and a deal room per record.
Ledgers and reconciliations: formulas, totals by group, read-only closed rows and activity on every record.
Controls with owners and evidence, required fields that hold submission, and history.
Shipments on a timeline and a board, live updates as they land, exceptions surfaced.
Hundreds of thousands of SKUs, server-side grouping by warehouse, bulk edits in one step.
Roadmaps as a Gantt with dependencies and a critical path, the same items as a board.
The depth behind every section above: editors, filters, charts, Excel, saved views, live teammates, conditional formatting and more — one engine, not a stack of plugins.
Selects, tags, people, dates, ranges, ratings, toggles, colours, sparklines — themed, keyboard-first, server-loaded options.
type: "select"Status columns with WIP limits and totals, swimlanes, multi-card drag with a drop slot, blocked work flagged.
kind: 'kanban'Every field edited by its column’s own editor, with comments and activity; Ctrl/⌘ K reaches every view and record action.
Ctrl + KOutline and timeline on one row model: dependencies with lag, working calendars, the critical path, baselines and workload. You see the knock-on before a move reschedules anything.
autoSchedule: 'push'Records stay on the device: the grid opens with what the user saw last, keeps working without a network, and syncs every edit to your server when it is back.
offline()Currency, percent and dates stay typed; groups export as collapsible outlines. No dependency.
exportExcel()A column’s filterDef drives the header funnel, floating row, sidebar, chips and query builder — relative dates included.
filterDefFeed in who is where: cursors glide between cells, rings sit on the cards and bars they are on, and their edits stay out of your undo.
api.setPresence()A view is a destination: a board with swimlanes, a schedule at a zoom, with its own filters, sort and columns. Yours, the team’s or the app’s, each saved as its owner acknowledges.
api.views.saveAs()Expandable groups with live aggregates, parent-child trees, and a sub-grid per row.
groupByColour scales, data bars and icon sets scaled to each column, repainting as live data moves — and kept in Excel.
kind: 'dataBar'Select across any view and move, assign, re-prioritise or shift dates for all of them: one transaction, validated and undoable.
api.transaction()Chart a selection or a column per category on a crisp canvas; click a bar to filter the grid.
createGridChart()A strip beside the scrollbar marks selection, recent edits and issues across 100k rows. Click to jump.
minimapNot shipped yet: real-time multiplayer editing (presence is in; syncing edits between people runs through your backend today), Excel import (export is in), and adapters beyond React (the core runs in any page).
Start with a grid. Add the reviews, views and server rules your users need — on the same records, under the same rules, without rewriting what you built.
Source-available for evaluation · read the license