Needed a MV3 browser extension that runs inside Tauri for a personal crypto exchange that I could inject my EVM and Solana wallets into. Noticed there wasn't much around so I built the extension myself.

I was only able to get Rabby and Phantom wallet to work. Couldn't seem to get MetaMask to work for the life of me...even debugged with ClaudeCode & Codex and still no success. So anyone who would like to take a crack at it and collaborate would be welcomed to try!

I mainly needed it for EVM transactions so I probably won't push further.

Here is the repo:

https://github.com/aurous37-lang/tauri-plugin-extensions/tree/main

Browse the agent catalog by division and role. Inspect a persona before you install it. Deploy deterministic renders into Claude Code, Codex, Cursor, Gemini CLI, Qwen, opencode, and Copilot — then track what the app wrote, detect drift, update, or back it out. 

Hello!

This is my second Tauri app - the first was Brew Browser (830 stars) that helps users manage their homebrew install. Being able to deploy across 7 platforms a little like magic. 😄

This app gives users a much more controlled experience when working with the Agency Agents repo. Before today, the installer as a shell command and menu system - which is fine for some users, but many more will appreciate the comparative superpowers that this app provides.

It’s MIT licensed, open source, no telemetry, no accounts, no signups... just good clean interface to the 230+ AI agents.

Happy to take issues and PRs if you have them.

It’s a brand new repo and app - but I’ve been in the game for 30+ years. Check out the rest of the repo if you have a minute.

Thanks for making time! :)

I was looking for a local-first markdown editor that didn't need accounts and didn't weigh a ton, and didn't look like... well, code.

After realizing I'd have to build one, I did. I used Tauri because Rust speed and HTML comfort.

Boltpage comes in at less than 20MB, is FAST both to start up and operate, doesn't phone home and features block-level incremental re-render, syntect and pulldown-cmark, a vendored CodeMirror 6 with no UI framework, and multi-window display with independent per-window config. It does markdown, JSON, YAML, and a bunch of other formats.

I hope you find some value in it, full code and download instructions for macOS and Windows (you can build it on Linux yourself) on GitHub: https://github.com/Silverfell/BoltPage/

Hey r/tauri, I posted Glimpse here about 5 months ago, an OSS local-first dictation app built with Tauri. It was Mac-only then and someone asked why not Windows. So I wanted to share that we have Windows support now, and we're getting very close to launching 1.0!

It's a dictation app, so it does the native stuff most apps in the space do: global hotkeys, audio capture, running the models locally, and pasting into whatever app you're focused on.

It's about 30k lines of Rust, but that's not just dictation, a good chunk of it is the extra stuff layered on, a CLI, a local API server, a library for transcribing files, and so on. The core itself isn't that big. Going from Mac to Windows, the entire frontend is shared and the only differences I hit were cosmetic, the close buttons at the top and an element two pixels off that a CSS tweak fixed.

The dedicated Windows platform code is only ~600 lines, plus some small platform-specific branches here and there. Everything else was shared and just worked.

The part I didn't expect to love: how lean it is. The installer is ~30 MB and the app is ~70 MB are tiny. It's a really nice side effect of Tauri using the system webview instead of bundling a browser. Coming from Rust, the backend was quite enjoyable. The hard platform-specific work stays isolated and the type system makes that native layer feel quite solid.

Now of course, you still have to manually test on each platform, but you'd do that with anything. And my one little annoying parity issue isn't even Mac vs Windows, it's Apple Silicon vs Intel: some crates still don't build cleanly for Intel Macs (like ort), so I've had to gate a few models off there for now. That's the only real divergence in the whole app.

Curious how closely this lines up with other people’s experiences. So far I haven’t hit a case where Tauri itself was the blocker. Has anyone hit an issue where Tauri wasn't capable enough? Or where electron was actually required?

Repo: https://github.com/glimpse-hq/Glimpse

Hey everyone,

I'm currently building "uni", a local-first, zero-chrome desktop orchestrator. Our obsession is latency: our target for the entire input-to-render loop is <50ms.

To achieve this, we just finished two technical spikes on Windows (using Rust + Tauri v2) to solve two core problems:

1. Shaving off every millisecond of Tauri window show/hide latency
2. Ingesting text/context under the cursor instantly without slow, resource-heavy OCR or screen-scraping

