Skip to content
Pre-releasev0.3.0 (unreleased)Apache-2.0

Write massive Excel files. Not massive memory bills.

Hypaxel is a family of high-performance, constant-memory XLSX writers for .NET, Rust, Python, Node.js, browsers (WebAssembly), Go, Java and PHP, built for web services. Streaming readers for .NET, Rust, Python, Go and Java.

by vensas GmbH
Spreadsheet grid spelling HYPAXEL, with a row of cells filling up to the formula =STREAM("xlsx", ".NET", "Rust", "Python", "Node.js", "WebAssembly", "Go", "Java", "PHP")

A1 Quick start

Install, write, stream.

Pick your language. Every example below comes from the Hypaxel documentation.

.NET

.NET 8, 9, 10, 11 · Native .NET, no dependencies; writer and streaming reader

dotnet add package Hypaxel
dotnet add package Hypaxel.AspNetCore

Not published yetHypaxel, Hypaxel.AspNetCore are not on NuGet yet. The command above is what installation will look like once it is.

Web: ASP.NET Core: Results.Extensions.Excel(...), this.Excel(...)

.NET documentation
ASP.NET Core minimal API
using Hypaxel.AspNetCore;

// Objects → worksheet with header, frozen top row and auto filter.
// EF Core rows stream from the database to the browser.
app.MapGet("/orders.xlsx", (AppDb db) =>
    Results.Extensions.Excel(db.Orders.AsNoTracking().AsAsyncEnumerable(), "orders"));

B1 Features

Built for exports that don't fit in memory.

  • Constant-memory writing

    Each cell is serialized to UTF-8 XML as it is written and deflated into a small buffer. Memory stays flat whether you export 10 rows or 10 million.

  • Streaming readers

    The .NET, Rust, Python, Go and Java readers return rows one at a time, with memory bounded by the shared string table plus one row. Each has its own dependency-free parser.

  • Streams while you query

    The destination never has to be seekable, so the first bytes reach the HTTP client while your database query is still running.

  • Measured against the incumbents

    Every implementation ships benchmarks against the established writers and readers in its ecosystem, with the hardware, versions and commands to reproduce them.

  • Seven languages and the browser

    .NET, Rust, Go, Java and PHP are native engines with no runtime dependencies. Python and Node.js run on the Rust core, which also runs in browsers as WebAssembly.

  • Web framework integration

    Download helpers for ASP.NET Core, axum, FastAPI, Django, Flask, Express, Fastify, Next.js, Hono, net/http, Spring, Symfony and Laravel.

  • Valid, real Excel files

    Output is checked against the Office Open XML schema validator and read back by independent readers such as Open XML SDK, calamine, openpyxl and LibreOffice.

  • Spreadsheet features you need

    Styles, dates, formulas, multiple sheets, frozen panes, merged cells, auto filters, Excel tables, row grouping and auto-fit columns.

C1 Performance

Benchmarked in every ecosystem.

Each implementation is benchmarked against the established XLSX writers and readers of its own ecosystem, on the same 10-column dataset. The results below are copied from the benchmark sections of the repository, including the hardware, versions and commands used.

  • .NET~0.8 s1M rows on .NET 9+~20–25x faster than ClosedXML
  • Rust~0.73 s1M rows~11–14x faster than rust_xlsxwriter
  • Python~0.9 s1M rows~50x faster than XlsxWriter, ~95x faster than openpyxl
  • Node.js~1.2 s1M rows~6x faster than ExcelJS's streaming writer
  • Browsers~0.5 s300k rows in Chrome (WebAssembly)~12–15x faster than SheetJS, ~20x faster than ExcelJS
  • Go~0.9 s1M rows~5–6x faster than excelize's StreamWriter
  • Java~1.2 s1M rows~2.5–3x faster than FastExcel, ~8–9x faster than POI SXSSF
  • PHP~4.2 s1M rows (~2.9 s with JIT)~11x faster than OpenSpout, ~40x faster than PhpSpreadsheet

Timings come from each implementation's own benchmark, run at different times and partly on different machines. Compare each Hypaxel result with the other libraries in the same table, not across languages.

Python: 100,000 rows

10 columns per row: integers, strings (one unique per row), floats, a date/time and a boolean

Xeon 2.1 GHz, Python 3.13

All results and methodology
Timelower is better
  1. Hypaxel write_rows0.1 s, 1.1×
  2. Hypaxel stream_rows0.09 s, best
  3. XlsxWriter (constant_memory)5.15 s, 57×
  4. openpyxl (write_only)9.48 s, 105×
  5. Hypaxel pandas DataFrame*0.27 s, 3.0×
  6. pandas.to_excel (xlsxwriter)*8.68 s, 96×
  7. Hypaxel polars DataFrame*0.21 s, 2.3×
  8. polars.write_excel*6.15 s, 68×

D1 How it works

One forward-only pass from row to response.

