
Open a modern desktop app and there is a good chance you are looking at a website in a trench coat. Electron and Tauri wrapped the web into a window, and for a decade that was the pragmatic way to ship cross-platform software. But a counter-movement has been gathering speed: developers rebuilding their apps as real native binaries, GPU-drawn, with no browser engine inside at all. The latest example surfaced this week on the Chinese developer forum LINUX DO, where the author of Nomo — a free, open-source Markdown editor — described rebuilding the app from scratch in Rust with GPUI and removing WebView entirely. The thread is one data point, but the pattern behind it is bigger than one app: a growing cohort of developers has decided the web layer was the problem, not the shortcut.
Nomo is a free, open-source Markdown editor for Windows and macOS, built as a Typora-style alternative: switch between WYSIWYG editing and raw Markdown source, with support for headings, lists, tables, code blocks, math formulas, and Mermaid diagrams. Its public listing went up in mid-October 2026, and the project lives on GitHub under nomo-md/nomo.
According to the author writing on LINUX DO, the app has now been thoroughly rebuilt — Rust plus GPUI, with WebView completely removed — and the discussion centers on document loading and performance. That rebuild claim comes from the forum thread itself, so treat the performance story as the author's account rather than an independent benchmark. The interesting question is not whether one editor got faster. It is why the rebuild was worth doing at all.
A WebView is a browser engine embedded in your app. It is the reason Tauri apps are small and Electron apps are large, and it is also the reason both feel the way they do. For a Markdown editor, the web layer does real work: it renders formatted text, handles scrolling, and provides an enormous ecosystem of ready-made components. Removing it means reimplementing all of that yourself. So why do it? The arguments developers in this wave keep making are consistent:
None of this is new as an argument. What is new is that the tooling has matured enough for small teams and solo developers to act on it.
GPUI is the GPU-accelerated UI framework developed by Zed Industries for the Zed code editor, and it is open source. It is written in Rust end to end: a view builds an element tree for layout, input, and painting; entities hold the application state that views read. It provides a real element tree, flexbox layout, GPU painting, and reactive entities — but it is not a complete widget toolkit. It was built to serve Zed first, which means conveniences other frameworks ship by default, like a ready-made text field, are not always there. Developers building on it have written about implementing text input themselves, using GPUI's EntityInputHandler trait and a custom element to paint the text, cursor, and selection.
GPUI's surface model is distinctive: overlays — menus, popovers, tooltips, modals — are solved inside a single GPU surface, with no OS popup window and no pointer grab. And the framework's APIs can change, because it is developed as part of Zed; third-party projects typically pin a specific Zed revision to stay compatible. A community-maintained fork, GPUI-CE, exists specifically for standalone applications, targeting macOS, Windows, Linux, and the web.
In short, GPUI is powerful and unfinished at the same time — which is exactly why it attracts the kind of developer who rebuilds an app to escape a WebView. The pitch is control, and the price is building your own widgets.
Nomo is not the first app to make this bet, and the company it keeps says a lot about where the movement is headed:
| Project | What it is | Native stack |
|---|---|---|
| Nomo | Markdown editor | Rust + GPUI, WebView removed (per author) |
| Zed | Code editor | Rust + GPUI (the framework's home) |
| LumaDisk | Disk space analyzer | Rust + GPUI, no Electron or embedded browser |
| Koru | Notes and docs workspace | Rust, winit + vello + parley, no Electron |
| enso | Markdown workspace | Rust, GPU-drawn, no WebView, no account |
| Markraft | Floating Markdown notebook for macOS | Rust, no WebView, plain .md files |
LumaDisk's author, who built a native disk analyzer for macOS and Windows on GPUI, describes the same trade-off Nomo's author accepted: GPUI supplies the rendering primitives and control, but as the app grows you end up building the missing pieces yourself — in LumaDisk's case, a declarative UI macro that eventually became its own open-source crate. Koru's author is even more explicit about the cost: drawing your own interface means building your own accessibility tree, because a browser engine derives one from markup and a GPU-drawn app does not. Koru uses AccessKit to publish its interface to assistive technology.
The pattern across all of them: the app is a single binary, the files are plain and local, there is no account, no telemetry, and no cloud dependency. That bundle of properties — native, local-first, single binary — is the actual product. Performance is the headline, but ownership is the selling point.
The honest version of this story includes the costs, because the developers doing it talk about them openly:
That is why the rebuild makes most sense for a specific kind of app: a focused tool with a small surface area, where the whole interface is a handful of views — an editor, a disk analyzer, a notebook. A Markdown editor is close to the ideal case: the document model is simple, the interactions are well understood, and the performance-sensitive part (typing, scrolling, rendering long documents) is exactly where a GPU-drawn UI pays off. It makes least sense for apps whose interface is genuinely a web of dynamic content, where the browser's layout engine is doing irreplaceable work.
A minimal GPUI dependency in a Rust project looks like this — note the pinned revision, which is standard practice rather than an accident:
[dependencies]
gpui = { git = "https://github.com/zed-industries/zed", rev = "<pinned-revision>" }
The revision pin is the tell. This is not a framework you casually upgrade; it is a framework you adopt deliberately, with your eyes open.
The LINUX DO thread is, on its surface, a developer talking about their own app's rebuild. The reason it is worth reading from outside the Chinese developer community is that it captures a shift that is easy to miss if you only watch the big frameworks. Electron is not going away, and Tauri is a genuinely good compromise — but the developers who care most about the feel of their software are quietly voting with rewrites. Rust's desktop story has moved past the "technically possible" stage: Zed proved GPUI in production, and now a second wave of small apps — editors, analyzers, notebooks — is shipping on it.
The same instinct — Rust, one binary, no browser runtime — shows up elsewhere in the ecosystem: RustDesk rebuilt the TeamViewer model as a self-hosted Rust tool, and REA is another example of Rust-first tooling shipping fast. The Markdown editor is the smallest case in the trend, and maybe the most telling one: if a text editor is worth rebuilding to escape the web, the web layer has officially become the thing developers route around.