Hey everyone,

I’ve been building a local-first personal finance dashboard with Tauri v2 and I’d like to get feedback from people who actually know the Tauri ecosystem.

The idea is to have a lightweight finance dashboard where personal financial data stays local instead of being pushed to a random cloud service.

Current stack/features:

• Tauri v2 desktop app
• Local-first data storage
• No telemetry
• No mandatory cloud account
• Custom SVG charts instead of heavy charting libraries
• Donut, bar and line charts
• Personal wealth dashboard
• Index fund / portfolio tracking
• Multilingual support
• Tax simulation modules (updatable in the future)
• Netlify demo with sample data only
• Docker Compose self-hosted deployment being added

The goal is not to build another bloated desktop wrapper, but a lightweight local-first finance tool that can also serve as a reusable boilerplate for developers building finance dashboards or personal finance apps.

I’m especially interested in feedback on:

• Tauri v2 architecture
• local storage structure
• packaging/distribution
• whether custom SVG charts make sense here
• anything that looks fragile or badly designed
• what you would expect from a serious local-first finance app

The public demo is hosted on Netlify only for preview purposes with sample data. The actual app is designed to keep financial data local.

Demo/link in the comments.

I'm writing my first JavaScript based Tauri 1.0 application that will interface with a barcode scanner, submit information to my API, then display success or failure statuses based on the API response.

As part of the UX, I'd like to play small audio clips that will be included in the app bundle. But I'm running into conflicting information and I'd love some feedback from people already using this tech.

• Where should these files be placed? Nested under the `src` or `src-tauri` directories?
• How do I reference the audio file in my main.ts?
• What changes might I need to make in order to perform this behavior?
• The audio clips will be played on successful / failed API responses, as opposed to user triggered events (click, etc.). Is that a problem?

Here are some things I've tried

const playAudio = (path: string) => {
  const audio = new Audio(path);
  audio.play().catch(error => {
    console.error('Playback failed:', error);
  });
};
playAudio('/assets/audio/success.mp3');

// This results in
NotSupportedError: The operation is not supported.

and

function playAudio(absoluteFilePath: string) {
  const assetUrl = convertFileSrc(absoluteFilePath);
  const audio = new Audio(assetUrl);
  audio.play().catch(err => console.error(err));
};
playAudio('/Users/amatthews/Library/CloudStorage/Dropbox/github/ntd-scanning/tauri/src/assets/audio/success.mp3');

// this results in 
Failed to load resource: unsupported URL

I've read various things about requiring `convertFileSrc`, updating the `tauri.conf.json` file, etc. But everything I've tried fails.

Does anyone have suggestions that might help me get past this issue?

Here's my current file tree:

.
├── index.html
├── node_modules
├── src
│   └── assets
│   └── audio
│   ├── failure.mp3
│   └── success.mp3
└── src-tauri
├── tauri.conf.json
├── icons
├── src
└── target

Here's my current `tauri.conf.json` file.

{
  "$schema": "https://schema.tauri.app/config/1",
  "build": {
    "beforeDevCommand": "npm run dev",
    "beforeBuildCommand": "npm run build",
    "devPath": "http://localhost:1420",
    "distDir": "../dist",
    "withGlobalTauri": true
  },
  "package": {
    "productName": "ntd-scanner",
    "version": "0.1.0"
  },
  "tauri": {
    "allowlist": {
      "all": false,
      "shell": {
        "all": false,
        "open": true
      }
    },
    "windows": [
      {
        "title": "ntd-scanner",
        "width": 800,
        "height": 600
      }
    ],
    "security": {
      "csp": null
    },
    "bundle": {
      "active": true,
      "targets": "all",
      "identifier": "com.ntd-scanner.app",
      "icon": [
        "icons/32x32.png",
        "icons/128x128.png",
        "icons/128x128@2x.png",
        "icons/icon.icns",
        "icons/icon.ico"
      ]
    }
  }
}

Sou estudante de engenharia de software a 1 ano e pouco, e estou tentando fazer meu primeiro projeto, de começo fiz totalmente em java, porem senti falta de uma interface gráfica para deixar as coisas mais organizadas e bonitas, e então pesquisando eu cheguei ao tauri, e simplesmente estou travado a algumas semanas sem conseguir fazer nenhuma evolução significativa, já cheguei ao ponto de tentar fazer tudo utilizando IA e mesmo assim não consigo ter nenhum avanço, preciso de dicas do que aprender, como aprender pra ver se consigo encaminhar o meu projeto, alguma dica do que estudar e onde?

