Tabularis: a Tauri SQL workspace that puts an MCP server inside the database client

The gap Tabularis is aiming at: schema context for AI agents without a second process

Most AI coding assistants can write SQL. What they cannot do reliably is see your actual tables, column types and indexes. The usual workaround is to paste a schema dump into the chat, or to run a standalone MCP server that holds its own database credentials. Tabularis takes the second option and folds it into the client: the README states that the built-in MCP server lets Claude, Cursor and Devin "read your schema and run queries in the same app you already use." The audience is therefore narrow and specific. It is a developer who already keeps a desktop SQL client open all day and wants the agent to query the same connections, rather than a data team shopping for a driver catalogue. The README's own comparison table concedes the point: "If you need dozens of drivers, use DBeaver. Tabularis focuses on doing a few databases well." Three databases ship built in (PostgreSQL, MySQL/MariaDB, SQLite); the rest arrive as plugins.

Tauri shell, TypeScript UI, and a plugin boundary drawn at JSON-RPC over stdio

The repository is primarily TypeScript with a Rust component, and the topics list confirms Tauri as the desktop shell. That choice matters for anyone evaluating install size and memory against Electron-based clients, though the README does not publish a binary size figure, so treat that as unverified. The architecture that is documented is the plugin boundary. Plugins are not compiled against a Java or Eclipse API, and they are not restricted to JavaScript. The README states that plugins can be written in "any language (JSON-RPC over stdio)." That is a process boundary rather than a library boundary: a driver plugin is a separate executable that speaks JSON-RPC over standard input and output, and the host app talks to it. The practical consequence is that a plugin author can write a ClickHouse driver in Go or Rust without touching the Tabularis codebase. The cost is that every plugin is an out-of-process dependency with its own release cadence, and the README links each one to its own GitHub repository rather than vendoring them. PostgreSQL, MySQL/MariaDB and SQLite avoid that risk because they are built in.

Installing v0.23.0 and where your connection credentials end up

The README gives package-manager commands per platform. On Windows: winget install Debba.Tabularis. On macOS: brew install --cask tabularis. On Linux: sudo snap install tabularis. Direct installers are also listed for v0.23.0, including tabularis_0.23.0_x64-setup.exe, tabularis_0.23.0_aarch64.dmg for Apple Silicon, tabularis_0.23.0_x64.dmg for Intel, and AppImage, .deb and .rpm builds for Linux. Flatpak is available through Flatpark and Arch users can take tabularis-bin from the AUR. The README has a dedicated Configuration Storage section, which is the part worth reading before you type a production password into the connection dialog. The material supplied here does not include the contents of that section, so I cannot tell you the exact path or whether secrets are encrypted at rest. Verify it yourself after install by locating the config directory on your platform and inspecting what the app writes there. The AI features are described as optional, and the MCP server is a separate section from connection management, so the agent integration is something you enable rather than something that runs by default. Confirm that too, since the README does not state the default state of the MCP listener.

SQL notebooks, visual EXPLAIN and the query builder are the parts that do not depend on AI

Strip out the MCP server and Tabularis is still a client with a feature set worth judging on its own. The comparison table lists SQL notebooks with SQL and Markdown cells, cross-cell variables and charts, and marks them absent in DBeaver CE, TablePlus and Beekeeper Studio. Cross-cell variables are the detail that separates a notebook from a list of saved queries: a value produced in one cell can be referenced by a later cell, which is how you build a parameterised exploratory session instead of re-pasting literals. Visual EXPLAIN with interactive plan graphs is listed as present in both Tabularis and DBeaver, so it is table stakes rather than a differentiator. The visual query builder and the data grid round out the non-AI surface. The README also documents a plugin system, a logging section and keyboard shortcuts, and the UI ships in eleven languages including English, Italian, Spanish, Chinese (Simplified), French, German, Japanese, Russian, Tagalog, Korean and Portuguese (Brazilian). None of this is unusual for a modern client; the notebooks are the piece with the fewest equivalents in the tools the README compares against.

