r/tauri

I know, another notes app. But it was born of love and an arguably unhealthy obsession with UX and making it super intuitive despite the many features. In particular, Spectral has:

• Fully offline mode (no account/sign up needed)
• Optional, cross-device (phone, windows, mac soon) sync
• The desktop app floats over other apps, and you can summon it with a shortcut so it's always is to bring it into focus without switching context, and dismiss it just as easily when you're done
• Capture first approach - no forced structure just to jot a note down
• That said, adding structures is easy; you can tag a note with #hashtags, and mark priority using `@` shortcuts
• You've got your standard chronological list view, but a clear "today" section above it for your "todo today" notes
• There's also a group view to view by tags
• Batch editing/archiving notes
• Robust search and filtering
• And some delightful UX, I think at least =]

Anyway if you're interested, here you go:

https://meet-spectral.pages.dev/

Any feedback is greatly appreciated, naturally

Hey everyone, I just pushed Gilbert Codex v0.5.0, which is the biggest update I’ve put out so far.

Gilbert Codex is an open-source desktop AI workspace for coding, review, tools, research, image generation, and release work. It’s built with Tauri 2, React, TypeScript, and Rust, and the goal is to make AI coding feel more like a real desktop workspace instead of a bunch of disconnected tabs, terminals, chats, and setup screens.

GitHub / download:
https://github.com/UrbanWafflezz/GilbertCodex/releases/tag/v0.5.0

Repo:
https://github.com/UrbanWafflezz/GilbertCodex

This update moves the app way past the earlier alpha builds. v0.5.0 now has local user accounts, project-scoped chat state, pinned/searchable history, queued sends, planning/thinking controls, source-backed research, image-generation artifacts, safer review flows, subscription account routing, GitHub and Discord setup, and a much cleaner runtime under the hood.

A few of the bigger changes:

local users, so chats, projects, settings, and workspace state can stay separated

a more complete chat workspace with projects, attachments, markdown, regeneration, stop controls, and local persistence

multi-provider model routing for OpenRouter, OpenAI, Anthropic, Gemini, xAI, LM Studio, Ollama, Groq, Mistral, and DeepSeek

subscription account routes for Codex / ChatGPT, Claude Code, Gemini CLI / Cloud Code, GitHub Copilot, and more where supported

image generation that shows up as real chat artifacts with progress, grids, preview, and download controls

DuckDuckGo / Brave source cards for research-style work

local tools for files, terminal, browser preview, Git, GitHub, web search, and MCP-facing flows where permissions allow them

safer review gates for destructive actions, terminal/file work, publishing, credentials, and outside-scope paths

a refreshed README, release notes, installer docs, roadmap, support page, and public repo hygiene

I want to be clear that this is still alpha software. Windows x64 is the main packaged target right now, and the installer may show SmartScreen because it is not fully code-signed yet. macOS and Linux have source support, but I need people with those machines to test and help tighten them up.

The most useful feedback right now would be real-world testing: install issues, first-run setup problems, provider/model weirdness, confusing UI, bugs during real coding tasks, and anything around local files, terminal, Git/GitHub, sources, or image generation. If you open an issue, please include your OS, install/run steps, what you expected, what happened, and sanitized screenshots/logs if possible. Please do not include API keys, tokens, private repo content, local database files, or sensitive terminal output.

Also, since I’m being open about the project: if Gilbert Codex ends up being useful to you and you want to support the work, there’s a small support/funding page in the app and on the repo. No pressure at all, and nothing is locked behind it. The app is open source either way. It just helps me keep putting serious time into it, paying attention to bug reports, and making the project better instead of letting it become one of those half-finished tools that never gets maintained.

I’m trying to make Gilbert Codex into a genuinely useful open-source desktop coding-agent app, and v0.5.0 feels like the first version where the full shape of it is really starting to come together. If you try it, break it, review it, support it, or even just tell me what feels confusing, that would help a lot. App may feel slow on first boot!

I've vibe coded a privacy focused. browser because why would i pay for this type of browser

Would you use it ? i plan to make it opensource

Built with:
Tauri 2 + Vanilla TypeScript + CodeMirror 6 + Konva

GitHub: https://github.com/DroicheadNua/MirrorShard_2
(MIT License · Open Source · Win / Mac / Linux / Raspberry Pi)

Demo videos are included in the repository README.

Hi everyone,

I’m probably an oddball, but I keep things like 20 years of journals and 10 years of gameplay logs in single hierarchical Markdown files.

I wanted a fast outliner that could handle huge text files without feeling bloated.

