Sources

## The meh At first, I wanted to create my usual showcase for desktop applications, a file renamer app. However, I soon hit an issue when I wanted to select a directory using the file browser button. First, Tauri doesn't allow to use the regular JavaScript file-related API; Instead, it provides a more limited API. Worse, you need to explicitly configure which file system paths are available at build time, and they are part of an enumeration. … ## The bad However, Tauri's biggest problem is its design, more precisely, its separation between the front and the back end. What I love in Vaadin is its management of all things frontend, leaving you to learn the framework only. It allows your backend developers to build web apps without dealing with HTML, CSS, and JavaScript. Tauri, though a desktop framework, made precisely the opposite choice. Your developers will need to know frontend technologies. Worse, the separation reproduces the request-response model created using browser technologies to create UIs. Reminder: early desktop apps use the Observer model, which better fits user interactions. We designed apps around the request-response model only after we ported them on the web. Using this model in a desktop app is a regression, in my opinion. ## Conclusion Tauri has many things to like, mainly everything that revolves around the developer experience. ... However, it's a no-go for me: to create a simple desktop app, I don't want to learn how to center a `div` or about the flexbox layout, etc.

Electron, powered by JavaScript and Chromium, has long dominated the space, enabling web developers to craft desktop apps with familiar tools. Tauri, a newer contender built on Rust, challenges this status quo with its promise of smaller, faster, and more secure applications leveraging native webviews. ... Electron’s strength lies in its simplicity and consistency, while Tauri’s Rust-based core and webview reliance reduce overhead. These architectural choices directly impact performance and security, explored next. ... Performance and resource usage are critical in 2025, as users demand efficient desktop apps. Benchmarks and data reveal stark contrasts between Tauri and Electron. Electron’s bundled Chromium engine results in larger binaries—typically 80-120 MB—and higher memory usage. A 2024 Levminer study found a basic Electron app consuming 85 MB on disk and 100 MB of RAM at runtime. Startup times average 1-2 seconds on mid-range hardware, per Chadura’s 2024 tests. While Electron’s consistency across platforms is a boon, its resource demands remain a drawback. Tauri shines in efficiency. Using native webviews, its binaries are as small as 2.5-3 MB, with RAM usage around 30-40 MB for similar apps, per the same Levminer analysis. Startup times clock in under 500 ms, thanks to Rust’s lightweight runtime. “Tauri apps use 50% less memory than Electron equivalents,” states Chadura’s 2024 benchmark, a gap widened by Electron’s Chromium overhead. Security also differs. Tauri’s Rust backend limits system access by default, reducing exploit risks, while Electron’s Node.js exposure requires careful sandboxing. Tauri’s edge in size, speed, and safety positions it as a compelling alternative, but real-world applicability seals the comparison. Levminer. (2024). ... Electron excels in rapid prototyping and complex GUIs. Its JavaScript ecosystem and Node.js integration suit apps needing extensive libraries—think Discord or Visual Studio Code. In 2025, Electron powers 60% of surveyed cross-platform apps, per Stack Overflow’s 2024 data, thanks to its ease for web developers and consistent rendering across OSes. … Electron fits large-scale, feature-rich projects with forgiving resource budgets. Tauri suits lean, secure apps where size and speed matter. These use cases guide developers toward the right tool for 2025’s diverse desktop demands. Stack Overflow. (2024). ... Electron’s Chromium and JavaScript foundation delivers familiarity and flexibility, ideal for quick builds and rich interfaces. Tauri’s Rust-driven, webview-based approach prioritizes efficiency, security, and minimalism, outpacing Electron in resource metrics. Use cases split them: Electron for robust, established projects; Tauri for lean, modern solutions. Future trends favor Tauri’s growth—its mobile support and Rust adoption signal scalability. Electron’s entrenched ecosystem, however, ensures longevity. The best pick in 2025 aligns with project scope, team skills, and performance goals, proving both frameworks remain vital in desktop development’s evolving landscape.