Where Tabularis is the wrong tool

Driver breadth is the first limit, and the project states it rather than hiding it. DBeaver CE is listed at 100+ databases; Tabularis is three built-in plus sixteen official plugins. If your week involves Oracle, SQL Server, Snowflake and a mainframe bridge, this is not your client. The second limit is the plugin supply chain. Sixteen databases are listed, each pointing at a separate GitHub repository, and several are community-maintained rather than first-party: the Cloudflare D1 plugin lives under josejorge, and the DM/Dameng plugin under haos666. A community plugin can fall behind a Tabularis release, and because plugins run as separate stdio processes, a version mismatch surfaces at connection time rather than at install time. The third limit is release cadence. The repository shows v0.23.0 alongside nightly builds tagged v0.22.1-4 and v0.22.1-3, which means the project ships frequently and nightly artefacts exist in the release list. Frequent releases are not a defect, but a desktop client that updates often is a moving target for anyone pinning a version across a team. Finally, the MCP server is only useful if your agent client speaks MCP; the README names Claude, Cursor and Devin specifically, and does not claim compatibility with anything else.

How it differs from DBeaver CE, the closest Apache-2.0 alternative

Both are Apache-2.0 and free, so the licence is not the deciding factor between them. The difference is in what each optimises. DBeaver CE is a driver platform: the README's own table credits it with 100+ databases and Java/Eclipse plugins, which means its extension model assumes the JVM and an Eclipse plugin API. Tabularis inverts that. It ships three databases in the core binary and pushes everything else across a JSON-RPC over stdio boundary that accepts any language, so the extension cost is lower for a single driver but the coverage is far smaller. The second difference is where AI sits. DBeaver's assistant is described as cloud-based; Tabularis lists AI text-to-SQL with local models through Ollama, and a built-in MCP server. Local models mean the schema and the query text do not have to leave the machine, which is a real distinction for anyone working against a database they cannot send to a third party. The third difference is the notebook. DBeaver CE is marked as not having SQL notebooks with cross-cell variables, and that is the feature that most changes how a long exploratory session is structured. If you want the widest driver list, DBeaver wins on the README's own numbers. If you want notebooks plus an agent that can see the schema, Tabularis is the one making that bet.

Licence, plugin provenance and what maintenance actually costs you

The core repository is Apache-2.0, which permits commercial use and modification and requires that you preserve the licence and notice files. That covers the Tabularis code. It does not automatically cover the sixteen plugin repositories, which are separate projects under separate owners, and the README links to them individually rather than stating a blanket licence. If your organisation has a policy against pulling code from unvetted personal repositories, the Cloudflare D1 and DM/Dameng plugins are the ones to check first, because they are hosted outside the TabularisDB organisation. On maintenance: the release list shows v0.23.0 dated 2026-09-10 and nightly builds from the same day and from 2026-09-04, so expect to track releases rather than sit on one. The README documents an Updates section, and the install path through winget, Homebrew, Snap, Flatpak and the AUR means updates can be handled by the same package manager you installed with, which keeps the cost low on those platforms. The AppImage and direct .deb/.rpm downloads do not get that for free. This is not legal advice; read the LICENSE and NOTICE files in the repository and check each plugin's own licence before shipping it inside a regulated environment.

Editorial conclusion

Adopt Tabularis if your work is concentrated on PostgreSQL, MySQL/MariaDB or SQLite and you want schema access from an AI agent without standing up a separate MCP process. Do not adopt it as a general-purpose driver catalogue; the README itself points DBeaver users elsewhere, and the 16 non-core databases depend on third-party plugin repositories that can lag the app. Before committing, install v0.23.0 through your platform's package manager, open the config directory to confirm where connection credentials are written, and read the Apache-2.0 LICENSE and NOTICE files in the repository, since the licence covers the code and not the third-party plugin repositories listed under driver coverage.

Official sources

1. License: Apache-2.0
2. Project website
3. README
4. Releases
5. TabularisDB/tabularis on GitHub