Linux kernel updates aren't always the most exciting. They happen all the time, and a lot of the changes they make are either exactly what you'd expect or small updates a lot of people wouldn't notice. But with the recent release of Linux kernel version 6.19, Linus Torvalds — the lead maintainer of the Linux kernel — has announced the next update will be version 7.0, and it's looking like a big one.

Not that this has any connection with the version number. For the past few iterations, the Linux versioning scheme has capped out at x.19 purely for pragmatic reasons. But even if the number alone doesn't mean much, there's quite a bit to be excited about with this update.

Rust in the kernel

More security is always good to have

The adoption of Rust in the Linux kernel has been ongoing for quite some time, first appearing in the mainline kernel in version 6.1, over three years ago. And it was almost on the third anniversary of that release that the Linux kernel developers decided that Rust support in the Linux kernel is no longer experimental, meaning it's a core technology to be supported by the kernel. This happened during the Maintainers Summit in December 2025, just before the merge window for Linux kernel version 6.19. At the same time, a lot of improvements to Rust support happened with that release, but Rust support is still considered experimental for that version.

However, Linux 7.0 is the first full merge window to take place after Rust has been considered a core part of the Linux kernel, so you can expect even more changes coming soon. While it's still early to say everything that will be merged into the Linux 7.0 kernel, the fact that it's an official part of the Linux kernel means we can count on more elements of the kernel transitioning to Rust, which comes with big benefits in regards to memory safety.

The C language that's currently prominent in the Linux kernel (and a lot of other software) is at the root of a lot of attacks and exploits due to how it handles memory management. A great example is this "use-after-free" vulnerability that could cause the Linux kernel to crash in some situations, but also potentially expose a method for privilege escalation to an attacker. Rust addresses a lot of problems in C's memory handling, from automatically checking memory bounds to prevent overflowing, eliminating undefined behaviors resulting from null pointers, and better error handling. This means you get more security and stability, but Rust still manages to be almost as efficient, so performance shouldn't be impacted.

To be clear, Rust isn't entirely replacing C anytime soon, but the gradual transition will lead to more and more improvements to the user experience.

Updates to the scheduler

Time slice extensions are finally here

Linux 7.0 also comes with some big scheduler updates that promise an improvement performance and reliability. A big change is the long-awaited merging of time slice extensions, which have been in the works for nearly a decade. As noted by Phoronix, time slice extensions allow a user-space process to request a "temporary, opportunistic extension of their CPU time slice" that can't be preempted.

This is specifically used when a thread enters a critical section so it can avoid contending with another thread when trying to use a resource, which could cause the critical thread to hang and result in serious errors. The result should be more reliability during critical processes.

The scheduler is getting other updates, including limiting the preemption modes to either "lazy" or "full" on most modern architectures, removing the options for "voluntary" or "none". Plus, there are some improvements to performance and scalability of some CPU workloads, among others.

Those aren't the only performance improvements you can expect, either. Some improvements are being made to how IO-uring manages pending read and write requests in IOPOLL, replacing the singly linked list with a doubly linked list that results in more IO operations being completed more quickly since operations are no longer deferred to wait for others to complete if there's no reason for that delay to occur.

Container workloads get better, too

OPEN_TREE_NAMESPACE removes a lot of redundant work

Container workloads are very common for Linux users in all kinds of settings, and those workloads are getting a big improvement with the implementation of a new flag called OPEN_TREE_NAMESPACE, which is to be implemented in the open_tree() system call.

As explained when the patch was submitted back in December, the current process of creating a container happens as follows:

When creating containers the setup usually involves using CLONE_NEWNS via clone3() or unshare(). This copies the caller's complete mount namespace. The runtime will also assemble a new rootfs and then usepivot_root() to switch the old mount tree with the new rootfs. Afterward it will recursively umount the old mount tree thereby getting rid of all mounts.

That's a very technical way of saying that this process wastes a ton of time and resources. Even on a system with a relatively small mount table, this results in a very large number of mounts being copied, and the problem just gets worse the larger the mount space gets. A test shared in the discussion of this the same submission showed a roughly 40% increase in performance when creating containers while using fewer system calls.

For containerized workloads, this should be a huge improvement, and again, that's a very common use case on Linux.

And of course, new hardware support

Including some weird things

Of course, a new kernel release also means support fort some new hardware, lining up with the latest releases from Intel and AMD. You can expect improved support for new GPUs (including integrated graphics) from both companies, and even Nvidia's GPUs should get some nice improvements. Notably, this kernel update will also add proper display support for the GPU in the Qualcomm Snapdragon 8 Elite Gen 5 chipset for smartphones.

Maybe the most notable addition in terms of hardware support, though, has to do with... guitars, somehow. Well, fake guitars, but still. As previously reported, Linux 7.0 adds native support for the guitar controllers used in Rock Band 4 for the PlayStation 4 and 5 when connected with the appropriate dongles. It's hard to imagine what you might be able to do with this, but it's possible some music production software and games would have a use for it.

Linux 7.0 is a big release

Even if the number doesn't mean much, the Linux 7.0 release is looking like a pretty big one for the platform. This kind of continuous improvement is what makes Linux so exciting to follow, whether you're a desktop user or you rely on Linux for servers and other devices.

We only called out some of the highlights, but there are many other improvements on the way, including a new improvement to the XFS file system that allows it to automatically detect and fix file system errors without requiring a reboot.