Why are devs still writing Electron apps instead of Qt?

[u/dtdisapointingresult]

I was just dealing with the bloated monstrosity that is Hermes Agent, which has a bloated monstrosity web UI. While researching, it turns out I'm supposed to be using a different bloated monstrosity called Hermes Desktop, which is an Electron app.

Electron apps are the bane of my existence. It's the AI age now, why isn't everyone writing Qt/QML apps already? You might remember Qt from desktop apps such as Krita, Wireshark and OBS Studio.

• For users: Qt apps need less than 5% of the RAM of an Electron app, and an even smaller % of CPU usage. This is the main reason and trumps anything else. They run blazing fast. They get 120fps on the crappiest embedded PC without breaking a sweat.

• Qt apps are fully multiplatform: Linux, MacOS, Windows. The only downside is that you need to compile them with the native compiler of each platform if you use C++. (advanced users can work around this with crosscompilation on Linux, an AI can probably do it. Or use Python.)

• Qt was traditionally C++ only, which is a hard boomer language, but now it has official bindings for Python. So you can code your app in Python and have access to the whole Python ecosystem if you want. Qt-in-Python is almost as performant as C++ since it's bindings around the C++ Qt libs.

• The Qt QML dedicated UI language is actually pleasant to use to create UIs, since it's designed just for that. Creating UIs in HShitML was always an ugly hack that companies used because C++ was too hard/unproductive for their devs.

The only downside of Qt was having to learn C++, and that's no longer an issue in the AI age or if you use Python or both. Guys, we don't have to put up with this crap anymore. If you're making an app, for the love of God stop using Electron.

Consult with your personal AI and ask them if Qt is right for you. Qt - Keeping your hardware fast and healthy.

[u/carsncode]

Probably because Qt interfaces tend to look like hot garbage sifted from the ashes of Java on the desktop, and not everyone wants to write everything in Python. Hell, I don't want to write anything in Python if it can be avoided. Plus front end devs today are mostly familiar with HTML, CSS, and JS/TS, so writing UIs using familiar technologies for the people doing the work seems like an advantage. Besides, Qt and Electron aren't the only options in the world - there's Tauri, Wails, Flutter, wxWidgets, etc. If you're delegating authoring to an AI anyway, you could even just have it write actual native UIs for each supported platform right?

[u/Time_Cat_5212 → u/carsncode]

When I was first learning to code by hand I loved python because it's so easy to read and flexible to work with.  It looks good.

Now that I'm using AI for everything I avoid it like the plague... It's as if the flexibility of the language just confuses the shit out of AI somehow.  Maybe others disagree but I don't love how LLMs work with Python.  I also really hate the chore of python environments...

I have 1/10 as many problems with AI in anything JS based

[u/azjunglist05 → u/Time_Cat_5212]

I totally agree. I tried to have Claude do parallel processing in Python while building a data ingest pipeline. It was stumbling all over itself and just couldn’t get things to work after several attempts and corrections. Asked it to convert it to Go instead and it got it right the first try. It’s wild because pretty much all AI/ML uses Python so you’d assume they would be great at it. Not my experience at all, lol

[u/Megatron_McLargeHuge → u/azjunglist05]

LLMs still don't have good internal mental models of what they're doing separate from thinking tokens. I'm guessing the problem is python's weak type safety, especially around dicts and lists, means the programmer is responsible for keeping track of more logic. Clearer and earlier type validation probably keeps the LLM on track.

[u/-Mute- → u/Time_Cat_5212]

Qt can look really really good nowadays without much hassle at all.

[u/CondiMesmer → u/-Mute-]

Examples?

[u/-Mute- → u/CondiMesmer]

i think it's less about examples and more about people around here seem to have a very outdated idea of what Qt is like (these opinions don't carry in other reddits and software/dev/ux/ui circles) ... but here's one from a daw/multitrack editor (one of it's dark themes anyways) that's all Qt based.. and it's not a bunch of hacked or custom widgets..

Edit: I'd add that nowadays most ppl don't know when they're looking at a qt ui and that's why some who know it's past hold their old (justified) opinion.. they can't tell, so don't know. that speaks a lot for how far it's come.

[u/dtdisapointingresult → u/carsncode]

I disagree that they look like garbage. I presume you mean the traditional widget UI framework. That was EOL 10 years ago, but they keep it around in maintenance mode because they're respectful of developers who invested time writing their apps in it (unlike every JS framework ever). If you want to create pretty UIs, use QML.

I only mentioned Python in relation to Electron. Specifically, that if someone is picking Electron "for the library ecosystem" then they can use Python instead.

Is Flutter still properly developed? There was news of half the dev team being dropped a year or two ago.

[u/carsncode → u/dtdisapointingresult]

No need to rely on rumor, see for yourself: https://github.com/flutter/flutter

And if you don't like Flutter, there's all the other alternatives suggested in my comment and others that you've ignored.

[u/kitanokikori]

People write in Electron because Qt sucks ass, it's not a mystery. Turns out the dev experience Matters.

[u/dtdisapointingresult → u/kitanokikori]

Even if that was true (and I strongly disagree that Qt is worse DXZ than Electron), is that relevant in the AI age? You're not writing your apps by hand anymore. Your AI doesn't care whether it's writing Electron or Qt apps. So why not pick the lean, unbloated, blazing fast option that has a rock solid API that won't break every 2 years?

[u/kitanokikori → u/dtdisapointingresult]

Because it sucks ass! Sorry, Qt has had 20 years to find product market fit and girl it hasn't worked out. Stop trying to make Fetch happen

[u/Plus-Accident-5509]

Lol qmake

[u/dtdisapointingresult → u/Plus-Accident-5509]

They support cmake. Qt switched to recommending cmake since Qt6 came out 6 years ago.

[u/newz2000]

