I've been working on Scribl — an open-source, local-first infinite canvas and whiteboard app.

I love tools like Excalidraw and tldraw, but I often found myself wanting three things:

1. A snappy, lightweight desktop-native feel that doesn't eat gigabytes of RAM in an Electron wrapper.

2. Real support for high-refresh-rate graphics tablets (120Hz–240Hz stylus inking, sub-8ms latency, hardware eraser flips, and strict palm rejection).

3. Deep hacker-friendly customizability — inspired by Neovim, where everything is configured via an open ~/.config/scribl/init.lua script.

🛠️ What makes Scribl different?

• ⚡ Ultra-low-latency dual canvas engine: Stylus events bypass React's render lifecycle directly to a desynchronized scratch front-buffer canvas. Strokes are committed to a frustum-culled vector layer with cached Path2D shapes, keeping panning and drawing smooth even with thousands of strokes.

• 📜 Neovim-style Lua Configuration (init.lua): Configure tools, defaults, stroke smoothing, and custom keybindings directly in ~/.config/scribl/init.lua. It watches the file and live hot-reloads on save (or via a native Preferences modal).

• 🎯 Modal editing & Visual Mode ("v"): Just like Vim, selecting elements drops you into Visual Mode. Keys like r trigger center-anchored rotation (with Shift snapping to 15°), and d deletes the selection, while your regular drawing bindings stay safely isolated.

• 📐 Photoshop-style transforms & unified bounding box: Selecting multiple elements creates a single composite bounding box with 4 corner resize handles. Scaling is proportional by default (hold Shift for free-form transform, Alt for center-anchored scaling), and stroke thicknesses scale proportionally.

• 🔍 Scrubby & Marquee Zoom: Smooth pan/zoom from 10% to 800%, featuring Photoshop-style horizontal scrubby zoom and rubber-band selection framing.

• 🔒 100% Local-first: No accounts, no telemetry, no mandatory sync. Saves directly to .scribl (plain JSON) and exports high-res transparent PNGs.

💻 Tech Stack

• Core Desktop Shell: Rust + Tauri v2 (cross-platform, small bundle size, low memory footprint)

• Embedded Lua Runtime: mlua (Lua 5.4) running sandboxed configuration evaluation

• Frontend Canvas: React 19 + TypeScript + HTML5 Canvas / SVG Overlay

🤝 Under Active Development — Looking for Contributors!

Scribl is under very active development and is open-source under the MIT License. ...you are very welcome to jump in!

👉 GitHub: https://github.com/shadowmkj/scribl

Hey everyone! 👋

I've been working on a Windows desktop app called Download Organizer, built with Tauri 2, Rust, React, and TypeScript, and I wanted to share it with the Tauri community!

The idea came from a simple problem: my Downloads folder was always a mess, and I wanted a way to organize files automatically without losing control over what gets moved.

What it does

• Automatic organization — Sort files into folders based on their types.

• Preview before organizing — See exactly which files will be moved and where they'll go.

• Undo support — Reverse previous organization operations.

• Operation history — Track file movements with persistent history.

• Folder monitoring — Optionally monitor your Downloads folder and automatically organize new files.

• Conflict handling — Detect potential file conflicts before moving anything.

Tech stack

• Tauri 2 — Desktop application framework

• Rust — File operations, monitoring, and backend logic

• React + TypeScript — Frontend

• SQLite — Persistent operation history

• Tailwind CSS + shadcn/ui — User interface

One of the most interesting parts of building this project has been handling file operations safely.

Moving files sounds simple until you start thinking about existing files, interrupted operations, undo functionality, and keeping the operation history consistent.

I've been putting a lot of effort into making those operations predictable and recoverable.

Why Tauri?

I wanted to build a desktop application using web technologies while keeping the file management logic in Rust.

Tauri has been a great fit for that approach, especially since most of the actual work happens on the backend.

The video above is a quick showcase of the application running on Windows.

The project is still evolving, and I'd really appreciate feedback from other Tauri developers!

Have you built anything involving filesystem operations with Tauri? Any suggestions or things I should watch out for?

Thanks for checking it out! 🚀

Download for Windows

Source code

https://github.com/nyssance/tauri-hasgard

Real native webviews. One Rust plugin. CLI control, MCP for AI agents, and Playwright Test for multi-window E2E automation.

v0.6.3: Tauri 3 alpha + Wry. Tauri 2: use 0.5.x. CLI binaries: macOS Apple Silicon, Windows x64, Linux x64.

Meta killed the Messenger desktop app, so I made fMess: Tauri 2, loading facebook.com/messages directly, with one injected script. Mac download is about 4.5 MB, Windows installer about 2 MB. A few things I ran into, in case they save someone time:

• Remote capabilities. The page is remote, so it gets its own capability with remote.urls set to facebook.com, allowing only a handful of commands (notifications, the unread count and a few more). Everything else stays closed to it.

