// sqlly vs rustable

SQLly vs Rustable

Rustable is a free, MIT-licensed database client written in Rust and drawn on the GPU with egui. It covers PostgreSQL, MySQL, MariaDB, SQLite and Redis, reviews every edit as SQL before it saves, and runs a WebAssembly demo on its website. SQLly is also a GPU-drawn Rust app, but a paid, closed-source workbench built on a different UI framework that goes wider on engines and deeper on SQL, guardrails and admin tools. Here’s the honest breakdown.

Last reviewed: November 2026

The short version

SQLly

A deep SQL workbench

One Rust codebase on GPUI, drawn on the GPU on macOS, Windows, and Linux. Thirty engines, IntelliSense that reads your data, layered safety guardrails, schema compare, a full Redis toolset, and script-first admin tools.

Rustable

A young, focused, open-source client

A Rust app on egui with five engines: PostgreSQL, MySQL, MariaDB, SQLite and Redis. Staged edits reviewed as SQL, a read-only Safe mode, TablePlus and TablePro import, and downloads around 30 MB. First released on 1 November 2026, at v0.4.22 nine days later.

Feature by feature

SQLly’s column uses the same honest status badges as the features page and the docs. For Rustable we list what its website, README, docs folder, release assets and source state.

Feature comparison of SQLly and Rustable
Capability SQLly Rustable
Runs on macOS, Windows & Linux YesmacOS is signed and notarized; Windows and Linux are a supported beta, on amd64 and arm64. YesSigned and notarized macOS DMG with automatic updates; portable Windows zip and Linux tarball (Ubuntu 24.04 or newer) with manual updates. x64 only on Windows and Linux.
Intel Macs NoApple Silicon only. NoApple Silicon only; Intel macOS is on its roadmap.
How the app is built GPUIOne Rust codebase on GPUI and gpui-component, rendered through Metal, Direct3D or Vulkan. How it works eguiRust on egui, an immediate-mode UI library, through eframe’s glow (OpenGL) backend. No webview.
Download size LargermacOS dmg 65.6 MB, Windows x64 zip 60.9 MB, Linux x64 tarball 76.2 MB. Smallerv0.4.22: macOS dmg 31.1 MB, Windows zip 28.3 MB, Linux tarball 28.8 MB.
Try it in the browser YesThe real workbench in WebAssembly and WebGPU, on SQLite (Northwind) and Postgres via PGlite (Chinook). Many features are missing in the browser build. Live preview YesThe same app in WebAssembly on its homepage, with a real SQLite sample and an in-memory Redis that supports a subset of commands.
Free to use Free tierTwo saved servers, one cloud account, and a reminder to pay about every five hours. Not for organizations over 100 employees. Pricing YesNo pricing or paid tier on its site or in its repository.
Open source NoLifetime licenses carry a source-escrow promise if SQLly is ever discontinued. YesMIT on GitHub.
PostgreSQL, MySQL, MariaDB, SQLite YesPlus documented compatibles such as CockroachDB, Neon, Supabase and Aurora. Full list YesMySQL 8.4 and MariaDB 11.4 are the tested versions. Its own docs call the MySQL/MariaDB adapters experimental, with visual schema changes still gated.
SQL Server & Azure SQL YesEntra sign-in for Azure SQL is in progress. Databases NoMore engines are planned but not named.
DuckDB, ClickHouse, Oracle, libSQL/Turso YesNative drivers; DuckDB is bundled. Per-engine coverage No
Redis YesTyped key editing, Cluster and Sentinel, ACLs, pub/sub, profiler, memory analyzer, slow log; Valkey, KeyDB, DragonflyDB, ElastiCache and MemoryDB. Redis YesStandalone, Cluster and Sentinel; inspectors for six core types, inline JSON path edits, Search indexes, a database analyzer and Pub/Sub. Transactions and blocking commands are not available.
SSH tunnels & TLS YesSSH hops, SOCKS and HTTP proxies, and TLS modes. TLS PartialVerified TLS everywhere; built-in SSH tunnels on macOS and Linux only. On Windows you need a direct connection or an external tunnel.
Saved passwords OS keychainConnection files are plain text; passwords live in the keychain. OS keychainStored in the system credential store, never in the connection profile.
Import connections from other tools YesDataGrip, DBeaver, pgAdmin, Azure Data Studio, DbGate, TablePlus, Navicat and more. Compatibility YesTablePlus and TablePro exports.
Autocomplete YesAlias- and scope-aware, JOIN ON from foreign keys, real column values in WHERE, plain-language dates, GROUP BY mistakes flagged. IntelliSense PartialSchema-aware completion; on PostgreSQL it runs the Postgres Language Server against the loaded schema, with CTE and alias handling. Its roadmap lists MySQL/MariaDB completion as still to improve. Formatter, history and saved queries too.
Edit table data YesA row editor generated from the table’s own metadata. Row editor YesStaged edits with undo, reviewed as generated SQL before they apply. MySQL/MariaDB writes need InnoDB and a primary key.
Large results YesStreams and spills to disk past 50,000 rows or 64 MiB; flat memory at 50 million rows. Streaming CappedIts source caps an editor result at 5,000 rows or 16 MiB and marks it truncated; table browsing pages 500 rows at a time.
Charts, pivot & result diff YesPivot, charts, conditional formatting, computed columns, and diffs. Pivot ChartsBar, line and pie charts from the loaded rows. No pivot or diff that we could find.
Import & export data YesCSV, JSON, SQL, and Excel with live formulas and a pivot sheet. Excel export PartialCSV import into a table; CSV and JSON export, including all matching rows of a table; copy rows as CSV, JSON, HTML, Markdown or INSERTs. No Excel. Editor exports cover the loaded rows only.
Query performance stats YesQuery Insights over Query Store, pg_stat_statements, Performance Schema, the ClickHouse query log and the Redis slow log. Query Insights -We found none in its docs or source.
Execution plan viewer In progressPlain-language findings, tree, and diagram across nine engines. Query plans PlannedEXPLAIN runs as an ordinary query; execution-plan workflows are on its roadmap.
Session & activity monitoring YesBlocking chains, expensive queries, waits, and a Server Dashboard. Activity Monitor PlannedSessions and server metrics are listed as future work.
Create & alter tables YesDesigners and Edit Structure. Designers PartialAdd, rename and alter columns and create or drop indexes on SQLite and PostgreSQL, reviewed before saving. Not yet on MySQL/MariaDB.
ER diagrams YesExport to SVG, Mermaid, or DBML. Relationship Graph PlannedOn its roadmap. Foreign keys are clickable in the grid today.
Backup & restore YesBackup and restore as reviewable scripts. Backup / Restore PlannedOn its roadmap.
Schema & data compare, data transfer YesRisk-graded schema diffs with sync and rollback scripts, data compare, and cross-engine transfer. Schema Compare -Not in its docs or roadmap.
Guardrails in the editor YesSELECT-only connections that block file-read and shell-escape tricks, a hard stop on UPDATE/DELETE without WHERE, auto-rollback, tenant checks, inherited from client to project to environment. Safety YesSafe mode makes the session reject writes on all four SQL engines and is on by default for Production connections; drops, truncates, and UPDATE/DELETE without WHERE ask for confirmation; environment colors.
AI assistant & MCP server YesLocal models, your own endpoint, or opt-in cloud; a read-only MCP server. How reads are kept read-only NoNone in its docs or source.

