Compared with Python's readers

This page sets XLSX.jl's features beside those of three Python packages often used to read Excel files: python-calamine (Python bindings for the Rust calamine reader), fastexcel (built on calamine and Apache Arrow) and openpyxl. It is meant to help you choose, or to help you move from one to another.

The Python columns were checked on 2026-11-14 against each project's documentation and type stubs, for python-calamine 0.9.1, fastexcel 0.21.0 and openpyxl 3.1. "Not documented" means the project's documentation and public API don't mention the feature. It may still exist in a form they don't describe. In short:

  • python-calamine and fastexcel only read. They read more file formats than XLSX.jl, but they can't write files or read formatting, formulas or objects. On tables, XLSX.jl's readtable is faster than python-calamine and about as fast as fastexcel (see Speed).
  • openpyxl reads and writes .xlsx files, as XLSX.jl does, with a similar range of features, but it is much slower to read and to write.
  • XLSX.jl reads and writes .xlsx files, edits them in place, and covers formatting, charts and Excel's newer features. It reads only the Office Open XML formats.

File formats and sources

FeatureXLSX.jlpython-calaminefastexcelopenpyxl
.xlsx, .xlsmread and writereadreadread and write
Templates (.xltx, .xltm)read and writenot documentednot documentedread and write
.xlsb, .xls, .ods—readread¹—
Password-encrypted files— (decrypt first with XLSXDecrypt.jl)— (raises PasswordError)not documented—
From a path✓✓✓✓
From an IO stream or bytes✓✓ (file-like objects)bytes only✓ (file-like objects)

¹ fastexcel doesn't list the formats it reads. It opens files through calamine, which reads all of these.

Reading data

