Open Source · MIT Licensed

The only Go library that actually calculates.

Read, write, and evaluate Excel files in Go. Compiled formula engine, incremental recalculation, zero dependencies.

main.go
package main

import "github.com/werkbook/werkbook"

func main() {
    wb, _ := werkbook.Open("financial_model.xlsx")
    sheet := wb.Sheet("Summary")

    // Change one cell — only the affected subgraph recalculates
    sheet.Set("B2", 150000)

    // Formulas compile to bytecode, not interpreted strings
    revenue := sheet.Get("D10")  // =SUM(B2:B9)*1.08
    margin  := sheet.Get("D15")  // =IF(D10>100000, D10*0.12, D10*0.08)

    fmt.Println(revenue) // 583200
    fmt.Println(margin)  // 69984
}

Built different, from the ground up

Other Go libraries read and write Excel. Werkbook reads, writes, and thinks.

Compiled formula engine

Formulas are parsed once, compiled to bytecode, and executed in a stack-based VM. No reflection. No re-parsing.

Incremental recalculation

A dependency graph tracks which cells depend on which. Change one cell, recalculate only the affected subgraph.

Zero dependencies

Built entirely on the Go standard library. No dependency tree to audit, no supply-chain risk, no binary bloat.

The only compiled formula engine in Go

Other libraries store formulas as opaque strings. Werkbook parses, compiles, and executes them — just like Excel does.

Without Werkbook
cell := sheet.Get("D10")
fmt.Println(cell) // "=SUM(B2:B9)*1.08"
// Just a string. No value. 😐
With Werkbook
cell := sheet.Get("D10")
fmt.Println(cell) // 583200
// Compiled. Calculated. Done. ✓

Excel-correct, not adjacent

Matches Excel behavior for type coercion, operator precedence, date serial numbers — including the 1900 leap year bug.

1,400+
Tests passing
Excel parity verified

Smart dependency graph

Tracks cell-level dependencies. Changing B2 only recalculates formulas that reference it — not the entire workbook.

B2
D10
D12
D15
changed recalculated updated

Comprehensive functions

50+ core functions free. 500+ with Pro — including full financial, statistical, and engineering suites.

SUM VLOOKUP IF INDEX IRR NPV XIRR NORM.DIST +450 more

Your go.sum stays clean

No transitive dependencies means smaller binaries, faster builds, and zero supply-chain risk.

werkbook
0 deps
excelize
26 deps

Up and running in minutes

No configuration. No setup wizards. Just go get and go.

1

Install

go get github.com/werkbook/werkbook
2

Open

wb, _ := werkbook.Open("file.xlsx")
3

Calculate

val := sheet.Get("D10")

Free to start. Pro when you need it.

The Community Edition covers most use cases. Go Pro when spreadsheet logic is business-critical.

Open Source

Community

Free forever · MIT

Full XLSX read/write, formula engine, and the most-used Excel functions.

Full XLSX read/write (cells, sheets, shared strings)
Compiled bytecode VM & dependency graph
~50 core functions (SUM, VLOOKUP, IF, INDEX, ...)
Lazy evaluation & incremental recalculation
Circular reference detection
Zero external dependencies
Get Started — Free
Coming Soon
Commercial License

Pro

$49 / dev / month

Everything in Community, plus full function coverage, streaming I/O, and priority support.

Everything in Community
500+ Excel functions (Financial, Statistical, Engineering)
Streaming reader/writer for 100K+ rows
Dynamic arrays, XLOOKUP, FILTER, SORT
Charts, pivot tables, images, conditional formatting
Priority support & SLA available
Join the Waitlist

Stop shelling out to LibreOffice

Start calculating Excel files natively in Go. Open source, zero dependencies, battle-tested with 1,400+ tests.