Sources

First, this observation – which I strongly agree with – regarding the desktop apps we ended up having > thanksto Electron and why we often consider them “buggy”[…] > […] > As documented in the thread from late 2023, this is a common issue for the majority of AI clients built with SwiftUI, which is often less efficient than Electron when it comes to rendering real-time chat messages. … ... > As usual, the commentary from @mjtsai is so spot on... The developer experience with Swift is so terrible. The language has brought many modern features to developers on Apple platforms, but at the significant cost of productivity and efficiency. > If you spend any time on other platforms, the differences smack you in the face almost immediately. ... While I've never found an Electron app as good as a native app, I've also never found a Native app as bad as a Catalyst app - even the first party ones from Apple. So much basic stuff, and it's hard to know if it's because the APIs are garbage, or because Catalyst just inherently attracts iPad-first developers who are bad at doing Mac apps. … Electron is still a leaky abstraction. Basic stuff doesn’t work as expected. My biggest beef is that most of the apps ignore regional preferences set at the OS level. The quickest way to tell an electron app from a native one is when you notice the whacky datetime formatting. It's pretty ridiculous that Swift UI / Catalyst often ends up as being worse than Electron. Outside of the obscene memory and CPU usage, the big problem with Electron apps -- as I'm sure many of you have experienced -- is the way they don't adhere to OS conventions. Things like system-wide keystrokes don't work properly, or UI elements don't behave properly. But somehow Apple managed to bungle Swift UI and Catalyst in the same way, even though it's presumably AppKit underlying it. … One of the issues with Electron that Apple should acknowledge, is that those Electron apps which don't adhere to HIG, undermine the platform and in turn one of the main reasons customers used to (past tense) buy Apple; great hardware and great software, built with a standard. Once that goes out of the window, and my user experience for non OS-apps on mac is the same as it is on windows, that is one less reason to buy a Mac. … - Multiplatform is a common business requirement. Apple refuses to bring back Yellowbox or acknowledge non-Apple platforms exist. - Apple's dev stack doesn't offer 10x speed or 10x simplicity to produce on Apple platforms. You still have to sweat the details (which Apple rarely does). The frameworks have not kept up with user and dev expectations. Meanwhile, it's not radically difficult to build a web app. - Hostile developer outreach. Poor experiences with app review, bug reports, and a "deal with it" attitude towards yearly breaking changes. - Apple's lost the UI/UX high-ground. "They don't have any taste". The HIG is gone. Catalyst and SwiftUI are negative starting points. There's no standard anymore, just common design patterns. That web apps are so widely-accepted proves the shift. … It is right to point to Apple's failure to embrace the web whilst squeezing out their own shitty cross-platform toolkits, I think, without simply apologising for some of the worst apps ever written. PHP rightly has a reputation for encouraging security vulnerabilities in web-apps, and Electron rightly has a reputation for slow, fat, not native and questionably inaccessible desktop apps. Of course, in both cases, there are great exceptions, but let's be honest here, making Electron look good is only possible if you're very selective in your criteria.

Because Electron apps are essentially browser windows with a Node.js server running in the background, they tend to consume a significant amount of memory. Because of that it doesn’t make much sense to use Electron for simple utilities. Electron apps can also be very large compared with their native counterparts. The difference in size can be especially pronounced when it comes to apps that don’t pack too many features.

