When people ask what makes Oxid apps fast, the short answer is: Rust.
The longer answer involves memory safety without garbage collection, zero-cost abstractions, fearless concurrency, and a compiler that catches entire categories of bugs before your code ever runs. Here's how Rust shapes every app we build.
Why Rust for Desktop Apps?
Most native macOS apps are written in Swift or Objective-C. These are excellent languages with deep Apple ecosystem integration. We use Swift too -- for UI layers, system integration, and anything that talks directly to AppKit or SwiftUI.
But for the core engine of each app -- the part that crunches data, processes files, manages state, and does the heavy lifting -- we chose Rust. Here's why:
Memory Safety Without the Overhead
Swift uses Automatic Reference Counting (ARC) to manage memory. It works well, but ARC has a runtime cost: every time you pass an object around, a counter increments and decrements. In hot loops processing thousands of files or video frames, that overhead adds up.
Rust takes a different approach. Its ownership system tracks memory at compile time. There's no reference counting, no garbage collector, no runtime overhead. Memory is allocated and freed deterministically, exactly when the compiler proves it's safe to do so.
The result: Rust code runs with the predictability of C, but without the memory bugs that have plagued C programs for decades.
Fearless Concurrency
Modern Macs have 8, 10, or even 24 CPU cores. To fully utilize that hardware, apps need to do work in parallel. But concurrent programming is notoriously error-prone -- data races, deadlocks, and use-after-free bugs are the stuff of debugging nightmares.
Rust's type system makes data races impossible at compile time. If your code compiles, it's free from data races. Period. This isn't a runtime check or a best practice -- it's a mathematical guarantee enforced by the compiler.
This means we can aggressively parallelize workloads without fear:
- Oxid Mac Cleaner walks your filesystem across all available cores at once, with each thread sharing results without locks or race conditions.
- Oxid Studio decodes and processes video frames in parallel, distributing work across your M-series chip's efficiency and performance cores.
- Oxid Transfer runs many file transfers at once over SFTP, FTP and S3, with a Rust engine coordinating them and no data races to debug.
Zero-Cost Abstractions
In many languages, writing clean, abstract code comes with a performance penalty. Rust's "zero-cost abstractions" principle means that high-level constructs like iterators, generics, and pattern matching compile down to the same machine code you'd write by hand.
We write expressive, maintainable Rust -- and the compiler turns it into code that's as fast as hand-tuned assembly.
Rust + Swift: The Best of Both Worlds
Our architecture follows a clear separation:
┌─────────────────────────────┐
│ SwiftUI / AppKit │ ← UI Layer (Swift)
│ Native macOS Interface │
├─────────────────────────────┤
│ Swift ↔ Rust Bridge │ ← FFI Layer
├─────────────────────────────┤
│ Rust Core Engine │ ← Business Logic (Rust)
│ File I/O, Processing, │
│ Algorithms, State │
└─────────────────────────────┘
Swift handles everything the user sees and touches: windows, menus, animations, drag-and-drop, and system integration. It's the right tool for UI work, with first-class access to Apple's frameworks.
Rust handles everything under the hood: scanning directories, processing media, running algorithms, and managing application state. It's the right tool for performance-critical work where every millisecond counts.
The bridge between them is thin and efficient, typically using C-compatible FFI (Foreign Function Interface) that adds negligible overhead.
Where This Shows Up
Rather than quote benchmark numbers, here is what the architecture actually buys, app by app:
Oxid Mac Cleaner walks a filesystem tree concurrently and reports what it found before deleting anything. The scan is parallel by construction; the review step is deliberately not automatic.
Oxid Studio ships an arm64-native media engine with FFmpeg bundled — a build made for this app, LGPL, using VideoToolbox for H.264 — so a clean Mac can import and export without installing anything else.
Oxid VM runs virtual machines and containers through Apple's Virtualization framework, with the supervisor written in Rust.
OXAMP is a static build of Apache, MariaDB and PHP. Nothing is resolved from Homebrew at runtime, which is why it starts the same way on a machine that has never had a developer stack installed.
The Developer Experience
Beyond performance, Rust makes us more productive:
- The compiler catches bugs early. Null pointer dereferences, buffer overflows, use-after-free -- entire categories of bugs that would be runtime crashes in other languages are compile-time errors in Rust.
- Refactoring is safe. When we change a data structure, the compiler tells us every place in the codebase that needs to be updated. Nothing slips through.
- Dependencies are reliable. Cargo, Rust's package manager, handles dependency resolution, building, and testing with a consistency that few ecosystems match.
We ship fewer bugs, iterate faster, and sleep better at night knowing that if it compiles, it's memory-safe.
Why This Matters to You
You don't need to care about programming languages to benefit from Rust. What you'll notice is:
- Apps that launch instantly and stay responsive under heavy workloads
- Lower battery consumption because the CPU finishes work faster and returns to idle
- No mysterious crashes from memory corruption bugs
- Smaller app sizes because there's no embedded runtime or browser engine
Rust is invisible to you as a user. But it's the reason Oxid apps feel the way they do -- fast, stable, and respectful of your hardware.
Building the Future on Rust
Rust adoption is accelerating. The Linux kernel now accepts Rust code. Microsoft is rewriting core Windows components in Rust. Apple's own tools are exploring Rust interoperability.
We're proud to be building on this foundation. Every new Oxid app starts with a Rust core, and the results speak for themselves.
Explore our apps and feel the difference that Rust makes.