Peek vs SQLly: a canvas DB client and a workbench
I build SQLly, so I'm biased. Here's how Peek's infinite-canvas, FK-clicking, multiplayer Mac client compares on engines, safety, AI and cost.
I build SQLly, so this is biased. Keep that in mind. Peek showed up on Show HN in June as "a Figma like DB GUI", and it's the first database client I've seen that throws out the grid-and-tabs layout entirely. I wanted to know how it really compares.
What I checked: its website, docs and changelog, the README, a good chunk of its Rust and TypeScript source on GitHub, and the release assets. What I didn't do: install it or benchmark it. So I can't tell you how it feels to use. Everything below comes from its own materials and code.
How they're built
Peek is a Tauri 2 app. The backend is Rust: sqlx for the databases, russh for SSH tunnels, a tree-sitter SQL language server built into the app, and iroh for peer-to-peer multiplayer. The UI is React and Monaco running in the system webview. The 4.4.0 DMG is 25.3 MB. It runs on Apple Silicon Macs only; there are no Windows or Linux builds, though you can build it from source.
The repo has about 378 commits since July 2025 and 60 GitHub releases, and nearly all of that is one developer. It has 16 stars. The source is public and the maker calls it open source, but there's no license file in the repository, so you can read the code, but nothing tells you what you're allowed to do with it.
SQLly is also Rust, but it draws its own UI on the GPU with no webview. That costs download size: the macOS DMG is 65.6 MB, more than twice Peek's. It runs on macOS, Windows and Linux (the last two are a supported beta). On the Mac it's Apple Silicon only too, so neither of us helps you on an Intel Mac. And SQLly is closed source.
Databases
| Engine | SQLly | Peek 4.4.0 |
|---|---|---|
| PostgreSQL | Yes | Yes |
| MySQL, MariaDB | Yes | Yes (parity with Postgres since 4.4.0) |
| SQLite | Yes | Listed on its site, no driver in the source |
| DuckDB | Yes, bundled | Listed on its site, no driver in the source |
| SQL Server, Oracle, ClickHouse, libSQL/Turso | Yes | No |
| Redis | Yes | No |
The SQLite and DuckDB thing is worth spelling out. Peek's homepage says "Postgres, MySQL, SQLite, DuckDB & more coming". In the 4.4.0 source, the connection code picks a driver from the URL scheme: postgres:// or mysql:///mariadb://, and anything else gets "Unsupported database scheme". Its own driver docs say the same: PostgreSQL and MySQL/MariaDB are what's implemented today. It's a beta and it says more is coming, so I'm not dunking on it. Just don't download it for SQLite yet. It also holds one live connection at a time.
The canvas
This is the whole point of Peek, and it's a good idea. You drop query nodes on an infinite canvas, run them, and the results show up as nodes next to them. Click a foreign key in a result and the related rows open as a new node, linked to the one you came from. Click a primary key and you see every row that references it. After a few clicks you've got a little graph of how your data actually connects, still sitting there on the canvas. There are also chart nodes, variable nodes wired into queries, text labels, freehand drawing, pages, regions and a minimap.
Then there's multiplayer. You host a session, send a ticket, and a teammate joins with live cursors. They can even join from a browser. Their queries run on your connection and they only ever see the connection's name, not the credentials. There's no Peek server in the middle; it's peer to peer over iroh.
SQLly has none of this. It's tabs, editors and a results grid. Its Relationship Graph maps your foreign keys and IntelliSense writes JOIN ON clauses from them, but you can't click from a cell to the row it points at. And there's no live collaboration at all; the closest thing is that SQLly's connections and settings are plain files you can sync or put in git.
Editor and results
Peek's editor is better than I expected for a project this size. The built-in language server knows table aliases, offers JOIN ON snippets from foreign keys, and puts squiggles under tables and columns that don't exist. You can double-click a cell to edit it, and it uses the schema to pick a dropdown or a JSON editor. It keeps per-connection query history. Export is CSV, JSON or SQL INSERTs, and you can drag a CSV, JSON or Parquet file onto a connection and query it as a temporary table.
SQLly goes further in a few places. IntelliSense pulls a column's real values into a WHERE clause. Export adds Excel with live formulas and a pivot sheet, and there's pivot, conditional formatting and computed columns in the grid. Big results stream and spill to disk past 50,000 rows or 64 MiB, so memory stays flat at 50 million rows. Peek virtualizes its tables and its site talks about 10k rows; I couldn't confirm what happens much past that.
Both can watch running queries and kill them. Peek added a Running queries node in 4.3.0 with a kill button per query. SQLly's Activity Monitor writes the kill as a script you review first. Neither has a finished plan viewer: I found nothing about plans in Peek's materials, and SQLly's is still in progress.
Safety and secrets
This is where the beta shows. Peek asks for confirmation before a DELETE without WHERE or a TRUNCATE, and connections can have a color. Read-only connections are an open issue on its tracker. Its docs show the password inside the connection URL in a JSON file under ~/peek, and I found no keychain support. The SSH tunnel code accepts any host key without checking it.
The MCP server is off by default, which is the right call. Its docs are upfront that once you turn it on it listens on all network interfaces with no authentication, so anything that can reach the port can drive your canvas. They tell you to keep it on a trusted network. Fair enough, but know that before you flip it on at a coffee shop.
SQLly does more here: read-only connections that also block file-reading and shell-escape tricks, a hard stop on UPDATE/DELETE with no WHERE, auto-wrapped transactions, prod painted red, and passwords kept in the OS keychain. Its MCP server lets an agent read schemas and run one SELECT in a read-only transaction that always rolls back; anything that writes comes back to you as a proposal.
AI
Both are local-first. Peek's agent nodes run against your own OpenAI-compatible endpoint (Ollama, llama.cpp, LM Studio), or hand the canvas to Claude Code over ACP so the agent writes queries and arranges nodes for you. That's a neat use of the canvas. SQLly works with local models (Ollama, MLX), your own endpoint, or cloud providers you opt into.
Cost
Peek is a free download, and I couldn't find a price anywhere on its site or repo. SQLly is free for hobbyists with two saved servers, and the free tier isn't available inside organizations with more than 100 employees. Past that it's a one-time $100 for SQLly 1.x or $200 for Lifetime.
Which one to pick
Pick Peek if
- You explore data by following relationships and want each step left on screen.
- You want to look at a database together with someone, live, without sharing credentials.
- You think on a whiteboard: queries, results, charts and notes side by side.
- You want Claude Code to build and arrange queries on a canvas for you.
- You only use PostgreSQL or MySQL/MariaDB, on an Apple Silicon Mac, and want something free and 25 MB.
Pick SQLly if
- You need Windows or Linux, or SQL Server, SQLite, DuckDB, ClickHouse, Oracle or Redis.
- You work on production databases and want read-only connections and passwords in the keychain.
- You need schema compare, data transfer, backup scripts and the other admin tools.
- You pull big result sets and need the grid to stay flat on memory.
- You're fine with closed source and paying once after the free tier.
Honestly, these two barely overlap. Peek is trying a different way to look at data, and I like the click-through-the-foreign-keys canvas a lot. SQLly is the workbench you use all day on a lot of engines. The full feature table is at /compare/peek. If you want to try SQLly, it's at /download, and if I got something wrong about Peek, tell me and I'll fix it.