First, electron doesn't integrate really well with the operating system: it's just a web browser displaying a website that is stored on your computer instead of being stored on a server. This means that if electron doesn't support a specific feature of your operating system, the apps using it also won't. A bigger problem, though, is the fact that developers often don't update the electron base, or not often enough. Electron, using CHromium, needs to be as up to date as any web browser you'd use everyday, to ensure that security flaws are patched. … And then there's the performance and resource usage. Since electron apps ship basically the whole of chromium's codebase, they aren't small. Discord, for example, once installed, weighs more than 700 MB. Almost a gigabyte. Even the most basic of Hello World applications would take about 100MB, just to display a line of text. … ### Transcript {ts:0} hey everyone this is nick and if there's one technology that is divisive between ... {ts:13} it as a desktop app and while it has many advantages for developers it also has many issues for their users so let's … {ts:324} snap store and everything is generally pretty fast but on mac os or windows the review process can take days so if you {ts:330} have a critical bug fix for your users you would probably prefer if that fix was deployed immediately as it's ready {ts:338} of course it also means that developers can push whatever they want to users without any control from the platform … {ts:386} platform they don't have to waste time re-implementing stuff and it also kind of lets them bypass the store updates {ts:392} policies which companies tend to like so generally for companies electron is a win {ts:398} but electron also has a lot of issues while it generally makes the developer's life easier for the user it's less … {ts:425} won't for example electron discontinued support for 32-bit systems so if you have an older computer none of these {ts:433} electron apps will work even though the website itself would work perfectly well since the application also doesn't use a {ts:440} native toolkit like gtk or cute on linux it also won't respect your theme your accent color your icon theme your header … {ts:489} guidelines in the same sentence just doesn't feel right at all now of course that's not something that will bother {ts:496} everyone some people are fine with using apps that don't look or feel the same and that's okay too a bigger problem {ts:503} though is that while it's pretty easy to update the content of the app the website part of the application a lot of {ts:510} developers don't generally update the electron part of their application see when you create an electron app you have {ts:517} basically two code bases your web app and electron and both should be updated regularly because electron using {ts:525} chromium needs to be as up-to-date as any web browser you would use every day to ensure that security flaws are … {ts:552} updating the electron version they use deprive users of that support so on wayland discord doesn't support screen {ts:560} sharing or when you use the flat pack version it doesn't support file portals so in the end you can't share your {ts:566} screen with other people and when you try to open a file to upload for example you will always get the gtk file picker … {ts:616} and then there's the performance and resource usage since electron apps ship basically the {ts:622} whole of chromium's code base they aren't small discord for example once installed {ts:628} weighs more than 700 megabytes almost a gigabyte even the most basic of hello world {ts:634} applications would take about a hundred megabytes just to display a line of text the size usage is extremely high if you … {ts:755} people mainly because of this specific reason developers either assume users will run {ts:761} their app and their app only all that all users have really high-end systems with a lot of ram and cpu cycles {ts:768} it prevents good optimization because there's always that incompressible chromium part that you cannot control as

## The Developer Complaint The frustration is real. Every time a big tech company releases a new desktop app, it's wrapped in Electron. Slack, Discord, Teams, Spotify, Notion, VS Code, and now OpenAI's Codex. It's everywhere. And developers notice things regular users don't. They see Task Manager showing 8 separate Chrome processes eating RAM. They feel the slight input lag when typing. They notice their laptop fans spinning up just to run what is essentially a chat app. One comment from the thread put it bluntly: "8GB of RAM usage for Codex App is clown-level ridiculous." The argument is simple: these companies have resources. They have some of the smartest engineers in the world. They literally build AI that can write code. Yet they ship apps that bundle an entire Chrome browser just to display a text input field? To developers who care about efficiency, it feels lazy. It feels like the company doesn't respect the user's machine. … ## Here's Where It Gets Messy Here's what made me uncomfortable reading this debate. Both sides are right. Developers are right that Electron apps are wasteful. They consume more memory, more CPU, and more disk space than necessary. When every app does this, your computer gets slower even though the hardware keeps getting better. … ## The VS Code Exception One thing that came up repeatedly: VS Code is also Electron, and people love it. VS Code proves that Electron apps *can* be performant and well-made. Microsoft invested heavily in optimization. The app feels responsive despite being web technology under the hood. So the problem isn't Electron itself. It's that most companies don't put in the same level of effort to optimize their Electron apps. They ship the default configuration and call it done. VS Code is the exception. Most Electron apps are the rule. … The problem isn't Electron. The problem is that Electron makes it too easy to skip optimization. Why spend weeks profiling memory usage when the app already works? Most teams ship the default config and move on to the next feature. VS Code got fast because Microsoft actually put in the work. Most companies don't. Maybe AI will change this. Ironic, isn't it?