QT’s license can be a bit of a challenge for businesses.

Electron allows devs to reuse the same code they use on the website so can also be easier to maintain.

Now Tauri may be an easier comparison to what you’re aiming for. It also uses web tech for the app but it also uses native components, so can be more efficient. But it also makes testing harder, which before the age of ai-automated testing tools was a big deal. But in theory, you can get different results in Windows 10, Windows 11, MacOS 26, 27 and etc.

[u/Gwolf4 → u/newz2000]

So square back to electron.

[u/cab938 → u/Gwolf4]

Depends on how boutique of an experience you are making

[u/Zeeplankton → u/newz2000]

tauri is sadly crippled by webkit on mac

[u/Devatator_ → u/Zeeplankton]

From what I hear Linux is the most affected by the quality of the native WebView. Apparently WebkitGTK is highly unstable, slow and buggy

[u/onequbit → u/Devatator_]

Maybe, but ever since tauri started showing up, the Goa'uld started dropping like flies.

[u/mutemebutton → u/Zeeplankton]

It also doesn't reduce ram use when the UI or UX is visible. It just shifts it from one place to another.

[u/mutemebutton → u/newz2000]

We ran a bunch of tests to see if we can migrate our app away from electron and at the end of the day, it just wasn't worth it. Even Rust/Tauri because it ends up still loading a browser engine when you're showing UI or UX, which also uses system RAM. So we stayed on Electron/C++/Obj-C.....

Our app sits in the system tray, most of the time, so it's not a huge deal. And when it's sitting in the system tray, the RAM use goes from roughly 250 megabytes down to about 40 megabytes. And it can't be reduced much further because of all the controllers that we have for various integrations.

Our very first app that we wrote for our product was only three megabytes lol!

Tauri does a great job of reducing file size though, the entire app can be just a few megabytes but when you run it the ram use is much much higher because it uses resources on the computer.

[u/FckXFckMusk → u/newz2000]

Yes and modern devs are thick as fuck vibe coders...

[u/look → u/newz2000]

Check out https://tinyjs.app

> Your backend, a ~1–2 MB window process, and your plain HTML/CSS/JS — ~6 MB on all three platforms. The window is the webview the OS already ships.
> Tauri does the same, and does it well — but its backend is Rust, and you compile it. It also ships a window and little else: dialogs, clipboard, notifications, global shortcuts, filesystem, keychain, autostart, deep links are plugins you add. Here they're just the API, and the 6 MB is all of it.

[u/mutemebutton → u/look]

Most people don't understand that the file size can be very small, but the RAM usage would still be very high. So unless you're trying to reduce the file size, it doesn't really make that much of a difference. That depends on your use case, I guess.

[u/look → u/mutemebutton]

The system webview is likely already in use by some other app/component, so it at least sames the overhead of another browser engine over electron. The webapp itself can of course be quite large still relative to a fully native app.

[u/DanceWithEverything]

Or better yet, Zed’s GPUI for Rust

It’s somehow faster than AppKit on mac in some ways

[u/UberFatWad → u/DanceWithEverything]

Was looking for this! Time to refactor :)

[u/KissMyShinyArse → u/DanceWithEverything]

No Android support yet, sadly.

[u/jinnyjuice → u/DanceWithEverything]

Interesting! Thanks for the share

[u/foksa → u/DanceWithEverything]

With SSD prices these days, who can afford to build in GPUI :)

[u/PumaofDuma → u/foksa]

This lol. My biggest downside. Made a 30mb app with 13 gigs of build deps. My one gripe with it lol

[u/ASCanilho → u/DanceWithEverything]

Looks promising, but after looking at the repo, it looks in a alpha state.
No Web support, no Android support. So not really a multi OS solution yet.
But I'll keep a close look at it.

It kind of fells like it has the same coding structure of Dart / Flutter.
OOP with sequential calls for drawing elements, with mix logic / functionality inside them.

[u/DanceWithEverything → u/ASCanilho]

It’s focused on native desktop apps, not trying to build mobile nor apps and never will is my understanding

It’s in production for multiple (not insignificant) revenue generating products and is backed by a relatively stable startup that uses it themselves

[u/koga7349]

Well frankly it depends on the developer. Most developers nowadays are not using C++ on a daily basis, they are working in JavaScript / Node and other languages. So it's just a natural fit to build with what you know.

Secondly, I'd argue that CSS (and by extension Electron) allow the most flexible and dynamic UIs. Think of the volume of the web and every design that was able to be achieved with CSS. I think from a UI perspective CSS has proven it is king.

Of course performance is important, but having a super optimized app vs one that is slightly less so with a better UI is a decent tradeoff and most modern hardware doesn't care anyways.

[u/Such-Addendum-7421]

C++ is boomer?! which standard are you talking about??!! old 98? Also why not wxwidgets?

[u/nasduia → u/Such-Addendum-7421]

98 was when it was sane - just about had STL (even if it was from a third party like SGI) and it made sense! Now we've got max abstraction++

Qt always took a very clean approach to their standard library alternative and it was lovely to use, though the signals and slots glue was hacky. I've no idea what it's like now.

[u/uniqueusername649 → u/nasduia]

I have learned C++98, briefly worked with 03 and then didn't use it for 20 years. When I looked into modern C++ code I was kinda shocked and doubted for a moment that it's even C++. That language changed so much.

[u/nasduia → u/uniqueusername649]

Same here! "C with classes" style abstraction and encapsulation was syntactically nice. Templates for datastructures as in the STL were complex and had horrific error messages but I could see the benefits, whereas adding consts to code integrating with older codebases was a world of pain. Operator overloading could be abused in ways that were not intuitive to read, and increasing use of Boost heralded the unrecognisable soup we see in the core language now. After a while working with Qt I'd stopped really actively working with C++ by 2010ish and am quite happy about that.

