I would like to defend Electron, the desktop framework that brings its own browser to render your chat window. This is terrible optics.
Open Activity Monitor and the prosecution arrives fully prepared: hundreds of megabytes for chat, another Chromium process for notes, another for code. The process list shows the cost in excellent detail. It cannot show what teams and users received in return.
Mocking Electron has become a cheap way to signal taste. Point at the process list, call the app a website, and close the case before anyone counts what the browser replaced. The evidence fits neatly into one column. The missing column is the interesting one.
Electron packages Chromium and Node.js into a cross-platform desktop runtime. The result can be heavy. It also powers software many of us live in: Visual Studio Code, Slack, Discord, and Notion. Apparently the website escaped its tab and acquired a product team.
Once a technology becomes ordinary, people stop discussing the problems it solved. Its remaining flaws stay visible. Electron’s reach disappears into everyday software; its memory usage remains highlighted in Activity Monitor. This is infrastructure amnesia with a memory column.
The bundled browser gives a team one known rendering engine instead of a different webview, version, and family of defects on every operating system. One team can reach several platforms without becoming several teams. Developers get one rendering model, browser DevTools, npm, and a large pool of people who already know how to build for the web. Electron turned that existing web stack into a desktop application platform. The browser is expensive cargo. It is also carrying things.
“Bloat” counts what lands on a user’s machine. Users should not become a dumping ground for careless engineering, and memory, battery life, launch time, and disk space all matter. A fair comparison must also count duplicated implementations, platform drift, delayed releases, abandoned Linux versions, and applications that never become viable enough to exist. We can inspect Electron’s memory usage. We cannot open a task manager for the software that was never built. That cost is harder to count.
Electron spends memory and disk space to reduce cross-platform engineering work. A tiny, stable utility should not need Chromium around a handful of controls. Sometimes the browser really does outweigh the product. The trade makes more sense for rich, collaborative, extensible applications that change often and must work the same way across operating systems.
A small team can support platforms it could not afford to build separately. A developer can turn an idea into an application with familiar tools. That reach changes which applications get built, which platforms they support, and how long they survive. This benefit does not appear beside a process ID.
Calling Chromium “an entire browser” makes it sound like empty cargo. The bundle contains decades of work on rendering, international text, input, media, graphics, accessibility, sandboxing, security, and compatibility. Then we try to remove the browser and discover that it was full of browser.
Replacing Electron remains difficult for the same reason. Tauri keeps the web stack but relies on each operating system’s webview, putting platform differences back on the table. Native renderers can use fewer resources and integrate more deeply with the operating system, but their teams must build tooling, primitives, accessibility, and developer familiarity. They reduce the browser tax by taking back work Electron bundled into Chromium. The weight leaves the installer and reappears on the roadmap.
One promising direction is not to remove Chromium, but to give it a narrower job. OpenAI’s Web Layer, or OWL, runs Chromium behind an isolated service while SwiftUI and AppKit handle Atlas’s interface. OpenAI’s account of the architecture explains that Chromium can start asynchronously, and a browser hang need not take down the native shell. The architecture preserves rendering and compatibility while separating lifecycle, failure isolation, and native UI. Chromium keeps its job. It loses custody of the whole application.
Before I could code, applications such as Slack and VS Code helped me enter the world of software. I work closer to the machine now, but that does not make the interfaces that brought me here trivial. Experts can outgrow an interface and forget who still relies on it. Crossing a bridge is not proof that the bridge was wasted infrastructure.
I want lighter desktop applications, deeper native integration, and better failure isolation. But a credible successor must preserve what made Electron valuable: one team, several platforms, and software that gets to exist. Build the successor. Just remember to include the missing column.