Electron's choices, especially the very idea of building interfaces with web tech and shipping large parts of Chromium to render them, are not uncontroversial. Reasonable people wonder why we made those choices. Operating systems already have user interface libraries. In those libraries is usually also some kind of WebView, often actually based on Blink (Windows) or WebKit (macOS, many Linux distributions). … ## Electron pits JavaScript versus native code The argument: JavaScript isn't the right choice for everything. Native is better. Electron is not native. This misconception is likely the fault of Electron's maintainer team and especially me. Most of the talks I've given in the earlier days of Electron highlighted its ability to interact with the operating system from JavaScript. … All `UIWebViews` run in a single process, which ends up using less CPU and Memory when directly compared with Electron. However, when running the actual Slack web app, users would report slow performance. Whatever the user wanted to do, it'd be faster in Chrome. Eventually, Apple moved towards a multi-process architecture with shared utility processes as popularized by Chrome et all with `WKWebView`. This "catch up" game remains – the very best web app rendering engines and runtimes can be found in our best browsers. Operating system WebViews will eventually catch up — but I have yet to see them ahead. … But: You might be surprised to hear that performance is not the primary reason why many Electron developers prefer a bundled engine. The primary reason is allowing developers to control the stability, security, and reliability of their applications independently from a WebView that's tightly coupled with the operating system and therefore out of their control.

The pitch? Code once, ship everywhere. The trade-off? Electron apps are notorious for using more RAM than traditional “native” apps, since each one ships with its own copy of Chromium. Some users also report quirky behavior or performance issues on macOS, especially with heavy apps or when Apple changes system APIs. Despite these criticisms, Electron remains one of the most popular ways to create cross-platform desktop software quickly. … ... If you’ve read any forum threads or watched opinion videos, you’ve probably heard the same refrains: Electron is bloated, slow, or “not native.” But do these criticisms hold water, or is Electron simply misunderstood? Let’s get real about what Electron is, why it has the reputation it does, and which criticisms are actually valid. … ## The Usual Complaints: Non-Native Feel, Performance, and Fragility The big gripes with Electron apps are pretty consistent: **Non-native look and feel:**Electron apps can feel different from platform-specific apps. UI controls may not match OS conventions, and behaviors can be subtly (or not so subtly) off. **JavaScript/Chromium overhead:**Each Electron app bundles a whole Chromium instance. This can mean higher memory and CPU usage, especially for basic tools. **Dynamic web pages:**Some teams ship Electron apps as essentially live web apps instead of self-contained binaries. This can make apps brittle, slower to load, and sometimes insecure. … ## Developer Quality Is the Real Problem Why do some Electron apps suck? Simple: bad development. Electron is easy to pick up, so inexperienced teams often use it and then ship subpar products. But this isn’t Electron’s fault—it’s a people problem. The same team would build a lousy native app if that’s what they used. ... Electron is a powerful, pragmatic tool for building desktop software. The real problem isn’t Electron, but how it’s used. Complaints about performance, memory usage, and “non-nativeness” usually stem from rushed development or bad product decisions, not inherent technical flaws. If you care about “creating an electron app,” focus on quality, testing, and user experience—just as you would with any stack.

