Linux 7.3 ships with a record 18,765 commits and 807 first-time contributors
On 18 October 2026, Linus Torvalds released Linux 7.3, a record kernel with 18,765 commits from 3,021 developers — 807 of them first-time contributors — plus new work across filesystems, the scheduler, and BPF. Before you update production servers, read what actually changed and what can wait for 7.4.
18 October 2026. Linus Torvalds releases Linux 7.3. 18,765. The number of non-merge commits merged, a record. 807. The number of developers making their first kernel contribution. Why it matters: 7.3 brings no single headline feature but an unprecedented breadth — filesystems, the scheduler, BPF, system calls — that touches servers, desktops, and embedded alike.
A record release on every front
The most striking number in this cycle is demographic. Linux 7.3 totals 18,765 non-merge commits, written by 3,021 developers, 807 of them first-time contributors. No previous release pulled in as many people or merged as many changes in a single merge window. It is the quantified confirmation of a trend visible for years: the kernel remains one of the most active software projects on earth, and its pool of new contributors keeps widening.
Torvalds announced the release in his usual offhand tone. “It’s Sunday afternoon, and this week I somehow kept my wits together long enough to keep track of the day of the week, so the release isn’t randomly delayed,” he wrote. The real scheduling note: the 7.4 merge window opens on 19 October, but he is on family vacation — he will spend the morning “on a boat and under water” and only merge in the afternoon. The first weeks of 7.4 will run on a slightly shifted schedule.
What actually lands in the kernel
Behind the counting record, 7.3 delivers changes spread across several subsystems. Three deserve an operator’s attention:
- Filesystems. A new filesystem, failfs, deliberately fails every operation — a testing tool, not a production filesystem. ntfs3 gains support for alternative data streams, and the SMB server receives a long list of improvements.
- Scheduling. Group scheduling targets better performance on large machines, and the sched_ext sub-scheduler feature is now complete: it lets you load scheduling policies in BPF and update them without a reboot.
- Infrastructure. binfmt_misc gains notable extensions, the new fchroot() system call arrives, BPF programs get global per-CPU data, and virtual machines gain working-set tracking.
Two additions show the general direction. fchroot() extends the chroot logic to a file descriptor, opening uses in containerization and fine-grained isolation. Working-set tracking for virtual machines, meanwhile, continues KVM’s long march toward better guest memory management. None of this is dramatic on its own; together they make 7.3 a release that touches nearly the whole kernel.
failfs, or the art of testing failure
failfs deserves a digression. The idea is counterintuitive: a filesystem whose every operation fails. Its purpose is not production but robustness testing — checking that applications handle write errors, ENOSPC, EIO, and allocation failures correctly. It is a reliability-engineering building block that teams building storage software or databases have wanted for a long time.
Landing failfs in the mainline kernel also signals normalization: rather than an out-of-tree module maintained by a handful of people, the tool is now available everywhere, documented in the kernel docs, and versioned with the rest. For infrastructure teams, that is one more reason to build fault-injection scenarios into their validation pipelines.
What it means for you
The practical question is the update schedule. 7.3 is a stable release in the strict sense: it ends a normal release-candidate cycle and is not an LTS. Maintenance policy therefore applies as with other recent major versions — fixes until the next one ships, then a move to the next stable.
For a production server already on an LTS branch, there is no rush: stay on your maintained branch and let 7.3 mature for a few weeks. For a workstation or test environment on a rolling distribution — Arch, Fedora Rawhide, or similar — 7.3 will arrive through the normal update flow. For kernel teams and distribution vendors, the action is already elsewhere: the 7.4 merge window is open, and that is where the next features get decided.
The main watch item is out-of-tree drivers and third-party modules: every major version changes internal APIs, and modules built for 7.2 will often need a rebuild. Check that your sensitive modules — GPU, network, storage — are compatible before switching. Finally, the very breadth of the cycle complicates backporting: expect the 7.3.x fixes to be triaged more finely than usual by distribution maintainers.
One slice of 7.3 matters disproportionately to homelab and NAS operators: the long list of SMB server improvements. Linux acting as a file server for Windows and macOS clients has historically lagged behind a dedicated Samba appliance on edge cases — permissions, oplocks, and caching behavior. Each mainline release narrows that gap, and for anyone running NFS or SMB shares off a small Linux box, upgrading to a kernel with these fixes is often cheaper than re-architecting around a separate NAS distribution. It is a quiet reminder that the headline features are not always the ones that matter for a given deployment.
None of this means most users will see a visible change. The value of 7.3 is under the hood — in memory accounting, scheduling fairness on big machines, and filesystem edge cases — and it accrues silently. The practical upgrade decision is therefore less about features than about maintenance: every kernel you run must eventually track a supported line, and 7.3 is simply the next one on the treadmill.
Rust for Linux keeps moving in the background
The contributor record hides another trajectory — slower but just as structural: the rise of Rust in the kernel. At Kangrejos 2026, Gary Guo presented a solution to the problem of self-referential structures — objects that reference themselves, which Rust cannot model cleanly without unsafe code. Building on the pin_init crate, his changes could remove most of the lifetime-related unsafe code in the Nova driver — the Rust GPU driver — and eventually in other components.
Why this matters in a note about 7.3: 7.4 and the releases after it will not be decided only on filesystems or the scheduler, but on the kernel’s ability to accept safe Rust code at larger scale. The work is structural: every abstraction that lets Rust “own” an object allocated in C — the Ownable trait presented at the same conference — reduces the friction still holding back drivers written in a memory-safe language. It is not a visible change in the 7.3 diff, but it is the one that shapes the kernel of 2027.
Verdict
If you run LTS servers, stand pat: 7.3 is a milestone, not an emergency, and your maintained branch remains the right call. If you are on a rolling distribution or testing new hardware, take 7.3 as soon as it lands: the breadth of fixes and widened hardware support make it a healthy update. Either way, note the underlying signal: a kernel that attracts 807 new contributors in one cycle is not a project in decline — it is a project accelerating, and 7.4 is already in motion.