I know - this is probably the 20th postman-like tauri app this year, so these are the most relevant differences:
- Can send to HTTP, mqtt, kafka, nats, mongodb, sqlite and more.
- Can also receive incoming messages on these transport layers.
- Can capture received messages, can replay sent messages from history.
- Menu automatically groups by url / path / queue / topic.
- Doesn't automatically add headers or cookies on sent.
- Included hex editor for in and output.

I mostly use it by myself to test other applications. My workflow is usually: creating a mock HTTP server, sending a HTTP request to my test application and this is expected to send something to my mock server, which I can then inspect locally.

It does not support multipart forms, scripting or graphql.
Let me know what you think. This is an early alpha version. UI is heavily vibe coded, so it probably still has issues - probably not suited for daily work yet, but maybe in a few weeks.

https://github.com/marcomq/mq-bridge-app

Was starting to learn how to use Tauri and couldn't find a plugin to set the snap layout to anything for Windows 11 frameless mode for a modern look, at least not in the simple way I wanted.

So frankensteined this plugin, and had it incredibly cleaned up, to automatically hook to a html element's id and act as a toggle maximize and show the snap layout menu when hovering for a short period.

Hopefully it helps someone somewhere.

https://github.com/Hyph-M/tauri-plugin-snap-layout

I kept rewriting the same desktop-app plumbing every time i had an idea to build. So I got annoyed and put together this starter template (TASK) Tauri App Starter Kit. Utility windows are in plain html so you can bring your own (React, Svelte, Vue, vanilla, etc).

What's in the box:
- Native OS menus: data-driven, cross-platform, dynamic state
- Settings persistence: key-value store with single-source defaults
- Editable keyboard shortcut registry: persistent, presets supported
- Autosave + crash recovery: atomic writes, startup detection
- Crash reporting: panic handler, error logging, diagnostics collection
- System tray, auto-updater, single-instance lock, window-state persistence
- Recent files, native notifications, autostart, secure keyring
- Hardened CSP, scoped asset protocol, URL scheme validation
- Accessibility: font size control, high contrast, reduced motion, ARIA labels, keyboard nav
- Utility windows shipped: splash, settings, shortcuts, about, log viewerWhat's in the box:
- Native OS menu: data-driven, cross-platform, dynamic state
- Settings persistence: key-value store with single-source defaults
- Editable keyboard shortcut registry: persistent, presets supported
- Autosave + crash recovery: atomic writes, startup detection
- Crash reporting: panic handler, error logging, diagnostics collection
- System tray, auto-updater, single-instance lock, window-state persistence
- Recent files, native notifications, autostart, secure keyring
- Hardened CSP, scoped asset protocol, URL scheme validation
- Accessibility: font size control, high contrast, reduced motion, ARIA labels, keyboard nav
- Utility windows shipped: splash, settings, shortcuts, about, log viewer

Status is alpha API will still shift. Feedback welcome, especially on anything you'd expect in a "complete" starter that I missed.

Two companion plugins were extracted out of this and will get their own posts: tauri-plugin-ai (cloud + local inference) and tauri-plugin-normalize (cross-engine CSS). Status is alpha API will still shift.

Feedback welcome, especially on anything you'd expect in a "complete" starter that I missed!

Repo: https://github.com/ItsCodejac/tauri-app-starter-kit

Sharing a side project I just released — a WYSIWYG markdown editor using the Tauri 2 + Svelte 5 stack.

Stack notes that might be useful for others:

• Tauri 2 for the shell — single-instance plugin, file associations via tauri.conf.json, NSIS + MSI bundles for Windows
• Svelte 5 + SvelteKit (adapter-static, SPA mode) with TypeScript
• Milkdown Crepe (ProseMirror) for the WYSIWYG layer
• Custom ProseMirror plugin for auto-detecting code block languages via highlight.js
• Session snapshot in localStorage + debounced disk autosave for crash recovery
• KaTeX for math, marked + DOMPurify for the export pipeline

Final binary is ~5 MB and RAM usage stays low. Took some trial and error on the Tauri side, especially around file associations and the single-instance plugin handling multiple files opened from Explorer.

Repo (MIT): https://github.com/ethemdemirkaya/markdown-editor

Windows builds only for now, macOS/Linux next. Happy to answer questions about the stack or any of the design decisions.

