Built a local-first writing editor using Tauri v2.

• 100% Offline Grammar & Proofreading: Powered by a local LanguageTool engine
• 15 On-Device AI Tools: Rewriting, tone shifts, summaries, and structured tables via local quantized GGUF models (llama.cpp)
• Ollama Integration: Auto-detects local Ollama instances or uses a bundled local model
• No Cloud / No Accounts: Everything stays strictly on your device
• Full Desktop Packaging: Compatible with Windows and Mac

GitHub: https://github.com/AashishH15/Lexicon

Website: https://lexicon-writer.pages.dev/

I built this because I wanted an offline Grammarly alternative where my drafts never touch a cloud server. Let me know what you think!

penna url

I'm working on a personal AI assistant for desktop — local-first and privacy-focused (no cloud dependency), starting with a desktop app and eventually

Runtime Of Backend (Bun)

Fast startup and low idle overhead — important for an app that runs continuously in the background, not just on-demand. Native TypeScript support and a built-in bundler simplify shipping without extra tooling.

Framework of Backend (Hono)

Lightweight and built with Bun in mind, so it doesn't add framework overhead on top of the runtime's own performance. Clean routing/middleware model keeps things simple for handling auth, commands, and local model inference.

Desktop Application (Tauri + Next.js)

Tauri has a much smaller footprint than Electron since it uses the OS's native WebView instead of bundling Chromium, which makes it great for lightweight apps that stay running. It also produces smaller binaries. Next.js provides a structured, file-based routing system and a strong component ecosystem for the UI.

Would love to hear reviews and suggestions on this stack — anything you'd change, any pitfalls you've run into with a similar setup, or better alternatives worth considering?

I started Tabularis as a one-person project, with the goal of shipping the same database client on Linux, macOS and Windows.

Tauri turned out to be the right choice, but the reasons go beyond small installers. The Rust backend fits database protocols, SSH tunnels, credentials and plugin processes very well. The web frontend makes Monaco, data grids and diagrams practical.

There are real costs too: three system webviews, Wayland and WebKitGTK bugs, a 94 MB AppImage, glibc compatibility and JSON serialization across IPC.

I tried to document both sides without turning it into another “Tauri vs Electron” comparison. I would still choose Tauri again.

I’d be especially interested in hearing how other Tauri developers handle large IPC payloads and portable Linux builds.

Gilbert Rift is a desktop workspace for turning an idea into finished work without constantly jumping between an AI chat, terminal, project browser, task tracker, messages, and team tools. Work sessions stay grounded in a real project and keep the model, permission level, files, tool activity, progress, and follow-ups visible in one place.
https://github.com/UrbanWafflezz/GilbertRift

I wanted to get some practice writing code with AI, and at the same time, I was curious about Tauri and the actual process of publishing an app (installers, Winget/Scoop, app store review). That’s how QuiverKit came about.

62 tools developers use throughout the day: Base64, JWT, hash, regex, JSON/YAML, color tools… They all run entirely on your device—no uploads, no accounts. There’s a web version, as well as a native desktop app for Windows and Linux. Only one tool (DNS) needs to query a server, and that’s clearly labeled.

It’s a learning project or side project, not a startup—so please be honest about what it’s good for, what’s missing, and what doesn’t work.

https://quiverkit.dev

https://github.com/ensardev/quiverkit

Hey everyone,

I built Swift Tunnel because I had a problem I couldn't solve with existing clients.

I use sing-box based configurations daily, but TUN mode was always the painful part.

Sometimes:

• routing didn't behave as expected
• some apps bypassed the tunnel
• DNS handling was inconsistent
• reconnecting could break networking

After spending too much time debugging and switching between clients, I decided to build my own.

Swift Tunnel is a Linux desktop client built with Rust + Tauri and powered by sing-box.

The goal was simple:

Make TUN mode feel reliable and easy to use.

Features:

• Native lightweight desktop app
• Rust + Tauri architecture
• sing-box powered
• VLESS / VMess / Trojan / Shadowsocks / Hysteria2 / TUIC / WireGuard support
• Import configs from links, QR codes, subscriptions
• TUN mode
• Proxy mode
• Latency testing
• Kill switch
• Local configuration storage

