VisiGrid

The spreadsheet built like a code editor.

Native, keyboard-first, and ~300ms from launch to first cell. A 16 MB download in a category where the incumbent install is 50× bigger. For macOS, Windows, and Linux.

Built in Rust, powered by GPUI (the GPU-accelerated UI framework behind Zed).

Most spreadsheets feel heavy.

They take seconds to open. They hide actions behind menus. They bury a formula — the thing a spreadsheet is — under ribbons and dialogs.

VisiGrid treats a spreadsheet the way a code editor treats code:

• Instant startup (~300ms cold launch)
• Command palette for every action — type what you want, no menu spelunking
• Keyboard-first navigation with Excel muscle-memory shortcuts that never change
• Conditional formatting you type, not click — =A1>100 -> warning, previewed live on the grid as you type
• Local-only files — no accounts, no cloud
• Inspectable formulas and dependencies
• Works with existing files — Excel, CSV, ODS, JSON, TSV

When correctness matters, VisiGrid also makes failure visible:

• Deterministic recomputation — same inputs, same outputs, always
• Explicit dependencies — precedents, dependents, and evaluation order are inspectable
• Traceable changes — structural edits generate provenance you can review and replay

For advanced workflows, VisiGrid also includes a CLI and headless mode built on the same engine.

VisiGrid was influenced by keyboard-first environments such as Omarchy — prioritizing speed, minimal friction, and staying in flow.

• Command palette for every action
• Keyboard-first navigation and editing — smart Ctrl+A (region first, sheet second), single-cell Ctrl+D/Ctrl+R fill, Ctrl+Enter fill-selection
• Conditional formatting as typed rules with live grid preview and match counts
• Multi-select editing across non-adjacent cells
• Format Painter (single-shot and locked mode)
• 120+ formula functions with autocomplete
• Instant startup and smooth scrolling
• 5 built-in themes including System (follows OS dark/light)

• Local-first: Your data lives on your machine. No accounts required.
• Native performance: GPU-accelerated rendering. Smooth at any scale.
• Explainable by default: Causality is visible. Trust is earned.
• No lock-in: Standard formats. Export freely.

The desktop app is the debugger for your data.

• Cell Inspector — view formulas, values, precedents, dependents, and recompute timestamps.
• Path Tracing — follow data flow across sheets and ranges.
• Provenance History — structural edits emit replayable scripts.
• Cycle Detection — circular dependencies caught at edit-time.
• Deterministic recomputation — explicit verification of stale vs current values.

Most AI tools trade explainability for convenience. VisiGrid doesn't.

The problem: AI in spreadsheets typically means black-box automation — formulas appear, values change, and you're expected to trust the result. When something goes wrong, there's no audit trail.

VisiGrid's approach: AI is a witness, not an author.

1. Cell-level truth — Inspector shows formula, value, inputs, dependents. Deterministic, local, zero AI involvement.

2. Change-level accountability — Every mutation is tagged: Human vs AI (with provider and timestamp). The diff engine surfaces net effects. AI-touched filter exposes exactly where AI participated.

3. Narrative understanding — "Explain this change" and "Explain differences" describe what happened in plain language. Both are optional, bounded, and never modify data.

• Answer questions about your data with formula proposals
• Summarize what changed between two points in history
• Explain individual cell changes in 2-4 sentences

• Edit cells without your explicit approval
• Run automatically or in the background
• Hide its participation (provenance is always visible)
• Suggest changes from the audit view

When you open a workbook six months from now, you can answer:

• Which values came from AI?
• What exactly did it change?
• Can I verify the formula it suggested?

The answer to all three is yes. That's what "explainable" means.

Get the latest release from Releases.

Or via package manager:

# macOS
brew install --cask visigrid/tap/visigrid

# Windows
winget install VisiGrid.VisiGrid

# Arch Linux
yay -S visigrid-bin

Requires Rust 1.95.0+ (pinned in rust-toolchain.toml — rustup picks it up automatically).

git clone https://github.com/VisiGrid/VisiGrid.git
cd VisiGrid
cargo build --release -p visigrid-gpui
./target/release/visigrid

Recent Xcode versions ship the Metal shader compiler as a separate component. If the build fails with cannot execute tool 'metal':

