Not a promo, just a genuine thank-you to Vercel.

A few months ago, I started Tabularis, an open-source desktop database client, mostly out of late-night frustration with the existing tools. Today, I got the email accepting it into the Vercel Open Source Program.

I’ll be honest: I’ve been a Vercel fan for years, so this one hit a little differently.
The part that made me smile is what gets supported: the site itself.

tabularis.dev (docs, blog, changelog, plugin pages) is an open-source Next.js app, static export, deployed on Vercel. So it ended up being an open-source database client with an open-source website, both backed by the same program.

How this actually helps the project:

• Next-level preview deploys: Since the site is mostly Markdown, being able to review every docs change or blog post, including dynamic OG cards, exactly as it will look live has already saved me from shipping so many typos.
• Zero-friction staging: It makes it incredibly easy to experiment with the "boring-but-important" stuff I've been pushing off, like custom search indexing and performance tweaks, without breaking production.
• Automated workflow: It just automates the whole deployment pipeline, meaning I can spend less time wrestling with DevOps and more time actually building the DB client.

Anyway, a huge thanks to the Vercel OSS team for backing a young project. It genuinely means a lot.

• The full story: tabularis.dev/blog/vercel-open-source-program
• The project (GitHub): github.com/TabularisDB/tabularis

Drop any questions about the DB client or the setup below, happy to chat!

Hi everyone,
Working with JSON/JSONB data inside relational databases is often a pain. Most database IDEs treat JSON fields as massive, unformatted text strings, forcing you to copy-paste them into external formatters just to understand what's going on.
To solve this, I’ve completely revamped the Data Grid in Tabularis (an open-source, local-first SQL client built with Rust and Tauri v2).
Here is how it handles JSON now:

• Code, Tree, and Raw Editors: You can switch views depending on whether you need to check the nested structure (Tree) or do quick edits (Code/Raw).
• Smart Auto-Detection: If you have valid JSON stored inside plain TEXT or VARCHAR columns, a new toggle automatically detects it and activates the rich JSON cell renderer (giving you the tree expander and native viewer).
• Native Viewer Window: Opens heavy JSON structures in a dedicated, lightweight Tauri window with per-cell deduplication, keeping the grid snappy.
• Pending Edits & Diffs: It tracks cell changes, row additions, or deletions as pending edits, showing side-by-side or inline diffs before you actually commit the generated SQL to the database.

Since it’s built with Rust/Tauri, the virtualized grid stays incredibly fast even with large result sets. It also features a built-in MCP (Model Context Protocol) server if you like connecting your database schema to AI agents like Cursor or Claude safely.
The project is fully open-source and local-first. Would love to get some feedback from the community on how to improve the data grid further!

• GitHub: https://github.com/debba/tabularis
• Wiki: https://tabularis.dev/wiki/data-grid

Hi everyone!

I wanted to share a quick update on Tabularis, a modern, open-source SQL client (PostgreSQL, MySQL, SQLite) built with Rust and Tauri.

If you work with JSON data inside relational databases, you know how frustrating it can be to read or edit it in standard tools. The latest update completely revamps the Data Grid to solve this.

What’s new with the JSON Viewer & Grid:

• Code, Tree, and Raw Editors: Choose how you want to inspect and modify your JSON data.
• Native Viewer Window: Opens heavy JSON structures in a dedicated, lightweight window.
• Auto-Detection: A new toggle automatically detects valid JSON inside plain TEXT or VARCHAR columns and activates the rich cell renderer.
• Inline Diffs: See clear, visual side-by-side or inline diffs of your pending changes before committing them to the database.

Other cool features:

• Virtualized Grid: High-performance rendering that keeps large result sets instant.
• SQL Notebooks: Mix markdown, SQL queries, and interactive charts.
• MCP Server Native: Let AI tools (Cursor, Claude) inspect schemas safely without credential leaks.

It's fast, local-first, and completely open-source.

• GitHub: https://github.com/debba/tabularis
• Wiki: https://tabularis.dev/wiki/data-grid