A dash means we couldn’t confirm it from Rustable’s own materials - it ships several releases a week, so check its repository for the current state.

Where SQLly is different

Both apps skip the webview and draw their own pixels. The differences are in the framework underneath and in how much sits on top of it.

GPUI rather than egui

egui rebuilds the interface from code on every repaint, which keeps an app simple to write. SQLly is built on GPUI, the framework from the Zed editor: views are long-lived objects that re-render when their state changes, drawn through Metal, Direct3D or Vulkan. Large results stream to disk, and a 0.5 MB script still edits at about 5 ms per keystroke.

Spill-to-disk results →

No result cap

Rustable stops an editor result at 5,000 rows or 16 MiB. SQLly’s grid spills to disk past 50,000 rows or 64 MiB and keeps going, so fifty million rows use about as much memory as fifty.

Streaming →

Autocomplete that knows your data

Beyond table and column names: SQLly pulls a column’s real distinct values into a WHERE clause, writes a join’s ON clause from actual foreign keys, reads plain-language dates, and flags a GROUP BY mistake as you type.

IntelliSense →

Guardrails set once, inherited

Rustable’s Safe mode is a good idea done carefully. SQLly adds a hard stop on UPDATE/DELETE with no WHERE, auto-wrapped transactions, and tenant checks, all inherited down your client, project, and environment tree.

Safety & guardrails →

Compare, transfer, and admin tools

Schema compare across engines with sync and rollback scripts, data compare, cross-engine data transfer, Query Insights, an Activity Monitor, backup and restore, an index analyzer, and a test data generator.

Tools →

More engines

SQL Server, DuckDB, ClickHouse, Oracle and libSQL/Turso sit next to the five engines both apps share, plus documented wire-compatibles - 30 in all.

Databases →

When Rustable is the better choice

Rustable is probably the better fit if:

  • Open source, or free at any company size, is a requirement. Rustable is MIT with no paid tier we could find. SQLly’s source is closed, and its free tier isn’t available inside organizations with more than 100 employees.
  • You want a small download. Rustable’s builds are about 28-31 MB; SQLly’s are 61-76 MB.
  • Your databases are PostgreSQL, MySQL, MariaDB, SQLite and Redis. That’s exactly Rustable’s list, Redis Cluster and Sentinel included, and you won’t pay for engines you don’t use.
  • You’re moving from TablePlus or TablePro. Rustable imports both, and its layout and staged-edit review follow TablePlus closely on purpose.
  • You want to read or patch the code. It’s a single Rust crate on egui, and its docs folder records what was verified for each release.

One honest caveat in the other direction: Rustable’s first release was on 1 November 2026, it calls itself early software with rough edges, and almost all of its commits come from one developer. Check its repository for recent activity before you rely on it.

Questions

Is Rustable free?

Yes. Rustable is open source under the MIT license, and we found no paid tier on its site or in its repository. SQLly is free for hobbyists (two saved servers), with a one-time $100 SQLly 1.x license and a $200 Lifetime license for everyone else.

Aren’t SQLly and Rustable built the same way?

Partly. Both are Rust apps that draw their own interface on the GPU with no webview, and both compile to WebAssembly for a browser demo. Rustable uses egui, an immediate-mode library that rebuilds the interface from code on every repaint, through eframe’s OpenGL backend (WebGL in the browser). SQLly uses GPUI, the framework from the Zed editor, which keeps views as long-lived objects and re-renders one when its state changes, through Metal, Direct3D or Vulkan (WebGPU in the browser).

Which databases do SQLly and Rustable support?

Both connect to PostgreSQL, MySQL, MariaDB, SQLite and Redis, including Redis Cluster and Sentinel. SQLly adds SQL Server, DuckDB, ClickHouse, Oracle and libSQL/Turso, plus documented wire-compatible services such as Neon, Supabase and Aurora - 30 engines in all. Rustable says more engines are planned.

// try it yourself

Point both at the same database

The quickest way to choose is to run your own queries in each. SQLly is free on macOS, Windows, and Linux, with no account required.