A huge pain of desktop development is managing dependencies particularly if you are coming from C++/Native code. Imagine you wanted to make a simple app in the 2010s that accesses the webcam for instance: If you use chrome you got the full html5 runtime, whereas with other tools you'd need bespoke libraries which your end user may not have.
The only way to ship the same code between linux, macOS, and Windows would have been to either use something like Qt or the JVM back in the 2010s. The JVM desktop stuff was super ugly and Java itself had become notorious (also if you wanted anything remotely interesting like webcam/microphone or multimedia access you'd still have to ship dynamic libraries). Qt required special packaging skills to ship to the end user especially if third party libraries were involved. Electron killed that by bundling chrome (and chrome has a huge api surface).
Today, I would argue the package management situation for a language like rust is a lot different. You dont have to cobble different DLLs together, you can just statically compile dependencies and cargo/rust do a pretty good job of making sure it's bundled with your app. Other languages also now have similarly useful tools.
But then the C++ libraries you mentioned also had the ability to statically link into a binary, which means you could statically link the webcam access in, in your example. So I don't see the advantage you're arguing for?
Dynamic vs static linking is mostly a red herring for desktop GUI application development unless you want to integrate into something like Linux distro package managers, as dynamic libraries on Mac and Windows can be self-contained within the application bundle/directory with no disadvantage beyond marginally longer startup time, and you can do similar things with Flatpak and friends on Linux.
The real difference is that Rust provides a package repository with a unified build system that's as simple to use as NPM or NuGet.
vcpkg which is similar exists today, but it didn't in 2015 when Discord started, still isn't anywhere near as comprehensive as package repositories for languages where package management is part of the standard toolchain, and the underlying build systems are far messier under the hood.
It can also be helpful in development to use libraries built from source as part of the application's build process, at least as an easily-accessible option, which wasn't common practice in most C/C++ ecosystems historically where different libraries used different build systems and if you wanted to integrate them into something like a Visual Studio solution for easy reference to source code during development and debugging you were often on your own.
In C++ land, you are ultimately going to either need to cook up your own webcam library or look for a 3rd party (which, in 2010, likely didn't exist) to provide it.
Today, there are a few easy to discover rust crates which provide cross platform webcam apis. But further, rust does cross platform better than C/C++ IMO. It's really easy to change how code is compiled based on the target. That was all well thought out because rust was supposed to be a language for browsers.
Java desktop was only ugly if you chose for it to be. It was pretty minimal effort to get native look and feel. Nothing built in electron looks native. If we're accepting custom interface using electron, that was doable with Java too.
At the time Electron came out, there weren’t as many cross-platform UI frameworks available that they could have gone with.
You can see this with the comparison chart. GPUI effectively replaced Electron so the desktop app UI works across platforms. React Native is replaced with WebAssembly so that Rust can be the primary language across all platforms including mobile.
It seems like the new situation for Discord is rather elegant, and that none of this would have been available when it first came out.
GPUI works well for Zed, but it's built for Zed's needs only. There is no official crates.io udates. Breaking changes land as Zed needs them, and outside PRs often get declined causing a mess of several forks.
Why https://gpui.rs/ doesn't have a single screenshot of how it actually looks?
The first thing anyone would want to know when choosing a GUI framework is how it looks by default. Every major GUI toolkit has screenshots on their websites.
This happens so often it makes me wonder if people just don't know how to take a screenshot and put it in a webpage with <img>.
Not mine. I loathe Electron like many people. But, as someone who is legally blind and has very limited vision, being able to have custom UI zoom levels, per application, has made my life much easier.
For a long time, and mostly out of frustration, I wanted to build my own stack of software around my vision. But the mammoth amount of effort it would require meant I never went through with it.
nice point, people like to shit on the web but it has one of the biggest accessibility features that most of the gui frameworks would just leave them as feature suggestions for years
The electron hate train needs to pull in to the station and be retired. We can just admit that it was a good solution for the problems of its time just like JQuery. Electron was conceived over a decade ago and it was an imperfect solution, but there’s no denying that it was a solution.
Election predates WebAssembly by 5 years and hit the scene only one year after Rust was first created.
And just like JQuery, its time is coming to a close as better frameworks are available now that weren’t available back then.
I never thought election was a good solution for the problems of its time. Just call it a web app and don't lie to people releasing something "native" for them to download.
Discord actually launched as a web app, and then moved to adding a desktop app, which has quite obviously become far more popular than visiting discordapp.com and using it in the browser.
Why do you think that is?
I'll give you a hint: if I close my web browser, how do I get a notification that I got a new message? Make sure you also pretend it's 2015 (launch year of Discord) and that I might be using Firefox, Safari, or Edge.
The funny part about this complaint is that you can literally just use the web app if you hate the desktop Electron app so much. That's one of the main benefits of Electron!
Discord isn't packaged as an Electron app simply because it pretends to be native, but because it has an entire system integration layer that isn't available in the web version.
That's like saying it would make sense to make Internet Explorer work on all platforms. It doesn't make sense.
The solution is to use user interface toolkits that are available on each platform. For example, wxWidgets or Qt or appropriate bindings to them if you can't be bothered to write UI code for each platform you're targeting.
Electron is pretty awesome in that it allows a small team to build a decent GUI app using their existing web skillset but it also feels like it's time for something better at this point.
With the ram prices as crazy as they are. It's pretty frustrating to have to run multiple GB eating applications just to do some basic tasks (90% is read and write messages, in the case of Discord). I understand that other people might use the more advanced features (voice chat, etc) but these could be loaded on-demand.
It's a bit crazy to me that I can comfortable run an entire Linux stack (+ Podman, monitoring, alerting and multiple services) in 512 MB ram (with 40% free, just checked!). However my Windows PC needs 5.5GB just to show the desktop! Realistically it needs somewhere between 8GB and 16GB for some basic web browsing and even then it can feel slow if you have a few apps like Discord running in the background.
Probably at the edge of being a good example. I recently switched to zed because of how bloated VS Code is becoming. I think it gained it’s momentum by being small, but enshitification seems to come for all software.
This is definitely true. It seems to be the modern approach that the less effort in development, the better!
I too had code that worked across 3 platforms with wxwidgets and a 3D game toolkit incorporated in opengl for visualisation, with most 2d controls being drawn using wxwidgets OnPaint handlers for custom controls rendered natively on that platform. I wrote this single-handedly, with another colleague handling the network code and firmware on the remote hardware devices.
Everything else is sheer laziness as far as I am concerned. There's even less excuse today with the rise of LLMs to do the majority of UI coding for you.
We have gotten so used to slow app startup these days I believe. I have recently started using Task Slinger [1] and every single time I boot it, I get a feeling that it was already running and it's window just showed up. I wish all modern software were like this.
I've rarely liked any Electron apps, both for the performance and because it seems to encourage a feeling of bloatedness, for want of a better word. Tried VS Code, but dropped it when they started putting too much AI in it and too much complexity. Sublime is so much better.
I don't know...there seems to be something unpleasant about all Electron apps.
I agree. The lack of native user interface controls for accessing menus and the inability for them to properly track focus for keyboard usage for right clicking (for example) makes them really difficult to use. You have to use the mouse for everything.
I did use VS code for a while but I've just gone back to using QT Creator simply because it is so much faster to use in daily life.
Discord isn't really the model to follow here, IMO. They killed their native Android app and moved to React Native, and now they're dropping React Native (while mobile somehow keeps "native UI", according to their CTO's tweet). If they wanted to maximize code reuse and accelerate feature development, they should have instead considered Kotlin Multiplatform, then they could've skipped the React Native detour while actually building apps that are native to the platform. (Rust and its cacophony of UI frameworks are not really platform-native anywhere, as far as I'm aware. Maybe Pop OS, but I don't know anyone targeting that specifically.)
This bit is obviously subjective, but Rust as a language is simply not ergonomic enough for a lot of the use cases people are trying to apply it to, especially UI development. Most of the Rust UI libraries I've seen to date either use a more imperative style, or attempt to replicate more declarative approaches like Compose UI or SwiftUI, but without the nice language aesthetics that make it simple to read and write. And if the counter-argument there is for LLMs to be reading and writing this stuff, that's a whole other can of worms: (1) The subsidized inference era is quickly coming to an end and (2) if you're using LLMs anyway, why not maintain apps that are as native to each platform as possible?
Is that a whole UI re-write in a native/non-web framework? Because in case that's not, this is still running in a browser, i.e. it stands at 80% or so of the bloat factor of electron, and what makes it faster is possibly (mainly?) that they haven't gotten yet to adding as much stuff as seen on the regular client.
Discord is a server-side protocol (the client isn't doing much besides displaying the server-prescribed state), there's very little logic/computation going on on there that should explain a world of difference.
Electron has always been about shipping cross-platform apps quickly, at the cost of higher memory usage and potentially worse performance. With or without LLMs, its core value proposition remains the same. LLMs simply amplify the framework’s existing strengths.
Raycast, originally a native macOS launcher, recently released v2 using a hybrid architecture. It’s not Electron, but it follows a similar approach to Spotify’s desktop app, using web technologies inside a native shell.
The memory usage is still pretty significant. It’s using around 350–450 MB at idle and can sometimes reach 1–2 GB depending on the workload. The upside is that they can now share most of their code across macOS and Windows and evolve beyond being just an app launcher.
It’s always been about trade-offs, and LLMs don’t fundamentally change that.
> you can now ship cross platform apps quickly, without electron.
The opposite is also true. My argument is that you can also ship Electron apps with more features more quickly with LLMs.
You still have a finite token budget. With native apps, you have to split those tokens across multiple platforms, whereas with Electron, you can reuse most of the code.
Big companies have been going back and forth between native and cross-platform approaches even before LLMs. They generally have the resources (humans, tokens, compute) that small and medium-sized companies don’t have. So I’d take their rationale with a grain of salt.
Because any kind of budget, resources are always finite? 2x the tokens roughly translates to 2x the cost. That’s a pretty big ask. Quality alone, unfortunately, isn’t always enough to justify it. There has to be business value too.
I don’t doubt that this will be faster and smaller than the current app, but it’s slightly annoying to me that the new app is getting so much coverage with specific claims about speed and memory usage when it’s not actually feature-complete or released yet.
One nice thing about Électron is that it supports accessbility and non-english IMEs correctly, and thus all Electron apps have decent accessibility out of the box, comparable to web apps.
GPUI has a single-paragraph accessibility section in their guide that defers to AccessKit[1] for everything, and points to a raw RS file for more info.[2]
I haven’t tested it or written anything using GPUI, but I’d expect it to be considerably harder work, based on the maturity of the web stack in this area. My assumptions have definitely been proven wrong before though… Anyone from Discord working on accessibility want to chime in?
I'm 100% on this since Electron is probably the worst thing that happened to the desktop development.
Hiwever, I'd like to hijack this front page article to for a related concern/question I've got.
It seems that all (popular) opensource LLM harnesses are either in JS or python (pi, hermes, opencode, paseo). The same seems to be true for closed source harnesses that I have used (deepseek, chatgpt).
I'd really like to ask why? I mean why somebody would use technologies like JS or python to implement a harness application instead of golang or rust or even C? I understand that before 1 year JS or python would be tempting but right now? Especially the LLm related companies have unlimited tokens and re-writing the harness software to golang or rust should be trivial.
This would benefit so many people (especiall considering the prices and scarcity of RAM these days).
So, why nobody does it? This is an honest question, I don't want to offend interpreted languages but it should be a universal truth that a compiled language is faster and consumes less ram.
Because most of the recent improvements on correctness and 'memory' are from harnesses, my guess is that you want to iterate and test quickly on the software that seems to improve the most and differentiate your brand best. Once a harness is 'complete' (which might happen for specific harnesses, but probably never for code), the team might start to optimise it with compiled languages.
The problem is that they never reach this point where they put it into native code. So you always have a plethora of JavaScript and Python files littering your system. It's baffling.
One good reason: extensibility. Pi is extremely malleable in ways that would probably be harder to achieve if it were in, say, Rust.
The resource usage of my harness is nothing compared to an electron app, and being able to easily customize it is more important to me than saving a few extra MB of ram.
I guess it depends on the harness, for example: chatgpt.exe right now is 1 GB on my windows machine. peseo.exe is 500 mb. and opencode.exe + bun.exe is 300 mb.
One possible reasons is that all of those are compiled languages vs interpreted. It doesn’t sound like much but compiling your code for three plus platforms and distributing binaries adds just enough complexity and friction to make it feel a lot more difficult.
chatgpt.exe right now is 1 GB on my windows machine. I have 16 GB and can spare none. So I don't think that nobody cares about such performance increases.
Most don't care or ever notice these things. Hacker News crowd does and always has, but the a non-technical user of a run-of-the-mill desktop app would rather have new features, and maybe some bug fixes, over performance.
Myself? I care. I regularly run a project that needs 6GB for the language server to provide type hints.
I think the reason why web technologies that are essentially being ported to desktop is not only because they provide cross-platform compatibility (still lacking a standardization on Linux), but they tremendously helped the hustle culture built around the motto of "ship it fast" by providing the fastest iterations and benefiting from already existing cheap pool of web developers, especially via outsourcing/offshoring.
Nowadays, AI (LLMs, genAI, call it what you will) has become so cheap to handle more than one codebase, they no longer feel the need for web only approaches.
Let’s hope we see a new wave of desktop apps rewritten natively, thanks to LLMs. Whether they use Rust with GPUI, C++ with Dear ImGui, or something else entirely, that would be great. Personally, I’m so fed up with bloated UIs. Windows is full of them, and it’s a pity considering how powerful our CPUs are.
compared to chromium, it's really limited, like it's just always a compromise with these
we should instead figure out a way to do electron but better and make it easier to do the things you can do with e.g. React with native languages and frameworks
The limitations are a large reason for why they're so resource efficient in the first place.
If you just reimplement Electron in a native language then you get... Chrome, which is already written in C++. The majority of RAM usage in Electron applications is from the native parts of Chrome itself and a decent ~40 MiB chunk for the Node.js runtime.
That’s what we’re trying to do with Slint (I work on it): a declarative, reactive UI like React, with the logic in Rust, C++, JS or Python. It needs no browser engine, so it uses a fraction of Electron’s memory.
I have had excellent results running a back-end Rust process that communicates with a C# Avalonia front-end via protobufs over named pipes on Windows and Domain Sockets on Linux and MacOS. With C# AOT I’ve been able to create self-contained apps that run incredibly fast despite the ipc between the front end and the rust core. I’m getting full 6 platform coverage too (Win/Linux/macOS on both x64 and arm64).
edit: Avalonia is quite mature, with accessibility to boot.
I have seen this assumption in recent GUI threads here (More so your upper post): Building a PC application is not equivalent to building a web browser. A web browser is a type of PC application built for a specific (But very broad!) use. I didn't think I would need to write this statement/distinction, but I have here. Web languages, culture, and syntax have not been a value add to PC application development. Electron is the clearest example why. My model is that is the value add of Electron: Appealing to web devs through language and culture.
Regarding "not doing what you can do with HTML/CSS/JS". Doubt. I varied and complex stuff and have never felt I needed to overload document rendering langs for this.
I will go a step further: I don't think Electron is a symptom of HTML/CSS/JS: I suspect it's more from the Node + Framework culture.
you simply just would stumble if you tried to do development like you can in React, constant "uhh... can't do that." while it just works in React.
I don't think anyone likes the look of Qt more than what you can achieve with webapps in terms of UI (style/etc. wise)
problem is the performance, I don't think many would be complaining if the performance was proper and the memory usage wasn't as terrible as it is now
you're talking about web browsers, I don't care what it runs on, if we have a way to run this in a lightweight way, would your complaints go away?
even Gnome uses JS etc.
you can do complex stuff in native UI, of course you can
what I'm talking about is the same kind of DX as with React. I really don't have faith in that, e.g. the new thing Discord is about to use, the css it tries to imitate just seems absolutely terrible.
the web technologies aren't perfect, in fact, far from it. however, when I see React vs whatever C/C++ alternative, I'd always go for React if it's about making the UI nice.
I've also shat on Electron before, but there's a reason as to why it's so popular. the tooling/UI capabilities are just much more powerful.
It's hard to say "Discord just showed why" before the product is in production and sees actual use. Promising initial statistics, but the transition is based on a lot of assumptions that won't really be proven until mass adoption and the software has seen long-term maintenance.
...exactly, and at some point you want to show inline animations or videos and all sorts of other media, show webpage previews, play audio snippets and all the other things things a webpage can do, and then you're back to either integrating a browser engine or attempt to write one from scratch (the browser engine can of course be provided by the system webview, e.g. what Tauri does).
I’ve programmed inline video players for 25 years. Same with audio and everything else. We had “accelerated” graphics back with winxp and gdi+ and of course OpenGL over ssh with x11. Browser preview pages in most apps are usually snippets of text and maybe an icon or pic. Not rendering a full page.
In a way, applications regressed a lot with react native and electron. I get it’s easier to develop but the apps are very bloated and underperforming even on computers with 10-100x more power.
If LLMs are truly driving the cost of "writing code" down to zero, then we shouldn't need Electron anymore. The whining from developers about how it's soooooo hard to write and maintain N separate native applications is no longer valid. Point an LLM at your existing Electron code base and have it fork off a bunch of native ports of it. LLMs are surprisingly good at matching the functionality of existing software. Keep and maintain the Electron app as an internal reference design (your developers probably only know JavaScript anyway) and "build" all your actual production releases from that.
Discord is my favorite thing to happen to chatting online. It combined everything useful from IRC, Skype and TeamSpeak, in one application and with modern UI, and things we now take for granted like attachments and link embeds. And even 10 years later, there are still no alternatives that aren't just discord but worse.
On another note, Microsoft Teams and new Outlook use very little amount of memory on paper, because their main windows show up under the Edge name. It’s a Microsoft way of solving the high ram usage problem.
When they can all share the same Electron implementation instead of individual copies it reduces memory quite a bit. I'm not trying to defend Electron way of development but I can see why they pushed WebView2.
When has Microsoft not been dishonest and misleading? Being dishonest and misleading has been Microsoft's entire game plan since all the way back into the Bill Gates era.
Discord’s new Rust client had its friends list loaded before the current Electron app could get past its loading screen, in a 15-second clip that we found on the X account of Discord co-founder and CTO Stanislav Vishnevskiy. The video had 2.3 million views at the time of writing, and Discord employees have confirmed that both apps were launched from a cold start.
"cross platform" I just spent 10 minutes trying to figure out what it uses for native on Linux, and whether it supports both Qt and GTK. Turns out the docs don't even mention Windows? "Cross platform" is now just MacOS + iOS + Android + Web? I guess the thought is supposed to be that crux helps you port your app to Windows if you want to... but even the example applications only run on those four platforms.
I'm pretty sure this was known since the early days of Electron. It was even one of the chief complaints about VS Code when it was first launched.
Electron's value prop has always been about having one team producing one app that is supported on multiple platforms with minimal additional effort.
This article does nothing to address that.
A huge pain of desktop development is managing dependencies particularly if you are coming from C++/Native code. Imagine you wanted to make a simple app in the 2010s that accesses the webcam for instance: If you use chrome you got the full html5 runtime, whereas with other tools you'd need bespoke libraries which your end user may not have.
The only way to ship the same code between linux, macOS, and Windows would have been to either use something like Qt or the JVM back in the 2010s. The JVM desktop stuff was super ugly and Java itself had become notorious (also if you wanted anything remotely interesting like webcam/microphone or multimedia access you'd still have to ship dynamic libraries). Qt required special packaging skills to ship to the end user especially if third party libraries were involved. Electron killed that by bundling chrome (and chrome has a huge api surface).
Today, I would argue the package management situation for a language like rust is a lot different. You dont have to cobble different DLLs together, you can just statically compile dependencies and cargo/rust do a pretty good job of making sure it's bundled with your app. Other languages also now have similarly useful tools.
But then the C++ libraries you mentioned also had the ability to statically link into a binary, which means you could statically link the webcam access in, in your example. So I don't see the advantage you're arguing for?
Dynamic vs static linking is mostly a red herring for desktop GUI application development unless you want to integrate into something like Linux distro package managers, as dynamic libraries on Mac and Windows can be self-contained within the application bundle/directory with no disadvantage beyond marginally longer startup time, and you can do similar things with Flatpak and friends on Linux.
The real difference is that Rust provides a package repository with a unified build system that's as simple to use as NPM or NuGet.
vcpkg which is similar exists today, but it didn't in 2015 when Discord started, still isn't anywhere near as comprehensive as package repositories for languages where package management is part of the standard toolchain, and the underlying build systems are far messier under the hood.
It can also be helpful in development to use libraries built from source as part of the application's build process, at least as an easily-accessible option, which wasn't common practice in most C/C++ ecosystems historically where different libraries used different build systems and if you wanted to integrate them into something like a Visual Studio solution for easy reference to source code during development and debugging you were often on your own.
It comes down to package distribution.
Chrome had already solved the hard problem of "how do we support webcams on linux, windows, and mac" and you as the dev just needed to use the Javascript webcam api. ( https://developer.mozilla.org/en-US/docs/Web/API/MediaDevice... )
In C++ land, you are ultimately going to either need to cook up your own webcam library or look for a 3rd party (which, in 2010, likely didn't exist) to provide it.
Today, there are a few easy to discover rust crates which provide cross platform webcam apis. But further, rust does cross platform better than C/C++ IMO. It's really easy to change how code is compiled based on the target. That was all well thought out because rust was supposed to be a language for browsers.
Java desktop was only ugly if you chose for it to be. It was pretty minimal effort to get native look and feel. Nothing built in electron looks native. If we're accepting custom interface using electron, that was doable with Java too.
The article at least indirectly addresses that.
At the time Electron came out, there weren’t as many cross-platform UI frameworks available that they could have gone with.
You can see this with the comparison chart. GPUI effectively replaced Electron so the desktop app UI works across platforms. React Native is replaced with WebAssembly so that Rust can be the primary language across all platforms including mobile.
It seems like the new situation for Discord is rather elegant, and that none of this would have been available when it first came out.
GPUI works well for Zed, but it's built for Zed's needs only. There is no official crates.io udates. Breaking changes land as Zed needs them, and outside PRs often get declined causing a mess of several forks.
Why https://gpui.rs/ doesn't have a single screenshot of how it actually looks?
The first thing anyone would want to know when choosing a GUI framework is how it looks by default. Every major GUI toolkit has screenshots on their websites.
This happens so often it makes me wonder if people just don't know how to take a screenshot and put it in a webpage with <img>.
Probably because it's not meant to be like Bootstrap.js where everyone's UI looks identical?
Even still, some screenshots of here's something we made earlier are always nice to see what's possible
Even imgui has screnshots.
The problem is that it made everyone's life worse.
Not mine. I loathe Electron like many people. But, as someone who is legally blind and has very limited vision, being able to have custom UI zoom levels, per application, has made my life much easier.
For a long time, and mostly out of frustration, I wanted to build my own stack of software around my vision. But the mammoth amount of effort it would require meant I never went through with it.
nice point, people like to shit on the web but it has one of the biggest accessibility features that most of the gui frameworks would just leave them as feature suggestions for years
I'd note that as stuff like A11y gets added into something like Discord, we'll see the app slowly bloat up to compensate.
Google Chrome generally used around 25mb per tab in 2010. Today, that number is often 500mb or even 1gb.
And Windows apps had accessibility before computers had 25MB RAM in total. Accessibility is not the cause of bloat.
do any of these native GUI libraries provide just as rich accessibility experiences to disabled people?
Would you really need 500mb for accessibility? Can't text to speech be outsourced to the OS or companion app?
The electron hate train needs to pull in to the station and be retired. We can just admit that it was a good solution for the problems of its time just like JQuery. Electron was conceived over a decade ago and it was an imperfect solution, but there’s no denying that it was a solution.
Election predates WebAssembly by 5 years and hit the scene only one year after Rust was first created.
And just like JQuery, its time is coming to a close as better frameworks are available now that weren’t available back then.
I never thought election was a good solution for the problems of its time. Just call it a web app and don't lie to people releasing something "native" for them to download.
Discord actually launched as a web app, and then moved to adding a desktop app, which has quite obviously become far more popular than visiting discordapp.com and using it in the browser.
Why do you think that is?
I'll give you a hint: if I close my web browser, how do I get a notification that I got a new message? Make sure you also pretend it's 2015 (launch year of Discord) and that I might be using Firefox, Safari, or Edge.
The funny part about this complaint is that you can literally just use the web app if you hate the desktop Electron app so much. That's one of the main benefits of Electron!
Noone is claiming that, though.
Discord isn't packaged as an Electron app simply because it pretends to be native, but because it has an entire system integration layer that isn't available in the web version.
> Electron's value prop
"Now you can have the cross-platform compatibility of a single-page application just by bundling Chrome."
It's worth remembering that electron was first released back in 2016 (formerly atom shell fro 2013) so Internet Explorer was still very much a thing.
Not a great justification, but it made a bit more sense then.
That's like saying it would make sense to make Internet Explorer work on all platforms. It doesn't make sense.
The solution is to use user interface toolkits that are available on each platform. For example, wxWidgets or Qt or appropriate bindings to them if you can't be bothered to write UI code for each platform you're targeting.
> The article does nothing to address that.
I dunno if you've been living under an enormous rock, but they used AI to make this.
Electron is pretty awesome in that it allows a small team to build a decent GUI app using their existing web skillset but it also feels like it's time for something better at this point.
With the ram prices as crazy as they are. It's pretty frustrating to have to run multiple GB eating applications just to do some basic tasks (90% is read and write messages, in the case of Discord). I understand that other people might use the more advanced features (voice chat, etc) but these could be loaded on-demand.
It's a bit crazy to me that I can comfortable run an entire Linux stack (+ Podman, monitoring, alerting and multiple services) in 512 MB ram (with 40% free, just checked!). However my Windows PC needs 5.5GB just to show the desktop! Realistically it needs somewhere between 8GB and 16GB for some basic web browsing and even then it can feel slow if you have a few apps like Discord running in the background.
Sorry can you show a decent GUI app in Electron compared with a native one.
You show this by all your other comments on memory. The reason apps take memory is Electron.
Plus I prefer apps that behave like OS native apps not the reduced GUI of web apps.
VS Code is a perfectly fine and pretty performant app.
Probably at the edge of being a good example. I recently switched to zed because of how bloated VS Code is becoming. I think it gained it’s momentum by being small, but enshitification seems to come for all software.
Based on the hype I tried zed thinking it would feel amazing compared to vscode, and it just didn't.
I don't know your Standards, but VS Code feels very smooth.
I volunteer as the arbiter of decency!
[dead]
I don't understand this idiocracy - it's super easy (I did myself alone many times) to have a single codebase in Qt for all OSes, even BSDs.
I think people become super lazy... "Ah, it's will ocupie a few hundreds of RAM, no problem, let's ship it."
They are companies with billions or even trillions shipping shit with Electron.
This is definitely true. It seems to be the modern approach that the less effort in development, the better!
I too had code that worked across 3 platforms with wxwidgets and a 3D game toolkit incorporated in opengl for visualisation, with most 2d controls being drawn using wxwidgets OnPaint handlers for custom controls rendered natively on that platform. I wrote this single-handedly, with another colleague handling the network code and firmware on the remote hardware devices.
Everything else is sheer laziness as far as I am concerned. There's even less excuse today with the rise of LLMs to do the majority of UI coding for you.
> single codebase in Qt
Not if your promary UI is web.
Qt runs on web too.
We have gotten so used to slow app startup these days I believe. I have recently started using Task Slinger [1] and every single time I boot it, I get a feeling that it was already running and it's window just showed up. I wish all modern software were like this.
[1]: https://taskslinger.net/
All modern apps are like this. It's Electron apps which are all legacy.
I've rarely liked any Electron apps, both for the performance and because it seems to encourage a feeling of bloatedness, for want of a better word. Tried VS Code, but dropped it when they started putting too much AI in it and too much complexity. Sublime is so much better.
I don't know...there seems to be something unpleasant about all Electron apps.
I agree. The lack of native user interface controls for accessing menus and the inability for them to properly track focus for keyboard usage for right clicking (for example) makes them really difficult to use. You have to use the mouse for everything.
I did use VS code for a while but I've just gone back to using QT Creator simply because it is so much faster to use in daily life.
[dead]
Discord isn't really the model to follow here, IMO. They killed their native Android app and moved to React Native, and now they're dropping React Native (while mobile somehow keeps "native UI", according to their CTO's tweet). If they wanted to maximize code reuse and accelerate feature development, they should have instead considered Kotlin Multiplatform, then they could've skipped the React Native detour while actually building apps that are native to the platform. (Rust and its cacophony of UI frameworks are not really platform-native anywhere, as far as I'm aware. Maybe Pop OS, but I don't know anyone targeting that specifically.)
This bit is obviously subjective, but Rust as a language is simply not ergonomic enough for a lot of the use cases people are trying to apply it to, especially UI development. Most of the Rust UI libraries I've seen to date either use a more imperative style, or attempt to replicate more declarative approaches like Compose UI or SwiftUI, but without the nice language aesthetics that make it simple to read and write. And if the counter-argument there is for LLMs to be reading and writing this stuff, that's a whole other can of worms: (1) The subsidized inference era is quickly coming to an end and (2) if you're using LLMs anyway, why not maintain apps that are as native to each platform as possible?
Is that a whole UI re-write in a native/non-web framework? Because in case that's not, this is still running in a browser, i.e. it stands at 80% or so of the bloat factor of electron, and what makes it faster is possibly (mainly?) that they haven't gotten yet to adding as much stuff as seen on the regular client.
Discord is a server-side protocol (the client isn't doing much besides displaying the server-prescribed state), there's very little logic/computation going on on there that should explain a world of difference.
Electron has always been about shipping cross-platform apps quickly, at the cost of higher memory usage and potentially worse performance. With or without LLMs, its core value proposition remains the same. LLMs simply amplify the framework’s existing strengths.
Raycast, originally a native macOS launcher, recently released v2 using a hybrid architecture. It’s not Electron, but it follows a similar approach to Spotify’s desktop app, using web technologies inside a native shell.
The memory usage is still pretty significant. It’s using around 350–450 MB at idle and can sometimes reach 1–2 GB depending on the workload. The upside is that they can now share most of their code across macOS and Windows and evolve beyond being just an app launcher.
It’s always been about trade-offs, and LLMs don’t fundamentally change that.
LLMs do change the tradeoff if you can now ship cross platform apps quickly, without electron.
GPUI is one example: some of the downsides of electron (UI is not native), but it solves memory and performance side, and shared codebase.
Just writing native apps because LLMs makes it cheaper is the other option. Shopify did this after years of react native.
> you can now ship cross platform apps quickly, without electron.
The opposite is also true. My argument is that you can also ship Electron apps with more features more quickly with LLMs.
You still have a finite token budget. With native apps, you have to split those tokens across multiple platforms, whereas with Electron, you can reuse most of the code.
Big companies have been going back and forth between native and cross-platform approaches even before LLMs. They generally have the resources (humans, tokens, compute) that small and medium-sized companies don’t have. So I’d take their rationale with a grain of salt.
Why assume finite token budgets? Scaling 2x tokens isn’t a major jump if it brings quality.
Also the GPUI approach is still finite tokens, just better stack.
Because any kind of budget, resources are always finite? 2x the tokens roughly translates to 2x the cost. That’s a pretty big ask. Quality alone, unfortunately, isn’t always enough to justify it. There has to be business value too.
I don’t doubt that this will be faster and smaller than the current app, but it’s slightly annoying to me that the new app is getting so much coverage with specific claims about speed and memory usage when it’s not actually feature-complete or released yet.
One nice thing about Électron is that it supports accessbility and non-english IMEs correctly, and thus all Electron apps have decent accessibility out of the box, comparable to web apps.
Most Rust GUI toolkits, at least in 2025, did not have that good accessibility or IME: https://www.boringcactus.com/2025/04/13/2025-survey-of-rust-...
Hopefully this has gotten better and the new discord client isn't worse in that regard.
GPUI has a single-paragraph accessibility section in their guide that defers to AccessKit[1] for everything, and points to a raw RS file for more info.[2]
I haven’t tested it or written anything using GPUI, but I’d expect it to be considerably harder work, based on the maturity of the web stack in this area. My assumptions have definitely been proven wrong before though… Anyone from Discord working on accessibility want to chime in?
[1] https://accesskit.dev/
[2] https://github.com/zed-industries/zed/blob/main/crates/gpui/...
I'm 100% on this since Electron is probably the worst thing that happened to the desktop development.
Hiwever, I'd like to hijack this front page article to for a related concern/question I've got.
It seems that all (popular) opensource LLM harnesses are either in JS or python (pi, hermes, opencode, paseo). The same seems to be true for closed source harnesses that I have used (deepseek, chatgpt).
I'd really like to ask why? I mean why somebody would use technologies like JS or python to implement a harness application instead of golang or rust or even C? I understand that before 1 year JS or python would be tempting but right now? Especially the LLm related companies have unlimited tokens and re-writing the harness software to golang or rust should be trivial.
This would benefit so many people (especiall considering the prices and scarcity of RAM these days).
So, why nobody does it? This is an honest question, I don't want to offend interpreted languages but it should be a universal truth that a compiled language is faster and consumes less ram.
Because most of the recent improvements on correctness and 'memory' are from harnesses, my guess is that you want to iterate and test quickly on the software that seems to improve the most and differentiate your brand best. Once a harness is 'complete' (which might happen for specific harnesses, but probably never for code), the team might start to optimise it with compiled languages.
The problem is that they never reach this point where they put it into native code. So you always have a plethora of JavaScript and Python files littering your system. It's baffling.
One good reason: extensibility. Pi is extremely malleable in ways that would probably be harder to achieve if it were in, say, Rust.
The resource usage of my harness is nothing compared to an electron app, and being able to easily customize it is more important to me than saving a few extra MB of ram.
I guess it depends on the harness, for example: chatgpt.exe right now is 1 GB on my windows machine. peseo.exe is 500 mb. and opencode.exe + bun.exe is 300 mb.
One possible reasons is that all of those are compiled languages vs interpreted. It doesn’t sound like much but compiling your code for three plus platforms and distributing binaries adds just enough complexity and friction to make it feel a lot more difficult.
I agree with that yes but consider how many people would benefit. And how easy it should be for them to do the change (and compile). It's just tokens.
But "friction" is the job, and "complexity" is the job. That's why we're developers.
Because it used to cost extraordinarily more money to build for a performance increases almost no one cares about.
chatgpt.exe right now is 1 GB on my windows machine. I have 16 GB and can spare none. So I don't think that nobody cares about such performance increases.
Most don't care or ever notice these things. Hacker News crowd does and always has, but the a non-technical user of a run-of-the-mill desktop app would rather have new features, and maybe some bug fixes, over performance.
Myself? I care. I regularly run a project that needs 6GB for the language server to provide type hints.
> chatgpt.exe right now is 1 GB on my windows machine. I have 16 GB and can spare none.
These are not the same units, because all modern OSes have compressed swap.
They keep talking about 2 accounts logged in so that's why it's still high. But they've done nothing to defend that claim.
Also, pro tip, you can still just use it in browser. I hope that doesn't go away.
I think the reason why web technologies that are essentially being ported to desktop is not only because they provide cross-platform compatibility (still lacking a standardization on Linux), but they tremendously helped the hustle culture built around the motto of "ship it fast" by providing the fastest iterations and benefiting from already existing cheap pool of web developers, especially via outsourcing/offshoring.
Nowadays, AI (LLMs, genAI, call it what you will) has become so cheap to handle more than one codebase, they no longer feel the need for web only approaches.
The barrier to entry for GPUI might be a bit high for some, but is there really any argument to be made against migrating to Tauri?
Tauri's value prop over EGUI and GPUI is that its syntax is familiar to web devs.
was wondering the same thing; my hunch-memory is that Tauri is not as performant on Windows. but that has not been my experience, Tauri seems great
[dead]
On my mac I’ve banned Electron apps, only native ones - Slack on Safari.
Let’s hope we see a new wave of desktop apps rewritten natively, thanks to LLMs. Whether they use Rust with GPUI, C++ with Dear ImGui, or something else entirely, that would be great. Personally, I’m so fed up with bloated UIs. Windows is full of them, and it’s a pity considering how powerful our CPUs are.
> C++ with Dear ImGui
it would be absolutely awful
compared to chromium, it's really limited, like it's just always a compromise with these
we should instead figure out a way to do electron but better and make it easier to do the things you can do with e.g. React with native languages and frameworks
The limitations are a large reason for why they're so resource efficient in the first place.
If you just reimplement Electron in a native language then you get... Chrome, which is already written in C++. The majority of RAM usage in Electron applications is from the native parts of Chrome itself and a decent ~40 MiB chunk for the Node.js runtime.
That’s what we’re trying to do with Slint (I work on it): a declarative, reactive UI like React, with the logic in Rust, C++, JS or Python. It needs no browser engine, so it uses a fraction of Electron’s memory.
QtQuick is quite good.
I have had excellent results running a back-end Rust process that communicates with a C# Avalonia front-end via protobufs over named pipes on Windows and Domain Sockets on Linux and MacOS. With C# AOT I’ve been able to create self-contained apps that run incredibly fast despite the ipc between the front end and the rust core. I’m getting full 6 platform coverage too (Win/Linux/macOS on both x64 and arm64).
edit: Avalonia is quite mature, with accessibility to boot.
Are you a web dev?
I use ImGui regularly, if you believe that it is on the same level as what you can do with React/HTML/CSS/etc. then I don't know what to tell you
I have seen this assumption in recent GUI threads here (More so your upper post): Building a PC application is not equivalent to building a web browser. A web browser is a type of PC application built for a specific (But very broad!) use. I didn't think I would need to write this statement/distinction, but I have here. Web languages, culture, and syntax have not been a value add to PC application development. Electron is the clearest example why. My model is that is the value add of Electron: Appealing to web devs through language and culture.
Regarding "not doing what you can do with HTML/CSS/JS". Doubt. I varied and complex stuff and have never felt I needed to overload document rendering langs for this.
I will go a step further: I don't think Electron is a symptom of HTML/CSS/JS: I suspect it's more from the Node + Framework culture.
it's not just about "appealing to web devs"
you simply just would stumble if you tried to do development like you can in React, constant "uhh... can't do that." while it just works in React.
I don't think anyone likes the look of Qt more than what you can achieve with webapps in terms of UI (style/etc. wise)
problem is the performance, I don't think many would be complaining if the performance was proper and the memory usage wasn't as terrible as it is now
you're talking about web browsers, I don't care what it runs on, if we have a way to run this in a lightweight way, would your complaints go away?
even Gnome uses JS etc.
you can do complex stuff in native UI, of course you can
what I'm talking about is the same kind of DX as with React. I really don't have faith in that, e.g. the new thing Discord is about to use, the css it tries to imitate just seems absolutely terrible.
the web technologies aren't perfect, in fact, far from it. however, when I see React vs whatever C/C++ alternative, I'd always go for React if it's about making the UI nice.
I've also shat on Electron before, but there's a reason as to why it's so popular. the tooling/UI capabilities are just much more powerful.
or Rust with things other than GPUI
Crux, lets you use native UI but Rust for business layer: https://github.com/redbadger/crux
It's hard to say "Discord just showed why" before the product is in production and sees actual use. Promising initial statistics, but the transition is based on a lot of assumptions that won't really be proven until mass adoption and the software has seen long-term maintenance.
...exactly, and at some point you want to show inline animations or videos and all sorts of other media, show webpage previews, play audio snippets and all the other things things a webpage can do, and then you're back to either integrating a browser engine or attempt to write one from scratch (the browser engine can of course be provided by the system webview, e.g. what Tauri does).
I’ve programmed inline video players for 25 years. Same with audio and everything else. We had “accelerated” graphics back with winxp and gdi+ and of course OpenGL over ssh with x11. Browser preview pages in most apps are usually snippets of text and maybe an icon or pic. Not rendering a full page.
In a way, applications regressed a lot with react native and electron. I get it’s easier to develop but the apps are very bloated and underperforming even on computers with 10-100x more power.
If LLMs are truly driving the cost of "writing code" down to zero, then we shouldn't need Electron anymore. The whining from developers about how it's soooooo hard to write and maintain N separate native applications is no longer valid. Point an LLM at your existing Electron code base and have it fork off a bunch of native ports of it. LLMs are surprisingly good at matching the functionality of existing software. Keep and maintain the Electron app as an internal reference design (your developers probably only know JavaScript anyway) and "build" all your actual production releases from that.
Signal is still dragging Electron, can't have a working FreeBSD port due to dependency hell. Also VSCode.
Meanwhile Zed isn't really usable on machines without a GPU e.g. VDIs
https://github.com/zed-industries/zed/discussions/17212
I don't know if we have a winner here.
I literally just run another browser Window with discord on the web rather than the native app.
Discord is probably my least favorite thing to happen to chatting online, but for some reason it's what everyone wants to fucking use.
Discord is my favorite thing to happen to chatting online. It combined everything useful from IRC, Skype and TeamSpeak, in one application and with modern UI, and things we now take for granted like attachments and link embeds. And even 10 years later, there are still no alternatives that aren't just discord but worse.
Discord tab also uses 500-600MB of RAM. This is private resident bytes of the tab excluding browser and its helper processes.
Don't worry I'm sure they'll find a way to make the rust based client crawl too soon enough.
Slapping a few million lines of AI generated slop code ought to do it for instance.
Rust to death i told them
On another note, Microsoft Teams and new Outlook use very little amount of memory on paper, because their main windows show up under the Edge name. It’s a Microsoft way of solving the high ram usage problem.
WebView2. Other applications can also use it but it seems like there's less out-of-the-box functionality than Electron
That’s also how Tauri claims to use so little ram.
By being dishonest and misleading?
When they can all share the same Electron implementation instead of individual copies it reduces memory quite a bit. I'm not trying to defend Electron way of development but I can see why they pushed WebView2.
By reusing the system webview? It's what web frameworks should've done.
When has Microsoft not been dishonest and misleading? Being dishonest and misleading has been Microsoft's entire game plan since all the way back into the Bill Gates era.
I would not add alternative accounts to the account switcher, they've used these to coordinate bans ever since the account switcher's inception.
Could they of used servo?
I hope they can do some work on a11y because it's bed. Not as bad as it was but still slow and clunky to use with a screen reader.
Great option for this that lets you use Rust along with real native UI for cross platform: https://github.com/redbadger/crux
"cross platform" I just spent 10 minutes trying to figure out what it uses for native on Linux, and whether it supports both Qt and GTK. Turns out the docs don't even mention Windows? "Cross platform" is now just MacOS + iOS + Android + Web? I guess the thought is supposed to be that crux helps you port your app to Windows if you want to... but even the example applications only run on those four platforms.
I've not seen the performance deficits demonstrated in this article. The article also does not discuss the specs.
Not to mention Windows is a very heavy slow inefficient and poorly made OS.
You don't see these issues generally on Linux or macOS.
[flagged]
[dead]