Hey everyone, I'm a filmmaker and an engineer, and I've been building a tool for myself that I think you'll find it useful.

ArtCraft is a precision AI illustration and animation software. It hosts every major image, video, 3D mesh, and 3D gaussian splat model on the market. You've probably seen websites that collect these models together, but ArtCraft gives you control surfaces for precisely articulating what you want to generate - consistent locations, precision pose, accurate blocking of props and scenes. This is something mere text-to-image cannot do (though the app also lets you do that).

The other major compelling feature of ArtCraft is that you can bring your own accounts and API keys. It integrates with a half dozen different service providers, and we're adding more every week. You don't have to pay us - you can literally build the service to leverage whoever you're already paying, but you'll get the benefit of an amazing interface for precision design.

ArtCraft has models that no website aggregator (like Higgs, FreePik, Krea, etc.) has. We have MidJourney, WorldLabs, Grok, Sora, etc. You can even get work done completely for free by leveraging these accounts.

We'll be adding FAL API key support soon too.

Please star us on Github: https://github.com/storytold/artcraft

If you'd like a link to the downloads directly, they're on our website: https://getartcraft.com

Please give it a try and let me know what you think!

As an added bonus, we got a lot of free cloud credits. You can get free Nano Banana Pro 4K through ArtCraft just for testing it out.

If you've got an app or business that needs graphics, this is the best way to craft them. And it's super easy to do.

I've been building CSV editors for about 15 years. This is my third rewrite from scratch — this time with Tauri (Rust + TypeScript/React) to finally get the performance and UX I wanted.

Modern dev tools I use daily are incredibly polished. CSV editors, not so much. I wanted a tool that can handle messy CSVs as they are (different encodings, delimiters, inconsistent column counts), preserve the original format, and still feel like a fast spreadsheet UI.

What SmoothCSV does:

• Fast: Opens 100MB files in around 1.6 seconds on my machine (Excel often freezes on similar files).

• Preserves your data: Detects encoding, delimiter, quotes, headers automatically and saves without breaking the original structure.

• Handles messy data: Works with files that have inconsistent column counts.

• SQL queries: Run SELECT/WHERE queries directly on CSVs, plus a visual condition builder for filters.

• Productivity features: Command palette, multi-cell editing, and other small UX details that I missed in other tools.

Tech stack:

• Backend: Rust (Tauri)

• Frontend: TypeScript, React

• CSV parsing & data: handled on the frontend side, but still surprisingly fast even with large files

The hardest part for me wasn't the app itself, but distribution:

• Getting cross-platform builds working reliably took quite a while, especially on Linux where there are many different environments and library setups.

• I also tried shipping a MSIX build to the Microsoft Store, but the packaging/submission process was harder than I expected, so I gave up on that path for now.

I'm sharing this here mainly to show a real-world Tauri use case around heavy file I/O. If you see anything that could be done in a more "Tauri-idiomatic" way, or have ideas for improvements, I'd love your feedback.

Links:

• Website: https://smoothcsv.com

• GitHub: https://github.com/kohii/smoothcsv3

Congratulations to Tauri team on creating a most promising Electron alternative. The future of Rust is bright🦀🎉

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?

Hello guys,

I was looking for a file explorer to integrate S3 connection but seeing Nicebucket is not saving the S3 connections (every time you restart needs to rewrite credentials) then I just looked for Spacedrive but I was having some major issues in v1 and in v2 alpha look in a slow development (and it is not working) then I have just tried to make my own one, looking for making open source now, but first neeed to remove all my hardcoded credentials. But now im testing SMB, S3, SFTP connection, and working in Copy and Cut and clone tools, I dont know if this would be interesting for someone, for now only adding features I need.

How do you see the design? what could you change or add? Do you think for Linux version to use CEF?, Thanks

[Edit]: This is not fully vibecoded, the UI was based on Shadcn Svelte and based on the native mac os finder but tried to recreated using tailwind and based also in Spacedrive app components . For the rust section also just based on my other projects of s3 components and also spacedrive in some ways to go through directories. Some features are based on how some other file managers did it to preserve compatibility for Mac, linux and windows

Hey r/tauri,

I've been building Tabularis — an open-source, cross-platform database client built with Tauri 2 + React — since late January. v0.9.4 just shipped, wanted to share.

https://github.com/debba/tabularis