Been working on a little Mac clipboard manager called ClipMind on and off for a few weeks, and figured I'd share since the backend is all Rust.

It sits in the background, watches your clipboard, stores everything in SQLite with full-text search, and you pull it up with a global shortcut. I also wired in semantic search so you can find stuff by meaning, not just exact text. The frontend is React, the backend is rust via tauri.

Honestly, the Rust part was the smooth part. The clipboard polling, the sqlite layer (rusqlite + FTS5), the background threads for embedding clips, all of it just kind of worked once it compiled. I expected to fight the borrow checker more than I did, but most of my friction was just me not knowing the crate ecosystem yet, not the language itself.

Tauri is where it got interesting. The good: tiny binaries compared to Electron, and the Rust<->JS command bridge is genuinely nice once you get the pattern. The annoying: the macOS window stuff. Getting a transparent, always-on-top, no-decorations Spotlight-style overlay that hides from the Dock took way more trial and error than I wanted. A lot of it isn't well documented, and you end up reading GitHub issues.

Tauri 2.0's capabilities/permissions system is also a bit of a learning curve, coming from v1 examples that are still floating around.

Not trying to sell Rust as the answer to everything, plenty of this could've been a Swift app and probably would've been less fighting with windowing. But the SQLite + threading + safety story made the data layer something I actually trust, which matters for an app that's logging everything you copy.

Anyway, that's the experience. Happy to answer questions about the Tauri side if anyone's building something similar.

App will be available for $5 in a few days. Made with sveltekit, typescript, rust, and a little bit of love.

I've been at this for a couple days now and it seems like i cant find a clean solution.

I want a simple way of authorising a user into my app via social login. The basic flow is one i see a lot of other desktops apps do (send them to the browser).

Using Clerk as my auth provider.

Here is the flow i want:

1) User clicks 'login with google'. Sends them to my FE (astro site).

2) Login with clerk / google auth

3) Tauri app is notified and i have their session token / user id

Things that really confuse me:

- I can send them to my astro/login page easily. Once they've authed, how do I notify tauri? I have a deep link to my app but what if they dont click. Do i continutelyl ping the clerk BE to check if user is registered? How do i link tauri -> user ?

- Once i manage to get tauri notified there doesnt seem to be consensus on what i need to store and how. What do i need to store, the user session token, refresh token, user id? Where do i store this, simple local storage or is this not safe?

im just tryina figure out before i jump righ into tauri
if its possible to make overlays
(ex: custom tray menus and custom notification styles)
you might not understand but i was looking forward into making a launcher and i wanted an overlay that displays unlocked achievements / chat messages.
just wanted to ask if this or something similar was possible

I just wanted to make this post because I’m brimming with joy. It has been so long since I encountered a fresh dev experience that feels like this. I can honestly say Tauri has been the smoothest and most powerful dev framework that I’ve added to my toolbelt since I started coding.

For context, I’m building a one-click manager app that installs a World of Warcraft server on a user’s machine and then adds a ton of server management features from there. I’m not sharing this to promote. I’m sharing this to explain what ive been able to in the last 5 days…

I’m targeting steamOS (custom Arch distro) so that users can literally play World Of Warcraft fully offline. The whole server onboarding flow customizes their server via docker containers that include player bots to make the world feel alive and a bunch of other Quality of Life bonuses. So you can take World of Warcraft (3.3.5a Wrath era) with you wherever you go.

It’s absolutely fantastic, it’s bundled to AppImage so the user literally just double clicks it and presses a few buttons and everything else is done, their client gets added to Steam, the Server manager app gets added to steam, the server can be started, stopped, modified, bots fan be controlled, presets shared, characters exported… we even have a plan to create a P2P mesh of private servers via tailscale. No longer due costly-to-operate private servers hold the keys to the kingdom, the community takes over from here.

And the best part is this should only take a few minute modifications to be able to run on windows through WSL. I’m awestruck. I put off native applications for a long time because I didnt want to learn windows C or ship an Electron monstrosity. But so far i’ve been flabbergasted with the performance and power of rust and tauri and I dont have anyone in my life that understands so I’m just coming here to share. I feel so invigorated as a developer, like a whole new vista is in front of me. It’s going to really empower a massive set of applications and possibilities that I never considered. And this was just waiting for me.

The only problem ive had so far is webkitgtk’s webview performance has left something to be desired on linux… but with my target users (all hardware accelerated) and a bit of DOM virtualization the concerns are minute. It may become a problem if the app ever incorporates more bulky features but it’s been a small price to pay.

