DBine and SQLly: 130 engines for free, or a deeper SQL workbench

DBine is a free Apache-2.0 Tauri client listing 130+ engines, a profiler, migration, sync and a phone app. What the engine count means, where it beats SQLly, and where SQLly goes deeper.

By

DBine showed up on DevHunt in October with a pitch that is hard to ignore: one free desktop app for 130+ databases, with a profiler, schema and data compare, cross-engine migration, notebooks, encrypted sync, an MCP server and an Android companion. All of it Apache 2.0, no account, no paid tier. That is a lot of the territory SQLly covers, and some it doesn’t, so this post puts the two side by side.

We build SQLly, so take the bias into account. We read DBine’s website, README, docs and release assets, and its issue tracker; we did not benchmark it or test every feature it lists. For several kinds of user it is the better choice, and we say which ones below.

Two Rust apps, two ways to draw a window

Both projects put their database work in Rust. They part ways at the UI.

  • DBine is a Tauri 2 app. A Rust core talks to a Vue 3 and Element Plus interface running in the operating system’s webview: WebKit on macOS, WebView2 on Windows, WebKitGTK on Linux.
  • SQLly has no webview. The UI is Rust too, drawn on the GPU through Metal, Direct3D or Vulkan, and rows go from a dedicated engine thread through a bounded queue to the grid painter in the same process.

The webview route is why DBine’s installers are small: its macOS dmg is 35.0 MB and the Windows setup is 27.2 MB, against SQLly’s 65.6 MB dmg and 60.9 MB zip. The other half of the difference is that DBine ships only the SQLite driver. Every other engine’s driver is a separate signed helper process that downloads the first time you connect. That keeps the installer light; it also means a fresh machine needs the internet before it can open an Oracle or SQL Server connection, unless you pre-stage the drivers. SQLly’s download includes every driver and DuckDB, so it works offline from the first launch.

The trade we chose shows up in large results. SQLly spills rows to a typed disk file past 50,000 rows or 64 MiB, so fifty million rows use about as much memory as fifty. We couldn’t find how DBine’s grid handles result sets that size; its exports do stream the full query.

130 engines, read closely

DBine’s headline number is real but needs unpacking. Its repository has about 40 native Rust driver crates. The rest of the 131 are wire-compatible variants (the PostgreSQL family alone covers Aurora, AlloyDB, Cloud SQL, YugabyteDB, Greenplum and more) and 39 ODBC presets that need the vendor’s ODBC driver installed. There is no JDBC and no bundled JVM, which we think is the right call.

DBine’s own engine notes are candid about depth. They list Redshift, Snowflake, Databricks, Athena and SAP HANA, among others, as covered by unit tests only, and say most ODBC presets haven’t been run against a real server. Credit to the author for writing that down. It means the list is wider than what has been proven so far.

Even so, the breadth is a genuine advantage. DBine connects to MongoDB, Cassandra, Neo4j, Elasticsearch, DynamoDB, InfluxDB and the big warehouses. SQLly connects to none of those. SQLly’s 30 engines are SQL Server and Azure SQL, PostgreSQL, MySQL, MariaDB, SQLite, DuckDB, ClickHouse, Oracle, libSQL/Turso and Redis, plus documented wire-compatible services, each tested against real servers. Snowflake, BigQuery and Trino are planned, not shipped.

The tool list

This is where DBine is most ambitious. Its feature page lists a live profiler on any engine, a server monitor with blocking chains, graphical estimated and actual plans, schema compare, data compare, cross-engine migration with resume, data subsets with masking, a table designer, ER diagrams, a query builder, a test data generator, backups, a health check, scheduled tasks that run with the app closed, a DBA script library, Git projects and Jupyter-compatible notebooks.

SQLly has most of that list too: Activity Monitor with blocking chains and waits, Query Insights from Query Store, pg_stat_statements and Performance Schema, schema and data compare with rollback scripts, cross-engine data transfer, designers, the Relationship Graph, backup and restore, test data, scheduled tasks and notebooks. Two gaps are real. SQLly’s live query capture is limited to SQL Server Extended Events and the Redis profiler, where DBine captures on any engine. And SQLly’s plan viewer is still marked in progress.

