Skip to content

Hypaxel / Benchmarks

Benchmarks

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.

Last updated

At a glance

  • .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

At a glance: reading

  • .NET~0.75–0.85 s1M rows (~0.55 s with background decompression)~2.4x faster than Sylvan.Data.Excel, ~5.5x faster than ExcelDataReader
  • Rust~0.75 s1M rows, 7–57 MB peak~2.8x faster than calamine's cell reader
  • Python~1.35 s1M rows, 68 MB peak~3.5x faster than python-calamine with ~12x less memory
  • Go~1.2 s1M rows, files ~40% larger (a reference on every cell)~11–14x faster than excelize's Rows and xlsxreader
  • Java~0.7 s1M rows~4x faster than the FastExcel reader, ~5–7x faster than POI's XSSFReader

.NET: 100,000 rows, mean time

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

.NET 10lower is better
  1. Hypaxel, typed Write78 ms, best
  2. Hypaxel, AddRowAsync76 ms, best
  3. Hypaxel, object mapping80 ms, 1.1×
  4. Hypaxel, shared strings89 ms, 1.2×
  5. SpreadCheetah75 ms, best
  6. ClosedXML1,845 ms, 25×
.NET: 100,000 rows, mean time
Case.NET 8.NET 9.NET 10.NET 11
Hypaxel, typed Write122 ms78 ms78 ms74 ms
Hypaxel, AddRowAsync127 ms87 ms76 ms75 ms
Hypaxel, object mapping118 ms78 ms80 ms75 ms
Hypaxel, shared strings159 ms97 ms89 ms90 ms
SpreadCheetah123 ms79 ms75 ms74 ms
ClosedXML2,369 ms1,910 ms1,845 ms1,773 ms
Hardware
Apple M1 Max, 10 cores, macOS 26.6
Runtime
.NET 8.0.34, 9.0.23, 10.0.15 and 11.0.0
Compared with
SpreadCheetah 1.29.0, ClosedXML 0.105.1, BenchmarkDotNet 0.15.8
Method
BenchmarkDotNet ShortRun, in-process toolchain.
  • Hypaxel and SpreadCheetah are within measurement noise of each other; both are roughly 20 to 25 times faster than ClosedXML.
  • .NET 8 is the slowest target and allocates more per workbook.
  • --inProcess is required on .NET 11, which BenchmarkDotNet 0.15.8 does not recognise otherwise.

Benchmark source code

Reproduce
cd dotnet/benchmarks/Hypaxel.Benchmarks
dotnet run -c Release -f net10.0 -- --filter '*' --job short --inProcess

.NET: 100,000 rows, allocated memory

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

.NET 10lower is better
  1. Hypaxel, typed Write12 KB, best
  2. Hypaxel, AddRowAsync12 KB, best
  3. Hypaxel, object mapping15 KB, 1.3×
  4. Hypaxel, shared strings10.1 MB, 842×
  5. SpreadCheetah16 KB, 1.3×
  6. ClosedXML1,103 MB, 91917×
.NET: 100,000 rows, allocated memory
Case.NET 8.NET 9.NET 10.NET 11
Hypaxel, typed Write208 KB12 KB12 KB14 KB
Hypaxel, AddRowAsync208 KB12 KB12 KB14 KB
Hypaxel, object mapping212 KB15 KB15 KB17 KB
Hypaxel, shared strings11 MB10.1 MB10.1 MB10.1 MB
SpreadCheetah84 KB15 KB16 KB18 KB
ClosedXML1,190 MB1,098 MB1,103 MB1,087 MB
Hardware
Apple M1 Max, 10 cores, macOS 26.6
Runtime
.NET 8.0.34, 9.0.23, 10.0.15 and 11.0.0
Compared with
SpreadCheetah 1.29.0, ClosedXML 0.105.1, BenchmarkDotNet 0.15.8
Method
BenchmarkDotNet memory diagnoser, ShortRun, in-process toolchain.
  • Allocations stay constant as rows grow, except with shared strings, whose table grows with the number of distinct values.

Benchmark source code

.NET: 1,000,000 rows, time

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

.NET 10lower is better
  1. Hypaxel, typed Write0.78 s, best
  2. Hypaxel, AddRowAsync0.77 s, best
  3. Hypaxel, object mapping0.81 s, 1.1×
  4. Hypaxel, shared strings1 s, 1.3×
  5. SpreadCheetah0.76 s, best
.NET: 1,000,000 rows, time
Case.NET 8.NET 9.NET 10.NET 11
Hypaxel, typed Write1.21 s0.8 s0.78 s0.73 s
Hypaxel, AddRowAsync1.23 s0.83 s0.77 s0.76 s
Hypaxel, object mapping1.26 s0.82 s0.81 s0.75 s
Hypaxel, shared strings1.42 s1.12 s1 s0.99 s
SpreadCheetah1.41 s0.85 s0.76 s0.74 s
Hardware
Apple M1 Max, 10 cores, macOS 26.6
Runtime
.NET 8.0.34, 9.0.23, 10.0.15 and 11.0.0
Compared with
SpreadCheetah 1.29.0
Method
--quick stopwatch runner: a single timed run after one warm-up. ClosedXML is not run at 1M rows.
  • At 1M rows Hypaxel and SpreadCheetah allocate less than 1 MB on every version; shared strings allocate 88 MB (96 MB on .NET 8).
  • The file is about 50 MB (53 MB with shared strings), or about 39 MB (41 MB) on .NET 8, whose compression produces smaller output.