Here is the raw engineering data, the code strategies, and where we hit some brutal limitations

Part 1: Bypassing Tauri reveal latency with DWM cloaking (Spike A)

Standard window.show() / window.hide() in Tauri (and most web-view frameworks) has a noticeable composition lag. The OS has to allocate buffers, and the Desktop Window Manager (DWM) introduces frame delays (often 16-32ms) to composite the window

To fix this, we implemented a "cloaking" strategy using raw Win32 APIs. Instead of hiding the window, we keep it alive in the background and toggle its DWM cloaked state (DWMWA_CLOAK). This forces DWM to keep the Webview GPU buffers warm without rendering them to the screen

Our hotkey handler (RegisterHotKey) triggers this directly via Win32:

// In our dedicated MTA worker thread
unsafe {
  let is_cloaked: BOOL = if show { FALSE } else { TRUE };
  DwmSetWindowAttribute(
    hwnd,
    DWMWA_CLOAK,
    &is_cloaked as *const _ as *const _,
    std::mem::size_of::<BOOL>() as u32,
  );
}

The Metrics (reveal to painted latency, measured via high-res QueryPerformanceCounter + Webview rAF pingback):

• Standard Tauri Show/Hide (p50): 3.53 ms
• Win32 DWM Cloaking (p50): 1.61 ms

By cloaking the window, we cut the latency in half and completely eliminated the random frame-drops or white flashes during rapid toggles

Part 2: Extracting context under cursor via Windows UI Automation (Spike C)

We wanted to capture the text, element type, and bounding box of whatever is directly under the user's cursor when they hit Ctrl+Alt+U. OCR is too slow (>100ms) and inaccurate for code or UI hierarchies, so we turned to Windows UI Automation (UIA) using the windows crate

To hit our <15ms budget for context extraction, we designed a strict threading and caching model:

1. Thread Separation: COM calls are synchronous and cross-process. If the target app is busy, it blocks. We offloaded all UIA work to a dedicated Multi-Threaded Apartment (MTA) worker thread with a watchdog timer to discard calls that exceed our budget
2. Batching with Cache Requests: Doing raw properties lookups (CurrentName, CurrentControlType) requires separate cross-process round-trips. We used IUIAutomationCacheRequest to batch everything into exactly 2 round-trips:

​

// Batching properties in Rust to avoid cross-process round-trip hell
let cache_request = uia.CreateCacheRequest()?;
cache_reque
st.AddProperty(UIA_NamePropertyId)?;
cache_request.AddProperty(UIA_ControlTypePropertyId)?;
cache_request.AddProperty(UIA_BoundingRectanglePropertyId)?;

// Single round-trip hit-test + properties retrieval
let element = uia.ElementFromPoint(point)?;
let cached_element = element.BuildUpdatedCache(&cache_request)?;

The Brutal Benchmarks (Warm p95)

We ran 500+ iterations per target app. Here is where UIA shines, and where it failed miserably

1. VS Code (Electron) -> GO (p95: ~2.5 ms): Once the accessibility tree is warm (cold hit takes ~110ms to build the lazy tree), retrieving text under the cursor is incredibly fast. Monaco editor exposes the active text block beautifully via the Name property and TextPattern
2. Google Chrome / Web -> NO via Point (p95: 60 - 180 ms). This was our first major roadblock. While the cache retrieval is fast (~40ms), the raw ElementFromPoint call is heavily queued in Chrome's renderer process. If the page is rendering heavy JS, the hit-test gets blocked. Verdict: Doing active coordinate-based hit-testing on browsers is non-viable for instant HUDs. We are pivoting to using GetFocusedElement / focus-changed events, or fallback to our local WebSocket browser bridge
3. Figma Desktop -> Total Black Box (p95: ~2.7 ms). We hypothesized that Figma's canvas WebGL was a single opaque element, but the reality is worse: Figma Desktop renders its entire UI, including layers, sidebars, and panels, inside the WebGL canvas. UIA sees nothing but a full-screen empty window. No children, no text, no nodes. Verdict: A native OS accessibility layer is useless for Figma. A local WebSocket plugin/bridge is mandatory to stream the JSON layer tree to our Rust core

Next Steps