On Windows, EmEditor covers that use case pretty well.
On Linux and Mac, I never found anything that quite fit.

VS Code works, but it always felt heavier than what I wanted for this kind of workflow.

So I built my own.

The first version was Electron-based, but startup times kept bothering me, so I eventually rebuilt the whole thing in Tauri 2.

That rewrite brought the app down from ~200MB to under 10MB and made startup dramatically faster.

It ended up fitting my workflow so well that it became my daily editor.

Once I started relying on it, I kept adding the features I personally wanted — AI chat, a node-based idea processor, ZEN mode, image generation support, and other writing-focused tools.

It gradually turned into a lightweight integrated writing environment.

I’m curious: does anyone else here keep massive single-file archives like this?

Or is anyone else using Markdown as a long-term archival database?

Personally, I prefer keeping long-term archives in a single structured file rather than splitting everything across hundreds of notes.

hey, i've been building a little instant replay tool called Clippy for the past few weeks and looking for a few people to bash on it before I push it wider.

it's basically Shadowplay/Medal but tiny and free. sits in your tray, detects when you launch a game, keeps the last number of seconds in a ring buffer, hotkey saves the clip. NVENC if you're on Nvidia, falls back to AMD/Intel hardware encode otherwise.

mostly want eyeballs on: weird games it doesn't detect, audio getting split wrong (game vs discord vs mic), and any jank on multi-monitor setups.

drop a comment or DM if you wanna try it and I'll send you a build. windows only for now.

website is clippy.rip btw.

I built this because I tend to keep working for hours without noticing, and it was affecting my health and mental state. I also wanted to learn how desktop apps work with Tauri and Rust.

The idea is intentionally simple:

Set a daily work limit (default is 8 hours — my own daily limit), and when the limit is reached, a fullscreen overlay gently reminds you to stop working.

Not a blocker. Not a productivity system. Just awareness.

Features:

• Tracks active screen time
• Fullscreen overlay across multiple monitors
• Lightweight & local-first
• No cloud / no tracking
• Windows, macOS, Linux (only tested on Windows and macOS by myself so far)

Built with:

• Tauri
• Vanilla HTML/CSS/JS

Would love to hear feedback — good or bad, send it all my way.

Website:
https://enoughwork.e4dx.com

GitHub:
https://github.com/mtsandeep/enoughwork

hey r/tauri 👋

shipped my first Tauri 2 app last week — marka.md, a local-first macOS markdown

editor for organizing the .md files i kept pasting into Claude / ChatGPT.

stack:

- Tauri 2 + React 19 + Vite 7 + Bun

- codemirror 6 + markdown-it + shiki + mermaid + katex

- ~12 MB binary, notarized, auto-updating via tauri-plugin-updater + minisign

features:

- IDE-style folder sidebar with HTML5 drag-and-drop

- ⌘⇧C → clean markdown to clipboard

- live preview, reading mode, ⌘K palette, 5 themes

- find/replace, export to PDF

- free, MIT, open source

a few tauri-specific notes that might help others:

- needed `bundle.createUpdaterArtifacts: true` to get `latest.json` + `.sig`

emitted (cost me 2 release attempts to figure out)

- set `dragDropEnabled: false` to use HTML5 drag-drop instead of tauri's native

handler

- `secrets.*` not allowed in GitHub Actions `if:` — hoist to `env`

→ https://markamd.vercel.app

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

happy to answer build questions 🐙

I don't know about you, but my Downloads folder has always been a disaster zone. PDFs, memes, installers, zip files, random images – all just sitting there in one giant pile. Every few weeks I'd open it, sigh, and spend 10 minutes manually dragging stuff into folders. Then a few days later it would be chaos again.

I looked at existing file organizers, but most of them either wanted a subscription, tried to upload my file names to some cloud, or were just way too heavy for something so simple. I wanted something that:

• Runs silently in the background (system tray)
• Automatically sorts new files by type (images, documents, archives, installers)
• Never sends a single byte of data off my machine
• Is open source so anyone can check what it's doing

So I built Mouzi 🐭🧹

It's a tiny desktop app (~5MB) built with Tauri and Rust, so it's ridiculously lightweight. It watches your Downloads folder, and whenever a new file appears, it moves it to a subfolder based on its extension. Images go to Images/, PDFs to Documents/, installers to Installers/, etc. You can also create your own custom rules.

Key things:

• 100% local – no cloud, no telemetry
• Open source (MIT) – GitHub repo here
• Silent – lives in your tray and doesn't bother you
• Undo – every move is logged, you can revert with one click
• Free, obviously