Benchmark source code

Reproduce
cd dotnet/benchmarks/Hypaxel.Benchmarks
dotnet run -c Release -f net10.0 -- --quick 1000000

Reading

.NET reading: 1,000,000 rows, time

1,000,000 rows × 10 columns, written by the Hypaxel writer with inline or shared strings, read cell by cell

.NET 10lower is better
  1. Hypaxel, TryGetText/TryGetDouble (inline)0.76 s, 1.5×
  2. Hypaxel, GetValue/ExcelValue (inline)0.8 s, 1.5×
  3. Hypaxel, BackgroundDecompression (inline)0.52 s, best
  4. Sylvan.Data.Excel (inline)1.87 s, 3.6×
  5. ExcelDataReader (inline)4.26 s, 8.2×
  6. MiniExcel (inline)6.94 s, 13×
  7. Hypaxel, TryGetText/TryGetDouble (shared)0.81 s, 1.6×
  8. Hypaxel, GetValue/ExcelValue (shared)0.83 s, 1.6×
  9. Hypaxel, BackgroundDecompression (shared)0.56 s, 1.1×
  10. Sylvan.Data.Excel (shared)1.92 s, 3.7×
  11. ExcelDataReader (shared)4.4 s, 8.5×
  12. MiniExcel (shared)12.49 s, 24×
.NET reading: 1,000,000 rows, time
Case.NET 8.NET 9.NET 10.NET 11
Hypaxel, TryGetText/TryGetDouble (inline)0.74 s0.8 s0.76 s0.73 s
Hypaxel, GetValue/ExcelValue (inline)0.82 s0.86 s0.8 s0.79 s
Hypaxel, BackgroundDecompression (inline)0.59 s0.56 s0.52 s0.51 s
Sylvan.Data.Excel (inline)2.19 s2.04 s1.87 s1.94 s
ExcelDataReader (inline)5.24 s4.82 s4.26 s4.6 s
MiniExcel (inline)9.24 s8.1 s6.94 s7.28 s
Hypaxel, TryGetText/TryGetDouble (shared)0.8 s0.86 s0.81 s0.82 s
Hypaxel, GetValue/ExcelValue (shared)0.87 s0.89 s0.83 s0.85 s
Hypaxel, BackgroundDecompression (shared)0.64 s0.6 s0.56 s0.58 s
Sylvan.Data.Excel (shared)2.18 s2.07 s1.92 s1.99 s
ExcelDataReader (shared)5.29 s4.88 s4.4 s4.64 s
MiniExcel (shared)14.77 s13.71 s12.49 s12.84 s
Hardware
Apple M1 Max, 10 cores, 64 GB, macOS 26.6
Runtime
.NET 8.0.19, 9.0.0, 10.0.13 and 11.0.0
Compared with
Sylvan.Data.Excel 0.5.8, ExcelDataReader 3.9.0, MiniExcel 1.47.1
Method
Each reader runs in its own process with the --read-quick stopwatch runner: one warm-up, then the best of three runs. Every reader produces the same checksum (10,000,000 cells, the sum of all numbers including date serials, 42,833,558 string characters, 500,000 TRUEs). The machine was otherwise idle.
  • Inline and shared name the file: the same dataset written by the Hypaxel writer with inline strings or with shared strings.

Benchmark source code

Reproduce
cd dotnet/benchmarks/Hypaxel.Benchmarks
dotnet run -c Release -f net10.0 -- --read-quick 1000000                    # all readers, both files
dotnet run -c Release -f net10.0 -- --read-quick 1000000 Sylvan shared      # one reader, one file

.NET reading: 1,000,000 rows, memory

1,000,000 rows × 10 columns, written by the Hypaxel writer with inline or shared strings, read cell by cell

Inline: peak RSSlower is better
  1. Hypaxel, TryGetText/TryGetDouble49 MB, best
  2. Hypaxel, GetValue/ExcelValue55 MB, 1.1×
  3. Hypaxel, BackgroundDecompression51 MB, best
  4. Sylvan.Data.Excel75 MB, 1.5×
  5. ExcelDataReader77 MB, 1.6×
  6. MiniExcel81 MB, 1.7×
.NET reading: 1,000,000 rows, memory
CaseInline: allocatedInline: peak RSSShared: allocatedShared: peak RSS
Hypaxel, TryGetText/TryGetDouble0.1 MB49 MB92 MB141 MB
Hypaxel, GetValue/ExcelValue153 MB55 MB92 MB141 MB
Hypaxel, BackgroundDecompression0.6 MB51 MB92 MB137 MB
Sylvan.Data.Excel154 MB75 MB85 MB156 MB
ExcelDataReader1,937 MB77 MB1,717 MB158 MB
MiniExcel10,649 MB81 MB10,157 MB84 MB
Hardware
Apple M1 Max, 10 cores, 64 GB, macOS 26.6
Runtime
.NET 10.0.13
Compared with
Sylvan.Data.Excel 0.5.8, ExcelDataReader 3.9.0, MiniExcel 1.47.1
Method
Each reader runs in its own process with the --read-quick stopwatch runner: one warm-up, then the best of three runs. Every reader produces the same checksum (10,000,000 cells, the sum of all numbers including date serials, 42,833,558 string characters, 500,000 TRUEs). The machine was otherwise idle. Allocations are for one run; peak RSS is the whole process (/usr/bin/time -l), including the runtime.
  • The other runtimes are within a few MB of these figures.
  • With inline strings, the only allocations are the strings you ask for: the 153 MB are the 3M cell strings, and reading text as a span allocates nothing.
  • With shared strings, the 92 MB are the shared string table (1M distinct strings), which is loaded once and then read without allocating. Nothing else grows with the number of rows.

