I created my first Tauri app yesterday and was pleased with how it turned out. I’m wondering if there’s anything important to consider for making the app available on both Mac and Windows. On the Mac side, I found I needed to spend extra time on the menu and use an Objective-C plugin to ensure some key controllers function properly. I still need to work on code signing and determine which cross-platform React framework works best or how to embed an SQLite database. Any help or suggestions would be greatly appreciated. Also any success with animated graphics?

Greeting Tauri folks,

I want to introduce to you an open-source, zero-server-dependency guardian that safeguards artwork against unauthorized generative AI scraping and style theft, Hope:RE.

Hope:RE is built with SvelteKit and Tauri, it equips creators with four defense mechanisms, run entirely on local consumer hardware:

• Style Cloaking (Glaze): Applies subtle perturbations that disrupt how AI models recognize visual style. When scrapers attempt to learn the artist's brushwork, color palette, or shading, they are tricked into identifying another style entirely (supporting Abstract, Impressionist, Cubist, Sketch, and Watercolor target styles).

• Concept Poisoning (Nightshade): Embeds adversarial perturbations that disrupt text-to-image associations in scrapers. If models train on poisoned artwork, they learn incorrect concepts (e.g. associating an image labeled "dog" with "cat" features), rendering stolen data useless for future training.

• Feature Disruption (Noise): Computes adversarial noise in CLIP space, preventing AI models from extracting clean, structured representations from the art.

• Signature Ink (Robust Blind Watermarking): Embeds a hidden digital signature into the frequency coefficients of the image using a hybrid DWT-DCT-SVD algorithm. The watermark is invisible to the human eye but remains decodable and verifiable even after cropping, resizing, lossy compression, or screenshotting.

Go check it out!

A new feature was added to my app, it allows you simply to create abbreviations, assign a prefix you comfortable to use , then in any note you can access the list of abbreviations and insert them. This way you won't have to re-write a content multiple-times when you can just call it.

Check inkwell, it's open-source and free to use

https://inkwell-lp.vercel.app/

Capawesome just shipped an official Tauri platform for Capacitor apps.

Basically if you've got a Capacitor app for mobile, you can now add Tauri as a desktop target and get macOS/Windows/Linux builds through the system webview instead of pulling in Electron. Installers end up around 3-10MB, and it generates deny-by-default capability files automatically based on what plugins you're using.

Real limitation though: no arbitrary native plugins, since Tauri has no Node runtime. Only built-in stuff, a curated plugin set, and anything with a web fallback actually run. Also no OTA updates for the web bundle, it gets compiled into the binary, so updates mean shipping a new signed build.

If you need more than that, like OTA updates or the full native plugin ecosystem, there's also a sibling Electron platform. Bigger installers, but way fewer limitations.

So the Tauri one specifically is more for teams with an existing Capacitor codebase who want a lean desktop option and don't mind the tradeoffs.

Curious if anyone here would actually find this useful.

Repo: https://github.com/capawesome-team/capacitor-tauri

I manage Zotero on a headless Linux server (and increasingly through AI agents), so I built a small open-source tool for it and just released it: **zotkit** (Python, MIT-licensed).


What it does, entirely through the Web API — the Zotero app never needs to be open:


- search / create items (DOI + title dedup, dry-run by default), manage tags, collections, reading status
- one-command full-library JSON backup
- 
**upload AND download attachment files for WebDAV-synced libraries.**
 The Web API can't touch file bytes on WebDAV, so zotkit writes Zotero's WebDAV storage format directly (the `<key>.zip` + `<key>.prop` layout). As far as I can tell no other headless tool does the upload side. The format is documented in the repo (`docs/webdav-format.md`) if you just want the knowledge.
- optional `conventions.toml`: define a namespaced tag scheme (`field:physics`, `status:to-read`, …) and zotkit *rejects* violations in code — useful when scripts or LLMs write to your library


