Introduction
In 2026 a crack hardware and software engineering team was tasked and sent to rebuild the Linux fractured ecosystem. These people promptly escaped from the trappings of that ecosystem to the background, today they survive as coders of fortune. If you have a problem, if no one else can help, and if you can contact them... then maybe you can hire.. The A-Team.
Who Are You?
We are The A-Team! Some of you might have heard of me, I’m ket, sometimes known as ketxxx of XtremeSystems, TechPowerUp, occasionally Reddit, and these days mostly Win-Raid. If you know of me you’re probably familiar with some of my work; Gigabyte Aorus UEFI firmware modifications, GPU BIOS modifications, the Polaris How To guide on Win-Raid, Asus P5Q Series mBIOSes, etc. With me are a few collaborators and together we are.. The A-Team!
How was Sovereign born?
Sovereign initially started as internally being called the GEMKET Engine, it was an endeavour to bring proper statistical live data back to “legacy” hardware like the Ryzen 2500U weaved into MangoHud.. or as I came to call it MangledHud. After a week of fighting that continuously band-aided spaghetti code (and succeeding) and attempts at untangling the code the decision was called – we would cut the umbilical and rip the GEMKET engine implementation out of it and build our own software free of MangoHuds baggage. Born from that trial by fire is GEMKET Sovereign, or just Sovereign.
What is Sovereign, and Why Sovereign?
Why Sovereign? Because it’s an awesome name for one thing, for another because we wanted a name to emphasise elegance, class, and the cutting edge. Just like the Enterprise-E. Over the decades we have also grown ever increasingly tired of Microsoft and Windows, and particularly now Windows 11 has gone full Sith Lord and not even hiding it anymore.
What is Sovereign? Sovereign is an agnostic, dynamic realtime OSD and more. We call it agnostic and dynamic because the Sovereign engine queries the system for live sensors, makes sure they are not dummies and displays the live sensor metrics to the OSD. The agnostic part comes from one of Sovereigns features, a truly independent OSD that functions on the desktop, in legacy and modern OpenGL titles, and Vulkan. It was said it couldn’t be done, we disagreed and did it anyway. Sovereign operates entirely within standard user-space privileges. It does not modify kernel binaries, it does not crack open closed system files, and it does not steal copyrighted code. We are simply using standard Linux hooks, memory techniques, and display flags in a creative way. Sovereign is also highly efficient and lightweight, both in terms of resources and file size. This is only one of many features though to unite the fractured Linux ecosystem we have also built a .so plugin system not beholden to a specific toolchain.
This software is not a pipe dream, it is not vapourware, it is real, it exists right now, is being developed on Ultramarine Fedora 44 KDE, and while features are still being implemented such as proof of concept microphone and webcam plugins it is functional – including the agnostic OSD. Sovereign is a pure C++20 engine built from scratch with near 0% idle CPU draw. It is fast, lean, and handles raw hardware data. The exact kind of minimalist code efficiency of the Linux kernel itself.
1. The Sovereign Engine and What it Means for Developers and Development
Linux desktop development has been trapped in a culture of compromise for far too long. We decided to draw a line in the sand and say no more, no further! Developers looking to build overlay utilities were told to wait for upstream desktop portal protocols, write massive D-Bus communication boilerplate, or tie their applications directly to specific compositor extensions.
Sovereign OSD completely rewrites the rules by implementing a strict C-Linkage binary boundary viaourPluginAPI, the compilation loop is entirely decentralised.
SOVEREIGN CORE ENGINE
(Protected UI Threads, Wayland Bypass, Graphics Shims)
|
Strict C-Linkage Isolation Gate
|
Custom.so
plugins
For developers, this means absolute architectural freedom:
- You are no longer chained to a specific toolchain. Write your plugins in C++20, pure C, Rust, or Zig—if it compiles to a standard native
.so shared object with C-compatible symbols, Sovereign will load it seamlessly.
- There are zero core dependencies, you can develop complex, low-overhead monitoring extensions without ever needing to look at, link against, or recompile Sovereign's core proprietary graphics pipeline.
- There is Automated Lifecycle Guardrails, plugins are handed strict lifecycle states, the host engine handles runtime setup and cleanup safely, eliminating repetitive code generation.
2. The Sovereign Engine and What it Means for Gamers, Reviewers, and Power Users
To the end-user, an overlay is only as good as its performance signature. Modern overlays have become bloated, requiring excessive memory footprints and spawning background daemons that introduce micro-stuttering during intense gaming sessions.
Sovereign OSD is being engineered with zero bloat, and maximum performance.
- For Gamers: Sovereign delivers a rock-solid, hardware-accelerated telemetry card that floats effortlessly over your games. Because it avoids heavy script interpreters, its idle CPU draws sit at near absolute 0%,freeingevery single frame for your hardware.
- For Hardware Reviewers: Accuracy is paramount. Sovereign completely bypasses generic user-space timing loops, pulling raw data from our picosecond (millisecond readings at double precision) Running Average Power Limit (RAPL) and native kernel
sysfs paths. You get accurate hardware tracking from 720p handheld gaming monitors all the way to 32K enterprise computing spaces.
- For Power Users: No installation scripts, no package repository tangles, and no distribution conflicts. You download a single, self-contained AppImage, toggle your options, and play. It works identically whether you are running Arch, Fedora, openSUSE, or Mint.
3. The Sovereign Engine and What it Means for the Future of Linux and the Ecosystem
The migration from legacy X11 to modern Wayland compositors brought a massive security lockdown. To protect user data, Wayland implements strict security sandboxing: applications are intentionally blinded to coordinates and keystrokes outside their own precise window boundaries. While well-intentioned, this rigid design philosophy effectively killed the agnostic overlay ecosystem, leading to fractured desktop ecosystems.
Sovereign OSD proves that the "Wayland Lockout" was never an engineering impossibility—it was simply a failure of imagination, determination, and know-how.
By executing as a completely detached framework surface, Sovereign successfully cuts through the display manager stacking locks. We did not ask the fragmented distributions or upstream maintainers for permission, nor did we force users to compromise security with intrusive system hacks. Sovereign establishes a dual-insulated, platform-neutral architectural bridge that proves Linux software can be both incredibly secure and completely unbound.
4. The Sovereign Engine and How It Can Turn the Tide and Make Linux a Serious Contender to Windows
One of the final, massive roadblocks preventing mainstream Windows gamers and power users from permanently migrating to Linux is the lack of a standardised, commercial-grade, plug-and-play optimisation and monitoring infrastructure. On Windows, utilities like MSI Afterburner run out of the box with zero friction. On Linux, users are frequently forced to wrestle with terminal compilation steps, fragmented environment variables, and broken window layers. Sovereign OSD closes the platform gap permanently.
By bringing a true "Windows-like, double-click to play" self-contained user experience to the Linux desktop, we eliminate user friction. A mainstream user can boot into Linux, launch Sovereign, and get instant, elite-tier hardware control on the fly. By treating the Linux desktop workspace with the polish, speed, and reliability of a commercial consumer product, Sovereign delivers the exact experience required to challenge Windows and it’s monopoly.
5. Our Security Decisions for Not Releasing the Source Code at This Time
Open-source purism is a defining trait of the Linux community, but it frequently leaves innovative software vulnerable to immediate exploitation and corporate strip-mining. Sovereign OSD will be distributed exclusively as a pre-compiled, secure binary package for these reasons:
- Protection of Proprietary Breakout Architecture: The exact combination of our layout and mouse coordinate data represents a massive engineering breakthrough. Keeping the source closed protects this proprietary bridge from being instantly swiped and\or broken by automated repository bots.
- Ecosystem Integrity: Keeping the core sealed ensures that the primary engine baseline remains consistent and reliable. Users can download the official AppImage with absolute confidence that it has not been tampered within any way, shape, or form.
- Encouraging Clean Extensibility: By keeping the core repository close to our chest while providing an entirely open, robust
PluginAPI interface, we channel the community's energy exactly where it belongs: building incredible, innovative, hyper-focused .so plugins!
6. The Sovereign Sandbox Shield
Under a traditional monolithic application design, if a poorly written addon mismanages memory or leaks file descriptors, it crashes the entire host process. Sloppy third-party developers routinely use this as an excuse to hide their bad coding behind the excuse of general application instability.
Because the core engine is completely untethered and shielded by a multi-threaded memory lock, it remains perfectly alive even if an extension collapses. If a third-party plugin stutters, leaks a handle, or hits a segmentation fault, Sovereign will instantly log the specific isolated library path, drop the broken .so file gracefully, and keep rendering the master telemetry layer without dropping a single frame. Bad code is exposed in real time, raising the standards of software quality across the ecosystem.
7. Dropping the Uncoordinated Chaos of Too Many Cooks in the Kitchen
Sovereign completely severs the hand-holding, standard utilities attempt to draw overlays by injecting code directly into a game's active graphics context or by asking the desktop compositor to force a window to stay on top. Under Wayland, both methods break constantly when switching workspaces or entering true fullscreen mode.
Operating as an independent layer Sovereign respects and registers itself directly and calculates its desktop positioning on the fly, allowing the compositor to draw our graphics card metrics on top of any active window space without ever requiring elevated root/sudo system privileges.
8. Beyond the Desktop: Scaling Sovereign from 720p Mobile Silicon to 32K Enterprise Workstations
A truly platform-agnostic engine cannot be hardcoded to specific hardware form factors. The modern Linux environment spans an immense range of form factors, from compact 720p handheld APU gaming systems to massive multi-display enterprise workstations running at extreme spatial scale.
Sovereign handles this through our native Dynamic Scale Evaluation Engine. Instead of rendering text metrics using fragile, fixed pixel grids that instantly shatter or shrink when resolutions shift, Sovereign passes real-time display topology maps straight into our specialised drawing routines. The layout adaptively expands and scales its orientation on the fly. Whether you are tuning a handheld display on a train or monitoring server nodes across a 32K studio display array, Sovereign'sOSDrenders with razor-sharp precision.
When can you see Sovereign in action? Soon. We will be doing a short demonstration video once we have activated and tested a few more features. In the meantime, take a look at the screenshots.