It's early stage, but it's already keeping my own machine sane. I'd love to get some feedback from this community – especially around what features would make this genuinely useful for you. Does this solve a real problem, or am I just scratching my own itch?

Download / more info: https://mouzi.cc

Hey r/tauri! I wanted to share **VeloxDB**, a PostgreSQL desktop client I've been building with Tauri 2 and Rust. The whole idea was to build something that actually felt native — no bloat, no cloud middlemen, no Electron tax.

Here's the stack:

- UI → React 19 · TypeScript · Tailwind · shadcn/ui

- Editor → Monaco (VS Code engine) · schema-aware SQL autocomplete

- Diagrams → ReactFlow · Dagre (visual ER diagram builder)

- Desktop → **Tauri 2**

- Backend → Rust · tokio-postgres · deadpool · rustls

- Build → Vite 8 · pnpm

**Things Tauri made really natural to build:**

🔐 Keychain integration— credentials live in macOS Keychain. No plaintext config files ever.

⚡ Local-first IPC — the frontend talks directly to the Rust backend via Tauri's IPC bridge. Zero cloud, zero telemetry.

📦 Tiny footprint — the whole binary is ~6MB. pgAdmin's installer is 500×+ that.

🗂 Visual ER designer— drag-and-drop schema builder powered by ReactFlow. No DDL by hand.

📊 Virtual scrolling — million-row tables stay snappy. Only renders what you see.

🌐 SSH tunneling + SSL — stable pooled connections via deadpool-postgres, rustls for TLS.

The Tauri IPC bridge made it surprisingly easy to wire up a repository pattern — the frontend data layer is abstracted behind a `VeloxDbRepository` interface, so swapping the transport later would be trivial.

Would love any feedback from the Tauri community — especially around window state management, updater best practices, or anyone who's tackled SSH tunneling from the Rust side. Happy to discuss any implementation details!

→ https://veloxdb.dev

→ https://github.com/abeni16/veloxdb

Disclosure: I made this. Free and open source.

I use Claude Code in Cursor every day and got tired of running /usage every 15 minutes. So I built BurnClaw, a Windows tray widget that shows three things at a glance:

1. Usage. Live 5h session and weekly 7d percentages, color-coded badge, native notification at 80% and 95% usage.
2. Service status. Pulls from status.claude.com so you know when problems aren't on your side.
3. Claude Code activity. The widget border reacts to what Claude is doing: solid orange while a session is active, pulsing when it needs your input (plus a notification), and back to normal when the response is finished (also with notification).

Everything is configurable in settings: thresholds, notifications individually, and the Claude Code activity tracking can be turned off entirely if you don't want it.

Setup wizard installs the Claude Code hooks in one click. Reads your local OAuth token, no API key, nothing sent externally.

Stack: Tauri 2 + Rust + TypeScript.

Repo: github.com/asantinos/burnclaw

Caveat: this reuses Claude Code's OAuth from a non-CLI client, which is a ToS grey area. Works today on Pro/Max, Anthropic could break it.

What started as an idea: what if we could turn Kiro CLI’s Agent Client Protocol into something closer to Codex, then expand it with richer agentic features and workflows? The goal was to move beyond the terminal into an environment built for working across multiple projects and parallel threads more naturally. That’s how Kirodex was born. Today, we’ve reached version 0.43.0. It’s been an incredible open-source journey, with contributions from many people along the way.

Repo: https://github.com/thabti/kirodex
Website: https://thabti.github.io/kirodex/
Change log: https://thabti.github.io/kirodex/changelog.html

Features

Chat & agents

• Chat interface via the Agent Client Protocol (ACP) SDK with threaded agentic development
• @ mention commands for skills and agents
• Slash commands (/clear, /close, /model, /agent, /plan, /chat, /data, /branch, /worktree, /fork, /btw, /tangent) with fuzzy search
• /btw side questions in a floating overlay without polluting history
• /fork to branch a conversation into a new thread
• Plan mode with per-thread state and handoff card to implementation
• Message queue (type while agent is running; sends when turn ends)
• Question cards for multi-choice agent prompts
• Subagent display with expandable stage cards and dependency indicators
• MCP server management (add/remove/configure, stdio/HTTP, live status)
• Image attachments as ACP ContentBlock::Image

Split-screen & multi-window

• Side-by-side threads (even cross-project), drag from sidebar, Cmd+\ toggle
• Cmd+N for independent windows with separate state

File tree

