Linux kernel development moves through a repeating cycle rather than a fixed release calendar. After a roughly two-week merge window, -rc1 marks the point where feature merging normally ends and stabilization begins. Further release candidates usually appear about a week apart while developers fix regressions and other bugs. In parallel, patches travel from mailing-list review to subsystem trees, through linux-next integration testing, and eventually into mainline or a separate stable-maintenance queue.
This guide explains what each stage means, how to test a candidate without confusing it with a production-ready kernel, and how a patch is reviewed, routed and accepted.
As an Amazon Associate I earn from qualifying purchases.
What “-rc” means in the Linux kernel
An -rc release is a development snapshot of the next mainline kernel. It is not a promise that the code is bug-free; it is an invitation to compile, boot and exercise the tree so remaining problems can be found before the final release.
Crashes, No Sound, or Screen Glitches?
Random freezes, missing sound and display glitches usually trace back to one bad driver. Find and replace yours safely.Free scan · under a minutePC Slower Than It Used to Be?
A free scan shows the junk files, broken settings and background clutter dragging Windows down - then fixes them in one click.Free scan · Windows 10 & 11The first candidate, -rc1, follows the merge window. The Linux kernel documentation describes the merge window as approximately two weeks after a major release. During it, maintainers submit larger, sufficiently mature changes. Once it closes, the normal rule is to stop adding new features and concentrate on fixes. The process is intentionally “loosely time-based,” not governed by a calendar with guaranteed dates. See How the development process works.
#1 Best Overall
The release-candidate timeline
1. A new mainline release starts the cycle
When a final kernel is published, the next development cycle opens. Maintainers prepare changes that have already gone through subsystem review and testing. These can include drivers, filesystems, architecture work, core changes and other improvements, provided they are considered ready enough for mainline consideration.
2. The merge window lasts about two weeks
The merge window is the period for bringing larger changes into the mainline tree. It is not a period in which every proposed patch is automatically accepted. Maintainers still select what they believe is appropriate, and the changes should have been developed and reviewed in their subsystem beforehand.
3. -rc1 closes feature merging
At the end of the window, Linus Torvalds publishes -rc1. This is the transition from feature integration to stabilization. New feature work generally waits for a later cycle; fixes for defects, build failures and regressions become the priority.
What’s actually slowing this PC down?
Pick the symptom - the matching free tool is one click away.
4. Weekly candidates expose remaining problems
Subsequent candidates are commonly issued about once a week when the tree is ready for another testing snapshot. A typical series reaches somewhere around -rc6 through -rc9, and stabilization often takes roughly six to ten weeks. Those figures are guidance, not promises. A serious regression can require extra candidates, while a relatively healthy cycle can finish sooner.
5. The final release follows bug status
There is no fixed “week six” release date. The project weighs known bugs and regressions, especially changes that break behavior that worked in an earlier kernel. Andrew Morton summarizes the principle in the official development HOWTO: “Nobody knows when a kernel will be released, because it’s released according to perceived bug status, not according to a preconceived timeline.” The same documentation notes that a final release can still contain known regressions if delaying it would damage the next development cycle more than releasing does. The historical Linux 5.4 schedule illustrates the process: 5.4-rc1 appeared on September 30, 2019, and 5.4 final followed on November 24, 2019; those dates are an example, not a current forecast.
What developers look for during stabilization
Every candidate is a request for evidence. Developers want to know whether a change causes a regression, fails to build, crashes, corrupts data, reduces performance or breaks a particular hardware or workload. Regressions receive special attention because they remove behavior users previously had.
Testing does not establish that a candidate is safe on every machine. A successful boot on one architecture and workload only demonstrates that those conditions worked. Reports should identify the kernel version, hardware or virtual environment, configuration, workload and result so a maintainer can reproduce the observation.
The Tool Desk
Outbyte PC Repair FREEClear out junk files and repair common Windows errorsFree Scan →Outbyte Driver Updater FREEScan for outdated or missing drivers - takes under a minuteDriver Scan →How a patch travels toward mainline
1. Define the problem and proposed change
A useful patch begins with a specific problem. The author should explain what users experience, under which conditions it happens, and why the proposed design addresses it. The explanation belongs in the patch description, not only in an external conversation.
2. Start review on the relevant mailing list
Early and broad review normally happens on the mailing list for the affected subsystem. Reviewers examine correctness, interfaces, locking, error handling, compatibility, performance and maintainability. A submission should include evidence such as reproduction steps, logs, crash information or measured performance results when those details are relevant. Explain trade-offs instead of presenting only the benefit.
3. Find the right maintainer and rules
The repository’s MAINTAINERS file identifies responsible people, mailing lists and, where available, the subsystem tree. Kernel documentation also recommends checking subsystem-specific workflow rules because review conventions differ. A patch sent to the wrong list can be delayed even when its code is sound.
4. Keep the change focused and resubmissions complete
A patch should address one problem rather than bundle unrelated cleanup. When reviewers request changes, each new submission should stand on its own: include the complete patch description, the motivation, the current implementation and the relevant test evidence. Reviewers should not have to reconstruct the rationale from several disconnected messages.
5. Enter a subsystem tree
If the subsystem maintainer considers the patch ready, it may be accepted into that maintainer’s development tree. This is a significant step because it enables further review and testing with other work, but it is not a guarantee of eventual mainline inclusion. The maintainer can still drop or revise it after conflicts, test failures or new technical objections appear.
6. Go through linux-next integration
linux-next combines work from many subsystem trees before a future merge window. Its purpose is to expose integration problems: conflicting edits, build failures, API mismatches and interactions that isolated subsystem testing did not reveal. The official HOWTO describes it as a preview of changes likely to be considered for the next merge window and invites adventurous testers to run it.
7. Reach mainline during a merge window
When a maintainer’s work is selected for the next merge window, it is merged into the mainline development tree. Mainline testing then continues through the -rc series. A patch can therefore be reviewed in a subsystem, tested in linux-next, merged during the window and still require fixes before the final release.
How to test -rc and linux-next kernels
Choose the target according to your risk tolerance
- Mainline
-rc: tests the next development release after feature merging has closed. It is appropriate for developers, distributions and experienced users who can recover from regressions and provide reports. linux-next: tests the integration of subsystem work before it reaches the next merge window. It is more exploratory and is aimed at adventurous testers who understand that interfaces and behavior can change.- Stable candidate: tests a proposed set of fixes for an already released stable series. It is narrower than a mainline candidate but still needs validation before publication.
Prepare a recovery path
Keep a known-working kernel installed and make sure the bootloader can select it. Back up important data, especially before testing storage, filesystem or power-management changes. Test on hardware you can service locally rather than on a system that must remain continuously available.
Free tools Windows power users keep installed
One-click scans. No signup required.
Record a useful test report
- Identify the exact candidate or
linux-nextsnapshot and the configuration used. - Describe the machine or virtual platform, relevant peripherals and the workload.
- State what you expected, what actually happened and whether the behavior is reproducible.
- Attach concise logs, crash information, reproduction steps or performance measurements where they clarify the issue.
- Compare with the last known-good kernel when reporting a regression.
A test result is evidence, not a certification. Passing your workload means only that the candidate worked under the conditions you exercised; it does not establish compatibility with other hardware, filesystems, applications or workloads.
Mainline candidates and stable candidates are different
| Aspect | Mainline -rc |
Stable -rc |
|---|---|---|
| Purpose | Stabilize the next major development release after its merge window. | Validate a proposed maintenance update for an already released stable series. |
| Change scope | Broad: fixes for newly merged work and regressions across the next release. | Narrow: selected fixes for significant real problems; not a general feature channel. |
| Where work originates | Mainline changes merged during the current development cycle. | Fixes that, under the stable rules, should already exist in mainline or have an equivalent upstream fix. |
| Testing question | Does the next kernel work correctly and integrate its new changes? | Does this proposed set of fixes improve the existing stable series without introducing regressions? |
| Risk interpretation | Development testing: broader change and greater variation by hardware or workload. | Maintenance testing: smaller change set, but still not a guarantee for a particular system. |
The stable process has its own review committee and candidate cycle. Testers can reply with a Tested-by: email describing what they tested; that tag may be collected into the eventual release commit. If problems remain, additional stable candidates can be issued. Security issues follow a distinct handling process in the stable guidance. Read the stable-kernel rules for the current criteria and workflow.
How to review a patch effectively
Check the problem statement first
Ask whether the description identifies a real, reproducible problem and names the affected users or systems. If the motivation is vague, request clarification before spending time on implementation details.
Rank #4
Examine behavior, not only style
Trace error paths, boundary conditions, locking and lifetime rules. Consider suspend and resume, hot-unplug, unusual hardware, recovery after partial failure and interactions with neighboring subsystems when applicable. A patch that looks clean in the normal path can still fail under interruption or resource pressure.
Demand evidence proportionate to the claim
Performance claims should include the workload and measurement method. Crash fixes should include reproduction conditions or a useful trace. Hardware fixes should identify the affected device or firmware context. Evidence lets later reviewers distinguish a real improvement from an untested assumption.
Separate review from acceptance
Comments, an “Reviewed-by:” tag or inclusion in a subsystem tree indicate progress, not a final promise. The maintainer still has to evaluate integration results and decide whether to send the work upstream. Mainline inclusion remains subject to the merge-window decision and subsequent regression testing.
Independent reader supportYour contribution helps us test, update, and keep practical guides available for everyone.Common mistakes and how to recover
Assuming the calendar guarantees a final release
Approximate weekly candidates and the six-to-ten-week stabilization description help planning, but regressions can extend the series. Follow the candidate announcements and bug status rather than scheduling production rollout against an assumed date.
Running a candidate without a fallback
If the new kernel fails to boot or breaks a critical device, select the known-good entry in the bootloader, collect logs and report the regression. Do not erase the working kernel while evaluating an experimental one.
Recommended Free Tools
Sending an incomplete resubmission
Reviewers need the current patch and its full rationale in every revision. Include what changed since the previous version and the tests that address earlier comments, while retaining the complete problem statement.
Best Value
Treating a subsystem merge as the finish line
Continue testing after subsystem acceptance. Conflicts may appear only when multiple trees are combined in linux-next, and additional failures can surface after mainline integration.
Reporting “works for me” without conditions
State the exact kernel, configuration, platform and workload. A bare success report cannot tell maintainers what was actually exercised or whether another tester’s failure is a genuine regression.
Where to follow the official process
The canonical development overview is the Linux Kernel documentation’s development-process guide. For authoring and routing a change, use Submitting patches. The broader workflow, including testing expectations and the role of linux-next, is covered in the kernel development HOWTO. Stable-series criteria and candidate testing are maintained in the stable-kernel rules. These pages are rolling documentation, so maintainer contacts and detailed procedures can change.
Frequently Asked Questions
Is a Linux kernel release candidate the same as a beta release?
Not exactly. “Release candidate” describes a point in the kernel’s development process after the merge window, when the usual focus shifts from adding features to fixing and testing the code already merged. It is a development status, not a guarantee about stability or hardware compatibility.
Why can a final kernel still have a known regression?
The project weighs the cost of delaying the release against the effect of carrying the problem into the next development cycle. The official process documentation acknowledges that a final release can ship with known regressions when postponing it would create a greater overall problem.
Does acceptance by a subsystem maintainer guarantee that a patch will ship?
No. A subsystem tree is an important review and testing stage, but integration conflicts, test failures, new objections or the merge-window decision can still cause the patch to be revised or dropped.
Quick Recap
Product prices and availability are accurate as of the date/time indicated and are subject to change. Any price and availability information displayed on Amazon at the time of purchase will apply.
Do these 3 things before closing this tab:
1Clear out junk files and repair common Windows errors2Scan for outdated or missing drivers - takes under a minute3Repair Windows errors before they cause bigger problems
