Linux 7.0 and Rust: the new leap for the Linux kernel

Linux 7.0 has become a major player in the software world, not only because of the kernel version change, but also because it marks a turning point in how the core of the world's most influential operating system is developed and secured. What at first glance seems like a simple version upgrade actually encapsulates years of debates, testing, patches, and technical decisions that affect servers, mobile devices, supercomputers, and even small home devices.

Beyond the buzz surrounding the version number, the truly important aspect of Linux 7.0 is the integration of Rust into the kernel , the formal end of the "experimental" phase, and the beginning of a new era in which this programming language becomes a stable and strategic component. All of this is accompanied by a series of improvements in performance, security, support for modern hardware, and energy efficiency, suggesting that this release will mark a turning point in the history of Linux.

What is Linux 7.0 really and why now?

When we talk about Linux 7.0, we're not referring to a specific distribution, but to the kernel , the core that allows your computer's hardware to communicate with the software. It's the "engine" that enables the CPU, RAM, storage, and GPU to work together with the operating system and applications.

Historically, Linus Torvalds has changed the kernel's main version number more for practical reasons than for marketing . When the number of minor versions becomes unwieldy or when many structural changes accumulate, he decides to "reset" the counter and increase it by one digit, something he often explains with his peculiar "fingers and toes" rule.

In this case, the jump to the 7.x series comes after the release of Linux 6.19 , a version packed with new features in graphics support, networking, and the first Rust integrations. The new numbering doesn't imply a complete revolution in a single leap , but it does mark the beginning of a cycle in which trends that have been developing for years are consolidated: internal modernization, cleaning up legacy code, and a total focus on security.

Linux 7.0 is currently in the Release Candidate (RC) phase , with RC1 already available for download and testing. This means that development has entered a stage where major new features are no longer being introduced, and the focus is on stability, bug fixes, and fine-tuning performance before the stable release.

The usual kernel development cycle forecast indicates that the stable version of Linux 7.0 should arrive in about 7 or 8 weeks from RC1 , placing its release around April 2026. As always, the schedule may change if the developers detect serious problems that require extending testing.

Current status: RC1 available and installation recommendations

With the release of Linux 7.0 Release Candidate 1 (linux-7.0-rc1) , any advanced user, developer, or simply curious person looking to experiment can download the code and try out the new kernel. This is a crucial phase in which the community reports bugs, compatibility issues, and regressions so that the maintainers can refine the final version.

This RC comes two weeks after the release of Linux 6.19, a release that already introduced better support for AMD graphics cards, improvements to IPv6, new drivers for brands like ASUS and Tuxedo , and more initial Rust integration. With 7.0-rc1, the version number jumps, and Linux enters a tuning phase focused on robustness and performance.

However, installing Linux 7.0 RC1 on your main computer is far from recommended . This is a development version, intended for testing, which may contain serious bugs, security vulnerabilities, unexpected crashes, and all sorts of strange behavior. The community itself strongly recommends using test machines, secondary computers, or virtual machines with tools like VirtualBox, VMware, or GNOME Box.

The RC1 kernel can be obtained directly from the official kernel repositories, for example by downloading the linux-7.0-rc1 tarball from kernel.org or cloning the Git repository at git.kernel.org. Once downloaded, you can compile the kernel manually or use specific utilities that simplify the process on distributions like Ubuntu.

If you choose the classic manual compilation method, the typical flow involves unpacking the package, configuring the kernel with `make menuconfig` , installing compilation dependencies (`build-essential`, `libncurses`, `libssl`, tools such as `bc`, `bison`, `flex`, `libelf`, etc.), and downloading, configuring and compiling the kernel with `make -j$(nproc)` and finally installing modules and the kernel with the classic `make modules_install` and `make install` commands executed with administrator privileges.

In the Ubuntu ecosystem and its derivatives, many users prefer to use the "mainline" tool to install new kernels without struggling with numerous commands . After adding the corresponding PPA, updating repositories, and installing it, this utility allows you to select Linux 7.0-rc1 from a more user-friendly interface, download it, and integrate it into the system to test it upon reboot.

For future release candidates (rc2, rc3, etc.), the procedure will be very similar: download the new release and compile it, or use the mainline version . The idea is that these intermediate versions will fix bugs, polish patches, and prepare the stable version that will later be adopted by the reference distributions.

Key technical updates in Linux 7.0

Although Linus Torvalds has warned that Linux 7.0 is not intended to be a complete revolution in a single leap , it does come loaded with significant changes for users and system administrators. The main focus is on robustness, security, cleaning up legacy code, and better support for next-generation hardware.

In terms of overall performance, version 7.0 brings internal optimizations across multiple architectures , allowing for better utilization of desktop and server processors as well as modern ARM platforms. For example, it enables support for 64-byte payloads on ARM CPUs, improving efficiency in certain input/output and communication operations.