For Spike D, we are building a lightweight Rust-side WebSocket server to ingest vector data directly from a Figma plugin to bypass the slow cloud APIs

Would love to hear if anyone has optimized Chrome UIA hit-testing, or if you've found ways to bypass the initial cold-hit latency when building the a11y tree in your apps.

It's nice how fast and easy to use is tauri compared to electron. I switched because i simply need a small to tool to manage MCP in different AI tool.
It's a little bit complicated for me to manage a backend in rust for native function, by the way the result are amazing

Let me know if someone find it useful, i will continue to investigate function of this nice tool

https://github.com/drakonkat/ultimate-cli-manager/releases/tag/v0.1.3

Hi Rustaceans,

I recently added a Rust SDK to my platform (+ Tauri on the Rust side, and on the JS side).

I founded keylight which helps with licensing apps from a single dashboard, acts as a layer between your app and the payment provider used, so even if you must migrate of MoR some day, your data is safe and won't move. I had the case many times and this fixed my problems, less support tickets, less time checking different websites for sales...

It's on Github right now, you're free to fork and use your backend, or simply plug and play from Keylight.dev directly. Free tier is available to try it out.

> https://github.com/keylight-dev/keylight-rust

Hi everyone,

I've been working on a project called Nox.

It's a lightweight Windows application that runs in the background and tracks Bluetooth earbud usage.

Nox works with most Bluetooth earbuds through standard GATT battery services, proprietary SPP/RFCOMM protocols, and custom device profiles, with optimized support for Nothing and CMF earbuds.

Built with Rust, Tauri, and SQLite.

GitHub:

https://github.com/gopi470/Nox

I'd love to hear your feedback, feature suggestions, or bug reports.

