By John | July 14, 2026 | dev-workshop
For the better part of a decade, if you wanted to build a cross-platform desktop app with web technologies, you had exactly one serious option: Electron. Sure, it shipped a full copy of Chromium with every "Hello World" — turning a simple counter into a 120 MB download — but that was the price of admission for React-based desktop UIs.
Then Tauri came along and proved you could cut that bloat by 96% using native OS WebViews and a Rust backend. Now, Vercel Labs has entered the arena with something even more radical: Native SDK — a toolkit that throws out the browser entirely.
Let me break down what this means, how to get started, and whether it's really a contender to dethrone Electron.
Native SDK (open-sourced under vercel-labs/native) is a complete desktop app toolkit built in Zig that renders every pixel through its own engine — no browser, no WebView, no JavaScript runtime in the binary.
Here's the architecture in a sentence: you write your UI in declarative .native markup files and your logic in plain TypeScript (compiled to native at build time) or Zig directly, and the toolkit's renderer draws everything into real OS windows.
The numbers are genuinely staggering for anyone who's dealt with Electron bloat:
| Metric | Electron 34 | Tauri 2.x | Native SDK |
|---|---|---|---|
| Hello World Binary | ~85 MB | ~3.2 MB | ~3.5 MB |
| Cold Startup | ~1,420 ms | ~380 ms | ~71-131 ms |
| Idle Memory | ~168 MB | ~42 MB | Even lower (no WebView) |
| Browser Bundled? | Yes (Chromium) | No (OS WebView) | No (Own Renderer) |
That startup time is not a typo. 71-131 milliseconds from process spawn to first frame. On desktop arm64 macOS. That's the kind of snappiness you only get when you're not loading a browser engine.
If you've ever used Elm, Redux, or The Elm Architecture, the mental model will feel instantly familiar:
Events produce Messages → Messages update State → State renders the Interface
That's the whole loop. Markup binds values ({count}) and dispatches messages (on-press="increment"), but it can never mutate state. All logic lives in one pure update function — the only place state changes.
Here's what a counter app looks like:
src/app.native (the UI):
<row gap="8" main="center" cross="center" grow="1">
<button variant="secondary" on-press="decrement"> - </button>
<text> {count} </text>
<button variant="primary" on-press="increment"> + </button>
</row>
src/core.ts (the logic):
export function update(model: Model, msg: Msg): Model {
switch (msg.kind) {
case "increment":
return { ...model, count: model.count + 1 };
case "decrement":
return { ...model, count: model.count - 1 };
}
}
Three files of truth: src/core.ts, src/app.native, and app.zon (manifest). No build config. No webpack. No Vite. The CLI owns the entire build graph.
Getting started is absurdly simple:
# 1. Install the CLI
npm install -g @native-sdk/cli
# 2. Scaffold a new app
native init my_app
cd my_app
# 3. Run it — a native window opens immediately
native dev
Prerequisites:
Prefer Zig over TypeScript? Just add the flag:
native init my_app --template zig-core
The same counter app, same src/app.native markup, but src/main.zig instead of src/core.ts. The toolkit doesn't care which you use — the build system auto-detects.
Edit src/app.native while native dev is running, and the window updates in place within a couple of seconds — keeping all your state intact. Parse failures keep the last good view on screen rather than crashing.
For pure logic iteration, there's an even faster loop:
native dev --core
This runs your src/core.ts under Node.js with a virtual host — no window, no renderer, just the dispatch cycle. Pipe JSON messages in, watch the model change:
printf '%s\n' '{"kind":"increment"}' '{"kind":"toggle_ticking"}' | native dev --core
You can iterate on logic faster than any full rebuild cycle — then flip back to native dev to see the real pixels.
This is the question I had immediately. Tauri already solved the "Electron is too fat" problem by using OS WebViews. Why does Native SDK matter?
Tauri still uses a browser engine. WKWebView on macOS, WebView2 on Windows, WebKitGTK on Linux. Your app renders HTML and CSS — it just doesn't ship its own copy of Chromium. This is a massive improvement over Electron, but you're still at the mercy of browser rendering quirks across platforms, and you still carry the overhead of a layout engine.
Native SDK owns its renderer completely. There's no HTML parser, no CSS engine, no DOM. Markup compiles directly into the executable at build time. The release binary carries zero interpreters or parsers. The engine draws directly into OS windows using Metal (macOS) or a deterministic software renderer (Linux/Windows).
The trade-off: Tauri lets you reuse your entire existing web frontend. Native SDK requires you to use .native markup — which is expressive and familiar (flex layout, bindings, conditionals) but not HTML. You're learning a new UI language.
This is where Vercel's play gets genuinely interesting. Every Native SDK app embeds an automation server. Any AI agent can:
The CLI ships with agent skills pre-built (native skills list). There's an eval harness that hands a clean agent a scaffolded workspace and grades the result — builds, markup checks, live snapshots, and an LLM judge.
This positions Native SDK not just as a framework for humans, but as a target for AI-generated applications. Vercel clearly sees a future where AI agents author, test, and iterate on desktop software — and they've built the infrastructure for it from day one.
Let's be honest — Native SDK is pre-1.0 (v0.5.1 as of July 2026). The APIs are still moving. Here's my honest assessment:
Vercel building a desktop framework makes more sense than it first appears. They're the company behind Next.js — the most popular React meta-framework. They dominate the "frontend cloud." But their platform has always been browser-first.
Native SDK represents Vercel saying: "We want developers to build for every surface, not just the web." By open-sourcing a desktop toolkit with deep AI integration, they're positioning themselves at the intersection of three massive trends:
The Zig choice is particularly telling. Zig compiles fast, produces tiny binaries, and interoperates directly with C libraries — no FFI overhead. The Roc language team famously rewrote their compiler from Rust to Zig citing compile times as a major pain point. For a framework targeting fast iteration loops, Zig makes a lot of sense.
Let me walk through a quick hands-on that goes beyond the counter:
# Install
npm install -g @native-sdk/cli
# Scaffold
native init my-first-native-app
cd my-first-native-app
# Run dev mode
native dev
# → A native window opens with a working counter
# Edit src/app.native — change a label, add a button
# → Window updates in place, state preserved
# Run the checker (no build needed)
native check
# → Validates all .native files and core logic in milliseconds
# Build for production
native build
# → Optimized release binary, a few MB small
Pro tip: Check out the examples/ directory in the repo. The soundboard, notes, calculator, and markdown viewer are all real working apps — zero config, just native dev from their directory.
Is the Electron era ending? Not overnight. VS Code, Slack, Discord, and Figma aren't rewriting in Zig tomorrow. The ecosystem moat — dev tools, plugins, community knowledge, Stack Overflow answers — is deep and real.
But the direction is unmistakable. Between Tauri (90k+ GitHub stars), Microsoft's WebView2 push, and now Vercel's Native SDK, the industry has clearly decided that shipping a browser with every app is no longer acceptable. The frameworks are ready. The tooling is maturing. The performance gains are too significant to ignore.
For your next greenfield desktop project — especially if it's an internal tool, a dashboard, or an AI companion — Native SDK deserves a serious look. The quick start is genuinely minutes. The bundle sizes are measured in single-digit megabytes. And the developer experience — hot reload that works, millisecond validation, zero config — is a breath of fresh air.
The Electron era isn't dead. But for the first time, we can see the horizon from here.
Resources:
What do you think? Is your team considering moving away from Electron? Drop your thoughts — I'd love to hear from teams actually shipping with these new frameworks.