The video discusses the development of a real-time system monitor application using Deno Desktop, contrasting it with the traditional approach using Electron. The primary advantage highlighted for Deno Desktop is its significantly smaller application size. Electron apps, by default, bundle a full Chromium browser, leading to large executable sizes (around 248 MB in the example). Deno Desktop, however, leverages the operating system's built-in web view (WebView2 on Windows, WebKit on Mac/Linux), drastically reducing the bundled size to approximately 21 MB and often resulting in a single executable file.

The technical implementation with Deno Desktop involves using `deno.serve` to host the application's interface and an API endpoint (e.g., `/stats` for JSON data), and `deno.browserWindow` to open a native window pointing to this interface. It also supports exposing backend functions directly to the frontend via a `bind` call. Permissions, such as `allow-sys` for system access, are crucial, and configuring `node_modules` to `none` prevents unnecessary package crawling.

The speaker shares their experience building a system monitor, which resulted in a 77 MB application that compresses to 21 MB. This is compared to Better Stack's findings where an Electron Node app was 248 MB versus 70 MB for Deno, with similar startup times. Deno Desktop is presented as a feature-rich solution, including system tray support, native notifications, binary diff auto-updates, and cross-compilation capabilities to Mac, Windows, and Linux, with installers built in Rust.

However, the video also acknowledges Electron's maturity and its own smaller starter size (around 14 MB), though it lacks Windows support. Deno Desktop's main drawback is its experimental nature (introduced in Deno 2.9), meaning APIs are subject to change, non-framework apps require explicit entry points, and developers must contend with OS-specific web view behaviors.

Ultimately, the choice between Deno Desktop and Electron (or related tools like Electrobun) for small applications depends on project priorities: Deno offers Windows support and cross-compilation from a single source, while Electrobun is smaller and more stable but limited in OS compatibility. The speaker emphasizes the practical implications of these trade-offs for shipping applications.

DIY Smart Code

I built a real desktop app in Deno Desktop, a real-time system monitor. Build something like that in Electron and it ships 248 MB because every Electron app bundles a whole copy of Chromium, an entire browser inside it. That's the Chromium tax and you pay it on every single app you ship.

Deno Desktop makes a different bet. Your operating system already ships a browser engine. So, Web View 2 on Windows, WebKit on Mac and Linux. So, instead of bundling Chromium, Deno Desktop just borrows the one that's already there. Same app built with Deno Desktop, about 21 MB and the whole thing is basically one file.

In main.ts, deno.serve hosts your interface plus a /stats endpoint that returns JSON. deno.browserWindow opens a real native window pointed at it. There's even a bind call to expose a backend function straight to the frontend running in process. Too gorgeous, bit me.

You need the allow-sys permission for system access. Without it, no CPU or memory numbers. And set the node_modules directory to none. Or Deno will crawl your entire home folder hunting for packages.

Now, the receipt. My system monitor came out at 77 MB and compresses down to 21. Better Stack's own test put an Electron Node app at 248 MB versus 70 for Deno with a near tie on startup time. Much smaller on disk, basically the same to launch. And it's not a toy. Batteries are included. A system tray, native notifications, binary diff auto update patches, and cross compile to Mac, Windows, and Linux from one machine. With installers written in pure Rust.

But let's be fair. Deno isn't the only player here. Electron was stabilized about 4 months earlier and self-reports a roughly 14 MB starter. The honest catch, it's Mac and Linux only, no Windows at all. And Deno Desktop has its own catch. It's experimental, new in Deno 2.9. The APIs can still move. Non-framework apps need an explicit entry point, and you inherit each operating system's web view quirks.

So, which one wins for your next tiny app? Deno gives you Windows and cross-compile. Electrobun is smaller and was stable months earlier. I built a real one and measured all of it. The full breakdown is linked. Which one are you actually shipping?

Electron is Getting Replaced #deno #programming

I built a real desktop app in Deno
Desktop, a real-time system monitor.
Build something like that in Electron
and it ships 248
MB because every Electron app bundles a
whole copy of Chromium, an entire
browser inside it. That's the Chromium
tax and you pay it on every single app
you ship.
Deno Desktop makes a different bet. Your
operating system already ships a browser
engine. So, Web View 2 on Windows,
WebKit on Mac and Linux. So, instead of
bundling Chromium, Deno Desktop just
borrows the one that's already there.
Same app built with Deno Desktop, about
21 MB and the whole thing is basically
one file. In main.ts, deno.serve hosts
your interface plus a /stats endpoint
that returns JSON. deno.browserWindow
opens a real native window pointed at
it. There's even a bind call to expose a
backend function straight to the
frontend running in process. Too
gorgeous, bit me. You need the allow-sys
permission for system access.
Without it, no CPU or memory numbers.
And set the node_modules directory to
none. Or Deno will crawl your entire
home folder hunting for packages.
Now, the receipt. My system monitor came
out at 77 MB and compresses down to 21.
Better Stack's own test put an Electron
Node app at 248 MB versus 70 for Deno
with a near tie on startup time. Much
smaller on disk, basically the same to
launch. And it's not a toy. Batteries
are included. A system tray, native
notifications, binary diff auto update
patches, and cross compile to Mac,
Windows, and Linux from one machine.
With installers written in pure Rust.
But let's be fair.
Deno isn't the only player here.
Electron was stabilized about 4 months
earlier and self-reports a roughly 14 MB
starter.
The honest catch, it's Mac and Linux
only, no Windows at all.
And Deno Desktop has its own catch. It's
experimental, new in Deno 2.9.
The APIs can still move. Non-framework
apps need an explicit entry point, and
you inherit each operating system's web
view quirks.
So, which one wins for your next tiny
app?
Deno gives you Windows and
cross-compile.
Electrobun is smaller and was stable
months earlier.
I built a real one and measured all of
it. The full breakdown is linked.
Which one are you actually shipping?

Get Our Mobile App

Electron is Getting Replaced #deno #programming

Transcription