Desktop apps

An Electron app has two sides. The main process runs Node.js, so it can open files, create windows, show notifications and call native code. Each window is a renderer process, a Chromium page that draws the interface with HTML, CSS and JavaScript. The two talk over IPC (inter-process communication), ideally through a small preload script that exposes only the functions the page needs.

Because every app bundles the same browser engine, it looks and behaves the same on all three systems, and any web framework works for the interface. VS Code, Slack, Discord, Figma's desktop app and Obsidian are built this way. The cost is weight: even a small app ships a full browser, so downloads run to tens of megabytes and each window uses about as much memory as a browser tab.

A new major version arrives every eight weeks to keep pace with Chromium, and only the three newest get fixes, so apps need regular upgrades. Electron Forge and electron-builder handle packaging, installers and auto-updates.

The interface is an ordinary web front end (React, Vue, Svelte or plain HTML) shown in the system WebView: WebView2 (Microsoft Edge's engine) on Windows, WKWebView (Safari's engine) on macOS and iOS, WebKitGTK on Linux and the system WebView on Android. The back end is Rust: the front end calls Rust functions (commands) through invoke, and Rust can send events back.

With no browser bundled, a basic app can be only a few megabytes and uses far less memory than an Electron equivalent. Security is deny-by-default: capability files list exactly which commands and plugins each window may use. Official plugins cover the file system, dialogs, notifications, a SQL database, global shortcuts and a signed auto-updater.

The trade-offs come from the same design. Each system's WebView renders slightly differently, so the interface needs testing on all of them, and native features mean writing or reading Rust. Tauri 2, released in 2024, added iOS and Android support.

Rust's async functions do nothing on their own; they need a runtime to schedule them. Tokio provides one, with a pool of worker threads that run tasks whenever they can make progress, plus async versions of TCP and UDP sockets, timers, file access, channels and locks. A #[tokio::main] attribute on main starts it.

Much of the Rust networking world is built on it: the reqwest HTTP client, the hyper and axum web servers, the sqlx database library and tonic for gRPC. Tauri uses it as its default async runtime. The main rule is never to block a Tokio thread with long CPU work or blocking calls; spawn_blocking moves such work to a separate thread pool.

reqwest wraps the low-level hyper library in a friendly API: build a Client once, then call get or post, add headers, a JSON body or a form, and await the response. It handles redirects, cookies, compression, proxies, timeouts and HTTPS, with a choice of the system's TLS library or rustls, a TLS stack written in Rust.

It is asynchronous and runs on Tokio, with an optional blocking API for simple scripts and command-line tools. Reusing one Client matters, because it keeps a pool of open connections. With the serde library, JSON responses turn straight into typed Rust structs.

sysinfo gives one API over very different system interfaces: /proc files on Linux, system calls on macOS and Windows APIs on Windows. Create one System value, refresh the parts you need, and read CPU load per core, used and total memory, swap, disks, network interfaces, processes and, through Components, temperature sensors where the system exposes them. It also supports Android, iOS and FreeBSD.

Usage figures are measured between two refreshes, so the first CPU reading is not meaningful; keep one System value and refresh it on a timer. Beyond what sysinfo covers, readings such as fan speeds and GPU load depend on the system and its drivers, some need administrator rights, and GPU details often need vendor libraries such as NVIDIA's NVML.

Each system has its own formats. Windows uses .exe setup programs (built with NSIS or Inno Setup), MSI packages (often built with WiX) and the newer MSIX. On macOS the norm is a .dmg disk image that the user drags into Applications, or a .pkg installer for anything that needs system-level setup. Linux has .deb (Debian, Ubuntu), .rpm (Fedora, Red Hat) and the distribution-neutral AppImage, Flatpak and Snap.

Framework tools produce most of these for you: the Tauri bundler makes MSI, NSIS, DMG, deb, rpm and AppImage files, and electron-builder or Electron Forge cover Electron. Package managers and stores such as winget on Windows, Homebrew on macOS and Flathub on Linux let users install without hunting for a download. Installers for Windows and macOS need code signing, or the system warns users away.

A signature is made with a private key that belongs to a certificate, issued after a check of the publisher's identity. When the app is downloaded, Windows or macOS verifies it: a valid signature shows the publisher's name, while an unsigned or altered file triggers a warning or is blocked. Phones go further, as Android and iOS refuse to install unsigned apps at all.

