Linus Torvalds released Linux Kernel 7.3-rc4 on 20 September 2026, marking the fourth release candidate in the 7.3 development cycle. For teams that build, patch, or maintain systems on top of the kernel, this stage matters more than a typical incremental update, because it signals which changes are stable enough to trust and which areas still carry risk. This article walks through what changed in Linux Kernel 7.3-rc4, why the release is larger than usual, how the fixes are distributed across subsystems, and what engineering teams should watch before the final 7.3 kernel ships. Along the way, we look at the bug fixes, the security-related changes, and the practical implications for anyone running production Linux systems.
What Is Linux Kernel 7.3-rc4?
Linux Kernel 7.3-rc4 is the fourth release candidate for the upcoming 7.3 stable kernel. Release candidates, or "rc" builds, are pre-release snapshots that Torvalds publishes on a weekly cadence after the two-week merge window closes. By the time a kernel reaches rc4, most new functionality has already been merged, and the remaining weeks are meant for stabilization rather than feature additions. That makes Linux Kernel 7.3-rc4 a useful checkpoint: it tells developers and system administrators how mature the upcoming kernel cycle really is.
In his release announcement, Torvalds noted that the size of this candidate remains "noticeably larger than normal" for this point in the cycle. That comment is significant because rc builds are expected to shrink steadily as a cycle progresses. A larger-than-expected rc4 suggests that maintainers are still working through a substantial backlog of edge-case issues, which is exactly what this stage of testing is designed to surface.
Linux Kernel 7.3-rc4 Changes: What Actually Landed
According to reporting on the release, Linux Kernel 7.3-rc4 Changes totaled roughly 449 commits from approximately 239 contributors. Unlike earlier stages of the cycle, this batch of changes was not dominated by any single subsystem. Instead, the work split into three roughly equal groups: driver updates, filesystem and networking fixes, and a broad category of miscellaneous architecture and tooling changes.
• Drivers: continued hardware and graphics support catch-up, including new game controller support merged into the input subsystem.
• Filesystems and networking: SMB/CIFS and NTFS received concentrated hardening work, alongside two notable Btrfs fixes and a long-standing silent data-loss bug traced back to 2023.
• Wireless and Bluetooth: Johannes Berg contributed roughly 34 Wi-Fi related patches, while Bluetooth updates added validation for service data lengths before reading UUIDs in packet headers.
• Architecture and core kernel: smaller, targeted fixes across CPU handling, memory management leftovers, and internal tooling.
None of this is presented as flashy new functionality. As one report on Linux Kernel 7.3-rc4 put it, the changes are mostly small patches with nothing described as "particularly interesting" on their own but that is by design at this stage of a kernel cycle.
Linux Kernel 7.3 Features and What They Mean for Stability
Because rc4 sits deep in the stabilization phase, the relevant Linux Kernel 7.3 Features worth tracking are less about brand-new capability and more about how existing subsystems behave under load. Filesystems continued to draw disproportionate attention this cycle, particularly SMB and NTFS, which points to ongoing work on interoperability with Windows-facing storage protocols. Processor microcode handling also changed: the kernel now explicitly rejects problematic microcode updates on Intel Granite Rapids systems, a defensive move intended to protect platform stability rather than add a user-facing feature.
On the ARM64 side, hibernation code was adjusted so that it clones only the linear memory map that actually exists at runtime, rather than assuming a fixed layout. This kind of correction reduces the chance of hibernation failures on systems with non-standard memory configurations, which is the sort of fix that rarely makes headlines but directly affects reliability for embedded and mobile Linux deployments.
Linux Kernel Bug Fixes Worth Understanding
The most consequential Linux Kernel Bug Fixes in this candidate were not glamorous, but several had real operational impact. Two Btrfs issues were addressed after being flagged as sufficiently disruptive to warrant priority handling. Separately, a silent user-space data-loss bug that had persisted since 2023 was finally traced and corrected, a reminder that even mature filesystem code can carry latent defects for years before detection.
SELinux also received attention: the module now preserves user security identifiers across nested backing files and rechecks intermediate files whenever memory protection changes occur. In practice, this closes a narrow but meaningful gap where access control decisions could become inconsistent during specific file-backing scenarios. For teams running SELinux in enforcing mode, this class of fix is exactly why release candidates deserve careful review before deployment planning begins.
• Prioritize testing on filesystems you actively rely on, especially SMB/CIFS, NTFS, or Btrfs, since these received the heaviest changes.
• Re-run security policy tests if your environment enforces SELinux, given the SID-handling correction.
• Check ARM64 hibernation behavior on non-standard memory layouts before promoting builds to production.
• Avoid deploying microcode updates for Intel Granite Rapids systems without confirming compatibility against the new kernel checks.
**
Networking, Wireless, and Bluetooth Hardening
**
Networking and Bluetooth changes in this cycle leaned heavily toward hardening rather than new protocol support. Developers serialized state garbage collection in xfrm, the kernel's IPsec transformation framework, closing a potential race condition. On the Bluetooth side, driver updates now validate service data lengths before reading UUIDs from packet headers, which mitigates malformed-packet handling issues that could otherwise be exploited or trigger crashes on affected devices.
Wireless networking saw the largest concentration of patches from a single contributor, with dozens of fixes touching state-machine correctness and bounds checking rather than feature work. This pattern, more error-path cleanup than net-new capability, is consistent with what maintainers describe as typical for a mature, well-tested subsystem heading toward a stable release.
**
Comparison: Where the Work Landed in 7.3-rc4
**
`
| Area | Focus in 7.3-rc4 | Typical Risk If Skipped | Who Should Care |
|---|---|---|---|
| Drivers | Hardware and graphics support catch-up | Missing device support on new hardware | Hardware vendors, laptop and desktop users |
| Filesystems & Networking | SMB/CIFS and NTFS hardening, network stack fixes | Data integrity and connectivity issues | Storage admins, network engineers |
| Security Modules | SELinux SID handling, memory protection rechecks | Privilege or policy inconsistencies | Security and compliance teams |
| Architecture & Core | ARM64 hibernation fix, microcode handling | Boot or suspend failures on affected platforms | Embedded and platform engineers |
`
**
Linux Kernel Release Notes: Timeline Toward Stable
**
Formal Linux Kernel Release Notes and changelogs for the 7.3 cycle continue to follow the standard weekly rc cadence Torvalds has used for years. Based on that pattern, rc5 was expected around 27 September 2026, with the cycle continuing through additional candidates before entering the stabilization tail. If testing proceeds smoothly, the final stable Linux 7.3 kernel is expected around mid-to-late October 2026; if late regressions surface, an additional rc8 build could push the final release slightly later.
This predictable cadence is part of why release candidates are useful signals rather than noise. Each weekly build narrows the scope of active change, and by the time a distribution packages the stable 7.3 kernel, the vast majority of the churn visible in Linux Kernel 7.3-rc4 will have been resolved, reverted, or refined.
**
Linux Kernel Development: The Bigger Pattern
**
Beyond this specific candidate, the broader trend in Linux Kernel Development is worth noting. Maintainers have observed that automated and LLM-assisted tooling is increasingly effective at catching error-path issues, the kind of defensive code that handles failure conditions but rarely executes in normal operation. That shift shows up clearly in Linux Kernel 7.3-rc4, where a meaningful share of the fixes fall into this category rather than representing newly discovered functional bugs.
For organizations that maintain custom kernel builds, embedded distributions, or downstream patches, this pattern has practical implications. It suggests that upstream review is getting better at catching subtle correctness issues before they reach production, but it also means teams tracking mainline closely should expect a steady trickle of small, defensive patches rather than large, easily summarized changesets. Reviewing Linux Kernel 7.3-rc4 alongside prior candidates gives a clearer picture of how the cycle is converging toward stability.
**
Advantages and Disadvantages of Tracking Release Candidates
**
**
Advantages
**
• Early visibility into subsystem-specific risk, such as filesystem or networking changes, before they reach stable users.
• Opportunity to test hardware, drivers, and custom patches against upstream changes while there is still time to report issues.
• Better planning for maintenance windows, since Linux Kernel Release Notes and rc cadence give a reliable release timeline.
**
Disadvantages
**
• Release candidates are not intended for production use and can contain regressions that have not yet been caught.
• Tracking every rc requires engineering time that smaller teams may not have available.
• Some fixes land, get reverted, and land again in modified form, which can complicate downstream patch management if applied too early.
**
Practical Guidance for Teams Evaluating This Cycle
**
Teams that maintain their own kernel configurations, out-of-tree drivers, or embedded Linux images typically benefit from testing against Linux Kernel 7.3-rc4 rather than waiting for the stable tag, since it gives more lead time to catch integration issues. That said, this is not a candidate to deploy broadly. The safer approach is to run it in staging or hardware validation environments, focus testing on the subsystems most relevant to your workload (filesystems, wireless, or security modules, depending on your stack), and track subsequent release candidates to see which fixes are confirmed rather than reverted.
Given how much of Linux Kernel 7.3-rc4 concentrates on filesystems, networking, and security hardening, teams running storage-heavy or security-sensitive workloads have the most reason to pay close attention this cycle.
**
Frequently Asked Questions
**
**
What is Linux Kernel 7.3-rc4?
**
Linux Kernel 7.3-rc4 is the fourth release candidate in the Linux 7.3 development cycle, released by Linus Torvalds on 20 September 2026. It represents a late-stage snapshot focused on bug fixes and stabilization rather than new features, ahead of the final stable 7.3 release.
**
Why is Linux Kernel 7.3-rc4 larger than usual?
**
Torvalds noted the candidate remains larger than normal for this stage of the cycle. Reports point to concentrated work in filesystems, networking, and driver subsystems, along with a wave of error-path and hardening fixes that pushed the change volume above typical rc4 levels.
**
When will the stable Linux 7.3 kernel be released?
**
Based on the standard weekly release-candidate cadence, the stable Linux 7.3 kernel was expected around mid-to-late October 2026, assuming no major regressions appear. An additional release candidate could extend the timeline slightly if late issues are found.
**
What subsystems changed the most in this release candidate?
**
Filesystems and networking, particularly SMB/CIFS and NTFS, received the heaviest attention in Linux Kernel 7.3-rc4, alongside significant driver updates and wireless networking fixes contributed largely by Johannes Berg.
**
Are there any major bugs fixed in Linux Kernel 7.3-rc4?
**
Yes. Two notable Btrfs issues were addressed, along with a silent user-space data-loss bug that had existed since 2023. SELinux also received a fix to preserve user SIDs correctly across nested backing files.
**
Should production systems run Linux Kernel 7.3-rc4?
**
No. Release candidates are intended for testing, staging, and hardware validation rather than production use. Teams should wait for the stable 7.3 release or apply rc builds only in controlled, non-critical environments.
**
Where can developers find official Linux Kernel Release Notes?
**
Official changelogs and shortlogs are published alongside each release candidate through the kernel.org Git repositories and Torvalds' mailing list announcements, which detail every merged commit for that cycle.
**
Conclusion
**
Linux Kernel 7.3-rc4 is a clear example of what a healthy stabilization phase looks like: fewer new features, more defensive fixes, and concentrated attention on the subsystems, filesystems, networking, and security modules, that carry the most operational risk if left unaddressed. The scale of this candidate, with roughly 449 commits from about 239 contributors, shows that testing and review activity is still active even this late in the cycle, which is a reasonable sign of thoroughness rather than instability. For teams building on Linux, reviewing Linux Kernel 7.3-rc4 now, rather than waiting for the stable tag, provides a practical head start on compatibility testing and hardware validation.
If your team maintains custom kernel configurations, embedded Linux images, or security-hardened deployments, evaluate your current build against the changes in this release candidate before the final 7.3 kernel ships. Mpiric's Linux and kernel engineering team can help assess compatibility, review filesystem and security-related changes, and plan a safe upgrade path for your infrastructure.
Top comments (0)