Benchmark source code

Reproduce
cd dotnet/benchmarks/Hypaxel.Benchmarks
dotnet run -c Release -f net10.0 -- --read-quick 1000000                    # all readers, both files
dotnet run -c Release -f net10.0 -- --read-quick 1000000 Sylvan shared      # one reader, one file

.NET reading: background decompression

1,000,000 rows × 10 columns, written by the Hypaxel writer with inline or shared strings, read cell by cell

Timelower is better
  1. Default, one reader (inline)0.77 s, 1.5×
  2. BackgroundDecompression, one reader (inline)0.53 s, best
  3. Default, one reader (shared)0.83 s, 1.6×
  4. BackgroundDecompression, one reader (shared)0.58 s, 1.1×
.NET reading: background decompression
CaseTimeCPU time
Default, one reader (inline)0.77 s0.76 s
BackgroundDecompression, one reader (inline)0.53 s0.92 s
Default, one reader (shared)0.83 s0.84 s
BackgroundDecompression, one reader (shared)0.58 s0.97 s
Hardware
Apple M1 Max, 10 cores, 64 GB, macOS 26.6
Runtime
.NET 10.0.13
Compared with
Method
XlsxReaderOptions.BackgroundDecompression measured interleaved with the default on the same files.
  • 4 readers at once (10 cores), inline, total time: 0.80–0.84 s by default, 0.56–0.59 s with BackgroundDecompression.
  • 10 readers at once (10 cores), inline, total time: 1.14–1.15 s by default, 1.54–1.56 s with BackgroundDecompression.
  • It saves about 30% of the time when cores are idle but costs about 20% more CPU; when every core is busy it makes the total slower, which is why it is off by default. Each open worksheet holds 1 MiB of buffers (four 256 KiB chunks) while it is on.

Benchmark source code

Reproduce
cd dotnet/benchmarks/Hypaxel.Benchmarks
dotnet run -c Release -f net10.0 -- --read-quick 1000000                    # all readers, both files
dotnet run -c Release -f net10.0 -- --read-quick 1000000 Sylvan shared      # one reader, one file

Rust: 100,000 and 1,000,000 rows

10 columns per row: integers, strings (one unique per row), floats, a date/time and a boolean, written to a Vec<u8>

100k rowslower is better
  1. Hypaxel (tuples)74 ms, best
  2. Hypaxel (serde records)75 ms, best
  3. Hypaxel (shared strings)100 ms, 1.4×
  4. Hypaxel (deflate level 6)316 ms, 4.3×
  5. rust_xlsxwriter (constant memory)796 ms, 11×
  6. rust_xlsxwriter1,019 ms, 14×
Rust: 100,000 and 1,000,000 rows
Case100k rows1M rowsFile (1M)
Hypaxel (tuples)74 ms0.75 s50 MB
Hypaxel (serde records)75 ms0.75 s50 MB
Hypaxel (shared strings)100 ms1.4 s53 MB
Hypaxel (deflate level 6)316 ms3.1 s31 MB
rust_xlsxwriter (constant memory)796 ms8.7 s57 MB
rust_xlsxwriter1,019 ms11 s59 MB
Hardware
Xeon 2.1 GHz, 4 vCPUs, Linux
Runtime
Rust 1.97, --release
Compared with
rust_xlsxwriter 0.102
Method
Criterion for 100k rows; a stopwatch run for 1M rows.
  • About half of the remaining time is deflate (zlib-rs, level 1); the other half is generating about 330 MB of XML at roughly 35 ns per cell.
  • The example axum server peaked at 5.4 MB RSS for the whole process after three 3M-row downloads, and at 11 MB with 8 concurrent downloads.

Benchmark source code

Reproduce
cargo bench -p hypaxel                          # Criterion, 10k and 100k rows
HYPAXEL_QUICK=1000000 cargo bench -p hypaxel    # stopwatch run, 1M rows

Reading

Rust reading: 1,000,000 rows, inline strings

10 columns per row: integers, strings (one unique per row), floats, a date/time and a boolean; 1M rows with inline strings (49 MB file)

Timelower is better
  1. Hypaxel XlsxReader0.78 s, best
  2. calamine worksheet_cells_reader2.18 s, 2.8×
  3. calamine worksheet_range2.43 s, 3.1×
Rust reading: 1,000,000 rows, inline strings
CaseTimePeak RSS
Hypaxel XlsxReader0.78 s7 MB
calamine worksheet_cells_reader2.18 s7 MB
calamine worksheet_range2.43 s793 MB
Hardware
Apple M1 Max, macOS
Runtime
Rust 1.100, --release
Compared with
calamine 0.38
Method
examples/read_bench.rs. The file is written by Hypaxel and read cell by cell, with a checksum over all values that every reader must match. Each run is in its own process; best of three.
  • About a quarter of the time is inflate. Common cell shapes and plain shared string items are matched in a single pass over the buffer; anything else goes through the general pull parser.
  • Row buffers are reused, so reading allocates nothing per cell.

Benchmark source code