So, if you’ve ever abandoned using an app after finding out it was built with Electron, what was the final straw? Was it slow start-up times? High RAM usage? Something else entirely? … Overall, I feel like some people jump on the “Electron bad” bandwagon because there are apps based on Electron that vary in quality a lot. Some are really good while some, for no real reason, feel odd when using them. They feel sluggish, all consume quite a few resources and some believe they don’t really have a place. I personally see Electron as a net positive, since there will be less work to do on all platforms, thus time can be better spent on something else. ... Another issue (now you have got me started!) is they all run on different version of electron, they never seem to keep up with the current version. I have 3 versions (I think, at work, so can’t check) of electron installed, for programs I rarely use. When I get home, will list the versions and the apps I use From my perspective there are two big issues with Electron applications. 1. They consume a lot of resources, mostly RAM. This is especially a problem with simple applications where they would normally be lightweight but are carrying huge overhead instead. 2. Security can be an issue with Electron applications. You basically have a web browser core and node.js embedded in your application. This creates a huge attack surface. On top of that, Electron apps often do a bad job of keeping up-to-date with the latest Electron. … There are multiple versions of electron in the repo and AUR and apps can be linked to those old versions. Also, some applications come with bundled electron. Electron apps not integrating or otherwise doing whatever they want to do is a huge reason why I don’t like them and I wouldn’t consider it to just be a blanket statement. … On top of that like many others have mentioned they are resource intensive in both ram, disk space, and cpu. I have literally had to help people on these very forums who are new and don’t know any better. There was a person who pretty much seemed to unknowingly use only electron apps which would eventually cause that person to run out of memory.

While it offers numerous benefits, there are significant drawbacks that can render Electron apps less than ideal for certain projects. In this article, we will delve into these downsides, analyzing performance issues, security concerns, user experience challenges, resource consumption, and significant implications for development and maintenance. ### Performance Issues #### Resource Consumption One of the most common criticisms of Electron applications is their resource consumption. Electron apps bundle the Chromium browser and Node.js runtime within each application, leading to larger file sizes and increased memory usage. This is particularly pronounced when comparing an Electron-based app to a native desktop application. While native applications can be optimized to run with minimal overhead, Electron apps often include an entire browser engine, impacting overall performance. … ### User Experience Challenges #### Inconsistent UI and UX While Electron enables developers to apply standard web technologies across platforms, it can lead to inconsistent user interfaces and experiences. Native applications often follow platform-specific design guidelines and conventions, offering a more unified and familiar experience for users. In contrast, Electron apps might omit key user experience principles, appearing out of sync with platform expectations and creating friction. For instance, a Windows user interacting with an Electron app would encounter the same UI elements they find on macOS or Linux. This lack of regard for native guidelines can lead to confusion, dissatisfaction, and ultimately, decreased user engagement. … #### Battery Drain Electron applications can also be unforgiving when it comes to power consumption, particularly on mobile devices or laptops. The continuous background processes, including the Chromium engine, can lead to significant battery drain, negatively impacting mobile user experiences and potentially leading users to seek more efficient alternatives. This problem can also extend to laptops, where users might find their devices rapidly depleting battery life while running multiple Electron applications, leading to inconvenience and frustration. ### Complexity in Development and Maintenance #### Learning Curve While the promise of using familiar web technologies is appealing, the learning curve associated with Electron’s specific nuances can be steep for new developers. Mismanaged expectations can arise as developers unfamiliar with Electron grapple with its complexities, particularly in debugging and managing application environments. This steeper learning curve and the need for continuous education can lead to friction within teams and extend project timelines. #### Testing Challenges Electron applications often require more sophisticated end-to-end testing strategies, given their hybrid nature. Testing Electron apps can present unique hurdles when trying to replicate user interactions across a multitude of environments. The reliance on numerous libraries, dependencies, and cross-platform functionalities increases the complexity of ensuring comprehensive test coverage, often resulting in bugs reaching production. ### Debugging Difficulties #### Lack of Diagnostic Tools A critical issue for developers working with Electron is the reduced availability of debugging tools compared to traditional native development environments. While tools exist, they may not be as refined or deeply integrated as those for 100% native applications. Sometimes, developers find themselves struggling to identify and resolve bugs due to less-than-ideal tools, elongating the development process and leading to user-facing issues in live applications. #### Version Management Electron updates itself regularly, and while this is often a good thing, it can create challenges in managing application versions. New versions might introduce breaking changes that disrupt existing functionality, requiring developers to frequently revisit their code and adjust accordingly. Combined with the numerous third-party dependencies that may not immediately support the latest version, managing a stable release becomes a juggling act that can consume significant development time. ### Use Case Limitations #### Not Sufficient for High-Performance Needs When building high-performance applications, alternatives to Electron may present better choices. Applications such as video editing software, gaming, or any other resource-intensive tasks may benefit from native development due to the reduced overhead and direct system access. In these scenarios, users will likely be less forgiving of performance bottlenecks, and Electron’s limitations could lead to poor reviews and diminished reputation. … ### Conclusion Electron has undeniably altered the landscape of application development through its ability to streamline cross-platform usability and empower developers with web technologies. Nevertheless, the drawbacks of using Electron as a framework can create substantial limitations, prompting developers and organizations to consider other options for specific use cases. From performance and security to user experience and resource consumption, the challenges faced by Electron applications warrant serious consideration. While the framework serves as a valuable tool for many desktop application development projects, it is not without its flaws. Developers should weigh these disadvantages against the benefits, carefully assessing project requirements, user expectations, and long-term implications before embarking on an Electron app. In conclusion, while Electron can simplify some aspects of app development, it remains essential to be acutely aware of its limitations.

