xleak renders Excel in the terminal, and lazy loading starts at a thousand rows

Viewing is the whole job, and the TUI is the default path

xleak exists to show Excel files without Microsoft Excel, and its inspiration is named: doxx. The pitch in the README is one line, expose Excel files in your terminal with no Microsoft Excel required.

The interactive TUI is the recommended mode and is entered with `-i`. It is a full ratatui application with keyboard navigation, and the shortcut list is specific enough to be useful: arrows move between cells, `Enter` opens cell details including formulas, `/` searches across all cells, `n` and `N` step through results, `Ctrl+G` jumps to a cell by row, column letter or both as `10,5`, `Tab` and `Shift+Tab` switch sheets, `?` shows help and `q` quits.

Rendering details are handled rather than left to you. Numbers are right-aligned, text left-aligned and booleans centred, which is the kind of small thing that makes a table readable at a glance.

Two features are unusual for this category. Formula display shows the underlying Excel formula in the cell detail view rather than only the cached value, which is what you need when a spreadsheet disagrees with itself. And the cell detail view plus visual highlighting of the current row, column and cell makes a wide sheet navigable without losing your place.

Progress indicators exist for long operations, which matters when a workbook takes a while to parse.

Eight package managers, and one is not ready yet

The installation section is long, and reading it tells you how widely this is packaged.

macOS and Linux through Homebrew:

brew install bgreenwell/tap/xleak

Windows through Scoop, which needs the bucket added first:

scoop bucket add bgreenwell https://github.com/bgreenwell/scoop-bucket
scoop install xleak

Windows through WinGet is listed as coming soon, pending an initial pull request merge, with the command `winget install bgreenwell.xleak` given but not yet available.

The Linux distributions are covered properly. Debian packages it as `rust-xleak`, available in Forky or later, installed with `sudo apt install xleak`. Arch has it in the AUR as `xleak-bin`, installable with either `yay -S xleak-bin` or `paru -S xleak-bin`. NetBSD uses `pkgin install xleak`.

Cargo works everywhere with `cargo install xleak`, and Nix has both a direct run and a profile install:

nix run github:bgreenwell/xleak -- file.xlsx

There are also quick install scripts that pipe to a shell, one for macOS and Linux and a PowerShell equivalent for Windows. Those pin the protocol and TLS version in the curl invocation, which is a better practice than most scripts manage, but piping a script from a release URL into an interpreter is still a choice you should make deliberately.

Pre-built binaries are listed separately: a macOS universal binary covering Apple Silicon and Intel, Linux for x86_64 in both glibc and musl builds, and a Windows x86_64 MSI installer or a standalone executable.

Building from source needs Rust 1.88 or later, clone the repository and run `cargo install --path .`.

The flags cover selection, limits and export

The command line is where most of the behaviour lives, and the README documents it in groups.

Interactive mode with a starting sheet and formulas shown by default:

xleak report.xlsx --sheet "Q3 Results" -i
xleak data.xlsx -i --formulas

A separate flag, `-H`, enables horizontal scrolling with auto-sized columns for wide files, which is the answer to a spreadsheet with more columns than your terminal.

Sheets can be selected by name or by index, and the index is 1-based, so `--sheet 2` is the second sheet.

Row limiting uses `-n`, where 20 shows the first twenty rows and 0 shows all of them. That default is worth knowing, since `-n 0` is how you defeat a limit rather than a special value.

Export is a mode rather than a flag combination, writing to standard output so it composes with shell redirection:

xleak data.xlsx --export csv > output.csv
xleak data.xlsx --export json > output.json
xleak data.xlsx --export text --delimiter "|" > output.txt

Three formats and a configurable delimiter, with plain text described as tab-separated by default.

Output control is a matched pair. `--no-color` disables colour for piping, and `--color` forces it even when piped, with the example of piping into `less -R`.

CSV and TSV are first-class inputs rather than a side path, enabled by default with automatic delimiter detection and an override through `--csv-delimiter ";"` for semicolon-separated files.

One documentation inconsistency is worth flagging so it does not waste your time. The final pair of examples both use `--no-header` with different descriptions, one saying it treats the first row as data and the other saying it generates column headers A, B, C instead of using the first row.

