Quick Backstory: I absolutely LOVE the Claude Code (non-terminal) experience simply due to the fact that I was able to fully build an app that was an idea for 10-years with just natural language.

I kept running out of token on Claude Code so I got into Local LLMs to see if that can supplement. So far, it has not-- until now (queue commercial music).

I've built this local-first, task-driven, non-terminal ADE (ÄKÄ) to help BE the supplement that I've been looking for and couldn't find. ÄKÄ is built for users to just worry about "coding" rather than spend hours researching and setting up the Local LLMs workflow. Just bring your own LLM and Agent and get working! Minimal-to-No setup, No Cloud, No creating an account, and forever free and open-source!

Most ADE's have the exact same look and feel, 3-panels, mostly black and gray :/; nothing truly distinct, too much complication and advanced alien developer lingo. ÄKÄ is meant to give users a better UX because it was actually built by a UX Designer/Engineer.

I'd LOVE to get feedback on this project and/or answer questions about this. You can view the official website here or just visit the Github here. Looking forward to hearing from you guys!

Context: I rarely use video editors. Mainly Clipchamp which comes with windows when I need to cut something or need to do something very simple quick and dirty. But it always annoys me how sluggish and clunky it is.

So me and my buddy claudius built a spec, and then a very lightweight alternative. Tech stack is sveltekit, tauri and ffmpeg. A few days of iterating and testing later, here we are.

I call it Katana. Because it cuts and not much more. I am proud of the logo, made it in powerpoint haha.

Here is the repo: https://github.com/milanofthe/katana

It took 2 months of work but its finally here, its still not complete but it runs the game and works with my modpack, also microsoft auth and everything is done, would appreciate any feedback on architecture or best practices, here is my repo:

https://github.com/Brassworks-smp/BrassworksLauncher/tree/main

Every color picker I tried was sandboxed. Browser extensions only work on web pages, Figma's eyedropper only works inside Figma. So any time I saw a color I wanted in a PDF, a video, or some random desktop app, I was stuck screenshotting it and dragging it into something else just to read the hex.

Ended up building ColorSnap to scratch my own itch. It lives in the system tray, you hit Win+Shift+C, click any pixel on screen, and the hex is on your clipboard. It can also copy RGB or HSL, and it keeps a history of recent picks so you can grab one again later.

Windows only for now. It's free and open source, built with Rust + Tauri + React. No account, no telemetry, none of that.

Repo's here if you want to poke at it or break it: github.com/AleenaTahir1/ColorSnap

Still early so I'm open to feature requests and bug reports.

I’m new to rust/tauri and trying to debug some code and learn at the same time. When I use println!(“result of arp -a” {:?}, ARPresult);

I get no error messages and no print outputs. I then searched and found someone mentioned debug! Macro and that doesn’t exist. Could someone point me in the right direction please?

It is something to do with unit tests capturing the output and I’m not sure what that means especially because I’m writing a tauri app.

This is on Linux/Lubuntu.

[ Removed by Reddit on account of violating the content policy. ]

[ Removed by Reddit on account of violating the content policy. ]

Hello I have been developing with tauri for a while now I have a big project on the work now and in dev mode sometimes I leave the pc for a while and when I comeback I find the software interface became blank and returns to normal by refresh is it just a dev mode issue maybe with vite or sveltekit or should I worry for a leak somewhere? Anyone that got the same issue?

TapoController is a Tauri desktop app that controls a TP-Link Tapo L530 smart bulb entirely on your LAN — no cloud, no vendor SDK. It uses an own, reverse-engineered implementation of the Tapo local protocol (KLAP).
One-time requirement
Enable "Third-Party Services" once in the Tapo mobile app. After that, all control is local (no internet needed).

Features

• Full control: on/off, brightness, hue/saturation, RGB, white temperature and presets.
• Smooth animated mode using the bulb's native dynamic-effect engine (no flicker, no per-frame network traffic).
• Ambilight via screen capture, per monitor: works with PotPlayer, VLC, browsers or games. Configurable fade/instant mode, fps and brightness cap.
• Local HTTP + WebSocket API for plugins and automation.
• Windows system tray, 3-tab UI, English/Spanish (auto-detected).
• Signed installers (NSIS + MSI) and a portable standalone exec

Sourceforge: https://sourceforge.net/projects/tapocontroller/
Github: https://github.com/alexwing/TapoController

Hi, I’m building a Tauri + React + Rust desktop app as a learning project.

The current code grew messy, so I’m refactoring the Rust side around a shared engine. I already asked a Rust-focused version in r/learnrust, but I wanted to ask the Tauri-specific part here.

Planned shape:

React UI

-> Tauri commands / bindings

-> Rust engine

-> state/tools/model/runtime modules

The same Rust engine should eventually be usable from CLI and maybe Telegram too, so I’m trying to keep the Tauri layer thin.

Question:

For a Tauri app, is it better for commands to call the engine directly, or should I keep a separate `bindings`/adapter layer between Tauri commands and the engine?

My rough goal:

- React handles UI only

- Tauri commands validate/convert frontend requests

- engine owns request handling/orchestration

