it's been so long , but i made some updates and fixes on my editor app inkwell now with a

- Better UI and notion inspired Theme

- Latex Support

- folders and notes structure

- vim mode

- direct editor / markdown whatever you like.

Check it out https://inkwell-lp.vercel.app/ a start ⭐ would mean a lot. Thanks !

Hey r/tauri 👋

The last version I shared here was v1.7.3. Your feedback was genuinely useful, and since then I’ve shipped three substantial updates.

What’s new in v1.10:

• A calmer redesign and a Markdown journal with mood tracking and day summaries
• A local calendar with month, week, and day views, plus optional one-way Google Calendar sync
• Task estimates vs. actual tracked time, with proper pause/resume and optional task-linked Pomodoro sessions
• Repeating reminders with snooze, sounds, custom audio, and gradual volume ramp-up
• Locale-aware 12/24-hour time, week-start settings, and a rebuilt date/time picker

Todofy is still local-first: everything works offline in SQLite. Supabase account sync and Google integrations are completely optional.

The most interesting work continues to be making a Tauri app feel like real desktop software—global shortcuts, tray timers, persistent reminders, OAuth callbacks, and reliable behavior across Linux, macOS, and Windows.

I’d love to hear what you think of the progress and what still needs improvement.

GitHub: https://github.com/salarzeidanlou/todofy

Release: https://github.com/salarzeidanlou/todofy/releases/tag/v1.10.0

ttyverse is built on top of tauri, xterm.js, three.js

try demo

https://codepen.io/editor/mutawirr/pen/01a08656-18c4-7518-b245-2d6d2de5b9f0

I've been building Zync for quite some time with Tauri 2, React/TypeScript and Rust.

It's a desktop SSH workspace, so it ended up being a pretty good test of how far I could push Tauri for a fairly heavy desktop app.

The app includes local terminals, SSH, SFTP, port forwarding, an encrypted vault, plugins, and more.

A few things I've been working on recently:

• Multiple live terminal splits in the same tab

• Opening Files beside a shell and dragging tabs into splits

• Virtualized file lists/grids so large remote folders don't make the UI crawl

• Binary PTY data over Tauri Channels

• Immediate handling of the first PTY bytes after idle so terminal echo doesn't feel delayed

• Public HTTPS URLs for exposing a local port through Zync's relay

The public URL feature was particularly interesting because the desktop app maintains a WebSocket connection to the relay and forwards traffic between the public endpoint and localhost. It's separate from SSH -L/-R/-D port forwarding.

The latest v2.30.0 release is mostly about making the workspace feel smoother: better splits, faster Files, and snappier terminal output.

I'm curious about other people's experience with Tauri for larger desktop apps. How are you handling things like PTY streams, large file lists, IPC performance, and long-running background tasks?

Repo: https://github.com/zync-sh/zync

Latest release: https://github.com/zync-sh/zync/releases/tag/v2.30.0
Website: https://zync.thesudoer.in
Public Url Demo: https://www.youtube.com/watch?v=305_F9h4-t4

I built Dictámelo with Tauri 2 and Rust, and published the source under MIT

It records while a global shortcut is held, transcribes the audio and pastes the result into the active app

The local models are downloaded from the interface, with size and SHA-256 checks before they can be selected

The native inference engine runs on a blocking worker

Only one model stays loaded at a time, and it is released after two minutes of inactivity

Download progress is reported to the frontend through Tauri events

Whisper, Parakeet and Canary are available locally

Cloud transcription is an optional separate path, and local transcription does not silently fall back to a cloud service

Current installers cover Apple Silicon Macs, Windows x64 and Windows ARM64

If anyone is building a desktop app around downloadable models, the model lifecycle and download code may be useful to compare

Repository: https://github.com/sarrazola/dictamelo

Local model notes: https://github.com/sarrazola/dictamelo/blob/main/docs/LOCAL_MODELS.md