• Real-time filesystem watching with git status indicators
• Inline rename, create, context menu, drag-to-chat, file preview with syntax highlighting

Code & diffs

• Syntax-highlighted inline and side-by-side diffs (Shiki)
• strReplace tool calls rendered as git-style diffs in chat
• Code viewer for read tool calls with line numbers
• Changed files summary with per-file stats and one-click stage/revert

Git

• Branch, stage, commit, push, pull, fetch via git2 (SSH + HTTPS)
• AI-powered commit message generation
• Git worktree support per thread (/worktree, /branch)
• Auto-cleanup worktree on thread close

Analytics

• Built-in dashboard (/data) tracking hours, messages, tokens, tool calls, diff stats, model popularity
• Nine chart types (Recharts) with redb backend

and much more

I got a lot of questions why would anyone need this, and and honestly it's something different, and I enjoy using Codex, Claude Desktop, and sometimes terminals feel limiting. This is very light-weight and doesn't run chromium, built via Rust and Tauri.

https://www.reddit.com/r/aws/comments/1si20a2/building_kirodex_if_kiro_and_codex_had_a_baby/

Currently using a Rust background thread to poll the mouse and dynamically toggle window.setIgnoreCursorEvents() when the mouse leaves the visible UI.

It works, but polling feels hacky. Is there a native way in Tauri to make transparent pixels click-through on Windows?

Hey everyone, I have been building Gilbert Codex, an open-source desktop workspace for coding with AI agents.


Repo: https://github.com/UrbanWafflezz/GilbertCodex  
Windows alpha release: https://github.com/UrbanWafflezz/GilbertCodex/releases/tag/v0.0.2


The short version: it is a local-first desktop app built with Tauri 2, React, TypeScript, and Rust. The goal is to give agent coding work a focused GUI instead of scattering everything across a browser tab, terminal window, notes, and Git client.


What is already in the alpha:


- chat workspace with local projects, pinned chats, markdown, attachments, and local persistence
- model routing for OpenRouter, OpenAI, Anthropic, Gemini, xAI, LM Studio, Ollama, Groq, Mistral, and DeepSeek
- thinking controls, planning mode, regeneration, stop, and visible activity/progress state
- local Git tools for status, diff, stage, commit, push, pull, branches, and review-style prompts
- GitHub tools for repo/file reads, code search, branches, releases, pull requests, and workflow runs
- DuckDuckGo-backed web search with source cards
- terminal sessions, browser preview, local file tools, tool toggles, and settings
- SQL-backed local app state for auth, chats, projects, settings, integrations, preview state, and agent runs


What I need help with right now:


- testing the Windows installer and setup flow
- trying real coding tasks and opening issues for confusing/broken behavior
- testing macOS and Linux from source, since Windows is the only packaged target right now
- reviewing the Rust/Tauri command layer, especially anything around local files, terminal, Git, permissions, and app data
- improving docs, first-run setup, contribution flow, and good-first-issue breakdowns


A few honest caveats:


- this is an early public alpha
- the Windows installer is unsigned, so SmartScreen may complain
- provider keys and local endpoints are still local user settings; moving sensitive tokens into OS-backed secure storage is on the roadmap
- macOS/Linux need real contributors with those machines before I can call them supported


If you try it, the most useful feedback is a GitHub issue with your OS, install/run steps, what you expected, what happened, and sanitized screenshots/logs if possible. Pull requests are welcome too. I am especially interested in practical feedback from people who actually use coding agents and know where these tools get annoying in day-to-day work.


Thanks for taking a look.

Features

• - Track work time per project
• - Archive old projects without losing history
• - Restore an active timer after restarting the app
• - View project totals, today’s time and task breakdowns
• - Estimate earnings from hourly rate or fixed project price
• - Track focused app activity for selected apps
• - Export reports as HTML, table and JSON
• - Minimize to system tray
• - Optional autostart with Windows
• - Multiple themes: Dark Blue, Coffee, Discord-inspired and Light

I didnt know where to publish it for ppl for free so I put it here https://mmeroo.itch.io/project-timer-by-mmero

I just really enjoy systems programming, AI and modern app development, so I decided to make this project, after opening Warp's app info and seeing 400MB+ for terminal.

Terax has built-in code editor, AI agents, file explorer, web preview and much more.

Source code: https://github.com/crynta/terax-ai

App: Rust + Tauri + React
Terminal: xterm.js (WebGL) + portable-pty
Code editor: Codemirror 6 + vim mode + AI autocompletions
AI: Vercel AI SDK (BYOK or local models)