The pitch? Code once, ship everywhere. The trade-off? Electron apps are notorious for using more RAM than traditional "native" apps, since each one ships with its own copy of Chromium. Some users also report quirky behavior or performance issues on macOS, especially with heavy apps or when Apple changes system APIs. Despite these criticisms, Electron remains one of the most popular ways to create cross-platform desktop software quickly. … ... If you've read any forum threads or watched opinion videos, you've probably heard the same refrains: Electron is bloated, slow, or "not native." But do these criticisms hold water, or is Electron simply misunderstood? ... ## The Usual Complaints: Non-Native Feel, Performance, and Fragility The big gripes with Electron apps are pretty consistent: **Non-native look and feel:**Electron apps can feel different from platform-specific apps. UI controls may not match OS conventions, and behaviors can be subtly (or not so subtly) off. **JavaScript/Chromium overhead:**Each Electron app bundles a whole Chromium instance. This can mean higher memory and CPU usage, especially for basic tools. **Dynamic web pages:**Some teams ship Electron apps as essentially live web apps instead of self-contained binaries. This can make apps brittle, slower to load, and sometimes insecure. But let's be clear: these are potential issues, not guaranteed outcomes. Most "electron desktop app" complaints stem from bad examples, not the platform itself. ## The "Native" Decay: Why Native Apps Aren't What They Used to Be Ironically, many modern "native" macOS and Windows apps also feel cheap or clunky. UI polish, responsiveness, and platform integration have stagnated, and even Apple's own software often cuts corners. "Native" doesn't mean what it used to. ... ## Developer Quality Is the Real Problem Why do some Electron apps suck? Simple: bad development. Electron is easy to pick up, so inexperienced teams often use it and then ship subpar products. But this isn't Electron's fault—it's a people problem. The same team would build a lousy native app if that's what they used. Well-built Electron apps can be fast, polished, and indistinguishable from native—VS Code is the canonical "electron app example" proving the point. ... Electron is a powerful, pragmatic tool for building desktop software. The real problem isn't Electron, but how it's used. Complaints about performance, memory usage, and "non-nativeness" usually stem from rushed development or bad product decisions, not inherent technical flaws. If you care about "creating an electron app," focus on quality, testing, and user experience—just as you would with any stack.