This started as a personal tool, but I thought other people fighting the same problems might find it useful.

Looking for feedback from Linux users and people using sing-box/Xray setups.

Website:
https://swifttunnel.site/

I released Verascope, a cross-platform desktop app for reading and validating C2PA Content Credentials locally.

The premise is simple: provenance verification and AI detection are different problems, so the app does not collapse them into a “real/fake” answer.

For every image, video, or audio file, it reports one of three states:

- Verified: a provenance manifest is present, valid, and chains to a trusted issuer in the bundled trust list.

- Untrusted or Broken: a manifest is present, but validation failed.

- No Provenance: no manifest was found. This is not evidence about the file’s origin; many genuine files have no provenance metadata.

The core verifier is offline by design. It does not upload files or fetch remote validation data. The C2PA HTTP resolver backends are disabled at compile time, and the trust list is bundled with the application.

Tech stack: Rust, c2pa-rs, Tauri v2, React 19.

The image heuristic panel is separate from the C2PA verdict and explicitly non-authoritative. It needs calibration work before it should be interpreted beyond rough image-artifact triage.

Repo and installers: repo

I would especially value feedback on C2PA edge cases, test fixtures, offline trust-list handling, and Rust/Tauri architecture. There are also labelled good-first-issue and help-wanted tasks for contributors.

I’m building Grok Build Desktop, an Apache-2.0 local-first coding agent, and Tauri 2 is the boundary that lets me keep the desktop UI deliberately untrusted.

The React WebView only submits user intent through allowlisted, typed commands. The Rust host owns: - canonical project paths and bounded context - local Ollama requests and capability checks - terminal PTYs with explicit approval - Git worktrees and exact hunk review - session persistence and process recovery

This separation has been useful because model output, repository content, and tool arguments all need to be treated as untrusted input. The current build is verified on macOS and still distributed from source while I finish write-capable routing and conflict handling.

GitHub and architecture docs: https://github.com/gallifre/grok-build-desktop

For people shipping larger Tauri apps: what pitfalls have you encountered around long-lived child processes, app-data migrations, or capability scoping when adding Windows and Linux support?

From 100 MB to just 6 MB, that is absolute happiness for github and users, app just feels and is faster that it has ever been, see it in action at https://container-desktop.com

It's been a while since I last posted here about Tabularis, an open-source desktop SQL workspace built with Tauri (Rust backend + React frontend). A lot has happened since, so here's an update.

Some numbers since launch (Jan 2026):

• ⭐ 3,700+ stars, ~250 forks
• 📦 41,000+ release downloads across macOS, Windows and Linux
• 👥 ~60 contributors, 1,400+ commits
• 🚀 Latest release: v0.15.0 (July 14) + nightly builds now available

What it does:

• Supports PostgreSQL, MySQL/MariaDB, SQLite and 13+ more databases like DuckDB, ClickHouse, Redis and Firestore, via a plugin system for drivers (separate Rust processes speaking JSON-RPC over stdio)
• Built-in MCP server so Claude, Cursor or Devin can talk to your databases safely
• SQL notebooks and visual EXPLAIN
• SSH tunnels, session restore, multi-window

Big things that landed recently (v0.13 → v0.15):

• Open a connection in a dedicated window — proper multi-window support in Tauri
• Stored routine management — run, create, edit and drop procedures/functions, with plugin support
• PostgreSQL materialized views support
• Connection export with optional password encryption, multi-select and nested connection groups
• Typo-tolerant fuzzy search across the Quick Navigator, sidebar filters and connection search
• A dedicated SSH connections settings tab, with tunnels cleaned up properly on app exit
• ENUM editing with dropdowns on both MySQL and Postgres
• Accessibility pass for screen-reader users
• Nightly builds, and Linux builds now target a lower glibc baseline (built in ubuntu 22.04 containers)