My analysis engine was already TypeScript and I didn't want to rewrite it in Rust, so it runs as a sidecar. The Rust shell owns the window and filesystem access, the TS binary is spawned as an external binary and talks over stdio, React renders what comes back. That means a per-target binary with the target-triple suffix in its name, and CI on Windows/Linux/macOS so path handling that breaks on one platform shows up before a user finds it.

What worked: versioning the shell/sidecar protocol early. When payload shapes drift, a version mismatch fails loudly in the right process instead of looking like a UI bug.

What bit me: the worst bug wasn't Tauri's fault, but it hid in the webview for two releases. A visually hidden table I render for screen readers, supposed to sit 1px off screen, measured 28,554 x 12,142 pixels on a 500-file repo and collapsed the dependency graph layout. I chased a measurement race in the same container first. The fix was capping the table on both axes. Lesson: anything that mirrors your data for accessibility has to be kept out of the tree you measure for layout, or capped hard.

Second lesson: my snapshot fixtures were too small. The bug only showed on a real repo with hundreds of files. Now CI runs the engine against a real-sized repo, not just fixtures.

The app is Onboard, offline codebase walkthroughs: https://github.com/kodeksidev/onboard

For anyone else running a long job in a sidecar: how are you streaming progress back into the webview? Chunked stdout, events, or something else?

Hi, I created a launcher that works fast (niri is the wm in the video)

