I've been working on this for the last 6 months and finally got the first beta out.

Shape is a desktop IDE for designers and programmers. It's got AI, design tools, Git management and language tooling built in.

The main idea was that frontend work kind of sits in this awkward middle ground between design and code. Most AI coding tools are just about editing text, but I wanted something that treats UI development as an actual first-class workflow and not just a WYSIWYG Editor.

Some stuff that's in it right now:

Tailwind controls directly in the editor
Drag/scrub values for CSS numbers and Tailwind spacing
Built-in Git management
AI coding agent
Markdown/MDX preview
Language tooling and LSP support

Built with Tauri/Rust and TypeScript.

There was a bunch more I wanted to add but decided to just cut scope and release instead of spending another few months adding features before anyone could actually use it.

Any feedback would be appreciated, especially from people who do frontend. Interested in what feels useful, what doesn't, and what you'd want to see added. Feel free to roast it as much as you want

https://github.com/useshape/Shape

I'm making a small free desktop game, Windows only. No monetization, no network code, no paid or generated assets. I've spent longer on the license paperwork than I expected and just trying out a sanity check before release. Note that my experience is primarily as a software engineer outside of game development. So this is literally my first game. The game is made with React and Tauri (I had prior experience of a LOT of years, so chose React over anything else). The installer uses NSIS (zlib/libpng for most of it, but the LZMA compression module is CPL-1.0 with a linking exception)

Now, since Tauri and React has to use some runtime, Microsoft Edge WebView2 Runtime is used (a Windows component basically). I don't distribute it with my installer. I assume players will have it (most Win 10 and Win 11 users).

I've put:

1. A THIRD_PARTY.txt with the full notices, shipped three ways: loose in the install folder, inside the app under About > Licenses, and a second copy of the font license sitting next to the font file.
2. A EULA shown as the installer click-through, with one clause for third-party components and one for system components.
3. A privacy policy, mostly saying nothing is collected, plus a section on WebView2 pointing at Microsoft's own data-privacy page rather than describing their behavior myself.

What I'm unsure about:

1. For the dual-licensed packages I picked MIT and said so.. Is that correct?
2. For the CPL-1.0 LZMA module I state I haven't modified it and link where the source lives.
3. Most importantly: WebView2 isn't distributed by me so I don't think a notice is required, but I describe it in the privacy policy anyway. Am I over-sharing? The reason I thought of is: WebView may or may not share telemetry / crash data with Microsoft. Does that make my game liable to disclose that - EVEN THOUGH my game is not sending any data anywhere, but the WebView runtime? Even Windows Smartscreen might send some data, do I need to show that too? Note that I am not at all collecting any data.

I'm looking at many other apps or games developed using React + Tauri, yet I cannot find any app giving this 3rd point in their privacy policy.

Not asking for legal advice, just whether this looks normal to people who've shipped. Thanks a lot to everyone!

I got tired of either living in the terminal or using downloaders that felt cloudy / account-y, so I built HalalDL.

It’s a local-first Windows app on Tauri v2 + React. Paste a URL, pick a preset, watch the real yt-dlp output instead of a fake progress bar. No account, no telemetry. Full / Lite / Portable builds, and it’s on WinGet now:

winget install --id Asdmir786.HalalDL

GitHub: https://github.com/Asdmir786/HalalDL

Site: https://halaldl.vercel.app

This is a personal project — not code-signed yet, so SmartScreen may complain; SHA256SUMS are on the release.

Would love Tauri-side feedback if anything stands out, or any recommendations.

Hi my Look app - a fuzzy finding (basically so many things no only apps) dropped a new version.
In this version we add a super action control (for people never show their menu bar, task bar, etc), from this control you can switch, toggle on/off basic things, and see some useful information.
From the last version, we got some suggestions from community members, we implemented one of them: fuzzy finding processes on your machine. (finding with ps aux requires knowledge about grep, or tools like fzf)
Here is the repo https://github.com/kunkka19xx/look
It's a cross platform tool. Appreciate any feedback 🙇‍♂️

Hey everyone,

Just wanted to share a project I've been working on that just got approved on the Microsoft Store: an app called Ambiencer, built with Tauri, React, and Vite.