Tauri-specific lessons along the way: spawning plugin processes on Windows without flashing console windows, keeping SSH tunnels alive across the app lifecycle and tearing them down cleanly on exit, and managing session restore across multiple windows. Happy to go into detail on any of these if anyone's curious.

Everything is free and open source.

Github project: https://github.com/TabularisDB/tabularis

Website: https://tabularis.dev

Feedback and contributions are very welcome!

Hey r/tauri,

I have been building Grayslate, a free and open-source developer scratchpad made using Tauri, Rust, Svelte 5, and CodeMirror.

I started building it because I always had some temporary file open for one thing or another. It could be an email draft, a Slack message, a prompt, a code snippet, an installation command, or an API response that I wanted to inspect.

I was using Boop (Mac App) for transformations, but it started feeling slow when the input became larger. Even a JSON file with around 1,000 lines could sometimes be frustrating to work with. I also wanted a tool that would save what I pasted, so I could find it again later instead of losing it after closing the app.

With Grayslate, you can paste almost anything and start working. It detects the content type, suggests a filename and extension, and automatically saves it as a slate. You can later search using both the filename and the file content.

Some features currently available:

• 80+ local transformations for JSON, CSV, Base64, hashes, text cleanup, timestamps, formatting, and more
• A Rust-backed virtualized CSV table that can handle hundreds of thousands of rows
• Tested with CSV files larger than 100 MB
• JSON shortcuts to copy a key, value, or full path
• Live Markdown preview
• Automatic detection for more than 40 languages
• Multiline find and replace
• Search across saved scratch notes

Tauri was a good choice for this because I wanted a small cross-platform application that uses the system webview. I could also move heavier work like CSV handling, transformations, search, Markdown rendering, and large-file operations to Rust.

On my machine, Grayslate generally uses less than 150 MB of memory while idle.

Over time, it has become a collection of small developer tools that I personally wanted in one place. This includes Rainbow CSV-style viewing, copying JSON paths and values, content-aware transformations, automatic file naming, and the ability to find an old command or draft after a few weeks.

Website: https://grayslate.app

GitHub: https://github.com/shriram-ethiraj/grayslate

It is available for macOS, Windows, and Linux.

I would genuinely appreciate any feedback, especially bug reports, performance issues, or feature requests.

There's been some ... debate here on how many markdown editors the world needs. I got an honorable mention in the thread "Enough with the markdown apps already" 😅 Still, I'm genuinely pleased with my app and truly enjoy working on it.

This is not a weekend project. The changelog is on Github. I took my time iterating and polishing, and using it myself.

Yesterday I finally released v1.0. And after that release comes the dreaded self-promotion phase. So here we are, in another Reddit post...

Favorite features

The entire notebook is stored in a single .nokta file. No cloud, no account. It's local only. The app state persists in the (SQLite) .db between sessions, so never worry about unsaved changes.

In folder mode, it shows all .md and .txt files in a folder and lets you edit them code-editor style.

An MCP server let's you collaborate with AI directly in your notebook (read and write in live mode or read from any .nokta file). Genuinely useful!

Flexible import/export: save a folder to a single nokta file or export a notebook as separate markdown files.

Other features:

• Simple, clutter free markdown editor
• Drag-and-drop notebook manager
• Full-text search
• 8 configurable note flags
• Publish to GitHub or a webhook with configurable frontmatter

Stack

• Tauri 2.0
• React 18, TypeScript, Vite
• Zustand, Styled-components
• Editor: Lexical
• SQLite (WAL) + FTS5, via tauri-plugin-sql
• .nokta file format: ZIP-container (fflate) with JSON content
• MCP server: Rust
• Secrets in OS keychain (keyring)

If this sounds interesting, I'd love to hear what the Tauri builders think! Available for Windows and Linux

https://noktanotes.badgersoft.nl/

I made A GUI app in tauri rust for warp-cli and did not know there is two one official and nonofficial .

The App is Great tho fast and it do the job and shi like that i made it in 3 hours drawing ideas and coding it
The App is basic colors look like the Phone one
But the fun part is The Config file u can for now Configure Css inside of config.mcfg file

.mcfg is minimal Configuration Parser i Wrote in 20 min