Check it out and let me know what you think!

For two decades the database could outsource trust to the application layer: humans authenticated users, sanitized inputs, reviewed every commit before it shipped. Agents don't fit that picture.

>

The app-as-perimeter model stops being true the moment an LLM holds a live connection to your DB.

I wrote a piece on this, and on how I handled it in Tabularis's MCP integration: read-only enforced at the connection (fail-closed), pre-flight `EXPLAIN` as the approval unit, append-only local audit logs, and session tracing you can export as a replayable SQL notebook:

https://tabularis.dev/blog/database-has-to-defend-itself-again

per @claudeai on X:

We’ve agreed to a partnership with @SpaceX that will substantially increase our compute capacity.

This, along with our other recent compute deals, means that we’ve been able to increase our usage limits for Claude Code and the Claude API.

Effective today, we are:

1. Removing the peak hours limit reduction on Claude Code for Pro and Max plans; and
2. Substantially raising our API rate limits for Opus models.

Read more at: https://www.anthropic.com/news/higher-limits-spacex

I manage quite a few GitHub repositories, both public and private, and I kept running into the same problem: GitHub has all the data I need, but accessing it quickly across many repos means jumping through a lot of pages.

So I built a small local web app for myself: a GitHub dashboard that pulls data from the GitHub APIs and gives me one place to filter, sort, and inspect everything.

It uses GitHub’s REST and GraphQL APIs for things like:

• repositories, issues, and pull requests
• repo metadata, languages, contributors, commits, and releases
• stargazers and forks
• GitHub Actions workflow runs
• traffic views, clones, referrers, and popular paths
• code/issue search for external mentions
• dependents and repository relationships where available

The app keeps GitHub API access server-side, so tokens are not exposed in the browser.

The goal is not to replace GitHub, but to make it faster to answer questions like:

Which repos need attention? Which PRs are waiting? Which issues are stale? What changed recently? Which repos are getting traffic, stars, forks, releases, or mentions?

It also has a repository detail view with tabs for Actions, PRs, issues, releases, forks, traffic, mentions, and dependents, plus simple charts for trends and traffic.

I originally built this just for my own workflow, but now I’m wondering if it might be useful to other people managing many repositories too.

Would it be worth cleaning it up and publishing it on GitHub, or is this probably too specific to my own use case?

A few weeks ago I caught myself doing the same chore for the third time:
opening 8 tabs (G2, Capterra, Reddit, GitHub Issues…), copy-pasting “what do you dislike?” into Notion, then trying to figure out which gaps my product already covers.

So I built GapHunter — a Claude Code skill that automates the whole loop:

• Scrapes G2, Capterra, TrustRadius, Reddit, GitHub Issues, Hacker News
• Deduplicates complaints semantically (no more “no dark mode” vs “lacks dark theme”)
• Reads your repo (package.json, Cargo.toml, source tree) to see what you already ship
• Outputs an interactive HTML report + JSON
• Includes:
  • Priority / Effort quadrant
  • Competitor comparison matrix (best opportunities)
  • Tags: priority, status (missing/partial/present), effort, trend
  • Even suggests which files in your repo to touch

Usage:

/gaphunter DBeaver
/gaphunter DBeaver TablePlus
/gaphunter Notion --sources-only

Built entirely inside Claude Code (prompt + ~2k lines HTML/CSS/JS + docs).
Kind of wild what you can ship in a weekend now.

Repo (MIT, screenshots, examples, install):
https://github.com/debba/gaphunter-skill

I’ve been working on Tabularis, an open-source desktop database client for Postgres, MySQL and SQLite.

It’s meant to be two things at once: a comfortable everyday SQL app (editor, notebooks, charts, visual tools) and a safe bridge for AI agents that want to read your schema or run queries, without you having to paste credentials into a chat.

Free, open source, runs locally. Would love your thoughts.

→ https://github.com/TabularisDB/tabularis

→ https://tabularis.dev