xcodebuild -downloadComponent MetalToolchain

# Ubuntu / Debian
sudo apt-get install libgtk-3-dev libxcb-shape0-dev libxcb-xfixes0-dev \
  libxkbcommon-dev libxkbcommon-x11-dev libwayland-dev

• Import: CSV, TSV, JSON, XLSX, XLS, XLSB, ODS
• Export: XLSX (File → Export to Excel), CSV, TSV, JSON, .sheet
• Interchange: visigrid-json — a stable, versioned JSON schema carrying values, formulas, formats, and merges (vgrid convert model.xlsx -t json-full); built for scripts and services that round-trip sheets through the engine
• Cross-platform: macOS, Windows, Linux

For users who treat spreadsheets as part of a larger system, VisiGrid includes a full CLI and headless execution mode built on the same engine.

VisiGrid ships a CLI that runs without a GUI. Same engine, no window.

# Evaluate a formula against piped data
cat sales.csv | vgrid calc "=SUM(B:B)" --from csv

# Reconcile two datasets by key
vgrid diff vendor.xlsx ours.csv --key Invoice --compare Total --tolerance 0.01

# Convert between formats (both directions — xlsx in and out)
vgrid convert data.xlsx --to csv
vgrid convert data.csv --to xlsx -o report.xlsx

# Full-fidelity JSON: formulas, formats, merges (stable versioned schema)
vgrid convert model.xlsx -t json-full | jq '.cells[] | select(.formula)'

# Project a vendor export down to reconciliation columns, then diff
vgrid convert vendor.xlsx -t csv --headers --select 'Invoice,Amount' | \
  vgrid diff - our_export.csv --key Invoice --compare Amount --tolerance 0.01

The CLI reads spreadsheet files (CSV, XLSX, JSON, TSV), runs the same formula engine and comparison logic as the GUI, and writes structured output to stdout. Exit codes are stable for scripting. Output is JSON or CSV.

Filtering rows (convert --where) — no awk required:

# Pending transactions
vgrid convert rh_transactions.csv -t csv --headers --where 'Status=Pending'

# Pending charges (negative amounts)
vgrid convert rh_transactions.csv -t csv --headers \
  --where 'Status=Pending' --where 'Amount<0'

# Vendor name contains
vgrid convert rh_transactions.csv -t csv --headers \
  --where 'Description~"google workspace"'

Five operators: = != < > ~ (contains). Typed comparisons — numeric RHS triggers numeric compare, string RHS triggers case-insensitive string compare. Lenient parsing handles $1,200.00. Multiple --where = AND.

Column selection (convert --select) — pick and reorder output columns:

vgrid convert data.csv -t csv --headers --select 'Status,Amount'

# Filter by one column, output different ones
vgrid convert data.csv -t csv --headers \
  --where 'Status=Pending' --select 'Amount,Vendor'

Reconciliation (diff) compares two datasets row-by-row:

• Rows only in the left file, only in the right file, or in both with value differences
• Numeric tolerance for financial data ($1,234.56, (500.00) handled natively)
• Either side can be - to read from stdin — pipe live exports directly into reconciliation
• Duplicate keys and ambiguous matches fail loudly instead of guessing

Example summary (from --out json):

{
  "contract_version": 1,
  "summary": {
    "matched": 14238,
    "only_left": 12,
    "only_right": 9,
    "diff": 3,
    "diff_outside_tolerance": 1
  },
  "results": [ ... ]
}

Control a running VisiGrid GUI from the terminal. Inspect cells, apply changes, and watch state evolve — all from scripts or the command line.

# List running sessions
vgrid sessions

# View live grid snapshot (auto-refresh on changes)
vgrid view --follow

# Inspect a cell
vgrid inspect A1
# → A1 = 1234.56  (number)

# Apply operations with retry on contention
cat ops.jsonl | vgrid apply --atomic --wait

# Query server health
vgrid stats

Session protocol: TCP localhost with token auth. Protocol v1 is frozen — wire format locked by golden vectors.

Scriptable control loop:

# Get session
SESSION=$(vgrid sessions --json | jq -r '.[0].session_id')