FeatureXLSX.jlpython-calaminefastexcelopenpyxl
Cell values✓ sheet["A1"], XLSX.readdata✓through a table✓
A table, typed by column✓ XLSX.readtable, any Tables.jl sink such as a DataFramelists of rows✓ to Arrow, pandas or Polarslists of rows (ws.values)
Dates, times and Booleans✓ Date, DateTime, Time, Bool✓ date, datetime, time, timedelta, bool✓ date, datetime, duration and Boolean columns✓ datetime and others, from the number format
Error values (#N/A, …)✓ XLSX.iserror, XLSX.geterror; missing in tablesnot documentedNone, with the cell's position from to_arrow_with_errorsas text ("#N/A")
Cached values of formulas✓✓✓✓ with data_only=True
Formula text✓ XLSX.getFormula——✓ (the default)
Calculating formulas————
Choosing the header row and first row✓ first_row, header, column_labels—✓ header_row, skip_rows, column_names—
Choosing columns✓ "B:D"—✓ by name, index or "A:C,E"—
Stopping at an empty row or a condition✓ stop_in_empty_row, stop_in_row_function—n_rows—
Setting column types— (inferred, or infer_eltypes=false)—✓ dtypes, dtype_coercion—
Text read as missing✓ missing_strings—whitespace_as_null—
Reading row by row without loading the sheet✓ XLSX.eachtablerow, enable_cache=false✓ iter_rowslazy loading✓ read_only=True
Excel Tables✓ XLSX.tables, read and write✓ read (load_tables=True)✓ read (load_table)✓ read and write
Named ranges✓ XLSX.getDefinedNames, read and write—✓ read (defined_names)✓ read and write
Sheet visibility✓ XLSX.getSheetVisibility, read and write✓ read✓ read✓ read and write
Merged cells✓ XLSX.getMergedCells, read and write✓ read (.xlsx, .xls)—✓ read and write

Writing and editing

FeatureXLSX.jlpython-calaminefastexcelopenpyxl
New files✓ XLSX.writetable, XLSX.newxlsx——✓
Editing an existing file in place✓ mode="rw" (see the warning on XLSX.openxlsx)——✓ (shapes are lost)
Writing large files in constant memory✓ streaming=true, XLSX.streamxlsx——✓ write_only=True
Formulas with a cached value✓ XLSX.setFormula with value——formula only
Inserting and deleting rows and columns✓ moving formulas, formats and objects——moves cells; formulas aren't updated
VBA macroskept, not edited——kept with keep_vba=True, not edited

Formatting and objects

Neither python-calamine nor fastexcel reads or writes anything in this table.

FeatureXLSX.jlopenpyxl
Fonts, fills, borders, alignment✓ read and write✓ read and write
Number formats✓ read and write, and XLSX.getText for the text Excel shows✓ read and write
Rich text in a cell✓✓ rich_text=True
Conditional formatting✓ read and write✓ read and write
Data validation✓ read and write✓ read and write
AutoFilter✓ filters and sorts the rows, as Excel doesstores the criteria only; Excel applies them
Column widths, row heights, freeze panes✓, and XLSX.autofitColumns✓
Charts✓ read, write and edit, including chartEx charts (experimental)✓ write; existing charts are kept
Images✓ read and write, and pictures in cells✓ write (needs Pillow); existing images are kept
Text boxes and shapes✓ read and write— (lost on save)
Comments✓ notes and threaded comments✓ notes (formatting lost on save)
Hyperlinks✓ read and write✓ read and write
Sparklines, checkboxes✓ read and write—
Sheet and workbook protection✓✓
Page setup, print areas, headers and footers✓✓
Document properties✓✓

Speed

All the times below were measured on 2026-11-15 on the same machine (Windows, 8 threads; Python 3.13). XLSX.jl's are those of the code for the next release. The method is in bench/README.md.

Reading

On the benchmark fixtures, XLSX.jl's XLSX.readtable reads a table 10 to 17 times as fast as openpyxl, in 0.4 to 0.8 times python-calamine's time, and in about the same time as fastexcel (0.8 to 1.5 times its time). The exception is the smallest table (100 rows), where fixed costs dominate and python-calamine and fastexcel are about 3 times as fast. Times in milliseconds (medians), for a few of the fixtures:

TableXLSX.jlpython-calaminefastexcelopenpyxl
5,000 rows × 30 columns, mixed508447702
50,000 rows × 70 columns, mixed1,2431,9741,17514,536
50,000 rows × 20 columns, numbers2714332022,801
50,000 rows × 10 columns, unique strings2974252944,001
30,000 rows × 100 columns, as Excel writes them, 20% formulas8801,4188218,999

python-calamine 0.9.1, fastexcel 0.21.0 (to Arrow), openpyxl 3.1.5 (read_only=True).

Writing

python-calamine and fastexcel can't write, so here openpyxl is set beside the two writers most used in Python: XlsxWriter, which pandas and Polars use to write Excel files, and rustpy-xlsxwriter, Python bindings for the Rust rust_xlsxwriter. Each writes the same table, values only, read beforehand and not timed. XLSX.writetable writes it 7 to 24 times as fast as openpyxl and 4 to 10 times as fast as XlsxWriter (the lower figures are against their faster modes), and in 0.85 to 1.4 times rustpy-xlsxwriter's time. With streaming=true it takes 0.6 to 1.0 times rustpy-xlsxwriter's time. Times in milliseconds (medians):

TableXLSX.jlXLSX.jl, streaming=trueopenpyxlopenpyxl, write_only=TrueXlsxWriterXlsxWriter, constant_memoryrustpy-xlsxwriter
5,000 rows × 30 columns, mixed795491580749544860
50,000 rows × 70 columns, mixed1,8761,12322,65617,53411,71910,1521,608
50,000 rows × 20 columns, numbers4344176,2814,9563,2482,717499
50,000 rows × 10 columns, unique strings4942393,8653,3102,4792,010342
30,000 rows × 100 columns, the values of the Excel-like table1,7191,47021,26117,17011,2699,7381,678

openpyxl 3.1.5, XlsxWriter 3.2.9, rustpy-xlsxwriter 0.9.1. XLSX.jl writes from the table readtable returns; the Python writers write from a list of rows (a list of dictionaries for rustpy-xlsxwriter), one row at a time where the writer takes rows. On the smallest table (100 rows) XLSX.jl takes 3 ms, XlsxWriter 15 ms and rustpy-xlsxwriter 4 ms.

Opening a workbook with XLSX.openxlsx to read or edit it does more work than readtable or writetable, and isn't compared here.

See also: Supported features for every XLSX.jl feature and its functions.