One of the areas that has received the most attention is memory. The new RAM management patches allow memory to be freed up to 75% faster on ARM64 and more than 50% faster on x86 architectures. This translates into more agile systems, less downtime for page reclaims, and improved performance under heavy load or in intensive virtualization scenarios.

Significant progress has also been made in key subsystems for professional performance. Direct I/O support has been expanded in file systems such as Btrfs , details in NTFS have been refined, and SSD behavior has been adjusted to reduce latency and improve disk durability.

In terms of compatibility, Linux 7.0 reinforces its commitment to the latest hardware . It arrives with specific improvements for Intel Nova Lake and Diamond Rapids processors, extended support for AMD Zen 6, and updates for SoCs like the Qualcomm Snapdragon X2. On the graphics front, it includes expanded support for next-generation GPUs, with specific mentions of AMD GFX 12.1, Intel Nova Lake, and Intel Battlemage, laying the groundwork for cutting-edge drivers to work better from day one.

In addition, the kernel introduces a feature called OpenTree namespace , designed to enhance security and performance in container environments like Docker and Kubernetes. These types of changes, while less visible to the end user, are fundamental in servers and cloud platforms, where Linux remains the undisputed king.

In terms of traditional security, Linux 7.0 removes support for module signing with the SHA-1 algorithm , which is now considered obsolete and vulnerable. This reduces the attack surface and forces the use of more robust cryptographic methods when signing kernel modules, a crucial factor for enterprise and mission-critical environments.

The silent revolution: AI, NPU and better battery life

One of the most interesting aspects of Linux 7.0 is the work done on accelerating artificial intelligence tasks and using NPUs (Neural Processing Units) . Until recently, most of these workloads fell on CPUs or GPUs, which aren't always the most efficient for neural networks and AI models.

Modern processors from Intel (Core Ultra), AMD (Ryzen AI), and Apple chips with M3 or M4 architecture integrate dedicated NPUs to accelerate AI inference with very low power consumption . Linux 7.0 incorporates a revamped acceleration subsystem that allows the kernel to communicate with these units more directly and efficiently.

Thanks to these improvements, AI tasks can consume up to 80% less power by running on the NPU instead of the CPU, which has a huge impact on laptops and mobile devices. The practical result is that more applications will be able to perform intelligent processing locally, without constantly sending data to the cloud, with the resulting benefits in privacy and latency.

Power management also receives a significant boost beyond AI. The kernel scheduler has been refined to better leverage hybrid architectures that combine high-performance and high-efficiency kernels. Linux 7.0 is smarter at deciding which tasks go to which kernel type, reducing power consumption without compromising system responsiveness.

Furthermore, the CPU's sleep states and the logic by which the kernel "puts parts of the processor to sleep" when they are not under heavy use have been improved. This includes micro-pauses between keystrokes or short periods of inactivity, where previously the chip remained partially active unnecessarily. In practical terms: laptops that last longer without being plugged in and generate less unnecessary heat.

Clean up legacy code and end nostalgia

One of Linux's traditional strengths has been its ability to run on virtually any machine, from 90s hardware to state-of-the-art servers . However, this backward compatibility comes at a cost: tons of code that is now rarely used, difficult to maintain, and can become a source of errors and vulnerabilities.

With the 7.0 series, Linus Torvalds and the rest of the maintainers have pressed the "clean-up" button . Support has been dropped for clearly obsolete architectures and chipsets, as well as drivers for devices that ceased production decades ago. A striking example has been the definitive end of support for certain classic chipsets from the late 90s, which were maintained for a long time purely out of inertia and nostalgia.

This cleanup isn't a nostalgic gesture, but a necessary step for the kernel to move forward with lighter, more understandable, and easier-to-audit code . Less old code means fewer blind spots where security vulnerabilities can creep in and less effort spent testing scenarios that are no longer practical.

At the same time, a general optimization and cleanup of internal subsystems has been carried out , removing duplicate functionalities, dead code paths, and configurations that only complicated the developers' lives. All of this has been done without sacrificing Linux's ability to run on a huge variety of devices, but focusing on what is still truly used.

The result is that Linux 7.0 is better prepared to focus on current hardware and that which will arrive in the coming years , without dragging along burdens from the past that hindered the introduction of new technologies or made it difficult to integrate profound changes such as the arrival of Rust to the kernel.

Rust makes a grand entrance into the Linux kernel

For more than three decades, the Linux kernel has been written almost entirely in C , a powerful language, very close to the hardware and extremely flexible, but also known for its tendency to allow dangerous memory errors: buffer overflows, use of already freed memory, dangling pointers and a long etcetera.

These types of flaws are not a mere annoyance: approximately 70% of serious security vulnerabilities are related to memory errors . Large companies like Google and Microsoft have been pushing for years to reduce this risk, since a critical part of their infrastructure depends on the Linux kernel, from cloud servers to millions of Android devices.

About three years ago, the first patches were integrated to allow the Linux kernel to be written in Rust , a modern language designed precisely to avoid memory errors thanks to its ownership and borrowing system. Since then, Rust has gained popularity among developers for its balance between native performance and security, and has established itself as one of the most highly regarded languages ​​in the community.

