Rustable vs SQLly: two GPU-drawn Rust clients
I build SQLly, so I'm biased. Rustable is a free MIT client on egui; SQLly is on GPUI. Engines, safety, result limits, Redis, cost, and who should pick which.
Rustable showed up on Hacker News as an open-source database client written in Rust, with a GPU-drawn UI and a WebAssembly demo on its homepage. I had to read that twice, because it’s also a fair description of SQLly. So this one is close to home.
I build SQLly, so I’m biased, and you should read this with that in mind. Here’s what I actually did: I read Rustable’s website, README, roadmap and the release notes and design docs in its repository, grepped the source for the things I wanted to compare, checked the v0.4.22 release sizes. I didn’t install it, I didn’t open the browser demo, and I didn’t benchmark anything.
How they’re built
Neither app ships a browser engine. Both are Rust top to bottom and draw their own pixels on the GPU. The difference is the UI framework, and it’s a real one.
- Rustable uses egui. egui is immediate mode: every time the window repaints, the app runs its UI code again and egui rebuilds the interface from scratch. There’s no widget tree to keep in sync, which makes it quick to write. Rustable runs it through eframe’s glow backend, so it draws with OpenGL on the desktop and WebGL in the browser. The whole app is a single Rust crate.
- SQLly uses GPUI, the framework from the Zed editor, with gpui-component widgets. Views are long-lived objects that hold their state and re-render when that state changes. It draws through Metal, Direct3D or Vulkan, and the browser preview needs WebGPU.
Neither approach is the “real native” one. Someone on the HN thread argued egui isn’t native, and by that standard SQLly isn’t either. What you notice in practice is size: Rustable’s macOS DMG is 31.1 MB, the Windows zip 28.3 MB and the Linux tarball 28.8 MB. SQLly’s are 65.6 MB, 60.9 MB and 76.2 MB. Both are Apple Silicon only on the Mac. Rustable is x64 only on Windows and Linux, where SQLly also ships arm64, and its Linux build wants Ubuntu 24.04 or newer.
The browser demos
We both did the slightly mad thing of compiling the desktop app to WebAssembly. Rustable’s demo runs
a real SQLite sample plus an in-memory Redis that understands a subset of commands (run INFO
to see which). SQLly’s live preview runs SQLite with Northwind and Postgres
through PGlite with Chinook. Mine needs WebGPU, and I’ll be upfront that plenty of features are
missing or broken in the browser build. Neither demo touches your own servers.
Databases
| Engine | SQLly | Rustable |
|---|---|---|
| PostgreSQL, SQLite | Yes | Yes |
| MySQL, MariaDB | Yes | Yes (tested on MySQL 8.4 and MariaDB 11.4; its docs call the adapters experimental) |
| Redis (standalone, Cluster, Sentinel) | Yes | Yes |
| SQL Server | Yes | No |
| DuckDB, ClickHouse, Oracle, libSQL/Turso | Yes | No |
If your week is Postgres, MySQL, SQLite and Redis, you’re covered either way. If SQL Server or DuckDB is in there, Rustable doesn’t do it yet; it says more engines are planned. SQLly gets to 30 counting the wire-compatible services it documents.
Editing and safety
This is where Rustable has clearly put in the work. Table edits are staged, you can undo them, and you
see the generated SQL before anything is applied. It has a Safe mode that makes the database session
itself refuse writes, on all four SQL engines, and Production connections start with it switched on. On
MySQL it even refuses executable comments in Safe mode, a detail I was glad to see. Drops,
truncates, and an UPDATE or DELETE without WHERE ask before they run.
SQLly’s guardrails go further in a few places: a hard stop
rather than a confirm on a WHERE-less UPDATE or DELETE, auto-rollback,
tenant checks, and SELECT-only connections that also block file-reading and shell-escape tricks. You set
them once on a client, project or environment and every connection under it inherits them. Both apps
keep passwords in the OS keychain.
Results
Rustable caps an editor result at 5,000 rows or 16 MiB and marks it truncated, and table browsing pages 500 rows at a time. For day-to-day browsing that’s fine. SQLly’s grid spills to disk past 50,000 rows or 64 MiB, so fifty million rows use about as much memory as fifty.
Rustable has bar, line and pie charts over the loaded rows, CSV import, CSV and JSON export, and copy
as CSV, JSON, HTML, Markdown or INSERTs. SQLly adds pivots,
conditional formatting, computed columns, result diffs and Excel
export with live formulas.
Writing SQL
Rustable’s completion is schema-aware. On Postgres it runs the open-source Postgres Language Server
against the schema it already loaded, without giving it your credentials, which is a neat bit of
engineering. Its own roadmap says MySQL and MariaDB completion still need work. SQLly’s
IntelliSense tracks aliases and scope, writes a
JOIN ON from real foreign keys, pulls a column’s actual values into a WHERE,
reads plain-language dates and flags GROUP BY mistakes as you type.
Redis
Rustable takes Redis seriously for a project this young: Cluster and Sentinel, SSH tunnels, inspectors for the six core types, inline JSON path edits, Search index management, a database analyzer and Pub/Sub. Transactions and blocking commands aren’t there yet. SQLly’s Redis side has typed key editing, ACLs, pub/sub, a profiler, a memory analyzer and the slow log, and also talks to Valkey, KeyDB, DragonflyDB, ElastiCache and MemoryDB.
What’s not there yet
Rustable’s roadmap lists execution plans, sessions and server metrics, backup and restore, and ER diagrams as future work. Built-in SSH tunnels work on macOS and Linux only; on Windows you bring your own. I found no AI features and no MCP server, which some of you will count in its favor.
SQLly has schema compare, data compare, cross-engine data transfer, Query Insights, an Activity Monitor, backup and restore scripts, and a read-only MCP server. Its own plan viewer is still marked in progress, so I don’t get to be smug about plans.
What they cost
Rustable is MIT-licensed and I couldn’t find a price anywhere. SQLly is free for hobbyists (two saved servers), then a one-time $100 for SQLly 1.x or $200 for Lifetime; see pricing. SQLly is closed source, with a source-escrow promise on Lifetime licenses if I ever stop.
Rustable is also very new. The first release was on 1 November 2026 and it was at v0.4.22 nine days later, with 24 releases in between and nearly every commit from one developer. It calls itself early software with rough edges. That pace is impressive, and it also means the details above will go stale fast.
Which one to pick
Pick Rustable if:
- You need open source, or free at any company size.
- You work in Postgres, MySQL, MariaDB, SQLite and Redis and nothing else.
- You want a 30 MB download.
- You’re coming from TablePlus or TablePro; it imports both and is modeled on TablePlus.
- You’d like to read or patch the code of the client you use every day.
Pick SQLly if:
- You need SQL Server, DuckDB, ClickHouse, Oracle or libSQL as well.
- Your queries return more than a few thousand rows.
- You want completions that know your data, not just your schema.
- You want guardrails set once per environment and inherited.
- You compare schemas, move data between engines, or watch server activity.
The fair test is your own database. The full side-by-side is at SQLly vs Rustable, and SQLly’s download is free.