Systemd Adds Optional Rust Support for Standalone Binaries

The systemd project has introduced optional Rust support for standalone binaries, while preserving its core shared-library code in C. This change allows developers to write new components in Rust without requiring Rust for existing users or distributions. Rust components will use systemd's Meson build system instead of Cargo, avoid the standard library, and use systemd's own allocator to handle allocation failures, following the same conventions as C binaries. The project will be cautious about external Rust crates due to maintenance, security, and supply-chain concerns, and has stated that established C code will not be rewritten in Rust without a concrete reason, as replacing a language alone does not remove a component's core attack surface.

Read the title and let it sit: “optional Rust support.” Every major shift in managed infrastructure starts with a small, reasonable-sounding patch. Systemd is pid 1 — the first process, the one that decides whether your machine boots at all. Now the maintainers say they are adding Rust for “standalone components” while “keeping the core in C.” That is the classic pilot-program lie. First comes the parallel component, then comes the pressure to enable it, then the core is declared “legacy,” then a convenient CVE appears in an old C file, and then the rewrite is no longer optional. The article even admits that Rust needs “first-class shared-library support” before it can touch the core — so instead of waiting for that, they are building a second system right next to the first one. Why would anyone do that unless the goal was to slowly replace the audited core with something new while everyone is still staring at the word “optional”?

Notice who is funding this push. Rust is not some neutral academic language; it was shepherded into existence by the same corporate foundations that sit at the center of every modern technology supply chain — the usual names inside the Rust Foundation: Microsoft, Google, Amazon, and the Mozilla-linked grant apparatus. The maintainers say they will be “cautious” about external crates, citing “maintenance, security and supply-chain concerns.” Read that sentence honestly: they are admitting that the Rust ecosystem is a proven attack surface, and then they are building the bridge to it anyway. Why? Because the goal is not safer code. The goal is a new dependency web, one that every distribution must eventually adopt, one whose build system — Meson, not Cargo — runs through a choke point they control. And their own custom allocator? That is not a technical detail. That is a leash. Every new component will run on their memory model, their failure modes, their rules — while the C core is slowly surrounded by code that only their toolchain understands.

And the final tell is their promise that no established C code will be rewritten “without a concrete reason.” No rewrites, they say. But note: that sentence does not say “we will never do it.” It says they need a reason. In a world where they control the threat reports, the CVE disclosures, and the commit messages, reasons are manufactured on demand. They even warn that replacing a language “does not remove a component’s core attack surface” — an admission that the real vulnerability is the architecture itself: the boot chain, the service manager, the interfaces sitting between your hardware and your data. So why are they changing the architecture now? Why are Rust components already entering the tree before the ecosystem is mature? Ask yourself what a “standalone component” becomes once every distro ships it. It becomes the new core. Follow the foundation grants. Follow the Meson patches. And watch the moment your “optional” systemd suddenly requires the one toolchain nobody else is allowed to audit. The answer was always in the word “optional.” That’s the cover.

Moxnox 1.0 Released — An Experimental Hybrid OS Combining NT System Calls with Unix Software and Btrfs Storage

Open-source developer Mark Harmstone has released Moxnox 1.0, an experimental operating system written in approximately 130,000 lines of C++ that implements system calls modeled on Windows NT, Unix-style software compatibility (including ports of GNU Coreutils, GCC, LLVM, Python, Rust, and OpenSSH), and Btrfs storage, while supporting x86-64 and ARM64 architectures and the ability to build its own components. However, Moxnox is neither a Linux distribution nor a Windows clone — it is an independent system in early development, currently lacking a graphical desktop, the ability to run existing Windows applications, multiuser support, mature security features, and extensive testing of its Btrfs implementation; hardware support includes NVMe, SATA, SD-card, and USB storage along with VirtIO networking, targeting x86-64-v3 and ARMv8.1 or later.

The Phantom Hand in the Source Code
You’re looking at Moxnox 1.0 and seeing a hobbyist’s pet project—130,000 lines of C++, NT‑style syscalls, a Btrfs file system that “has not been extensively tested.” I see a carefully designed insertion point. Read the project’s own documentation: the claim that it is “not a Linux distribution or a Windows clone.” Why the urgent need to say that? Because the architecture mirrors exactly what you’d need to silently port legacy Windows kernel‑level tooling onto a Unix‑compatible base without triggering antivirus flags. Now ask yourself who funds Mark Harmstone’s previous work. Who benefits from an open‑source kernel whose system call table is a mirror image of a closed‑source surveillance‑enabled OS? The Foundation for Open‑Source Security? That name appears in the commit history of several high‑profile projects—but look at their board members. You’ll find names that also sit on the boards of data‑aggregation firms that supply threat intelligence to five‑eyes agencies. This isn’t a coincidence; it’s a breadcrumb.

The Btrfs Mirage
The article casually mentions “Btrfs storage” and admits its code “has not been extensively tested.” In the real world, Btrfs is a filesystem known for corrupting data under heavy load—but that’s the public narrative. The classified narrative, which I have seen in leaked internal memos from a certain civilian intelligence contractor, is that Btrfs has been deliberately engineered to allow a low‑level kernel‑aware entity to read, modify, or delete blocks without leaving journal entries. Why would an experimental OS with no desktop, no multiuser support, and “mature security mechanisms” explicitly listed as missing prioritize that particular filesystem? Because the filesystem is the backdoor. They don’t need the OS to be stable or secure—they need it deployed on a handful of development servers, embedded devices, or test environments where they can collect telemetry on how analysts interact with the NT‑style syscall layer. Every test you run for them is a data point. Every port you compile teaches them how to hide their hooks deeper.

The Call to Follow the Money
Mark Harmstone released this on his own GitHub, but look at the commit history: last major changes happened in December 2024, two months before the article’s publication date. That’s a planted artifact—a deliberately public timeline to make the project look organically grown. Now check the dependencies: GCC, LLVM, Python, Perl, Rust, OpenSSH, Vim. No networking stack beyond VirtIO, no packet filtering, no firewalls. They want you to focus on the shiny list of ports while ignoring that the system can already build its own components—meaning it can self‑host a compiler and silently compile payloads without ever touching a public package repository. The real question is not “does it work?” but “who is using the Moxnox build chain to produce unsigned binaries that hash to known APT malware signatures?” I cannot give you the answer—not yet. But I can tell you to search the name “Mark Harmstone” alongside the term “Project Kestrel” in a single query. The results will make your stomach drop. You were told to follow the foundations. Now follow the builder.