# Inspect current state
REV=$(vgrid inspect workbook --json | jq '.revision')

# Apply changes with revision check (prevents stale overwrites)
vgrid apply ops.jsonl --atomic --expected-revision $REV --wait

# Verify new state
vgrid view --range A1:D10

Exit codes are stable for scripting: 0 = success, 20-29 = session errors (conflict, auth, protocol).

VisiGrid provides a headless build loop for LLM agents and CI pipelines. Write Lua, build a .sheet, inspect results, verify fingerprint.

# Build from Lua script (replacement semantics — Lua is source of truth)
vgrid sheet apply model.sheet --lua build.lua --json

# Inspect cells to verify results
vgrid sheet inspect model.sheet B3 --json
# → {"cell":"B3","value":"220000","formula":"=SUM(B1:B2)","value_type":"formula"}

# Get fingerprint for audit trail
vgrid sheet fingerprint model.sheet --json
# → {"fingerprint":"v1:42:abc123...","ops":42}

# Verify in CI (exit 0 = match, exit 1 = mismatch)
vgrid sheet verify model.sheet --fingerprint v1:42:abc123...

Fingerprint boundary: set(), clear(), and meta() affect fingerprint. style() does not. Agents can format sheets without breaking verification.

Workflow rule: Always apply → inspect → verify. Never assume results.

See Agent Tools for MCP definitions and Claude MD Snippet for copy-paste instructions.

Exit 0 means reconciled (within tolerance). Exit 1 means material differences — missing rows or diffs outside tolerance. Exit ≥ 2 means error. No wrapper scripts needed.

Bank statement vs ledger:

# Reconcile bank export against your ledger
# --key-transform digits: match "INV-001" to "PO-001" by extracting "001"
vgrid diff bank_export.csv ledger.csv \
  --key Reference --key-transform digits \
  --compare Amount --tolerance 0.01 \
  --out json

Vendor export via stdin:

# Pipe a live vendor export, project to reconciliation columns, then diff
curl -s https://vendor.example.com/api/export.csv | \
  vgrid convert - -t csv --headers --select 'Invoice,Amount' | \
  vgrid diff - our_export.csv --key Invoice --compare Amount --tolerance 0.01

CI gate with strict exit:

# In CI: fail the build if ANY value differs, even within tolerance
vgrid diff expected.csv actual.csv \
  --key SKU --tolerance 0.01 --strict-exit --quiet || {
  echo "Reconciliation failed — diffs detected"
  exit 1
}

More examples:

# Quiet mode: just the exit code, no output
vgrid diff expected.csv actual.csv --key id --quiet

# Pipe a live export into diff
rails runner 'Ledger.export_csv' | vgrid diff - expected.csv --key id --quiet

# Verify a provenance trail hasn't been tampered with
vgrid replay audit-trail.lua --verify --quiet

• Conditional formatting is new in 0.12: rules are add/clear via the typed dialog; a full rules-management panel (edit/reorder existing rules) is in progress
• Replay: layout operations (sort, column widths, merge) are hashed for fingerprint but not applied to workbook data
• Nondeterminism detection is conservative — NOW(), TODAY(), RAND(), RANDBETWEEN() fail --verify even in dead-code branches
• Multi-sheet export writes sheet 0 only
• CLI calc reads from stdin only; no file-path argument

VisiGrid is fully usable under its open-source license.

Some organizations require additional guarantees around scale, support, or long-term use. Commercial licenses are available for large-file performance, team controls, and operational assurances.

See visigrid.app/commercial for details.

VisiGrid integrates with VisiHub, a public-first publishing service for versioned datasets.

VisiHub is optional and not required to use VisiGrid.

VisiGrid is open source under AGPLv3 with a plugin exception.

This ensures improvements remain open while allowing commercial plugins and extensions. Plugins using the public API may be licensed independently. Commercial licenses are available for organizations that require alternative terms.

See LICENSE.md for details.

Issues and pull requests are welcome.

Diff bug reports: if you file a bug against vgrid diff, include a minimal CSV fixture that reproduces the issue. Every confirmed diff bug becomes a corpus golden test in tests/cli/diff/ — this is how the contract stays honest.

See the Roadmap for what's next.