After this testing period, Linux 7.0 delivered a resounding message: “the experiment is over, Rust is here to stay .” A recent patch, signed by Spanish engineer Miguel Ojeda—the main driving force behind Rust for Linux—updates the kernel documentation to make it clear that this is no longer an experimental feature, but a firm commitment for the future.

This same change also introduces the "__rust_helper" annotation, designed to improve kernel compilations in Rust when using Link Time Optimization (LTO) , resulting in more optimized and consistent binaries. Furthermore, the kernel-specific crates (libraries) have been expanded and refined, albeit without sweeping changes, but rather through continuous and pragmatic progress.

It's important to emphasize that no one is going to erase the millions of lines of C code that currently make up the kernel overnight . That code works, it's stable, and it's thoroughly tested, so there's no point in touching it unless there's a compelling reason. The strategy adopted is that, from now on, all new features that can reasonably be written in Rust will preferably be developed in that language.

The underlying idea is twofold: to reduce the number of memory vulnerabilities in the future and to send a clear signal to companies and organizations (see disadvantages and challenges of using Rust in the kernel ) to invest in Rust, both in training their developers and in tools. Miguel Ojeda himself has emphasized that he hopes this move will encourage companies and entities to dedicate work time to teaching their staff Rust in the context of the kernel.

Who is behind Rust for Linux and what does it mean for the ecosystem?

Miguel Ojeda 's leadership as the lead maintainer of Rust for Linux is one of the cornerstones of this change. He is currently the project's sole official maintainer, supported by reviewers who collaborate on patch reviews and integration with the rest of the kernel tree.

In the past, other prominent names such as Wedson Almeida Filho and Alex Gaynor were part of the core driving group, but both have left that role in recent years, which makes Ojeda's work and the support he receives from the wider kernel developer community even more relevant.

The message conveyed by this "graduation" of Rust into the kernel is also a call to the enterprise ecosystem. Giants like Google, Meta, Microsoft, ARM, AWS, and Huawei are part of the Rust Foundation and have long been committed to this language in high-performance projects, critical infrastructure, and embedded systems.

In areas such as Python extension packaging, Rust has already surpassed C in new native projects uploaded to PyPI . It is estimated that between a quarter and a third of all new native code in that ecosystem is written in Rust, which gives an idea of ​​the extent to which it has taken hold among developers and companies.

For many programmers, Rust combines efficiency, speed, and flexibility thanks to its extensive ecosystem of libraries , and together with Python it has become a very popular duo: Python for speed of development and Rust for the low-level parts that require maximum performance and security.

With Linux 7.0 publicly stating that Rust is no longer an experiment, the perception is growing that this language could become the most important for systems development in the coming years . It won't replace C overnight, but it is carving out a structural niche in one of the most critical software projects in history.

Linux 7.0 vs. Windows: performance, gaming, and the usability challenge

The age-old joke that “ this will be the year of Linux on the desktop ” has been circulating for decades, but the work being done on kernel 7.0 has reignited the debate. Not so much because it's trendy, but because the accumulated improvements in performance, graphics, and hardware compatibility bring the user experience even closer to what Windows offers… and even surpass it in several areas.

In tests on identical hardware, Linux 7.0 is able to outperform Windows 11 in certain productivity tasks , thanks to more refined process management, smarter kernel utilization, and a highly optimized storage stack. This doesn't mean it will be the case in every scenario, but the gap has narrowed dramatically.

Where the change surprises many is in the gaming field. Kernel improvements in file systems, memory management, and GPU support , combined with the work of projects like Proton and Wine, mean that more and more Windows games run just as well, or even better, on Linux.

Cases like the Steam Deck demonstrate this: the Proton-based compatibility layer flies on top of a finely tuned kernel , and Linux 7.0 comes precisely to reinforce that scenario, with better support for next-generation GPUs and optimizations in memory management and drivers.

However, Linux's biggest challenge on the desktop isn't technical, but rather user experience. To compete head-to-head with Windows, Linux needs to be simple and user-friendly for non-technical users , without sacrificing the flexibility and deep control that enthusiasts and professionals appreciate.

There is a risk of "dying of success": the more popular Linux becomes, the more it will have to refine its usability, and that sometimes forces decisions that make purists uncomfortable . The challenge of the 7.0 kernel era is to demonstrate that it's possible to offer a usable system for the average user, ready for AI, gaming, and daily work, without abandoning the open-source philosophy and the enormous customization capabilities that have defined it since its inception.

With everything being integrated into Linux 7.0—from Rust to NPU support, including the cleanup of legacy code and improved security— this version is shaping up to be a turning point in the history of the kernel . While the version number alone won't make it magical, the combination of technical changes, design decisions, and backing from tech giants is positioning Linux to dominate not only servers and cloud environments, but also laptops, desktops, and devices where Windows was the undisputed king until recently.