Coming Soon · Open Source · Modified MIT
The spreadsheet for humans and agents.
An open-source spreadsheet engine rebuilt in Rust. Dynamic arrays, pivot tables, XLOOKUP — with Python and Node.js SDKs built for AI.
SDK packages will be published at launch. Follow for updates
Live spreadsheet running in your browser via WebAssembly — not a screenshot.
Use Cases
Built for developers and agents
Embed in your app
Drop a full spreadsheet into any web app with one React component. Dynamic arrays, pivot tables, and 582 functions out of the box.
Run on a server
Process XLSX files, evaluate formulas, and generate reports server-side with the Node.js or Python SDK. No browser required.
Power AI agents
Give LLMs structured access to spreadsheet operations. The SDK’s typed API is designed for tool-use — no screen scraping or prompt engineering.
Why Mog
A complete spreadsheet engine, not just a UI component.
Built for humans and agents
A structured API that LLMs can call directly. Python and Node.js SDKs designed for AI agent workflows — no screen scraping or macro hacks.
- Python SDK via PyO3 for AI agent workflows
- Node.js SDK via N-API with native performance
- Headless server for batch processing
- Tool-use-ready API (structured input/output)
Full Excel compatibility, rebuilt in Rust
582 functions, dynamic arrays, pivot tables, XLOOKUP, conditional formatting, and structured references. Not a subset — the real thing.
- 582 Excel-compatible functions
- Dynamic arrays, XLOOKUP, LAMBDA
- Pivot tables, conditional formatting, data validation
- Native XLSX parsing and writing (full OOXML spec)
Real-time, offline-first, conflict-free
CRDT-based collaboration powered by Yrs. Works offline, syncs when connected, never loses data. No operational transform complexity.
- CRDT collaboration via Yrs (Rust)
- Cell identity model for conflict-free formulas
- Offline-first with automatic sync
- Canvas rendering at 60fps via binary wire protocol
Architecture
One Rust engine, every platform
Written once in Rust, compiled to three targets. Same code in the browser, on a server, and in a Python notebook.
Browser
WebAssembly
Runs in a Web Worker. Zero server round-trips for computation.
Node.js
N-API
Native binaries for macOS, Linux, and Windows. No WASM overhead.
Python
PyO3
Native Python bindings. Use spreadsheet formulas alongside pandas.
Rust compute core
Formulas, dependency graph, pivot tables, conditional formatting, and XLSX parser — all Rust. One annotated API generates bindings for every target.
compute-core
parser, functions, graph, formats,
schema, stats, charts, cf, pivot,
table, fill, solver, collab, wire
Binary wire protocol
Viewport data as compact binary buffers, not JSON. Zero allocations per cell. 60fps on large sheets.
Viewport buffer
36B header + N × 32B cell records
+ string pool + format palette
Mutation patches
Spliced directly into the viewport
buffer — no deserialization step
SDK
Programmatic access to everything
One Rust engine, every SDK. Same API in Python and TypeScript.
Python
import mog
wb = mog.create_workbook()
ws = wb.active_sheet()
# Set values and formulas
ws.set_cell("A1", "Revenue")
ws.set_cell("A2", 150000)
ws.set_cell("A3", "=A2 * 1.15")
# Dynamic arrays just work
ws.set_cell("B1", '=FILTER(A1:A3, A1:A3>100000)')
# Convert to pandas DataFrame
wb.calculate()
df = ws.to_dataframe()
wb.save("forecast.xlsx")Node.js
import { createWorkbook } from "@mog-sdk/node";
const wb = await createWorkbook();
const ws = wb.getActiveSheet();
// Set values and formulas
await ws.setCell("A1", "Revenue");
await ws.setCell("A2", 150000);
await ws.setCell("A3", "=A2 * 1.15");
// Structured table references
await ws.tables.add({ range: "A1:A3", name: "Forecast" });
await ws.setCell("B1", "=Forecast[@Revenue]");
// Batch operations into a single undo step
await wb.batch(async () => {
await ws.setRange("C1:C3", [["Q2"], [170000], ["=C2*1.15"]]);
});Built With Mog
Ready for your project
From AI agents to SaaS products to data pipelines. Be among the first to build with Mog.
AI agents
Structured spreadsheet API for LLM tool-use. No screen scraping.
SaaS products
Full spreadsheet in one React component. Dynamic arrays and all.
Data pipelines
Process XLSX server-side in Python or Node.js. No Excel required.
Frequently asked questions
What is Mog?
Mog is an open-source spreadsheet engine rebuilt from scratch in Rust. It provides a complete spreadsheet runtime — formula evaluation, dependency tracking, XLSX parsing, canvas rendering, and real-time collaboration — that you can embed in web apps, run on servers, or use from Python and Node.js.
Why Rust?
Rust gives us native performance, memory safety, and the ability to compile to WebAssembly (browser), N-API (Node.js), and PyO3 (Python) from a single codebase. One engine, every platform, zero garbage collection pauses.
Is Mog free?
Yes. Mog is open source under the Modified MIT license. Use it in personal projects, commercial products, or SaaS platforms.
How does Mog compare to existing spreadsheet libraries?
Most spreadsheet libraries focus on either UI rendering or file parsing. Mog provides the full stack: a Rust compute engine with 582 functions, canvas rendering, CRDT collaboration, and native SDKs. See the comparison page for a detailed feature matrix.
Is Mog production-ready?
Mog is in active development. The core engine (formulas, rendering, collaboration, XLSX) is functional and under testing. We’re working toward an open-source release — follow us for launch updates.
More questions? Read more about Mog
Interested in building with Mog?
Mog will be open source under the Modified MIT license.
Get notified when Mog launches