1) Non native cross platform frameworks. This includes QT, JavaFX/Swing, Flutter and others. While they are probably more snappier than Electron apps, you can't really call them native. A lot of the criticism of Electron in terms of UI/UX, can be directed at those as well. 2) Native. This means I need to develop at least 2 different UIs to capture 98% of the market, and being a former Linux user and understanding the struggle of lack of good apps in Linux, I can't ignore that platform. So 3 times the development time, 3 times the bug fixes, 3 times the support. 3) Electron. We all know this one. While I agree that big companies like Slack, Microsoft or Spotify can (and should) invest money in proper app development for each platform; solo developers like me, rarely have the luxury to do so. So I'm left with either choosing one platform to focus on (in my case its Mac since I'm a Mac user) and ignoring all others (at least for now) or settle on semi-native solutions. I'm a perfectionist and I have a vision. But because I'm a power user, doesn't mean everybody else is like me. So to all the people who say that Electron is not native and breaks their UI/UX - is this really an issue among non power users, or is it just us, developers, being frustrated (and I share this frustration) over minor issues like keyboard shortcuts or lack of native Mac text fields?

However, Svelte’s relatively recent entry into the mainstream poses its own challenges. For one, the ecosystem and community support are still growing, which can impact the availability of resources and expertise, especially for large-scale, complex applications. Furthermore, integration with large-scale enterprise systems or complex architectures might not be as straightforward as with more established frameworks. ### Common Scalability Challenges in Svelte Developers using Svelte for large-scale projects may encounter specific scalability challenges: … However, as our team and codebase grew, we started to encounter limitations with these platforms. In a high-traffic environment with multiple developers pushing numerous builds daily, we observed these systems beginning to falter. The smooth and efficient process we initially experienced was no longer consistent. ### Caching Issues Leading to Build Failures A particularly troubling issue we faced was related to caching on Vercel. Despite successful build logs and transferring the domain to the new deployment, we frequently encountered serverless function start failures in production. These subtle build issues were often elusive and challenging to debug, significantly impacting our deployment reliability.

(1, 2, 3) Like most frameworks that abstract the DOM, Svelte has incompatibilities like the inability to name a prop `class` because it’s a reserved keyword in JS, and you’ll use `on:click` not `onclick`, but these quirks are few in number and reflect carefully chosen tradeoffs. … Concurrent mode applies additional restrictions that developers are learning to work with, which the React team confidently trades for the benefits. The tradeoffs are complex, context-dependent, and nuanced. React may provide amazing UX in some circumstances once concurrent mode is ready, but I’m skeptical that their solution is the best one for our problems. … Svelte’s upsides are compelling to our team, but we also need to understand its downsides. First we’ll discuss the negatives that are unlikely to change. The compiler architecture moves complexity from the runtime and source code to buildtime and tools. Behind Svelte’s simple APIs sits a beefy compiler. Frontend web development has become very tool heavy in the webapp era, so in practice this adds little cost beyond what developers like myself already pay, but increased build complexity is important to acknowledge. For example Vue’s Evan You has stated that Vue should always be droppable into any webpage for immediate development. Many people like and rely on this ability. It keeps things simple. Svelte can do this but only by including its compiler in the browser, which currently weighs 870k. This is super useful in some circumstances, like Svelte’s REPL, but it’s not a viable option for normal application code. Svelte requires a build step that’s heavier than React’s JSX and Vue’s `.vue` files. Svelte is its own language not plain HTML+CSS+JS, increasing the risks of adoption, … Svelte may never be able to implement the equivalent of React’s concurrent mode. This could be a big deal and it’s probably the weakest part of my recommendation to my team. See the discussion above for more about concurrent mode. Rich Harris intends to implement an equivalent to React’s suspense, so it appears React’s advantage there is temporary. Svelte has a history of surprising innovations but we shouldn’t count on this one. … Svelte’s userland resources and cultural knowledge like patterns, anti-patterns, best practices, and consensus libraries are sparse and under-developed. People who adopt it today will have to think through problems where other communities have common knowledge solutions, making the learning curve temporarily steeper. Svelte’s beginner documentation is great but people are still figuring out what mastery looks like. … Svelte is known for its tantalizingly small JavaScript bundles, and compiler improvements sometimes shrink the output even more for free, but there’s a problem here. With its current compiler, as more components are added to a single bundle, Svelte’s JS size advantage shrinks and eventually reverses, because Svelte templates are compiled to a form that is more verbose than the source.