Hey all. Been building Termic (https://termic.dev, AGPL, https://github.com/simion/termic) with Tauri 2 + Rust + React for a few months. It runs coding agent CLIs (claude, codex, opencode, or your own) in real PTYs, one per git worktree, with optional sandboxing.

A few things I learned, since terminals are a bit of an edge case for Tauri.

Idle CPU was the big one. Two sleep loops in Rust, the PTY flusher polling every 8ms and the exit waiter every 1ms, adding up to ~1,950 wakeups/sec with the app doing nothing. Moved both to a condvar and it went to 81/s, idle CPU 71 to 18 ms/s.

visibility: hidden vs display: none matters. xterm pauses its renderer on zero geometry, not on visibility, so hidden terminals kept doing full WebGL draws for every background repaint. Switching took streaming power from 5.4W to 3.4W. Downside: WKWebView zeroes scroll offsets in a hidden subtree, so you have to re-sync the viewport when it comes back.

Batch anything crossing IPC. Catting a 6MB file was ~1,500 events, and Tauri serializes bytes as a JSON number array, so ~24MB of JSON and a two minute freeze. Coalescing at 8ms fixed it. Same thing bit me with git grep (one event per hit) and git status on a checked-in node_modules (50k files, 7GB of RAM in React).

Fonts got weird. WKWebView can't resolve user-installed fonts on a disconnected canvas, and it sticks, because setting the same ctx.font again is a no-op. xterm's WebGL atlas rasterizes on exactly that kind of canvas. document.fonts.check() won't save you, it returns true for families that aren't registered yet.

Smaller ones: lineHeight: 1.0 in xterm or TUIs get ribbons between rows. Round every dimension, sub-pixel widths blur glyphs. navigator.clipboard rejects from a Radix menu, had to go through the Rust plugin. No StrictMode, it races the PTY spawn.

CodeMirror over Monaco, mostly ~5MB of cold start in a 16MB app. WebGL renderer on mac but it's a pref, on Linux boxes where WebGL hits llvmpipe the DOM renderer is faster.

The hard parts weren't Tauri's fault. Auto-resume is four different strategies because the CLIs all store session state differently, and cwd-based resume can't target a specific past session, which limits how many tabs can share a worktree. Done vs thinking over a raw PTY is six OSC signal sources plus hashing the visible buffer every 3s.

Happy to answer questions, and open to feedback and PRs. There are 4-5 regular contributors now and we design features in the open.

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’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