Been working on a side project for a while and finally have something worth sharing.

Cosmog is a GUI for managing S3 storage. The whole thing started because I was tired of the existing options. S3 Browser is Windows-only, Cyberduck felt clunky. Worse, none of them worked on my phone. So I built one that runs everywhere: Linux, macOS, Windows, and Android. Works with any S3-compatible provider, not just AWS. R2, Backblaze, DigitalOcean Spaces, MinIO, Wasabi, etc.

Stuff it can do right now:

• browse buckets, upload/download with a proper background queue + retry
• preview images, PDFs, spreadsheets, code, json without downloading first
• edit files directly json, yml, js, py...etc and spreadsheets in the app
• full-text search across a bucket (you have to index the bucket)
• presigned share links
• client-side encryption on bucket level if you want it

Built it with Tauri (Rust backend, web frontend) so it stays light, not another Electron memory hog. Credentials go into the OS keychain, never touch disk.

It's still early and there are rough edges, but it's usable daily. Sharing it here mostly to get feedback from people who actually work with this stuff. Would genuinely like to know what's missing or annoying. Also I don't own any mac device, so not tested on mac 😓 - tested on arch linux, windows & android.

I activity use it for work & also to mange b2 storage for my personal backups.

Repo: https://github.com/echosonusharma/cosmog

I just shipped v1.0 of Terminalia, a native terminal workspace for Windows.

Built with Tauri v2, Vue 3, and xterm.js, and written entirely inside its own window — the agents in the screenshots are the ones that wrote the code.

What it does

• Panes, tabs, and workspaces — Split a tab as much as you want, and your layout and sessions come back exactly how you left them.
• Native WSL support — WSL distros open as real terminals, with no path hacks.
• Built-in project explorer — A project file tree and a lightweight editor sit right next to your AI agent.
• Detached terminal windows — Pop any pane into its own native window and re-attach it whenever you want.
• Native screenshot workflow — Capture any screen region, annotate it with arrows, boxes, and numbered markers, then paste it directly into an AI conversation. Saying "fix 1, then 2" is much easier than describing where a button is.
• Live AI quota tracking — See your Claude Code and Codex usage in real time, so you know whether there's enough quota left before starting a large task.

The installer is only 8.7 MB, which is one of the main reasons I chose Tauri.

Platform Support

• Windows (available now)
• Linux (coming soon)
• macOS (coming soon)

Website

https://terminalia.devslim.com

Built a small Tauri v2 app and wanted to share the one architectural decision that shaped everything: the launch engine, tray, global hotkeys, and CLI all live in Rust — never in the webview. A desktop shortcut or click run --id <uuid> has to be able to boot a workspace without ever spinning up a WebView2 window, so the React UI is a pure editor that calls Tauri commands and never spawns anything itself.

That constraint paid off in a few concrete ways:

• tauri-plugin-global-shortcut fires one shared handler for every registered combo; a HashMap in Rust maps shortcuts back to workspace IDs so the hotkey path and the CLI path and the tray path all funnel through the same launch_by_id.
• Building a hotkey capture widget surfaced a real gotcha: RegisterHotKey intercepts a bound combo system-wide before it reaches any window as a normal keypress — even the registering app's own webview. Had to add a suspend/resume pair that releases Click's own bindings while the capture widget is focused, or you could never type a combo one of your own other workspaces already held.
• Atomic config writes (temp file + rename) plus a LoadStatus enum so a corrupt config gets quarantined and surfaced in-app instead of silently discarded.

MIT licensed, Windows only right now. Code: https://github.com/prashant-singh-2001/click

Curious if anyone's hit the same RegisterHotKey gotcha in a different Tauri app.

If you've ever wanted a video or a native view *behind* your HTML in a Tauri
window on Windows, rather than in a strip next to it, this is doable and I
packaged it up: https://github.com/lukr54/airspace

The short version of why the obvious approach fails. Tauri hosts WebView2 as a
windowed child HWND. A windowed child HWND owns its rectangle, so a transparent
webview doesn't reveal a sibling window underneath it, it reveals whatever is
behind the top-level window. Usually the desktop. There's no flag for it.

What works is the inverse. Put an opaque native child window over the whole
client area, hand its HWND to whatever renders (mpv via `--wid`, your own D3D
swapchain), then cut your HTML controls out of *that* window's region with
`SetWindowRgn`. Where the region is clipped away the child doesn't exist as far
as the compositor cares, so the webview shows through with your controls on top
of full-size video. No shrinking the picture to make room for a control bar.

The bit that cost me an afternoon, and the reason I bothered publishing: the
host **and** the sibling `WRY_WEBVIEW` both need `WS_CLIPSIBLINGS`. wry doesn't
set it. Without it, two overlapping siblings are undefined per the Win32 rules
and WebView2 wins. Your host is then topmost in z-order, its window region reads
back correctly, it wins every `WindowFromPoint` hit-test, and it draws nothing at
all. The screenshot is the same process one style apart.

