Rust went from curiosity to convention across Linux land in 2025, and that has both engineers and end users rubbing their eyes. What started as cautious experimentation—writing new drivers or tiny utilities in Rust—morphed into a strategic push: parts of the upstream kernel embracing Rust, distributions shipping Rust-based system tools by default, and university researchers proposing whole new extension models in Rust. The result is cleaner, safer code in crucial places, but also a reminder that language changes don’t erase complexity overnight.
Memory safety finally gets more than lip service
For years the kernel community has talked about memory-safety improvements without changing the dominant language. In 2025, that conversation accelerated into action. The Linux kernel’s growing Rust footprint moved from experimental patches to permanent choices in driver and extension code — a deliberate attempt to reduce classic C mistakes like use-after-free and buffer overruns.
The practical wins are obvious: Rust’s ownership model and borrow checker catch whole classes of bugs at compile time, and that helps harden drivers and subsystems that interact with untrusted inputs. Distributions began shipping Rust implementations of previously C-based userland tools, and vendors leaned on Rust to make new Android drivers and desktop utilities less crash-prone.
But adoption hasn’t been frictionless. The disclosure of CVE-2025-68260 — the first notable Rust-related CVE in the kernel — triggered debate. To some it was a sign that Rust isn’t a silver bullet; to others it was validation that Rust surfaces issues earlier in review and audit processes. Either way, the incident underscored that safer languages reduce attack surface but don’t replace careful design, testing, and governance.
Ubuntu’s leap, and the stubborn fallout
Canonical’s experiments with Rust were among the most visible distribution-level moves. Ubuntu 25.10 pushed Rust-based system components into everyday use: a Rust reimplementation of sudo (sudo-rs) became the default on daily ISOs, and Canonical made serious bets on Rust Coreutils (the uutils project) and other memory-safe utilities.
That’s important: when a mainstream distro chooses Rust for core tooling, it accelerates real-world testing and drives upstream fixes. It also reveals compatibility and performance gaps quickly. Ubuntu 25.10’s rollout exposed issues that maintainers might not have seen in lab conditions: certain Makeself archives broke, unattended-upgrades failed because of a coreutils bug, and early Rust Coreutils builds lagged GNU Coreutils in some microbenchmarks. There were security notices around sudo-rs as well, proving that converting to Rust changes the failure modes rather than eliminating them.
Canonical’s approach has been pragmatic — provisionally shipping Rust tools but continuing to iterate — which is a sensible path. Distributions will gain if they shepherd these transitions carefully, keeping fallbacks, robust testing, and clear upgrade paths for users who depend on older behavior.
Rex vs eBPF: a new idea for safe, extensible kernel code
At the Linux Plumbers Conference 2025, researchers from Virginia Tech and UIUC presented Rex, a proposal for safe Rust kernel extensions that could play a role similar to eBPF. Where eBPF gives administrators the ability to run small, sandboxed programs inside the kernel, Rex aims to let people plug in Rust-written extensions with comparable safety guarantees but using Rust’s language-level checks.
Rex is still early-stage and hasn’t been submitted for mainline review, but it’s notable for a few reasons:
- It leans on Rust’s static safety to avoid whole classes of runtime memory issues.
- It envisions a lightweight runtime model with extra runtime protections layered atop Rust’s guarantees.
- It proposes a different ergonomics model from eBPF: not just sandboxed bytecode, but composable Rust modules that can be developed and audited with normal Rust tooling.
If Rex or something like it gains traction, it would broaden the mental model for kernel extensibility: administrators and vendors could choose between the well-established eBPF path or a Rust-native extension route. Each has trade-offs — eBPF’s maturity, verifier, and ecosystem versus Rust’s stronger type and borrow guarantees.
Real-world wins for gaming and graphics
The kernel’s memory and scheduler work this year didn’t just help servers — it improved the desktop and gaming stack too. Driver optimizations and better memory handling breathed new life into legacy AMD GPUs and tightened latency on graphics paths. That matters for handhelds and low‑power gaming devices: Valve’s Steam Deck inspired scheduler work that even Meta adopted for server-side efficiency, and handheld optimizations made Linux a smoother option for gamers.
If you care about gaming on Linux, these kernel improvements are the quiet upgrade you don’t always notice until a title runs cooler or battery life improves. Related platform improvements — including low‑power download modes for handhelds — make the whole experience more polished; for example, Valve’s small but welcome firmware and system tweaks have been rolled into workflows like the Steam Deck display-off download mode.
Those same kernel improvements feed into cloud and streaming tech: devices such as the PlayStation Portal getting major streaming updates benefit from lower-latency drivers and more predictable scheduling.
Security hardening: more knobs, not one switch
2025’s security story is mixed. Rust reduces certain classes of memory bugs, but defenders also added more tooling and policies: improved SELinux/AppArmor integration, signed and verified eBPF programs, and tightened subsystem fixes (for instance, the AF_VSOCK use-after-free patching cycle continued). The upshot: you get more mechanisms to defend systems, but you also need the right configuration and operational discipline.
For operators that want a stable target, long‑term support kernels and conservative distro choices remain sound: many organizations still prefer LTS kernels while the bleeding-edge Rust transitions mature.
What this means for users and maintainers
If you’re a sysadmin or distro maintainer: expect faster detection of bugs in code that’s been rewritten in Rust, but also prepare for compatibility testing. Tools that historically behaved one way may behave slightly differently when reimplemented—so add regression suites to deployments and keep recovery paths.
If you’re a developer: learning Rust for kernel or systems work is a good investment. The ecosystem is evolving quickly; contributing to libraries, tooling, and safety reviews influences how seamless these transitions become.
If you’re an end user: you won’t have to rewrite your workflows, but you may see smoother updates, fewer crashes, and, with time, fewer exploitable memory bugs. Distributions experimenting with Rust will iron out rough edges; that’s already underway.
Why the fuss isn’t over
Switching languages in a decades-old, safety-critical codebase is more cultural and infrastructural than purely technical. Rust helps, but it brings new maintenance demands: cross-language toolchains, build-time complexity, and the need for Rust-aware auditing and fuzzing. The lessons of 2025 are practical: Rust moves the needle on safety and empowers new designs (Rex is a great example), yet shipping robust, compatible systems remains painstaking work.
Expect more hybrid stacks in 2026: kernels where C and Rust coexist, distros that ship Rust utilities with fallbacks while upstream projects mature, and extension ecosystems that let administrators choose the right tool for the job.
If you want to follow one tangible thread from this year: experimental ideas shown at conferences (like Rex) and distribution-level choices (like Ubuntu shipping sudo-rs and Rust Coreutils) are nudging the whole Linux ecosystem toward a safer future — but not without the messy, sometimes public debugging that accompanies meaningful change.
PlayStation 5 Pro enthusiasts take note: hardware and kernel improvements make consoles and PC gaming closer allies than ever; if you’re tracking hardware, the new PlayStation 5 Pro listings on Amazon reflect how the ecosystem’s improvements feed into consumer devices. (Shop at your discretion.)
The migration is ongoing. The code is safer in many places. The work continues.