Clipboard copy works over SSH because of OSC 52

Copying from a terminal application is usually the feature that fails away from a local desktop, and xleak addresses it directly.

`c` copies the current cell and `C` copies the entire row, with the row copy described as tab-separated. Both go through OSC 52 plus the system clipboard, and the README states that this works over SSH.

That is the important part. OSC 52 asks the terminal emulator to set the clipboard, and the README says xleak's copy commands work over SSH. Combined with the system clipboard through `arboard`, you get a cell copied in a remote shell and pasted into a local editor.

The Cargo.toml shows the dependency and the reason for its companions: `arboard` for the system clipboard and `base64`, which is part of the OSC 52 encoding. There is also a macOS-specific entry for `libc`, present because it is used to silence NSPasteboard's stderr diagnostics during clipboard writes. That is a small, specific fix that tells you the macOS path had a noisy failure mode.

A related detail for wide data is the sticky ID columns. A column-letter column and a row-number column stay fixed while you scroll horizontally, which helps keep row and column context visible while scrolling horizontally. Both can be turned off with `--no-column-id` and `--no-row-id`.

Large files switch to lazy loading at a thousand rows

The performance claim in the feature list points at a specific dependency: calamine, described as the fastest Excel parser in Rust, pinned at 0.35.0 in Cargo.toml.

On top of that, lazy loading kicks in for files with 1000 or more rows. Below that threshold the whole sheet is materialised; above it the viewer loads on demand as you scroll.

The formats are broader than the name suggests. Alongside `.xlsx` and `.xls` it reads `.xlsm`, `.xlsb` and `.ods`, so macro-enabled workbooks, the binary Excel format and OpenDocument spreadsheets all open. CSV and TSV are handled through a separate optional dependency, the `csv` crate, behind a `csv` feature that is enabled by default. Disabling default features drops CSV support and the dependency with it, which is a real lever for a static binary.

One format-specific limitation exists. Excel Table support, meaning listing and extracting named tables, is marked as `.xlsx` only.

The rest of the build configuration is tuned for a released binary. The release profile uses `opt-level = 3`, link time optimisation and a single codegen unit, while a separate `dist` profile inherits from release and switches to thin LTO for the `dist` tool's builds. That is a small detail, but it is the difference between a fast build and a fast program.

The crate targets Rust edition 2024 and declares `rust-version = 1.88`, which is the real floor for anyone building it themselves.

Where xleak is the wrong tool

Three cases.

If you need to change data, this is the wrong program. Every documented capability reads: view, search, inspect formulas, copy, export. There is no editing, no recalculation and no save. A workbook with volatile formulas will show the cached values Excel left behind, not a fresh evaluation.

If you need to analyse rather than look, a spreadsheet application or a proper dataframe tool will serve you better. xleak gives you a rendered table and three export formats, and everything after that is your problem.

If your file is corrupt or exotic, the parser is the constraint. Reading is delegated to calamine, so a workbook that library cannot open will not open here, and the error will come from that layer rather than from a friendly message.

A smaller practical note: the TUI is keyboard-driven, so if you are reading on a system where you cannot use a terminal with a proper escape sequence handler, the non-interactive mode with `--no-color` is the fallback rather than the experience.

On the project itself, activity is regular. v0.2.6 was released on 2026-05-24, after v0.2.5 and v0.2.4, both listed with release dates of 2025-12-04, and the last push was on 2026-10-13. The default branch is `devel`, and the repository carries a CHANGELOG.md, a RELEASE_CHECKLIST.md, an AGENTS.md and Nix files, which is the paperwork of a project being maintained rather than published once. The licence is MIT.

Editorial conclusion

Adopt xleak if you read spreadsheets from a terminal or over SSH and only need to view, search and export data, since it avoids opening Excel on a remote machine. Skip it if you need to edit cells, evaluate formulas or open a corrupted workbook that the calamine parser rejects. Verify first that your file is one of the seven supported extensions and that `xleak <file> -i` starts, and install through Homebrew or Scoop rather than the piped installer script.

Frequently asked questions

Official sources

1. bgreenwell/xleak on GitHub
2. Issues
3. License: MIT
4. README
5. Releases