tabularis

Tabularis is an open-source desktop SQL workspace built with Tauri, pairing a React 19 frontend with a Rust backend for native, local-first performance. It ships with drivers for PostgreSQL, MySQL/MariaDB, and SQLite, and extends to nearly any other database — DuckDB, ClickHouse, MongoDB, Redis, Elasticsearch, and more — through an external plugin system where each driver is a standalone executable speaking JSON-RPC 2.0 over stdin/stdout, so a driver can be written in any language and installed without restarting the app.

Beyond a Monaco-powered SQL editor with tabbed, isolated connections and split view, Tabularis includes SQL notebooks that mix SQL and Markdown cells with cross-cell variable references and inline charts, a drag-and-drop visual query builder built on ReactFlow, and a visual EXPLAIN view that renders execution plans as interactive node graphs across PostgreSQL, MySQL, and SQLite.

A built-in MCP (Model Context Protocol) server lets AI agents such as Claude, Cursor, and Devin read schemas and run queries directly against a saved connection, with one-click configuration for popular clients. Because the MCP subprocess has no UI of its own, write and DDL queries route through a file-queue approval gate: the main app watches for pending requests, runs a pre-flight EXPLAIN, and surfaces an approval modal before anything executes.

The project is Apache 2.0 licensed with no paid tier or license-gated features — the plugin system, notebooks, and MCP server all ship free in the self-hosted desktop app. It has an active release cadence with near-daily nightly builds and native packaging for Windows, macOS, and Linux (Snap, Flatpak, AppImage, AUR).

What You Get

• Three built-in database drivers (PostgreSQL, MySQL/MariaDB, SQLite) plus 16 shipped community plugins covering DuckDB, ClickHouse, Redis, MongoDB, Elasticsearch, SQL Server, and more.
• A Monaco-based SQL editor with tabbed, isolated connections, split view, multi-statement execution, and dialect-aware statement splitting for stored procedures and $$-delimited blocks.
• SQL notebooks combining SQL and Markdown cells, cross-cell variables, inline bar/line/pie charts, and export to HTML, CSV, or JSON.
• A drag-and-drop visual query builder and a visual EXPLAIN graph view for inspecting query plans across drivers.
• A built-in MCP server with one-click setup for Claude Desktop, Cursor, and Devin, exposing tools to list connections, describe schemas, and run queries with a human-in-the-loop approval gate for writes.
• Optional AI assist for text-to-SQL and query explanation across OpenAI, Anthropic, MiniMax, OpenRouter, and local Ollama models.

Common Use Cases

• Backend developers who need one native app to inspect and query PostgreSQL, MySQL, and SQLite databases without juggling separate GUI tools.
• Teams that want an AI coding agent (Claude, Cursor, Devin) to read their schema and run scoped queries through the built-in MCP server instead of pasting SQL back and forth.
• Data analysts documenting investigations in SQL notebooks that combine queries, markdown notes, and charts in one shareable file.
• Engineers optimizing slow queries with the visual EXPLAIN graph instead of parsing raw text execution plans.
• Organizations that need a niche database driver (DuckDB, ClickHouse, MongoDB, Redis) and can install or write a plugin instead of switching tools.

Under The Hood

Architecture Tabularis is a Tauri v2 desktop app: a React 19/TypeScript frontend (src/) talks to a Rust backend (src-tauri/src/) over Tauri’s IPC commands. The backend is organized into clear module boundaries — drivers/ defines a DatabaseDriver async trait with a DriverCapabilities struct so the frontend can adapt its UI per database, plugins/ handles installing, versioning, and integrity-verifying third-party driver executables, and mcp/ implements the Model Context Protocol server with its own protocol.rs, an install helper, and a preflight/approval subsystem. Because the MCP server runs as a headless subprocess with no window, sensitive queries are routed through a file-queue (pending_approvals/) that the main app polls and renders as an approval modal after running a pre-flight EXPLAIN — a deliberate cross-process design to keep human oversight in an otherwise autonomous agent workflow. Connection pooling is centralized in pool_manager.rs, which maintains separate pool maps per engine (Postgres via deadpool-postgres, MySQL/SQLite via sqlx) behind async RwLocks.

Tech Stack The frontend uses React 19, TypeScript, Tailwind CSS v4, Monaco Editor for the SQL/JSON editors, @xyflow/react for the visual query builder and ER diagrams, TanStack Table/Virtual for large result grids, and react-i18next for the app’s eleven-language UI. The Rust backend runs on Tauri 2 and Tokio, with sqlx for MySQL/SQLite and a dedicated tokio-postgres + deadpool-postgres stack for PostgreSQL, rustls (with rustls-platform-verifier) for TLS instead of native-tls to avoid deprecated macOS Secure Transport issues, keyring for OS-native credential storage, russh for SSH tunneling, and ed25519-dalek to verify signed release integrity for the plugin registry.

Code Quality The backend keeps unit tests colocated as _tests.rs siblings next to the module under test (31 such files covering connection migrations, pool management, plugin installation, MCP protocol handling, and more), while the frontend has an extensive Vitest + Testing Library suite (249 test files) spanning components, hooks, contexts, pages, and utilities. CI (GitHub Actions, ci.yml) runs typecheck, lint, a full tauri build, and pnpm test:all (Rust cargo test plus frontend coverage) on every push and PR, with a separate pg-integration.yml workflow for Postgres-specific tests. The repository also documents its own conventions in a .rules/ directory (Rust module structure, React patterns, modal styling, testing conventions) that contributors are expected to follow.

What Makes It Unique Most open-source SQL clients that added AI features stop at text-to-SQL suggestions inside the editor. Tabularis instead ships a real MCP server so external agents (Claude Desktop, Cursor, Devin) can connect directly, but pairs it with a genuinely novel safety mechanism: because the MCP subprocess has no UI, write/DDL queries are queued to disk, pre-flighted with an EXPLAIN, and require an explicit approval click in the running desktop app before they execute — giving agent-driven database access a human-in-the-loop gate without requiring the agent’s host app to build one itself. Combined with a plugin system where drivers are arbitrary executables speaking JSON-RPC over stdio (not a JS-only or Java-only plugin API like most competitors), it extends to any database in any language while keeping the trust boundary between an AI agent and a live database explicit.

Self-Hosting

Licensing Model Apache 2.0 licensed — all features available in self-hosted deployments with no restrictions or license keys required.

Self-Hosting Restrictions None found. The README’s own comparison table lists the license as “Apache 2.0, free” with no paid tier, and no ee/, enterprise/, or pro/ directories, license-check code paths, or feature flags gating functionality were found in the source.

License Key Required No.