DBDelve and SQLly: two Rust GPUI database clients, compared
DBDelve and SQLly share a UI framework and most of their driver crates. Where they differ: blocking vs async drivers, engines, ODBC, guardrails, DBA tools and price.
DBDelve is a database client that went up on GitHub in August 2026 and passed 650 stars in under three months. Its README describes it as “a fast, native, cross-platform, multi-engine database client” written in Rust with GPUI. That last part caught our eye, because SQLly is also written in Rust with GPUI. Of all the clients we compare against, this is the one built most like ours.
We build SQLly, so take the bias into account. We read DBDelve’s README, website, docs folder,
Cargo.toml and release notes, and checked the sizes of its v0.7.0 release files. We did
not run its benchmarks or test it against our own databases. It’s a young, one-maintainer-led
project with a lot going for it, and for some people it is the better pick. We say which below.
Same framework, same drivers
Most comparisons on this site set a Rust app against Electron, Java or a stack of native toolkits.
This one doesn’t. Reading the two Cargo.toml files side by side:
- UI. Both pin
gpui-pre0.3.9, the crates.io republish of Zed’s GPUI, and both build widgets on gpui-component (DBDelve on 0.8.0, SQLly on 0.7.3). Both draw on Metal on the Mac, Direct3D on Windows, and Vulkan on Linux, with no browser engine. - Drivers. Both use
tokio-postgresfor PostgreSQL,tiberiusfor SQL Server,rusqlitefor SQLite, theduckdbcrate with DuckDB compiled in, andredisfor Redis. - Where they split. DBDelve runs its drivers as blocking calls; SQLly runs most of its drivers as async tasks. DBDelve also uses the blocking
mysqlcrate where SQLly usesmysql_async, and it speaks HTTP to ClickHouse and Snowflake. This is the biggest difference under the hood, so it gets its own section below. - Customizing the framework. DBDelve vendors gpui and gpui-component and patches the renderers so its translucent “glass” themes composite correctly. It looks good in the screenshots, and it’s something SQLly doesn’t do.
We didn’t time them against each other, but with the same framework painting both, we’d expect scrolling and startup to feel similar. The real differences are in what each app does once the rows arrive.
Blocking drivers and async drivers
GPUI brings its own async executor, and that executor has no reactor of its own. A tokio
future, which is what tokio-postgres, tiberius and
mysql_async are built on, panics on it the moment it touches a socket or a
timer. DBDelve’s developer docs spell this out. Every GPUI database client has to decide
how to keep the two apart, and DBDelve and SQLly decided differently.
DBDelve makes everything blocking. Each statement runs as a blocking call on a
thread from the blocking crate’s pool, which by default grows to as many as 500
threads. The drivers that are async underneath (PostgreSQL, SQL Server, MongoDB) get a small
tokio runtime of their own per connection, kept behind the connection’s mutex, and every
call into them is a block_on on that thread. Nothing async ever leaves the driver
module. Cancel runs on a thread of its own, so it never waits behind the statements it is trying
to stop.
SQLly runs most of its drivers on one shared tokio runtime, separate from GPUI’s executor, with a worker thread per core. PostgreSQL, MySQL, SQL Server, ClickHouse, libSQL and Redis queries are tasks on that runtime, and their rows reach the grid through a bounded channel. Three drivers can’t work that way because the libraries under them are synchronous: Oracle (ODPI-C), SQLite and DuckDB. Each connection to one of those gets a dedicated OS thread for its whole life, and the async side talks to it over channels. So SQLly is not async all the way down. For those three engines it does roughly what DBDelve does for all of them.
Both designs work, and neither one is a bug waiting to happen. Here is what the difference means in practice:
- A waiting query costs different things. In DBDelve, a statement that is waiting on the server holds a pool thread, with its stack, for as long as it runs. In SQLly, a query on a network engine that is waiting is a parked task: a few kilobytes of state and no thread. With a handful of tabs open you won’t notice this either way. It starts to matter when many things wait at once: long-running reports in several tabs, refresh loops on monitoring panes across a dozen servers, Redis pub/sub and
MONITORstreams, and schema loads for every connection in a big tree. - Running statements side by side. A DBDelve connection runs one statement at a time behind its mutex. To run more, DBDelve opens extra connections for the batch, up to eight at once. SQLly pools connections per lane: a finished query checks its connection back in for the next one to reuse, and concurrent queries open parallel connections instead of queueing. Both avoid one slow query blocking the next. SQLly also avoids paying for a fresh handshake each time, which matters most on Azure SQL, where every new connection costs token validation at the gateway.
- How Cancel and timeouts reach a statement. A blocking read can’t be interrupted from its own thread, so DBDelve cancels from another thread, and its ClickHouse transport checks for Cancel and an idle limit between reads. In SQLly, a timeout or a Cancel is one more event the task waits on alongside the next batch of rows, so it takes effect at the next await point. Then both apps do the part that really counts and stop the work on the server: PostgreSQL’s cancel request,
KILL QUERYon MySQL and ClickHouse. On SQL Server, SQLly ends the session, becausetiberiusdoesn’t expose the TDS Attention signal. - Backpressure is the same idea in both. DBDelve’s driver pushes rows into a bounded feed and waits when the grid falls behind. SQLly’s driver waits on a bounded channel. Either way the first rows paint while the rest are still arriving, and a fast server can’t flood the app. The apps differ in what they do with the rows next. DBDelve keeps them in memory up to its row limit and reads and discards the rest. SQLly spills them to disk (more on that under Results).
- The same engine code can run in a browser. SQLly’s query layer is plain futures with no runtime of its own baked in. That is why the same code runs in the desktop app, in
sqlly-cli, in the language server, and in the WebAssembly build behind the browser preview. A browser has no threads to block, so a blocking design couldn’t be carried over that way. - Simplicity favors DBDelve. Blocking code is easier to read, step through in a debugger and get right, and DBDelve’s rule makes the GPUI panic impossible by construction. SQLly runs two executors and has to hand work between them correctly. When we get that wrong, the bug is subtler than a blocked thread. We think the trade is worth it for a tool that keeps a lot of connections busy at once. For a client focused on browsing and editing, DBDelve’s choice is a reasonable one.
Downloads and install
| Package | SQLly | DBDelve 0.7.0 |
|---|---|---|
| macOS (Apple Silicon) | 65.6 MB dmg, signed and notarized | 54.2 MB dmg, ad-hoc signed |
| Windows x64 | 60.9 MB zip | 45.3 MB zip |
| Linux x64 | 76.2 MB tarball | 61.7 MB tarball, or a 57.5 MB AppImage |
DBDelve is 11 to 16 MB smaller on every platform. It also has a Homebrew cask and an AUR package.
The cost of not being notarized shows up on the Mac: its install docs tell you to run
xattr -dr com.apple.quarantine after every install and update, and macOS asks again for
saved Keychain passwords after each update. The author says he’ll pay for a Developer ID if
enough people use it. Neither app has an Intel Mac build.
Databases
| Engine | SQLly | DBDelve |
|---|---|---|
| PostgreSQL, MySQL, MariaDB, SQLite, SQL Server, DuckDB | Yes | Yes |
| ClickHouse | Yes | Yes, over HTTP only |
| Redis, Valkey, KeyDB, Dragonfly | Yes, plus Cluster, Sentinel, ElastiCache and MemoryDB | Yes |
| libSQL / Turso | Self-hosted sqld or Turso Cloud | Local files |
| Oracle | Native driver | Through ODBC, editing off |
| MongoDB | No | Yes |
| Snowflake | Planned | Yes |
| Anything with an ODBC driver (Db2, Informix, Teradata…) | No | Yes, bring the vendor’s driver |
| Azure SQL (Entra sign-in in progress), documented wire-compatibles (CockroachDB, Neon, Supabase, Aurora…) | Yes | Not documented |
DBDelve has 11 built-in engines and the ODBC bridge, which ships as an out-of-process plugin as of 0.7.0; its release notes say the Windows side of it is untested. If you need MongoDB, Snowflake or an ODBC-only database, DBDelve covers them and SQLly doesn’t. SQLly’s count of 30 comes from native drivers plus the hosted services it documents and tests; see the engine list.
Writing SQL
DBDelve’s completion offers tables, and a table’s columns after its name and a dot, from the catalog it has already loaded. It has a fuzzy command palette for commands, tables, saved queries, history and connections, every shortcut can be rebound, and a query formatter that leaves your comments alone.
SQLly puts most of its effort here. IntelliSense
tracks aliases and scope, writes a JOIN ON clause from real foreign keys, pulls a
column’s actual values into a WHERE clause, and flags a GROUP BY
mistake while you type. The editor adds query parameters, templates, multi-cursor editing,
split views, folding, and optional AI ghost text.
Results and editing
DBDelve does a few things we like a lot. Edit a cell and it writes the UPDATE into the
editor for you to read before it runs. Hidden and pinned columns survive a restart. A cold launch
reopens your last tab with its last result already in the grid, from a snapshot, without rerunning
the query. Drop a CSV, Excel, Parquet or JSON file on the window and it opens as a DuckDB query.
Export covers CSV, TSV, JSON and INSERT statements.
On large results, DBDelve applies a row limit by default. Its published benchmark (DBDelve 0.3.6, M1 Pro) turns the limit off and pulls a million-row, 4 GB table into memory: 4.9 GB for DBDelve against 17 GB for DBeaver. SQLly takes the other route and spills results to disk past 50,000 rows or 64 MiB, so memory stays flat at 50 million rows. SQLly’s grid also has pivots, charts, conditional formatting, computed columns, result diffs and Excel export, none of which DBDelve has today.
Safety
DBDelve takes safety seriously for a project this young. Each connection runs read-only,
read-write or with full access; the check parses statements with sqlparser so a
GRANT isn’t mistaken for a read; each connection can color the title bar; and it
asks before anything destructive.
SQLly’s guardrails go further: SELECT-only connections that
also block file-reading and shell-escape tricks, a hard stop on UPDATE or
DELETE without WHERE, automatic rollback, tenant checks, and an optional AI
review before a data change, all inherited from client to project to environment.
What SQLly has that DBDelve doesn’t try to
DBDelve has a good plan viewer: a highlighted pane that calls out bad row estimates. Beyond that it keeps to browsing, querying and editing. SQLly adds the DBA side: Activity Monitor, Query Insights, schema and data compare, SQL Agent, an index analyzer, test data, an ER diagram, cross-engine data transfer, and backup and restore as reviewable scripts. It also has an AI assistant that can run on local models, and an MCP server that lets agents read but never write. We found no AI or MCP features in DBDelve.
Whether that’s a plus depends on you. If you never open those tools, DBDelve’s smaller surface is easier to learn.
What they cost
DBDelve is GPL-3.0, free, with no account and no telemetry beyond an update check you can turn off, and the README promises that no feature will ever go behind a paywall. 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. SQLly is not open source. If open source or free for the whole company is a requirement, DBDelve meets it and SQLly does not.
Which one to pick
Pick DBDelve if:
- You need open source, or free at any company size.
- You use MongoDB, Snowflake, or a database that only has an ODBC driver.
- You want a small, fast, keyboard-first client for browsing and editing.
- You care about themes, or want to bring yours over from Zed or VS Code.
- You’d like to contribute to a Rust GPUI codebase.
Pick SQLly if:
- You work in SQL Server, Azure SQL, Oracle or Turso Cloud.
- You write a lot of SQL and want completions that know your data.
- You want guardrails on your own queries, not only a read-only switch.
- You read plans, compare schemas, watch server activity, or move data between engines.
- You want AI help that can stay on your machine, or an MCP server that never writes.
The fair test is your own database: both are Rust, both start fast, and neither needs an account. The side-by-side table is at SQLly vs DBDelve, and SQLly’s download is free.