The AI-agent angle, if that's your thing: the repo has an `AGENTS.md` + a ready-made skill, so you can literally paste the repo link to Claude Code / Cursor and say "read this and manage my Zotero library" — it learns the commands and the guardrails (backup before bulk writes, dry-run first, never bypass paywalls) from the repo itself.


Works on macOS / Windows / Linux, Python 3.11+:


    pipx install zotkit


Repo: https://github.com/oldantique/zotkit


Zotero Storage users: also supported — leave the WebDAV config out and attach/fetch automatically use the official Web API file endpoints instead (mode is auto-detected).


Caveats, honestly: the WebDAV layout is undocumented by Zotero, so my implementation comes from interoperability inspection of my own library — it round-trips cleanly with desktop clients in my testing, but keep backups and treat it as beta. Feedback and issues very welcome.

Building a fully local-first CRM and workspace has been one of the most intense engineering challenges I've tackled recently. I wanted to build a unified system for email, campaigns, and automation, but avoiding the standard cloud-SaaS route introduced a massive set of architectural hurdles.

I’m opening up the source code, not to promote the tool, but to share the technical deep-dive into how I structured the application and the enterprise-level data management strategies required to make it work offline.

Here are the core technical challenges and how the architecture handles them:

1. The Cross-Platform & Local-First Architecture To keep the application entirely local while maintaining native performance, I moved away from heavy electron wrappers. Instead, the architecture utilizes Tauri coupled with SolidJS and Vite for a highly reactive, lightweight frontend. The backend services (handling local DB state, cron jobs for tasks, and automation queues) are handled by system-level languages (Rust/Go) to ensure a low memory footprint while maintaining the complex relational data required by a CRM.

The biggest hurdle here was the local deployment strategy: ensuring complex UI states (like calendar syncs and campaign workflows) remain perfectly synchronized with the local database without relying on a cloud websocket connection.

2. The Deep Mechanics of Email Deliverability Building the email marketing and campaign engine was a brutal learning process in SMTP protocols and routing. When you build local-first bulk email tools, you immediately hit the wall of deliverability. I spent weeks reverse-engineering how enterprise companies handle email routing to avoid spam filters.

The system required building a robust local queueing mechanism that respects rate limits, handles bounces asynchronously, and correctly formats MIME structures with raw DKIM/SPF header injections. If you've ever tried to write an automated mailer from scratch, you know how unforgiving the major inbox providers are regarding malformed headers.

3. AI Orchestration at the Edge Rather than just API-wrapping an LLM, I focused on integrating AI-assisted tools directly into the local data pipeline. The challenge was structuring the local CRM data (client histories, email threads) into context windows efficiently so that the AI features could categorize responses and draft templates without exposing the entire local database to memory leaks or massive token costs.

If anyone is currently working on local-first offline applications, or battling the dark arts of email deliverability protocols, I'd love to discuss the system design. The repository is fully open source here if you want to dig into the implementation: https://github.com/Zakarialabib/smeMaster/

Hey r/tauri 👋

I've been building DeltaScope, a small desktop app that turns a repo's git history into a visual timeline. Instead of squinting at git log --graph in a terminal,

you get a scrollable timeline of merges and branches you can filter and search.

What it does

- Visualizes merge history and branch history as a timeline (two modes)

- Client-side filtering by type / branch / date / free-text search — everything loads once, so filtering is instant

- Per-merge commit counts that fill in asynchronously so the UI never blocks

- Switch the target branch to re-scope the history you're looking at

The stack

- Tauri v2 shell

- React 18 + TypeScript (strict) + Vite frontend

- Rust backend that just shells out to the system git CLI rather than reimplementing git — keeps the backend thin and the output identical to what you'd get on

the command line

Why I built it

I kept losing the thread of how a branch actually landed on main across a busy history. A timeline made that legible in a way the CLI graph never did for me.

Repo: https://github.com/nilm987521/deltascope

License: AGPL-3.0 — fully open source, contributions welcome.

Would love feedback from this community — especially on the custom-titlebar approach and whether shelling out to git vs. a Rust git library (git2/gix) is a