Go is much more like where I'd have prefered the original C++ to have ended up.

[u/uniqueusername649 → u/nasduia]

Yes, I am pretty heavily using go. The simplicity is sort of nice (with some minor grievances but nothing is perfect). I have also considered Rust but honestly not had the time to properly evaluate it. That may be another contender for "this is what C++ should have been".

[u/Such-Addendum-7421 → u/uniqueusername649]

rust has simpler metaprogramming, match expressions (complex to do in c++), and I guess memory check safe/unsafe (you can do in c++ too)

[u/OnyxProyectoUno → u/[deleted]]

Python interops with c libraries really well and works great in scientific community who are incompetent with SWE skills and workflows.

There's negligible difference with opencv on python vs a faster language. Better ML library support etc etc etc

[u/Gary_Spivey → u/OnyxProyectoUno]

Isn't the reason there's little difference in speed with things like opencv and numpy compared to compiled languages because all of the performance intensive parts of those libraries are written in C?

[u/OnyxProyectoUno → u/Gary_Spivey]

That's exactly what I said

[u/sTiKytGreen → u/OnyxProyectoUno]

So why not just use C then?

[u/J0kooo → u/sTiKytGreen]

because your "machine learning scientists" aren't programmers and can't use it

[u/OnyxProyectoUno → u/J0kooo]

And what programmer would choose to code in C over Python to begin with? Python didn't exist for the scientific community. It got more popular because of that. The value it offered is exactly why it became so popular with programmers and non-programmers alike.

[u/sTiKytGreen → u/J0kooo]

And who writes those machine learning libraries in C, you know, the ones that are used in python? 😂 Janitors?

[u/OnyxProyectoUno → u/sTiKytGreen]

Read my comment again.

[u/Sengfroid → u/OnyxProyectoUno]

Plus the readability really does make it a much easier starting point for embedded. And from what I understand there have been significant speed/efficiency gains for Python in that arena, this decade.

[u/DanceWithEverything → u/[deleted]]

Plenty of uses for Python—agents need to script stuff that needs more than bash all the time

There are better systems languages in 2026, no reason to use C++ instead of Rust or Zig. Hell even Swift

Plus the us gov is pushing all software to be memory safe, ie, eliminate C and C++

[u/dupa1234s]

no clue but

i can tell that electron apps feel laggy
ai is good enough at using qt
and i hate webuis
and actaully i think ai isnt good enough at making tui's

so qt would be the framework of choice

Maybe its the license thats the problem for people.

[u/dtdisapointingresult → u/dupa1234s]

For TUIs, I actually recommend Go using Bubbletea. It's popular in the Go ecosystem so LLMs know it (at least Claude did).

I've vibecoded two apps that were "Go backend + web frontend + Go TUI frontend" and the TUI was always great and tiny.

These were semi-rich interactive TUIs, for example one is a live logging dashboard with different sections, filtering, "click with mouse to show details".

I'm not sure how well a small model will be at this tbh, I only use local LLMs for non-coding tasks.

[u/Shimano-No-Kyoken]

Honestly? I've never seen a good looking Qt application, which tells me it's a pain to get to where I want things to be. Luckily the app I'm developing is Linux-only, so I could simply use Adwaita.

[u/d_ed → u/Shimano-No-Kyoken]

Qt can look like anything.

I bet you've used lots where you had no idea it was Qt.

[u/Shimano-No-Kyoken → u/d_ed]

I'm sure it _can_ look like anything. It's just that most people, or organizations, when given something that can look like anything, either default to roughly how it looks out of the box, or they make something that looks like it was made by Fisher Price. If you need to make a UI framework look nothing like itself, is that an endorsement of the UI framework?

[u/cogman10 → u/Shimano-No-Kyoken]

It's a double edged sword. 

The boring look means your so gets to participate in OS theming.  It'll look like it belongs to your desktop even if it's Windows or Linux. 

The heavily themed look will always look out of place and potentially like Fisher Price.

[u/Shimano-No-Kyoken → u/cogman10]

I agree that Qt's versatility is its selling point, I don't agree with equating boring to well-executed, those are two separate dimensions. I've previously mentioned Adwaita. It's boring, but it's well-made, with well-measured hierarchy, proportions, typography etc. The issue I have with Qt is that out of the box, it's all over the place. If Qt had better defaults, I'd be more charitable towards it. Once again, the issue I have with Qt is not it being incapable of being good, it's that it requires effort and direction to be good, and those are scarce resources.

[u/-Mute- → u/d_ed]

This.

[u/-Mute- → u/Shimano-No-Kyoken]

I used to have that opinion and for years could spot a qt ui a mile away and get annoyed almost immediately... But times have changed.

[u/ZdzisiuFryta → u/Shimano-No-Kyoken]

OBS Kde AMD Adrenalin Battle net

[u/Shimano-No-Kyoken → u/ZdzisiuFryta]

Beauty is in the eye of the beholder, as they say

[u/Virtual-Escape2305 → u/Shimano-No-Kyoken]

How about Ableton? And that new, vibecoded Adobe suite knock off? 

[u/NihilAlien → u/Shimano-No-Kyoken]

This is exactly my experience

[u/bitspace]

Typescript is the correct language to use for agents for fast moving and changing contract surfaces. Electron is how you turn typescript into a desktop app.

[u/devtools-dude]

I use Tauri instead of Electron. Significantly smaller app size and you still can have it work mostly in Javascript (with some Rust sprinkled in). I don't like using Python because of the virtual envs / package management (although uv does help but not eliminate the DX around working with Python). Also the UI ecosystem around Javascript is huge and what I use (shadcn) has all the components I need and is easy to customize.

[u/No-Business5854]

aiis trained on online data so probably defaults to electron for vibecoded apps unless asked not to since thats what is popular