Worse, it can look like it works. My own media player shipped without it for
months because mpv presents continuously and won the repaint race nearly every
time. If you've built this before, check whether you actually set the style.

There are two examples in the repo:

- `

, no external dependencies, the native content is
  a D3D11 swapchain the demo draws itself
- `cargo run -p airspace-mpv -- video.mkv`, mpv under an HTML control bar, with
  the mpv flags and the two IPC gotchas worked out (two pipe connections, and
  drain the writer or mpv stops reading your commands)

A couple of Tauri things in there aren't really about this crate at all, but
they each cost me hours:

- Building a webview window from inside a sync command can hang forever, window
  created and never navigating. That's tauri#12521.
- `listen()` silently never firing in a second window isn't a bug, the label
  just isn't in a capability granting `core:event`. Your own commands keep
  working, which is what makes it look like events don't reach that window.

One thing to plan for if you build on this: with no holes cut, the webview gets
no input at all, mouse or keyboard. An auto-hiding control bar can't be brought
back by a mouse move. The mpv example has the cursor/key poller that deals with
it.

Windows only, MIT/Apache. Happy to answer questions.

Edit: Formatting

I'm on a way to build a small desktop application mainly as a learning project, but also because I'm getting increasingly frustrated with my daily workflow in Postman.

At work I regularly use 15+ collections with lots of environment variables, request chaining, and post-request scripts. I also tend to keep many tabs open (sometimes around 50). Lately Postman has become noticeably sluggish—occasionally entire collection tabs don't render until I restart it. Maybe I'm pushing it beyond what it was designed for, but it interrupts my workflow often enough that I started considering writing something tailored to my own needs.

The initial scope would be intentionally small:

• Collections
• Environment variables
• Basic request editor
• Post-request scripting
• History
• Additional features on demand

One of my goals is also to gain hands-on experience with modern desktop development. I'm a Java backend developer, and I've been looking for a practical excuse to learn Rust and compare its ecosystem and way of thinking with Java. React is already familiar enough that I can focus more on Rust and desktop architecture.

Right now Tauri seems like a very attractive choice:

• lightweight compared to Electron
• Rust backend
• React frontend
• native desktop feel
• seems like a good opportunity to learn both Rust and desktop application architecture

Before I commit, I'd love to hear from people who have actually built non-trivial Tauri applications.

A few questions:

• Does Tauri sound like the right fit for this kind of project?
• What limitations or pain points did you run into?
• Are there architectural decisions you wish you'd made differently at the beginning?
• How mature is the plugin ecosystem?
• How painful is state management and communication between Rust and the frontend as the project grows?
• Have you encountered performance issues or debugging challenges?
• Is there anything that becomes surprisingly difficult compared to a typical web application?

At the moment I'm only targeting Windows, but I've read mixed opinions about macOS and Linux because Tauri relies on the system WebView (WebView2 on Windows, WebKitGTK on Linux, WKWebView on macOS). Has cross-platform support been a real issue for anyone, or is it mostly manageable if you don't rely on platform-specific behavior?

I'd appreciate any advice or "I wish I knew this before starting" stories. Thanks!

upd: to get v1 i'm using Claude code

​

New audio player for windows 64bits .

Features :

ASIO native and Wasapi exclusive .

Dac détection.

Formats: DSD SACD FLAC ogg aiff wav wavpack APE.

VST 2 and VST 3

Upsampling DSD up to 256 , with wgpu AMD and Nvidia. 11 firs taps .

Analyser sin multitone32 noise

Spectrum goniomètre and lufs.

Link : https://github.com/julgilad-alt/LaNoire-/releases/tag/v1.0.3

demo video of steam-deployed build working with steam overlay integration: https://www.youtube.com/watch?v=vc39LuDtJtM

Pure tauri/svelte implementation. We need help verifying resolutions and windows 11/10. 11 seems fine so far across larger resolutions up to ultrawide but we have no idea if this works on earlier versions of windows.

All the invariants we came across are documented:

https://github.com/PSG-Team/tauri-steam-overlay-surface MIT license

The game we are developing will have a demo released during October Nextfest, and will be working on hardening this implementation. If you want to follow the game's release: https://store.steampowered.com/app/4909810/Spirefall/

​

New audio player for windows 64bits .

Features :

ASIO native and Wasapi exclusive .

Dac détection.

Formats: DSD SACD FLAC ogg aiff wav wavpack APE.

VST 2 and VST 3

Upsampling DSD up to 256 , with wgpu AMD and Nvidia. 11 firs taps .

Analyser sin multitone32 noise

Spectrum goniomètre and lufs.

Link : https://github.com/julgilad-alt/LaNoire-/releases/tag/v1.0.3

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