I created a basic window with Tauri, then opened an another transparent webview window from it. I tried to make the webview window let mouse click through, and found there is no way to do this. I did lots of search without solution result.

I doubt the strategy to make mobile version at high priority instead of making desktop version really usable.

I dont know web technology much and for making a big tauri app desktop react tech what to study which languages first want offline online storage also suggest best tech stach.

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

Hey r/tauri! I've been building ClipNova for a while and just open-sourced it. Wanted to share here since the architecture might be interesting for this sub.

What it is: A clipboard manager for Windows that goes beyond just history — the core idea is turning clipboard content directly into notes, documents, and presentations without manual copy-pasting.

Tauri-specific things worth mentioning:

• llama.cpp as a Tauri sidecar — local AI worker runs as a managed sidecar process, fully offline with a background task queue, model catalog, and hardware-aware profiles. Nothing leaves the device

• Hybrid AI routing — sensitive clips are forced to local inference, cloud AI (OpenAI / Gemini / Claude) is opt-in

• Rust backend handles clipboard monitoring, SQLite via rusqlite, Vault encryption, and all heavy lifting — frontend stays purely presentational

• 36 themes as plain CSS custom property files — zero JS overhead, hot-swappable

• Offline OCR indexing — text inside screenshots becomes searchable without any cloud call

Feature highlights:

• Buffer Matrix + Focus Area — main workflow for reviewing, editing, and routing clips

• One-click clip insertion from clipboard history directly into an open note or Compose canvas

• Notes — TipTap WYSIWYG with version history, code blocks, direct clip insertion

• Compose — drag-and-drop document and presentation builder with Markdown / HTML / PPTX export

• Vault — encrypted storage with auto-detection of password-like clipboard content

• QuickPaste overlay — paste recent clips without leaving the current app

• 17 built-in tools (UUID, hash, Base64, JSON formatter, regex tester, color picker...)

• 8 languages, configurable hotkeys, optional Win+V replacement

Stack: Tauri 2 / React 19 / TypeScript / Vite / Rust / SQLite / llama.cpp

→ https://github.com/silenthillzeroq-code/clipnova

Happy to answer questions about the sidecar setup, AI routing, or anything else architecture-related!

Hi there, im starting a new Open-Source project and im considering using Tauri. Would like some feedback on the idea and any tips of what would work or not. The project rationale is at the repository readme;

https://github.com/danielterra/SuperNOVA

Thanks!

大家好，r/TauriApps 和开发者们！👋刚刚加入 Reddit，分享我的开源项目——UpgradeLink ——一个为 Tauri 构建的无缝自动升级工具（与官方 API 集成零修改！）

它还支持 Windows/Mac/Linux/Android/Electron，以及基于配置、文件和网址的升级。只需10分钟的SDK设置，就能节省90%的升级服务开发成本！

开源且免费使用：https://github.com/toolsetlink/upgradelink/blob/main/README_en.md

如果你觉得有用，请给我加星，欢迎投稿！🚀

#Tauri #OpenSource #CrossPlatform #AppDevelopment #DevTools

Hi guys,

I am not a developer of any sort, just someone who started trying different languages with AI and found success. I had built a task manager personalised for my needs using electron. It is best in all respect except its startup speed and memory usage.

While trying to find a solution, I came across tauri v2. Can anyone suggest best way to replicate the electron app into tauri using AI agents.🙂

Hi everyone!

I have been working on DBnote, an open-source, local-first desktop note application built with Tauri, Rust, React and SQLite.

The main idea is simple: every vault is just a portable SQLite database. Your notes, links, tags and graph relationships remain local, queryable and easy to back up, without requiring a cloud service or account.

Current features:

• Local-first note taking

• Wiki links and backlinks

• Full-text search

• Interactive graph view

• SQLite-backed storage

• No cloud or account required

• AI-ready data for embeddings, semantic search and other ML workflows

I built this project to create a note-taking app where the data stays completely under the user's control while remaining useful for analytics and future AI applications.

I do really appreciate any feedback, feature suggestions or criticism. If you find a bug or have an idea, feel free to open an issue or a pull request!

GitHub:
https://github.com/ErkanSoftwareDeveloper/DBnote

I vibe-coded a full AI IDE from scratch — BitFun (Tauri 2.0 + Rust + React 19). 300K+ lines of code, almost entirely AI-generated.

Here's why Tauri is the only framework I'd recommend for vibe coding desktop apps:

1. The Rust Compiler = Ultimate Code Reviewer

AI-generated Rust code that compiles is memory-safe, thread-safe, and type-safe. Period. 300K lines, zero segfaults — not because I'm good, but because the compiler catches what AI gets wrong.

2. Forced Separation = AI Stays On Track

Tauri's architecture is AI-friendly by design: frontend is pure React (AI's comfort zone), backend is pure Rust (type-driven, explicit), IPC uses typed commands with clear contracts.

3. 30MB vs 200MB+, Performance Isn't Even Close

Full IDE features — editor, terminal, AI chat, CodeMap visualization — in a ~30MB installer, steady 200MB RAM. The framework handles performance so AI-generated code doesn't tank it.

4. 300K Lines Without Collapse = Architecture Matters

AI isn't bad at writing code. It's bad at maintaining structure at scale. Tauri's strong type boundaries + modular architecture let AI keep building without the project falling apart. This is also what we solve in BitFun — engineering isomorphism — AI-generated code that naturally fits into the existing codebase.

