Fast, local-first SQL workbench

A native, GPU-rendered app with no accounts and no telemetry.

Download BarSQL Star on GitHub

Free and open source · Windows, macOS and Linux Other platforms

Works with

SQL tools are usually overkill. BarSQL isn't.

01

Native and GPU-rendered

Drawn on the GPU with GPUI, the UI framework behind the Zed editor: one Rust codebase from the database drivers to the window.

02

Yours, entirely

Everything runs and stays on your machine. No account, no sign-in, no telemetry: your connections and queries never leave your computer.

03

Portable by design

Connections, history, saved queries and settings live in one BarSQL-data folder next to the app. Copy both to a USB stick and carry on elsewhere.

04

Tested for real

Whole-window UI tests drive the app with real keystrokes and clicks, and end-to-end suites run against real PostgreSQL, MySQL, MariaDB, SQL Server, ClickHouse and libSQL servers.

Tour

A closer look

The work you do every day, without the detours.

SQL editor

Write SQL at full speed

Suggestions know your schema and your engine: tables, columns, aliases and CTEs, every built-in function with its arguments, and JOIN snippets where a join fits.

  • Run the statement at the caret, a selection, or the whole script
  • Multiple cursors, line commands and go to definition, as in VS Code
  • :name parameters ask for their values, and remember them
  • A result tab per output, and notices, warnings and PRINT output in a Messages tab
  • Pinned transactions per tab: BEGIN, then commit or roll back from the toolbar
  • An error is underlined where it happened, and a mistyped name gets a one-click fix
More about the SQL editor
Plan viewer

See why a query is slow

Explain shows the planner's estimate; Explain analyze runs the statement and reports what really happened. Every engine's plan lands in the same tree, with costs and timings wherever the engine reports them.

  • A heat bar on each node's own share of time, cost or rows
  • Row estimates 10x off are flagged: that's where a missing index hides
  • Every detail the engine reported, plus its raw output
  • Analyzing a write always rolls it back, so nothing lands
More about the plan viewer
Table data

Edit rows, not UPDATE statements

Browse any table, filter it with a WHERE condition that autocompletes, and change it in place. A query's results edit the same way, when they come from one table with its primary key.

  • Edits and deletes are staged until you apply them, with undo and redo
  • Paste blocks of cells, set NULL, insert rows
  • Checkboxes for booleans, and a picker for enums
  • Jump through foreign keys to the row a cell points at
  • The focused row as JSON beside the grid, filterable by key
More about editing data
Results

See the shape of a result

The Chart button plots any result as bars or lines, beside the grid it came from. Pick the labels and up to five values, summed, counted or averaged where labels repeat.

  • Sensible picks to start from, kept when you switch back to the grid
  • The count, sum, average, min and max of a selection in the status bar
  • Numbers lined up on the decimal point, and each column's type and keys in its header
  • Many bars scroll sideways rather than squeeze together
More about the results grid
Schema

Your schema, down to the triggers

Schemas, tables and columns, then indexes, constraints, triggers and functions, fetched only when you open them.

  • An ER diagram of a schema, with a table's keys lit as you point at it
  • Compare two schemas and get the script that syncs them
  • Copy any object's DDL, or open it in a tab ready to run
  • Rename, truncate and drop, with the exact SQL shown first
  • Back a table up to a .sql file that restores it exactly
  • System views for what the server is doing, or how a table is doing
More about the schema explorer
Structure editor

Change a table without writing ALTER

Edit a table's columns, indexes, foreign keys and checks in a Structure tab, or design a new table there. The SQL it will run sits right below, and follows every edit.

  • Added rows in green, changed fields in yellow, dropped ones struck through
  • One transaction on PostgreSQL and SQL Server, and a single ALTER TABLE on MySQL
  • SQLite tables rebuilt in a transaction when ALTER can't do the job
  • If the server refuses, its message shows and your edits stay as they are
More about the structure editor
Import and export

Data in, data out

Load a CSV into a new or existing table, or run a .sql script, and export any result in the format you need.

  • Delimiter detected, columns mapped, types inferred for a new table
  • Bad rows skipped and reported, with live progress and Stop
  • Export as Text, CSV, JSON, Markdown, or SQL INSERTs in your engine's own syntax
  • CSV and SQL exports import back cleanly, NULLs included
More about import and export
AI assistants 
list_connections  shared connections
list_tables       schemas and tables
describe_table    columns and keys
show_ddl          CREATE statements
run_query         read-only SQL
explain_query     query plans
run_change        changes you allow

Your databases, in your AI assistant

