Linux kernel reaches version 7.0 with Rust now permanent and next-gen chip support
New Capabilities
The first major version bump since 2022 made Rust permanent and added early hardware support. The 7.x series has since grown into record-sized development cycles, with AI-assisted fixes now a visible part of the work.
Linux 7.0 was the first major version number change since 6.0 in October 2022. It runs on most of the world's servers and all 500 of the fastest supercomputers. Rust, a memory-safe programming language, became a permanent part of the kernel after a three-year experiment.
The 7.x series has kept growing. In August, Linus Torvalds called the 7.2 release candidates unusually large and said AI-assisted fixes are now the 'new normal.' In October, he used Claude Code, an AI coding tool, to rework a locking mechanism. Stable updates released October 30 carried 'Assisted-by: Claude' credits. On November 1, Slashdot reported that the 7.4 merge window was the busiest on record, with 19,671 commits.
Questions about this story
Free account needed to ask — your question is kept and asked for you right after sign-up. Answers are public.
No questions yet — be the first to ask.
Key Indicators
19,671
Commits in the 7.4 merge window
Slashdot's report, summarizing Phoronix, says this is the busiest merge window on record by Git commit count. Typical windows once held 13,000 to 14,000 commits.
14 events
Latest: November 1st, 2026 · 1 week ago
Showing 8 of 14
JK to step
Tap a bar to jump to that date
Jump to
November 2026
Slashdot reports record 7.4 merge window
LatestDevelopment
Slashdot, summarizing Phoronix, reported 19,671 commits in the 7.4 merge window, ahead of 7.4-rc1. Maintainers have described being overwhelmed by AI-generated reports and patches. Slashdot did not check the count independently.
October 2026
Seven stable kernels released together
Release
Greg Kroah-Hartman released 7.2.14, 6.18.60, 6.12.115, 6.6.161, 6.1.191, 5.15.224 and 5.10.273. Changelogs carried 'Assisted-by: Claude' and Codex credits.
Torvalds uses Claude Code on a kernel locking change
Development
Torvalds used Claude Code to find that Read-Copy-Update, a lockless synchronization method, would outperform the existing reference-counting approach. Linux Magazine reported the work on a new branch in his main repository.
August 2026
Torvalds calls 7.2-rc6 'huge'
Release
Torvalds said the sixth 7.2 release candidate was the biggest rc6 in years by commit count, calling it the 'new normal.'
7.2-rc7 released with a large set of fixes
Release
Torvalds wrote that he was not 'exactly thrilled' by the size, but would not delay the release. Most changes were small fixes, with three larger ones in s390 crypto, btrfs and netfilter.
March 2026
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.
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.
February 2026
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.
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.
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.
December 2025
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.'
March 2024
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.
December 2022
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.
October 2022
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
1
Linux 7.0 ships on schedule in mid-April with no major regressions
Likely
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
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.
2
Release delayed past mid-April due to persistent regressions
Possible
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
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.
3
Rust's permanent status accelerates new driver development in Rust
Likely
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
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.
4
Rust adoption triggers maintainer friction in the 7.x series
Possible
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
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.
5
Linux 7.4 release candidates shrink before a winter release
Uncertain
Resolves by Feb 28, 2027
Discussed by: Phoronix, and Torvalds' weekly release-candidate messages
If 7.4 follows the pattern of recent cycles, the candidates would shrink after the record merge window. Torvalds has said the large sizes are the new normal, so a return to 13,000-14,000 commit windows is not assured.
Historical Context
3 moments from history that rhyme with this story — and how they unfolded.
1 of 3
July 2011
Linux 2.6 to 3.0 version bump (2011)
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.
Then
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.
Now
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 this matters now
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.
2 of 3
2004-2007
C++ proposal for the Linux kernel rejected (2004-2007)
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.
Then
The C++ proposals were dropped entirely. Kernel development continued exclusively in C and assembly.
Now
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 this matters now
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.
3 of 3
October 2022
Linux 6.0 release (2022)
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.
Then
The release shipped without incident. Distributions adopted it within their normal timelines.
Now
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 this matters now
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.
