Electron is now ten years past its 1.0 release and has fully matured into the de facto runtime for desktop apps. Most of the products people actually use day-to-day, Visual Studio Code, Slack, Discord, Notion, Figma Desktop, GitHub Desktop, 1Password 8, Signal Desktop, plus OpenAI’s ChatGPT for Windows and the newly arrived Codex Desktop, and Anthropic’s Claude Desktop, all ship on Electron.

At the same time, Microsoft Teams moved off Electron to WebView2 in October 2023, WhatsApp Desktop went through UWP and then reverted to a thin WebView wrapper, and Zed, the successor to Atom, walked away from Electron entirely with a Rust-native rewrite. Other apps people often assume are Electron, including Spotify and Raycast, are not Electron at all, and ChatGPT for macOS is a less-obvious case where the Mac build is fully native while the Windows build is Electron.

This post audits the 2026 Electron landscape from primary sources, public engineering blogs, on-the-record interviews, and public package.json files. It covers who really uses Electron, who never did, the optimization patterns the survivors built, and 2026 newcomers like OpenAI’s Codex Desktop. The frame, product by product, is “why teams stay, and where some are actually leaving”.

Category Map — Famous Electron Apps Still Shipping in 2026

Here is the set of widely used apps that we can confirm still run on Electron, sourced from public repositories, engineering blogs, and on-the-record statements from their teams.

Developer Tools

App	Vendor	Notes
Visual Studio Code	Microsoft	75.9% of developers reported using it in the Stack Overflow Developer Survey 2025
Cursor	Anysphere	VS Code fork. Over 1M DAU and +9,900% YoY ARR growth as of December 2025 (Bloomberg)
Windsurf	Cognition AI	Formerly Codeium. VS Code fork
GitHub Desktop	GitHub	package.json in desktop/desktop shows Electron 42.0.1
Postman	Postman	The API development default. Avoiding CORS constraints is the official reason for shipping desktop
Insomnia	Kong	Original author Gregory Schier spun out after the Kong acquisition and rebuilt the successor Yaak on Tauri
Hyper	Vercel	Vercel’s terminal
Docker Desktop	Docker	UI layer is Electron

Communication

App	Vendor	Notes
Slack	Salesforce	macOS version rebuilt on Electron in 2016, rewritten “ground up” in 2019
Discord	Discord	Electron + C/C++ native modules + WebRTC. Over 200M MAU
Signal Desktop	Signal Foundation	UI on Electron / React / TypeScript, cryptography on libsignal-client (Rust)
WhatsApp Desktop	Meta	Electron → UWP (2022) → WebView2 wrapper (December 2025)
Mattermost Desktop	Mattermost	Enterprise design isolating each server in its own process

Productivity and Note Taking

App	Vendor	Notes
Notion	Notion Labs	11B USD valuation and over 100M MAU as of December 2025
Obsidian	Obsidian	Desktop 1.12.7 (March 2026) ships Electron 39.8.3
Joplin	Joplin	OSS Markdown notes, Electron 40.9.2
Linear	Linear	Speed-obsessed project management
Asana / Loom / Todoist / Trello / Miro	Each	Regulars in the productivity-on-Electron lineup

Design and Creative

App	Vendor	Notes
Figma Desktop	Figma	Electron plus a WebAssembly editing engine. Contributed BrowserView to upstream Electron
Canva	Canva	Listed in Electron’s official showcase
balenaEtcher	balena	OS image writer. Real value lives in native modules (drivelist, direct-io)
Streamlabs OBS	Streamlabs	A streaming-focused OBS derivative

AI Assistants

App	Vendor	Notes
ChatGPT for Windows	OpenAI	About 260 MiB Electron app. The size sparked debate against Copilot (WebView2, under 600 KiB)
Codex Desktop	OpenAI	macOS and Windows only. Alexander Embiricos (OpenAI) confirmed on X Electron was chosen to share code with the VS Code extension
Claude Desktop	Anthropic	macOS and Windows both on Electron. Felix Rieseberg leads engineering
Cherry Studio / Chatbox / Opencode Desktop	OSS	Textbook electron-vite + electron-builder setups

OSS and Community Apps

Electron also still dominates OSS productivity territory: WordPress Studio (Automattic/studio), TriliumNext, WebCord, Element Desktop, Standard Notes, and Bitwarden Desktop all run on it.

