TablePro and SQLly: an open-source Mac client and a cross-platform SQL workbench
TablePro is an AGPL Swift app for Mac, iPhone and iPad with 37 engines, AI and MCP; SQLly is one Rust workbench for macOS, Windows and Linux. Platforms, engines, plans, safety, agents and price, compared.
TablePro is the fastest-growing database client we’ve watched this year. Its repository dates from December 2025, it passed 6,300 GitHub stars by November, and its README states the goal in one line: “TablePro is what I wanted TablePlus to be: native, fast, open source.” It overlaps with SQLly in a lot of places, so this post sets the two side by side.
We build SQLly, so take the bias into account. We read TablePro’s website, its docs repository and README, and the assets on its v0.85.0 release (November 4, 2026). We did not install it or benchmark it. In several areas it is ahead of SQLly, and we say which.
Where each one runs
This is the first fork in the road, so it goes first.
- TablePro is an Apple-platforms app. The Mac app is Swift and needs macOS 13 or later; it runs on Apple Silicon and Intel. There is a free iPhone and iPad app on iOS 18 or later, with connections synced from the Mac. A Linux app is being built in the repository on a shared Rust core, with nine engines so far, but no Linux release exists yet. There is no Windows version.
- SQLly is one Rust app for macOS, Windows and Linux. The UI is drawn on the GPU through Metal, Direct3D or Vulkan, so a feature ships on all three in the same release. Windows and Linux are a supported beta on amd64 and arm64. On the Mac SQLly needs Apple Silicon, and there is no phone app.
If anyone on your team works on Windows, TablePro is out for now. If you’re on an Intel Mac or want your databases on an iPad, SQLly is out.
On size: TablePro’s v0.85.0 DMG is 82.3 MB, and plugin drivers download on first use (the DuckDB plugin is 37.7 MB, Oracle 11.5 MB). SQLly’s macOS DMG is 65.6 MB with DuckDB compiled in.
Databases
TablePro covers more ground here, and by a wide margin outside SQL. Its databases page lists 37 engines on the Mac: 12 drivers built in and 25 plugins.
| Engine | SQLly | TablePro |
|---|---|---|
| PostgreSQL, MySQL, MariaDB, SQLite, SQL Server | Yes | Yes (SQL Server as a plugin) |
| Azure SQL with Entra sign-in | Azure SQL yes; Entra sign-in in progress | Entra ID sign-in on its SQL Server plugin |
| ClickHouse, DuckDB, Oracle, libSQL/Turso | Yes, native drivers | Yes (ClickHouse built in, the rest plugins) |
| Redis | Yes, plus Valkey, KeyDB, DragonflyDB, ElastiCache and MemoryDB | Yes, standalone, Sentinel and Cluster |
| Snowflake, BigQuery, Trino | Planned | Yes |
| Teradata, Spanner, SAP HANA, Databend, Cloudflare D1 | No | Yes |
| MongoDB, SurrealDB, Cassandra, ScyllaDB, DynamoDB | No | Yes |
| Elasticsearch, Typesense, Weaviate, Kafka, etcd | No | Yes |
TablePro also lets you write your own driver as a Swift plugin. SQLly has no plugin system and supports 30 engines, all of them SQL databases or Redis-compatible stores. What SQLly does with that narrower list is go further per engine; the engine list spells out which tools work where.
Writing SQL
TablePro’s editor has schema-aware autocomplete that understands aliases, subqueries and CTEs, per-dialect operators, enum values, multi-cursor editing, folding, query parameters, and both Vim and Emacs modes. That is a well-built editor, and SQLly has no Vim mode at all.
SQLly’s IntelliSense goes further into the
data itself: it writes a JOIN ON clause from real foreign keys, pulls a column’s
actual distinct values into a WHERE clause, turns plain-language dates into literals,
and flags a GROUP BY mistake while you type. On a 0.5 MB script the editor takes
about 5 ms per keystroke.
Results
TablePro’s grid pages through results and stops reading at a configurable row cap. Cell edits queue up, show the SQL they will run, and save in one transaction; Data Rewind, a Pro feature, restores a save. It exports CSV, JSON, SQL, MQL, XLSX or a data dictionary, and a Parquet export plugin ships with each release. Charts and a map view are in the grid; charts need Pro.
SQLly’s grid streams rows and spills to disk past 50,000 rows or 64 MiB, so a 50-million-row result stays flat on memory with no cap. On top of it are pivots, charts, conditional formatting, computed columns, result diffs, and Excel export with live formulas and a pivot sheet. We couldn’t find a pivot view in TablePro’s docs.
Plans and admin tools
Credit where it’s due: TablePro’s plan viewer is ahead of ours. It draws diagrams and trees from about a dozen engines, including SQL Server showplan XML and Oracle actual plans, and can compare two runs. SQLly’s query plans cover nine engines with plain-language findings, and are still marked in progress.
TablePro also has tools SQLly doesn’t: a Users & Roles editor that shows effective privileges, a debugger for PL/pgSQL and Oracle PL/SQL routines, and data masking that hides columns in the grid, exports, the AI assistant and MCP. Its Table Health report finds bloat, unused indexes and missing primary keys, and its Server Dashboard shows sessions, metrics and slow queries on nine engine families.
SQLly’s Tools menu is broader on the DBA side: Activity Monitor with blocking chains and waits, Query Insights read from the server’s own Query Store, pg_stat_statements or Performance Schema, Extended Events and SQL Agent on SQL Server, an index analyzer, a test data generator, disk usage, cross-engine data transfer, scheduled tasks and notebooks. Schema and data compare come with sync and rollback scripts.
One pricing point matters here. TablePro’s Compare & Sync and its Query Insights are Pro features, and its Query Insights groups the queries you ran in TablePro rather than reading the server’s statistics. In SQLly both are part of any license.
Safety
Both projects take this seriously, in different shapes. TablePro gives each connection one of
six Safe Mode levels, from no checks, through a confirmation dialog, to Touch ID on every write,
to read-only. Even at the lowest level it warns about DROP, TRUNCATE
and a DELETE with no WHERE. It keeps a local, hash-chained log of every
authorization decision, and an MDM can enforce a minimum level across a fleet of Macs.
SQLly’s guardrails are set on a client, project or
environment and inherited by every connection under it: SELECT-only connections that block
file-reading and shell-escape tricks, a hard stop on UPDATE or DELETE
without WHERE, automatic rollback, tenant checks, an optional AI review before a data
change, and production painted red.
AI and MCP
TablePro’s AI is free and broad: chat, inline suggestions, and review/explain/optimize/fix,
across about 15 providers, including Ollama, llama.cpp, MLX, a custom OpenAI-compatible endpoint,
and Apple Intelligence on macOS 26. Chat starts in Ask mode, which only reads schema. Edit mode
lets the assistant run INSERT, UPDATE and DELETE, and Agent
mode runs tools in a loop, with destructive statements always waiting for a click.
Its MCP server is the most carefully built one we’ve read about in a client. It is off by default and listens only on your machine. Every request needs a scoped token, the first call to each connection asks you in a dialog on the Mac, writes go through the connection’s Safe Mode, and a 90-day activity log records every call with the statement stored as a hash.
SQLly’s AI uses local models, your own endpoint, or cloud
providers you opt into, with no default provider. Its MCP server, sqlly-cli mcp,
makes a narrower promise: an agent can list connections, read schemas and run one
SELECT at a time, inside a transaction the database keeps read-only and then rolls
back. A write comes back to the app as a proposal showing the exact SQL, and production
connections are refused.
If you want an agent that changes data for you, TablePro does it with sensible gates. If you want agents that can look but never touch, SQLly’s model has nothing to approve by mistake.
Moving between tools
TablePro imports connections from TablePlus, Sequel Ace, DBeaver, DataGrip, Beekeeper Studio and Navicat, passwords and saved queries included. SQLly imports from DataGrip, DBeaver, pgAdmin, Azure Data Studio, DbGate, TablePlus, Navicat and others, and exports to several of them, but leaves passwords behind on purpose (Redis Insight is the one exception). TablePro syncs over iCloud with a Pro license; SQLly stores everything as plain files any sync tool can carry, with iCloud Drive sync planned.
What they cost
TablePro is AGPL-3.0 and free at any company size: every engine, the editor, the AI assistant and the MCP server, with no time limit. On day 30 it asks once whether you’ll buy a license. Pro is $39 a year, $4.99 a month or $79 one-time, for up to three Macs, and adds Compare & Sync, Query Insights, charts, Data Rewind, iCloud Sync, encrypted connection export, environment variables and linked folders. Team is $10 per seat per month billed yearly, with a two-seat minimum. The iPhone and iPad app needs no license.
SQLly’s free tier is for hobbyists: two saved servers, one cloud account, and a reminder to pay about every five hours, and it isn’t for organizations over 100 employees. A SQLly 1.x license is $100 one-time and Lifetime is $200; see pricing. SQLly’s source is not open. If open source or free at work is a requirement, TablePro meets it and SQLly does not.
Which one to pick
Pick TablePro if:
- You use MongoDB, Snowflake, BigQuery, Cassandra, DynamoDB, Elasticsearch or Kafka.
- You’re on an Intel Mac, or want a database client on your iPhone or iPad.
- You need open source, or free at any company size.
- You read a lot of execution plans today, or debug PL/pgSQL and PL/SQL routines.
- You want an AI agent to change data for you, behind approvals and a log.
- You want Vim mode, Touch ID on writes, or a UI in Vietnamese, Chinese, Korean, Turkish or French.
Pick SQLly if:
- You or your team work on Windows or Linux.
- You write a lot of SQL and want completions that know your data.
- You pull large results and want no row cap, plus pivots and Excel export with formulas.
- You want schema compare, server-side query statistics and DBA tools without a subscription.
- You want agents to read but never write.
The fair test is your own database. Neither app needs an account to start. The side-by-side table is at SQLly vs TablePro, and SQLly’s download is free.