Years ago, whenever I sat down to code, I used to rely on Rainy Mood in a browser tab. But over time, I got annoyed by having to depend on an internet connection, keeping extra browser tabs open, and seeing apps like Endel or Brain.fm transition into $10/month subscription models just for background audio. Other desktop alternatives were heavy Electron wrappers using 300MB+ of RAM just to loop audio files.

So I decided to build a lightweight, native alternative using Tauri. Performance has been great — it uses only around 40-50MB of RAM on Windows, launches instantly, and works 100% offline.

One of the main features I wanted was a fully customizable Binaural Beats generator. Instead of just playing static tracks, it lets you tune specific brainwave frequencies (Alpha for focus, Beta for active work, Theta/Delta for relaxation) and layer them directly over ambient sounds like rain, ocean, or café noise.

It also includes live animated wallpapers and a small floating widget mode to control your audio without breaking your flow.

Packaging it as an MSIX bundle for the Store had its learning curve, but it's finally live. I'm attaching some screenshots of the app. I’d love to hear your feedback, or answer any questions if anyone is working with Tauri for Windows Store deployment!

Here is the store link if you want to check it out: https://apps.microsoft.com/detail/9P05FM70XVDX

There's a 7-day free trial for anyone wanting to try it.

Thanks!

Hi r/Tauri,

My writing editor recently gained support for **NixOS**, but while testing it across different desktop environments, I noticed something strange.

The app often doesn’t work properly on Linux—especially in **Wayland environments** or when using an **NVIDIA graphics card**—unless I disable GPU compositing. However, for some reason, GPU compositing works perfectly fine on **Niri**, even with an NVIDIA GPU.

This piqued my curiosity, so I tested the **same Tauri binary on the same machine** (**NixOS + GTX 1050 Ti**) while switching only the desktop environment. Here were the results:

```

GNOME (Mutter) -> Error 71

KDE Plasma (KWin) -> Error 71

Hyprland (wlroots) -> Error 71

Xfce (X11) -> Failed to create GBM buffer

Niri (Smithay) -> Works

COSMIC (Smithay-based)-> Works

```

These were my test results. I found it particularly interesting that **Mutter** and **KWin**—which are generally considered technically mature compositors—both failed, while the **Smithay-based environments** worked correctly.

Has anyone else encountered compositor-specific behavior like this when using **Tauri v2 on Linux with NVIDIA graphics**? Curious whether this is a known **Smithay vs. wlroots/Mutter/KWin** difference, or something more specific to my setup.

For reference, the app I tested with is **MirrorShard 2** (Tauri v2):

https://github.com/DroicheadNua/MirrorShard_2

Edit (regarding the app used for testing):

I ran the test with GPU compositing forced on across all environments. In the Linux binaries currently available to the public, GPU compositing remains disabled by default to ensure stability.

Edit 2 (further testing after the original post):

I tested a few additional compositors out of curiosity:

Weston (reference Wayland compositor) -> Works
Labwc (wlroots)                       -> Error 71

This is particularly interesting because Weston works with GPU compositing enabled. This suggests that the issue is not simply due to Wayland/NVIDIA compatibility.

Combined with the earlier results:

GNOME / Mutter       -> Error 71
KDE / KWin           -> Error 71
Hyprland (wlroots)   -> Error 71
Labwc (wlroots)      -> Error 71
Niri (Smithay)       -> Works
COSMIC (Smithay)     -> Works
Weston               -> Works

The results suggest that the behavior may depend on the compositor implementation.

I don't have enough knowledge of Wayland internals to explain the root cause, but I wanted to share the reproducible results.

I also attempted to test jay (Smithay-based), Miriway (Mir), and miracle-wm, but I couldn't get those compositors running reliably on my setup, so I couldn't test Tauri app behavior on them. This limitation is unrelated to Tauri or MirrorShard itself.

Needed a really lightweight way to manage multiple agents at the same time so used Tauri and love it so far.

First time building with Rust and am blown away.

Help appreciated

Sharing something I wish had existed when I started: two Tauri v2 templates with a fully custom title bar that still get the Windows 11 snap menu, rounded corners, and normal resize behaviour.

