I’ve been working on Tabularis, an open-source desktop database client for Postgres, MySQL and SQLite.
It’s meant to be two things at once: a comfortable everyday SQL app (editor, notebooks, charts, visual tools) and a safe bridge for AI agents that want to read your schema or run queries, without you having to paste credentials into a chat.
Free, open source, runs locally. Would love your thoughts.
Hi, I ship a Tauri v2 app on Windows as an MSI (WiX bundle), installed per-machine into C:\Program Files\....
Updates go through tauri-plugin-updater against a self-hosted latest.json.
Current flow: check on startup → pre-download and verify the MSI in the background → show an "Install now" button → update.install() → UAC prompt.
It works, but non-technical users don't understand the elevation dialog and click on NO ^^
I want updates to be fully unattended. (like Chrome, firefox, and the other app)
Is there a solution ?
I made a post here about linXiv, asking for tips and tricks to Tauri, about two months ago but since have made a ton of QOL updates and mini, non-obtrusive features (RSS feeds, full-text search, to name a few) and finally added iroh for p2p sharing of research projects, notes, etc...
I would love some feedback as to if anyone finds it useful, interesting, or obvious improvements to make to it. I have found it to be very useful in my own physics research but still want to continue to refine it.
GitHub: linXiv
Website + Docs: linxiv.dev
Hey there!
Building synap.md — a self-hosted, Obsidian-style Markdown notes app. Notes stay plain \`.md\` files on your own disk, no lock-in. Web app (Nuxt) + a native Tauri/Rust desktop client that syncs against your own server, offline-capable.
Still WIP with rough edges, but usable — and I'd genuinely love contributors, especially if local-first sync or Rust interests you.
Repo: https://github.com/BungeeDEV/synap-monorepo (MIT)
I've been using T3 Code for a while and genuinely love its UI — the chat view, the workflows, the whole feel of it.
Then I discovered omp (oh-my-pi) and it was a wake-up call. My agents just feel powerful with it. The way it hands them tools, the rewriting hooks, the whole setup — they work so much better.
Problem: I missed the T3 Code experience. So I decided to marry the two.
I forked T3 Code and heavily modified it to run specifically on omp (omp --mode rpc). Stripped it down to omp only, added managed omp install and account login right in Settings. Bringing the omp functionality into the ui of t3 code and calling it pivot. Also thought about the name t3.14 but did not end up going with that name.
It's alpha. Rough around the edges, needs a lot of work. But I've been using it as my main driver for a couple days now and honestly? Really enjoying it. Figured I'd share it.
GitHub: https://github.com/13kparkin/Pivot
Edit: I know there are other gui wrappers out there for this type of thing but nothing that quite felt right for me like t3code does.
Hi everyone, I built an earlier app called SplitTimer using Tauri. I made it Windows 11 only because of the bundled webview2 and the binary size came down to 11mb. It was 230mb with webview2 bundled.
Now I have an earlier app called photo viewer classic. Looking at the usage data this app has a user base of 52 percent on windows 10. So it looks like any update will have to take them into account. I am not sure how to handle this because the electron version came in at 77mb. I want to create two versions, one for windows 10 and another for windows 11 but I still think the windows 10 version will have to be minimized somehow. Any suggestions on how to build a smaller version less than 100mb hopefully?
I ship a PR review app built on Tauri. Last week a dialog that was green in every test shipped as a header, a clipped search input, and a footer. The body rendered at height zero.
The cause is the flex: 1 shorthand. It expands to flex-basis: 0%, and a percentage basis needs a definite parent height, which an auto-height panel capped by max-height does not have. The spec says the fallback is content. Chromium does that. WebKit keeps the zero.
The part that cost me the evening: Playwright's WebKit is their own recent build, not the WKWebView you actually ship in, and neither engine in my harness reproduced it. Screenshot tests, all green, app broken.
Wrote up the mechanics, the spec citation, and what I changed about testing: https://nodreview.com/blog/wkwebview-flex-collapse/
Fix is flex: 1 1 auto. Curious if anyone has found a CI-friendly way to test against the real system webview, because Playwright clearly is not it.
I have been building a Tauri v2 app that needs to read pages sitting behind Cloudflare, and the approach ended up being unusual enough that it might be useful to someone here.
reqwest is useless here, the JavaScript challenge needs a real engine. So the app builds a WebviewWindow pointed at the target URL, waits until it clears, and then reads the rendered DOM back host side.
The main gotchas, in case they save someone time:
Tauri does not inject its IPC into external pages, which is correct and you would not want it there anyway. So getting the HTML out means going one level down: on Windows that is ICoreWebView2::ExecuteScript through webview2-com. It works well but it is Windows specific, so that whole module is cfg gated with a stub for other platforms.
ExecuteScript does not await a returned promise. An unresolved promise just serializes to null, so every script you send has to be synchronous, or use a poll for a global pattern instead of await. That one cost me a while.
Do not wait for readyState to be complete. Pages loading ad or tracker scripts can sit at interactive forever while being visually finished, so the readiness probe accepts interactive or complete plus a body size floor and a title check that excludes known challenge pages.
Concurrency needs one process wide ceiling, not a per command one. Every caller (a refresh, the discovery deck, a one off detail fetch) now draws from a single semaphore. Per caller limits looked fine in isolation and still stacked into multi second stalls and occasional ExecuteScript timeouts when two flows overlapped.
One more that is not Tauri specific but bit me hard: a synchronous #[tauri::command] runs on the main thread from the WebView2 callback, and a panic there cannot unwind across the FFI boundary, so the runtime aborts the process. In a release build with no console that shows up as the app simply closing, with nothing to go on. I ended up installing a panic hook that appends to a log file next to the database, which turned a crash dump investigation into reading one line.
The app is an anime episode tracker, source is here if anyone wants to look at the scraper module: https://github.com/Yearsuck/AnimeOnTrack
Curious whether anyone has done the same on macOS or Linux, since porting means reimplementing the eval bridge against WKWebView and WebKitGTK and I have not touched either.
Hey everyone!
I've been working on Orchestro, a desktop music player built with Tauri.
The idea was to create a Spotify-like experience, but focused on local music rather than requiring a streaming subscription.
I'm still actively developing it, so there's definitely more I'd like to improve.
GitHub: https://github.com/Kryiocifer/Orchestro
I'd really appreciate feedback, especially from people who have built Tauri applications or use local music players.
What features would you want to see in something like this?
If anyone here is into keyboards or cozy management games, I would love to get some feedback. Demo is playable in the browser.
I recently released HackySack, a free practice/live interview app for the desktop where you bring your own API key (BYOK). Built it using Tauri, Rust, and React.
Tech Stack & Architecture:
Building a BYOK AI tool in Tauri made a lot of sense to me, keeping API keys and interview histories entirely on the user's local machine instead of routing through an intermediary backend avoids privacy concerns and recurring server hosting costs.
I'd love any feedback, bug reports, or feature ideas—feel free to drop thoughts here or open an issue on GitHub!
hey everyone,
I made a local agentic voice assistant for Windows called Boris, and it’s built with Tauri v2.
Basically:
You say “Hey Boris” → it listens → turns voice into text (Parakeet ONNX) → LLM call → executes tools → talks back with Supertone TTS.
The voice pipeline runs fully on-device, only the LLM goes through OpenRouter right now.
I used Tauri + React + Vite + Bun for the desktop app. There’s a small always-on-top overlay, settings page, and the main window. I’m not a frontend person at all, so I used AI (mostly Grok) to help build and polish the Tauri side and UI. The core voice pipeline + agent logic is written in Rust by me.
This is my 2nd Rust project. Originally I just wanted something that could help me with LinkedIn/Twitter posts, but it slowly turned into this full voice assistant.
Please try the 1.1.0 beta if you want:
I’d really love any feedback — especially about the Tauri part (packaging, updater, overlay behavior, performance, etc.) or the overall experience.
thanks!
I got tired of opening VS Code and seeing it use 500+ MB of RAM just to edit some files.
Then I'd open a TypeScript project, add a few extensions, node_modules would show up, and suddenly the editor was using over 1 GB.
So one day I thought:
>
And that's how Astro Editor started.
It's built with Tauri 2 + Rust + React + TypeScript + Monaco.
Right now it uses around 9 MB of RAM in normal use, the executable is around 3.5 MB, and the MSI installer is about 1.75 MB.
Some of the things I've built so far:
One of the more annoying things I had to solve was Monaco's context menu.
I wanted a proper glass/blur effect, but Monaco renders its context menu inside a container with overflow: hidden, which basically kills the backdrop-filter effect.
So I disabled Monaco's context menu and built my own using a React Portal directly in <body>.
For TypeScript and JavaScript, I'm using Monaco's built-in TypeScript services for IntelliSense.
For other languages, I'm currently working on proper LSP support using Rust and JSON-RPC. That's one of the next things I want to improve.
I'm also planning:
The editor itself will be open source under GPLv3. I'm planning to keep AI and cloud features as optional paid services.
I'm not trying to replace VS Code. I know the ecosystem it has is massive.
I just wanted to build something that feels fast, lightweight and doesn't need hundreds of megabytes of RAM just to show a text file.
If anyone wants to check it out, here's the repo:
I'd genuinely love some feedback, especially from people who have built editors, worked with Tauri/Rust, or have ideas for features I should add.
Roast it if you want
Built from Mexico
Hi everyone, I’m new to the community. I just wanted to get some advice.
I’m a web developer with 3 years of experience. Most of my past work has been with SaaS companies dealing with large amounts of data and cloud-based applications.
I recently joined a new company in a new country, and I’ve been tasked with building an offline simulation software that will capture data from sensors while also handling RBAC and a database.
The architecture requires WebSockets, REST APIs, and UDP protocols. The V1 of the web app is ready, but it was tested on my local machine. Basically, the software and the sensors communicate through Wi-Fi.
Since it needs to be an offline-first app, I initially wanted to package it as an Electron .exe. At first, I used Node.js with Express, React, and SQLite. It was a prototype and it worked, and the .exe wasn’t even that large — around 400 MB max. However, the code became too complex and there wasn’t really any proper structure. Most of it was also built with AI, so looking back, the way I approached it wasn’t great.
I then decided to use NestJS because of its opinionated structure and because there were some new requirements. So I rewrote the entire backend using NestJS and Prisma. It was a really good experience, and I got to learn NestJS along the way.
But when I tried to package everything into an .exe, it ended up being more than 700 MB. The tablets that the software is supposed to run on couldn’t handle it and wouldn’t even install it.
While researching possible alternatives, I came across Tauri, and it looks like it could be a really good choice for this kind of application, especially because of the much smaller bundle size.
My main concern is whether I’ll lose any of the features I currently have with Electron, especially since I need UDP, WebSockets, REST APIs, Prisma/SQLite, and offline functionality.
Could Tauri with a NestJS sidecar give me the smaller footprint without forcing me to rewrite or lose any of the functionality I already have?
Built a local-first writing editor using Tauri v2.
llama.cpp)GitHub: https://github.com/AashishH15/Lexicon
Website: https://lexicon-writer.pages.dev/
I built this because I wanted an offline Grammarly alternative where my drafts never touch a cloud server. Let me know what you think!
If you want to build a polished macOS app with Tauri, there is one tradeoff worth knowing early: Tauri gives you a webview, not a library of native UI components.
In Tauri, a button, switch or segmented control is still HTML and CSS inside WKWebView. There is no equivalent layer that turns the components in my React interface into native macOS controls (like in React Native), so I needed to build and style that component system myself.
I knew that when I chose Tauri for Abstand, an open-source app and website blocker for macOS. Desktop apps can be quite custom anyway and I was happy to make that tradeoff to keep working with React and Rust.
The above GIF scrolls through the shared components I ended up building: buttons, switches, sliders, toggles, segmented controls, inputs, menus, dialogs and settings rows.
They use accessible web primitives for behavior, but the visual layer is designed specifically for macOS. That meant defining the small details myself:
None of those details is especially difficult alone. The work comes from rebuilding the full set and making every component and state feel consistent. At least for me, getting from a functional web interface to something that feels at home on macOS took time.
The upside is that I still get React, CSS and fast UI iteration. I can shape components more freely than native controls allow and the same component system now makes new screens much faster to build.
CSS was enough for most of what you see in the GIF. I only reached for Swift and AppKit when macOS behavior itself became part of the feature, such as window levels, transparent overlays and system font metrics.
Liquid Glass introduced another tradeoff. Making WKWebView transparent over the native glass effect currently requires a private KVC key. That works for a directly distributed, signed and notarized app. An App Store build would need to disable that path and use the fallback instead.
For Abstand, the tradeoff has been worth it. The result can feel native while still giving me the flexibility of the web stack. It just takes deliberate component work to get there.
GitHub: https://github.com/builder-group/abstand
Components: https://github.com/builder-group/abstand/tree/develop/apps/desktop/src/components
If you have tried to make a Tauri app feel native: did you build your own components, use an existing system, or accept a more web-like interface?
Hi everyone! 👋
A few months ago, I shared with you the first version of GianoReader, my open-source desktop app for reading books in their original language with a synchronized, side-by-side translation.
Personally, I use this application a lot, but I find it uncomfortable having to read on a monitor and, like many of you, I would prefer having a mobile version to read comfortably while lying on the couch.
Porting Giano Reader into an Android and iOS app is technically feasible, but it clashes with the translation API usage policies, which would no longer be free.
For this reason, I equipped Giano Reader with a Web Server mode to access the application from any device on the LAN (and if you then want to access it from the outside, I've included instructions in the Manual on how to do it via Tailscale).
Here is the big news:
This is the main new feature. Now, with a simple click from the desktop app, you can activate the built-in Web Server. What does this mean in practice?
No leaps in the dark. If you start reading a chapter on your PC and then move to bed with your tablet via the Web Server, your reading progress, bookmarks, and translation status remain perfectly synchronized. The PC acts as the "brain", the phone as the "screen".
As always, the project is 100% open-source and free. You can download the installers (for Windows, macOS, and Linux) or take a look at the source code directly on GitHub:
👉 https://github.com/DrLoki/GianoReader
🗄️Download
If you had tried the old version, I invite you to give the new Web Server feature a chance. If you find it useful for learning new languages (or if you simply like the idea), a ⭐ on GitHub is the best way to support the project!
As always, I am very open to feedback, advice, or bug reports. Happy bilingual reading, now also from the couch! 📖✨
It’s now fully replaced whatsapp web for me.
Built with Tauri + SolidJS, ~7 MB:
• themes
• Ctrl/Cmd+K search
• Ctrl+Tab chat switching
• split view
• one-click history sync
• control Codex agents through WhatsApp (like buzz)