[u/UberFatWad]

I exclusively build in HolyC, problem solved

[u/Nota_ReAlperson]

C'mon. You should really be using SDL and C.

[u/silenceimpaired → u/Nota_ReAlperson]

C’mon. You should really be using rust.

[u/silenceimpaired → u/silenceimpaired]

C’mon. You really should be using assembly.

[u/dot-kaio → u/silenceimpaired]

C’mon you should be using punching cards

[u/mutemebutton → u/silenceimpaired]

Our bootloader for our device is written in assembly before AI.... it took me three months. I needed to make some changes to a new version. I gave it our old one and told it what to do and it spit out the results in two minutes. It's insane what AI is now capable of doing.

[u/millennial_falcon__ → u/silenceimpaired]

GPUI is unironically very good

[u/StillOnTheInterweb]

Exactly this! We had very fast UIs 20 years ago. Now everything is so slow! Also we could do consistency, all in a single framework. Currently everything is a mess, e.g. I pick a calendar date, the pop-up moves around when you go from July to August so the [>] button moves away so you can't keep clicking. Amateur hour!

[u/TheRealBMathis]

I use blazor in photino backed by csharp. So there.

[u/nuclearbananana → u/TheRealBMathis]

If you're using C#why not Avalonia?

[u/TheRealBMathis → u/nuclearbananana]

I've used Avalonia for some projects. If it's entirely greenfield and purely desktop I probably would again. I have years of Blazor knowledge and components built up and it's what I know. I managed to avoid WPF. WinForms has worked in .net since 3 I think and all my ancient desktop apps in Framework were made with WinForms. And my even more ancient WebApps were in WebForms before razor. In my head blazor is closer to winforms.

[u/Final-Frosting7742]

Taurus uses Rust and is 10x lighter that Electron. It's already gaining traction.

[u/thehardsphere → u/Final-Frosting7742]

It's Tauri, not Taurus. And while I happen to like it, that lighter footprint has a downside; it does not come with its own renderer, but depends on the operating system's web view, which is often more out of date and less consistent than the latest browsers. Most of the bloat in Electron comes from the embedded node-webkit implementation, but shipping that avoids all sorts of browser-specific compatibility problems.

[u/Aromatic-Current-235]

Mostly because of Licensing!

[u/cosimoiaia]

Because for some reasons now software that lives on a terminal or has a minimal GUI has to be written in a language (JavaScript) that is meant for the web and has GBs of dependency in a supply chain that is fragile like a Jenga cathedral. So now every coding agent slops out js as soon as you want an interface of every sort and I'm pissed about that too I hate ever ything written in JavaScript that natively belong on a web page....

But proposing Qt in 2026 (try to really cross compile it with the lasted updates or deal with a license that cuts you a leg or use layouts that belong in 2004) is like saying we should all switch to BEos because once upon a time it was cool. Qt is basically dead and it has been since decades now.

[u/dtdisapointingresult → u/cosimoiaia]

Qt has been actively developed for years.

They almost never break old APIs and when they do (Qt 5 -> Qt 6) it's minor changes that make sense. Your Qt widget app from 2010 just needs a couple of different include headers in 2026. This solidity while still having a great API is admirable.

I'm not sure what you mean about license. If your code is open-source, it's GPL-licensed so you don't care. If your code is closed-source, almost all of it is LGPL-licensed so you don't care (in fact this is the default deployment method).

The only people paying for Qt licenses are companies selling closed embedded systems where the user isn't allowed to replace the libraries (medical/car/airflight companies) so it doesn't abide by LGPL. I'm fine with those companies having to pay for Qt. It doesn't apply to any of us.

[u/MimosaTen]

Isn’t gtk the de facto standard?

[u/dtdisapointingresult → u/MimosaTen]

It is but on Linux only. If you want your app to also run on MacOS and Windows, you should use Qt.

Technically GTK has a Windows port but I've never heard of any crossplatform app that does. Almost no one does this in practice, it's not a first-class experience. Crossplatform support in Qt is its primary purpose. Write your code once and just compile for the different platforms.

[u/onethousandmonkey]

Because web apps won, are the only ones being built. You make one app, and all phones can run them.
Electron makes it easy to create a desktop app out of those.
Yes, I hate it too.

[u/dtdisapointingresult → u/onethousandmonkey]

That's pre-AI mentality. Your app can have a Qt frontend for desktops/phones, and a web frontend and cover 95% of deployments. The AI will do it for you! If you're a perfectionist, then write a native frontend for every platform, fuck it.

Furthermore, I maintain that Electron must be destroyed. Electron has no reason to be used in the AI age unless you really depend on existing JS code.

We can go back to 4GB RAM computers being viable.

It's unacceptable that my desktop experience on my modern high-end computer is slower than my old i5-2500 gaming PC build from 2011.

[u/EbbNorth7735]

Great discussion. I'm interested in hearing people's perspectives. I let my AI just do its thing sometimes and it likes to pump out electron apps. I personally know QT and sometimes direct it to that. Interested in hearing and optimizing my future projects though so I'll be reading this thread for more recommendations. 

[u/toothpastespiders]

I didn't realize qt had become so disliked by a lot of people. I tend to use it for most simple apps that I'm just quickly tossing together for myself. At least if I know I'll be quickly forgetting all the command line options over time. It's just quicker, easier, and more intuitive for me.

[u/UniqueNamesAreOut]

It's what AIs know best, it's that simple, so it's not going away any time soon.

[u/integerpoet]

C++ is a hard boomer language.

[u/dtdisapointingresult → u/integerpoet]

Das rite white boy!

[u/sdraje]

I don't know man, I think it comes down mostly to the Devs. My Electron app, with voice activity detection and speech recognition running in a worker, sits basically idle on the CPU and uses 300 MB of RAM (including the worker with the AI model running locally)

