Pull to refresh
Logo
Daily Brief
Following Why Ranks Sign Up
Linux kernel reaches version 7.0 with Rust now permanent and next-gen chip support

Linux kernel reaches version 7.0 with Rust now permanent and next-gen chip support

New Capabilities

The first major version bump since 2022 brings the end of the Rust experiment, hardware enablement for unreleased Intel and AMD processors, and an unusually large release candidate that has Linus Torvalds watching closely

March 9th, 2026: Linux 7.0-rc3 released with 'some of the biggest changes in recent history'

Overview

Linux kernel 7.0 is the first major version number change since 6.0 arrived in October 2022, and the software that quietly runs the majority of the world's servers, all 500 of the fastest supercomputers, and roughly 70% of the world's smartphones is getting two significant upgrades at once: the Rust programming language is now a permanent part of the kernel after a three-year experiment, and early support for Intel's Nova Lake and AMD's Zen 6 processors is being baked in before either chip has shipped.

Release Candidate 3, published on March 9, arrived unusually large — Linus Torvalds called it 'some of the biggest in recent history' — but the bulk of the extra code is an expanded self-test suite designed to catch regressions before the final release, expected in mid-April. The sheer volume of changes rather than any specific bug is what concerns Torvalds, who wrote that he hopes things 'calm down' in the coming weeks. For the billions of devices downstream — from cloud servers to Android phones — what happens in these release candidates determines the stability of the software layer everything else sits on.

Play on this story Voices Debate Who Said What? Predict

Key Indicators

~20
Minor versions per major bump
Linux consistently bumps the major version after roughly 20 minor releases, a pattern repeated from 4.x to 5.x to 6.x.
3 years
Length of Rust experiment
Rust entered the mainline kernel in version 6.1 in late 2022 and was declared permanent in December 2025.
~20%
RC3 patch devoted to self-tests
Almost a fifth of the RC3 changeset consists of new automated tests to catch regressions before the final release.
100%
Top 500 supercomputers running Linux
Every one of the world's 500 most powerful supercomputers runs the Linux kernel, a status held since 2017.

Interactive

Exploring all sides of a story is often best achieved with Play.

Ever wondered what historical figures would say about today's headlines?

Sign up to generate historical perspectives on this story.

Log in Sign Up

People Involved

Linus Torvalds
Linus Torvalds
Actively managing 7.0 release candidate cycle
 Miguel Ojeda
Miguel Ojeda
Overseeing Rust's transition from experimental to permanent kernel language

Organizations Involved

Linux Foundation
Linux Foundation
Nonprofit technology consortium
Provides organizational infrastructure for Linux kernel development

The Linux Foundation employs Linus Torvalds and provides infrastructure for kernel development, though code decisions remain with the kernel maintainer hierarchy.
Intel Corporation
Intel Corporation
Incumbent x86 chipmaker
Top corporate contributor to the Linux kernel by commit volume

Intel contributes more code to the Linux kernel than any other company, nearly double the volume of second-place Google, and Linux 7.0 includes early enablement for Intel's upcoming Nova Lake and Diamond Rapids processors.

Timeline

  1. Linux 7.0-rc3 released with 'some of the biggest changes in recent history'

    Release

    RC3 exceeded RC2 in size, though nearly a fifth of the patch consisted of new self-tests. Specific fixes included a slab performance regression, battery reporting for Apple's Magic Trackpad 2, and a ~1.5% network performance improvement on AMD Zen 2 processors.

  2. Linux 7.0-rc2 arrives larger than expected

    Release

    Torvalds said he was 'not super-happy' with the size of rc2, noting that drivers accounted for only 25% of changes — unusually low, meaning fixes were spread across more subsystems than typical.

  3. Linux 7.0-rc1 released after 'fairly smooth' merge window

    Release

    The first release candidate closed the merge window. Two-thirds of the new code was in drivers, including early support for Intel Nova Lake, AMD Zen 6, and RISC-V user-space Control-Flow Integrity.

  4. Torvalds confirms next kernel will be 7.0

    Decision

    Torvalds announced the version bump from 6.20 to 7.0, citing his running-out-of-fingers-and-toes reasoning. The two-week merge window for new features opened the same day.

  5. Linux 6.19 released as the final 6.x kernel

    Release

    The last kernel in the 6.x series shipped with a 300% improvement in certain TCP workloads, first fully Rust-written production drivers, and the new Live Update Orchestrator subsystem.

  6. Rust declared permanent in the Linux kernel

    Decision

    At the Kernel Maintainers Summit, maintainers agreed to drop the 'experimental' label from Rust support. Miguel Ojeda wrote: 'The experiment is done — Rust is here to stay.'

  7. First Rust-written drivers accepted in Linux 6.8

    Development

    The kernel accepted its first drivers written entirely in Rust, moving the language from infrastructure tooling to production components.

  8. Rust enters the mainline kernel in version 6.1

    Development

    Initial Rust support was merged as an explicit experiment to determine whether the language was technically and socially suitable for kernel development.

  9. Linux 6.0 released, setting a new major version baseline

    Release

    Torvalds bumped the version from 5.19 to 6.0 because minor numbers were getting unwieldy. No major architectural change accompanied the bump.

Scenarios

Predict which scenario wins. Contrarian picks score more — points lock in when the scenario resolves.

Log in to predict. Track your picks, climb the leaderboard. Log in Sign Up
1

Linux 7.0 ships on schedule in mid-April with no major regressions