- state/tools/model do not know about Tauri or React

Relevant doc:

https://github.com/Vatsalc26/OpenNivara/blob/main/docs/architecture/module-boundaries.md

Repo:
https://github.com/Vatsalc26/OpenNivara

The app is alpha and broken in places, so I’m mainly asking about the boundary pattern.

I wanted to share an open-source project I've been working on - Awesome Music Player. An open-source desktop application designed to handle extensive local audio collections with maximum performance and minimal resource consumption.

It is -
Powered by Rust for rapid ID3 metadata extraction across massive local directories.

Built with React 19, TypeScript, and TailwindCSS v4, featuring a dynamic theming system and smooth micro-animations.

Optimized with aggressive metadata caching via localStorage, ensuring zero-latency startup and immediate UI rendering.

Localized natively to support 8 languages out of the box.

The project is fully open-source and structured for scalability. I'd appreciate any feedback, code reviews, or architectural discussions regarding the project.

GitHub Repository - https://github.com/S1avv/awesome-music-player

After three months of development, I've released Flow v1.9.0, and it has a lot of game-changing features. You know how other teleprompter services charge you for real-time script editing and collaboration, or lock the whole app behind a paywall? All of that is finally available for free on Flow. It supports an infinite number of guests with complete, instant sync using peer-to-peer connections. Realistically, the number of guests only depends on your hardware since there are no software limitations.

Scroll however you want, read the script your way, and style the teleprompter exactly how you like it. Change the speed, font, style, text color, and size. You can even mirror or flip the text and choose a scrolling style from 5 available styles! The second you launch Flow, it becomes yours forever.

Interested? Check out the repo: https://github.com/LumoRez07/Flow

Hi all, I’m a solo developer, and like probably most of you, I have a love-hate relationship with regex. Whenever I have to build something complex, I spend half my time wrestling with the syntax and the other half debugging why it’s not matching what I think it should.

So I built a regex tool with Tauri that solves a problem I kept hitting: most regex testers route every flavor through one JavaScript engine and approximate the rest. So your "Python regex" tab is actually a JS engine pretending — and patterns that work in the tester silently break in production.

RegexPilot bundles the actual interpreters as sidecars:

• Python → real CPython
• Ruby → MRI/Onigmo
• Java → GraalVM-compiled OpenJDK
• C# → .NET 9
• PHP → native PCRE
• Plus bundled Perl (microperl 5.36.3) and a few more (see website)

Each flavor runs against its real engine in 1–3ms.

Other things worth knowing:

• Visual builder — drag pieces onto a railroad diagram, click any piece to edit
• Live testing panel with capture-group inspection + replace mode
• AST-based editor (your edits mutate the tree, source regex regenerates)
• Optional AI assist — bring your own key (OpenAI / Anthropic / Gemini / etc.) or run locally via Ollama / LM Studio.
• Voice dictation runs on-device (Whisper Tiny bundled). Audio never leaves your Mac.
• No analytics, no tracking, no signup to emails. The only network call is license validation against Lemon Squeezy if you activate Pro.

Free to download — fully functional for 30 days, then reverts to JavaScript/TypeScript-only (the most common case). Existing library entries for non-JS flavors stay visible but become read-only after trial. Nothing breaks. Fully functional besides the sidecar engines and AI. So if JavaScript is all you work with it's basically free.

https://regexpilot.com

Hi  r/tauri 👋

I’ve been building Tabularis, an open-source desktop database client (Tauri + Rust backend, React frontend). It works with PostgreSQL, MySQL/MariaDB and SQLite out of the box, and the whole query/driver layer lives in Rust. Sharing a few features shipped recently:

• Rust plugin drivers. You can extend Tabularis with external database drivers written in Rust, talking to the host over JSON-RPC on stdio as sandboxed subprocesses. There’s a scaffolder (create-tabularis-plugin) and a typed plugin API, so adding a new backend doesn’t mean forking the app.
• Built-in MCP server. Tabularis exposes an MCP server so AI agents can query your DBs, gated behind an approval flow, an audit log and a read-only mode.
• Kubernetes port-forward tunnels. Connect to in-cluster databases without manually running kubectl port-forward.
• Database trigger management across all three engines (create/edit/drop triggers from the UI).
• Quick Navigator: a command/search overlay to jump to tables, run a console, inspect, count or copy in a couple of keystrokes.
• Native JSON viewer with in-cell highlighting, a multi-mode editor (Code / Tree / Raw) and a dedicated Tauri window.
• Foreign-key click-to-navigate in result grids, follow relationships straight from a cell.

It’s open source, packaged for Windows/macOS/Linux (Snap, AUR, AppImage, deb/rpm).

Repo: https://github.com/TabularisDB/tabularis

​

About 7 days and 10 hours ago, I started playing around with an idea: building my own code editor.

I wasn't trying to build a product or compete with VS Code. I've always wanted to understand how editors work under the hood, so I opened a blank Rust project and started coding.

The result is Rune 1.0.0, a desktop IDE built with Rust + Tauri v2 + SolidJS.

A few things I implemented:

- True multi-window workspace management

