# IronCalc: A Work-in-Progress Rust Spreadsheet Engine with Python and WASM Bindings

> IronCalc is an open-source spreadsheet engine written in Rust that reads and writes xlsx files and provides bindings for Python, Node.js, and WebAssembly. The README describes it as a new, modern, work-in-progress project and an early-stage effort to build a more open infrastructure for spreadsheet computation.

**ironcalc/IronCalc** — Main engine of the IronCalc ecosystem

- Repository: https://github.com/ironcalc/IronCalc
- Website: https://www.ironcalc.com
- Stars: 4,181 · Forks: 189
- Language: Rust
- License: Apache-2.0
- Published: 2026-09-10 · Updated: 2026-09-10 · Language: en
- Canonical page: https://hysenlabs.com/projects/ironcalc-ironcalc

## What IronCalc Is and Why It Exists

IronCalc is a spreadsheet engine and a set of tools for working with spreadsheets in environments where Excel, LibreOffice, or a web-based spreadsheet are not appropriate. The README describes its purpose as building a more open infrastructure for spreadsheets: an alternative to the proprietary calculation engines that underlie most spreadsheet applications.

The core engine is written in Rust and handles formula evaluation, cell references, and the xlsx file format. The engine is designed to be embedded: a developer integrates it as a library in a Rust application, calls it from Python via bindings, runs it in a browser via WebAssembly, or uses it from Node.js.

An early interactive preview runs entirely in the browser at app.ironcalc.com. This preview is described in the README as an early preview of the technology, not a finished product. The repository is dual-licensed under MIT and Apache-2.0, and the README includes a call for contributors across Rust, Python, TypeScript, React, design, and business roles.

The README's description of the project vision includes planned skins: a terminal interface, a desktop application, and an embeddable web application. The webapp/ directory already contains the embeddable widget at webapp/embed.ironcalc.com/ and the full web application at webapp/app.ironcalc.com/, showing that the web skin is under active development. A generate_language/ directory and a generate_locale/ directory exist at the root, which the workspace excludes from the main Cargo build, suggesting that locale and language support are generated artifacts rather than hand-written source files.

## The Rust Core and the xlsx Crate

The Cargo.toml workspace defines five crates: base, xlsx, bindings/wasm, bindings/python, and bindings/nodejs. The base crate is the calculation engine. The xlsx crate reads and writes .xlsx files. The binding crates expose the engine to each target language.

```toml
[workspace]
resolver = "2"

members = [
  "base",
  "xlsx",
  "bindings/wasm",
  "bindings/python",
  "bindings/nodejs",
]
```

The release profile enables link-time optimization (lto = true), which reduces binary size at the cost of longer compile times. Building from source requires the Rust toolchain:

```bash
cargo build --release
```

The README documents that the API is published at docs.rs/ironcalc/latest/ironcalc/ and can be generated locally:

```bash
make docs
cd target/doc
python -m http.server
```

Visit http://0.0.0.0:8000/ironcalc/ to browse the local API documentation.

## Docker Quick Start and the Web Application

For developers who want to test IronCalc without building from source, the repository provides a Docker Compose configuration. Running the following command starts a server and a Caddy reverse proxy:

```bash
docker compose up --build
```

The application is then available at http://localhost:2080. The docker-compose.yml uses two services: a server built from the ironcalc-server image (tagged at 0.8.3) and a Caddy proxy. The Dockerfile shows the full build chain: it compiles the Rust server, builds the WebAssembly bindings via wasm-pack, builds the React widget in webapp/IronCalc, and builds the frontend application in webapp/app.ironcalc.com/frontend.

The webapp/ directory contains three applications: the IronCalc widget (webapp/IronCalc/), the public web application at app.ironcalc.com (webapp/app.ironcalc.com/), and an embeddable widget for third-party sites (webapp/embed.ironcalc.com/). The webapp applications are excluded from the workspace Cargo.toml because they have their own server written in Rust that is built separately.

## Using IronCalc in a Rust Application

The README gives a minimal Rust example. Add the dependency to Cargo.toml:

```toml
[dependencies]
ironcalc = { git = "https://github.com/ironcalc/IronCalc", version = "0.8"}
```

Then use the Model API in main.rs:

