There's a peculiar breed of programmer who views the mouse as an admission of defeat and considers leaving the terminal a form of context-switching trauma. For them, even opening a CSV file has historically meant choosing between sc-im—a venerable if somewhat arcane tool—or copying data into a text editor and squinting at comma-separated values until patterns emerge.
Cell, a new open-source spreadsheet editor written in Rust, arrived recently with a proposition that sounds almost contradictory: Excel-compatible formulas that respond to Vim's modal editing commands. The kind of thing that shouldn't work, perhaps, but does.
The project made its debut on Hacker News on April 27, 2026, drawing attention from developers who'd grown weary of bouncing between spreadsheet applications and their terminal workflows. Within a day of launch, creator Garrit Franke had already pushed three version updates, each incorporating features the community had immediately requested. The velocity suggested someone who'd been thinking about this problem for a while.
The Core Proposition
Cell presents itself as a terminal UI for spreadsheet data—nothing more, nothing less. Navigation works through the familiar hjkl keys; modal editing cycles through Normal, Insert, and Visual modes as any Vim user would expect. But the cells themselves can contain formulas prefixed with =, behaving much like their Excel counterparts.
The formula engine covers the basics you'd actually use: SUM, AVERAGE, COUNT, MIN, MAX, and IF. One early version introduced Neumaier's improved Kahan compensated summation for SUM and AVERAGE operations—the kind of detail that matters when floating-point precision errors compound in financial calculations. Not flashy, but the sort of thing that prevents embarrassing bugs six months down the line.
File format support includes CSV and TSV, naturally. But Cell also ships with its own .cell format that preserves formulas as formulas rather than flattening them to computed values. Export to CSV and those formulas get evaluated and written out as static numbers, useful when you need to hand data off to tools that don't understand what =SUM(B1:B10) means.
Where It Gets Interesting
The terminal interface is table stakes. What separates Cell from being merely "sc-im but newer" is its headless CLI mode—the ability to treat spreadsheet operations as scriptable commands.
You can read specific cells (cell data.csv --read A1), evaluate ranges (--read B1:B10), or calculate expressions on the fly (--eval '=SUM(B1:B10)'). A subsequent update added support for reading CSV or TSV data from stdin, which means you can pipe data directly into Cell from shell pipelines. Traditional spreadsheet applications don't really think this way.
The documentation suggests using Cell in Makefiles or CI pipelines: read a cell, check if a calculated value hits a threshold, fail the build if it doesn't. It's the kind of use case that sounds niche until you've spent an afternoon trying to extract a single number from an Excel file using Python and openpyxl just to validate a test suite.
Iteration in Real Time
Franke moved with unusual speed after the initial release. One patch fixed an issue where Windows users were registering double key events—the sort of platform-specific bug that drives people away if it lingers. Another version added operator counts (so 3dd deletes three rows), command history, dot-repeat for the last change, and Ctrl+A/Ctrl+X to increment or decrement cell values.
Performance improvements came through batch recalculation APIs. Benchmarks got added to the core library. Small touches, but they signal someone who's thinking beyond the initial demo.
The Vim emulation runs deeper than casual imitation. There are marks and a jump list. Search with / and ?. The f and F find-in-line commands. Visual block selection via Ctrl+V. Screen positioning commands like zz, zt, and zb. The README puts it plainly: "If you know Vim, you know cell." That's either confidence or hubris, depending on how seriously you take your modal editing.
The sc-im Question
Cell's documentation doesn't avoid the comparison to sc-im, the C-based terminal spreadsheet that's been around considerably longer and accumulated features accordingly. Sc-im supports XLSX and ODS file import, Markdown export, Lua scripting for extensibility, GNUplot integration for charting. It has richer formatting options and, frankly, a broader feature set.
Cell doesn't pretend otherwise. Instead, it stakes its claim on "true Vim modal editing, Excel-compatible formula syntax, modern Rust/ratatui stack, built-in clipboard and Windows binaries." The README even suggests choosing sc-im if you need XLSX import or Lua scripting today.
It's a calculated concession. The approach suggests a bet that a tighter, cleaner implementation of its core promise—spreadsheets that feel native to Vim users—will be enough.
Technical Architecture
The project is MIT-licensed and available through Rust's package manager: cargo install cell-sheet-tui. Pre-built binaries exist for Linux, macOS, and Windows on GitHub Releases. The repository has attracted a modest but growing number of stars and forks—enough to suggest the project found its audience without overpromising.
Architecturally, Cell splits into two crates: cell-sheet-core handles the data model, formula engine, and file I/O, while cell-sheet-tui implements the ratatui-based interface and event loop. Developers who want to embed spreadsheet logic without the terminal UI can use just the core library, which feels like forward thinking. Or at least optionality.
Command mode works as expected: :w to save, :w filename.csv to save to a specific file, :w! to flatten formulas to values, :e to open a new file, :sort A asc to sort by column A. Undo and redo with u and Ctrl+R. If you've used Vim, none of this requires documentation.
Early Reception
The Hacker News launch post generated engagement from developers who'd apparently been waiting for exactly this tool. Comment threads explored use cases—parsing log files into tabular form, doing quick financial calculations without context-switching, automating report generation in CI environments. Third-party analysis positioned Cell against VisiData and sc-im almost immediately, suggesting developers were actively searching for comparisons and context.
The timing of those comparisons—appearing the same day as the launch—hints at how quickly niche developer tools get evaluated and categorized. In certain circles, people notice.
What Cell Is and Isn't
Cell targets a specific niche: developers who live in the terminal and think in Vim keybindings. It's not trying to replace Google Sheets or Excel for most users, and Franke doesn't seem interested in pretending otherwise.
But for those who need to manipulate tabular data without leaving their terminal workflow, or who want to script spreadsheet operations in build pipelines, it might fill a gap that's been open longer than anyone wanted to admit. The developer who edits server configs in Vim, writes SQL queries in a terminal multiplexer, and then has to open LibreOffice just to sort a CSV file—that's the person Cell is for.
The project remains young. In its first two days, three updates landed in rapid succession—version 0.3.0 on April 27, followed by 0.3.1 and 0.4.0 on April 28. But the fundamentals seem sound: a working formula engine, comprehensive Vim emulation, and a clear vision for what problem it's solving.
Whether that's enough depends on how much you hate reaching for your mouse.