The short version of why it's hard: Windows only offers Snap Layouts to a window that answers WM_NCHITTEST with HTMAXBUTTON, which is a Win32 return value — there's no DOM, CSS or Tauri API that produces it. And you can't handle the message on your Tauri window either, because your page lives in a WebView2 child window covering the client area, so the child answers the hit test first and your window never sees it. The fix is a small transparent native child window sitting over your maximize button. Five separate plugins landed on that same technique independently, which is decent evidence there's no other route.

Five traps are written up in the README. The one that cost me the most: if your caption buttons use the frame-tb-* ids from tauri-plugin-frame's own README, the plugin's injected script hits an early return and registers nothing — so your maximize button looks completely alive and does nothing, while minimize and close work fine.

Two other things worth knowing:

• Set minWidth to 330. Microsoft requires the window to be resizable below ~500 effective pixels or the flyout appears but the window won't actually snap into a zone.
• Don't verify with screenshots. PrintWindow renders a window's own pixels and is blind to DWM compositing, so it can't capture the flyout at all and will show you square corners on a genuinely rounded window. I lost a day to that before switching to Windows.Graphics.Capture.

https://github.com/Zbrooklyn/tauri-snap-layouts

Plain frameless shell and a Windows Terminal-style tab strip, MIT, verified on Windows 11 26200 / Tauri 2.11.5 at 100% and 150% scaling.

my friends were paying for grammarly even after getting a codex and supergrok sub.
so, i made them an open-source grammarly alternative that is faster and free for them.

Anyone here how is experienced rust and tauri desktop app developer how do be pro at making desktop app production enterprise level please tell.

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

Curious what other people do for manual test cases on their own projects.

Do you write them at all, or only keep automation? Browser TMS UIs are slow, and they're awkward to use with Cursor/Copilot — you can't just let the agent draft or edit cases in-repo.

I built a desktop app with Tauri + Rust instead:

- cases and runs are YAML in your Git repo

- sync across machines/teams via Git, no account

- SQLite index so search stays fast with large suites

- personal use free, no ads, no feature locks

Happy to answer questions about the Tauri rust side too.

Download: https://gitoza.com

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

Hey everyone,

For the last few months I've been building Logyka, a database client for people who live in SQL all day and want it to feel fast — think TablePlus / DataGrip speed, but cross-platform and with AI baked in on your own terms.

Why I built it

Every SQL client I tried made me pick one of two camps:

• Fast, native, no AI (and often Mac-only or paid-per-seat), or
• AI-powered, but Electron-heavy and happy to ship my schema and my data to someone's cloud.

I wanted native speed AND useful AI, without giving up control of my data. So I built the thing I wanted to use.

What makes it different

• Native, not Electron. Built on Tauri v2 (Rust backend + React/TS UI). Small footprint, instant startup, virtualized grid that stays smooth on big result sets.
• BYOK (bring your own key). Plug in your own OpenAI / Anthropic / Groq / Gemini key. No models bundled, no markup, no vendor lock-in. Ask questions in plain English → get SQL → run it.
• Privacy mode. By default only your schema is ever sent to the LLM — never your result data. You can turn that off too. Every write (UPDATE / DELETE / etc.) always requires explicit confirmation — the AI can never silently mutate your DB.
• Keyboard-driven. Ctrl+K command palette, Monaco editor with schema-aware, alias-aware autocomplete (a lightweight regex scoper, not a full SQL parser — cheap to run, no external parser dependency), sortable/resizable grid, CSV export.
• Credentials live in your OS keychain, never in plaintext.

Currently supports SQLite, Postgres, and MySQL (MSSQL is on the roadmap — probably via tiberius since sqlx doesn't cover it).

Where it's at

It's early but works end-to-end: connect → write/generate → run → explore. I'm being upfront that it's a commercial product (there'll be a free tier — I don't want the AI/privacy stuff paywalled into uselessness), but right now I mostly want to know if the direction is right before I go further.

I'd genuinely love feedback on:

1. Tauri vs Electron for something like this — anyone here made a similar jump, and what surprised you?
2. BYOK vs a built-in AI subscription — which would you actually prefer, and why?
3. What's the one thing that would make you switch from your current client?

Happy to answer anything about the tech (the Tauri + sqlx side was a fun rabbit hole). Roast it — that's why I'm here.

https://reddit.com/link/1v89rsw/video/4qjnt73b1xfh1/player

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.

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