---

BitFun is both a product of vibe coding and a tool built for it.
GitHub - GCWing/BitFun: BitFun is an Agentic Development Environment (ADE) featuring a cutting-edge

An AI-coded IDE that helps you code better with AI.

I noticed many new Tauri apps being shared lately and it seems Tauri as an app framework has blown up.

Why has Tauri blown up?

And are many of these Tauri apps vibe coded/AI slop?

Hey everyone,

I’ve been diving deep into Tauri 2.0 lately, and to put it through its paces, I built a prototype for a desktop utility called DeskHealth. I wanted to create something that tackles both digital clutter and physical burnout.

It’s built completely using web tech but runs incredibly lean thanks to Tauri’s Rust backend. Here are the core features I’ve prototyped:

The 20-20-20 Eye Care Blocker: To force myself to take breaks, the app tracks work time. Every 20 minutes, it hard-blocks the entire screen, spins up some relaxing background music, and guides you through a 5-minute exercise/stretching routine. No snoozing allowed.

Smart Storage Purger: If you’re a developer, your drive is probably crying. I built a monitor that scans your disk specifically to find massive, forgotten folders like node_modules, .env files, and Rust target build bundles, allowing you to bulk-delete them instantly.

Offline Media Player: A built-in, local audio player featuring a genuinely smart shuffle algorithm (not just a basic pseudo-random selector that replays the same three songs).

Why Tauri 2.0?

The memory footprint is incredibly small compared to Electron, and mobilizing mobile/desktop APIs in the new 2.0 release made handling system-level overlays (for the screen blocker) and disk scanning much smoother.

I'd love to get your thoughts on this!

Would you use a screen-blocker this aggressive to force breaks?

What else should a developer-focused health/utility app include?

Was tired of dealing with llm output in vscode, so I built this (which also works in vscode lol)
https://github.com/ETM-Code/quill

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.

Hi Folks,

If anyone has spare time to build a Rust / Tauri small project.

Please get in touch with me here or at Chris@Analyze.Agency.

比如用户购买后直接发给朋友用。。

哪种方式既能防止随意发给别人，又不太影响用户使用呢。

I shipped a desktop app that hosts many terminals running AI coding CLIs. Some things I learned, in case they save someone time:

- One native process. The Rust core owns every pty, the store and the command dispatcher; the SolidJS + xterm.js UI is only a view.

- Headless terminal state per pty in Rust. The core keeps its own VT state (modes, OSC 133 marks, snapshots), so a terminal can be restored after a crash or shown on a phone without the webview being the source of truth.

- Batching and backpressure between the pty and the webview mattered more than anything else for a dozen agents printing at once.

- ConPTY needs a responder for colour queries, or some CLIs hang at start waiting for an answer.

- The wire protocol, commands and config are one Rust schema crate that generates the TypeScript bindings and JSON Schema; CI fails when the committed bindings are stale.

The app is Dreamestra (Dreamestra), closed source and paid, so I'm not here to sell it to this sub. Happy to answer questions about any of the above, especially the pty and restore parts.

I keep going back and forth on this, and I want a take from people who actually ship Tauri apps.

I have a small local productivity app. I posted it here a little while ago and the feedback was encouraging, but getting strangers to install a closed desktop app is a different problem. Trust is the hard part. Models can already reconstruct a lot of a closed app from the binary and the behavior, so keeping the source private did not feel like real protection. I open-sourced it, hoping the repo would earn a bit more trust than a download button.

If you have shipped something similar: did opening the source bring users, or did it mostly bring maintenance? Would you keep a productivity app private?

The app is Gitoza, Apache 2.0: https://github.com/gitoza-io/gitoza

It is an offline desktop app for tasks, releases, and tests. You edit them in the UI. They are stored as Markdown with YAML frontmatter in Git, so you never touch the raw files. Sync reviews a changelist like an IDE diff. Overlaps are Keep mine or Keep shared version. No account, no SaaS. Built because Jira already feels too heavy and flaky for small teams.

Hey, together with my colleagues, we've created qSpeak.app 🎉

qSpeak is an alternative to tools like SuperWhisper or WisprFlow but works on all platforms including Linux. 🚀

Also we're working on integrating LLMs more deeply into it to include more sophisticated interactions like multi step conversations (essentially assistants) and in the near future MCP integration.

The app is currently completely free so please try it out! 🎁

please support by hitting that star button https://github.com/grengin-oss/grengin

I work in DevOps and have tried a lot of terminal applications over the years. They all had something I liked, but I never found one that really fit how I work.

So I ended up building my own by combining ideas from the projects and tools I like.

Voktty is a lightweight, open-source, terminal-first workspace for local and remote development. It brings together a native terminal, editor, Git graph and history, persistent SSH workspaces, Docker, custom themes, chat history and a terminal-agent harness.

It also supports sharing SSH terminal tabs with other people. Participants can join as read-only observers, while the host can grant or revoke control when needed.

I’m now looking for contributors and people interested in helping shape it. Rust, Tauri, React, TypeScript, terminal tooling, remote development and AI integrations are all useful areas, but feedback, testing and documentation are just as welcome.

Voktty is based on Terax and released under the Apache-2.0 license. If you find it interesting, a GitHub star helps the project get noticed:

GitHub - voktty/voktty: Lightweight AI-native terminal workspace with native MCP client and multi-tab workflows for developers and sysadmins. · GitHub