Often Mistaken for Electron — Apps That Actually Aren’t

Electron’s polished web-based UIs make it visually indistinguishable from other web-shell technologies, so several non-Electron apps get tagged as Electron in casual conversation. Here are the most common ones, with primary sources.

Spotify Desktop runs on CEF, not Electron

Spotify Engineering’s blog states plainly: “Before tools like Electron became a reality for building hybrid applications, Spotify started using Chromium Embedded Framework (CEF) in 2011.” Spotify has run its own native C++ shell with Chromium Embedded Framework since before Electron existed.

ChatGPT for Mac is native Swift; only Windows is Electron

OpenAI engineer Javier Soto stated on X: “ChatGPT for Mac is a fully native macOS app. Not Electron. Not even Catalyst.” The Windows version, on the other hand, was confirmed as Electron by Windows Latest through binary inspection (Electron-specific files such as chrome_100_percent.pak). Splitting technology selection per OS within a single product line is unusual even in desktop AI.

Raycast is a native macOS app

Raycast is written in AppKit and Swift, with Node.js subprocesses only for extensions, and a custom React Reconciler renders to native AppKit components. Raycast’s own blog post How Raycast API Extensions Work puts it plainly: “Raycast is a fully native macOS app and we treat extensions as first-class citizens.”

Game launchers and streaming clients are not Electron

Amazon Music, Twitch, Battle.net, Epic Games Launcher, Steam, GOG Galaxy, and OBS Studio all run on CEF or Qt WebEngine, not Electron. “Game launchers and streaming clients aren’t Electron” is a useful rule of thumb.

Sketch is a different lineage

Sketch has always been native macOS (Swift / Objective-C) and has never used Electron.

Why Big Apps Keep Picking Electron — The Optimization Patterns

The “Electron is heavy” criticism is old, but the apps that ship at scale have built structural ways to address it. Here are the most important architectural decisions inside three flagship Electron apps.

Visual Studio Code — Piece Tree and V8 Snapshots

VS Code’s reputation as “a lightweight Electron app” hinges in large part on its Piece Tree text buffer rewrite. The original implementation kept each line as an object inside an array, a “line array” model that ballooned on large files. A 13.7M-line, 35 MiB file consumed roughly 600 MiB just for the buffer thanks to V8 metadata overhead, which led to easy OOM crashes.

The team did test moving the buffer into a C++ native module, but found that the cost of crossing the JavaScript / C++ boundary and copying strings outweighed the benefits. They stayed in JavaScript / TypeScript and introduced a red-black-tree-balanced Piece Tree instead. The original file sits in memory as a read-only buffer, edits append to a separate append-only buffer, and lightweight tree nodes track positions and lengths. Memory consumption now sits close to the actual file size, eliminating the OOM class of failures.

On top of that, VS Code addresses the synchronous require() startup bottleneck with V8 startup snapshots, and it defers syntax highlighting so the editor renders plain text first and accepts input before tokenization completes (“staged initialization”).

Slack — legacy-interop and Single-Process Consolidation

Slack’s 2019 desktop rewrite is still one of the most-referenced case studies for refactoring an Electron app at scale. The original implementation leaned on jQuery, direct DOM manipulation, and eager data loading at startup. For users in multiple workspaces, it spawned an entire WebView and Electron process per workspace, which is how the app earned its reputation for chewing through RAM on developer machines.

The team’s answer is laid out in Slack Engineering’s “When a rewrite isn’t: rebuilding Slack on the desktop”: a “legacy-interop” approach that kept the old jQuery main app running while progressively merging in React-based rewrites. The interface rules were strict (old code only calls new code through explicit exports, new code only calls old code through adapters), which kept the codebases from melting into spaghetti.

The headline outcome was consolidating every workspace into a single Electron process. State was rebuilt on Redux and redux-thunk, with each workspace encapsulated as its own slice. Data fetching moved to lazy loading. Slack publicly reported a 33% faster startup, up to 50% lower memory consumption, 10x faster call connection, and the disappearance of the workspace-switch lag.

Discord — CSS Selector Optimization and N-API Linking