BarSQL is an MCP server too. Claude, Cursor, VS Code and other AI apps start BarSQL --mcp in the background, with no window, and work with the connections you share.

  • Opt in per connection: the rest stay invisible to the AI
  • Queries pass BarSQL's read-only check, and PostgreSQL, MySQL, SQLite and ClickHouse sessions refuse writes too
  • Changes only where you allow them, with a preview that rolls back
  • No password or token reaches the AI, and every call is logged
  • Set up with one paste: tick Allow AI assistants, then Copy MCP setup
More about AI assistants
Engines

Six engines. One app.

The same editor, grid, schema tree and plan viewer on every engine, speaking each one's own dialect. Read-only connections are refused by BarSQL and, wherever the engine allows, by the server as well.

PostgreSQL

Server
  • SSL: disable, require, verify-full
  • Notices and warnings as they arrive, in the Messages tab
  • Activity, blocking and long-running queries in one click
  • DDL composed from the catalog
  • Powered by tokio-postgres

MySQL / MariaDB

Server
  • TLS transport
  • Warnings and notes in the Messages tab
  • The process list and open InnoDB transactions
  • The server's own SHOW CREATE DDL
  • Powered by mysql_async

SQL Server

Server
  • TLS, including TDS 8.0 strict, and named instances
  • GO batches, with PRINT output in the Messages tab
  • Estimated and actual plans from Showplan XML
  • Requests, sessions and blocking at a glance
  • SQL Server 2017 or newer, powered by tiberius

ClickHouse

HTTP
  • HTTP or HTTPS, with a session per tab, so SET and USE hold
  • Read-only connections run with readonly=2 on the server too
  • Plans with the indexes each step reads
  • Array, Map and Tuple values read as JSON
  • A table's parts, mutations and merges

Turso / libSQL

HTTP
  • Turso Cloud, or your own sqld, with an auth token
  • Rows stream in as the server sends them
  • An expired stream reopens by itself, and says what was lost
  • libSQL's vector functions in completion and hover
  • SSH tunnel to a self-hosted sqld

SQLite

File
  • Open a file, or drop it on the window
  • Opens straight from Finder or Explorer
  • Extensions such as cr-sqlite, loaded as it opens
  • Local libSQL and Turso files open here too
  • Bundled SQLite via rusqlite

What each engine gets

Feature PostgreSQL MySQL / MariaDB SQL Server ClickHouse Turso / libSQL SQLite
Read-only modeYesYesYesYesYesYes
SSH tunnelYesYesYesYes1Yes, self-hosted sqld onlyNot applicable
Transactions pinned to a tabYesYesYesNo2No, though a script's own BEGIN … COMMIT worksYes
Edit rows and query resultsYesYesYesNoYesYes
Structure editorYesYesYes3Yes, columns onlyYesYes
Function completion and hoverYesYesYesYesYesYes
Messages tabYesYesYesNoNoNo
System viewsYesYesYesYesNoNo
Query plan treeYesYesYesYesYesYes
Measured plans (explain analyze)YesYesYesNoNoNo
Copy DDL and table backupsYesYesYesYesYesYes
AI assistants (MCP)YesYes4Yes, with a read-only loginYes4Yes, with a read-only tokenYes

1 To a self-hosted sqld; Turso Cloud is reached directly. 2 Turso holds no transaction between runs, but a script's own BEGIN … COMMIT works. 3 Columns only. 4 The server doesn't refuse writes by itself here, so give the AI's connection a read-only login or token. ClickHouse has no transactions and no primary keys to edit rows by, so its tables are browse-only.

Features

Everything you need. Nothing you don't.

Smart autocomplete

Fuzzy and context-aware: schema.table.column dot completion, quoted identifiers, aliases, CTEs and JOIN snippets.

Function help

Every built-in function of your engine, plus the server's own, completes with its arguments. Hover one for its signatures and what it does.

Multiple cursors

Add a cursor at the next occurrence or at every one, and edit them all at once. Line commands, go to definition and go to line work as in VS Code.

Messages tab

PostgreSQL notices, MySQL warnings and SQL Server PRINT output, grouped under the statement that raised them, with levels and codes.

Multi-statement scripts

Statements run in order on one connection, so temp tables, SET and scripted transactions hold. SQL Server scripts run by GO batch.

Pinned transactions

BEGIN, COMMIT and ROLLBACK as SQL or from the toolbar. Queries run inside the tab's open transaction until it ends.

Streaming results

Rows render as the driver yields them, in a virtualized grid that scrolls smoothly through thousands of rows.

Quick charts

Plot a result as bars or lines: pick the labels and up to five value columns, summed, counted or averaged.

Query plan viewer

Estimated or measured plans as one tree on every engine, with heat bars and flagged estimates. Type EXPLAIN yourself and it opens there too.

System views

Activity, blocking, sessions and running queries, or a table's statistics, index usage, parts and merges, each in a tab you can tweak.