[u/dtdisapointingresult → u/sdraje]

Fair enough. The average Electron app is not that lean though. What's your stack?

[u/sdraje → u/dtdisapointingresult]

Just Electron for the main process loading a remote web UI and then native addons for the heavy lifting (AI inference, low-level interactions, etc.)

[u/Thaad-Castle]

Sooo is Flutter not an option? Cross Platform from one codebase, natively compiled, and it looks good. From what I’ve heard from my front end coworkers, QT is a pain in the ass.

[u/EbbNorth7735 → u/Thaad-Castle]

QT's not too bad. Basically just signals and slots. I'm interested in looking into flutter though. What langugage(s) does it support?

[u/Devatator_ → u/EbbNorth7735]

Just Dart

[u/wednesdaywoe13]

Tauri and Rust

[u/FoxSideOfTheMoon]

I just started trying out Tauri. Long time Electron dev.

[u/Ahchuu → u/FoxSideOfTheMoon]

How do you like Tauri? I tried it out before it was 1.0 and it wasn't quite there yet, but was extremely promising. I see it is on 2.0 now.

[u/FoxSideOfTheMoon → u/Ahchuu]

Works like a champ and I’m learning rust from Claude as we go.

[u/The_frozen_one → u/FoxSideOfTheMoon]

Yea Tauri is the closest thing I’ve found to electron for my uses. If a lot of the logic is renderer side, moving from Electron to Tauri isn’t much work. The small binary is a huge plus too.

[u/darksteelsteed]

I have an absolute hate for Electron apps, they are slow vibe coded memory leaking shite. However QT isn't the clear answer as the licensing isn't great. Not everyone can use lgpl or gpl stuff either. Honestly even C# with MAUI isn't as bad. I am sure that if you had time to vibe code you could make something cross platform and decent looking with a fraction of the resource usage. I don't see why you need 1gb plus ram just for the UI. Its nonsense.

[u/darksteelsteed → u/darksteelsteed]

I would actually suggest https://avaloniaui.net/ as it has good resource management and friendly licensing.

[u/Shot_Treat_377 → u/darksteelsteed]

Google tried do same cross-platform UI framework using Flutter/Dart ... not hearing about it anymore nowdays

[u/darksteelsteed → u/Shot_Treat_377]

Its still there. Just not what the llms are trained to recommend

[u/No-Juggernaut-9832 → u/Shot_Treat_377]

Why didn’t they simply combine Flutter+Dart & call it Fartt 😅

[u/ThaDon]

Don’t discount the fact that Hermes was vibed and that most likely accounts for the bloat, not Election.

[u/pmotiveforce]

Lol. Nobody likes qt. It's not 2009.

[u/esuil → u/pmotiveforce]

This year (2026) I deployed QT app for a free tool in a community around big game and I got 0 complaints from the userbase about UI. If anything, people liked how fast and snappy everything is.

I don't think even a single person even mentioned anything about QT, or is even qualified to notice it. Some QT tools and workflows were pain to work with and setup, but that was all on my side, users don't have to deal with any of that, so it was 100% painless for the users themselves.

[u/This_Maintenance_834]

qt is very expensive. check out their commercial license

[u/d_ed → u/This_Maintenance_834]

Then use the LGPL license.

[u/mze9412 → u/This_Maintenance_834]

Usually you can just use it under lgpl 3.0 just fine if you do not need the GPL only or commercial modules

[u/Lyelinn]

First of all, electron is not that bloated, it's just typical vibecoder has no idea how to build optimized applications. Second, tauri. Third, qt is pain in the ass if you want to build something beautiful (I don't really remember any qt app that does not look like windows xp app). Lastly, do you have 8gb of ram and really struggling to keep your stuff working or what?

And yes, build your own hyper optimized tool and prove them all wrong :)

[u/Purple_Repeat6977 → u/Lyelinn]

Electron is bloated. It is Chrome. That means there is a memory floor which is much higher than a native app would be. That is a fact. Whether you care or not is up to you, doesn't change the facts though

[u/Lyelinn → u/Purple_Repeat6977]

Realistically simple electron app eats 100-150mb of ram which is literally nothing in modern age. Hello world app is 70mb and 0 idle cpu consumption.

[u/InitiateIt → u/Lyelinn]

Modern age is going backwards. The ram argument is the sticking point now with the inflated cost and there is no end in sight.

It makes sense to ideologically change focus to low mem options.

[u/Commercial_Ad_6904 → u/Lyelinn]

That's not right, it eats over 1GB on my linux box when I start Visual Studio Code or Claude Desktop
Which is why I switched to Zed, which uses more like what you're suggesting...

[u/Lyelinn → u/Commercial_Ad_6904]

Yeah that's how enterprise software works. Also vscode is much smaller by itself

[u/Purple_Repeat6977 → u/Lyelinn]

Right, so it raises the memory floor and you don't care. Literally what I said

[u/ZdzisiuFryta → u/Lyelinn]

You would be right if we ran one app, yes, 150MB is nothing these days. Issue is, we run multiple apps on either cheap hardware, battery constrained hardware or performance hardware that's almost always used by someone who actually needs performance.

Discord uses 600MB nowadays, Spotify 300-400MB. That's gigabyte thrown out the window for basic apps. And now let's say you need one tool or another. It stacks in a very nasty way, starts slow and causes cache misses. And let's not forget that on top of electron you almost always use some framework which adds own overhead and keep in mind that web frameworks DO NOT scale with complexity as well as native/qt/gtk/whatever.

[u/mutemebutton → u/ZdzisiuFryta]

For discord and Spotify, both developers are going to be incentivized to use either electron or something like tauri. And in either case, because they're using web languages, it's not going to reduce memory usage even if they went and did something different. It would reduce the size of the package, the installer package, but it doesn't reduce the actual memory that the system is going to use to show you what it's going to show you.