Where the two differ in approach: SQLly’s tools are script-first. Anything that changes a definition opens as SQL in a tab for you to read before it runs.

Writing SQL

DBine’s editor has schema-aware completion and code-quality lints. Its tracker has open requests for column completion scoped to the tables in the query and for cross-database completion, which tells you roughly where it is.

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, understands plain-language dates, and flags a GROUP BY mistake as you type. A half-megabyte script edits at about 5 ms a keystroke. On the result side, SQLly adds pivots, conditional formatting, computed columns, result diffs and Excel export with live formulas, and a one-line comment saves the layout with the query. DBine has ECharts charts and a JSON tree view.

Safety, AI and agents

Both tools treat AI carefully, which is good to see. DBine’s assistant can run a bundled llama.cpp with Qwen2.5-Coder (3B, 7B or 32B, downloaded on first use), Ollama, LM Studio, or your own Claude Code or Codex CLI. It never runs the SQL it writes and never sends rows. SQLly supports local models, your own endpoint, or cloud providers you opt into, with no default provider.

The MCP servers differ in one decision. DBine gives each connection a level: disabled, schema (the default), read or write. Connections tagged prod are capped at read, and every write needs your approval in the app within two minutes. SQLly’s sqlly-cli mcp has no write level at all. An agent’s SELECT runs in a transaction the database itself keeps read-only and then rolls back, and a change comes back as a proposal you run yourself. Production connections are refused. If you want an agent to fix data for you, DBine’s model does that. If you want agents to look but never touch, SQLly’s leaves you nothing to approve by mistake.

For people typing in the editor, DBine has read-only connections and prod tags. SQLly’s guardrails go further: SELECT-only connections that refuse 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, inherited down a client, project and environment tree.

Things DBine has that SQLly doesn’t

  • Encrypted sync. Connections, queries and settings sync end-to-end encrypted through your own Google Drive, OneDrive or a folder. SQLly keeps everything in plain files you can sync with any tool, and built-in iCloud sync is planned.
  • A phone companion. The Android app pairs with the desktop over an encrypted channel and lets you watch the server, see blocking chains, and kill a session or cancel a query with biometric confirmation. It never runs SQL. It’s a sideloaded APK, with no iOS version.
  • Thirteen interface languages. SQLly has English and Spanish.
  • An Intel Mac build. SQLly needs Apple Silicon.
  • Imported passwords. DBine imports passwords along with connections from DBeaver, DbGate, DataGrip, Azure Data Studio and SSMS. SQLly imports from more tools but leaves passwords behind on purpose and asks for each one once.

One difference runs the other way: DBine sends anonymous usage events by default (app start, engine opened, module used, with no queries or names) and documents how to switch them off. SQLly has no telemetry, and our privacy page commits to keeping any future usage counts opt-in.

Age

DBine’s public repository was created on 28 September 2026. It went from 0.1.0 to 1.4.2 in 25 releases over five weeks, and almost all the commits come from one developer. The maintainer answers issues fast, often the same day. We couldn’t find any independent reviews yet, so there’s no record of how it holds up over months of daily use. That isn’t a criticism of the code, which we didn’t audit. It is a reason to try your own workload before you move a team onto it, and the same advice applies to any young tool, including ours.

What they cost

DBine is free with every feature, at any company size, under Apache 2.0, and asks for donations. 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 free for the whole company or open source is a requirement, DBine meets it and SQLly does not.

Which one to pick

Pick DBine if:

  • You work with MongoDB, Cassandra, Neo4j, Elasticsearch or another non-SQL store.
  • You need Snowflake, BigQuery or Databricks in a desktop client today.
  • You need open source, or free at any company size.
  • You want a live profiler on every engine, built-in encrypted sync, or a phone monitor.
  • You’re on an Intel Mac, or want the UI in one of its 13 languages.

Pick SQLly if:

  • You spend your day writing SQL and want completions that know your data.
  • You pull large result sets and want the app to stay flat on memory.
  • You want guardrails on your own queries, and agents that can read but never write.
  • You want every driver in the box, tested, working offline from the first launch.
  • You work in SQL Server or Azure SQL and use Query Store, Extended Events or SQL Agent.

The fair test is your own database. Both apps install in a minute and neither needs an account. The side-by-side table is at SQLly vs DBine, and SQLly’s download is free.