Tabiew: a terminal viewer for CSV, Parquet and a dozen other table formats

The gap Tabiew fills between head, less and a notebook

Opening a CSV in a terminal usually means one of three things: `head -n 20`, `less`, or a Python one-liner that loads pandas and prints a frame. None of them gives you a scrollable grid, column widths that adjust, or a way to ask a question about the data without writing a script. Tabiew targets exactly that moment. The README describes it as "a lightweight TUI application that allows users to view and query tabular data files", and the feature list backs the claim with vim-style keybindings, SQL support, fuzzy search, multi-table handling and plotting. The audience is narrow and specific: engineers, analysts and SREs who are already in a terminal and do not want to leave it to inspect a file. If you are comfortable in Jupyter, Tabiew is not aimed at you.

How Tabiew loads a file and what the UI does with it

The entry point is a single binary called `tw`. You pass it one or more paths, and format detection is driven by the file extension: `.csv`, `.tsv`, `.parquet`, `.pqt`, `.json`, `.jsonl`, `.arrow`, `.fwf`, `.db`, `.sqlite`, `.xls`, `.xlsx`, `.xlsm`, `.xlsb`, `.avro`, `.html`, `.htm`, `.md` and `.markdown` all map to a reader. Logfmt is the exception, because it has no distinctive extension, so it requires an explicit `-f logfmt`. Once loaded, the interface is a grid with a status bar, and `Enter` opens a sheet view where `f` toggles between the default rendering and JSON. Multi-table functionality means several files can be open at once and switched with `t`. Queries go through a command palette opened with `:`, which lists `Query`, `Filter`, `Order`, `Select`, `Cast`, `Import`, `Export`, `Schema`, `ThemeSelector` and `ToggleNerdFont`. Four prefixes bypass the list: `q `, `s `, `o ` and `f ` open an inline editor for SQL, select, order and filter respectively. Navigation uses `h j k l` or the arrow keys, `b` and `w` step between columns, `Ctrl + r` resets the frame, `/` starts a fuzzy search and `Q` quits. The whole thing is one process with no server component.

Installing Tabiew and running a first query

The README lists six install paths. On Linux and macOS there is a shell installer that pipes a script from the repository into `sh`. Arch users get an official repository package. Debian and RPM users download a package from the releases page. macOS users can use Homebrew core, and Cargo users can install from crates.io. The Cargo route is the most predictable because it pins dependencies with `--locked`:

cargo install --locked tabiew

After that, the binary is `tw`. Note the crate is named `tabiew` but the command is `tw`, which is easy to miss. Building from source instead requires rustc 1.95 or higher, per the README, and the build command is `cargo build --release`, after which the binary is copied out of `./target/release/tw`.

A first real use is opening a CSV and previewing it before committing to a full load. The README gives `--max-rows` for exactly this, and notes it applies to CSV, DSV, TSV, Parquet, JSON, JSON Lines, Arrow and Avro:

tw big.csv --max-rows 1000

You should see a grid of the first 1000 rows with the header row in place. From there, press `:` and type `q ` to open the SQL editor, then write a query against the loaded table. Delimiters are configurable when the file is not comma-separated, and `--no-header` tells Tabiew the first line is data:

tw data.csv --separator ';' --no-header

If the extension lies about the contents, `-f` overrides detection, for example `tw data.txt -f parquet`. Tabiew also reads from stdin, which the README demonstrates by piping a remote CSV through curl into `tw`.

The nerd font setting is the first thing that will look broken

Settings live in `~/.config/tabiew/config.toml` and are written back whenever you change one from the command palette. The README calls out one key explicitly: `use_nerd_font` defaults to `false` and turns on glyphs in the status bar and pickers. The README's own warning is blunt: leave it off unless your terminal uses a patched font, or the glyphs render as empty boxes. This is a real first-run failure mode. Turn the setting on with an unpatched font and the interface looks corrupted rather than merely plain. The inverse is also worth knowing: the config file is rewritten by the application, so hand edits can be overwritten when you toggle a setting from the palette.

Where Tabiew stops being the right tool

Tabiew is a viewer with a query surface, not a transformation engine. The command palette covers `Select`, `Cast`, `Filter` and `Order`, which is enough for inspection, but the README does not document a way to save a chain of those operations as a repeatable script. `Export` exists, so you can push a result out, but the pipeline itself lives in your keystrokes. That makes Tabiew a poor fit for anything you need to run nightly or share with a colleague as a reproducible artifact. Large files are another boundary. `--max-rows` is offered precisely because loading a multi-GB file is something the README treats as a step to sanity-check first, not something to do casually. And if your data needs reshaping before it is readable, wide-to-long pivots, splitting columns, deduplication, Tabiew gives you SQL but not a visual editor for those operations. Finally, `--max-rows` is documented for CSV, DSV, TSV, Parquet, JSON, JSON Lines, Arrow and Avro; the README does not state that it applies to SQLite, Excel, HTML or Markdown sources, so do not assume it does.

VisiData, csvlens and DuckDB take different routes to the same file

The obvious comparison is VisiData, which is also a terminal data browser and also opens CSV without a schema. The difference is in the interaction model. VisiData is built around a stack of sheets where every operation, sorting, filtering, frequency tables, is a command applied to the current sheet and pushed onto a history you can undo. Tabiew is built around a grid plus a SQL palette, so the mental model is closer to a database client than to a spreadsheet. csvlens is the other end of the spectrum: a pager-style CSV viewer with search and no query language, which is lighter than Tabiew but cannot answer a question about aggregates. DuckDB is not a TUI at all, but it competes for the same job once your question is analytical rather than visual; it gives you a full SQL engine over CSV and Parquet from a shell prompt with no interface to learn. If you want to look at data, Tabiew or csvlens. If you want to compute over it, DuckDB. If you want to edit it interactively, VisiData.

Licence, release cadence and what an upgrade costs

Tabiew is MIT licensed, and the repository ships a `deny.toml`, which is the cargo-deny configuration file used to audit dependency licences and advisories. That is a signal the maintainers care about what enters the dependency graph, though it is not a guarantee about any specific crate. The licence itself is permissive with no copyleft obligation, which matters if you redistribute the binary inside a product; as always, read the LICENSE file rather than this summary. On maintenance, the last push to the default branch was on 2026-09-23, and the most recent release listed is v0.15.1 from 2026-09-09, following v0.15.0 on 2026-09-06 and v0.14.2 on 2026-08-17. The version numbers are still in the 0.x range, which in practice means the command-line surface and the config file format can change between minor releases. The config file at `~/.config/tabiew/config.toml` is written by the application, so a release that adds or renames a key can rewrite your settings. The crate requires rustc 1.95 or higher and uses edition 2024, so `cargo install --locked tabiew` is the upgrade path least likely to surprise you; pinning the version is the safer choice if you script around `tw`.

Editorial conclusion

Adopt Tabiew if your workflow is already a shell and you want to look at a CSV, Parquet or Arrow file, run a SQL query and plot a column without starting a notebook. Do not adopt it if you need to reshape messy data, join across many large tables or script a repeatable pipeline; VisiData and DuckDB fit those jobs better. Before installing, check two things: that your rustc is at least 1.95 if you build from source, and that your terminal renders the status bar glyphs correctly, since use_nerd_font defaults to false in ~/.config/tabiew/config.toml.

Frequently asked questions

Official sources

1. Issues
2. License: MIT
3. README
4. Releases
5. shshemi/tabiew on GitHub