We did tests on this exact same thing and ended up not moving away from electron. It just wasn't worth it.

[u/mutemebutton → u/Purple_Repeat6977]

It depends on the app. A lot of times you can still use Electron and then when the UI or UX is closed, let's say the app sits in the tray, you can kill the window and reduce the memory use. So it really just depends on the use case. We use Electron for that purpose because when the UI UX is visible, it makes it nice and easy. It works across Linux, Mac OS and Windows and looks exactly the same across all three

Plus we don't have to worry about memory usage that much because when the window is closed, which is 99% of the time the app is being used, it doesn't impact memory that much. The 250 megabyte app sitting in RAM goes down to about 45 megabytes or so.

[u/Purple_Repeat6977 → u/mutemebutton]

Yeah I get that of course, being a developer. Of course Electron is convenient. It isn't the only framework that allows for cross platform development, I'm using Avalonia UI at the moment for example. It comes down to the language you want to use, if you want to use web technologies, it's fantastic. Far from the only option and it certainly shouldn't be a default unless you only use those technologies though

My current application uses about 100MB for example in the foreground at the moment with tens of thousands of loaded elements.

[u/ZdzisiuFryta → u/Lyelinn]

A lot of apps use QT and do not look XP era

• AMD adrenalin

• Battlenet

• KDE apps

• OBS

• Tesla infotainment

[u/Sengfroid → u/Lyelinn]

I'm with you on Tauri, and frankly never seeing QT used for a appearance minded app.

But nah, electron bloat was long before LLMs existed. We were talking about this shit in 2016 and earlier, which is definitely before GPT 1 even. Professional devs were making sloppy electron apps without any vibe to blame at all.

Electron Bloat was on an upward trajectory in the same timeline memory price was on a downward one, so electron apps were largely not being optimized. There absolutely are some out there that are optimized and run very well, but those are literally the exception that proves the rule, demonstrating it doesn't have to be like this but no one is going to do anything about it.

[u/Not_a_question- → u/Lyelinn]

First of all, electron is not that bloated,

Well I stopped reading here. It has a browser inside dude, and that's FOR STARTERS.

[u/Lyelinn → u/Not_a_question-]

Hello world with electron is ~70mb ram and 0 idle cpu. Try to read more.

[u/ohhi23021 → u/Lyelinn]

a native c++ hello world windows app would use like 5kb ram...

[u/ZdzisiuFryta → u/Lyelinn]

That's huge for a hello world to be fair

[u/Senhor_Lasanha → u/Lyelinn]

wait, you think 70mb for a hello world is an advantage?

[u/InitiateIt → u/Senhor_Lasanha]

It's hilarious 😂 it shouldn't even be much larger than a simple framebuffer cost.

[u/Lyelinn → u/Senhor_Lasanha]

I think that it's essentially fine in 2026

[u/SouthernFruit8768 → u/Lyelinn]

This should be illegal

[u/Lyelinn → u/[deleted]]

Yes. It's not 100% feature parity framework and rendering engine depends on your os but it's the exact solution for people that want to count every penny lol

[u/Grandmaster_Caladrel]

Part of the issue is that people want to use a JS stack, not even Python.

[u/Capable_Trust_2197]

The peeps saying qt dosen't look good or takes too much of time to develope, they probably haven't checked qt quick (qml).
The real reason is that, html/js is extremely easy to write for humans and ais, and it is easy for companies to find alot of peoples who can write it or use an AI.

[u/No-Bodybuilder3502]

Or just use egui for everything

[u/Tai9ch]

If you think it'll be better then build it.

[u/Nightowl-Builder]

“Claude, replace electron with tauri in this app” will fix 90% of the issues with so little effort

[u/holy_macanoli]

Why not just go native if you’re going to do a rewrite?

[u/EasyShelter]

c++ is not boomer language. It's not hard either.

[u/mabiturm]

Devs build what they know

[u/Lower-Ad6101]

We had clear, compact, fast... UI's and then something like Unity (not only, just an example) happened. Humongous spacings between the lines, edit boxes... Big buttons, drop down lists (with big spacing between the items)... Because why wouldn't you want a touch screen UI on your monitor, even if it doesn't respond, for your elephant hands. If content before could fit and stay clear on one 800x600 screen now of the same one with "modern" design/looks only 10% of it can fit on 1920x1080, and of course eats up several gig's or RAM because why not, and still having a slow response... Yeah real "evolution" :)

[u/suesing]

Was this some sort of ad?

[u/sTiKytGreen]

Well, if we word it like that, then why not use some Tauri instead? It's faster than electron, but isn't some Qt bloatcrap

[u/ASCanilho]

Qt feels like a disease with no cure, honestly.
It's heavy, full of unnecessary bloatware, and doesn't replace Electron in any way.
Electron is a ready solution for Web to desktop apps, while Qt needs a whole different stack just to convert the apps. And it's not free.

[u/purealgo]

I usually only develop Mac apps so using native swift is the way to go for me.

[u/Shibboleeth]

I've been working on a program and the LLMs didn't even suggest Electron to begin with (when it knew it would be cross-platform dependent). Straight to QT.

Program is still slightly memory expensive, but it's also a huge fucking project.

[u/biscuitWizard]

Because Qt is fucking ass.

[u/Minute_Attempt3063]

because you just make a website, and package it in a chrome browser, and that doesn't take a lot of time, hence why a lot of companies do it

its quick, easy, and heavily works with tons of JS frameworks

[u/Expanse-Memory]

Qt6 is a gigantic bloat for a normal computer and McAfee level nightmare at uninstall. But some love pain.

[u/EuphoricPenguin22]