```rust
use ironcalc::{
    base::{expressions::utils::number_to_column, Model},
    export::save_to_xlsx,
};
```

The README's example creates an empty model named hello-calc.xlsx with English locale and UTC timezone, fills a 99 by 99 grid of cells with the product of row and column numbers, adds a new sheet named Calculation, and then references the last column using the number_to_column utility. The example is in the README's simple example section and is also available in the examples folder of the xlsx crate.

The Model struct is the central API. It handles cell input, formula evaluation, and sheet management. The export::save_to_xlsx function writes the model to an xlsx file.

## Testing, Coverage, and the Test Suite

The Makefile documents the full test suite:

```bash
make tests
```

This runs lint checks (cargo fmt and clippy), Rust unit and integration tests, JavaScript type checks and tests for the WebAssembly bindings and the webapp, Python binding tests, Node.js binding tests, and a check that the language binary file is up to date. The lint step uses clippy with four warning flags: clippy::unwrap_used, clippy::expect_used, clippy::panic, and D warnings, which treats unwraps and panics as errors.

Code coverage is tracked externally and can be generated locally:

```bash
make coverage
cd target/coverage/html/
python -m http.server
```

The README links to Codecov for the public coverage report. Running make tests on a developer machine requires all five binding targets to be set up: Rust, wasm-pack, Node.js, pnpm, and Python with the test runner configured.

## Alternative: HyperFormula, License, and Early-Stage Status

HyperFormula is a JavaScript spreadsheet engine that evaluates spreadsheet formulas without a backend. Its approach differs from IronCalc in two ways. First, HyperFormula is JavaScript-native, which means it runs in a browser or Node.js without requiring WebAssembly compilation. Second, it focuses on formula evaluation rather than on file format support; reading and writing xlsx files is not its primary function.

IronCalc's difference is its language stack: a Rust core with first-class Python, Node.js, and WebAssembly bindings, plus an xlsx reader and writer in the same workspace. For a team building a Python application that needs to generate xlsx files programmatically with formula evaluation, IronCalc's Python binding provides a single library that covers both concerns.

IronCalc is dual-licensed under MIT and Apache-2.0. Users may choose either license. The README describes the project as being in its very early stages, with the community not yet established. The latest release is v0.8.3, dated 2026-08-03, with two prior releases v0.8.2 and v0.8.0 published in July 2026. The last push was on 2026-09-22.

## Conclusion

IronCalc is appropriate for developers who want to embed spreadsheet computation into a Rust, Python, Node.js, or WebAssembly application and are comfortable working with a project that the authors themselves describe as work-in-progress and early-stage. It is not an appropriate choice for production applications that require a stable API, long-term support, or commercial backing, because the README explicitly acknowledges that the project is in its early stages and does not yet have a stable community. Teams evaluating IronCalc should review the API at docs.rs/ironcalc and test the online preview at app.ironcalc.com before committing. The latest release is v0.8.3, published on 2026-08-03.

## FAQ

### What is IronCalc?

IronCalc is a spreadsheet engine written in Rust that reads and writes xlsx files and evaluates spreadsheet formulas. It is designed to be embedded in other applications through bindings for Python, Node.js, and WebAssembly. The README describes it as a new, modern, work-in-progress project.

### What programming languages can use IronCalc?

The Cargo.toml workspace includes binding crates for WebAssembly, Python, and Node.js, alongside the core Rust library. The README also mentions possible future bindings for R, Julia, and Go, but only the WebAssembly, Python, and Node.js bindings are in the current workspace.

### Does IronCalc support reading and writing xlsx files?

Yes. The workspace includes a dedicated xlsx crate for reading and writing xlsx files. The README's simple example demonstrates creating a model, populating cells, and saving the result with save_to_xlsx. The xlsx crate is a separate workspace member from the core base crate.

## Sources

- [ironcalc/IronCalc on GitHub](https://github.com/ironcalc/IronCalc)
- [License: Apache-2.0](https://github.com/ironcalc/IronCalc/blob/main/LICENSE)
- [Project website](https://www.ironcalc.com)
- [README](https://github.com/ironcalc/IronCalc/blob/main/README.md)
- [Releases](https://github.com/ironcalc/IronCalc/releases)

---

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