Discord sits in possibly the most punishing slot for an Electron app: hundreds of millions of users running voice calls in the background while playing games. From late 2025 through 2026, Discord ran a major modernization pass against a “resource hog” problem on Windows 11 where memory could temporarily reach 4 GiB.

Investigation pinpointed the cause not just in Electron but in the third-party systeminformation library Discord depended on. Instead of calling low-level Windows APIs directly, the library kept spawning PowerShell in the background and running heavy WMI queries like Get-WmiObject Win32_logicaldisk, producing CPU spikes and steady memory growth. Discord rewrote system info collection to use APIs directly, fixed nine or more memory-leak scenarios, and began testing a safeguard that triggers a one-shot self-restart when the app is idle for over 30 minutes and memory usage exceeds 4 GiB.

The team also traced the UI stutter that users blamed on backend latency to inefficient CSS selectors causing reflows in the renderer. Refactoring to flat, optimized selectors made server / channel switches noticeably snappier. Voice processing (noise suppression, echo cancellation, H.264 codecs) lives in C++ native modules linked through N-API so it runs off the JavaScript thread, and on Linux (driven by Steam Deck adoption) the team bypasses the standard Electron rendering path during screen sharing by talking to Gamescope and Vulkan directly, to avoid degrading game performance.

The Common Pattern — Push Hot Work into Rust, WASM, or C++

Across these case studies, the shared strategy is hybrid: keep the UI on Electron, but write performance- and security-critical cores in another language.

• VS Code: Piece Tree in TypeScript for editing, V8 snapshots for startup
• Slack: Single Electron process per app, with Redux slices for workspace state
• Discord: Voice and screen-sharing in C++ + N-API; Vulkan on Linux for rendering
• Signal Desktop: Cryptography and calling in libsignal-client (Rust) and RingRTC
• 1Password 8: Almost all backend in Rust; publishes electron-secure-defaults and electron-hardener
• Notion: Local cache on WebAssembly SQLite
• Figma: Editing engine compiled from C++ to WebAssembly via Emscripten

Notable Departures from Electron — Teams, WhatsApp, and Zed

Three Electron exits get cited most often: Microsoft Teams, WhatsApp Desktop, and Zed. The Teams call belongs to Microsoft (Electron’s largest corporate sponsor), which makes it especially symbolic; the others (Meta’s WhatsApp and the Atom-successor Zed) left for their own independent reasons.

Microsoft Teams Migrated Fully to WebView2

The original Teams was Electron, and the memory-consumption complaints became famous. In 2021, former CVP Rish Tandon publicly announced on X: “We are moving away from Electron to Edge Webview2. Teams will continue to remain a hybrid app but now it will be powered by Microsoft Edge. Also Angular is gone. We are now 100% on reactjs.” After the March 2023 preview, “new Teams” hit GA on Windows and Mac on October 5, 2023.

The published impact is significant: installer size shrank from 134 MiB to about 12 MiB, memory dropped roughly in half, and startup got about 2x faster. The Linux client was dropped in favor of a PWA, and from March 31, 2024 onward, classic Teams installations are migrated automatically, with the old client uninstalled 14 days after the new one lands.

WhatsApp Desktop Went Electron → UWP → WebView2 Wrapper

WhatsApp Desktop moved off Electron to UWP / WinUI in 2022 with positive press, then reversed course just three years later. Late 2025 builds in the Microsoft Store ship as a thin WebView2 Chromium wrapper. Windows Latest reported that the new build consumes significantly more RAM than the previous native UWP version. Daring Fireball bluntly called the new release “a shitty web app wrapper” that is “bloated, slow, and unsurprisingly has poor support for native Windows features”, and the case is now a cautionary example that “leaving Electron” doesn’t necessarily mean “going native”.

Zed Left Atom’s Lineage Entirely

Atom, the editor whose Atom Shell became Electron, was archived by GitHub on December 15, 2022. The successor Zed was started by former Atom core contributors and built on Rust plus a custom GPU UI framework, GPUI. The team’s stated argument is that an editor’s latency targets are unreachable in Electron’s Chromium model. Zed is the most-cited case of “a famous Electron-era product completely leaving Electron”.

The AI Era Is Pulling Apps Back Into Electron

While the leave-Electron narrative is real, the wave of AI desktop apps shipping between 2024 and 2026 has overwhelmingly chosen Electron.