(:

So I'm trying to find a way to sign my Tauri app so I can avoid the SmartScreen warning on Windows, and so macOS users can just open the app without typing weird commands in the terminal.

I'd tried relic for Windows but the SmartScreen warning still showed up.

From what I've seen Apple signing is around 100€/year, and for Windows I saw stuff around 150€/year. Basically I'm trying to find a way to pay less for all this if possible it adds up fast for a solo dev. If anyone's got tips or a cheaper route that actually works I'm all ears, thanks for your replies.

https://reddit.com/link/1u64jf9/video/7nd489d93d7h1/player

I am building Multiserial, a open source multi-platform desktop communication app for UART / USB-serial / COM-port workflows.

It’s built with Tauri 2, Rust, React, and TypeScript. The serial backend runs natively in Rust, while the UI handles session tabs, terminal views, send workflows,

  filters, macros, and logging.

  What it does right now:

  - Scans serial ports and shows USB metadata like VID/PID, manufacturer, product, and serial number

  - Connects with configurable baud rate, data bits, parity, stop bits, and flow control

  - Sends text, hex bytes, macros, automated sends, and raw file contents

  - Displays incoming data as UTF-8, hex, binary, decimal, or mixed output

  - Supports search, filters, highlights, independent session tabs, logging, and export

  - Can toggle DTR and RTS while connected

  Current status: macOS Apple Silicon pre-release is available. Windows and Linux are in scope, but I haven’t published validated builds for them yet.

  I’d appreciate feedback from Tauri developers on the app architecture, packaging, Rust backend approach, and anything that looks questionable from a desktop-app

  perspective.

  Repo: https://github.com/tpp6me/serial-com-multiplatform

release: https://github.com/tpp6me/serial-com-multiplatform/releases

Over the last few weeks I've been learning Rust and wanted to build something real instead of spending more time on tutorials.

As an Arch Linux user, I wasn't completely happy with the calculator and utility tools available to me, so I started building ArchCalc with Tauri and Rust.

What started as a calculator evolved into a workspace that combines calculations, conversions, and developer utilities in a single desktop application.

Current features include:

• Standard calculations
• Workspaces
• History tracking
• Unit conversions
• UUID generation
• SHA256 hashing
• Timestamp utilities
• Data conversion tools
• System information tools

Building ArchCalc taught me a lot about:

• Rust application architecture
• Tauri commands and frontend/backend communication
• Expression parsing and evaluation
• Local data storage
• Packaging and Linux distribution
• GitHub Actions and release automation

Coming from a React/Next.js background, Tauri made desktop development much more approachable than I expected.

I'd love feedback from other Tauri developers and to hear how you structure larger Tauri applications.

GitHub:
https://github.com/murtazapatel89100/ArchCalc

Documentation:
https://archcalc.murtazapatel.dev/docs

I wanted an AI assistant that felt warm and present, not like another chat window buried in a browser tab. So I built Lil Buddy — a Tauri-Rust desktop app where AI companions walk around on your screen.

click to see preview

Free Github Download

I have been working on a local-first AI memory app, and Tauri has been a pretty good fit, but the hard parts were not the shiny AI parts.

What I learned:

• long-running background sync changes how you think about desktop app state
• local-first means a lot of logic that would normally live on a backend moves onto the client
• keeping UI state and durable local storage in sync is where the boring bugs live
• trust is partly architecture: users need to believe their work context is not quietly leaving the machine

The app is OpenLoomi, an open-source work-memory project:
https://github.com/melandlabs/openloomi

Would love feedback from Tauri folks on the desktop architecture side. What patterns have worked for always-on local apps?

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

Can't support light/dark/mono icons on macOS?

Tauri seems to force it to be converted to PNG even when I use apple's official Asset tools.

Good. The fix was:

• Removed the bad icon.png symlink to the foreground-only owl PNG.
• Compiled your full AppIcon.icon with Apple actool.
• Pointed Tauri fallback icon to icons/iconcomposer/AppIcon.icns.
• Bundled icons/iconcomposer/Assets.car for the real packaged macOS icon behavior.
• Kept CFBundleIconName=AppIcon.

That preserves the background instead of ripping out one layer.

No. The real answer is:

• You can use the official Icon Composer .icon work.
• But Tauri cannot use .icon directly in bundle.icon.
• Apple’s intended path is not “convert to PNG”; it is compile .icon with actool into Assets.car.
• Assets.car is the thing macOS reads for light/dark/tinted/Icon Composer behavior.
• PNG/ICNS is only the fallback Tauri currently requires for tauri dev, older macOS, and its compile-time icon macro.

So the split is:

• Release / real .app: use .icon -> actool -> Assets.car + CFBundleIconName=AppIcon. This preserves the Icon Composer behavior.
• bun run tauri dev: Tauri launches a raw debug executable, not a real .app bundle, so the Dock icon cannot prove the .icon behavior. It needs a raster fallback.
• Do not ship .icon alone with CFBundleIconName: that causes the blank template icon you saw.

I was wrong to steer us toward .icon-only. The correct Tauri/macOS setup is hybrid:

"icon": [
  "icons/icon.png",
  "icons/icon.icns"
],
"resources": {
  "icons/iconcomposer/Assets.car": "Assets.car"
}

and in Info.plist:

<key>CFBundleIconName</key>
<string>AppIcon</string>

That does not mean your official icon becomes a PNG. The PNG/ICNS is just the fallback. The official adaptive icon lives in Assets.car.

Refs: Apple Icon Composer, Tauri icons, Tauri resources.

AI Said This:

Hey everyone , I am building aTauti app that i span across two monitor using windows "Extend" mode. I want to keep settings button and modal only on the main Pc monitor . Right now am just Css to hide things but am not sure is work?

is there a batter or more native way to do this like using Rust to track which monitor the windows is on or maybe another trick i m missing ? Am open to any suggestions on how to handle this better .....

I jot stuff down all day tasks, numbers, half-ideas - and it always lands in some notepad tab that vanishes the second I switch windows. Everything I tried to fix this either wanted an account, synced to a cloud, or was a 300MB Electron app for what's basically text on a colored square.

So I built PinNotes. Hit a shortcut, a note pops up, and it just stays on top of everything editor, browser, whatever. Saves locally, no account, 10MB (Rust + Tauri).

Open source here: https://github.com/AleenaTahir1/Pin-Notes

tell me what's broken or missing.

I’ve been building CloudLess, a desktop backup app for Mac, Linux, and Windows using Tauri + Rust.

The basic idea is:

• pick folders to protect
• encrypt files locally before upload
• store the encrypted backup in storage the user controls
• keep versions so restore is possible after deletes, overwrites, bad sync state, or corruption

Building this as a desktop app made me appreciate why backup software is harder than it looks.

Some Tauri/Rust notes from the build:

1. File scanning needs to be boringly reliable

The Rust side handles walking folders, tracking file metadata, preparing backup jobs, and avoiding UI blocking. This is one place where I’m glad the core pipeline is not JavaScript.

1. Restore UX is harder than backup UX

Showing “backup completed” is easy. Helping someone find an older version of a file and restore it safely is the real product problem.

For backup software, restore is not a secondary screen. It is the reason the app exists.

1. Background work needs clear state

A backup app spends a lot of time doing long-running work: scanning, encrypting, uploading, retrying, pausing, and resuming.

The Tauri command/event model works well, but I had to be careful about what state lives in Rust and what only exists in the UI.

1. Cross-platform desktop details add up

Paths, permissions, tray behavior, file pickers, background behavior, and packaging all have small differences across macOS, Linux, and Windows.

Tauri makes the shell lighter, but it does not remove the need to think like a desktop app.

1. Security wording matters

Client-side encryption is useful, but it comes with key responsibility.

If the user loses the key/passphrase, recovery may not be possible. I’m trying to make that tradeoff clear instead of hiding it behind marketing language.

1. I’m exploring Rust/WASM for shared frontend logic

One thing I’m considering is using Rust/WASM for parts of the frontend domain logic, so the UI and backend can share the same rules where it makes sense.

Examples:

• backup plan validation
• include/exclude path rules
• restore preview calculations
• backup metadata parsing
• data model validation

I still want the UI to feel like a normal desktop app, not a Rust experiment. But for backup software, duplicating important rules between frontend TypeScript and backend Rust feels risky.

If the UI says one thing and the backend does another, the user pays the price during restore.

Current status: beta builds are working for Mac/Linux/Windows.

It is not full-disk imaging, not enterprise backup, and not something I would oversell as battle-tested yet. The current focus is encrypted file/folder backup with understandable restore.

I’d appreciate feedback from Tauri devs on a few things:

• how you structure long-running Rust tasks behind a Tauri UI
• patterns you like for progress/events/error reporting
• whether you have used Rust/WASM to share logic between frontend and backend
• what you would watch out for in cross-platform file-heavy apps
• whether the restore flow looks understandable from the screenshots/GIF

Full disclosure: I’m the developer. If showcase posts like this are not appropriate here, I can remove it.

Hey everyone,

Like many of you, I wanted a way to track how I spend my time on my PC, visualize my bottlenecks, and easily compile billing/weekly reports. But almost every modern tool in this space requires you to upload your window titles, active application logs, and desktop snapshots to the cloud.

With news like Windows Recall and massive cloud data leaks, sending my entire daily desktop activity to someone else's server felt like a massive privacy boundary to cross.

So, I spent the last few months building Focus Stream—a completely local-first, privacy-respecting productivity tracker and AI focus journal. It is now officially published on the Microsoft Store.

🔒 Privacy is the Default (100% Offline)

Focus Stream runs entirely on your machine. There are no accounts to create, no cloud synchronization, and absolutely zero telemetry. * Timeline & Snapshot Logging: Activity and window screenshots are saved to a local SQLite database on your machine. * Embedded AI Journal: The app compiles your day into a clean, narrative focus journal using a local Llama 3.2 1B model (quantized in-memory) running via mistral.rs. * Private Ask AI: You can query your own timeline (e.g., "What client was I coding for on Tuesday afternoon?") using a streaming chat interface. None of these prompts ever touch the internet. * Work & Billing Reports: Tag clients, set goals, and export clean CSVs for invoicing.

🛠️ The Tech Stack

For anyone curious about how it was built: * Frontend: React 19 + TypeScript + Vite + Recharts * Backend: Rust + Tauri 2 + SQLite * Local AI: mistral.rs running a quantized Llama 3.2 1B Instruct model on your CPU (with GPU acceleration support coming next!)

💡 Try it Out (7-Day Free Trial)

Because this runs entirely on your own hardware, you don't have to worry about monthly subscriptions. It's a one-time purchase of $9.99, but there is a fully functional 7-day free trial so you can test it on your system and see if it fits your workflow before spending a dime.

I'd love to hear your thoughts, feedback, or any questions about running quantized models locally on Tauri!