Sources

### Data collection Ok, the first thing that comes often first is the fact that Ubuntu spies on its users. This complaint usually is linked to 2 Ubuntu features: the Amazon web app, and the opt-out system information. Ubuntu introduced an integration with Amazon when they started shipping Unity as a default desktop environment, and later, they added a reporting tool that collects sytem information and sends it back to Ubuntu to check on what their users are actually using hardware wise. The Amazon thing was bad. It sent unencrypted search requests to Amazon, for anything the users were looking for in the Unity dash, and it generally returned very bad results. Ubuntu actually allowed users to disable that feature a little later, and in the end, that Amazon integration turned into an affiliate link in the dash, that could be removed easily, and not used. Still, the community generally resented the distro for adding this by default. … While these are valid criticisms, you have to remember that the competing projects, at that time, were far from ready. Ubuntu should have gone with Wayland instead of inventing Mir is a phrase we often read nowadays, and still, Wayland at the time just wasn’t suited for what Ubuntu wanted to do. Wayland is just a protocol, and its implementation at the time, Weston was severely lacking. Mir was supposed to allow a less modular design, with more stuff relegated to the display server instead of the client, to guarantee more performance on ARM environments, which was where Mir would run as well: on smartphones and IoT devices. Wayland didn’t meet these criteria. … These two projects are often criticized as unnecessary, and as having hurt the development of competing initiatives. The problem here is that Ubuntu has a vision that differed from what the other projects had in mind, and these couldn’t be reconciled, so they had to go their own way, or ditch what they felt the desktop should look like, or their plans for convergence. … ### Snaps Snaps are another controversial point, that I would tend to put in the “they invented another way to do things instead of contributing to an already existing model” locker. Snaps are a way of packaging and distributing software. They are generally criticized for being slow to load, creating new mount points in the disk utility, yes, really, and for being proprietary. While snaps are indeed pretty slow to load, don’t always respect the user’s theme, and do use mount points to mount the snaps and allow the apps to run, the proprietary part is complete bogus. Snaps themselves are completely open source, as is the way of creating them, running them. What is proprietary, however, is the snap store, the place where applications are distributed. … Now snaps can be criticized for a lot of things, and I generally agree that I’d rather use regular packages that are smaller, faster, and better integrated, than snaps or even flatpaks. You just have to remember that the decision to use snaps by Ubuntu is more than just a statement that they don’t want to use other people’s stuff. Snaps can also implement server side stuff, like Nextcloud, when flatpaks can’t, or just don’t at the moment.

Ive been in and out of this forum… because i was trying to find out why ubuntu feels so… unstable, unreliable and a pain to use (only tried ubuntu24 so far). ... I can most of the time assume correctly why something in linux is not working. I do it often. The difference is - I do it often because the issues I’m confronted with 95% have to do with my individualization of the OS. My first issue with ubuntu was during the 2nd step of the installer when I clicked the vision impaired magnifying glass. The magnetization aid messed up the scale of the UI so much - it was impossible to revert exit or continue and forced me to reboot. Many issues small and big followed. with a cleanly installed version 24 … Because what i unexpectedly got was an overcomplicated overly complex, badly documented, anti-intuitive, OS with a hard to use UI and a defensive community behind it. Imo. Users who take their valueable time to give feedback are either: - overwhelmed by the complexity of options to do so and give up because no place seems right - scared of - completely misunderstood … issue 1: why is there no option to give feedback on snap programs where they are obtained? issue 2:is there an alternative without the need to give personal information (phone) He also hints at the obvious … bigger issue imo. … “Ubuntu has a bigger percentage of newbies that probably won’t do the mobile verification” … i would wonder if those users would even try to understand where they ended up and not close github - immediatly. … I switched to ubuntu because i believed that claim still counts - and as experienced user - i restarted the installer 3 times because i was met with bugs and unclarity. after the installation… it was unclear which UI to pick - which store to use - how to create a “dock/taskbar shortcut”. I had to boot sign my nvidia drivers or was forced to disable safe boot instead… My NTFS drives where not recognized and not automatically mounts…

With Ubuntu, Canonical has had notable success in convincing people to switch from other platforms, but potential Ubuntu users are still running into trouble in several areas. Having spent some time on Canonical's forums, I've identified 10 points that seem to be common sticking points for new users -- that is, problems that have the potential to prevent a new user from adopting Ubuntu in the long term. These problems span the entire Ubuntu experience, but they all have two things in common: they are all serious enough to evoke the dreaded "I tried Linux but it didn't work" excuse, and they are all solvable. Ubuntu is still bad at properly detecting and setting up the display. Once it's gone wrong, there isn't much you can do from the GUI setup tool -- it either lies about your screen settings or offers inappropriate screen modes. Anyone for 640x480@52Hz on a 19-inch CRT? This is probably the most frequently reported complaint on the beginner forum. Other operating systems can set up the screen, so why can't Linux? From the user perspective, the solution involves some research and the editing of the xorg.conf config file. This is bad, because if the user makes a single mistake -- presuming the typical user is resourceful enough to make it this far -- it's all too easy to render the whole Ubuntu setup unusable. This problem is so widely acknowledged as a weakness of Ubuntu that I was surprised that Ubuntu 8.04 was still getting it wrong. ... Ubuntu is still bad at properly detecting and setting up the display. Once it's gone wrong, there isn't much you can do from the GUI setup tool -- it either lies about your screen settings or offers inappropriate screen modes. Anyone for 640x480@52Hz on a 19-inch CRT? This is probably the most frequently reported complaint on the beginner forum. Other operating systems can set up the screen, so why can't Linux? From the user perspective, the solution involves some research and the editing of the xorg.conf config file.

