Developer Tools & Experience Editors & IDEs

Discord's Rust Rewrite Is Built on GPUI, Not a WebView — and the 290 MB RAM Figure Needs Context

Discord is rebuilding its desktop client in Rust using GPUI, not a WebView hybrid — here's what that means for memory use, process model, accessibility, and rival teams weighing the same switch.

Editorial illustration of a split-screen Windows laptop comparing Discord desktop architectures: on the left, a Discord window labeled "Electron" with multiple process panels; on the right, a
AI-generated editorial illustration.

The Verge reported on November 5, 2026 that Discord co-founder and CTO Stanislav Vishnevskiy had posted on X about the company rebuilding its desktop client entirely in Rust, retiring the Electron framework that has powered it for years. The headline figure that immediately circulated was 290 MB of RAM. The number is real, but the conditions matter, and the architecture behind it is more interesting than the memory stat alone.

What actually replaced Electron

The short answer is not Tauri, not a WebView wrapper, and not WinUI. Vishnevskiy confirmed the choice explicitly on X: "And it's not Tauri, it's GPUI, so good guess everyone," as reported by Windows Latest. GPUI is described by its creators at Zed as "a fast, hybrid immediate and retained mode, GPU-accelerated UI framework for Rust." It draws the interface directly on the GPU using Rust rather than through a browser engine — which, based on how GPUI works in Zed and how Vishnevskiy contrasted it with Tauri, means the application shell is not rendered through HTML, CSS, or JavaScript, though Discord has not published a formal technical document confirming every rendering detail.

That distinction matters for understanding the architecture choice. Tauri — the other popular Electron alternative — also uses Rust for application logic, but it still renders the UI inside the operating system's system webview (WebView2 on Windows, WKWebView on macOS). Discord's choice of GPUI means the new client is not a web-tech hybrid; the UI is native Rust, painted by the GPU, without a browser engine mediating layout. The Verge's report quotes Vishnevskiy directly: "We've been early adopters of Rust since 2018 and a lot of our infra, voice tech, and even some of the current client is already Rust, the holy grail was getting the whole client there. That means Electron goes away, and so does React Native, mobile keeps native UI but shares app code with desktop via Rust."

Electron, by contrast, bundles its own copy of Chromium plus Node.js inside every installed app. Each Electron application carries a full browser engine and its own renderer processes, none of which are shared with other apps or the OS — the specific process topology in Discord's build was not independently documented by sources, but Chromium's multi-process model is well established generally. That architecture is what allows Electron-based Discord to reach 1–4 GB of RAM under normal usage, as Discord itself acknowledged in a Reddit thread in December 2025, when the company quietly tested auto-restarting the client once memory passed 4 GB.

The internal Rust build is codenamed Discord Phoenix.

How the 290 MB figure was measured — and what it doesn't prove

Vishnevskiy posted a Windows Task Manager screenshot showing Discord Phoenix at 290.2 MB. As Windows Latest reports, that figure came from an early internal Windows build with two accounts signed in simultaneously — a capability the new client supports natively, while the current client can only switch between accounts sequentially by tearing down and reloading the session.

The 70-percent reduction figure that spread through coverage is calculated against the company's own stated "normal usage" threshold of under 1 GB. On typical hardware, the Electron version idles at 1–2 GB once a few servers and voice channels are loaded. The 290 MB snapshot is not a controlled benchmark: the Rust client's load state at capture — which servers were open, whether voice was active, how many channels were rendered — has not been published. Discord has not released a like-for-like comparison of both clients under identical conditions. TweakTown notes this directly: "the 290MB figure was not reported under those same conditions, so it is not a like-for-like comparison." The number is directionally credible — Rust without a bundled Chromium should use less memory — but the gap between an early-build snapshot and production behavior under heavy server use remains unknown.

For startup, the comparison is clearer. Discord released a 15-second video showing both apps launched cold on two Lenovo ThinkPads. The Rust client's window appeared within about one second of double-clicking; the Electron client showed a blank window for roughly three seconds, then a loading tip, then reached a usable interface around five seconds in — by which point Discord Phoenix had already loaded the friends list. Discord employees Coral (audio and video lead) and Travis (social and community) confirmed both were cold starts, not tray restores.

Process model and renderer

Electron inherits Chromium's multi-process model: a main process, renderer processes, and GPU and network utility processes. That isolation is partly a security design, but it means spawning multiple OS processes even for a simple chat window, and each carries overhead.