Schema explorer

Tables, views, columns, indexes, constraints, triggers and functions, with type and key icons, instant search and a row count that needs no tab.

ER diagrams and compare

Every table and key of a schema in a diagram you can pan, zoom and search, and a compare with another schema that writes the sync script.

Structure editor

Edit columns, indexes, foreign keys and checks, or design a new table. The exact SQL shows as you go, in a script your engine can apply safely.

Schema changes

Rename, truncate and drop from the tree. Each dialog shows the exact SQL for your engine, with Cascade on PostgreSQL.

Table backups

Structure and rows to a .sql file. The server writes every value as a literal, so dates, JSON and binary survive the round trip.

Edit data in the grid

In a table, or a query's results from one: staged edits, deletes and new rows with undo, paste and foreign-key jumps, checkboxes for booleans and pickers for enums.

Cell and JSON viewers

A cell editor for large values (JSON, XML, HTML or text), and a JSON view of the row. PostgreSQL arrays and ClickHouse maps and tuples read as JSON too.

CSV and SQL import

Column mapping, inferred types, configurable NULL text and header rows, or a .sql script run statement by statement.

One-click export

Text, CSV, JSON, Markdown or SQL INSERT written for your engine, for all or the selected rows, to the clipboard or a file.

Saved queries and history

Save and reuse queries with unsaved-change tracking, plus per-connection history with status and duration, filterable to failed runs.

Safety nets

Ask before changes on production connections, a check before an UPDATE or DELETE without WHERE, and read-only mode the server enforces too, where it can.

SSH tunnel

Reach a database only its bastion can see, with a key, a password or ssh-agent, and host keys checked against known_hosts.

Connection manager

Folders, tab colors, read-only mode and a database list fetched from the server, plus SQL Server named instances and Turso tokens.

SQLite extensions

Load extensions such as cr-sqlite into a connection each time it opens. Their functions complete and show on hover, and Test says why a file didn't load.

Keyboard-first

Quick Search jumps to tabs, tables, saved queries and connections, and the command palette runs any command, with its shortcut. Shortcuts are remappable.

Instant and polished

Dark and light themes that can follow the system, English, Deutsch, Български and Español, no animations in the way, and your window restored where you left it.

Updates itself

A new release shows up with its notes. One click downloads it, checks its SHA-256 and restarts into it.

Gallery

Screenshots

Click a screenshot to see it full size, then use the arrow keys to browse.

Cell editor
Grid
Export
Connections
Quick Search
DDL viewer
Plan viewer
CSV & SQL import
Structure editor
ER diagram
Quick charts
Appearance
Shortcuts

Keyboard-first

Most can be remapped in the app's shortcuts editor. The editor's own keys work as in VS Code.

Quick Search
CtrlP
Command palette
CtrlShiftP
Run selection, or the statement at the caret
CtrlEnter
Run all statements
CtrlShiftEnter
Explain the query plan
CtrlShiftE
Explain analyze
CtrlShiftA
Go to definition
F12
Go to line
CtrlG
Add a cursor at the next occurrence
CtrlD
Save the query, or apply staged edits
CtrlS
New tab / close tab
CtrlT / CtrlW
Reopen a closed tab
CtrlShiftT
Toggle sidebar / JSON viewer
CtrlB / CtrlJ
Set a cell to NULL
CtrlBackspace
Zoom in / out
Ctrl= / Ctrl-
Rename a saved query
F2
Your data

Portable by design

Everything lives in one BarSQL-data folder next to the app (beside the .app on macOS): connections, the editor session, history, saved queries and settings. Move both to a USB stick, a network drive or another computer and pick up where you left off.

When the app sits somewhere read-only, the folder goes to your user data directory instead, and BARSQL_DATA_DIR puts it anywhere you like. 

BarSQL(.exe)
BarSQL-data/
  connections.json
  editor_session.json
  query_history.json
  saved_queries.json
  settings.json
Open source

Built with

One Rust codebase: a background Tokio runtime talks to the databases, so the UI thread only draws. ClickHouse and Turso go through BarSQL's own small HTTP client, which also runs over SSH.

RustLanguage GPUIUI framework GPUI KitComponents TokioAsync runtime tokio-postgresPostgreSQL mysql_asyncMySQL / MariaDB rusqliteSQLite tiberiusSQL Server httparseClickHouse & Turso HTTP russhSSH rustlsTLS LucideIcons

Download BarSQL

Free, open source and yours to keep. No account needed: download it and run it.

Every build updates itself from inside the app. All of them, with their checksums, are on the latest release. The Windows build isn't signed yet, so Windows asks once before the first launch: here's how. Prefer to build it? cargo run -p barsql --release, as the contributing guide explains.

Star on GitHub