Linus Torvalds officially released the final Linux kernel 7.3 version on October 18, 2026. The release includes changes across several core subsystems, from task scheduling and filesystem isolation to GPU memory management and storage I/O.
The scheduler changes complete support for nested sched_ext schedulers and improve CPU weight distribution across cgroup hierarchies. On the security side, failfs and the new fchroot(2) system call provide a different approach to filesystem isolation.
The release also improves VRAM management under memory pressure, adds working-set tracking for virtual machine memory, and speeds up several filesystem operations.
Alongside these technical changes, Linux 7.3 sets new records for developer participation and commit activity. The growing use of AI-assisted tools also continues to influence how developers find bugs and submit fixes.
Here are the biggest highlights and features delivered in the final 7.3 release:
Table of Contents
1. Development Activity and the Growing Role of AI
Linux Kernel 7.3 received 18,765 non-merge commits from 3,021 developers, including 807 first-time contributors. These figures set new records for the kernel development project.
The release also reflects a change in how developers find and fix bugs. Automated tools and large language models (LLMs) are increasingly involved in code review, error-path analysis, and routine bug fixing.
Torvalds has described the resulting increase in small fixes as the new "AI normal." The trend is not limited to AI-generated patches; AI-assisted review can also identify problems that developers then fix manually.
This increased activity brings both benefits and challenges.
Automated tools can help find overlooked edge cases and suggest fixes across a large codebase. However, every patch still needs careful review and testing. A larger number of patches does not automatically mean better code, and maintainers must continue to judge changes on their correctness and value.
The growing volume of small fixes is therefore an important part of the Linux 7.3 development story, alongside the larger architectural changes in the release.
2. Core Kernel and Task Scheduling
Completed sched_ext Sub-Schedulers
Linux 7.3 completes support for nested sub-schedulers in sched_ext. A root BPF scheduler can delegate entire cgroup subtrees to child schedulers and grant them CPU access that it can later revoke.
The parent scheduler passes per-CPU capabilities to each child, including control over task enqueueing, preemption, and CPU frequency management. This allows each child scheduler to manage the tasks assigned to it rather than relying on the parent for every scheduling decision.
The kernel also adds a rescue path for tasks that become stranded after their scheduler loses access to the CPUs they need. Instead of allowing these tasks to remain stuck until the watchdog ejects the scheduler, the kernel runs them within a limited CPU bandwidth budget. This provides a controlled fallback when a sub-scheduler can no longer make progress.
Together, these changes give cgroup-specific BPF schedulers more control while providing a recovery mechanism for scheduling failures.
Cgroup Weight Scaling with cgroup_mode
On large multiprocessor systems, distributing CPU time across deep cgroup hierarchies can introduce scheduling overhead and distort resource allocation. Linux 7.3 adds the cgroup_mode setting to control how the kernel distributes CPU weights.
The setting supports four modes: up, max, concur, and tasks. The default is concur, which aims to provide more accurate weight distribution across complex hierarchies, although this accuracy can come at a higher computational cost.
The release also moves cgroup scheduling to a single run queue. This simplifies parts of the scheduling path and helps reduce overhead and latency. These changes target systems where hierarchical scheduling can become a bottleneck.
Isolating Kernel Thread and PID 1 Filesystem State
Linux 7.3 changes how the kernel initializes filesystem state for kernel threads and the init process.
Previously, PID 1 and kernel threads could share an fs_struct. This meant filesystem operations that changed the process's root or related state could also affect kernel threads.
The release gives PID 1 its own fs_struct and places kernel threads in an isolated nullfs mount. This separates their filesystem state from that of user-space processes and avoids unintended sharing of mount namespace references.
3. Sandboxing and Executable Control
The failfs Pseudofilesystem and fchroot(2)
Linux 7.3 introduces failfs, a pseudofilesystem that rejects unsupported operations with EOPNOTSUPP. Unlike nullfs, which behaves as though files are absent and returns ENOENT for missing paths, failfs provides a stronger boundary for filesystem access.
The release also introduces fchroot(2), a file-descriptor-based alternative to chroot(2). An application can open the directory file descriptors it needs before entering a restricted environment, then use fchroot() with the FD_FAILFS_ROOT flag to move its root into failfs.
Once the process enters this environment, absolute path lookups and absolute symlink resolution fail. The application must use explicit directory file descriptors to access the parts of the filesystem it needs.
This approach reduces dependence on ambient filesystem state and avoids the path re-resolution race associated with traditional path-based root changes. It provides a useful foundation for applications that need strict filesystem isolation without relying on chroot() alone.
BPF-Based Binary Selection in binfmt_misc
Linux 7.3 extends binfmt_misc with BPF hooks for binary matching and interpreter execution.
Traditional binfmt_misc rules rely on file extensions or fixed byte patterns to identify executable formats. With BPF support, programs can inspect binaries when a process calls exec() and make decisions about interpreter selection and execution. The kernel can also perform PT_INTERP loader substitution to override the dynamic loader specified by the binary.
This gives distributions such as NixOS more flexibility when locating interpreters and dynamic loaders. It also helps build relocatable binary environments without requiring wrapper scripts or patchelf modifications for every executable.
4. Graphics Memory and Virtual Machine Tracking
Protecting VRAM Under Memory Pressure
When multiple applications compete for limited VRAM, a GPU may move buffers into system RAM through the graphics translation table (GTT). This can hurt performance, particularly when an application that needs protected GPU memory cannot obtain enough of it.
Linux 7.3 addresses this problem by integrating device-memory cgroups (dmemcg) with the DRM TTM memory manager.
Under VRAM pressure, the kernel can evict unprotected buffers before reclaiming memory reserved for protected workloads. This helps applications make better use of the memory protection assigned to them and reduces repeated movement of buffers between VRAM and system RAM.
The change is particularly useful on low-end GPUs, where memory is limited and competing workloads can cause unstable frame rates. It can also help local LLM workloads, including llama.cpp, avoid unnecessary performance loss when sharing GPU memory with other applications.
Tracking Guest Memory with userfaultfd
Virtual machine monitors (VMMs) need to know which parts of guest memory are actively used before moving less frequently accessed pages to slower or remote storage.
Linux 7.3 adds the UFFDIO_REGISTER_MODE_RWP flag to userfaultfd(2). This enables read-write protection tracking for registered memory regions, allowing a VMM to identify the guest's active working set.
The mechanism serves a similar purpose to tracking memory access with mprotect(PROT_NONE) and a signal handler, but avoids that approach's signal-handling overhead. VMMs can use the information to identify cold memory and move it to tiered or remote storage.
This gives virtual machine memory managers a more efficient way to track guest memory usage and manage memory placement.
5. Storage and Filesystem Improvements
Linux 7.3 improves I/O performance and adds new capabilities across Btrfs, ext4, block devices, FUSE, SMB, and NTFS3.
Btrfs Direct I/O and fsync Performance
Btrfs changes its Direct I/O path to use iomap bounce buffers instead of falling back to buffered I/O in the affected cases. The previous behavior limited throughput to roughly 50% of the hardware's theoretical maximum. The new implementation raises it to about 95%, nearly doubling throughput in the reported workload.
The release also removes an unnecessary one-jiffy delay from the logging path used for non-SSD storage. This change improves fsync throughput by about 5x in the measured workload.
Another optimization skips unnecessary hole detection during full fsync operations on files without holes. This reduces the time needed to complete logging for files with many extents.
These changes target specific bottlenecks in the Btrfs I/O and logging paths rather than changing the filesystem's basic interface.
Ext4 Parallel Writes
Ext4 improves parallel Direct I/O writes by allowing more operations to proceed while holding the shared i_rwsem lock in shared mode.
The release also improves block preallocation through fallocate(). The kernel avoids unnecessary work in the ext4_mb_prefetch() path, reducing the cost of preallocation when that work is not needed.
These changes help reduce locking overhead and improve performance in workloads that issue concurrent writes or allocate large file regions.
RWF_DONTCACHE for Block Devices
Linux 7.3 adds support for RWF_DONTCACHE on raw block-device I/O. The flag allows an individual I/O request to avoid polluting the page cache.
This gives applications more control over cache behavior without requiring them to use Direct I/O for every operation. It is useful for workloads that access large amounts of data once and do not benefit from keeping that data in the page cache.
Zero-Copy FUSE with io_uring
FUSE allows filesystems to run in user space, but moving data between the kernel and a FUSE server can add overhead.
Linux 7.3 improves this path by allowing FUSE servers to share buffer pools directly with the kernel and use io_uring for data transfer. This reduces unnecessary data copies and can improve throughput for user-space filesystems that handle large amounts of I/O.
ksmbd and NTFS3 Updates
The in-kernel SMB server, ksmbd, gains support for Apple Time Machine extensions, per-share SMB3 encryption, and encryption for SMB Direct over RDMA.
These additions improve compatibility with Apple backup workflows and provide more options for securing SMB shares and RDMA-based data transfers.
The ntfs3 driver also adds native support for NTFS Alternate Data Streams (ADS). This allows applications to access named streams associated with a file, such as file:stream, rather than treating every file as a single unnamed data stream.
Should You Try Linux Kernel 7.3 Right Away?
If you run Linux on a desktop, workstation, or server, the benefits depend on your workload.
GPU-heavy applications may benefit from better VRAM management, storage-intensive workloads may see faster I/O, and developers working with custom schedulers or isolated environments gain new capabilities.
For most users, the best approach is to upgrade through their distribution's supported kernel packages and test workload-specific changes before deploying them in production.
Summary and Key Takeaways
Linux kernel 7.3 addresses several practical problems across scheduling, security, memory management, and storage. Nested sched_ext schedulers gain more control over CPU allocation, failfs and fchroot(2) provide a new approach to filesystem isolation, and VRAM eviction changes help protect important GPU workloads under memory pressure.
The release also improves guest-memory tracking, speeds up Btrfs and ext4 I/O paths, and adds capabilities to FUSE, ksmbd, and ntfs3.
The development process is also changing. Record contribution numbers and the growing use of AI-assisted tools show how kernel maintenance is evolving. The challenge remains the same: getting useful changes into the kernel without compromising correctness, performance, or maintainability.
For more details, see the LWN merge-window summaries part 1 and part 2 and Kernel Newbies coverage on Linux 7.3.