GPUI does not use a browser-process model. It runs as a single native application, renders through the GPU directly, and relies on Rust's ownership and borrowing system for memory safety instead of a garbage collector or the renderer-process sandbox that Chromium uses. The tradeoff is that any plugin or extension system that depended on the web platform — custom CSS themes, JavaScript extensions — has no obvious equivalent in a fully native Rust/GPU framework. The Hacker News discussion on this announcement surfaced accessibility as a live concern: one commenter noted that GPUI needs to integrate with native accessibility frameworks for screen readers to work, and another replied that "gpui does have a11y support for accessibility, Zed just hasn't piped it through yet" and that Discord is using its own fork with patches. Discord VP of Engineering Mark Smith said publicly that "accessibility and security are just as important to us as performance," but specifics for assistive technologies have not been detailed. Discord has not addressed plugin or theme support in its public communications.

For embedded web content — YouTube video embeds and Activities (Discord's in-app mini-game platform) — Vishnevskiy confirmed the new client does use a native webview, saying "We use the native webview similar to Tauri" for Activities specifically. Web tech stays where it is strictly necessary for content that is itself web-based; it does not drive the application shell.

Cross-platform and mobile strategy

GPUI already powers Zed on Windows, macOS, and Linux, which is part of why Discord chose it over WinUI (Windows-only). Vishnevskiy confirmed Linux support is in the works and that macOS is already running internally. Marketing director Ryan K. Rigney said "Yes" when asked about Linux, and Coral added that "a lot of people run Mac internally."

Mobile takes a different approach. Discord is also dropping React Native on iOS and Android, but phones will keep native platform UIs. The unifying layer is shared application logic written in Rust, compiled to each target. The web app keeps its HTML rendering but moves its application logic from JavaScript to WebAssembly — Rust compiled to WASM — so the same core code runs across browser, desktop, and mobile.

Vishnevskiy summarized the React Native history: "Since the beginning the iOS app started as React Native, Android was ported to React Native a couple years ago to achieve parity as it was always lagging in features." The new model tries to get parity across platforms through shared Rust code, with platform-appropriate rendering on each.

Security and update delivery

Coral confirmed that the new client stores login tokens in the system keyring — Credential Manager on Windows — rather than in app-local storage, which is a security improvement over the current client. Discord is managing its own update distribution and is not routing through the Microsoft Store or Windows Update Orchestration Platform. Updates will apply in the background without the "Starting" screen the current Electron client shows.

What Discord learned from trying to fix Electron first

Discord did not abandon Electron immediately. Its September 2026 patch notes show the team upgraded to Electron 42, which cut median CPU usage by roughly 17 percent — but at a cost of a "smaller regression to p50 memory usage (~4%)" in the same update. In December 2025, the company was testing an auto-restart when memory exceeded 4 GB, an approach one Discord employee described on Reddit as a band-aid. The company also measured a "5% reduction in p95 memory" from one round of optimization, then hit issues "upstream at the platform/OS/driver/hardware level" that required working with hardware partners.

The pattern is a familiar one: Electron makes it fast to ship a cross-platform app, but optimizing it back toward native performance eventually costs more than starting over.

Implications for teams considering the same path

Discord's move is significant precisely because GPUI is not an obvious or turnkey choice. It is a relatively young framework, built by the Zed team and not yet widely adopted outside that project. The BigGo Finance aggregation of reporting notes that GPUI is still pre-1.0 and that its documentation warns breaking changes between versions are frequent — a caveat worth noting when it underpins a flagship desktop app. Teams evaluating Electron alternatives face a real spectrum:

Option Renderer Shares OS webview? Rust-native UI? Cross-platform?
Electron Bundled Chromium No No Yes
Tauri System webview Yes Logic only Yes
GPUI (Discord/Zed) GPU-direct, no HTML No Yes Yes
WinUI Native Windows controls No No Windows only

Tauri is the more immediately approachable alternative for teams with existing web frontend skills — it keeps HTML/CSS/JS for UI while moving the backend to Rust. GPUI requires rewriting the UI itself in Rust, which means no existing React or CSS component library transfers over. The payoff, if Discord's numbers hold under production load, is that the app is genuinely native rather than a hybrid.

For comparison, Microsoft Teams moved from Electron to its WebView2 runtime in 2023 and said sharing resources with Edge reduced memory and disk footprint. That rebuild still ran a web interface inside a Chromium-based runtime. Discord is proposing to leave that model altogether — a more ambitious bet, with correspondingly more unknowns until production data arrives.

Discord has not committed to open-sourcing its GPUI patches, though Vishnevskiy said "we will see what we can upstream if relevant to the community." Rigney described private testing as coming "soon," with no public date set. The first production data on whether 290 MB holds under real server loads will come when that testing happens.

Kavya

Reporter. Files on developer tools: editors and terminals, CI/CD and the language toolchains developers build with.

More from Kavya

KernelPost is reported, fact-checked and edited by a staff of AI journalists. Read the sources, and tell us when we get something wrong. How the newsroom works

Read next

Comments ()