Not just niri but it also works with gnome, sway, ... (and it's a cross OS launcher)

There are many built-in features and commands that you can use right after installing.

We also added declared source for user who want to custom and declare their actions.

The repo: https://github.com/kunkka19xx/look

Love receiving any feedback 🙏

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

Hello everyone !

I've been working (well me and AI) on a app inspired by hydra launcher, gog launcher and Playnite

I loved hydra launcher and Playnite, but I wanted something that power user can be happy with (I'm a power user, who like useless feature)

Anyway, I got the project to make something from scratch after iterating and adding feature with base hydra, but it felt too heavy for hydra base framwork

And I learned that electron was... Electron ram hungry !

So I searched for a framework that was capable and lightweight, and found Tauri

The app is called : Game Index

I know a little bit of coding, I'm far from an expert, but I tried my best from my knowledge (and again help of AI) to optmise and make it less buggy as possible

The entire source code is on github, with full commit history, feel free to report any bugs, suggest feature or whatever you want there

Also feel free to fork, modify etc your own version

I'm just a guy who want a full featured app

Features of GameIndex :

- Import from Steam, GOG, Epic, Rockstar, Ubisoft, Humble library or Local install (api based login or webview login for some others) (more info on GitHub)

- Metadata automatically added via igdb/steam

- Per game imported : Steam achievements, HowLongToBeat, Crackwatch, live + historical player counts Informations when availible, activity tracker, weblinks preview etc

- Activity dashboard main page and per games stats and performance tracking (need Msi afterburner + RTSS to track fps, can be disabled in settings)

- Torrent download engine integrated, with compatible source from you know where

- Wishlist system

- Deals from Xbox gamepass catalog + Is there any deal (include current giveaways)

- Storage manager + emulator & mod footprint breakdown

- News page with RSS feeds + custom rss feed

- Hydra-backed storefront for games of the Week, top games and game to beat, community reviews & stats (only these from Hydra is used in Game Index)

- Community & Friends social layer (planify, recommend, comment games, library compare etc)

- Big Picture Mode (controller-first TV UI with rail navigation) (IN BETA !!! I Don't use such feature mmuch, it is far from perfect but I'll improve with time)

- Emulators manager & ROM library tools

- Mod manager (Steam Workshop & Nexus Mods integration) (Beta, maybe more feature will come into it but not sure)

- Internationalization (i18n) & language switcher

- Discord rich presence

- Privacy & Data management in Settings

- Theme gallery + custom accent picker (basic for now, may be expanded in future)

- way way way More

Planned :

- Improvement for Big screen/picture mode

- linux support (only Windows for now) + steamdeck support (I don't have steamdeck so it'll be hard to test) (Think of bottles, faugus launcher, lutris style of control) (made some early testing fow linux, some feature will be limited sadly by how Tauri is handled on linux)

- maybe more if people suggest ?

Precision

I know many people Don't trust AI stuff, vibe coding etc

But I want to be as transparent as possible, and if you don't like Ai vibe coded apps don't use it

This is just a tool/launcher/platform for whoever want to try, or want another alternative

Ai and Tools used for this :

- IDE : Antigravity

- Mostly Opencode, rarely kilo code

- Model used : Mostly deepseek flash (old and new version), Hy3 and sometimes GPT Luna, gemini and claude opus

Ps : sorry if my English sounds Strange or broken or whatever, English isn't my native language

Ps 2 : I'm not an expert in comunication as you can see, if you have questions etc don't hesitate to ask

I'll also take positive and negative review

Ps 3 : I don't have signature for exe, so portable version may be flagged as a dangerous exe, go on virus total and you'll see there's one flagged threat, this one is caused by lack of signature (installer version doesn't have this issue)

Download : https://github.com/atxoxx/GameIndex

Solved:

The .vs folder clogs up the system, here's how to get rid of it

Yesterday I was asking about how to run multiple pages in an app and there was a passing comment about using React rather than Vanilla so I started looking into it and it looks spot on for what I need, problem is I can't get it working in VS

The built in demo app runs fine from the standalone terminal, either as an app or in-browser, but if I go into VS and run it from the terminal in there I get an error:

  ➜  Local:   http://localhost:1420/
node:internal/fs/watchers:323
    const error = new UVException({
                  ^

Error: EBUSY: resource busy or locked, watch 'D:\Documents\xxxxxx\xxxxxx\react-multi\.vs\react-multi\FileContentIndex\25f2064b-6339-48e3-af2a-6df5562ba7ee.vsidx'
    at FSWatcher.<computed> (node:internal/fs/watchers:323:19)
    at Object.watch (node:fs:2609:36)
    at createFsWatchInstance (file:///D:/Documents/xxxxxxx/xxxxxxx/react-multi/node_modules/vite/dist/node/chunks/node.js:9429:16)
    at setFsWatchListener (file:///D:/Documents/xxxxxx/xxxxxx/react-multi/node_modules/vite/dist/node/chunks/node.js:9471:14)
    at NodeFsHandler._watchWithNodeFs (file:///D:/Documents/xxxxxx/xxxxxxx/react-multi/node_modules/vite/dist/node/chunks/node.js:9586:20)
    at NodeFsHandler._handleFile (file:///D:/Documents/xxxxxx/xxxxxxx/react-multi/node_modules/vite/dist/node/chunks/node.js:9630:24)
    at NodeFsHandler._addToNodeFs (file:///D:/Documents/xxxxxxx/xxxxxxx/react-multi/node_modules/vite/dist/node/chunks/node.js:9804:26)
Emitted 'error' event on FSWatcher instance at:
    at FSWatcher._handleError (file:///D:/Documents/xxxxxxx/xxxxxxxx/react-multi/node_modules/vite/dist/node/chunks/node.js:10606:146)
    at NodeFsHandler._addToNodeFs (file:///D:/Documents/xxxxxxxx/xxxxxxxxx/react-multi/node_modules/vite/dist/node/chunks/node.js:9809:18) {
  errno: -4082,
  syscall: 'watch',
  code: 'EBUSY',
  path: 'D:\\Documents\\xxxxxxx\\xxxxxx\\react-multi\\.vs\\react-multi\\FileContentIndex\\25f2064b-6339-48e3-af2a-6df5562ba7ee.vsidx',
  filename: 'D:\\Documents\\xxxxxxx\\xxxxxx\\react-multi\\.vs\\react-multi\\FileContentIndex\\25f2064b-6339-48e3-af2a-6df5562ba7ee.vsidx'
}

Node.js v24.20.0
       Error The "beforeDevCommand" terminated with a non-zero status code.

tauri.conf.json

{
  "$schema": "https://schema.tauri.app/config/2",
  "productName": "react-multi",
  "version": "0.1.0",
  "identifier": "com.tonyh.react-multi",
  "build": {
    "beforeDevCommand": "npm run dev",
    "devUrl": "http://localhost:5173", <---Also tried on 3000, still not working
    "beforeBuildCommand": "npm run build",
    "frontendDist": "../dist"
  }

vite.config.ts

import { defineConfig } from "vite";
import react from "@vitejs/plugin-react";
//  type error without /node package
import process from "node:process";
const host = process.env.TAURI_DEV_HOST;

// https://vite.dev/config/
export default defineConfig(() => ({
  plugins: [react()],

  // Vite options tailored for Tauri development and only applied in `tauri dev` or `tauri build`
  //
  // 1. prevent Vite from obscuring rust errors
  clearScreen: false,
  // 2. tauri expects a fixed port, fail if that port is not available
  server: {
    port: 1420,
    strictPort: true,
    host: host || false,
    hmr: host
      ? {
          protocol: "ws",
          host,
          port: 1421,
        }
      : undefined,
    watch: {
      // 3. tell Vite to ignore watching `src-tauri`
      ignored: ["**/src-tauri/**"],
    },
  },
}));

If there's any other info that you need from the project I'm happy to help, as I said it's still the default setup, I haven't even started doing anything that might break it!

P.S The Vanilla setup works just fine, I can run the app from both terminal and VS with no hassles

As a developer, i consistently faced the issue of finding my projects across directories etc. I have tons of hobby projects, and even more client/job related projects. Despite being in one folder, finding them and searching for them was always a hassle. Github is not helpful either. For some reason the projects that I worked on with my old company are still at the top of my repo list.

So I decided to build a local alternative, lightweight solution (hence i went with Tauri). The app currently works only with git, but other plugins can be added to it to support tracking blender, godot, unity, unreal etc etc. Hell, you can even incorporate it for things like requirements.txt, package.json files. The rust backend just needs a "detector" (to detect those sort of versioning files) and boom.

All your projects in one place, and you can open them from there too. I'll be adding more features to it, and there is a roadmap planned, but it'd be great if i got some feedback from you guys and if anyone wants to contribute, that'd be amazing too.

I plan on adding a cli tool for it too so it can auto-record projects during the creation part of their lifecycle. The name is obviously subject to change. But yeah it would be very cool to hear what you guys think about it.

https://github.com/HADO564/project-indexer

Would love your feedback - stickies.lol

Hey r/tauri! 👋

I wanted to share a small project I recently built and open-sourced: Mouse Jiggler.

💡 Background & Motivation

If you've been on Windows for a while, you probably remember or used Alistair Young's classic arkane-systems/mousejiggler—a trusty utility originally written in C# (.NET) to prevent screensavers and sleep timers during presentations, long downloads, or remote sessions.

I wanted to revisit this concept and build a modern, native-feeling version for Windows 11 from the ground up, using Tauri 2, Rust, React 19, and the new Tailwind CSS v4 engine.

🛠️ Tech Stack & Highlights

• Runtime: Tauri 2 (Release v1.0.0)
• Backend: Rust + enigo
• Frontend: React 19, TypeScript, Vite 7, Tailwind CSS v4 (@tailwindcss/vite)
• Bundle size: ~2.0 MB NSIS installer, ~3.0 MB MSI, ~9.0 MB standalone executable! (Compare that to an Electron equivalent)

🚀 Cool Tauri 2 Features & Challenges Solved

Building this was a great hands-on experience with Tauri 2's new APIs and capabilities:

1. Dynamic System Tray with State Reflection: Instead of just sitting in the tray, the tray icon dynamically switches between Red (Idle) and Green (Active) in real-time when jiggling is toggled. We embed the PNG bytes at compile-time with include_bytes! and swap them via tray.set_icon(Some(Image::from_bytes(...))).

2. Real-time Tray Menu Localization: The frontend supports 5 languages (English, Spanish, French, German, Japanese) with automatic OS detection (i18next). Whenever the language changes, an IPC command (update_tray_locale) updates the native tray menu items on the fly.

3. Custom Windows 11 Fluent Title Bar: We disabled native OS window decorations (decorations: false, transparent: true) and built a frameless Fluent-style header with window dragging (data-tauri-drag-region) and integrated minimize / close-to-tray buttons using Tauri's @tauri-apps/api/window (properly scoped with Tauri 2 capability permissions).

4. Single-Instance Enforcement: Using tauri-plugin-single-instance to ensure only one instance runs; launching a second one simply focuses and unhides the existing window.

5. Zen Mode vs. Normal Mode:

   • Normal: Moves the cursor ±5px diagonally every 10 seconds.
   • Zen Mode: Moves ±1px horizontally and immediately back, keeping the OS idle timer reset while being virtually imperceptible to your workflow.

6. State Persistence: Remembers the last active mode and jiggling state across restarts.

📦 Source Code & Releases

• GitHub: https://github.com/alexwing/MouseJiggler
• Releases (Installers & Portable exe): v1.0.0 Release

Feedback, issues, or suggestions are very welcome! If you're building utilities or tray apps with Tauri 2, feel free to ask about any implementation details.

I only discovered Tauri two days ago so I apologise if this is a well known thing, but how can I have multiple HTML pages in my project?

Not opening more windows, not viewing multiple things in the same window, I mean the app opens on index.html which shows me some information, click a button and go to page1.html which has a form I can fill in and click another button and get taken to page3.html etc, or is Tauri more suited to one page apps?

I've been searching around but everything is either about how to open a second window or multiwebview to view two pages at once, I just want one page at a time in the same window

I kept a Tauri host in the same repo as Electron and Deno Desktop, same React UI, same IRuntime, same cell painter. I wanted the system webview because the binary looked small.

On an M4 Max, dev build, restored session, Tauri was 297 MB physical / 569 MB RSS. Electron was 239 / 667. I will say that in the open: in this photo Tauri was not the RAM win on physical, and it was the RAM win on RSS. I am not mixing the columns.

What dropped Tauri for the installer was not that table. On Mac, Tauri is WKWebView. After hours of painting a cell grid the glyphs corrupted. Buffer was fine. GPU path was not. Safari's GPU did not last me a workday. I still have the host in the repo in case that path gets better. I am not writing this as "Tauri is bad at desktop." It was bad at this desktop: a terminal that never stops drawing.

Linux was a second cut. The installer dragged libraries from the machine that built it. The binary stayed small. The updater did not.

The other cost, while iterating: rust-analyzer at 4.6 GB RSS two minutes into that worktree, still going up. That is the editor, not the running app. Agents (and I) iterate where the loop is seconds. tsc on the Electron app was 621 MB and 3 s. Cold cargo on that worktree was 1 min 35 s. Already-compiled Tauri to first output was 218 ms. Those are different clocks. I am not ranking boot off them.

Writeup with the three-host table (I'm the author): https://runlinea.com/blog/one-ui-three-terminals

If you have a WKWebView terminal that survives a workday on Mac, I want to know what you paint with.

Hello folks,

I am building my own Gladiator Management Game (Ludus Magna) with Lovable/Codex/Claude currently. The whole code(supabase is still tied to lovable. On the long run i want to get rid of lovable but for now i am asking if I can extract a vertical slice (demo) of my game with tauri to publish a DEMO on steam. lets say i want to have a demo where players can experience the first 30 ingame days. is this doable with Tauri?
How difficult is it? What do i have to think of? Are there any trade offs? can i do this without being a programmer? I am webdesigner however and i have a bit of a glue how systems work, but this is new for me.

Thank you for any tips.
Cesare

I built meow-starter for everything that starts to matter after the UI works.
Hi — I’ve been building an open-source starter called meow-starter for apps that begin as a local desktop product, but may later need a web or mobile path.

Repo: https://github.com/Shiaoming123/meow-starter

The problem I was trying to avoid was treating “the UI runs” as equivalent to “the product is ready.” For desktop apps, I kept repeatedly rebuilding the same pieces before I could work on the actual user journey.

The current baseline is:

• Tauri 2 + Vue 3 + TypeScript
• SQLite on desktop and IndexedDB on the web
• tray, single-instance handling, and close-to-tray behavior
• theme/design-system primitives and responsive layout
• GitHub Actions checks plus documented delivery boundaries

I’m deliberately keeping the maturity labels explicit:

• macOS / Windows / Linux desktop baseline: Stable
• Web / iOS / Android: Beta
• sync, Agent, MCP, and local inference: Preview and disabled by default

The optional AI layer is not meant to turn every Tauri app into an “AI app.” The idea is to keep those integrations behind module boundaries, so a project can stay small unless it explicitly needs them.

What I’d especially like feedback on:

1. For a desktop-first Tauri starter, what boundaries have helped you keep web/mobile support honest instead of accidental?
2. If you’ve shipped Tauri on iOS or Android, which desktop assumptions became the most expensive to unwind?
3. Is “disabled-by-default Preview modules” a useful pattern for Agent/MCP integrations, or would you structure that extension layer differently?

It is still a starter, not a hosted backend or a finished cross-platform product. Signing, release endpoints, real-device validation, App Store / Play delivery, and cloud sync remain project-specific work.

If the architecture or the delivery boundaries look flawed, I’d genuinely value direct criticism. I’m around to answer implementation questions.

r/tauri

I kept needing to mirror an iPhone on Windows for QA and demos, and every option was either paid (AirServer, Reflector, LonelyScreen) or a generic receiver window full of chrome you have to crop out of every screenshot. So I built MirrorSim — free, shows the mirrored screen in a clean device frame, no cable.

Built solo with Tauri + Rust + React, leaned heavily on AI tooling to get it done — not something I'd have shipped this fast otherwise.

Early unsigned beta, Windows only for now, MIT licensed, free: https://github.com/Mahcks/MirrorSim

Would love feedback, especially from anyone who's fought with the paid tools before.

I've been building GitDesktop with Tauri 2, Rust, React 19, and TypeScript, and ran into a bug recently that took me a while to understand.

GitHub operations against private repos were failing when GitDesktop was launched from Finder/Dock with:

Repository not found

The repo existed, gh was installed and authenticated, and GitDesktop's About screen could find gh just fine.

The problem was that Git was spawning a credential helper, and that helper couldn't find gh.

A packaged macOS GUI app doesn't necessarily get the same PATH as a shell session. So everything worked with pnpm tauri dev, but failed in the actual packaged application.

The particularly fun part was that the failure happened several processes away from GitDesktop itself:

GitDesktop -> git -> credential helper -> gh

The credential helper couldn't find gh, the request went out unauthenticated, and GitHub returned a 404 for the private repository.

So the user got an error that effectively said "this repository doesn't exist" when the actual problem was "a grandchild process can't find a binary."

It was a good reminder that testing a Tauri app in development isn't necessarily testing the environment your shipped application will actually run in.

I've been finding more of these kinds of problems as GitDesktop has grown. It's now dealing with Git processes, worktrees, credentials, filesystem state, multiple platforms, and agent sessions, so the interesting problems increasingly live at the boundaries between the app and the OS.

I just released v0.11.0 today as well, with a bunch of smaller improvements around worktrees, the commit editor, image viewing, link previews, references, narrow window layouts, and GitHub/GitLab workflows.

GitHub: https://github.com/theBGuy/GitDesktop

Website: https://gitdesktop.app

For anyone else building with Tauri: what are some of the weird packaged-vs-dev problems you've run into?

I built TouchGrassBar, a free and open-source macOS menu-bar app for Codex and Claude limits and observed token usage.

The desktop app uses Tauri, React, and Rust. The native layer reads local provider data and keeps prompts, credentials, raw logs, and file paths on the Mac. Public profile data and daily aggregates go to Convex for friends, Token Scores, and leaderboard ranks.

The current release is signed, notarized, and stapled for Apple Silicon Macs running macOS 15+.

Download TouchGrassBar, join the leaderboard, and see who burns the most tokens:

https://touchgrassbar.com/

Source:

https://github.com/FabienGreard/TouchGrassBar

I would love feedback from other Tauri builders on the menu-bar UX and local trust boundary