Doing a security freeze to finally release a "v1.0" at this point seems very, very pre-mature to me after my usage of it. For some very **limited** scope of apps, it is production ready but for the vast majority of apps that you would want to do in Tauri, you can't do them. I never managed to crash any apps that Tauri created! In that the apps actually built using features it supports appear to be production ready however I did have some issues with some simple Tauri JS API code that worked in development but didn't work on a release build... In the multiple days I have played with Tauri, I have easily ran into so many different issues that makes me think it is no where even close to production ready for any real world usage or, as you will see later, very many application types. Everything from virtually a non-existent JS API's (missing many simple things, like you can't even check if a file even exists...) to things like broken flavors (Pure JS & Svelte JS don't even work out of the box, despite them having official flavors for them). However, one of the biggest issue for Tauri is that two of its major claims to fame appears to be false for the majority of developers and instead create some way worse issues for the Tauri team and by extension you the developer. … Unfortunately, the currently distributed Webkit on most distributions has a very nasty bug that makes most Tauri app that needs access to any and all web sites that use CORS, impossible in virtually all situations. So to "fix" this you have to build your own version of Webkit using the latest sources. Which is fairly time consuming and basically means you are forced to distribute using an AppImage so that everything including the new fixed Webkit is bundled in your app. … In addition the current version of Tauri's Webkit on Mac and Linux has issues actually recognizing cookies marked as "Secure". So overall Tauri and Cookies are currently not very friendly with each other at this point. Now granted this only impacts any apps that need remote resources (assuming the CORS issue isn't already blocking you), but it does eliminate a number of apps that people might want to do... This brings up the next issue with Tauri. To try and make the apps really small they are binding to whatever the existing version of WebKit is on Linux & Mac. If you are running a older version of Linux or MacOS, the app won't run because it requires WebKit to be a certain version. This is similar to the Windows issue, you have to be running a certain version of the OS browser component or the app will not work. … You now also have to unfortunately deal with this exact same issue with Tauri too. This is not something Tauri can fix, without replacing the actual engine, meaning they have to ship a large file on one or more platforms. Either they replace the Windows engine with Webkit (probably their easiest solution), or switch to Chromium on Linux and Mac OS. Tauri, you are dealing with effectively TWO completely different targets that act similar until they don't. This alone makes developing on Tauri a much larger job than the other platforms... The final issue with this design is that they are seriously beholden to the Webkit team, the Edge team, Apple, Microsoft, and all the different Linux distributions. They have to hope and pray that first the Webkit team (or Edge team on Windows) fixes any browser issues they find. Then they have to wait patiently for these to actually hit the distribution channel. The supply chain for fixes for Tauri is very deep. A really good example is the CORS issue above, first they had to report it to WebKit team, the WebKit team had to **decide** it was something they **wanted** to fix (and even when to fix it). So now presuming the Webkit team has actually fixed it, then downstream Apple has to ship it for MacOS (which again is hit or miss on when Apple will decide to ship, another sore point for a lot of developers). … So until Ubuntu ships the new WebKit, ALL downstream OS's that are based on Ubuntu has the broken browser that doesn't support CORS properly. Tauri team can't do really anything thing about this. Since you have two different paths for bugs (WebView2 & WebKit) and features they really are fighting an uphill battle. … In my humble opinion, this is the significant Achilles heel of Tauri and I would consider it way more than just a heel -- the ability to get timely fixes out to the developers is completely outside of the Tauri's hands unless they start distributing pre-built webkit builds with the app (which then makes it the exact same footprint as Electron in all factors but using Rust as the back end) Now if you have been following along on how it Tauri binds, what is the other issue you face with this design? What happens when the Edge team or the Webkit team introduces new bugs into the WebView's?

When developers first research Tauri, they often encounter articles describing it as a **"lighter Electron"** or emphasizing the need to **"learn Rust."** While truth exists in these points, they don't capture the full picture. These two leading cross-platform frameworks have architectural differences that impact development and performance. Let's dive into how Tauri and Electron operate behind the scenes. ... Tauri leverages Rust for its backend. A key advantage comes from Rust compiling to a native binary, **eliminating the need to bundle a runtime (like Node.js)** with the app. This contributes to a more lightweight app, though it involves trade-offs discussed later. … By relying on the system's WebView, **Tauri creates smaller app bundles, but this comes at a cost.** Developers using Tauri face potential challenges with cross-platform UI consistency. Browser-specific quirks can appear—issues in Safari but not Chrome, or Firefox behaving differently across operating systems. Since Tauri uses different underlying web engines on each OS, these platform variations become factors developers must manage during app development. … ### Build time # The initial build time was significantly slower for Tauri, primarily due to the Rust compilation step. Subsequent builds are typically much faster.

**Summary** – Facing demands for lightweight, high-performance, secure desktop apps without sacrificing development agility, enterprises may turn to Tauri, which combines a Rust backend and embedded web UI to minimize memory footprint and binary size, speed up prototyping (hot reload, unified CLI), and enable cross-platform packaging. However, its fine-grained permissions (restricted JS APIs, FSI whitelisting) and request/response model can complicate configuration and introduce latency in advanced business interactions. … When organizations are seeking high-performance desktop applications without sacrificing development speed, Tauri emerges as a hybrid solution: leveraging Rust for the backend while maintaining an embedded web UI. ... Tauri’s CLI includes step-by-step guides that walk users through the initial configuration and bundling options. This self-guided approach reduces configuration errors and streamlines new developer onboarding. … ## Functional Limitations and Restrictions of Tauri **Tauri’s security policy can be constraining for certain local desktop applications. Configuring file-system access and native APIs requires expertise and frequent adjustments.** ### Intentionally Restricted JavaScript APIs By default, Tauri exposes only a limited set of system APIs and requires explicit declaration of used functions. This granularity benefits security but incurs additional configuration overhead. In an internal project at a Swiss industrial company, developers made repeated back-and-forth adjustments between Rust code and Tauri configuration to fine-tune permissions, extending the integration phase by two weeks. For business applications where end users already master their local environment, these restrictions can feel excessive and slow down maintenance teams’ responsiveness. ### Whitelist-Based File-System Management All disk access must be approved at build time by listing authorized paths. This measure reduces data leak risks but complicates dynamic access to unforeseen directories. A Swiss logistics company encountered challenges managing user-configured import folders dynamically, as every new path required recompilation and redistribution of the application. This example highlights the tension between extreme security and flexibility, especially when handling runtime-defined file processing. ### Complex Configuration for Specific Use Cases Tauri’s build options cover many scenarios, but their comprehensiveness can make configuration tedious. Custom packaging profiles demand fluency in JSON, Rust scripts, and the Tauri CLI. At an SME in the Swiss insurance sector, the IT team invested significant time training developers to handle test, staging, and production environments, requiring external support. This complexity can pose a challenge for small teams or projects in rapid exploration phases, where agility outweighs configuration rigor. … ### Request/Response Model vs. Event-Driven Architecture Unlike traditional desktop frameworks that rely on events and observers, Tauri uses asynchronous requests between the JavaScript frontend and the Rust backend. Each call is serialized into JSON and processed, which can introduce latency and complicate debugging. A video stream management project at a Swiss organization highlighted performance issues when a large number of asynchronous calls accumulated, necessitating a pooling mechanism to reduce overhead. … ### Web-Dominated User Interface The UI relies entirely on an embedded web rendering engine, often Chromium. HTML, CSS, and JavaScript components remain at the core of the user experience, even for native tasks. In one Swiss educational sector case, integrating vector drawing features in the Tauri application proved less intuitive than with a traditional desktop framework, as developers had to adapt web libraries to emulate native behavior. … ### Learning Curve and Dependence on Web Skills To master Tauri, backend developers must acquire frontend skills (and vice versa), as the UI layer offers no native components. The “desktop” promise still hinges on web expertise. A Swiss software publisher had to hire full-stack profiles to meet Tauri requirements, forcing the IT department to decide between internal training and recruiting new talent. … ## Tauri: A Pragmatic Web-to-Desktop Extension Tauri asserts itself as a lightweight, secure alternative to Electron, with a proven developer experience and controlled technical footprint. Its business benefits—multiplatform support, security by design, and Rust performance—are real for internal applications or offline SaaS-like tools. However, its configuration limitations, embedded web philosophy, and request/response model distance it from “classic” desktop frameworks for rich, interactive business applications. Choosing Tauri should be seen as embracing a web-to-desktop extension rather than a universal desktop solution.

## The Meh At first, I wanted to create my usual showcase for desktop applications, a file renamer app. However, I soon hit an issue when I wanted to select a directory using the file browser button. First, Tauri doesn't allow to use the regular JavaScript file-related API; Instead, it provides a more limited API. Worse, you need to explicitly configure which file system paths are available at build time, and they are part of an enumeration. … ## The Bad However, Tauri's biggest problem is its design, more precisely, its separation between the front and the back end. What I love in Vaadin is its management of all things frontend, leaving you to learn the framework only. It allows your backend developers to build web apps without dealing with HTML, CSS, and JavaScript. Tauri, though a desktop framework, made precisely the opposite choice. Your developers will need to know frontend technologies. Worse, the separation reproduces the request-response model created using browser technologies to create UIs. Reminder: early desktop apps use the Observer model, which better fits user interactions. We designed apps around the request-response model only after we ported them on the web. Using this model in a desktop app is a regression, in my opinion. ## Conclusion Tauri has many things to like, mainly everything that revolves around the developer experience. ... However, it's a no-go for me: to create a simple desktop app, I don't want to learn how to center a `div` or about the flexbox layout, etc.

Tauri solves this problem by leveraging the system’s native webview. Instead of bundling a full browser engine, Tauri uses a library called WRY, which provides a cross-platform interface to the appropriate webview for the operating system. As you’d expect, this makes Tauri apps far more lightweight. The downside here is that you no longer have a hard guarantee on compatibility. From what I can tell, however, this mostly seems to be a non-issue. Compatibility issues across system webviews are exceedingly rare, especially for the major operating systems. … ## Limitations # After replicating the workbench’s functionality in Tauri, we’re holding off on making the full transition for a couple reasons: 1. Lack of support for .appx and .msix bundles on Windows - Currently, Tauri only support .exe and .msi bundles on Windows. This means your Microsoft Store entry will only link to the unpacked application. The workbench is currently bundled and published using the .appx format. To address this, we would need to take down the workbench entirely from the Microsoft store and create a new application that uses the .exe format. 2. Issues with MacOS universal binaries - This is more an annoyance than a bug, but I ran into a few issues related to codesigning universal binaries for MacOS. Namely, Tauri doesn’t seem to be able to create Mac universal binaries from their arm64 and x64 subcomponents. It also seems to be codesigning the Mac builds twice. Neither of these are hard blockers, but they’re annoying enough that I’m holding off on migrating until they’re resolved or our issues with Nextron become more problematic. For now, I’m leaving my branch with the migration open and hope to revisit soon.

## The meh At first, I wanted to create my usual showcase for desktop applications, a file renamer app. However, I soon hit an issue when I wanted to select a directory using the file browser button. First, Tauri doesn’t allow to use the regular JavaScript file-related API; Instead, it provides a more limited API. Worse, you need to explicitly configure which file system paths are available at build time, and they are part of an enumeration. … ## The bad However, Tauri’s biggest problem is its design, more precisely, its separation between the front and the back end. What I love in Vaadin is its management of all things frontend, leaving you to learn the framework only. It allows your backend developers to build web apps without dealing with HTML, CSS, and JavaScript. Tauri, though a desktop framework, made precisely the opposite choice. Your developers will need to know frontend technologies. Worse, the separation reproduces the request-response model created using browser technologies to create UIs. Reminder: early desktop apps use the Observer model, which better fits user interactions. We designed apps around the request-response model only after we ported them on the web. Using this model in a desktop app is a regression, in my opinion. ## Conclusion Tauri has many things to like, mainly everything that revolves around the developer experience. ... However, it’s a no-go for me: to create a simple desktop app, I don’t want to learn how to center a `div` or about the flexbox layout, etc.

One of the major challenges of Tauri is that it doesn't guarantee a consistent, or even eventually-consistent degree of API support. An immediate example of this is WebGPU access. If Tauri ran Chromium everywhere, an app could use WebGPU on most desktops that will support it's current version, either right now, or very soon. Because Tauri uses the default browser, the release date for a Linux app using GPU compute is "soon-*ish*?" and Mac is "ehhhhh". And because it goes with what is on the path, there is no accounting for version, either. I’d really like there to be a dynamic installer process that allowed you to check for certain requirements and then check for other browsers, and then install a different head, as a last resort. No WebGPU in Safari? Is Chrome installed? Go with that. No? Then let me install a portable version that this Tauri app and all others can use.

At first, I wanted to create my usual showcase for desktop applications, a file renamer app. However, I soon hit an issue when I wanted to select a directory using the file browser button. First, Tauri doesn't allow to use the regular JavaScript file-related API; Instead, it provides a more limited API. Worse, you need to explicitly configure which file system paths are available at build time, and they are part of an enumeration. I understand that security is a growing concern in modern software. Yet, I fail to understand this limitation on a desktop app, where every other app can access any directory. ## The bad However, Tauri's biggest problem is its design, more precisely, its separation between the front and the back end. What I love in Vaadin is its management of all things frontend, leaving you to learn the framework only. It allows your backend developers to build web apps without dealing with HTML, CSS, and JavaScript. Tauri, though a desktop framework, made precisely the opposite choice. Your developers will need to know frontend technologies. Worse, the separation reproduces the request-response model created using browser technologies to create UIs. Reminder: early desktop apps use the Observer model, which better fits user interactions. We designed apps around the request-response model only after we ported them on the web. Using this model in a desktop app is a regression, in my opinion. ## Conclusion Tauri has many things to like, mainly everything that revolves around the developer experience. ... However, it's a no-go for me: to create a simple desktop app, I don't want to learn how to center a ``` div ``` or about the flexbox layout, etc. **To go further:** - Tauri

I'm just wondering if my experience was unusual or if rendering differences are as common as they felt to me. ... Did they get the docs sorted out? ... In particular, rendering and crashing issues specific to Linux have been blockers, but Tauri 1.x also has other rendering issues on Linux that 2.0 fixed. There's little to no guidance on what's causing the stability and new rendering problems or how to fix them. … With Electron's UI powered by the same browser across platforms, you end up with a much more consistent experience. ... This is our #1 frustration with Tauri. The OS-provided system webviews are not stable, repeatable, consistent platforms to build upon. Tauri decided that a key selling point of their platform was that Tauri builds won't bundle a browser runtime with your application. Instead, you wind up with whatever your operating system's browser runtime is. Each OS gets a different runtime. Sounds nice on paper, but that has turned into a massive headache for us. … To be fair, we're using advanced browser features. Animation, 2D contexts, trying to do things like pointer lock. But these are all examples of things that are extremely different between each web view. All of this has doubled (quadrupled - with dev and prod builds behaving so differently! - but that's another story) the amount of physical testing we have to do. It takes so much time to manually test and ship. When we were building for the web, this wasn't an issue even if people used different browsers. The webviews have incredibly different behavior than web browsers. Their rationale for using OS-provided system webviews instead of a bundled runtime baked into the installer at build time is that it would save space. But in reality all it has done is created developer frustration. And wasted so much freaking time. It's the single biggest time sink we have to deal with right now. We were sold on Tauri because of Rust, but the system browser runtime is just such a bad decision. A self-imposed shotgun wound to the chest. The Tauri folks have heard these complaints, and unfortunately their approach to solving it is to put Servo support on the roadmap. That's 1000% not the right fix. ... That's the real trade off. … It feels great working in Rust, but the webviews kill it. They're inferior browsers and super unlike one another. If Tauri swapped OS webviews for Chromium, they'd have a proper Electron competitor on their hands. ... The fact they use the system webview is front, left and center on their website. It’s like you decided to use a fork because of the decorations on the back, and now complain that it’s pointy and the developers should just make it a spoon instead. … I've worked on large consumer-facing web-apps where we had a dedicated QA team (and/or contracting firm) that runs visual regression testing on multiple platforms and browser versions. As a solo developer, I have no interest in being that team for my hobby project. So the tradeoff with Tauri for me was "accept that I will ship obvious UI bugs" vs "accept that I will ship a bloated binary." … paxys 4 months ago ... No only were there UI inconsistencies, but Safari lags behind chrome with things like the Popover API and the build/codesign/CD ecosystem for Tauri is incredibly scattered. When I was using it, IAPs were still not really an option for Tauri or at least I could not find any docs or resources about it. … Also, did you go Tauri 2.0 or 1.0? 2.0 released its first stable release while I was mid-stream on v1, and migration was a nightmare/documentation was woefully inadequate.

Without searching, can you ever find something? And if your telescope is cracked, can you see the planets or stars? We know that our search lens was dusty and scratched; it felt sometimes like a roll of the dice, and some folks even resorted to using ChatGPT to find answers. … ### Search Engine ... Previously, we had a setup that would take our markdown documentation and JavaScript AST and use that to build the search index. Although it led to much faster indexing times, it meant we had a tightly coupled dependency between search indexing and the way we rendered content on our website. This would sometimes lead to the search results getting out of sync with the content on the live website. In order to update the website or optimize the indexer, someone would need to have knowledge of both, making it more difficult to maintain. … The meilisearch/docs-searchbar.js project was good, but I always felt it could use some improvements to get feature parity with algolia/docsearch. I also felt we could help with an update to help with UI/UX. The main pain points with meilisearch/docs-searchbar.js were: 1. On mobile screens, it needed UI/UX improvements so that the search results wouldn’t go off-screen. 2. On desktop, the search results would normally appear under the search input, which in the case of tauri.app was placed on the top-right. This caused a bad UX because you’d have to keep moving your eyes between the page content in the middle and the search results in the top-right. 3. It is missing a common keybinding. `ctrl/command + K` to start the search, `ctrl/command + K` is pretty common in the JS ecosystem documentation sites. It also doesn’t have the ability to select text on the page and then trigger a search directly from that text. I have been always a big fan of algolia/docsearch UI/UX. It checked all the features on my list, and I always wanted to have that for tauri.app. In fact, several months ago, I tried to change the meilisearch/docs-searchbar.js CSS on our end to improve point 1 and 2 above but I stopped mid-way because of the difficulty of building on top of existing css and fighting for highest specifity (plus CSS is hard :wink:). Other projects also couldn’t benefit from our modifications in an easy way.