Reproduce
cargo run --release -p hypaxel --example read_bench -- generate data.xlsx 1000000 inline
cargo run --release -p hypaxel --example read_bench -- hypaxel data.xlsx     # or calamine, calamine-stream

Rust reading: 1,000,000 rows, shared strings

10 columns per row: integers, strings (one unique per row), floats, a date/time and a boolean; 1M rows with a shared string table (52 MB file)

Timelower is better
  1. Hypaxel XlsxReader0.73 s, best
  2. calamine worksheet_cells_reader2.05 s, 2.8×
  3. calamine worksheet_range2.33 s, 3.2×
Rust reading: 1,000,000 rows, shared strings
CaseTimePeak RSS
Hypaxel XlsxReader0.73 s57 MB
calamine worksheet_cells_reader2.05 s64 MB
calamine worksheet_range2.33 s849 MB
Hardware
Apple M1 Max, macOS
Runtime
Rust 1.100, --release
Compared with
calamine 0.38
Method
examples/read_bench.rs. The file is written by Hypaxel and read cell by cell, with a checksum over all values that every reader must match. Each run is in its own process; best of three.
  • What stays in memory is the shared string table plus the current row; in this file the 1M unique strings are in the shared table.

Benchmark source code

Reproduce
cargo run --release -p hypaxel --example read_bench -- generate data.xlsx 1000000 shared
cargo run --release -p hypaxel --example read_bench -- hypaxel data.xlsx     # or calamine, calamine-stream

Python: 100,000 rows

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

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×
Python: 100,000 rows
CaseTimeThroughputPeak Python memory
Hypaxel write_rows0.1 s1,000,000 rows/s5 MB
Hypaxel stream_rows0.09 s1,080,000 rows/s11 MB
XlsxWriter (constant_memory)5.15 s19,400 rows/s7 MB
openpyxl (write_only)9.48 s10,500 rows/s7 MB
Hypaxel pandas DataFrame*0.27 s371,000 rows/s16 MB
pandas.to_excel (xlsxwriter)*8.68 s11,500 rows/s147 MB
Hypaxel polars DataFrame*0.21 s475,000 rows/s8 MB
polars.write_excel*6.15 s16,300 rows/s265 MB
Hardware
Xeon 2.1 GHz, Linux
Runtime
Python 3.13
Compared with
XlsxWriter (constant_memory), openpyxl (write_only), pandas, polars
Method
benchmarks/bench.py. Rows marked with * include building the DataFrame from the row list.
  • Hypaxel write_rows peak memory is the output itself (5 MB).
  • Hypaxel writes 1M rows in about 0.9 s (write_rows) and 2.5–3.4 s from a DataFrame, scaling linearly.

Benchmark source code

Reproduce
python benchmarks/bench.py 100000

Reading

Python reading: 100,000 rows

10 columns per row: integers, strings (one unique per row), floats, a date/time and a boolean, plus a header row, saved with a shared string table as Excel does

Timelower is better
  1. Hypaxel iter_rows0.13 s, best
  2. python-calamine iter_rows0.47 s, 3.6×
  3. openpyxl (read_only)3.58 s, 28×
  4. Hypaxel read_dataframe (pandas)0.2 s, 1.5×
  5. pandas.read_excel (calamine)0.74 s, 5.7×
  6. pandas.read_excel (openpyxl)4.36 s, 34×
  7. Hypaxel read_dataframe (polars)0.18 s, 1.4×
  8. fastexcel to_polars0.24 s, 1.8×
Python reading: 100,000 rows
CaseTimePeak RSS
Hypaxel iter_rows0.13 s27 MB
python-calamine iter_rows0.47 s105 MB
openpyxl (read_only)3.58 s63 MB
Hypaxel read_dataframe (pandas)0.2 s182 MB
pandas.read_excel (calamine)0.74 s315 MB
pandas.read_excel (openpyxl)4.36 s201 MB
Hypaxel read_dataframe (polars)0.18 s143 MB
fastexcel to_polars0.24 s188 MB
Hardware
Apple M1 Max, macOS
Runtime
Python 3.13
Compared with
openpyxl 3.1.5, python-calamine 0.9.1, fastexcel 0.21.0, pandas 3.1.1, polars 2.1.0
Method
benchmarks/read_bench.py. Every reader runs in its own process; peak RSS covers the whole process (Python, modules and native memory); imports are not timed. All readers return the same 1,000,010 non-empty cells.
  • At 1M rows (55 MB file) iter_rows takes 1.35 s with a 68 MB peak, against 4.7 s and 862 MB for python-calamine.
  • At 1M rows read_dataframe takes 1.9 s (pandas) and 2.0 s (polars), against 8.3 s for pandas.read_excel(engine="calamine") and 2.5 s for fastexcel.

Benchmark source code

Reproduce
python benchmarks/read_bench.py 100000

Node.js: 100,000 and 1,000,000 rows

10 columns per row: five numbers, three strings (one unique per row), a Date and a boolean. Each case runs in its own process

100k rowslower is better
  1. Hypaxel, arrays, streamed133 ms, best
  2. Hypaxel, arrays, to buffer131 ms, best
  3. Hypaxel, objects, to buffer151 ms, 1.2×
  4. Hypaxel, WebAssembly engine, arrays, to buffer223 ms, 1.7×
  5. ExcelJS, streaming writer815 ms, 6.2×
  6. ExcelJS, in-memory workbook4,186 ms, 32×