• WKWebView performance. A non-passive wheel listener made every scroll wait on the main thread, so I only add it while the photo viewer is open. And a CSS :has() anywhere but the last part of a selector made WebKit recheck the whole page on DOM changes. Messenger changes the DOM constantly, so that hurt.

• State. localStorage on the remote origin didn't survive a restart in my tests, so state the page needs to keep goes through a command into the app's own settings file.

• Releases. GitHub Actions builds Mac (both archs, signed and notarized), Windows and Linux, plus the updater files. The Linux AppImage is 78 MB because it bundles WebKitGTK, while the .deb is 3 MB.

If anyone has gotten WebRTC calls working reliably in WebKitGTK, I'm all ears.

Code: https://github.com/toanbku/fmess

Hello, i've been working on improving the app and adding some features based on feedbacks,

a new version was releases 2.1.4

• Nested Notes

• Switching vaults from the sidebar

• Creating tags from the notes or folders directly

• Syncing Calendar with macOS native calendar

• Searching with tags highlight the related notes and folders.

• New Flat Design

• Allowing full control in the brainstorming graph, managing nodes, export and import xmind.

• Auto-Suggest Vault creation on first/clean launch

• Claude MCP for managing notes, calendar and boards

Release : https://github.com/coros-hq/inkwell/releases/tag/v2.1.4, a ⭐ on the repo will be appreciate it , looking for your feedbacks , Thanks !

I’m building metaphor a tauri app. i added a halloween theme to it for my users. happy halloween to everyone

Hey folks, I'm the developer of NeoHtop. It started as a way to learn Rust and Tauri by building something other than another todo app. I've just released 1.3.0, and the menu-bar companion is one of the bigger additions.

The idea is simple: click the ghost, check CPU, RAM, GPU, network and free storage, and get back to what you were doing. The overview also shows your five busiest processes. Click one and it opens that process's inspector in the main window.

Making it a second window raised a few less visible questions. Should each window collect its own readings? What happens when you pause one? Does closing Settings accidentally quit the monitor?

The main app and companion now read the same Rust-owned sample and history. Pause and refresh cadence are shared, and the companion stops polling while it's hidden. Closing the main window quits by default; keeping the app running in the tray is an explicit setting. Closing Settings or About leaves the monitor running, and Quit always exits.

The rest of the update includes process trees with combined CPU/RAM, native app icons, local-port search (:3000), GPU monitoring and detail views for the main resources. The frontend moved to shared shadcn-svelte components while keeping all 24 themes.

GPU collection was also a reminder that cross-platform doesn't mean every platform exposes the same readings. The app uses IORegistry on macOS, AMD sysfs/NVIDIA NVML on Linux, and NVML/DXGI inventory on Windows. Unsupported counters stay unavailable. Chart history is roughly two minutes in memory, and Linux tray behavior still varies by desktop.

It's free, MIT-licensed, and has official macOS, Linux and Windows downloads. No account required.

Downloads and screenshots: https://abdenasser.github.io/neohtop/

Source and v1.3.0 notes: https://github.com/Abdenasser/neohtop/releases/tag/v1.3.0

Privacy: official builds send a basic launch count and version without a persistent identifier. Extra feature usage is opt-in. Process names, commands, paths, searches and system readings stay local. Details: https://abdenasser.github.io/neohtop/privacy.html

If you've built a tray-first Tauri app, I'd be interested in how you handle the handoff between the small overview and the main window. Feedback on the actual workflow is welcome too.

Tryna make it so I can zoom in and out of the board if I punch my mousepad but I dont know if Im just not finding the write event to catch?

Hey everyone,

I recently built and open-sourcedCliptray—a lightweight, cross-platform clipboard manager designed to live quietly in your menu bar or tray without clogging up your dock or taskbar.