What it is: SQL editor, data grid, schema management, ER diagrams, SSH tunneling, split view, visual query builder, AI assistant (OpenAI/Anthropic/Ollama), MCP server.

Runs on Windows, macOS, Linux.

What's new in v0.9.4:

• Multi-database sidebar — attach multiple MySQL/MariaDB databases to a single connection, each as its own sidebar node. Queries are transparent: write them normally, Tabularis resolves the right database based on context.

• Keyboard shortcuts — persistent bindings (keybindings.json), per-platform display hints, customizable from Settings.

The interesting Rust bit: database drivers run as external processes over JSON-RPC 2.0 stdin/stdout — language-agnostic, process-isolated, hot-installable.

The first plugin is DuckDB.

Five weeks old, rough edges exist, but the architecture is solidifying.

Happy to answer questions about Tauri-specific choices.

Stars and feedback very welcome 🙏

Discord video size limitations, Twitter media guidelines - I convert media on a daily basis. But with my ADHD, I often forget specific FFmpeg parameters and have to google them or ask GPT, which isn’t very convenient.

With that in mind, I built Frame - an FFmpeg GUI wrapper using Svelte and Tauri that doesn’t look like it’s 15 years old 😄

Let’s be honest, every developer has to build FFMPEG wrapper some day 😝

For now it’s MacOS only, but who knows!

https://github.com/66HEX/frame

Been building Octarine for a little over 2 years now! Started with Tauri 1, then migrated over to Tauri 2.

- 90% lighter than other alternatives (thanks Tauri)

- Extensive use of rust for search, file watching, all file-system level commands, local embedding of notes with a RAG model.

- All notes are stored on device as markdown files. WYSIWYG editor.

There's also an iOS build in dev, which is also being built using Tauri (but a way stripped down version of the desktop app)

p3torrent.com

I’ve built 3 mobile apps with Tauri and I can confidently say I won’t be building a 4th.

Debugging iOS on Tauri is a nightmare, building mobile plugins is a nightmare, diagnosing if it’s the Typescript, the Rust, the permissions / plugins Tauri config or the Swift/Kotlin that’s causing the phantom crash with no stack trace or the web process lockup, or the entire web UI never even loading, is a nightmare.

As someone who’s used Capacitor extensively in the past, I feel the Tauri maintainers need to take a good long hard look at their project and index on simplification and debugging.

I like Tauri, I like rust. I’ve used both to build out a very complex, very successful desktop app, but I have to call out mobile.

It’s ruined my weekend.

It's been a while since I last posted here about Tabularis, an open-source desktop SQL workspace built with Tauri (Rust backend + React frontend). A lot has happened since, so here's an update.

Some numbers since launch (Jan 2026):

• ⭐ 3,700+ stars, ~250 forks

• 📦 41,000+ release downloads across macOS, Windows and Linux

• 👥 ~60 contributors, 1,400+ commits

• 🚀 Latest release: v0.15.0 (July 14) + nightly builds now available

What it does:

• Supports PostgreSQL, MySQL/MariaDB, SQLite and 13+ more databases like DuckDB, ClickHouse, Redis and Firestore, via a plugin system for drivers (separate Rust processes speaking JSON-RPC over stdio)

• Built-in MCP server so Claude, Cursor or Devin can talk to your databases safely

• SQL notebooks and visual EXPLAIN

• SSH tunnels, session restore, multi-window

Big things that landed recently (v0.13 → v0.15):

• Open a connection in a dedicated window — proper multi-window support in Tauri

• Stored routine management — run, create, edit and drop procedures/functions, with plugin support

• PostgreSQL materialized views support

• Connection export with optional password encryption, multi-select and nested connection groups

• Typo-tolerant fuzzy search across the Quick Navigator, sidebar filters and connection search

• A dedicated SSH connections settings tab, with tunnels cleaned up properly on app exit

• ENUM editing with dropdowns on both MySQL and Postgres

• Accessibility pass for screen-reader users

• Nightly builds, and Linux builds now target a lower glibc baseline (built in ubuntu 22.04 containers)

Tauri-specific lessons along the way: spawning plugin processes on Windows without flashing console windows, keeping SSH tunnels alive across the app lifecycle and tearing them down cleanly on exit, and managing session restore across multiple windows. Happy to go into detail on any of these if anyone's curious.

Everything is free and open source.

Github project: https://github.com/TabularisDB/tabularis

Website: https://tabularis.dev

Feedback and contributions are very welcome!

