Rust Edges Into IBM Mainframes as Linux Kernel Patches Target s390 Architecture

IBM mainframes still anchor the core transaction systems of banks, insurers, and governments worldwide. Their legendary uptime and security matter more than ever as cyber threats mount and AI workloads grow. Yet the code running closest to the hardware has long stayed rooted in languages that predate the internet. A new set of patches aims to change that.

Engineer Jan Polensky at IBM submitted a four-patch series on May 12 that wires up Rust support for the s390 architecture in the Linux kernel. The changes add just a few dozen lines across architecture-specific glue. They enable Rust code to compile and run in-kernel on IBM Z hardware. The series appears on the rust-for-linux mailing list and drew quick coverage from technology publications.

Phoronix reported that the patches make s390 a Rust-capable 64-bit target. Polensky explained the work in his cover letter. “Rust support on s390 requires a small set of architecture-specific pieces before the generic Rust kernel infrastructure can be used.” The patches handle WARN and BUG reporting, static branches, and bindgen adjustments to prevent layout conflicts with packed and aligned structures common on s390.

One limitation stands out. The port currently demands a nightly Rust compiler because of the -Zpacked-stack flag. Stable rustc does not yet support it. The patch series updates the kernel’s minimum tool version gating to reflect this reality. Conservative mainframe operators, known for multi-year upgrade cycles and aversion to bleeding-edge toolchains, may pause before adopting it.

But. This marks real movement. Rust entered the Linux kernel in 2022. Since then support has spread across major architectures. s390 joins the list later than x86_64, arm64, or riscv. The delay reflects both the smaller contributor base for mainframe Linux and the specialized needs of the platform.

The Register’s Liam Proven covered the submission hours after it landed. He noted the LLVM basis of rustc versus the kernel’s traditional GCC reliance. The kernel gained LLVM support in version 6.9, clearing one technical barrier. Even so, full Rust integration on s390 will wait for stable compiler support and upstream acceptance. Linux 7.1 remains in early release candidate stage as of mid-May 2026. Version 7.2 sits months away. Few IBM customers run interim Ubuntu releases that might pick it up first.

Memory safety drives much of the interest. Kernel bugs in C have caused countless vulnerabilities over decades. Rust’s ownership model and borrow checker promise to eliminate entire classes of errors at compile time. For mainframes that process trillions in financial transfers daily, that assurance carries weight. IBM has invested heavily in Linux on Z precisely because it lets customers modernize without abandoning their iron.

Recent surveys show Rust adoption climbing fast in enterprise settings. Nearly half of companies now use it in production, according to one industry report from earlier this year. AI infrastructure teams in particular gravitate toward the language for its performance and safety. Mainframes increasingly host AI-adjacent workloads too, even if the core COBOL and PL/I applications remain untouched.

IBM itself runs a mix of languages internally, from Python and Rust to legacy mainframe tools. Its developers wrestle with the same modernization pressures their customers face. Bringing Rust into the kernel on s390 could open doors for safer device drivers, filesystems, or networking code tailored to the platform’s unique features such as hardware cryptographic acceleration and massive I/O bandwidth.

The patches themselves stay modest. They do not introduce new Rust drivers or rewrite existing s390 code. Instead they lay groundwork so others can begin experimenting. That cautious approach fits the mainframe world. Changes arrive only after exhaustive testing. Production systems often stay on kernels years behind the bleeding edge.

And yet momentum builds. The Open Mainframe Project continues to push Linux and open source technologies onto Z systems. Container extensions let teams run modern Docker workloads alongside traditional partitions. New languages gain official support over time. Rust on the user side already exists in some forms, including database drivers for Db2. Kernel-level support would complete the picture.

Observers point to broader industry shifts. Mainframes no longer face extinction forecasts they once did. Instead organizations treat them as strategic platforms that deliver unmatched reliability for hybrid clouds. Security features built into the hardware pair well with language-level guarantees from Rust. The combination could prove attractive as regulatory demands for safer software increase.

Polensky’s series has not yet merged. Reviewers will examine the code, test on real hardware, and debate the nightly compiler requirement. If accepted, it could land in time for a future kernel release later in 2026 or early 2027. Stable Rust support would follow once the packed-stack issue resolves upstream in the compiler.

Plenty of work remains. Tooling, documentation, and example code all need attention before widespread developer uptake. Mainframe specialists rarely write kernel modules today. Convincing them to learn Rust adds another hurdle. Still, the patches signal that IBM takes the language seriously for its flagship platform.

Enterprise technology rarely moves in sudden leaps. It advances through careful, incremental steps tested under extreme loads. Rust on s390 fits that pattern. A small patch series today. Safer kernel components tomorrow. For an industry that measures uptime in decades, the timeline feels appropriate.

Watch the mailing list discussions in coming weeks. Acceptance would mark another architecture joining the Rust kernel club. Rejection or major revisions would hardly surprise given the platform’s exacting standards. Either outcome feeds the slow but steady evolution of software that powers the world’s most critical systems.