On Windows this is Authenticode, with certificates from a certificate authority (CA) such as DigiCert or Sectigo, or from Microsoft's Azure Artifact Signing service (formerly Trusted Signing). Since 2023 private keys must live on hardware, a USB token or a cloud HSM (hardware security module), and since 2024 pricier EV certificates no longer skip SmartScreen's warnings: reputation builds as a signed app is downloaded. MSIX apps in the Microsoft Store are signed by Microsoft for free.

On macOS, apps distributed outside the Mac App Store are signed with a Developer ID certificate, which needs the Apple Developer Program, then sent to Apple for notarisation, an automated malware check. Gatekeeper blocks apps that skip these steps, and recent macOS versions make opening them deliberately awkward. Linux has no central scheme; package repositories sign their packages instead.

The app asks a server, often a JSON file or a feed on GitHub Releases, whether a newer version exists, downloads the installer or a patch, checks its signature and installs it, usually on the next restart. Electron offers electron-updater (from electron-builder) and a built-in autoUpdater based on Squirrel, plus a free update service for open-source apps on GitHub. Tauri has an updater plugin, and native Mac apps often use the Sparkle framework.

Signing is the part that cannot be skipped: an updater that installs whatever a server sends is a direct route for attackers, so Tauri requires, and Sparkle recommends, updates signed with a key only the developer holds, on top of HTTPS and code signing. Staged rollouts, where a new version reaches a small share of users first, limit the damage of a bad release. Apps from the Microsoft Store and the Mac App Store are updated by the store instead.

At the centre is the kernel, which schedules programs on the processor, hands out memory, talks to hardware through drivers and enforces permissions. Around it sit the file system, networking, the graphical shell (desktop, taskbar, home screen) and the system libraries that apps call, known as APIs. Apps never touch hardware directly; they ask the operating system.

Desktops run Windows, macOS, Linux or ChromeOS; phones run Android or iOS; most servers and cloud machines run Linux. An app built for one system does not run on another without being rebuilt or ported, which is why cross-platform frameworks exist, and why installers, signing and app stores differ on every platform.

Windows runs on PCs from many manufacturers, mostly with Intel and AMD chips and increasingly with ARM chips (Windows on Arm), which run most older x64 apps through emulation. Native apps are written in C#, C++ or other languages with frameworks such as WinUI 3, WPF and WinForms, or with cross-platform tools such as Electron, Tauri and Flutter. WebView2, Microsoft Edge's engine for showing web content inside apps, comes with Windows 11.

Apps reach users as downloadable installers, which should be code-signed or SmartScreen warns people away, through the Microsoft Store, where registration is free for individuals and companies, or through winget, the built-in command-line package manager. Windows 10 reached end of support in October 2025. WSL (Windows Subsystem for Linux) lets developers run Linux tools inside Windows.

macOS is built on a Unix foundation (Darwin), so the terminal, shell scripts and most developer tools behave much as they do on Linux servers. Since 2020 Macs have used Apple's own ARM-based chips (Apple silicon); new macOS releases no longer run on Intel Macs, and Rosetta 2, which translates older Intel apps, is being phased out. Native apps use Swift with SwiftUI or AppKit, and Electron, Tauri and Flutter also build for it.

Apps are sold through the Mac App Store, where they run in a sandbox, or downloaded directly, in which case they must be signed with a Developer ID and notarised by Apple or Gatekeeper blocks them. Xcode, and with it every iPhone and iPad build, runs only on macOS, which is why mobile teams need at least one Mac or a cloud Mac service. A new version arrives every autumn as a free update.

Strictly, Linux is the kernel, started by Linus Torvalds in 1991 and released under the GPL licence. A distribution (distro) packages it with system tools, a package manager and usually a desktop: Ubuntu and Debian use apt and .deb packages, Fedora and Red Hat Enterprise Linux use dnf and .rpm, Arch uses pacman. GNOME and KDE Plasma are the main desktop environments.

Linux dominates servers, containers and the cloud, which is why web back ends and Docker images are almost always Linux. Android and ChromeOS are built on the Linux kernel, and Valve's Steam Deck runs a Linux-based system. On the desktop it is popular with developers, and it runs well on old hardware and small boards such as the Raspberry Pi.

For desktop app makers it is a fragmented target: several package formats (deb, rpm, AppImage, Flatpak, Snap), different desktops, and the move from the X11 display system to Wayland, which changes how screen capture, global shortcuts and window positioning work. Tauri apps use WebKitGTK here. There is no central code-signing scheme; repositories sign packages instead.