I've been managing databases for years, and I'm tired of the same two options: heavyweight enterprise tools that feel like flying a 747 to get groceries, or stripped-down CLI utilities that make even simple tasks a chore. There had to be a middle ground—something fast, clean, and actually enjoyable to use.
So I built Tabularis, starting from a vibe-coding session with Claude Code, and then it evolved as I really put my mind into it.
The Problem With Database Tools
Like everyone else, I spent years bouncing between phpMyAdmin, MySQL Workbench, DBeaver, and whatever else was popular that quarter. They all had the same issues:
- Too heavy: Enterprise tools pack in features I'll never touch, eating RAM and taking forever to start
- Poor UX: Clunky interfaces designed by committee, not for actual daily use
- Vendor lock-in: Tools optimized for one database, awkward for others
- Missing modern features: No AI assistance, no visual query building, no MCP integration
The real frustration came when I just wanted to quickly check production data or test a query—it shouldn't require launching a 500MB Electron app and waiting 30 seconds for it to connect.
What Makes Tabularis Different
Tabularis is what I actually wanted to use every day. It's built with Tauri (not Electron), so it's genuinely lightweight—the entire app is under 20MB. Starts in under a second. Feels native because it is native.
But being lightweight doesn't mean being limited. Here's what actually matters:
Connection Management That Makes Sense
SSH tunneling with automatic readiness detection. No more "is the tunnel up yet?" guessing games. Secure password storage in your system keychain, not some custom encrypted file. Clone connection profiles instead of manually recreating them.
The Database Explorer I Always Wanted
A proper tree view that shows everything—tables, views, stored procedures, functions, foreign keys, indexes. Not hidden in submenus or separate windows. Right-click context actions for common operations. Want to see the row count? It's one click, not three windows deep.
The ER diagram generator is particularly useful. It's not trying to be a full diagramming tool—it just shows your schema interactively. Pan, zoom, select specific tables. When you're debugging a complex query join, being able to visually trace the relationships saves real time.
Visual Query Builder (That Actually Works)
Most visual query builders are toys. They work for SELECT * FROM users and fall apart at the first JOIN. I needed something that could handle real queries—multiple joins, aggregates, WHERE clauses, HAVING filters.
The builder uses ReactFlow for drag-and-drop table connections. Create visual relationships between tables, and it generates proper JOIN syntax. Add filters, aggregates, sorting—all visually—and watch the SQL update in real-time. When you need to switch to the SQL editor, you're not starting from scratch.
AI Integration (Optional, But Useful)
This is where it gets interesting. I didn't want to force cloud AI on anyone—privacy matters—so Tabularis supports multiple AI providers:
- OpenAI, Anthropic, OpenRouter for cloud options
- Ollama for completely local inference
- OpenAI-compatible APIs (Groq, Perplexity, LocalAI, etc.)
The AI features are straightforward: text-to-SQL generation and query explanation. Type "show me users who signed up last week" and get working SQL. Or paste a complex query and get a plain-English explanation of what it's doing.
But here's the part I'm most excited about: MCP Server support.
The MCP Server: Exposing Databases to AI Agents
Tabularis includes a built-in Model Context Protocol (MCP) server. Run tabularis --mcp and your database connections become available to any MCP-compatible AI agent—Claude Desktop, Cursor, or custom tools.
This means AI agents can query your databases directly. Not through screenshots or copy-paste, but actual programmatic access. I've been using it with Claude Desktop to analyze production data, generate reports, and debug queries—all without leaving my chat window.
The architecture is simple: Tabularis runs as an MCP server, exposes your saved connections through a standard protocol, and handles authentication and query execution. The AI agent just sees a set of available databases and can query them like any other data source.
It's surprisingly powerful. I recently had Claude help me optimize a slow query by letting it inspect the actual table structures, existing indexes, and query execution patterns—all through MCP. It generated three optimization strategies, I tested them, and cut query time by 60%. That workflow wasn't possible with traditional database tools.
Building It All
I started Tabularis about six months ago, mostly as a weekend project to scratch my own itch. The tech stack choices were deliberate:
- Tauri v2 instead of Electron (smaller bundle, better performance, native feel)
- React 19 with TypeScript (familiar, fast development)
- Tailwind CSS v4 (rapid UI iteration without CSS bloat)
- Rust backend with SQLx (type-safe queries, excellent performance)
The Rust backend handles all database operations through SQLx, which provides compile-time verification of SQL queries. No more runtime surprises about typos in column names. SSH tunneling is handled with native Rust libraries, not shelling out to external processes.
One interesting challenge was supporting multiple database types (MySQL, PostgreSQL, SQLite) with a unified interface. SQLx helps here with its database-agnostic query builder, but each database has quirks—MySQL's information_schema differs from PostgreSQL's pg_catalog, and SQLite is its own thing entirely.
The solution was a trait-based provider system in Rust. Each database implements a common DatabaseProvider trait that defines operations like "fetch tables," "execute query," "get foreign keys." The frontend doesn't care which database it's talking to—it just calls methods on the trait.
Using Tabularis
Getting started is intentionally simple:
macOS (Homebrew)
brew tap debba/tabularis
brew install --cask tabularis
Arch Linux
yay -S tabularis-bin
Everyone Else
Download from releases for Windows, Linux (AppImage), or macOS (DMG).
Connect to your database, start exploring. The interface is designed to be obvious—if you've used any database tool before, you'll figure it out in 30 seconds.
All configuration lives in ~/.config/tabularis/ (or your OS equivalent)—connections, saved queries, themes, settings. Plain JSON files, easy to back up or edit manually if needed.
What's Next
Tabularis is fully functional today, but there's more to build:
- Better PostgreSQL & SQLite support: MySQL is solid, but Postgres and SQLite need more love
- Query history: Track and revisit past queries across sessions
- Performance monitoring: Built-in query profiling and execution plan visualization
The code is on GitHub, Apache 2.0 licensed. It's built by a developer, for developers. No telemetry, no accounts, no subscriptions. Just a tool that works.
If you're tired of database tools that feel like they're fighting you instead of helping you, give Tabularis a try. It's what I wish I had years ago.
Download: tabularis.dev | Source: github.com/debba/tabularis
Run tabularis --mcp to enable MCP server mode and start connecting your databases to AI agents.
Top comments (0)