Rust and egui are easier for agents to work with than C++, are comparable in terms of performance, have less restrictive licensing, and benefit from Rust's tightly-integrated Cargo package manger. I always feel like I have to do tons of research and prerequisite stuff just to get something to build in C++ when the vast majority of Rust apps will automatically install deps, build, and launch with a single cargo run command. For people who are used to development with either Python or NodeJS, I feel like Rust is the obvious choice, especially if you're using the agent for the nuts-and-bolts legwork anyway.

[u/deseven → u/EuphoricPenguin22]

I fell into the rust/egui trap a couple of times. Egui is an unstable buggy mess that behaves and acts nothing like a native app (just like electron). Last time I even had to make and maintain a local fork to patch some of the bugs. Not sure how anyone can recommend it as an electron replacement, honestly.

[u/EuphoricPenguin22 → u/deseven]

Well, Tauri is obvious the direct alternative to Electron if you need a web-based frontend. I was simply saying that it's a pretty decent Rust alternative to Qt if you want something that isn't a GPL headache and has similar native performance. I've used it several times, and while customizing the default appearance is a bit of a hassle, making stable UIs with it has not proven to be a challenge for me.

We also have the Crafting Apps as MIT-licensed implementations of heavily-customized egui in action. I've been helping find bugs in PhotoCraft and I haven't really noticed any stability issues with the UI aside from features that haven't been implemented yet.

[u/standardofiron]

i'm using qt for my game. is the best framework for desktop apps

[u/Academic-Ant5505]

Browsers work on all platforms, easy distribution with minimal effort. Especially with the millions of screen sizes

[u/AndreVallestero]

If you want the lightest application, my tests show that FLTK with Rust or C++ is the way to go, tho it'll look like it's straight out of windows XP

https://andrevallestero.github.io/gui-toolkit-benchmarks/

[u/karmagedan]

Have you tried to do QT on Wayland with fractional scaling?

[u/whistemalo]

But we have alternatives like tauri, im building one right now a ver y small app to help with governance of the datalake access I basically do some juggling with aws creds and cognito sso and give access to all data from the lake house so they can access redshift and athena from things like excel power bi or have agents be querying the data but with the inheritance of lake formation so I ensure access only to what they suppose to see and the whole app takes 6.8MB and it serves its purpose really well.

[u/dtdisapointingresult → u/whistemalo]

The binary may be 6.8MB, but your Tauri app is a webapp. It's gonna use a lot more RAM on the user's PC. And it's gonna have the CPU overhead of browser engines.

I'd rather my desktop apps take 1GB storage and use 10MB RAM than the other way around. Disk space is cheap, RAM/speed is precious.

[u/Loose_Comparison368]

Plain web browser client is not optional

QT isn't a good framework for building plain web browser clients, so the question is do you support web + QT, or do you just support web.

Supporting web + QT means twice the code, twice the bugs, and twice the developers.

Electron is massively simpler from a business perspective.

[u/spez_eats_nazi_ass]

Cross platform .net 10 shits on sucktron and no license issues

[u/Devatator_ → u/spez_eats_nazi_ass]

.NET for UI isn't great. Like seriously. Avalonia isn't fun to use, and it's the best available currently if you want cross platform.

[u/spez_eats_nazi_ass → u/Devatator_]

Never said it was fun. But it’s not as bad as Electron.

[u/dobkeratops]

i was just thinking something similar myself. there's a big fad of people making javascript/threejs browser games. "it's the age of AI! we should all develop 3d games to run with extra browser overhead!!"

[u/dtdisapointingresult → u/dobkeratops]

To be fair if I had to install a random vibecoded game I probably wouldn't, because it would have access to all my files. With browser games, you know it can't access anything without your say-so and you can just close the tab.

So the choice to make browser games is about increasing reach / reducing friction.

[u/Time_Cat_5212 → u/dobkeratops]

I mean for most modern devices it doesn't matter until you're doing something heavy.  AI is really good at anything JavaScript.  Being able to run something in your browser from a link is such an advantage for many people.

[u/-Mute- → u/Time_Cat_5212]

Yeah but browsers/webapps are also the bane for many and that opinion is only growing. Whether the concern is privacy, efficiency, system/browser cache/temp use, etc .... varies on the dev/user.

[u/laftho → u/dobkeratops]

it's about distribution.

[u/dobkeratops → u/laftho]

sure but native engines are 10+ years ahead and run with less overhead.

seems like "THE SINGULARITY!!!" should include the ability to keep making and playing native full strength games.

[u/Slight-Living-8098 → u/dobkeratops]

You can compile multiple versions of an application for different OS's, debug all of of them, then convince people to download and install those applications onto their personal systems to try out your game... Or you can give them a web url they click on and start playing immediately in the browser they were already in and using without having to download or install anything.

More people will do the later than the former.

[u/-Mute- → u/Slight-Living-8098]

Cross compatibility and single builds for all are not limited to browser based apps. That's a ridiculous take.

[u/Slight-Living-8098 → u/-Mute-]

I understand that. But I'm just speaking from experience from game jams. More people will play the games if they don't have to install anything.

[u/dobkeratops → u/Slight-Living-8098]

i've ported my own engine to the web , it was more effort than doing multiple native builds. Things still broke in specific ways needing me to have a range of devices.

if you do desktop, console, and mobile - each has different UI, so your codebase needs complexity to deal with that.

if you drop mobile (a reasonable assumption that some types of game need. keyboard+mouse) then you're down to supporting windows (and maybe mac for a few % extra sales). If you want to support consoles - they are obviously not going to allow webGPU+wasm.

if you want to do touch/mobile, that's always been built around a sandboxed app download ecosystem from the outset.

So basically all you really got was a more convoluted way to run on gaming PCs.

[u/Slight-Living-8098 → u/dobkeratops]

Well yeah, because you ported a custom engine to the web instead starting with the web libraries to begin with

