Every capability in the engine.

npm package

Install with npm or Yarn and import the engine as an ES or CommonJS module.

CDN builds

Load a full build with its dependencies from jsDelivr, or a minimal one when your page already ships them.

Server-side use

Install the same package in Node.js and require it on the server.

Headless engine

Build an instance from an array, from named sheets or empty, then read computed values out — there is no UI to work around.

Multi-sheet workbooks

Add sheets by name and let a formula on one read cells on another.

A1 notation

Address cells by sheet, column and row, or convert an A1 string such as "Sheet1!B2" into that address.

Configuration options

One options object at build time sets the engine’s behavior, from rounding precision to separators and date formats.

Coding agent setup

An official Claude skill, a single-file docs corpus and a Markdown version of every docs page, so an agent writes against the real API.

One API in every framework

The engine has no framework bindings to learn: the API is identical in a component and in plain JavaScript.

React

A documented pattern for holding the engine in a ref, creating it in an effect and destroying it on cleanup, safe under StrictMode.

Vue

A documented pattern for Vue 3 that keeps the engine out of the reactivity system and surfaces its values through refs.

Angular

The engine as an injectable service that exposes values as a signal, with a variant for NgModule-based apps.

Svelte

The engine created with the component and released in onDestroy, with its values bridged into Svelte’s reactivity.

Server-side rendering

Guidance for server-side rendering with Next.js, Nuxt, Angular Universal and SvelteKit.

Sheet operations

Add, remove, rename and clear sheets, or replace a sheet’s whole content in one call.

Row and column operations

Add, remove and move blocks of rows and columns, with every reference in every sheet updated to match.

Cell operations

Set the content of one cell or a block, move a range, and read back a cell’s value or its formula.

Changes array

Every modifying call returns the cells whose values changed, with their addresses and new values, so your UI knows what to redraw.

Operation checks

Ask whether an operation is allowed before running it, through isItPossibleTo* methods that return a boolean.

Batch operations

Combine many changes into one operation that recalculates once at the end, by callback or by suspending and resuming evaluation.

Clipboard operations

Copy, cut and paste ranges inside the engine, with relative references adjusted on paste the way a spreadsheet does it.

Undo and redo

Step back and forward through CRUD and move operations, with a configurable undo limit and a batch counted as one step.

Sorting data

Reorder rows or columns by a permutation your own sort produces, and check first that it can be applied.

Cell references

Relative, absolute and mixed references to cells, ranges, whole columns and whole rows, on the current sheet or another one.

Circular reference detection

A cycle returns #CYCLE! in the cells it involves while every other cell keeps calculating.

Types of values

Numbers, text, logical values, dates, times, currency and percentages, detected from what you pass in.

Detailed value types

A number keeps its subtype — date, time, currency or percentage — through arithmetic, and you can read it back per cell.

Types of errors

Spreadsheet error values such as #DIV/0!, #REF! and #VALUE!, each able to carry a message of its own.

Operators

Arithmetic, comparison, concatenation and percent operators, evaluated in the order of precedence spreadsheets use.

Built-in functions

A function library grouped as spreadsheets group it — financial, statistical, lookup, text, date and more.

Volatile functions

RAND, NOW, TODAY and the like recalculate on every change, while structure-dependent functions such as ROW recalculate only when the sheet’s shape does.

Named expressions

Name a cell, a range, a constant or a formula, globally or for one sheet, and use the name in any formula.

Array formulas

Operate on whole ranges at once, per formula with ARRAYFORMULA or everywhere through array arithmetic mode.

Localized function names

Write formulas with function names in the user’s language, so SUM can be typed as SOMME in French.

Localized errors

Error values in cells follow the language you set, alongside the function names.

Custom language packs

Add a language that is not shipped, starting from an existing pack as a template.

Date and time formats

Set which date and time formats the engine parses, such as US formats in place of the default European ones.

Custom date and time handling

Supply your own parse and stringify callbacks, for example backed by Moment.js, when the built-in formats are not enough.

Number format

Configure the decimal and thousands separators to match a region’s way of writing numbers.

Currency input

List the currency symbols to recognize, as a prefix or a suffix, and such input becomes a number tagged as currency.

Currency output

Plug a formatter into the TEXT function for grouped, non-dollar and accounting currency formats.

String comparison rules

Compare text by the user’s locale, with case, accent, case-first and punctuation handling each configurable.

Compatibility with Microsoft Excel

A documented configuration that aligns the engine with Excel’s default behavior as closely as the engine allows.

Compatibility with Google Sheets

A documented configuration that does the same for Google Sheets.

OpenDocument standard

Formula behavior conforms to the OpenDocument standard while following the practices Excel and Google Sheets set.

Criteria matching

Choose whether SUMIF, COUNTIF and other criteria functions use wildcards or regular expressions, and whether a whole cell must match.

Spreadsheet quirks on request

Opt in to Excel’s 1900 leap-year bug, empty results evaluating to zero, and whitespace ignored inside formulas.

Numerical precision

Floating-point results are rounded automatically, as Excel and Google Sheets do, with the rounding configurable.

Published list of differences

A full list of where behavior and results differ from Excel and Google Sheets, function by function.

Dependency graph

Cells and ranges are nodes in a graph of what depends on what, which sets the order formulas are evaluated in.

Cell precedents and dependents

Ask the graph which cells and ranges a cell or range reads from, and which ones read from it.

Selective recalculation

After a change, only the cells that depend on it are recalculated, not the whole workbook.

Large range optimization

A range is stored as a shorter range already seen plus one row, so formulas over growing ranges reuse each other’s work.

Formula reuse

Formulas that share a pattern, like a filled-down column, are stored with relative addressing and parsed once.

Lazy transformations

Reference updates after inserting or moving rows are applied when a formula is next needed, not all at once.

Custom functions

Add your own functions through a plugin, with argument validation, translated names, aliases, array results and a volatile flag.

Lookup column index

Turn on a column index to speed up VLOOKUP and MATCH on large or unsorted data, at the cost of memory.

Address mapping policies

Store each sheet densely or sparsely, or let the engine pick from how full the sheet is.

File import

Feed the engine what a CSV or XLSX parser such as PapaParse or ExcelJS reads, since it takes plain JavaScript arrays.

Unit tests

Over 5,000 unit tests, run in continuous integration on every commit.

Open source

The entire source code is on GitHub, to read, review and file issues against.

Independent security certificate

A certificate from TestArmy Group, after code review, white-box penetration testing and analysis of v3.3.0 against OWASP ASVS.

Dependency scanning

Dependencies are scanned for vulnerabilities with Fossa, Dependabot and Snyk.

Supported browsers

Each release is tested on the two latest versions of every modern browser, desktop and mobile.

Few dependencies

A short, published list of open-source dependencies, each with its license and author.

GPLv3 or proprietary license

Use it under GPLv3 in an open-source or non-commercial project, or buy a proprietary license for anything else.

Offline license key

A proprietary key is checked against the build date with no network connection.