What is the state of frontend frameworks and libraries in 2026? This is a question many frontend developers today are wrestling with, and it appears one answer is that frontend has moved deeper into the stack. Take gpuix-svelte, an experimental project built by Stanislav Khromov, a Svelte core team member, that renders the JavaScript framework Svelte as native desktop apps with no browser underneath. In this case, the framework web devs know stays, but the browser it was built for becomes unnecessary and drops out of the picture. Whoa.
I’ve written previously about the emerging appeal of native code in our AI-assisted, cheap-code era, using Shopify’s move off React Native and back to Swift and Kotlin as the flagship example. Shopify went native all the way down, trading its JavaScript layer for platform languages. gpuix-svelte and similar projects take a different approach. Devs continue writing in web frameworks, but the JavaScript runs in Node or Bun, and a native renderer draws the UI.
Both Shopify and gpuix-svelte move down the stack, closer to the metal, and, most shockingly, away from the browser as the default target for UI. So what does gpuix-svelte add beyond another data point in my continuing research at RedMonk into where software development teams are focusing their energy now that code is so damn cheap? Join me!
Frontend, minus the browser
Khromov’s gpuix-svelte builds on two layers. At the bottom is GPUI, the Rust UI engine behind the Zed code editor, which draws the interface directly on the computer’s graphics chip. On top of it sits Tommy D. Rossi‘s GPUIX, a bridge that lets JavaScript frameworks hand their components to GPUI. Rossi wrote adapters for React and Solid, and gpuix-svelte adds Svelte as a third. The result? Ordinary frontend components become a native desktop app for macOS, Windows, and Linux. Importantly, no web browser is involved, not even the hidden, built-in one that tools like Electron and Tauri rely upon.
I’m not surprised to see this latest addition to the frontends supported by GPUI. Since Rich Harris launched it a decade ago, Svelte has been a developer favorite despite powering a relatively small share of the web. We see a signal of this in the “Web frameworks and technologies” section of the 2026 Stack Overflow Developer Survey when the survey’s authors note:
Svelte and SvelteKit are both highly admired, scoring 59% and 64% respectively.
gpuix-svelte lets developers keep writing Svelte the way they already do, but ship their app as a single, self-contained program that doesn’t bundle an entire copy of the Chrome browser, as Electron apps do, or lean on the browser engine built into the user’s operating system, like Tauri apps. This is a big deal, and it’s telling that one of the first replies on Bluesky came from Zach Inglis, a developer who had given up on Tauri because of webview rendering problems on Linux.
This is great.I've had so many issues with Linux rendering of web views (and so couldn't use Tauri.) Looks like this solves that!
Not an isolated experiment
Most of the projects below fall into the familiar category of cross-platform frameworks intended to let teams write an app once and ship it everywhere (Google’s Flutter, JetBrains’s Kotlin, Apple’s Swift, Microsoft’s .NET MAUI). What’s new is that they deliver on that promise without leaning on the browser. A cluster of projects pulling familiar web-style authoring down toward native rendering include:
- rvst (2026), created by Shane Murphy, Head of Digital Technology at ContentJet, renders Svelte 5 through a pure Rust pipeline: Taffy for layout, Parley for text, Vello for GPU paint.
- Valdi (built inside Snap around 2017, open sourced in late 2025), created by Simon Corsin, Member of Technical Staff at OpenAI, compiles TypeScript components straight to native views on iOS, Android, and macOS, with no webviews and no JavaScript bridge. Snap ran it in production for eight years before releasing it.
- Lynx (open sourced in March 2025), from ByteDance, lets web developers build native iOS and Android apps with markup, real CSS, and a React-style API, rendering to native elements rather than a webview.
- Dioxus Native from DioxusLabs, renders HTML and CSS through Blitz, its own GPU-based engine, instead of the system webview that Dioxus’s desktop renderer uses.
What ties these projects together is that developers still want to write declarative, component-based UIs in the frameworks they already know. They just no longer want a browser standing between that code and the screen. In that sense, these projects make the same move down the stack that Shopify did, with a different bargain. Shopify gave up its shared JavaScript layer because agents made writing Swift and Kotlin twice affordable. These projects keep that shared layer and swap out the browser beneath it for a renderer that talks directly to the GPU or to native views. Either way, the browser is no longer the default place the UI runs.
Why now
For most of the last decade, the web platform won by default because rebuilding for each native target was too expensive. Now that agents have made writing and maintaining glue code between a JavaScript framework and a Rust GPU renderer cheap, solo maintainers can take on projects that once required a funded team, and the old tradeoff between developer velocity and native performance dissolves. Notably, gpuix-svelte ships with an AGENTS.md and publishes its docs as llms.txt, a sign of who (and what) its authors expect to be writing these apps.
What about the web itself? WebAssembly lets these same native renderers run inside a browser and both GPUIX and gpuix-svelte already offer this. In this way the browser becomes one deployment target among several rather than the platform everything is built around. The catch is that these apps paint the whole interface as a single picture rather than building the page out of the HTML elements that browsers, screen readers, and search engines understand, which means they give up some of what the web provides, such as accessibility and search indexing, so this approach suits app-like experiences more than ordinary web pages.
Although gpuix-svelte is an experiment, depending on a Svelte API that hasn’t shipped yet and supporting only a fixed set of elements that can’t use DOM-based component libraries, the direction of innovation is worth watching. Frontend frameworks are no longer just ways to manage the DOM. They are becoming portable authoring layers that can sit on top of whatever renderer makes the most sense, and in a cheap-code era, that increasingly means native rendering rather than the browser.
Disclaimer: Google and Microsoft are RedMonk clients.