TuxCleaner is a free, open-source Linux toolkit that combines system cleanup, application uninstalling, disk analysis, project artifact removal, and system monitoring in a single terminal app.

I took a lot of inspiration from Mole for macOS, which I really appreciate, while implementing the Linux-specific cleanup rules independently.

Key features:

• Deep cleaning: removes known system, user, browser, developer, package-manager, Docker, and Flatpak leftovers
• Application uninstaller: finds explicitly installed desktop apps and Flatpaks, previews the removal transaction, and preserves user data
• Disk and project insights: finds large personal files and old artifacts such as node_modules, target, build, dist, and .venv
• System status: displays CPU, memory, disk usage, load, and uptime
• Safety-first workflow: includes dry-run support, explicit confirmation, protected paths, and operation history

It currently supports Arch, Debian/Ubuntu, and Fedora/RHEL-based distributions.

TuxCleaner is still an MVP, so feedback, bug reports, and contributions are very welcome.

GitHub: https://github.com/debba/tuxcleaner

I got tired of running the same ritual every few months (paccache, docker prune, digging through ~/.cache, hunting for that 8GB ISO I forgot about), so I turned it into a Claude Code skill.

You run /free-my-arch and it goes through four strict phases: scan, report, confirm, clean. The scan is read-only, no sudo, and nothing gets deleted until you've explicitly confirmed it.

What it looks at:

• pacman cache, AUR helper caches, orphan packages, journal, coredumps
• user and app caches (~/.cache, thumbnails, trash)
• dev caches: pip, cargo, npm/pnpm/yarn, Go modules, plus node_modules folders in projects you haven't touched in 30+ days
• Docker dangling images and build cache, unused Flatpak runtimes
• personal files above a size threshold (default 500M, configurable: /free-my-arch 1G)

The part I spent the most time on is the confirmation model. Caches get confirmed per group, but personal files are picked one by one, and the skill never recommends deleting your own data. It just surfaces it. Docker volumes are excluded from the group clean entirely and get their own explicit question, orphan packages show the full list before removal, and things like VM images or Thunderbird mail stores are flagged separately with a warning instead of being mixed in with regular files.

There's also a hardcoded do-not-touch list: dotfile configs, browser profiles, the pacman database, anything inside .git. And it keeps one cached version of each installed package by default instead of wiping the whole cache.

At the end you get a before/after df comparison so you can see what it actually freed.

Repo: https://github.com/debba/free-my-arch

Feedback welcome, especially if you can think of a category it should scan that it currently doesn't.

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