Corrected 2 October 2026. This post used to say that all of our apps were native, built with Rust for the core and Swift for the interface. That was not true: two of our apps, Oxid Studio and Oxid Note, use a web interface. It also quoted memory, battery and user-report figures we had never measured. This version says what we actually build and why.
If you've noticed your MacBook fan spinning while running a "simple" chat app or text editor, part of the reason may be what's underneath. Many popular apps are built on Electron, which, in its own words, works by embedding Chromium and Node.js into its binary. Every Electron app carries its own copy of a browser engine.
Here's what we chose instead, including where we didn't go fully native.
What We Build On
Every Oxid app has a Rust engine underneath. On top of it, there are two kinds of interface:
- SwiftUI, in ten apps. Oxid Transfer, OXAMP, Oxid VM, OxidDB, Oxid Mail, Oxid Mac Cleaner, Oxid Capture Studio, Oxid SiteMirror, Oxid Voice and Oxid Hub are SwiftUI apps. Their windows, menus and controls are Apple's own.
- Tauri, in two apps. Oxid Studio and Oxid Note are built with Tauri: the interface is HTML and JavaScript drawn by the web view macOS already has, with a Rust backend. Unlike Electron, Tauri doesn't ship its own browser engine — Tauri's documentation puts it as "they use the OS's webview". But it is still a web interface, so we don't call those two apps native.
How much of each app is Rust varies. In Oxid Mail, OxidDB, Oxid SiteMirror and Oxid Studio, most of the work happens in Rust. In Oxid VM, the virtual machines are run from Swift through Apple's Virtualization framework, and Rust is the command-line tool, the MCP server and the agent inside Linux guests. In Oxid Mac Cleaner, the junk scanner and cleaner are Rust and most other tools are Swift.
Why Rust Underneath
The engine is where an app talks to servers, parses files and keeps state, and where a memory bug does the most damage. In safe Rust, use-after-free and data races are compile errors rather than crashes found later. It also lets us put the same engine behind an app's window and its command-line tool or MCP server: Oxid Transfer, OXAMP, OxidDB and Oxid SiteMirror all ship a CLI built on the same Rust core as the app.
More on that in how Rust powers our macOS apps.
Why SwiftUI on Top (Mostly)
A SwiftUI interface gets the platform's own controls, menus, keyboard handling and accessibility without us reimplementing them, and it doesn't carry a browser engine. That's why ten of our apps use it.
Some concrete examples:
- Oxid Transfer embeds a real SSH terminal (SwiftTerm, which is xterm-compatible) alongside the transfer panes.
- Oxid Capture Studio records through Apple's ScreenCaptureKit straight to H.264.
- Oxid Hub is Swift and Rust, with no web view at all.
Where We Didn't
Oxid Studio's timeline, inspector and preview are a web interface. Its export doesn't route through the web view: the Rust backend runs a bundled FFmpeg that encodes H.264 and HEVC with Apple's VideoToolbox. Oxid Note's note windows are small web views managed from Rust. We think both are useful apps, but they don't behave exactly like SwiftUI apps — Oxid Note, for example, doesn't float over full-screen apps.
What We Don't Claim
We haven't published measurements of memory use, launch time or battery life for our apps against Electron apps or anyone else, so we don't quote numbers. We'd rather you try an app on your own Mac — most have a seven-day trial with every feature unlocked — and judge for yourself.
The Mac Deserves Mac Apps
Apple silicon has given us very capable hardware. We started Oxid Apps because we believe the Mac deserves software built specifically for it. Ten of our apps meet that bar with native interfaces; two use a web interface over a Rust engine, and we'll say so on their pages.
Try It
Browse our apps — every one is a one-time purchase, with no subscription required.