Node.js: 100,000 and 1,000,000 rows
Case100k rowsPeak RSS (100k)1M rowsPeak RSS (1M)
Hypaxel, arrays, streamed133 ms87 MB1.23 s104 MB
Hypaxel, arrays, to buffer131 ms97 MB1.23 s204 MB
Hypaxel, objects, to buffer151 ms99 MB1.36 s207 MB
Hypaxel, WebAssembly engine, arrays, to buffer223 ms108 MB1.91 s271 MB
ExcelJS, streaming writer815 ms169 MB7.89 s612 MB
ExcelJS, in-memory workbook4,186 ms1,301 MBnot runnot run
Hardware
Apple M1 Max, macOS 26.6
Runtime
Node.js 22.23.2
Compared with
ExcelJS 4.4.0
Method
Single runs. Peak RSS is the process's peak resident memory, which includes Node.js itself and both libraries (about 85 MB before any row is written).
  • Single runs: treat small differences as noise.
  • The 1M-row file is 50 MB from Hypaxel and 67 MB from ExcelJS's streaming writer.
  • The WebAssembly row runs the browser build in Node.js; it is about 1.5x slower than the native module, which is why Node.js uses the native one.

Benchmark source code

Reproduce
node benchmarks/bench.mjs            # 100,000 rows
node benchmarks/bench.mjs 1000000

Browsers (WebAssembly)

Browsers: an XLSX Blob in headless Chrome

10 columns per row: five numbers, three strings (one unique per row), a Date and a boolean, built before timing; every library gets the same array

100k rowslower is better
  1. Hypaxel (WebAssembly)153 ms, best
  2. SheetJS1,913 ms, 13×
  3. ExcelJS3,074 ms, 20×
Browsers: an XLSX Blob in headless Chrome
Case100k rowsFile (100k)300k rowsFile (300k)
Hypaxel (WebAssembly)153 ms5 MB484 ms15.2 MB
SheetJS1,913 ms15.1 MB7,099 ms45.5 MB
ExcelJS3,074 ms5.8 MB9,617 ms17.5 MB
Hardware
Apple M1 Max, macOS 26.6
Runtime
Chrome 158.0.8127.36 (headless)
Compared with
SheetJS 0.20.3, ExcelJS 4.4.0
Method
Each library runs in a fresh browser; the time is the median of three runs after the library has loaded. SheetJS writes with compression: true.
  • Hypaxel's WebAssembly memory stayed at 2.4 MB in both runs. The browser does not expose the peak JavaScript heap, so memory is not compared across libraries.
  • Download sizes, gzipped: Hypaxel 171 KB of WebAssembly plus about 7 KB of minified JavaScript; SheetJS xlsx.full.min.js 335 KB (xlsx.mini.min.js 86 KB); ExcelJS exceljs.min.js 256 KB.

Benchmark source code

Reproduce
npm run bench:browser                        # 100,000 rows; needs Chrome (or set CHROME_PATH)
node benchmarks/browser/run.mjs 300000

Go: 100,000 and 1,000,000 rows

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

100k rowslower is better
  1. Hypaxel, typed cells88 ms, best
  2. Hypaxel, struct mapping95 ms, 1.1×
  3. Hypaxel, WriteRow100 ms, 1.1×
  4. Hypaxel, shared strings113 ms, 1.3×
  5. excelize, StreamWriter432 ms, 4.9×
  6. excelize, in-memory1,740 ms, 20×
Go: 100,000 and 1,000,000 rows
Case100k rowsAllocated (100k)Peak RSS (100k)1M rowsAllocated (1M)Peak RSS (1M)
Hypaxel, typed cells88 ms0.2 MB18 MB0.92 s0.4 MB19 MB
Hypaxel, struct mapping95 ms0.2 MB18 MB0.97 s0.4 MB19 MB
Hypaxel, WriteRow100 ms10.9 MB19 MB1.02 s107 MB20 MB
Hypaxel, shared strings113 ms17.7 MB28 MB1.37 s214 MB157 MB
excelize, StreamWriter432 ms171 MB78 MB5.62 s1,317 MB179 MB
excelize, in-memory1,740 ms1,250 MB631 MBnot runnot runnot run
Hardware
Apple M1 Max, 10 cores, macOS 26.6
Runtime
Go 1.27.4
Compared with
excelize 2.11.1
Method
Time and allocated bytes from go test -bench with the rows built beforehand and a discarding destination: about a dozen iterations per case at 100k rows (one for the in-memory case), three at 1M. Peak RSS from separate runs, one process per case, generating the rows on the fly; it includes the Go runtime and both libraries. Other processes were using the machine, so treat small differences as noise.
  • The typed and struct-mapping cases make 27 to 66 allocations per workbook, whatever the number of rows.
  • With shared strings, memory grows with the number of distinct strings, here one per row.
  • The 1M-row file is 40.5 MB from Hypaxel and 62.9 MB from excelize's StreamWriter. At compression level 6 it is 29.0 MB and takes 1.32 s; at level 0 it is 331 MB and takes 0.37 s.
  • The in-memory excelize case was not run at 1M rows.

Benchmark source code

Reproduce
cd go/tests
go test -run '^$' -bench Write -benchmem                                 # 100,000 rows
go test -run '^$' -bench Write -benchmem -rows 1000000 -benchtime 3x     # 1,000,000 rows
go run ./cmd/bench                                                       # peak RSS, 100,000 rows
go run ./cmd/bench 1000000

Reading

