dbx: 25 MB, 100 Databases — The Minimalist Philosophy

> Source: t8y2/dbx — https://github.com/t8y2/dbx > Language: Rust | Stars today: 349 | Size: 25 MB single binary > In one line: DBeaver needs Java, TablePlus charges money — dbx is just 25 MB

An Old Problem

Every developer knows this moment: starting a new job, getting a machine, and needing to connect to five databases — MySQL for orders, PostgreSQL for logs, Redis for cache, MongoDB for user profiles, ClickHouse for event analytics.

Then you start installing tools. DBeaver needs a Java runtime, 300 MB minimum. TablePlus's free version allows only two tabs. DataGrip requires a JetBrains subscription. Navicat is so expensive that company procurement takes three days of approval.

In the end your machine has three Java versions, two Electron apps, and a bundled Chromium kernel — eating 5 GB of disk and 2 GB of RAM just to run one SQL query.

t8y2's dbx aims to end this.

What Fits in 25 MB

dbx is a database client written in Rust, compiled to a single 25 MB binary. No Java, no Python, no Chromium. Download, extract, run — three steps.

But those 25 MB contain:

• 100+ database drivers: MySQL, PostgreSQL, SQLite, Redis, MongoDB, DuckDB, ClickHouse, SQL Server, Oracle, plus Dameng, OceanBase, TiDB, KingbaseES, and more
• Desktop + Docker + CLI + Web: four deployment forms, one feature set
• AI SQL assistant: describe requirements in natural language, 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
• ER diagrams, Schema Diff, execution plans, column lineage: professional data-engineering features

This isn't a "lightweight" tool — it's a tool that compresses professional features into a tiny footprint.

How 25 MB Is Possible

It comes down to 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 a native UI framework (Tauri or similar), compiling to a native binary with no runtime overhead. Rust's zero-cost abstractions mean 100 database drivers can be statically linked into one binary and loaded on demand.

No Bundled Browser

Many cross-platform desktop tools (VS Code, Slack, Discord) use Electron, which bundles a Chromium — adding roughly 200 MB of memory per app. dbx renders natively: 25 MB means 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 Anthropic's protocol for letting AI tools access external data sources. dbx's MCP support means:

• Claude Code can query your database directly, no manual schema copying
• Cursor can see table structures in real time while writing code
• Any MCP-capable AI tool can connect to your databases through dbx

This upgrades dbx from "a developer's database tool" to "a database interface for AI agents." Agents don't need to know how to connect to MySQL or write connection strings — dbx handles that, and the agent just asks over MCP, "what columns does this table have?"

An Analogy: Swiss Army Knife vs. Toolbox

dbx's philosophy resembles a Swiss Army knife. The essence isn't "many features" — a 50-function knife is too heavy to use. A real Swiss Army knife is the 91mm Victorinox Classic: blade, scissors, nail file, tweezers, toothpick — each made extremely light.

dbx does the same: not cramming everything in, but making every feature minimal. The 100 database drivers aren't 100 full clients, but 100 connectors stripped to their core protocols. The AI assistant doesn't embed an LLM — it supports Claude, OpenAI, or a local Ollama.

Core insight: Lightweight doesn't mean "fewer features" — it means every byte is spent where it matters.

Comparison with DBeaver

| Dimension | DBeaver | dbx | |------|---------|-----| | Size | 300+ MB (with JVM) | 25 MB | | Runtime | Java JRE required | None | | AI integration | Plugins | Built-in + MCP | | Message queues | Not supported | Native support | | Chinese databases | Partial | Dameng, KingbaseES, OceanBase, etc. | | Price | Community edition free | Fully free | | MCP Server | No | Built-in |

DBeaver's advantage is its ecosystem — plugins, community, maturity. dbx's advantage is density: more packed into 25 MB than DBeaver fits in 300 MB.

The Signal from 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.

Their historical pain point 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 Observations

dbx's most notable aspect isn't its size but its answer to "what should a database tool look like in the AI era?"

Traditional database tools are built for humans — open a GUI, click tables, view data. dbx's MCP support signals a different question: if the primary consumer of database queries becomes an AI agent, how should the tool change?

The answer is turning the database into a protocol endpoint. Agents don't need a GUI; they need structured schema information and a safe query interface. dbx's MCP Server is that endpoint — any AI tool can access the database via 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 — GUI for humans, MCP for agents.

---

*GitHub: https://github.com/t8y2/dbx*