Systemd's Optional Rust Is the Core Rewrite Lie

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.

Related posts