Go: reading 1,000,000 rows

10 columns per row: integers, strings (one unique per row), floats, a date/time and a boolean. Written by Hypaxel with a cell reference on every cell, as Excel writes them (about 40% larger files than the other languages' read benchmarks), read cell by cell

Inline stringslower is better
  1. Hypaxel, Rows.Next1.16 s, best
  2. Hypaxel, Rows.All1.16 s, best
  3. excelize, Rows with RawCellValue15.55 s, 13×
  4. excelize, Rows (formatted values)68.33 s, 59×
  5. xlsxreader, ReadRows14.51 s, 13×
Go: reading 1,000,000 rows
CaseInline stringsPeak RSS (inline)Shared stringsPeak RSS (shared)
Hypaxel, Rows.Next1.16 s21 MB1.2 s73 MB
Hypaxel, Rows.All1.16 s21 MB1.21 s86 MB
excelize, Rows with RawCellValue15.55 s22 MB17 s142 MB
excelize, Rows (formatted values)68.33 s23 MB69.41 s142 MB
xlsxreader, ReadRows14.51 s22 MB12.86 s163 MB
tealeg/xlsx, OpenFilenot runnot runnot runnot run
Hardware
Apple M1 Max, 10 cores, macOS 26.6
Runtime
Go 1.27.4
Compared with
excelize 2.11.1, thedatashed/xlsxreader 1.2.8, tealeg/xlsx 3.3.13
Method
Each reader runs in its own process, best of three, on an otherwise idle machine. Every reader must return the same checksum (rows, cells, sum of numbers, dates as Unix seconds, string bytes, TRUE count), which the harness verifies. The inline-strings file is 70.7 MB, the shared-strings file 71.5 MB.
  • tealeg/xlsx, which loads the whole sheet, was not run at 1M rows. At 100k rows it takes 2.33 s and peaks at 715 MB, against 0.22 s and 18 MB for Hypaxel.
  • Per 100k rows, Hypaxel allocates 5.3 MB in 102k allocations (one string per row holding its inline text) with inline strings, and 15 MB in 1.6k allocations with shared strings (mostly the table itself); excelize allocates 0.97 GB in 20M allocations.
  • With GOMAXPROCS=1 there is no core to overlap decompression with, so the reader inflates on the caller's goroutine and takes about 2.1 to 2.2 s (interleaved A/B runs on a busy machine).
  • Formatted excelize values only match on cell counts and text, because numbers and dates come back as display text.
  • xlsxreader truncates date-times instead of rounding them, so about half of the dates come back one second early; the harness allows for that.
  • xlsxreader and tealeg/xlsx 3.3.13 cannot read cells without references. tealeg's ValueOnly option crashes on inline strings, so it runs with default options.
  • The worksheet XML tokenizer runs at 460 MB/s, 7x faster than encoding/xml's RawToken (64 MB/s) on the same input (go test -bench Tokenize in go/).

Benchmark source code

Reproduce
cd go/tests
go test -run '^$' -bench Read -benchmem                                  # every reader, 100,000 rows
go run ./cmd/bench read 1000000                                          # time and peak RSS

Java: 100,000 rows

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

Timelower is better
  1. Hypaxel, typed write118 ms, best
  2. Hypaxel, writeRows with a RowWriter118 ms, best
  3. Hypaxel, object mapping123 ms, best
  4. Hypaxel, addRow(Object...)123 ms, best
  5. Hypaxel, shared strings135 ms, 1.1×
  6. Hypaxel, compression level 6324 ms, 2.7×
  7. FastExcel, compression level 1352 ms, 3.0×
  8. FastExcel, default settings443 ms, 3.8×
  9. Apache POI SXSSF1,057 ms, 9.0×
Java: 100,000 rows
CaseTimeAllocatedFile
Hypaxel, typed write118 ms0.17 MB3.9 MB
Hypaxel, writeRows with a RowWriter118 ms0.17 MB3.9 MB
Hypaxel, object mapping123 ms0.17 MB3.9 MB
Hypaxel, addRow(Object...)123 ms14.6 MB3.9 MB
Hypaxel, shared strings135 ms3.9 MB4.1 MB
Hypaxel, compression level 6324 ms0.37 MB3 MB
FastExcel, compression level 1352 ms261 MB6.9 MB
FastExcel, default settings443 ms262 MB5.9 MB
Apache POI SXSSF1,057 ms501 MB5.6 MB
Hardware
Apple M1 Max, 10 cores, macOS 26.6
Runtime
OpenJDK 24.0.1
Compared with
FastExcel 0.20.2, Apache POI 6.0.0, JMH 1.37
Method
JMH average time per workbook: 2 forks, 5 warm-up and 5 measured iterations of 2 s; allocation from the JMH GC profiler. The machine was running other work (load average about 10).
  • Treat differences of a few percent as noise.

Benchmark source code

Reproduce
cd java
./mvnw -q -DskipTests install
./mvnw -q -f benchmarks/pom.xml package
java -jar benchmarks/target/benchmarks.jar jmh WriteBenchmark -prof gc

Java: 1,000,000 rows

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

Timelower is better
  1. Hypaxel, typed write1.2 s, best
  2. Hypaxel, writeRows with a RowWriter1.21 s, best
  3. Hypaxel, object mapping1.25 s, best
  4. Hypaxel, addRow(Object...)1.31 s, 1.1×
  5. Hypaxel, shared strings1.5 s, 1.3×
  6. Hypaxel, compression level 63.24 s, 2.7×
  7. FastExcel, compression level 13.01 s, 2.5×
  8. FastExcel, default settings4.22 s, 3.5×
  9. Apache POI SXSSF9.77 s, 8.1×
Java: 1,000,000 rows
CaseTimeAllocatedPeak RSSFile
Hypaxel, typed write1.2 s0.16 MB325 MB38.8 MB
Hypaxel, writeRows with a RowWriter1.21 s0.16 MB331 MB38.8 MB
Hypaxel, object mapping1.25 s0.17 MB326 MB38.8 MB
Hypaxel, addRow(Object...)1.31 s137 MB467 MB38.8 MB
Hypaxel, shared strings1.5 s30 MB366 MB41 MB
Hypaxel, compression level 63.24 s0.35 MB324 MB29.9 MB
FastExcel, compression level 13.01 s2,503 MB1,097 MB69.3 MB
FastExcel, default settings4.22 s2,487 MB1,064 MB60.7 MB
Apache POI SXSSF9.77 s4,712 MB866 MB56.9 MB
Hardware
Apple M1 Max, 10 cores, macOS 26.6
Runtime
OpenJDK 24.0.1
Compared with
FastExcel 0.20.2, Apache POI 6.0.0
Method
Stopwatch runner: mean of 5 runs after 2 warm-ups, bytes allocated by the writing thread per run. Peak RSS from a separate single run in a fresh JVM with default settings that creates the rows on demand; creating the rows without writing anything peaks at 314 MB.
  • At the same deflate level Hypaxel is about 2.5 to 3x faster than FastExcel. FastExcel's own default is a higher level, which makes its files smaller than at level 1 but still larger than Hypaxel's.
  • At level 6 Hypaxel is slower than FastExcel at level 1 and produces a file less than half the size. About 70% of Hypaxel's time at level 1 is spent in the JDK's Deflater, so the compression level decides most of the run time.
  • Peak RSS is dominated by the JVM and by garbage between collections, not by what a writer keeps alive. All three writers stream; FastExcel was flushed every 100 rows and POI used a 100-row window.
  • Allocation does not grow with the row count for the typed, RowWriter and object-mapping paths. addRow(Object...) boxes its arguments, and shared strings keep every distinct string.
  • FastExcel needs a style per date cell to show dates as dates; that call is part of its loop.
  • The machine was running other work (load average about 10); treat differences of a few percent as noise.

Benchmark source code

Reproduce
cd java
./mvnw -q -DskipTests install
./mvnw -q -f benchmarks/pom.xml package
./benchmarks/run.sh 1000000

Reading

Java: reading 1,000,000 rows, inline strings

The 1M-row write benchmark dataset (10 columns per row: integers, strings (one unique per row), floats, a date/time and a boolean), written by Hypaxel with inline strings (40.7 MB)

Timelower is better
  1. Hypaxel XlsxReader0.7 s, best
  2. FastExcel ReadableWorkbook2.69 s, 3.8×
  3. Apache POI XSSFReader + SAX3.27 s, 4.7×
Java: reading 1,000,000 rows, inline strings
CaseTimeAllocatedPeak RSS
Hypaxel XlsxReader0.7 s322 MB354 MB
FastExcel ReadableWorkbook2.69 s3,913 MB732 MB
Apache POI XSSFReader + SAX3.27 s1,267 MB616 MB
Hardware
Apple M1 Max, 10 cores, 64 GB, macOS 26.6
Runtime
OpenJDK 24.0.1
Compared with
FastExcel reader 0.20.2 (ReadableWorkbook, Aalto StAX), Apache POI 6.0.0 (XSSFReader with a SAX handler and ReadOnlySharedStringsTable)
Method
Each reader streams the first worksheet and visits every cell with its typed accessors; all must produce the same checksum (10,000,000 cells, sum of all numbers and date serials, 42,833,558 characters of text, 500,000 TRUEs). Time: mean of 5 runs after 2 warm-ups in one JVM. Allocated: bytes allocated by the reading thread per run. Peak RSS: a separate single read in a fresh JVM with default settings. The machine was running other work (load average about 12).
  • Hypaxel's allocation on the inline file is the String of each text cell, which the benchmark asks for. Numbers, booleans and dates allocate nothing.
  • All three readers stream with bounded live memory: each completes with -Xmx16m on the inline file and with -Xmx96m on the shared one, whose string table must be held. The RSS differences come from garbage that the JVM lets accumulate between collections under default settings.
  • FastExcel did not read number formats (its default); Hypaxel and the POI handler detect date formats.
  • About 25% of Hypaxel's time is inflate and CRC-32 verification in the JDK.
  • Treat differences of a few percent as noise.

Benchmark source code

Reproduce
cd java
./mvnw -q -DskipTests install
./mvnw -q -f benchmarks/pom.xml package
./benchmarks/read.sh 1000000

Java: reading 1,000,000 rows, shared strings

The 1M-row write benchmark dataset (10 columns per row: integers, strings (one unique per row), floats, a date/time and a boolean), written by Hypaxel with a shared string table (43.0 MB, 1M distinct strings)

Timelower is better
  1. Hypaxel XlsxReader0.69 s, best
  2. FastExcel ReadableWorkbook2.97 s, 4.3×
  3. Apache POI XSSFReader + SAX4.65 s, 6.7×
Java: reading 1,000,000 rows, shared strings
CaseTimeAllocatedPeak RSS
Hypaxel XlsxReader0.69 s74 MB155 MB
FastExcel ReadableWorkbook2.97 s4,068 MB1,015 MB
Apache POI XSSFReader + SAX4.65 s7,886 MB827 MB
Hardware
Apple M1 Max, 10 cores, 64 GB, macOS 26.6
Runtime
OpenJDK 24.0.1
Compared with
FastExcel reader 0.20.2 (ReadableWorkbook, Aalto StAX), Apache POI 6.0.0 (XSSFReader with a SAX handler and ReadOnlySharedStringsTable)
Method
Each reader streams the first worksheet and visits every cell with its typed accessors; all must produce the same checksum (10,000,000 cells, sum of all numbers and date serials, 42,833,558 characters of text, 500,000 TRUEs). Time: mean of 5 runs after 2 warm-ups in one JVM. Allocated: bytes allocated by the reading thread per run. Peak RSS: a separate single read in a fresh JVM with default settings. The machine was running other work (load average about 12).
  • Hypaxel creates shared strings once, when the table is loaded. Numbers, booleans and dates allocate nothing.
  • All three readers stream with bounded live memory: each completes with -Xmx16m on the inline file and with -Xmx96m on the shared one, whose string table must be held. The RSS differences come from garbage that the JVM lets accumulate between collections under default settings.
  • FastExcel did not read number formats (its default); Hypaxel and the POI handler detect date formats.
  • About 25% of Hypaxel's time is inflate and CRC-32 verification in the JDK.
  • Treat differences of a few percent as noise.

Benchmark source code

Reproduce
cd java
./mvnw -q -DskipTests install
./mvnw -q -f benchmarks/pom.xml package
./benchmarks/read.sh 1000000

PHP: opcache off (CLI default)

10 columns per row: integers, strings (one unique per row), floats, a date/time and a boolean, from a generator to a file. Each case runs in its own process

100k rowslower is better
  1. Hypaxel, rows0.42 s, best
  2. Hypaxel, records with header0.57 s, 1.4×
  3. Hypaxel, rows, shared strings0.44 s, best
  4. Hypaxel, rows, Xlsx::stream()0.45 s, 1.1×
  5. OpenSpout4.6 s, 11×
  6. PhpSpreadsheet17.2 s, 41×
PHP: opcache off (CLI default)
Case100k rowsPeak memory (100k)1M rowsPeak memory (1M)
Hypaxel, rows0.42 s4 MB4.17 s4 MB
Hypaxel, records with header0.57 s4 MB5.38 s4 MB
Hypaxel, rows, shared strings0.44 s13.5 MB4.09 s90 MB
Hypaxel, rows, Xlsx::stream()0.45 s4 MB4.92 s4 MB
OpenSpout4.6 s4 MB47.83 s4 MB
PhpSpreadsheet17.2 s661.1 MBnot runnot run
Hardware
Apple M1 Max, macOS 26.6
Runtime
PHP 8.4.8 (CLI, NTS)
Compared with
OpenSpout 5.14.1, PhpSpreadsheet 5.11.0
Method
Single runs while the machine was busy with other work. Peak memory is memory_get_peak_usage(true), including the autoloader and the library's classes.
  • OpenSpout is a streaming writer too and uses as little memory as Hypaxel; the difference is time.
  • PhpSpreadsheet builds the workbook in memory and is not run at 1M rows.
  • The 1M-row file is 39 MB from Hypaxel and 52 MB from OpenSpout.

Benchmark source code

Reproduce
php benchmarks/bench.php                  # 100,000 rows
php benchmarks/bench.php 1000000

PHP: opcache with tracing JIT

10 columns per row: integers, strings (one unique per row), floats, a date/time and a boolean, from a generator to a file. Each case runs in its own process

100k rowslower is better
  1. Hypaxel, rows0.3 s, best
  2. Hypaxel, records with header0.37 s, 1.2×
  3. Hypaxel, rows, shared strings0.31 s, best
  4. Hypaxel, rows, Xlsx::stream()0.32 s, 1.1×
  5. OpenSpout4.11 s, 14×
  6. PhpSpreadsheet11.81 s, 39×
PHP: opcache with tracing JIT
Case100k rowsPeak memory (100k)1M rowsPeak memory (1M)
Hypaxel, rows0.3 s4 MB2.93 s4 MB
Hypaxel, records with header0.37 s4 MB3.64 s4 MB
Hypaxel, rows, shared strings0.31 s13.5 MB3.07 s90 MB
Hypaxel, rows, Xlsx::stream()0.32 s4 MB3.18 s4 MB
OpenSpout4.11 s4 MB40.65 s4 MB
PhpSpreadsheet11.81 s659.1 MBnot runnot run
Hardware
Apple M1 Max, macOS 26.6
Runtime
PHP 8.4.8 (CLI, NTS), opcache.enable_cli=1, opcache.jit=tracing, opcache.jit_buffer_size=128M
Compared with
OpenSpout 5.14.1, PhpSpreadsheet 5.11.0
Method
Single runs while the machine was busy with other work. Peak memory is memory_get_peak_usage(true), including the autoloader and the library's classes.
  • PhpSpreadsheet builds the workbook in memory and is not run at 1M rows.

Benchmark source code

Reproduce
php benchmarks/bench.php 100000 --jit     # opcache + tracing JIT

Methodology, the reasons behind the numbers and tuning advice are in the performance guide.