Hypaxel writes .xlsx files as a forward-only stream. Each cell is serialized to UTF-8 XML the moment it is written and compressed straight into a small buffer that flushes to the destination.

 rows ──▶ ▓▓▓ UTF-8 XML ──▶ ▒▒▒ deflate ──▶ ░░░ small buffer ──▶ HTTP response / file
          one cell at a time                 flushed as it fills
  1. 01

    Forward-only by design

    Rows are written top to bottom and cells left to right, one worksheet at a time. Column widths, frozen panes and outline depth are declared when a sheet is created, because they come before the cell data in the file.

  2. 02

    Hand-written, compact XML

    Markup is appended as precomputed byte literals to a reused buffer, with no XML library. Cell references are only written after a gap, which removes about 20% of the XML that has to be deflated.

  3. 03

    No seeking, ever

    Compressed output is buffered up to a flush threshold (64 KiB by default) and then written in one call. The Rust, Java and PHP engines write their own front-to-back ZIP container with data descriptors; .NET drains ZipArchive output from a pooled buffer with async I/O.

  4. 04

    Native engines and bindings

    .NET, Rust, Go, Java and PHP are independent implementations of the same design. Python (PyO3) and Node.js (napi-rs) call into the Rust core, with the per-row loops running in native code. In browsers the same Rust core runs as WebAssembly and produces byte-identical files.

  5. 05

    Compression is the main dial

    Deflate level 1 is the default. Higher levels produce noticeably smaller files at several times the CPU cost, and every implementation lets you choose.

  6. 06

    Bounded exceptions

    Shared string tables grow with the number of distinct strings, and auto-fit holds back a sheet's output until its sample is measured (1,000 rows or 8 MiB of XML by default). Both are opt-in.

E1 Languages

7 language ecosystems, one design.

  • .NET

    Not published yet
    Package
    Hypaxel, Hypaxel.AspNetCore
    Runtime
    .NET 8, 9, 10, 11
    Engine
    Native .NET, no dependencies; writer and streaming reader
    Registry
    NuGet (not yet)
    Install and use
  • Rust

    Not published yet
    Package
    hypaxel, hypaxel-axum
    Runtime
    Rust 1.85+
    Engine
    Native Rust, #![deny(unsafe_code)]; writer and streaming reader
    Registry
    crates.io (not yet)
    Install and use
  • Python

    Not published yet
    Package
    hypaxel
    Runtime
    CPython 3.10+
    Engine
    Rust core via PyO3; writer and streaming reader
    Registry
    PyPI (not yet)
    Install and use
  • Node.js

    Not published yet
    Package
    hypaxel
    Runtime
    Node.js 22+; browsers with WebAssembly (Chrome/Edge 96+, Firefox 79+, Safari 15+)
    Engine
    Rust core via napi-rs (Node.js) and WebAssembly (browsers)
    Registry
    npm (not yet)
    Install and use
  • Go

    Not published yet
    Package
    github.com/vensas/hypaxel/go
    Runtime
    Go 1.26+
    Engine
    Native Go, standard library only; writer and streaming reader
    Registry
    Go modules (not yet)
    Install and use
  • Java

    Not published yet
    Package
    de.vensas:hypaxel
    Runtime
    Java 17+
    Engine
    Native Java, java.base only; writer and streaming reader
    Registry
    Maven Central (not yet)
    Install and use
  • PHP

    Not published yet
    Package
    vensas/hypaxel
    Runtime
    PHP 8.2+ (64-bit), ext-zlib
    Engine
    Native PHP, no runtime dependencies
    Registry
    Packagist (not yet)
    Install and use

F1 Licensing

Licensing

Community

Apache-2.0

The complete XLSX writers and readers in all seven languages.

Free

  • All seven language implementations
  • Streaming, constant-memory writing
  • Streaming readers (.NET, Rust, Python, Go, Java)
  • Browser build (WebAssembly)
  • Styles, tables, row grouping, auto-fit
  • Web framework integrations
  • Commercial use permitted under Apache-2.0
Read the docs

G1 FAQ

Frequently asked questions

What is Hypaxel?

A family of XLSX writers that stream Excel files instead of building them in memory. Each cell is serialized and compressed as it is written, so exports of any size run with a small, fixed amount of buffer memory.

Which programming languages are supported?

.NET (8, 9, 10, 11), Rust 1.85+, Python 3.10+, Node.js 22+, Go 1.26+, Java 17+ and PHP 8.2+, plus browsers through WebAssembly (Chrome and Edge 96+, Firefox 79+, Safari 15+). .NET, Rust, Go, Java and PHP are native engines; Python, Node.js and the browser build run on the Rust core.

Can Hypaxel generate large Excel files?

Yes. Output is streamed, so the file size does not drive memory use. Excel's own limits still apply: 1,048,576 rows and 16,384 columns per worksheet and 32,767 characters per cell.

How does its memory usage behave?

It stays flat as rows grow. The .NET writer, for example, holds about 64 KiB of XML plus about 96 KiB of compressed output per export by default. Two opt-in features use more: shared strings keep every distinct string, and auto-fit buffers its sample rows.

Can Hypaxel read or edit existing Excel files?

It reads them in .NET, Rust, Python, Go and Java. The readers stream rows one at a time, with memory bounded by the shared string table plus one row, and recognise dates, times and durations from number formats. Node.js and PHP do not read yet. Editing existing files (read-modify-write for templates) is on the roadmap.

Does Hypaxel run in the browser?

Yes. The hypaxel npm package runs in browsers on the Rust core compiled to WebAssembly (171 KB gzipped), with the same API as in Node.js. toBlob() creates a file for download and webStream() streams one. Bundlers pick the browser build automatically.

Is Hypaxel open source? Can I use it commercially?

Yes. The source is on GitHub and licensed under the Apache License 2.0, which permits commercial use. The packages are not published to registries yet.

Where can I find installation instructions?

The getting started guide covers every language, and each language guide lists the package names, runtime requirements and integration examples.

How do I report bugs?

Open an issue in the GitHub repository at github.com/vensas/hypaxel. Include the language, package version and a minimal example if you can.

Build Excel exports without the memory headache.

Pick your language and write your first streamed workbook in a few lines.