https://github.com/obitoc/warp-gui
This is the first Version of The App in future ill enhance every thing and add Js Script Loader and shi like that

Ordinary Tauri 2/WebView2 presentation on Windows is already a documented architectural mismatch: WebView2 renders through separate browser/GPU processes, while Steam expects to hook a game-owned graphics presentation path.

Our own Tauri 2.10.0 + Rust steamworks 0.13 result show this. Steam initialization, identity, non-overlay callbacks, restart, and Cloud work. A Steam overlay store request can be issued, but neither it nor Shift+Tab visibly renders over WebView2. We therefore retain Tauri and use the known authenticated Steam-client URI fallback rather than pretend the Steam overlay works.

WebView2 issue #547 now contains examples using CompositionController plus Windows Graphics Capture to obtain RGBA/D3D content, while Valve describes offscreen browser rendering into a native game-owned surface. A comparable Electron library now uses capturePage() plus a native OpenGL/Metal window so Steam can hook that surface.

Has anyone integrated the WebView2 CompositionController/Graphics Capture route with Tauri or Wry in a production Windows app and then presented it through an opaque native D3D/OpenGL swapchain that Steam Overlay can hook?

If so, I would value concrete details on:

1. Tauri, Wry, WebView2 Runtime, and Windows versions.
2. Whether pixels stay GPU-resident or cross a CPU buffer on every frame.
3. Measured latency, CPU/GPU/power cost at 4K and high refresh with animated content.
4. Pointer, keyboard, IME, controller, accessibility, focus, DPI, resize, fullscreen, and Alt+Tab handling.
5. Whether Steam's overlay alpha/composition behaved correctly and survived repeated open/close cycles without stale frames.
6. Packaging and maintenance costs compared with using CEF offscreen rendering or keeping the authenticated Steam-client fallback.

This would be a custom native compositor, not a Tauri flag or WebView2 configuration fix. If nobody has production evidence, that negative result is useful too.

A few days ago I shared SiphonDB here and received a lot of valuable feedback.

Yesterday I finished implementing several of the most requested features:

• Encrypted password storage for database and SSH connections
• A new SQL editor with syntax highlighting, line numbers, and auto-complete
• Query History
• Saved Queries
• Search, inline filters, and sortable columns in the data preview
• Database ER Diagram to visualize table relationships

These changes make SiphonDB much more practical for day-to-day database management while keeping it lightweight and cross-platform.

I'm continuing to improve it, so if there's a feature you'd like to see in a modern database client, let me know.

GitHub: https://github.com/Premod1/SiphonDB

So working on a an image app I can drag and drop into the image drop zone. But I want to apply a filter like the gray, sepia which work but I can’t preview sharpen or blur. Is that a limitation of WebKit?

I use Tauri and it is amazing, but writing the Rust backend takes too much time. Are there better options that use an easier language with a WebView for the UI? Don't tell me Electron.

I’ve been building CodeDeck, a local-first desktop app for managing development projects from one place.

It lets you:

• organize local projects
• open projects in different IDEs and terminals
• run commands with live logs
• view Git status and branches
• start complete development setups

The app is built with Tauri, Rust, React and TypeScript. Everything runs locally, with no account or cloud service required.

I attached a short GIF showing the current workflow.

I’d especially appreciate feedback on the UI, native integrations and cross-platform behavior.

GitHub: https://github.com/JadnK/CodeDeck

Hey 👋, I've just open sourced one of my tauri app, it's still in active development. It's a simple command palette to manage your interaction with GitHub. I was tired of having many GitHub tabs open. It's currently only available on OSX but I'm planning to release versions for others OS as well. https://gitpal.pushpull.sh/

Repository: https://github.com/fkhadra/git-pal

Hope you'll like it.

I built a full featured local-first agentic harness with multi-tier memory architecture for long term persistence, user customizable Personas with swappable tool profiles, project management, skills, Andover 60 preinstalled tools. Full description on GitHub. If you like what you see, please leave a star. Thanks for checking it out.
https://github.com/Bino5150/lumina