ChatGPT for Windows and Claude Desktop on the Record

ChatGPT for Windows shipped as a roughly 260 MiB Electron app, immediately contrasted with Microsoft’s Copilot (WebView2, under 600 KiB), and the size sparked an extended technical debate. The fact that OpenAI shipped Electron anyway is the signal: distribution velocity and UI consistency beat installer size.

Claude Desktop goes further. Both macOS and Windows are Electron. Boris Cherny, on the Claude Code team, commented on the Hacker News thread for Drew Breunig’s February 21, 2026 piece “Why is Claude an Electron App?”: “Some of the engineers working on the app worked on Electron back in the day, so preferred building non-natively. It’s also a nice way to share code so we’re guaranteed that features across web and desktop have the same look and feel. Finally, Claude is great at it. That said, engineering is all about tradeoffs and this may change in the future!”

And Felix Rieseberg, a long-time Electron core maintainer (and previously at Slack and Notion), now works on Anthropic’s desktop applications. In his post Things people get wrong about Electron, he repeatedly argues that Electron matters precisely because it ships Chromium as a controllable rendering stack independent of OS-bundled WebViews, and that no public data shows built-in WebViews outperforming bundled Chromium.

In a world where AI features (MCP server integration, Claude Code / Cowork, Computer Use, Artifacts, Skills) ship every week, the Electron benefits (perfect sync with web, full control over Chromium rendering, the Node.js ecosystem as host for MCP tooling) are decisive. The shipping cadence of AI products effectively rewards Electron.

Codex Desktop Is Electron, Sharing Code with the VS Code Extension

OpenAI’s Codex ships two distinct surfaces: the terminal Codex CLI (Rust core plus a Ratatui TUI), and a separate GUI build named Codex Desktop. Running codex app from the CLI downloads Codex.dmg from persistent.oaistatic.com into /Applications/Codex.app on macOS, or points users to Codex on the Microsoft Store on Windows — both paths are visible in codex-rs/cli/src/desktop_app/mac.rs and windows.rs. There is no Linux GUI build.

The implementation stack is Electron. OpenAI’s Alexander Embiricos, who leads Codex product, stated on X on February 2, 2026: “we built it in Electron, sharing code the with VSCode extension, specifically so we can get to Windows quickly. (Initially we were even hoping to get out at the same time.)” The decision rationale — sharing UI code between the VS Code extension and the desktop app to accelerate Windows shipping — overlaps cleanly with Anthropic’s stated rationale for Claude Desktop. The size profile (about 330 MiB for the Apple Silicon DMG, in the same range as ChatGPT for Windows at ~260 MiB) is consistent with bundled-Chromium packaging.

VS Code Forks Are the New AI IDE Default

Cursor, Windsurf, Kiro (from AWS), Antigravity, and Void (the OSS variant) all inherit Electron through VS Code. Cursor in particular, per Bloomberg, had over 1M DAU and +9,900% YoY ARR growth as of December 2025. The VS Code economy is, in effect, keeping Electron alive through AI editors.

The downside is a new class of supply-chain risk. Independent security researchers have reported malicious extensions and MCP servers injecting JavaScript into the Electron context. The combination of AI agents evaluating code in a Node context and Electron’s privilege model is becoming a recognized security concern.

AFFiNE Walked Back to Electron

A relevant pre-AI-era case: AFFiNE once shipped its desktop client on an alternative framework, then later switched back to Electron. A “Why Shift from Tauri to Electron” thread on the project’s forum cites plugin ecosystem maturity, debugging ergonomics, and Chromium consistency as the deciding factors. It reinforces the same point as the Anthropic and OpenAI examples: shipping Chromium as a controllable rendering stack is Electron’s intrinsic value, and that value is hard to replicate.

Common Optimization Practices Across the Survivors

Lining up the apps that ship at scale, a set of optimization practices emerges as table stakes.

Eliminate Synchronous require() and Use a Modern Bundler

Node.js’s traditional module loader is synchronous; if it runs during main / renderer startup it stalls the UI thread. When Google engineers profiled Atom’s startup, most of the time was spent on thousands of synchronous require() calls before the first paint.

Modern Electron projects ship Webpack, esbuild, or Vite and roll modules into a single bundle at build time, cutting runtime sync I/O dramatically.

