I've been building IONA OS — a sovereign operating system written entirely in Rust — for the past 13 years.
For most of that time, the focus was on the kernel. Memory management, schedulers, drivers, syscalls — the invisible foundation that makes everything else possible.
But an operating system is not just a kernel. It's a desktop. It's applications. It's an experience.
This month, I focused on that experience. I audited every GUI file, fixed every broken application, and made sure the desktop is not just functional, but stable.
Here's what I found and what I fixed.
The numbers
Before I started, I took inventory:
-
68 applications registered in the app registry (
app_grid.rs) -
72 source files in
src/gui/apps/ -
238 source files in
src/gui/total (including widgets, theme, window manager, compositor)
Every file needed to be reviewed. Every application needed to be tested. Every comment needed to be checked.
The audit: 238 files, ~50 findings
I started with a sweep of every file in src/gui/. I was looking for:
- Stubs and TODOs that had been forgotten
- Comments that no longer matched the code
- Dead code that was never called
- Duplicated logic that could be shared
I found about 50 issues. Almost all of them were out‑of‑date comments or small stub functions that had been replaced but not removed.
No major structural problems. No broken architectural assumptions. Just a project that had grown and needed a bit of cleanup.
This was the easiest part. The real work came next.
Testing every application
I booted IONA OS in QEMU (with TCG emulation — the slower, more accurate mode) and tested every application.
1. Firewall & Permissions
What it does: Shows network permissions per application.
The test: Opened the firewall UI. Checked the permission matrix for each app (Terminal, Monitor, Governor, Browser, etc.) across NET/FS/GPU/AUDIO/CLIP.
Result: ✅ Renders correctly. Tabs (Connections/Permissions) switch on click. Escape closes the window.
2. IONA Benchmark
What it does: Runs a suite of benchmarks across 9 stages:
- CPU: float operations, integer operations
- RAM: read, write, latency
- GPU: fill rate
- Disk: write, read, IOPS
The test: Launched the benchmark, pressed R to start.
Result: ✅ Renders correctly. The benchmark runs without blocking the GUI. It's slower under QEMU TCG (expected — it's emulating all the hardware), but it doesn't hang. Escape closes the window even while the benchmark is running.
3. Bluetooth
What it does: Manages Bluetooth devices (RTL8761B controller).
The test: Opened the Bluetooth UI. Toggled the switch.
Result: ✅ Renders correctly. The toggle attempts real hardware initialisation and correctly reports OFF or "device not found" — because QEMU doesn't emulate this specific USB dongle. Correct behaviour, not a bug.
4. Process Manager (Task Manager)
What it does: Shows live processes with CPU%, RAM, Threads, State, Uptime, and I/O.
The test: Opened the Process Manager.
Result: ✅ Renders correctly. The list is live and includes real processes: the compositor, the kernel, iona‑node, and even itself. Bars update in real time. Escape closes the window.
5. Transaction Log
What it does: Shows blockchain transactions.
The test: Opened the Transaction Log. Looked for a real confirmed transaction.
Result: ✅ Renders correctly. A real transaction is displayed in the table (Block, Tx Hash, From, Value, Status). Escape closes the window.
This was the hardest one to test. It requires a working blockchain node with real transactions. I had to verify that the data was actually coming from the node, not from a mock.
6. IONA Update Manager
What it does: Shows available updates and allows governance voting.
The test: Opened the Update Manager.
Result: ✅ Renders correctly. Displays a real governance proposal (#1 v2.0.0) with FOR/AGAINST vote options. Shows tool status for rustup/cargo/git. Escape closes the window.
The review: window manager, compositor, focus, input
Beyond the applications, I also reviewed the core GUI infrastructure:
- Window manager — handles window creation, stacking, resizing, and closing
- Compositor — draws windows and manages the desktop
- Focus — tracks which window has keyboard input
- Input — routes keyboard and mouse events to the correct window
I was looking for:
- Deadlocks (two operations waiting for each other)
- Race conditions (concurrent access to shared state)
- Focus bugs (keyboard events going to the wrong window)
- Input bugs (events being lost)
What I found: A few minor issues. Nothing critical. The core GUI infrastructure is solid.
What this means
This is not a project that "kind of works".
It's a project that works.
- 68 applications are registered and functional
- Every application tested in QEMU (the hardest environment)
- No hangs, no deadlocks, no crashes
- The benchmark runs without blocking the GUI
- Escape closes every window, even during heavy load
What's next
IONA OS is not yet ready for public release. There are still things to polish:
- Performance optimisation (especially in QEMU)
- Documentation
- A proper installer
But the core is solid. The desktop is stable. The applications work.
The code
You can find the full source code on GitHub:
github.com/Ionablokchain/Iona-OS
The project is not yet production‑ready — but it's getting closer every day.
Final thoughts
13 years ago, I started with a single line of assembly.
Today, I have a desktop with 68 applications, a window manager, a compositor, a blockchain node, and a kernel‑integrated AI.
This month, I made sure it all works.
IONA OS launches on September 15, 2026.
Website: iona.zone
GitHub: github.com/Ionablokchain
13 years of research. Every line written from scratch. And it works.
Top comments (0)