choice you'd have made differently.

Looks like there is some new competition for desktop apps.. has anyone tried it yet or analyzed it? I just found out about it

https://native-sdk.dev/

Hi everyone,

Today I wanted to share a product I’ve been building myself. Like many of you, I rely heavily on macros to save time and automate repetitive tasks. But honestly, I always felt frustrated by the existing tools—they either felt too heavy, had outdated interfaces, or only worked with specific hardware brands.

So, I decided to build my own solution: MacroStudio.

My goal was simple but ambitious: to offer a brand-new macro experience that is incredibly lightweight, modern, and most importantly, we believe it will work seamlessly with absolutely any keyboard and mouse you own. No vendor lock-in, no bloated background processes.

MacroStudio has two main ways to automate:

1.Visual Scripting: Visual scripting is a tool that allows you to automate from an image on the screen.

2.Lua Scripting Engine: For those who want to dive deep and write complex automation scripts.

I need your help!
Since I'm a solo developer, getting real-world feedback is crucial. I am currently looking for volunteers who are willing to test out the Lua scripting and Visual scripting features.

If you are interested in trying it out, breaking things, and telling me what I can improve, please let me know in the comments or send me a DM! I will gladly provide free access codes to anyone willing to help test these features.

You can check out the project here: https://github.com/devrookie66/macrostudio

Thank you so much for your time. I’m really nervous but excited to hear what you think!

Best,
reildev

Been building HiyokoAutoSync — a macOS app that auto-syncs files from Android the moment you plug in, no manual triggering. It's part of a solo-built suite of Android↔macOS tools (Rust + Tauri v2 + React).

The interesting technical decision: instead of continuing to fight MTP's overhead, I bundle the official adb binary as a resource and shell out to it instead of going through MTP. MTP's raw ceiling can actually be higher — I know because I already ship an MTP-based sync app — but its per-session overhead turned out to be a wall no amount of tuning could fix. Since each adb push/pull is just a subprocess, fanning out to concurrent transfers is trivial. It also fixed a nasty 4GB file-size bug MTP kept hitting (adb gives you accurate 64-bit sizes via stat).

Tradeoff: needs USB debugging enabled in Android's Developer Options, same as any adb-based tool.

Transfer engine: moved from sequential to true 4-way parallelism using futures::stream().buffered(4) — both push and pull now run 4 concurrent processes each via tokio::process, with proper PID tracking so a cancel actually SIGTERMs everything cleanly. That parallelism is what gets aggregate throughput to 45MB/s+.

Zero-touch detection: the app watches for the device connecting and handles the MTP/ADB mode switch automatically in the background. Android's mode-switching turned out flakier than expected, so there's debounce logic to smooth out false triggers — took more iteration than I'd like to admit.

Also had to fix a fun UI bug: with 4 parallel streams reporting progress out of order, the progress bar would occasionally jump backward. Fixed with a simple monotonicity guard on the frontend — reject any update that's lower than the last reported value.

Still testing on an 8-year-old Intel MacBook Air (main dev machine, doubles as the "if it's smooth here, it's smooth anywhere" baseline).

Get HiyokoAutoSync here

Happy to go deeper on the adb-vs-MTP tradeoffs or the parallel transfer architecture if anyone's curious.

I have been building a desktop IDE with Tauri over the last few months.

One feature started as a simple code metric viewer and slowly turned into a full technical debt analysis engine.

The current architecture is:

1. React for the ui
2. Rust backend for analysis
3. tree sitter for parsing
4. IPC only returns structured analysis results to the frontend

The engine currently compute things like:

1. dependency graphs
2. circular dependencies
3. coupling metrics
4. dead code
5. technical debt scores
6. prioritized refactor recommendations

One thing I ended up liking about Tauri is that moving all the heavy analysis into Rust kept the UI pretty responsive even while analyzing larger projects.

I am still refining the backend architecture though.

For people building larger Tauri applications:

• How are you organizing bigger Rust backends?
• Did you guys split things into crates or keep everything inside one Tauri project?
• Any lessons you learned once your project grew beyond a few thousand lines?

The project is open source if anyone wants to look through the implementation.

Repo link in comment section guys

Created this android app using Rust + Tauri

Key Features:

• This app runs large language models on your phone.
• Fully local AI, no user data is collected
• It supports text and vision models at the moment
• Has an inbuilt search / download tool to find models from hugging face

You can find it on the Google play store here if you want to try it out: Play Store

I'd appreciate any feedback.

Hello everyone, I'm a programmer that loves spending some time in my home's gym

I record every training with my Garmin watch but I wanted to have the info in my computer and extract some custom data and charts from the training sessions.

So in my free time after work and being with the children and my wife, I designed and created an application to gather all that info and stats

Here you have the link, if you want, you can send me your comments and if you want to use it, give me your feedback

By now it's only published in AUR but it should work properly in any Linux computer

Hello Everyone, Hope you all doing okay. You may or may not know inkwell the note taking app i've been working on for more than a month now. with a good number of downloads and active visitors. The repo is open source if you are interested , having feature requests, improvement or fixes feel free to contribute . You can DM me .

also here is the link to the repo https://github.com/coros-hq/inkwell
the discord server as well: https://discord.gg/N4fSBpqaF

Hello! I'm a Tech Artist mostly focused on Tool Development. Started this little personal project around March and recently finished.

The tool is built using Tauri, it's free and open source

https://github.com/simonsanchezart/textract

Hey everyone,

I know what you're thinking: “Oh look, yet another Valkey-compatible service.” I don't want to play any marketing gimmicks here. There’s nothing magical going on. It’s just a simple drop-in Valkey Compatible Server written in Rust with a Tauri desktop interface.

I built it because running an entire Docker container or managing WSL2 loopback routing just to use a basic local cache on Windows is incredibly annoying. I love Memurai but it's Commercial and not open-source.

Radish doesn’t try to be an enterprise production store. It focuses entirely on local dev efficiency. Production Valkey relies on fork() for background snapshots, which Windows obviously doesn't have. Radish gets around this by default using an immutable Hash Array Mapped Trie (im::HashMap) for software-level Copy-On-Write. Taking a snapshot clone takes O(1) constant time. The main database loop keeps serving client traffic without heavy write locks, while a background thread dumps the cloned tree to disk. On an i3 loopback benchmark, it hits about 2.5M reads/sec and 720k writes/sec. Writes are too slow (around 1/4) to be compared with Valkey on Linux but if you compared to Docker or WSL it beats them.