Route-Based Code Splitting and Lazy Loading

Using React’s lazy() and Suspense to dynamically import code only when a specific page or modal (emoji picker, settings) opens is now standard. The goal is keeping idle memory (resident set size) around 150 MiB.

Never Block the Main Process

Electron’s main process is the “control tower” that relays OS events and manages every window. Heavy compute, synchronous file I/O (fs.readFileSync and friends), or synchronous IPC on the UI thread freezes the app. CPU-bound work should run in Worker Threads or be deferred to renderers, and @electron/remote is fully deprecated in 2026.

Secure Defaults

contextIsolation: true, nodeIntegration: false, strict CSP, and isolated preload scripts are non-negotiable. 1Password’s open-source electron-secure-defaults and electron-hardener are useful reference implementations for hardening beyond Electron’s defaults.

Continuous Production Profiling

Notion worked with Palette to put a JS profiler into production and traced the cause of a 10% latency increase on initial page render. Microsoft, Dropbox, and Slack run similar setups. The common trait among Electron apps that survive is the assumption that “real work begins after release”.

Selection Guide — When to Pick Electron

Whether to adopt Electron — and how much to keep it doing alone — comes down to a few scenarios.

When to Pick Electron

• You want to share code and design with the web product to maximize shipping velocity
• You can put a React / TypeScript talent pool to work immediately
• Rapid iteration of AI features (MCP, Computer Use, Cowork) is expected
• You need identical rendering and behavior across every OS
• You need to operate at the maturity bar set by Slack, Notion, and Anthropic

When to Pick the Electron + Rust Hybrid

• You already ship Electron and memory or startup has become a product KPI
• Only a specific subsystem (crypto, calling, DB) actually needs native performance
• You want to mirror the 1Password 8 / Signal Desktop playbook

When to Avoid Electron

• You target a single OS (especially macOS) and want absolutely top-end UX
• Your product can’t exist without native, like Raycast, Sketch, or Zed
• Your latency targets are editor-class (typing latency under 5 ms, etc.)

Caveats

The audit reflects publicly verifiable evidence as of May 2026, but a few caveats apply.

• Numbers are point-in-time: Discord’s 200M MAU (CEO statement, April 2024), Notion’s 11B USD valuation (Forbes, December 2025), Cursor’s 1M+ DAU (Bloomberg, December 2025) and similar figures can shift.
• The “50% memory reduction” for new Teams is a Microsoft internal measurement and real-device experience depends on configuration and tenant count.
• Perplexity Desktop’s public implementation stack could not be confirmed from primary sources.
• “AI company quality judged by Electron usage” narratives (such as Drew Breunig’s February 2026 piece “Why is Claude an Electron App?”) should be weighed against Anthropic’s own statement that Electron is the current best fit. The right separation is “current rationality” vs. “future switching cost”.

Closing

Ten years in, Electron in 2026 remains the foundation under Visual Studio Code, Slack, Discord, Notion, 1Password 8, Signal Desktop, ChatGPT for Windows, Codex Desktop, and Claude Desktop, platforms collectively serving hundreds of millions of users. The core reasons are unchanged: an unparalleled web ecosystem, predictable Chromium rendering, deep OS control via Node.js, and the agility to ship AI features weekly.

At the same time, a steady “leaving Electron” trend exists with Microsoft Teams, WhatsApp Desktop, and Atom → Zed. But “leaving Electron” doesn’t always mean “going native”: WhatsApp ended up on a thinner web wrapper, and AFFiNE actually walked back to Electron after trying an alternative.

In practical terms, three layers hold up well: “Electron stays strongest when a web team needs velocity”, “the Electron + Rust hybrid pattern (1Password / Signal) is the answer when a specific subsystem demands native performance”, and “fully native (Raycast, Sketch, Zed) is right when single-OS, top-end UX is non-negotiable”.

“Electron or native?” is not a binary. It is a design decision with shades of gray, made better by understanding what Slack did with legacy-interop, what VS Code did with Piece Tree, what Discord did with N-API, and what Notion did with WASM SQLite. Even looking only at the Electron adoption side, the 2026 map is rich and full of viable options.

That’s all from someone auditing famous Electron apps in 2026. From the gemba.