The most likely outcome. The oversized release candidates reflect an expanded test suite rather than instability, and Torvalds himself noted nothing in the non-test portion of RC3 'looks particularly scary.' If the remaining release candidates shrink as expected, the final kernel ships around April 12-19, 2026, and lands in Ubuntu 26.04 LTS and Fedora 44 shortly after. This is the standard pattern — concerns about RC size have arisen in past cycles without delaying the final release.

Discussed by: Phoronix, Linux Journal, and kernel developers on the mailing list who note that the self-test expansion is specifically designed to prevent regressions
Consensus —
2

Release delayed past mid-April due to persistent regressions

If the sheer volume of changes produces hard-to-isolate regressions — particularly in the new hardware enablement code for unreleased Intel and AMD chips — Torvalds could extend the release candidate cycle to eight or more iterations. This has happened before: some kernel cycles have required up to eight RCs. A delay would push the final release to late April or early May, potentially complicating the timeline for Ubuntu 26.04 LTS, which typically ships with the latest kernel.

Discussed by: XDA Developers, which noted Torvalds' concern is about volume rather than specific bugs, and kernel development watchers who track the historical correlation between large RCs and extended cycles
Consensus —
3

Rust's permanent status accelerates new driver development in Rust

With the 'experimental' label removed, corporate contributors — particularly Google, which already ships Rust kernel code in Android — may accelerate Rust driver development. The barrier was never purely technical; many companies avoided writing kernel code in an 'experimental' language for liability and maintenance reasons. If the 7.x cycle sees a meaningful uptick in Rust-language kernel submissions, it could reshape how the kernel evolves over the next decade, gradually reducing the class of memory-safety bugs that account for a large share of kernel vulnerabilities.

Discussed by: The New Stack, Phoronix, and the Rust for Linux community, who point to Android's already shipping Rust kernel code in millions of devices
Consensus —
4

Rust adoption triggers maintainer friction in the 7.x series

The Rust integration has not been without social friction. Some veteran kernel maintainers have pushed back on being required to interact with Rust code in subsystems they maintain. If the removal of the 'experimental' label leads to Rust patches flowing into subsystems whose maintainers are unprepared or unwilling, it could produce bottlenecks or disputes that slow development. This tension played out in 2024-2025 and could resurface as Rust's footprint grows.

Discussed by: The Register, LWN.net, and kernel mailing list discussions where some long-time C maintainers have expressed reluctance about Rust's growing role
Consensus —

Historical Context

Linux 2.6 to 3.0 version bump (2011)

July 2011

What Happened

After eight years on the 2.6.x numbering scheme — reaching 2.6.39 — Linus Torvalds jumped the version number to 3.0 to coincide with Linux's 20th anniversary. The change was purely cosmetic: no major technical shift accompanied it. Kernel developers had to add a compatibility layer so that older programs expecting '2.6.x' in version strings would continue to work.

Outcome

Short Term

Some minor software breakage occurred where programs parsed the version number and couldn't handle a single-digit minor version. The compatibility shim resolved most issues within weeks.

Long Term

The bump established the precedent that major version numbers in Linux are arbitrary bookkeeping, not semantic markers. Every subsequent bump — 4.0, 5.0, 6.0, 7.0 — has followed the same pattern of resetting minor numbers when they get too large.

Why It's Relevant Today

Linux 7.0 follows the exact same playbook: Torvalds bumped the number after 19 minor releases because he was 'running out of fingers and toes,' not because of a fundamental architectural change. The consistent precedent means observers should not read significance into the number itself — but the features landing in this particular cycle, especially Rust permanence, are independently significant.

C++ proposal for the Linux kernel rejected (2004-2007)

2004-2007

What Happened

Multiple developers proposed adding C++ as a second language for Linux kernel development during the 2.6 era. Torvalds rejected the idea emphatically, calling C++ a 'horrible language' in a widely cited 2007 email. The proposals died without formal consideration, and the kernel remained C-only for another 15 years.

Outcome

Short Term

The C++ proposals were dropped entirely. Kernel development continued exclusively in C and assembly.

Long Term

The rejection reinforced a cultural norm that new languages face an extraordinarily high bar for kernel acceptance. It took Rust — with its formal memory-safety guarantees — three years of experimentation and production deployment on millions of Android devices to clear that bar.

Why It's Relevant Today

The successful conclusion of the Rust experiment is remarkable precisely because the kernel's track record with new languages has been one of categorical rejection. Rust succeeded where C++ failed by offering something C fundamentally cannot: compile-time prevention of the memory-safety bugs that account for a large share of kernel vulnerabilities.

Linux 6.0 release (2022)

October 2022

What Happened

Torvalds bumped the version from 5.19 to 6.0 after running through 20 minor releases in the 5.x series. He described it as 'one of the bigger releases in numbers of commits in a while,' with over 15,000 non-merge commits. That same cycle saw the initial groundwork for Rust integration, which would land two months later in 6.1.

Outcome

Short Term

The release shipped without incident. Distributions adopted it within their normal timelines.

Long Term

The 6.x series ran for 19 releases over three and a half years, producing the Rust experiment, live kernel update orchestration, and major filesystem improvements before yielding to 7.0.

Why It's Relevant Today

The 6.0-to-7.0 cycle mirrors the 5.0-to-6.0 cycle in duration and rationale. But where 6.0 was setting up the Rust experiment, 7.0 is concluding it — marking a genuine inflection point beneath the routine version arithmetic.

Sources

(13)
+7
Phoronix XDA Developers Linux Compatible The Register 9to5Linux OSTechNix Linux Journal Tom's Hardware Phoronix Phoronix Phoronix 9to5Linux Phoronix