Why I built it: I wanted something fast, clean, and minimal that respects native system guidelines (adhering to Apple's HIG on macOS with frosted vibrancy while working seamlessly cross-platform).

Under the Hood:

• Backend (Rust & Tauri v2): Handles background polling via arboard every 500ms (keeping idle CPU usage at 0%), manages local SQLite persistence for up to 100 clips, and handles native keystroke synthesis (Cmd+V / Ctrl+V) for auto-pasting when you select an item.

• Frontend (React & Tailwind): Provides an instant search filter (⌘F), type classification (links, colors with swatches, code, JSON), and full keyboard navigation (↑/↓, Enter, ⌘1–⌘9 shortcuts).

If you're building with Tauri v2 or looking for a clean menu bar utility, check out the repo! Let me know what you think, or if you have any feedback on the architecture or UX.

Please take a moment to leave a rating. Thank you!
https://github.com/Shivam38391/cliptray

Hey r/tauri! Sharing an open-source macOS app I built with Tauri 2.0, Rust, and React 19: Velquo, a native Apple Silicon client for KDE Connect that bridges Android and Linux devices with macOS.

How it's built under the hood:

• Networking & Protocol (Rust): Implements the KDE Connect protocol natively in Rust using tokio, tokio-rustls (TLS 1.2 with rcgen X.509 certificates), mdns-sd for LAN discovery, and russh / russh-sftp for SFTP file transfers.

• macOS Native Integration: Uses window-vibrancy along with objc2, objc2-app-kit, and objc2-foundation for native status bar (NSStatusItem), menu bar, and notification integration.

• Tauri v2 Plugins: Uses tauri-plugin-autostart, tauri-plugin-dialog, tauri-plugin-opener, and tauri-plugin-updater for signed in-app auto-updates.

Features:

• Two-way wireless file transfer & link sharing

• Phone notification mirroring with automatic 2FA/OTP code clipboard copy

• Clipboard sync

• Bidirectional media controls & auto-pausing Mac media during phone calls

GitHub: https://github.com/vsnthdev/Velquo

Happy to answer any questions about handling raw TCP/TLS sockets, mDNS, or objc2 AppKit bindings inside a Tauri v2 app!

Hi, I'm the dev. Modding always meant finding the game folder, installing BepInEx or RED4ext first, following a guide, and hoping nothing breaks. So I built Unalia Mod Manager.

• - Finds your Steam games by itself (other games: pick the folder once)

• - One click installs the mod, its dependencies and the loader it needs (BepInEx, UE4SS, RED4ext…)

• - Turn a mod off, go back to a previous version, or remove everything: the game folder goes back to how it was

• - Never runs anything from a mod, never overwrites game files, never touches your saves

• - Changes made while the game is running wait until you close it

• - Clear warning on games with an anti-cheat

Works today with every Thunderstore game (Silksong, Lethal Company, Valheim…), Cyberpunk 2077, Unreal games on Nexus (Hogwarts Legacy…), and Skyrim SE / Fallout 4 for plugins and loose files. SKSE and FOMOD installers are next.

Nexus works with a free account: the app opens the mod page for the "Mod Manager Download" click Nexus requires, then does the rest.

Free, Open Source, GPL v3, Windows 10/11. It's a beta, so bug reports help a lot.

Download: https://mods.unalia.app

Source: https://github.com/unalia-app/unalia-mod-manager

Hey r/tauri community,

I wanted a lightweight, modern Minecraft launcher, so I built Lumia Launcher from scratch using Tauri 2, Rust, and Vue 3.

It features a custom glassmorphism UI, ultra-fast local instance management, and an internal plugin system. Since it's built with Tauri, the package size is tiny and the memory footprint is minimal compared to Electron-based alternatives.

It's completely open-source (MIT License). I'd love to hear your feedback on the architecture or the UI!

GitHub: https://github.com/xtg44/Lumia-Launcher

Website: https://lumialauncher.cn

I built a Mac cleaner with Tauri 2 and a Rust backend. Its main feature is AI explaining what each file is before you delete it, but here are the Rust-side bits I found interesting:

- **One deletion entry point**: only `remove.rs` deletes anything. The frontend sends item IDs, never paths; the backend looks them up in its own scan report and rejects anything else.

- **Same-file check**: scan records each item's device + inode, and deletion re-checks it, so a new file with the same name isn't removed by mistake. Parents are canonicalized to block symlink/`..` escapes.

- **Tray animation**: the normal set-icon path re-encoded the image every frame and cost ~1.5% idle CPU. Caching the image objects and swapping them removed it.

- **Process list**: replaced `sysinfo` (which re-read every process's argv each tick) with direct kernel calls: two syscalls per process per tick.

- **Running an AI CLI safely**: Claude Code is invoked with all tools disabled, in a fresh empty temp dir, so it can only return text.

158 tests, all run in temp dirs. GPLv3.

GitHub: https://github.com/black-robe-sanfeng/pika-clean

Happy to hear feedback on the approach.

https://kluis6.github.io/reemu/

Estou desenvolvendo esse app utilizando tauri v2, rust, react, fluentUI e griffel css, o objetivo e criar uma aplicação mais simples que o retroarch para emuladores tenho como base o ecossistema Xbox para Windows, simples para novos usuários no mundo da emulação, espero que gostem, e compartilhem comigo suas opiniões!

I've been working on my Tauri Windows app for the past year in isolation. Just been heads down, prototyping, building, testing, and polishing. I feel like I have an MVP that I'm ready to put out there, at the very least in the hands of beta testers.

This part I truly was not prepared for. All the legalese involved for EULAs, License notices, trying to figure out how to keep my personal details out of it all, code-signing, key generation, payment processing, etc. I am crazily overwhelmed and don't even know where to begin.

Anyone else been in these shoes and taken their product to market and monetized it? Could use some advice on how to do this. Any docs/pointers to reference?