Tusk and SQLly: two database clients on the same GPUI stack
Tusk and SQLly are both Rust apps drawn by GPUI. Tusk goes wide on engines and keyboard flow; SQLly goes deep on SQL, results and guardrails. Here's where each one wins.
Tusk is a new open-source database client that showed up at the end of September 2026 and passed 400 GitHub stars in its first weeks. Its README describes a fast, native, keyboard-driven client for macOS, Windows and Linux, with 20 database engines and an AI assistant that writes queries but never runs them. It’s written in Rust on GPUI, the GPU-drawn UI framework from the Zed editor. So is SQLly. That makes this an unusual comparison: two apps on the same foundations that went in different directions.
We build SQLly, so take the bias into account. We read Tusk’s README, its release notes for
0.2.0 and 0.2.1, its Cargo.toml and its source tree, and we checked the sizes of its
release downloads. We did not install it or benchmark it. Tusk is a few weeks old and made by
one main author, and for some people it’s already the better pick; we say which below.
The same stack, mostly
Under the hood the two projects overlap more than any other pair we’ve compared:
- UI. Both draw with GPUI and use the gpui-component widget library, and both carry small local patches to it. Tusk reaches gpui-component through the gpui-kit crate; SQLly tracks gpui-component 0.7 directly.
- Drivers. Both use tiberius for SQL Server, tokio-postgres with rustls, the DuckDB crate, russh for SSH tunnels and the keyring crate for the OS credential store. Tusk uses sqlx for PostgreSQL, MySQL and SQLite and adds clients for MongoDB, Cassandra (the scylla crate), Oracle (the pure-Rust oracle-rs), Snowflake, BigQuery and DynamoDB. SQLly uses mysql_async, rusqlite and the
oraclecrate. - Completions. This is the biggest architectural split. Tusk bundles two language servers, postgres-language-server for Postgres and sqls for most other SQL engines, and talks to them over LSP; elsewhere it completes from the live catalog. SQLly parses SQL itself and builds its own completions.
Tusk’s choice is a good one for a young project: it gets completions and diagnostics on many
engines without writing a parser. The trade-off is that a generic language server knows the
grammar and the catalog, not your data. SQLly’s IntelliSense
can pull a column’s real values into a WHERE clause, write a join’s
ON clause from actual foreign keys and flag a GROUP BY mistake, and it
keeps a 0.5 MB script at about 5 ms per keystroke. One practical note from Tusk’s README: the
language servers aren’t bundled on Windows yet, so Windows users get catalog completions only.
Download sizes
| Platform | SQLly | Tusk 0.2.1 |
|---|---|---|
| macOS (Apple Silicon dmg) | 65.6 MB | 85.3 MB |
| Windows x64 zip | 60.9 MB | 39.6 MB |
| Linux x64 | 76.2 MB tarball | 54.5 MB .deb, 54.1 MB .rpm, 69.1 MB Arch package |
Tusk’s Mac download includes the PostgreSQL client tools and both language servers, which accounts for at least part of the difference there. On Windows and Linux Tusk is the smaller download. Neither app supports Intel Macs. Tusk’s Linux build needs a Wayland desktop (Xwayland works as a fallback), and its Windows build isn’t code-signed yet, so SmartScreen warns on first launch.
Databases
| Engine | SQLly | Tusk |
|---|---|---|
| PostgreSQL, MySQL, MariaDB, SQLite, SQL Server | Yes | Yes |
| DuckDB, libSQL, Oracle, ClickHouse, Redis | Yes | Yes |
| CockroachDB | Documented wire-compatible | Yes |
| Redshift, Greenplum, Vertica, Cloudflare D1 | No | Yes |
| Snowflake, BigQuery | Planned | Yes |
| MongoDB, Cassandra, DynamoDB | No | Yes |
| Azure SQL with Entra sign-in | Azure SQL yes; Entra sign-in in progress | Not documented |
| Valkey, KeyDB, DragonflyDB, ElastiCache, MemoryDB, Neon, Supabase, Aurora… | Documented and tested | Not documented |
Tusk wins on breadth. If your week includes a warehouse like Snowflake or BigQuery, or a non-relational store like MongoDB, Cassandra or DynamoDB, Tusk connects and SQLly doesn’t. SQLly’s count of 30 comes from going deeper on fewer families: the engine list shows plans, dashboards, activity monitors and compare on each one, and Redis gets its own toolset (typed key editing, Cluster and Sentinel, ACLs, pub/sub, a memory analyzer).
Working in the app
Tusk is built around the keyboard. A command palette lists every action with its shortcut and also switches connections, databases, schemas and themes, and quick-open jumps to a table. The grid is virtualized, edits use typed editors for dates, enums and numbers, pending changes save in one transaction, and undo and redo cover cell edits. The structure editor changes columns, defaults, comments and indexes and generates each engine’s own DDL, and it warns you before a change the engine can’t make in place, such as a column type change in SQLite. That last detail is the kind of care you don’t usually see in a 0.2 release. It also ships more than 30 themes.
SQLly has a row editor and
designers too, and spends the rest of
its effort on results. Its grid streams rows and
spills to disk past 50,000 rows or 64 MiB, so fifty million rows use about as much memory as
fifty. Tusk pages table data 1,000 rows at a time. On top of SQLly’s grid sit
pivots, charts,
conditional formatting,
computed columns, result diffs and
Excel export. Tusk exports CSV, JSON and SQL,
imports CSV, and copies rows as TSV, CSV, JSON, INSERT, UPDATE or Markdown.
AI
The two apps landed in nearly the same place on the important question: neither lets an AI change your data on its own.
- Tusk drives an agent CLI you already have, Claude, Codex or Gemini CLI, over the Agent Client Protocol, under that CLI’s own account. The agent reaches your open connection through a small MCP server inside Tusk whose tools list and describe tables and read or write the query tab. It writes a query into a new tab and explains its assumptions; you run it. A failed query gets an “Ask AI to Fix” button.
- SQLly works with local models (Ollama, MLX), your own endpoint, or cloud providers you opt into, with no default provider. Its
sqlly-cli mcpserver is for agents outside the app: they can list connections, read schemas and run oneSELECTin a transaction the database keeps read-only and then rolls back. A write comes back to SQLly as a proposal you confirm, and production connections are refused.
Tusk’s approach is neat if you already pay for one of those CLIs: no keys to paste and no new provider. SQLly’s lets an agent look at real rows, safely, and works with a model that never leaves your machine.
Safety and admin tools
Tusk has status colors for connections (red for production, say) and a Safe Mode that asks before saving grid edits or running a statement that writes. Safe Mode is off by default. Its tools menu has a process list with cancel and kill on every engine, a search for a term across every row of every table in a schema, PostgreSQL role management, and PostgreSQL backup and restore.
SQLly’s guardrails go further: SELECT-only connections that
block file-reading and shell-escape tricks, a hard stop on UPDATE or DELETE
without WHERE, automatic rollback and tenant checks, set on a client, project or
environment and inherited by every connection under it. Its Tools
menu has an Activity Monitor with blocking chains, Query Insights, Extended Events, SQL Agent,
query plans on nine engines,
schema and data compare,
cross-engine data transfer, an index
analyzer, a test data generator and backup and restore as reviewable scripts.
What they cost, and how old they are
Tusk is free and MIT-licensed, with no account, no telemetry and no paid tier. SQLly has a free tier for hobbyists (two saved servers), a one-time $100 SQLly 1.x license and a $200 Lifetime license; see pricing. If open source or “free for the whole company” is a requirement, Tusk meets it and SQLly does not.
Tusk’s repository was created on 28 September 2026, version 0.1.0 shipped that night, and 0.2.0 added Windows and Linux two days later. The latest release is 0.2.1 from 30 September, and there are open pull requests from outside contributors for things like Simplified Chinese and a Nix flake. It’s early, and a lot can change in a month.
Which one to pick
Pick Tusk if:
- You use Snowflake, BigQuery, Redshift, Vertica, D1, MongoDB, Cassandra or DynamoDB.
- You need open source, or free at any company size.
- You want a command palette for everything and a long list of themes.
- You already use Claude, Codex or Gemini CLI and want it inside your database client.
- You mostly browse and edit tables.
Pick SQLly if:
- You write a lot of SQL and want completions that know your data.
- You work in SQL Server or Azure SQL and want its tools: Activity Monitor, Extended Events, SQL Agent, Query Store.
- You pull large results and want pivots, charts and diffs on them.
- You want guardrails that are on by design, inherited across environments.
- You read plans, compare schemas or move data between engines.
The fair test is your own database. Both apps are free to start and neither needs an account. The side-by-side table is at SQLly vs Tusk, and SQLly’s download is free.