Explain the difference between FreeBSD's CURRENT, STABLE and RELEASE branches, and what the trailing "-p6" in a version string such as 14.1-RELEASE-p6 tells you.
answer
- main, then stable/N, then releng
- stable means ABI, not bug-free
- the -p number is patch state
- binary updates target RELEASE only
- installed kernel versus running kernel
basics
~20 sCURRENT is FreeBSD's main development branch, STABLE is the per-major-version branch that keeps kernel and userland interfaces compatible while taking merged changes, and RELEASE is a tagged snapshot cut from it. The -p number is the applied security and errata patch level.
solid answer
~50 sFreeBSD development happens on `main`, historically called CURRENT — it is where new work lands, it can break, and it is not a production branch. When a major version is prepared, a `stable/N` branch is cut; it takes changes merged back from `main` but promises kernel and userland interface stability within that major version, so a module or binary built for 14.0 keeps working across 14.x. Individual releases are then cut on a `releng/14.1` branch and tagged as 14.1-RELEASE — that is what installer images, `freebsd-update` and the binary package repositories target. The `-p6` suffix is the patch level: six sets of security advisories or errata notices have been applied, and `freebsd-update` bumps it. On a running box, `freebsd-version -k` reports the installed kernel, `-r` the running one and `-u` the userland, which is how you tell whether a patch has actually taken effect or is still waiting for a reboot. Running STABLE means building from source; `freebsd-update` only serves RELEASE branches.
code
bash · 8 lines# Patch state is three separate numbers, not one
freebsd-version -k # installed kernel, e.g. 14.1-RELEASE-p6
freebsd-version -r # running kernel, still -p3 before a reboot
freebsd-version -u # userland
uname -r # running kernel only - not the whole story
# Apply outstanding security and errata patches
freebsd-update fetch installgo deeper
Know that RELEASE is what you install on a server, CURRENT is the development branch you do not run in production, and the -p number counts the security patches applied by freebsd-update.
Be able to order main, stable/N and releng/N.M, and explain that STABLE promises kernel and userland interface compatibility within a major version rather than fewer bugs.
Show the operational consequence: binary updates and binary packages target RELEASE, so choosing STABLE commits you to source builds per host, and verifying patch state means comparing the installed kernel, the running kernel and the userland.
Own the lifecycle plan — how long a major branch is supported versus how briefly a point release is, when a major-version upgrade with its package ABI change is scheduled, and whether an internal build and update stream is worth owning.
## The three branch kinds **CURRENT** is the tip of development — the `main` branch of the `src` repository. Everything new lands here first. It is expected to be unstable at times, its kernel interfaces move, and running it in production is a decision to debug the operating system as part of your job. Its version string looks like `15.0-CURRENT`. **STABLE** is a `stable/N` branch, one per major version (`stable/14`). It is created when a major version is being prepared and then lives for years. Changes are developed on `main` and *merged from current* into it — the project's long-standing term for this is MFC. What "stable" promises is not an absence of bugs but **interface stability**: the kernel binary interface and the userland ABI do not break within the branch, so a kernel module or a third-party binary built against 14.0 continues to work on 14.2. Its version string looks like `14-STABLE`. **RELEASE** is a tagged snapshot. When a point release is prepared, a `releng/14.1` branch is cut from `stable/14`, stabilised, and tagged as `14.1-RELEASE`. This is the artefact everything downstream targets: the installer images, `freebsd-update`, and the binary package repositories, whose ABI string identifies the major version and architecture in the form `FreeBSD:14:amd64`. The flow is one-directional: `main` → `stable/14` → `releng/14.1` → `14.1-RELEASE`. ## The -p number After a release ships, the security team publishes Security Advisories and the release engineers publish Errata Notices. Each applied set increments the patch level, so `14.1-RELEASE-p6` means six such rounds have been applied to that release. `freebsd-update fetch install` is what moves it. The patch level is the number you compare against an advisory to answer "am I vulnerable?", so it belongs in your inventory alongside the release number. ## Reading the version on a live machine This is the practical half of the question, and it catches people out: ```sh uname -r # the RUNNING kernel only freebsd-version -k # the INSTALLED kernel freebsd-version -r # the RUNNING kernel freebsd-version -u # the USERLAND ``` Right after `freebsd-update install`, the installed kernel and the userland can show a new patch level while the running kernel still shows the old one — because you have not rebooted. `uname -r` alone will happily tell you that you are still unpatched, or (after a reboot) that you are patched when a userland patch has not been applied. Checking the kernel and userland separately is how you verify that a patch round actually landed. ## Which branch should you run? For almost every production system: RELEASE, kept at the current patch level with `freebsd-update`. You get binary base patches, binary packages built for your ABI, and a supported upgrade path. Run STABLE only when you need a fix or a driver that has been merged but not yet released, and accept the consequence: **`freebsd-update` serves only RELEASE branches**, so a STABLE machine is a from-source machine — `buildworld`, `buildkernel`, `installkernel`, `installworld`, plus an `etcupdate` merge. That is a real, recurring operational cost per host, and it is the reason most shops that need a STABLE build produce their own images or their own binary update stream rather than compiling on each server. CURRENT is for developers and testers, not for servers. ## Support windows The support model since the 13 series works on two clocks: a `stable/N` branch is supported for roughly five years from its first release, while an individual point release stops receiving patches a few months after its successor appears. The practical consequence is that staying on 14.1 forever is not an option even though the 14 branch is supported for years — you must keep moving to the newest point release within the branch to keep receiving `freebsd-update` patches. A major-version upgrade (`freebsd-update -r 15.0-RELEASE upgrade`) is a bigger event that also requires reinstalling packages built for the new ABI. ## Interview framing The grader wants three things: that you can order the branches correctly and say what STABLE actually promises (interface stability, not reliability); that you read the `-p` level as patch state rather than a version; and that you know binary updates and binary packages are RELEASE-oriented, so choosing STABLE is choosing to build from source.
- Right after freebsd-update install, uname -r still shows the old patch level. Is the patch applied?Partly. `uname -r` reports only the *running* kernel, which does not change until you reboot. `freebsd-version -k` shows the installed kernel and `-u` the userland, so those may already show the new level. Userland patches take effect once the affected processes restart; a kernel patch needs the reboot. Compare all three before declaring a machine patched.
- Why can't you use freebsd-update on a machine running 14-STABLE?Because freebsd-update distributes binary patches built by release engineering for RELEASE branches specifically; there is no binary update stream for a moving STABLE branch. A STABLE machine is maintained from source — buildworld, buildkernel, installkernel, installworld and an etcupdate merge — which is a recurring per-host cost and the main reason to stay on RELEASE unless you genuinely need an unreleased fix.
- What does the ABI string FreeBSD:14:amd64 mean for packages when you upgrade a major version?It identifies the major version and architecture that the binary packages were built for. Packages built for FreeBSD:14:amd64 are not the ones you want on a 15.x system, so a major upgrade is not just a base upgrade — you reinstall or rebuild the packages against the new ABI. That is why a major-version jump is planned work, while a point release inside the same branch is routine.
saying these in an interview costs you the question
- Thinks STABLE means more reliable than RELEASE
- Reads the -p number as a minor version
- Assumes freebsd-update works on STABLE branches
- Checks patch state with uname -r alone
- Believes a point release can be run indefinitely and stay patched