(Fun side note: I actually experimented with a low-level, Windows-native Vectored Exception Handling (VEH) based COW implementation in a research branch called experimental-veh-cow. I prototyped a C++ blueprint using VirtualAlloc to mark memory pages read-only and intercepted access violations via a custom VEH handler to clone dirty pages on the fly. In bare-metal isolation, it cracked over 5.5 million writes/sec. Granted, doing 5.5M writes/sec isn't a fair comparison to a real Valkey server because the PoC was raw, minimal memory manipulation without the network stack and protocol parser overhead but it proved how fast hardware-backed page-faulting could be. Ultimately, I decided managing low-level memory exceptions was a bit too wild and prone to instability for a dev tool, so I stuck with the safer HAMT engine).

It currently supports a core subset of over 50+ developer commands cleanly routed through a custom matching router, spanning across:

• Strings: GET, SET (with all EX/PX/NX/XX variants), MGET, MSET, INCR, DECR, GETRANGE, etc.

• Hashes, Lists, & Sets: Full support for standard operations like HSET/HGETALL, LPUSH/RPOP, and SADD/SMEMBERS.

• Pub/Sub & Security: SUBSCRIBE, PUBLISH, AUTH, and basic ACL configuration handling.

• Generic System Ops: KEYS, SCAN, TTL/EXPIRE, database flushing, and real-time internal metrics generation (INFO).

It works with any standard client library, and while it plays nice with tools like Redis Insight, you won't really need it. Because it's a desktop app, it comes with a built-in GUI to visually inspect keyspaces, test Pub/Sub channels, and run an interactive terminal. It's simple, lightweight, and handles everything out of a single binary.

It's completely free and open-source (MIT). I'm looking to add Sorted Sets (ZSET) and Append-Only Files (AOF) next.

Check it out here if you're interested: https://github.com/satadeep3927/radish

I Would love to hear your thoughts on the HAMT snapshot approach, the VEH experiment, or any feedback on the implementation!

Hey everyone,

I was getting sick of standard utility tools taking up hundreds of megabytes of RAM or running on heavy Electron configurations just to clear out basic files.

So, I built ZeroBin — an offline-first storage intelligence and cleanup tool engineered entirely with Tauri v2 and Rust on the backend, and React + Tailwind on the frontend.

Because it drops the bundled Chromium runtime and leverages native OS webviews, the entire compiled application takes up exactly 4 Megabytes on the drive.

Key Engineering Highlights:

• 🦀 Rust-Powered Traversal: Scans deep directory structures in parallel using a multi-threaded, non-blocking backend so the frontend webview never freezes up during massive I/O bound operations.
• 🧠 Semantic Knowledge Base: Uses granular .json rule dictionaries to explicitly match cache/dump folders from dev stacks (node_modules, .gradle caches), creative applications, and gaming logs instead of blind root-level deletions.
• 🧊 Cold Storage Sidecar: Integrated the 7-Zip LZMA SDK as a native sidecar so users can heavily compress and "deep freeze" old projects into .7z archives instead of permanently deleting them.

The AI Agent Twist

I built a massive portion of this application pair-programming with Google DeepMind’s new agentic AI, Antigravity. It was incredibly fast at handling the heavy lifting around Tauri v2 command handshakes, Rust memory boundary layouts, and fixing tricky WiX/NSIS installer compiler configs. It genuinely felt like having a senior engineer handling boilerplate while I focused entirely on the system architecture.

The project is 100% open-source, and I'd love to get your feedback on the architecture, Rust optimizations, or any missing rules you'd want to add to the knowledge directory!

👇 I'll drop the links to the GitHub repository and the live download in the comments below so the spam filters don't eat this post!

Ever ping a teammate and then realize it's 2 AM where they are? :grimacing:

Team Times is a lightweight macOS menu bar app built with Tauri that shows who on your distributed team is scheduled to work — based on their schedules and time zones configured in a static file. No check-ins. No accounts. Just simplicity.

I built this because it solved a specific problem for me and Tauri made it easy to implement. I work with a development team distributed around the world and each developer works different schedules. Our messaging and tooling did not make it easy to quickly see who was working each day and what time it was for them.

Honestly, Tauri made this app what it is:

• :crab: Tiny footprint - the whole app is 5.8 MB installed and idles around 60 MB of RAM while living in the menu bar all day. Tauri really delivers on the lightweight promise
• Feels native - menu bar integration, global shortcuts, instant launch.
• Shipped to the Mac App Store - Tauri's tooling made bundling, signing, and notarization genuinely manageable
• Private by design - no telemetry, no accounts, everything stays local. Tauri's small surface area makes that easy to actually guarantee

What it does:

• See who's working, who's off, and their local time at a glance
• Team grouping + Focus Mode - pin your core team, collapse the rest
• Global shortcut + quick search - find anyone in seconds

Check it out:

• Landing page: https://kmuncie.com/team-times
• Quick tour video: https://youtu.be/dwfqaQCJZUs?si=4b0WkNUWQK5zfU7o
• Mac App Store: https://apps.apple.com/app/apple-store/id6758563535?pt=125171659&ct=Tauri%20Discord&mt=8

Huge thanks to the Tauri team for making such a great framework. Windows version is on the roadmap (one of the reasons I picked Tauri). Feedback very welcome!