DBeaver has held a very comfortable place for years in the daily workflow of many developers, system administrators and data teams. It is complete, free in its Community edition, cross-platform and compatible with a huge number of databases. For anyone who needs to connect to almost any engine through JDBC, it remains a difficult tool to replace.
But its historical advantage also comes at a cost. DBeaver is a mature, broad application built on Java and Eclipse. That gives it compatibility and extensibility, but also a sense of heaviness for some users. At a time when AI agents are becoming part of the development workflow, a younger alternative has appeared with a different direction: less out-of-the-box universality, more AI integration, notebooks, MCP and a lighter architecture.
It is called Tabularis. It is an open source database client for PostgreSQL, MySQL/MariaDB and SQLite, built with Rust, Tauri, React and TypeScript. Its repository describes it as a hackable client with plugins, SQL notebooks, Visual EXPLAIN, optional AI features and a built-in MCP server. The idea is not to copy DBeaver feature by feature, but to build a SQL workspace better adapted to how programming agents are now being used.
A SQL client born as an AI-assisted experiment
One of the most striking aspects of Tabularis is its origin. According to the project’s own documentation, it started as an experiment: to see how far AI-assisted development could go in building a real tool from scratch. The result no longer looks like a simple demo. The project maintains frequent releases, a growing community and a plugin system designed to expand support without turning the main application into a hard-to-maintain monolith.
The story fits a broader trend. Many personal projects powered by AI agents are moving from quick prototypes to functional tools. Tabularis is interesting because it does not try to solve a trivial problem. A database client requires connections, credential management, SQL editors, tabular results, schema introspection, exports, multi-database support, execution-plan explanation, polished UX and cross-platform compatibility.
| Aspect | Tabularis |
|---|---|
| License | Apache 2.0 |
| Technologies | Rust, Tauri v2, React 19, TypeScript, Tailwind CSS v4, SQLx |
| Databases supported out of the box | PostgreSQL, MySQL/MariaDB and SQLite |
| Extension model | Plugins via JSON-RPC 2.0 over stdin/stdout |
| AI | Text-to-SQL, query explanation and local models through Ollama |
| Agent integration | Built-in MCP server |
| Installation | Windows, macOS and Linux |
| Mandatory telemetry | Not listed as a requirement |
The choice of Rust and Tauri makes sense in this context. Tauri enables cross-platform desktop applications with a Rust backend and a modern web interface, without carrying the full weight of Electron. That does not automatically make Tabularis better than DBeaver, but it does explain why it may feel lighter and more aligned with a new generation of tools born close to the AI agent ecosystem.
What Tabularis offers compared with DBeaver
The comparison with DBeaver is inevitable, although it should be made carefully. DBeaver is a very mature tool, with support for more than 100 drivers and years of use in professional environments. Tabularis, by contrast, is a much younger project, focused on fewer databases out of the box and strongly oriented toward modern workflows: SQL notebooks, MCP, interactive Visual EXPLAIN, plugins and optional AI features.
| Feature | Tabularis | DBeaver Community |
| License | Apache 2.0 | Apache 2.0 |
| Core technologies | Rust/Tauri + React | Java/Eclipse |
| Databases supported out of the box | PostgreSQL, MySQL/MariaDB, SQLite | More than 100 drivers |
| SQL notebooks | Yes | Not as an equivalent core feature |
| Built-in MCP | Yes | No |
| Visual EXPLAIN | Yes | Yes |
| Plugins | JSON-RPC over stdin/stdout, any language | Java/Eclipse plugin system |
| Local AI with Ollama | Yes | Not as a primary approach |
| SQL Server and Oracle | Not out of the box | Yes, through drivers |
The table makes one thing clear: this is not a universal replacement. If a company works with Oracle, SQL Server, DB2, Snowflake, BigQuery, Redshift, Teradata or dozens of different engines, DBeaver still has an obvious advantage. If daily work is concentrated around PostgreSQL, MySQL/MariaDB, SQLite and some engines extended through plugins, Tabularis starts to make sense as a more focused tool.
Its philosophy seems different: do a smaller set of workflows very well and open the rest through plugins. The documentation already mentions a ClickHouse plugin and a roadmap where SQL Server appears as a target. The message is honest: if you need dozens of drivers today, use DBeaver; if you want a modern, extensible SQL client prepared for AI agents, Tabularis is worth trying.
MCP changes the relationship between databases and agents
Tabularis’ most distinctive feature is its built-in MCP server. MCP, Model Context Protocol, is becoming a way to connect AI agents with external tools. In the case of Tabularis, it allows clients such as Claude Desktop, Cursor or Windsurf to read schemas and execute queries through the database client itself.
This changes the experience considerably. Until now, for an agent to help with SQL, the user often had to copy the schema, describe tables, paste errors or export results. With MCP, the agent can query the authorized environment directly: list connections, list tables, describe a table and run queries.
| MCP tool | Function |
list_connections | Lists saved connections |
list_tables | Shows tables in a connection |
describe_table | Returns columns, indexes and foreign keys |
run_query | Executes a SQL query and returns results |
The productivity advantage is obvious. A developer can ask the agent to inspect a structure, propose a query, analyze indexes or look for relationships without manually pasting all the information. But it also raises a delicate issue: permissions and security.
It is not the same for an assistant to suggest SQL as it is for it to execute it. That is why any integration of this kind should be used with explicit approval, separated environments, read-only mode whenever possible and great care around production databases. The power of MCP lies in connecting agents with real tools. Its risk lies in exactly the same place.
SQL notebooks: from SQL client to analysis workspace
Another important difference is SQL notebooks. Tabularis makes it possible to combine SQL and Markdown cells, inline results, variables between cells and bar, line or pie charts. This brings the tool closer to a data-notebook workflow, but centered on SQL and relational databases.
For teams doing data exploration, technical reports, incident analysis or executable documentation, this approach is practical. Instead of saving loose queries or screenshots of results, users can build a document with explanation, queries, variables and charts.
| Notebook feature | Practical use |
| SQL and Markdown cells | Combines explanation and queries |
| Variables between cells | Reuses results in later steps |
| Inline charts | Visualizes results without leaving the tool |
| Export | Generates HTML, CSV or JSON |
| Sequential execution | Allows full analyses to be reproduced |
| AI-generated cell names | Helps organize long notebooks |
This kind of workflow fits a clear evolution in SQL tools. The traditional client was used to connect, run queries and view results. Today’s teams also need to document, share, reproduce and automate analyses. Tabularis tries to move in that direction from the start.
Visual EXPLAIN and query builder to understand before changing
Tabularis also includes Visual EXPLAIN, with execution plans represented as interactive graphs, table views, raw output and optional AI-assisted analysis. For anyone working with PostgreSQL, MySQL/MariaDB or SQLite, understanding an execution plan can make the difference between an acceptable query and one that blocks a production database.
The value is not just in showing a nice graph. It is in making it easier to read scans, joins, estimates, costs, indexes used and possible bottlenecks. If AI analysis also helps explain why a query is doing a full scan or where an index is missing, the optimization loop can become faster.
| Feature | What it provides |
| Visual EXPLAIN | Execution plans as navigable graphs |
| Raw view | Original database output |
| Table view | Exact metrics for each node |
| AI analysis | Optional explanation of the plan |
| Visual Query Builder | Drag-and-drop JOINs and filters |
| Real-time SQL | Instant query generation |
The visual query builder also targets users who need to assemble queries without writing everything by hand. It does not replace SQL knowledge, but it can help with queries involving several tables, relationships and complex filters. For mixed product, technical support or analysis profiles, it can lower the entry barrier.
Plugins: fewer built-in drivers, more open architecture
One of Tabularis’ early weaknesses is limited database support out of the box. PostgreSQL, MySQL/MariaDB and SQLite cover many cases, but not all. DBeaver clearly wins when the main criterion is connecting to almost anything.
Tabularis’ answer is its plugin system. Plugins are independent executables that communicate with the application through JSON-RPC 2.0 over stdin/stdout and can be written in any language. That decision matters because it avoids limiting extensions to an internal SDK or a single language.
| Advantage of the plugin system | Reading |
| Plugins as independent executables | Less coupling with the main app |
| JSON-RPC over stdin/stdout | Simple and portable protocol |
| Any language | A driver can be written in Rust, Go, Python or another language |
| Installation without restart | Better experience when adding support |
| Plugin registry | Easier discovery and installation |
| Roadmap with more drivers | Allows community expansion |
The challenge will be quality. An open plugin system needs documentation, testing, versioning, security and a community that maintains drivers. The architecture is promising, but real support will depend on whether reliable plugins appear for relevant engines.
What it still cannot replace
Tabularis should not be presented as “the new DBeaver” for every scenario. It still does not have the same database coverage, the same track record in enterprise environments or the same accumulated maturity. For teams using Oracle, SQL Server, multiple JDBC drivers, advanced administration or very specific workflows, DBeaver will remain the safer option.
It is also worth remembering that Tabularis is a young project. It can move fast, but that means frequent changes, possible regressions and a community that is still small compared with established giants. For personal use or technical teams comfortable with new tools, it is attractive. For a large company, it is better to test it first in non-critical environments.
| Tabularis fits well if… | DBeaver still wins if… |
| You work with PostgreSQL, MySQL/MariaDB or SQLite | You need support for many engines |
| You want MCP for AI agents | Your environment does not allow agents connected to data |
| You use SQL notebooks | You prefer a classic universal client |
| You value a lighter startup and modern stack | You prioritize maturity and compatibility |
| You want local AI with Ollama | You need consolidated enterprise integrations |
| You are interested in extending through plugins | You depend on Oracle or SQL Server today |
The honest comparison benefits the project. Tabularis does not need to beat DBeaver on every front. It can grow as a modern alternative for a specific segment: developers who live in PostgreSQL/MySQL/SQLite, use AI agents and want a tool more integrated with those workflows.
A signal of where development tools are heading
Tabularis is interesting beyond its specific features because it shows a market direction. Development tools are starting to be designed with agents in mind, not only humans. Previously, a SQL client showed tables so a person could write queries. Now, that client can expose the schema to an agent, allow it to run queries, explain plans and act as a bridge between database, editor and chat.
This does not remove the professional from the process. It forces them to work with another layer. The developer no longer only writes SQL: they validate suggestions, control permissions, review plans, decide indexes, audit the agent’s actions and turn analysis into real changes. The tool has to support that dialogue between human and intelligent system.
Tabularis, with MCP, notebooks, Visual EXPLAIN and optional AI, moves precisely in that direction. It is not just a prettier SQL client. It is a test of what technical applications can look like when AI stops being a side add-on and becomes part of the product architecture.
The experiment already looks like a product
The most striking part is that Tabularis does not come from a large company with a huge team behind it, but from an AI-assisted development experiment driven by a single person. That does not guarantee quality or long-term survival, but it says a lot about the current speed of software creation. With good tools, technical judgment and well-used agents, an individual project can approach problems that previously seemed reserved for larger teams.
The question now is whether Tabularis can sustain the pace. Building a tool is one thing. Maintaining it, handling bugs, ensuring compatibility, documenting plugins, responding to the community and earning trust in work environments is another.
Even so, its arrival is good news for the open source ecosystem. DBeaver will remain the universal client for many people. TablePlus and Beekeeper Studio will continue to have their audiences. But Tabularis brings something different: a modern, open, extensible SQL tool designed from the beginning to coexist with AI agents.
The future of database clients will not be only about connecting to more engines. It will also be about understanding context better, explaining plans, documenting queries, automating tasks and allowing agents to work with data without turning security into an afterthought. Tabularis does not have the whole answer yet, but it has asked a very relevant question: what should a SQL client look like when the user no longer works alone?
Frequently asked questions
What is Tabularis?
Tabularis is an open source database client for PostgreSQL, MySQL/MariaDB and SQLite, with SQL notebooks, Visual EXPLAIN, optional AI, a plugin system and a built-in MCP server.
Is it written in Rust?
Yes. The backend uses Rust and Tauri v2, while the interface uses React, TypeScript and Tailwind CSS.
Can it replace DBeaver?
It depends on the use case. For PostgreSQL, MySQL/MariaDB and SQLite, it can be an interesting alternative. If you need broad support for more than 100 databases, Oracle or SQL Server, DBeaver is still more complete.
What does the MCP server add?
It allows agents such as Claude Desktop, Cursor or Windsurf to read the database schema and execute queries through controlled tools exposed by Tabularis.
Does it include AI features?
Yes. It includes optional features such as text-to-SQL and query explanation through OpenAI, Anthropic, OpenRouter, Ollama and OpenAI-compatible APIs.
What license does Tabularis use?
Tabularis is published under the Apache 2.0 license, a permissive license that allows use, modification and distribution under its terms.