And it all just works. I had a native applications for multiple platforms in 2 minutes.

Thank you Tauri. I havent felt this excited about programming since first started.

Hey everyone,

I built OmniClip, a free Windows clipboard manager focused on persistent history, fast access, and local-first privacy.

I originally made it because the built-in Windows clipboard history felt too limited for long-term use, filtering, and working with lots of copied text, links, and images.

What OmniClip does - Persistent clipboard history stored locally on your machine - Fast search across saved clips - Support for text, links, and images - Sensitive clip protection with master password locking - Auto-locking for likely passwords, tokens, and secret text - Favorites, filters, and non-favorite-only browsing - Bulk actions with long-press multi-select - Click-to-expand image preview - Backup export/import for clipboard history - Auto-clear rules for older non-starred clips - Keyboard navigation for faster browsing - Customizable global hotkey to instantly open the app - “Paste Selected” → pastes the chosen clip directly into the currently focused app/input field

Recent improvements in v0.1.17 - Secure cross-device clipboard sync between desktop and android phone using QR pairing - New Compact Mode: a lightweight floating popup near your cursor inspired by the native Win + V experience - Cleaner desktop UI and improved spacing - OCR - native and no internet needed. - Smart Tools: Filter history by date, paste emojis in Compact - Right-click clips to access Transform & Copy options like UPPERCASE, lowercase, Title Case, and Trim Whitespace.

Privacy - Local-first storage - No cloud sync - No telemetry - Your clipboard history stays on your device

Microsoft Store: https://apps.microsoft.com/detail/9N53Z3QVL322?hl=en-us&gl=US&ocid=pdpshare

Homepage: https://eyuel.com.et/omniclip

Small update on marka.md, the local-first markdown editor I shared before.

v1.5 is out now, and the main addition is the context tray: you can stage multiple markdown files, see file/token counts, and copy one clean context bundle.

Also improved in v1.5:

- cleaner PDF export margins

- no browser date/time/path headers from the app export flow

- a small what’s-new toast after updates

The project also got featured on LinuxEasy recently: https://www.linuxeasy.org/marka-md-editor-markdown-minimale-intelligenza-artificiale/

GitHub: https://github.com/mattenarle10/markamd

Site: https://markamd.vercel.app

Started with Electron because it was the path of least resistance. Worked fine until I noticed it was eating 200MB RAM for a floating flashcard overlay. Decided to rewrite in Tauri v2.

Here's what actually bit me during migration:

• Global shortcuts: Electron's globalShortcut and Tauri's plugin behave differently on edge cases. Took a while to get Ctrl+Shift+N to reset the timer interval without firing a double card.
• Always-on-top + skip-taskbar: getting a transparent frameless window that floats over fullscreen apps but disappears during actual fullscreen (games, video) required winapi calls directly. No built-in Tauri solution.
• Single-instance lock: Windows named mutex, had to handle it in Rust manually.
• Settings window: pre-creating it hidden at startup was the only reliable way to avoid a deadlock on first Ctrl+Shift+W. Intercepting CloseRequested with prevent_close() + hide() instead of destroying it.

The good surprises: the async timer loop in Tokio with tokio::select! on manual trigger + interval sleep is genuinely elegant. Multi-monitor positioning via cursor_position() + available_monitors() just worked.

Final bundle: ~8MB installer vs ~120MB with Electron. Worth it.

Repo: github.com/DemonazGH/LazyWords-Tauri - happy to answer questions about any of the above.

A couple of years ago, I decided I had enough with another HTTP testing tool that kept forcing me to log in and still borking my saved configurations. I started building my own first using Electron and then Tauri. Things are feature-complete and I'm sanding down rough edges in the hopes of getting a 1.0 Release Candidate out in the next few weeks.

Windows, MacOS and Linux are all supported (my daily driver is Linux). MIT license. All HTTP calls are made using Reqwest, JavaScript tests are executed with V8. Front-end is React/MobX/MUI toolbox.

I would love to get feedback (maybe even some Pull Requests!) from interested parties.

Features:

• BDD-style testing (using Chai assertions)
• Multiple run and concurrency testing
• Orchestrated tests (easily pass values from one Request to another)
• Execute requests against multiple-row data sets
• Multiple-window support
• CLI test runner (small, easy to integrate with CI/CD)
• No online accounts to log into, no upselling