dbx: A 25 MB Rust Client Supporting 100+ Databases
> Source: t8y2/dbx — https://github.com/t8y2/dbx > Language: Rust | Stars today: 349 | Size: 25 MB single binary > In one sentence: DBeaver needs Java, TablePlus costs money — dbx is just 25 MB
---
An Old Problem
Every programmer knows this moment: you start a new job, get a laptop, and need to connect to five databases — MySQL for orders, PostgreSQL for logs, Redis for cache, MongoDB for user profiles, ClickHouse for analytics events.
Then you start installing tools. DBeaver requires a Java runtime, starting at 300 MB. TablePlus's free version only opens two tabs. DataGrip requires a JetBrains subscription. Navicat is so expensive that company procurement takes three days of approvals.
In the end your machine carries three Java versions, two Electron apps, and a Chromium instance — 5 GB of disk and 2 GB of RAM just to run one SQL query.
t8y2's dbx wants to end this.
What's Inside 25 MB
dbx is a database client written in Rust, compiled to a single 25 MB binary. No Java, no Python, no Chromium. Download, unzip, run — three steps.
But those 25 MB contain:
- 100+ database drivers: MySQL, PostgreSQL, SQLite, Redis, MongoDB, DuckDB, ClickHouse, SQL Server, Oracle, Dameng, OceanBase, TiDB, KingbaseES... basically anything you can think of
- Desktop + Docker + CLI + Web: four deployment forms, one feature set
- AI SQL assistant: describe requirements in natural language, auto-generate SQL with safety checks
- MCP Server: AI coding tools like Claude Code, Cursor, and Windsurf can query your databases directly
- Message queue management: Kafka, RocketMQ, RabbitMQ, Pulsar, MQTT in one place
- ER diagrams, schema diff, execution plans, column lineage: professional data engineering features
- Claude Code can query your databases directly, no manual schema copying needed
- Cursor can see table structures in real time while writing code
- Any MCP-capable AI tool can connect to your databases through dbx
This is not a "lightweight" tool — it's a tool that compresses professional features into a minimal footprint.
How 25 MB Is Possible
The key is technology choices.
Rust + Native GUI
DBeaver uses Java + SWT and needs a JVM. TablePlus uses Swift (macOS-native) but requires rewrites for cross-platform. dbx uses Rust with Tauri (or a similar native UI framework), compiling to a native binary with no runtime overhead.
Rust's zero-cost abstractions mean you don't pay a runtime tax for abstraction layers. 100 database drivers can be statically linked into one binary, loaded on demand, with unused ones consuming no memory.
No Bundled Browser
Many "cross-platform" desktop tools (VS Code, Slack, Discord) use Electron, which essentially bundles Chromium. Each Electron app costs an extra ~200 MB of memory. dbx doesn't take this path — native UI rendering means 25 MB is 25 MB.
Native MCP Support
This is dbx's most interesting design. It's not just a database client — it's also an MCP Server.
MCP (Model Context Protocol) is a protocol proposed by Anthropic that lets AI tools access external data sources. dbx's MCP support means:
A Cross-Domain Analogy: Swiss Army Knife vs Toolbox
dbx's philosophy reminds me of a Swiss Army knife.
The essence of a Swiss Army knife isn't "many features" — you can buy a 50-function one, but it's too heavy for anyone to use. The real Swiss Army knife is the 91mm Victorinox Classic — just a blade, scissors, nail file, tweezers, and toothpick, each engineered to be extremely light.
dbx does the same: not cramming every feature in, but making every feature as small as possible. 100 database drivers aren't 100 full clients, but 100 connectors trimmed to their core protocols. The AI assistant doesn't embed an LLM — it lets you connect Claude, OpenAI, or a local Ollama.
Core insight: lightweight doesn't mean "fewer features" — it means "every byte spent where it matters."
Comparison with DBeaver
| Dimension | DBeaver | dbx | |-----------|---------|-----| | Size | 300+ MB (with JVM) | 25 MB | | Runtime | Java JRE required | No dependencies | | AI integration | Plugins | Built-in + MCP | | Message queues | Not supported | Native support | | Chinese databases | Partial | Dameng, KingbaseES, OceanBase, etc. | | Price | Free community edition | Completely free | | MCP Server | None | Built-in |
DBeaver's advantage is its ecosystem — many plugins, a large community, high maturity. dbx's advantage is density — more packed into 25 MB than into 300 MB.
A Signal on Dameng and Chinese Databases
dbx supports Dameng, KingbaseES, OceanBase, TiDB, openGauss, GaussDB, GoldenDB, and other Chinese databases — a signal that the ecosystem for Chinese databases is being taken seriously.
The pain point for these databases has been scarce tooling — DBeaver's Dameng support is half-broken, and Navicat requires an enterprise license. Treating Chinese databases as first-class citizens shows the developer community is seriously closing this gap.
My Take
dbx's most noteworthy aspect isn't its size, but its answer to "what should database tools look like in the AI era."
Traditional database tools are built for humans — open a GUI, click tables, view data. dbx's MCP support shows it's thinking about something else: if the primary consumer of database queries shifts from humans to AI agents, how should tools change?
The answer is turning the database into a protocol endpoint. An agent doesn't need a GUI — it needs structured schema information and a safe query interface. dbx's MCP Server is exactly that endpoint — any AI tool can access databases through a standard protocol without writing its own drivers.
Core insight: when AI agents become the primary database consumers, database tools will shift from "GUI-first" to "protocol-first." dbx does both — a GUI for humans, MCP for agents.
---
*GitHub: https://github.com/t8y2/dbx*