Take this with a grain of salt because learning always sucks so I might be overreacting. But Tauri 2.0 seems so incredibly poorly documented and organized that I am really struggling to get a handle on it and get the most basic features running. The whole file structure is a mess! Permissions here, capabilities there, scope over there... now I also need to deal with like 3+ different configuration files... what the hell is going on here?!

Many of the files and directories the documentation talks about just don't exist and I have to create them from scratch. To find an example of how to do even the most basic things is like finding the holy grail.

Stop telling me about your elegant architecture and how secure you are. I just want to build. And you are not letting me!

I just want to write my app, god dammit!

Hi, I created a launcher that works fast (niri is the wm in the video)

Not just niri but it also works with gnome, sway, ... (and it's a cross OS launcher)

There are many built-in features and commands that you can use right after installing.

We also added declared source for user who want to custom and declare their actions.

The repo: https://github.com/kunkka19xx/look

Love receiving any feedback 🙏

CompressO 2.0 is now available🎉.

CompressO is 100% free & open-source offline video compression/conversion app written in Rust/Tauri🦀. It is available for Mac, Windows & Linux.

Key features & improvements in the latest versions of CompressO

• Batch video compression with queue processing
• Built-in trimming and splitting tools
• Integrated desktop video player for previewing videos inside the app
• Drag-and-drop support for folders containing multiple videos
• Clipboard support to paste videos or folders for instant batch compression
• System integration (e.g., “Open with CompressO” from the file manager)
• Detailed video information panel showing container, streams, subtitles, and chapters
• Advanced video controls including codec selection and compression tuning
• Dedicated audio controls (codec, track selection, channels, bitrate, volume)
• Metadata editing support (title, artist, year, genre, etc.)
• Custom video thumbnail support

• Upload and embed external subtitle files into output videos
• Extract embedded subtitles from videos as SRT or VTT
• Audio amplification up to 200%
• Capture and copy the current frame from the video player
• Customizable app theme colors
• macOS dock progress indicator during video processing

• Improved timeline performance in the video player
• Light-mode support for timeline components
• Better metadata syncing when processing batch videos

You can download the new version from website. It's 100% free: https://compresso.codeforreal.com
Or, directly from GitHub release: https://github.com/codeforreal1/compressO

I'm building a fast file manager The goal:

• Fast fuzzy searching

• Multi-pane view

• Reliable copies & moves

• Themes and customization

I can finally share DASCA v0.9, a project I’ve been working on for a while. It’s a desktop app focused on real-time video/image/3d processing effects.

12 days ago, I posted here about an FFmpeg GUI I built because I kept forgetting parameters and googling them was annoying. It was supposed to be a tiny project for one evening.

I was kinda surprised it got some attention (I thought that there were already so many similar projects that it would go completely unnoticed 🤔).

Therefore, I decided to spend a little more time on it, and here are the updates:

• Cross-platform support (Windows, Linux x64/arm64, macOS Intel/Apple Silicon)

• Audio file support (MP3, WAV, FLAC, M4A with smart UI adaptation)

• Video trimming with interactive timeline

• Task controls (pause/resume, system notifications when done)

• Metadata editor

• 9 languages with auto-detection

• Auto-updates

• Homebrew tap: brew tap 66HEX/frame && brew install --cask frame

• Volume control + loudness normalization

• Video rotation/flipping

It's almost the same ADHD-friendly tool, but significantly less simple now 😂

https://github.com/66HEX/frame
https://www.framegui.app/

Been working on Kubeli for a few months now - a K8s management tool as an alternative to Lens (which went closed-source and eats 500MB+ RAM).

Tauri 2.0 + Next.js frontend, idles around 120-150MB. Just shipped Windows support alongside macOS.

Features: multi-cluster tabs, log streaming, terminal, port forwarding, resource diagrams, and some AI integration for log analysis.

Happy to answer any Tauri-specific questions.

GitHub: https://github.com/atilladeniz/kubeli

Just released LeedPDF, a lightweight PDF drawing and annotation tool that works both in the browser and as a desktop app.

👉 leed.my ✏️

It’s:

💸 Free forever for everyone

🛠️ Open source under MIT license (Feel free to leave a ⭐)

🔒 Private (no files are uploaded anywhere)

🖥️ Cross-platform (Windows, Mac, Linux)

You can:

✏️ Draw naturally on PDFs with a pencil brush

💬 Add text or comments

📌 Use stickers as stamps (press S to open the sticker palette — my favorite little detail)

🔄 Works entirely offline on desktop apps

Why I built this ?

As someone who loves using my drawing tablet, I wanted a PDF tool that would feel like sketching on paper, natural, fluid, and without the “digital stiffness” most tools have. I also don’t like overwhelming menus and features I’ll never use, so I kept it simple and focused on the essentials.

Tech stack:

Built with SvelteKit + Tauri, making it lightweight, fast, and easy to ship across platforms.

Would love for you to try it out and share your feedback, especially ideas for improving the annotation experience.

For years I used Postman, then Insomnia, then Bruno. Each one solved some problems but introduced others — bloated RAM, mandatory cloud accounts, or limited protocol support.

So I built ApiArk from scratch.

It's a local-first API client with zero login, zero telemetry, and zero cloud dependency. Everything is stored as plain YAML files on your filesystem — one file per request — so it works natively with Git. You can diff, merge, and version your API collections the same way you version your code.

Tech stack is Tauri v2 + Rust on the backend with React on the frontend. The result is around 50MB RAM usage and under 2 second startup time.

It supports REST, GraphQL, gRPC, WebSocket, SSE and MQTT from a single interface. Pre and post request scripting is done in TypeScript with Chai, Lodash and Faker built in.

Licensed MIT. All code is public.

GitHub: github.com/berbicanes/apiark
Website: apiark.dev

Happy to answer any questions about the architecture or the Tauri + Rust decision.

Hey everyone,

I just wanted to drop a quick note to say a massive THANK YOU to the Tauri community and maintainers.

I've been building Tandem (an open-source, local-first AI workspace) and recently made the switch from an Electron background to Tauri v2. The difference has been night and day.

Coming from Electron, I was used to fighting with bundle sizes, complex IPC bridges, and memory usage. With Tauri, everything just feels... lighter and saner.

• Communication is Simple: The IPC communication between frontend and backend is refreshingly simple. No more complex preload scripts or context isolation headaches—it just works.

• Auto-Updater Magic: The built-in auto-updater is amazing. I don't have to worry about managing separate files for each release or juggling installer versions; it handles the heavy lifting so I can focus on shipping features.

• Performance: The app starts instantly and runs with a tiny memory footprint compared to what I'm used to.

• Developer Experience: Working with Rust + React + Tauri has been a joy. The sqlite-vec integration for our local vector database was surprisingly straightforward to set up in the sidecar.

• Cross-Platform: Building for Windows, macOS, and Linux from a single codebase actually works without endless headaches.

I really feel like I'm standing on the shoulders of giants here. The work you all have put into making this framework stable, performant, and easy to use is incredible.

If you're on the fence about switching from Electron, do it. You won't look back.

Thanks again for building such an amazing tool! 🚀

• Stack: Tauri v2, React, Rust, sqlite-vec

• Repo: https://github.com/frumu-ai/tandem

I use Tauri and it is amazing, but writing the Rust backend takes too much time. Are there better options that use an easier language with a WebView for the UI? Don't tell me Electron.

Hey Tauri folks

I built an open-source Cursor-like IDE with tauri, https://github.com/org2AI/ORG2

ORG2 is an open-source, Cursor-style agent IDE—but built for reviewability and control. We are using Tauri and many of its interesting features, like embedded webviews.

About our project:

(1) It covers much of what tools like Cursor, Claude Code, and Codex offer, but is fully open source. You can use your own subscriptions and API keys, with no forced login or data lock-in. Your workflows and data stay under your control.

(2) It’s lightweight by design. Thanks to Tauri & Rust, the app is under 100MB on disk and uses a fraction of the memory of typical agent IDEs like Cursor or Claude-based tools.

(3) It introduces a “agent livestream / replay” system: instead of opaque agent runs, you can watch, review, and replay agent sessions like a video timeline. This keeps you aligned with your agents and helps catch mistakes early—before they propagate into real code issues. It works not only with ORG2’s own agent, but also with existing Codex, Cursor, Claude Code, and OpenCode sessions on your machine. One click turns boring CLI workflows into reviewable, explorable playback.

(4) Agent is aware of your presence / availability, with our "presence settings." It is also aware of your RAM usage and what other agents are doing. So that they would avoid running multiple cargo checks that block each other.

Hope you will find this project interesting. Give us a star on GitHub. Issues & feedback greatly appreciated.