DataBison
A calm, fast database client for six engines.
PostgreSQL, MySQL/MariaDB, SQLite, Redis/Valkey, MongoDB, and ClickHouse — in one native app that starts instantly, stores nothing in the cloud, and never phones home.
Apple Silicon only for this beta · unsigned build, right-click → Open on first launch
Most GUI database clients make you compromise.
They're Electron-heavy, or they treat SSH tunneling as a bolt-on TCP forward and stop there, or they make you re-enter credentials and rebuild tunnels every time you connect. DataBison treats SSH access, peer authentication, and multi-engine support as first-class, unified concerns — not per-engine afterthoughts.
Built for developers, backend engineers, DBAs, and SREs who work across more than one database engine and connect through SSH bastion hosts more often than not.
Six ideas, taken seriously.
Fast and light, by construction
Built on Tauri 2 (Rust) using the OS's own WebView — no bundled Chromium or Node runtime. A real architectural difference, not just a marketing claim.
Six engines, one tool
Relational, key-value, document, and columnar — behind one interface that honestly shows what each engine can and can't do, rather than faking uniformity.
Real SSH peer authentication
Forwards straight to a database server's Unix socket through SSH and performs genuine OS-level elevation — no database password at all. For both Postgres and MySQL.
Discovery that connects
Point it at a host and it reads each protocol's real handshake to confirm what's running — then connects automatically when the trust it just used is provably sufficient.
Local-first, no telemetry
No analytics or tracking system anywhere in the app — not a toggle, an absence. Every credential lives in your OS keychain; every byte of query data stays on your machine.
AI that's transparent by design
Every AI action shows exactly what context will be sent before it's sent, and defaults to an offline mock provider — fully demoable with zero network calls.
Connect the way a DBA does by hand — no database password at all.
Most GUI clients stop at TCP port-forwarding. DataBison goes further: it can tunnel straight to a database server's Unix domain socket through SSH and perform genuine OS-level authentication — the same trust a DBA relies on when they SSH in and run psql or mysql locally on the box.
- Two elevation modes — trust the SSH login's own OS user as-is, or run a real remote elevation first: su <user> -c when the SSH session is root, non-interactive sudo -n -u <user> otherwise. Fails fast instead of hanging on a password prompt.
- Implemented for both PostgreSQL (peer) and MySQL/MariaDB (unix_socket / auth_socket) — most tools that bother with peer auth only cover Postgres.
- Same mechanism, same UI, for both engines.
Discovery that connects, not just lists.
Point DataBison at a host — directly or through an SSH hop — and it probes the standard ports for all five networked engines and reads each protocol's actual handshake: a real Postgres SSLRequest reply, MySQL's handshake packet, a Redis PING, a MongoDB hello, ClickHouse's HTTP banner. It clearly distinguishes "confirmed" from "port is open."
- Selecting a confirmed Postgres or MySQL result found on the SSH host itself immediately tries peer-auth elevation using the SSH credentials already in hand.
- A confirmed Redis result tries an unauthenticated connection. Success saves the connection and opens the schema browser directly — no form.
- Anything less certain falls back to a pre-filled New Connection dialog. One click turns the SSH details just used into a reusable saved host.
Everything else, briefly.
Connection management
One dialog for all six engines. Paste a postgres:// URI or CLI flags like psql -h host -U user -d db and the fields fill themselves in — engine-aware, so it knows mysql -p is a password flag while psql -p is a port flag. Environment tags are color-coded, with Production locked to a distinct amber/red scheme.
SSH tunneling
Real port-forwarding for every engine except SQLite, built on a pure-Rust SSH implementation — not a shell-out to the system ssh binary — so behavior is identical on macOS, Windows, and Linux. Password, key, or Automatic auth, with real known_hosts verification.
Query editor
A Monaco-based SQL editor with schema-aware autocomplete, a dialect-aware formatter, and Cmd/Ctrl+Enter to run. A heuristic mutation-safety gate blocks writes on read-only connections and requires confirmation on Staging/Production, naming exactly which keywords triggered it.
Data, schema & export
A searchable, lazily-loaded schema tree with columns, indexes, and foreign keys, plus a DDL panel. Table and collection contents load into a paginated, virtualized grid — exportable to CSV or JSON, with binary columns exported as real base64 content.
AI assistant
Six tasks: explain schema, explain query, generate from natural language, improve/format, identify relationships, summarize results. A side panel shows exactly what context will be sent before you click Ask. Defaults to an offline mock provider; swaps for any OpenAI-compatible endpoint.
Settings & privacy
Theme, default row limit, query timeout, and AI provider configuration — plus a Privacy section that states outright there is no telemetry system anywhere in the app.
Paste a connection string. Watch it parse.
A simplified preview of the same engine-aware parsing DataBison uses in its New Connection dialog. Nothing here leaves your browser — same as nothing in DataBison leaves your machine.
Note: this is a taste, not the whole thing — the real parser also handles SSL params and more flags/edge cases.
Six engines, one tool.
Relational, key-value, document, and columnar — DataBison queries each connection's actual capabilities, so the UI only shows what that engine genuinely supports rather than a one-size-fits-all facade.
| Engine | Driver | Notes |
|---|---|---|
| PostgreSQL | sqlx | Schema-level browsing; optional server-wide mode |
| MySQL / MariaDB | sqlx | Server-wide database browsing |
| SQLite | sqlx | Local file, no server required — works out of the box |
| Redis / Valkey | redis-rs | Key/prefix browsing, per-type paginated views |
| MongoDB | MongoDB driver | Collection browsing, constrained shell-style command grammar |
| ClickHouse | HTTP (reqwest) | Table/view browsing; the only engine with true server-side query cancellation |
Why it's fast.
Tauri 2, not Electron. A Rust backend paired with the operating system's own WebView, instead of bundling a full Chromium and Node runtime — the direct basis for starting instantly and staying light on memory and CPU.
DataBison's UI design is original, inspired by the clarity of professional SQL IDEs — it doesn't use JetBrains assets, layouts, or trademarks.
Where DataBison actually differs.
| Angle | What sets DataBison apart |
|---|---|
| Performance footprint | Tauri's native WebView instead of Electron — lighter idle memory and CPU than heavier, Electron-based tools in this category. |
| SSH depth | Most clients stop at TCP tunneling. DataBison also tunnels to Unix sockets and performs real remote su/sudo elevation — for both Postgres and MySQL, where most tools that bother with peer auth only cover Postgres. |
| Discovery UX | Protocol-verifying discovery, not a bare port scan — chains directly into a credential-free connection when the trust it just used already proves it out. |
| AI transparency | Context sent to any AI provider is shown up front, before it's sent; the default provider is a fully offline mock, so the feature is demoable without a vendor account. Not locked to one AI vendor — any OpenAI-compatible endpoint works. |
| Privacy stance | No telemetry is an architectural fact, not a settings toggle promising restraint. |
| Defense in depth | Read-only and mutation protection are enforced in the backend command layer and, where possible, at the database server session level — not just a client-side confirmation dialog. |
| Engine breadth | Relational, key-value, document, and columnar engines behind one interface that adapts its UI to each engine's real capabilities. |
Private by default. Not a setting — a fact.
No cloud backend, no account
The app never phones home. There's nothing to sign up for.
No telemetry, period
Confirmed absent from the codebase — not a disabled analytics SDK, no analytics SDK at all.
Secrets never touch disk in plaintext
Passwords, SSH passphrases, and AI API keys go only to the OS-native keychain. A pasted connection string has its password stripped and redirected there automatically.
Read-only is enforced, not just suggested
Backed by an application-level gate and, where the engine allows it, a server-side read-only session setting too.
Errors are redacted before display
Connection strings, credentials, and tokens are scrubbed out of error text before it reaches the screen, history, or an AI prompt.
AI is opt-in, per connection, and visible
Nothing is sent to a remote AI provider until you explicitly ask, and the exact context is shown beforehand.
Grab the beta. Point it at a database.
One native app. SQLite works immediately with no setup — the other five engines connect to a server or instance you already have; none are bundled.
macOS
Apple Silicon (arm64)A real release build — right-click → Open past the Gatekeeper warning, and connect.
Download — Free BetaWindows
x64An .msi build is next up, once it's built and tested.
Coming soonLinux
.AppImage / .debComing soon as a fast-follow after Windows.
Coming soonDataBison is in public beta. Core features are stable and tested, but you may hit rough edges as we polish toward 1.0.
- No inline cell editing yet — writes go through the query editor.
- Export covers CSV and JSON today.
- Query cancellation is genuinely server-side for ClickHouse; other engines stop the client from waiting, not the server from working.
- Built with automated test coverage from day one — hundreds of Rust tests, plus a frontend test suite.