These six issues – the extent of file compatibility, the lack of feedback on system behaviours, the use of jargon, challenges to the ability to use flash, access to applications in the software centre, and installing a printer – are central to whether Ubuntu will be taken up by ‘ordinary’ users. For many, if they’re unclear about these things, they’ll simply be unable to use Ubuntu to accomplish their basic goals: to communicate and exchange documents, to feel in control, to use the internet fully and to access new software.

This item was probably where the least concrete progress was made, though I probably could have predicted that. Many of the processes in the Ubuntu project serve to ensure that we ship resilient software, and don’t break users - so changing them in a hurry is not generally a good idea. … ... `sudo` implementation on Ubuntu 25.10, and uutils’ `coreutils` has *mostly* replaced the GNU implementation, with a few exceptions, many of which will be resolved by releases in the coming weeks. ... `initramfs-tools` until remaining hooks are ported. For each of these changes ( `coreutils`, `sudo-rs` and `dracut`) the previous implementations will remain supported for now, with well-documented instructions on the reversion of each change for those who run into unavoidable issues - though we expect this to be a very small number of cases. ## What’s Next?

🚀 Tauri is revolutionizing desktop app development! But how does it really stack up against Electron in 2025? 🤔 In this video, we break down: ✅ What is Tauri? ✅ Why developers are switching from Electron ✅ Performance, security, size, and cross-platform support ✅ Real-world pros & cons you NEED to know ✅ Which one is better for your next app? 👨‍💻 Whether you're a beginner or experienced dev, this breakdown will help you decide the best tool for building modern desktop applications! 💬 Let us know in the comments: Are you team Tauri or team Electron? 🔔 Don’t forget to LIKE, SUBSCRIBE, and hit the bell icon for more tech breakdowns! #Tauri #Electron #WebDevelopment #DesktopApps #TauriVsElectron #DevTools2025 #CodingTips #SoftwareDevelopment Why Tauri is Replacing Electron in 2025 🧨🔥 Tauri vs Electron ⚔️ The Battle for Desktop Apps Begins! Stop Using Electron? 🤯 Try Tauri Instead! Electron is Dying? 😱 Meet Tauri – The Future of Desktop Apps! Tauri Explained in 5 Minutes ⏱️ | El...

The IPC layer was completely rewritten to address performance bottlenecks, the security model was replaced with a more granular and powerful permissions system, and many core APIs were modularized into a more maintainable and extensible plugin architecture.2 ... This configuration forces SvelteKit to act as a sophisticated build tool that outputs a self-contained, client-side application, which is precisely what Tauri requires. While this enables the use of Svelte’s powerful component model and reactivity within a Tauri app, it’s a significant trade-off. Developers are effectively using a subset of SvelteKit’s features and must adapt their data-fetching strategies and application structure to a purely client-side model. This is a crucial consideration for teams evaluating the stack, as it alters the typical web development workflow associated with SvelteKit and has a ripple effect on how the application must be architected. … However, the framework is not without its challenges. The primary barrier to adoption for many teams will be the requirement of Rust for backend development, which introduces a steeper learning curve compared to JavaScript-based alternatives.8 The reliance on native webviews, while a source of efficiency, can lead to minor UI rendering inconsistencies across platforms, necessitating more rigorous testing.8 Furthermore, as a rapidly evolving project, the documentation has at times struggled to keep pace with the significant breaking changes introduced in the v2.0 development cycle, creating friction for developers migrating from version 1.0 or learning the framework for the first time.66 **Future Outlook: The Road Beyond 2.0** ... Post-release, the team has identified improving the mobile developer experience and enhancing documentation as key priorities.15 This acknowledgment of community feedback suggests a commitment to refining the framework and lowering the barrier to entry for new developers. The continued growth of the official and community plugin repositories will be a critical factor in Tauri’s long-term success, as it will determine the breadth of native functionality that is readily available to developers.6

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.

## 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.

For years, Electron has been the dominant choice for building cross-platform desktop applications using web technologies. While it has enabled countless developers to create desktop apps with familiar tools like JavaScript, HTML, and CSS, it also comes with significant drawbacks, including high memory usage, slow performance, and large application sizes. … Electron applications expose a full Node.js runtime, increasing the risk of security vulnerabilities if proper precautions are not taken. Tauri enforces a strict security model where applications must explicitly define the APIs they need access to. By using Rust’s strong memory safety guarantees and isolating system interactions, Tauri provides a more secure environment. … Tauri presents a compelling alternative to Electron for building desktop applications with web technologies. By leveraging Rust for backend performance and native webviews for rendering, it offers significant advantages in terms of application size, memory efficiency, security, and startup speed. While Electron remains a powerful tool for applications that require deep Node.js integration, Tauri’s lightweight approach makes it an excellent choice for developers looking to build modern, efficient desktop applications.

**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.

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.