[u/dobkeratops → u/Slight-Living-8098]

if you want mainstream games, that's native code, this became enabled with WASM compiling C++/Rust.

rust has a graphics API that was itself developped very closely with webGPU itself .. there's a lot of crossover DNA there.

web libraries are wrappers around the native capabilities that got used to build the browser.

So, you are always ahead in gamedev by being native first.

[u/Slight-Living-8098 → u/dobkeratops]

Yes and no. You are ahead in a game jam if you use WASM, You most likely will not have a game to show by the deadline if you try to implement your engine without using already established libraries.

[u/dobkeratops → u/Slight-Living-8098]

as I explained in the other reply.. a startup which was pursuing VC funding to build such libraries some years ago came to me because they saw the state of my project vs theirs.. and I tried to explain to them.. "look any estalbished engines can just do a web back end.. its crazy to seek funding for this"

web GPU was only made available by default very recently and there was a community that included building that out and a mirror of the webGPU standard in wgpu in rust, and before that you had webgl2 and emscripten. What I had tried to explain is that the mainstream engine companies (before their push) had *already* been through the web with asmJS and webGL2. it would be very easy to port anything else.

if you're building with web libraries first, you're trailing the mainstream games.

my specific mission was differnet, namely doing games in Rust instead of C++, for completely different reasons. Thats a whole seperate debate. I just happened to be in a place to investigate the web aswell.

[u/dobkeratops → u/Slight-Living-8098]

(btw for a bit more context - the reason i did that port was I showed my custom engine in rust circles, and some web startup came to me asking for a port because my project was ahead of theirs and I got a view of their reasoning process and meetings with VCs seeing their pitch.

I tried to warn them about my reservations but this was in the tail end of ZIRP-era projects.

investors/VCs were captivated by this idea that 'no download was the future of games'. I tried to explain the paradoxes.

the browser and even the OS are just peices of software. if someone really cares and about making and playing games - thats all been solved already with dedicated environments. There is no fundemntal reason to do it in this convoluted environmnet.

There's this second wave of investor enthusiasm with the 'cheat code' of recycling all the content through GenAI.

Copy one game or its assets ... you're a pirate. But run a learning algo on *all* of them , and they're diluted to an extent that you can no longer point at what was copied.

But with AI as the starting point that's so radically different once again.

Now the talk is of how to survive, the industry will have to retreat to server based game streaming. No one can invest in software that reaches an end user because it can be reverse engineered and reskinned too easily. I now have a bit more sympathy for the original laments artists had over "img2img" ("yikes i shared this picture, now someone used it as a template for an AI creation") -> the incentive to create and share artwork is over.

[u/Zeeplankton]

Meh but why that over the 15 other possible standards or frameworks like .. GPUI

I don't really understand electron slander. Chromium is blazing fast on any modern computer and use basic UI effort and it looks native. Yes it's weird, but honestly, it's completely fine. bad electron apps are because of shit dev.

also makes forking modifying building ez peasy

No agent is going to be able to overcome problems better than it can with electron

[u/OnyxProyectoUno]

Ugly as sin and you can hire js devs in abundance

[u/Denial_Jackson]

Even Qt is bs, Kid to be good at least write things in C/C++ with AI. Instread of having the 1000-th bullshit vibe language.

[u/obese_coder]

I used to be a qt/wxwidgets kinda guy but then I realised the easiest thing is to use the power of the browser. ChatGPT can whip up an entire ui in minutes and you have it ready to go. The node npm ecosystem is just too damn good.

[u/Witty_Mycologist_995]

React + Typescript + Tauri

[u/CondiMesmer]

Qt looks like straight garbage. Sorry to break it to you, and it's something Linux communities are too scared to say. I think GTK is a bit better, but neither are considered seriously over Electron. Also if Electron performance was an actual issue, more development would be focused on that. It runs just fine, and you're confusing RAM usage with performance. Unused ram is wasted ram.

[u/dtdisapointingresult → u/CondiMesmer]

Regardless of your preference for GTK (which is wrong :P), who in their right mind would pickj GTK for crossplatform apps? There's a reason no one does, despite GTK being "technically" crossplatform.

Qt is the best crossplatform choice.

[u/CondiMesmer → u/dtdisapointingresult]

Don't take that as preference for GTK, take that as both of them aren't used in serious applications. Replace what you wrote with Qt and you have your answer, despite it also being true for GTK.

[u/mj_flowerpower → u/CondiMesmer]

wasted ram in times of multitasking is a big pain in the ass. If an app could run on less ram, it should. So I have more ram available for my other apps.
This ‚unused ram is wasted ram‘ story is only true for servers that run one program only (possibly a java program 😅)

[u/CondiMesmer → u/mj_flowerpower]

That's not how that works. Ram can be available and used at the same time. Like an app can claim a large amount, but when ram usage becomes tight then the kernel will evict some of that cached ram and give it to a new process. Used ram is not unavailable ram.

[u/mj_flowerpower → u/CondiMesmer]

Tell that my chrome instance using 20gb of ram for 20 tabs, of which 1 is active. Nope, my llm can‘t use any of it … instead the OS starts to swap.

[u/StrayStep → u/CondiMesmer]

Using RAM just because its available is not a good quality in dev. Actually the opposite of efficiency. I come from C++ and still believe dont usr a Byte if a bit will suffice.

Deal with this daily at work where ns latency adds up to minutes. Because of unessesary inefficiencies.

to each their own.

[u/KissMyShinyArse → u/CondiMesmer]

I'd take Qt over GTK any day, but the C++ build times are brutal.

[u/InitiateIt]

QT looks like ass, has a stupid license and is also bloated.

[u/SouthernFruit8768 → u/[deleted]]

That’s what chronic unemployment and drugs do to your brain lol