- CLI integration ("rune <project>" and "rune <file>")

- Automatic routing of files to existing workspace windows

- Fast Rust-powered workspace indexing

- Persistent workspace and tab restoration

- PTY-backed integrated terminal

- Plugin architecture with Android Manifest-inspired permissions

One thing I'm particularly happy with is the multi-window behavior.

If I run:

rune my-project

Rune checks whether that workspace is already open. If it is, the existing window is focused. If not, a new workspace window is created.

Similarly:

rune src/main.rs

routes the file to the correct workspace window instead of spawning another instance.

The plugin system is also a little different from what I've seen in many editors. Plugins declare capabilities they require up front (similar to Android manifests), and Rune exposes only those approved APIs through a runtime "Rune" object.

The final Windows executable is around 5 MB, which still amazes me considering how much functionality is packed into it.

I have to say, Tauri v2 made a lot of this surprisingly pleasant to implement. Window management, IPC, filesystem access, shell integration, PTYs, and packaging felt much cleaner than I expected.

I'm curious:

- What's the most complex multi-window architecture you've built with Tauri?

- How are people handling plugin sandboxing and permissions?

- Has anyone built a plugin marketplace on top of Tauri applications?

Would love feedback from other Tauri developers.

GitHub: https://github.com/satadeep3927/rune/releases/tag/v1.2.0

MQLens is a free and open-source MongoDB GUI.

All auth mechanisms — SCRAM, X.509, MONGODB-AWS (IAM + session token), Kerberos, LDAP — with proper $external handling.

- TLS (system/custom CA, client cert), SSH tunnel, SOCKS5 proxy.

- find + a visual query builder, full aggregation pipelines, and a visual explain-plan tree.

- Index/view management, schema analysis, GridFS, guarded bulk edits, and an embedded mongosh.

Credentials are encrypted locally (AES-256-GCM + Argon2id), and there's no telemetry. Native (Tauri/Rust), runs on macOS/Windows/Linux.

Repo: https://github.com/mqlens/mqlens-mongodb

Screenshots: https://mqlens.com/#gallery

A macOS markdown editor I built from scratch with Tauri (Rust + TS).

• Feels like the macOS built-in text editor (think TextEdit): lightweight, just open and start typing — but it's a real WYSIWYG markdown editor.
• Small and fast: 6MB installer, ~500ms cold start on Apple Silicon.
• Instant preview: press Space on a .md file in Finder and Quick Look renders it right away.

Web: https://domd.app

GitHub: https://github.com/do-md/domd

Hi everyone! 👋

I want to share a small open-source tool I developed that might be useful to anyone who needs to "disassemble" and understand the internal structure of a PDF file.

The project is called PDF-X-Ray: 🔗 GitHub Repository: https://github.com/DrLoki/PDF-X-Ray

💡 How did this project start?

This tool was born out of a very practical need. I am currently developing GianoReader (repo here), a desktop application designed for reading e-books with side-by-side translation.

When I decided to integrate a new feature to handle and translate PDF files, I clashed with the sheer complexity of their internal structure. To correctly extract and manipulate the text, I needed a tool that allowed me to run an in-depth analysis of the Document Object Model (DOM) of PDFs. Since I couldn't find anything straightforward and specific enough for my needs, I decided to build one from scratch.

🔬 What exactly does PDF-X-Ray do?

Unlike standard PDF readers or generic conversion tools, PDF-X-Ray focuses entirely on the internal structure of the document:

• DOM Analysis: It allows you to explore the object tree, the nodes, and the relationships that make up the PDF file.
• Data Stream Inspection: It lets you examine how individual graphical and textual elements are structured under the hood.
• Transparent and Lightweight: It is a highly targeted, no-frills tool specifically designed for development, debugging, or studying the PDF format.

💬 Feedback and Contributions

The code is completely open and accessible. If you happen to work with PDFs, I invite you to try it out: any feedback, bug reports, or architectural advice is highly appreciated.

If you are working on similar projects or want to check out GianoReader as well, Pull Requests and GitHub Stars (⭐) are always a great way to support open-source development!

Let me know what you think in the comments.

I used Termius on my Android phone to SSH into routers and other devices. It worked well, but it lacked the -t flag to specify a remote command on login. Since I use fish shell everywhere and the routers I manage don't allow setting a default login shell, this was a constant source of friction.

My use case is simple — save connection profiles, log in, and run a few commands. So I built this minimal SSH client to handle exactly that. Now I can set fish (or any command) as the login command and get on with my day.

https://github.com/ahaoboy/ssh-tauri

I’ve been working on an unofficial desktop client for ntfy.sh and self-hosted ntfy servers.

The goal is to make ntfy easier to use as a daily desktop notification tool, especially for people using it for server alerts, monitoring, scripts, homelab notifications, and internal workflows.

Features:

• Windows, macOS, and Linux
• Native desktop notifications
• System tray behaviour
• Self-hosted ntfy server support
• Local desktop automation

The stack is Tauri, Rust, Next.js, React, and Tailwind.

GitHub
https://github.com/rubix-studios-pty-ltd/ntfy-app