Where Last Sunday Ended
Last Sunday's piece argued that openness and ownership are different words. A licence states conditions; it does not in itself transfer ownership. Permissive licences move ownership cleanly to the receiver; copyleft absorbs surrounding code into its own conditions; AGPL closes the network gap. The piece ended on an uncomfortable admission: the licence layer is the layer with the most words and the most procurement documents, and not the layer with the most consequences.
This Sunday picks the thread up exactly there. Suppose the licence is right. Suppose, further, that the architecture is right, that the code is genuinely yours to build and modify and hold. There is still a lever that no licence clause and no architecture diagram touches, and it is the one that actually gets pulled. The whole sovereignty conversation has a habit of stopping one layer too early, at the comfortable layer, the layer with the lawyers. The layer that matters is the one underneath: who governs the thing, and under whose law do they do it.
What Linux Is, and What It Is Not
Begin with the architecture, because it is the part most people mean when they say fork.
Linux is a kernel. The thing that boots when one says "Linux is running" is, in practice, a distribution: kernel plus GNU coreutils, glibc, bash or zsh, an init system, a package manager, a window system on desktops, plus several hundred independently-governed projects assembled and integrated by a distribution maintainer. The kernel is the trunk one notices; the rest is the forest one does not.
This is not a criticism. It is the design. The kernel was deliberately built as a single kernel project, leaving userland to whoever wanted to ship it. GNU supplied one answer; BusyBox supplied another for embedded systems, Alpine's musl stack another for containers, Android's Bionic another for phones. The result is a diversity of Linux systems that share a kernel and remarkably little else.
Distributions paper over the seams. Debian, Red Hat Enterprise Linux, SUSE, Arch each select component versions, patch them where integration requires, and ship the assembly as a coherent system. Each act of selection and patching is governance. None of it is upstream-decided.
So when one says we want to fork Linux, the honest question is: which assembly, which versions, which patches? The kernel can be forked. The distribution-as-system cannot, in the same sense, because it is not a single object. It is an assembly process. Forking the assembly process means forking the distribution maintainer's institution, which is a great deal harder than forking a tree.
What FreeBSD Is
FreeBSD is a single project that maintains, in one source tree, the kernel, the standard C library, the userland utilities, the documentation, the toolchain, and the release-engineering process. When the project announces a release, that announcement covers all of those components, tested together by one release-engineering team, shipped as one snapshot. FreeBSD's own documentation calls this the base system.
The technical literature has a phrase for this: the base system. The phrase carries its weight precisely. Base means what is shipped together. System means integrated whole. There is no version-skew between component projects, because there are no component projects to skew between. A receiver who pulls the FreeBSD tree pulls a known integrated artefact, and forking it is a tractable engineering question rather than an act of institutional archaeology.
OpenBSD makes the same architectural choice and adds proactive auditing as a separate discipline, file by file, since 1996, on a twice-yearly release cadence small enough that the audit keeps pace. The audit is not a special event. It is simply what the project does.
This is a real advantage, and it is worth being precise about its size, because it is smaller than the enthusiasts claim and larger than the sceptics admit. A coherent base system is one tree, with one history, auditable by one institutional process. That is the architectural half of the answer. It is genuinely half. It is also only half.
The Three Properties We Keep Confusing
Here is the distinction the whole debate trips over. Three different properties travel under the single banner of open source, and they are not the same property.
The first is permission: may I read this, modify it, fork it, ship it? That is what the licence answers. Open source answers it generously.
The second is practical forkability: can I actually take responsibility for this code, hold a local tree, keep pace with upstream, at a cost I can bear? That is what the architecture answers. A single-tree base system answers it well; a several-hundred-project distribution answers it badly.
There is a quieter advantage buried in the second property that only a permissive licence can offer, and it deserves to be said plainly because it is the part Linux structurally cannot match. Fork FreeBSD and you import the code, and nothing else. Fork a GPL tree and you import the code together with the licence's conditions, which travel with every line into your new system and remain there in perpetuity. Permissive licensing is the only kind that genuinely lets go. A BSD fork is a clean break; a GPL fork is a clean break with a chaperone attached, governing what you may combine the result with and under what terms you may ship it ever after. The Linux kernel cannot offer the first kind, because the kernel is GPLv2, and the GPL was designed, with complete deliberation and no apology, precisely not to let go. That is a virtue in the FSF's reading and a structural ceiling in a sovereignty reading. It is not a flaw; it is a property, and it is the property that decides whether the receiver who forks owns the fork or merely holds it on conditions someone else wrote.
The third is jurisdiction: who governs the upstream from which I receive all this, and under whose law do they sit? That is what the institution answers. And it is the property that the sovereignty conversation, having congratulated itself on the first two, tends to leave in the dark.
Most sovereignty programmes answer the first question, mistake it for the third, and wonder, two budget cycles later, why the lever still reaches them. Open source is a statement about permission. It is not a statement about jurisdiction. The whole European sovereignty programme, in every capital that has taken it up, tends to begin and end at the same sentence: we use open source. That sentence answers the permission question and nothing beneath it. The point at which a programme congratulates itself on open source is, with some reliability, the precise point at which it stops being sovereign.
The 84,3 %
The Linux Foundation's 2024/2025 Annual Report states that 84,3 % of kernel commits in the reporting period came from developers paid by their employers, distributed across more than 1.780 organisations.
This is not a scandal. It is a description. The kernel is mature corporate infrastructure; the companies that ship it contribute back because doing so is cheaper than maintaining out-of-tree patches forever. The arrangement has, over thirty years, produced a kernel that runs an extraordinary share of the world's compute.
What the figure does mean is that the kernel's direction of travel is, in the aggregate, the direction that paid-developer salaries point, and those salaries are paid, in the main, by a particular cohort of hyperscalers, hardware vendors and distribution vendors. A European entity that wants to take responsibility for the kernel meets this less as ideology and more as a payroll. To hold a local fork is to fund a team that can keep pace with upstream. The salaries are not optional; the Linux Foundation's figure is, in effect, the labour cost of remaining current. FreeBSD's developer base is smaller and proportionally less corporate, which is not always an advantage, but does mean the institutional bet required to hold a local tree is a different and smaller size.
That is still the architectural and economic half. Now the half that gets pulled.
The Lever, Applied
In October 2024 the kernel's MAINTAINERS file was edited to remove approximately eleven entries, under the stated reason of compliance requirements. Linus Torvalds confirmed the change shortly afterwards and declined to reverse it, observing that the requirements in question were not solely an American matter. The maintainers held positions in a jurisdiction that had come under expanded sanctions, and the Linux Foundation, registered in the United States as a 501(c)(6), is bound by US legal reach in its operations.
Which jurisdiction in which month is not the point, and this piece takes some care not to make it the point. The point is that the lever is institutional, not technical. Forking the kernel's source does not fork its governance. The source is in your hands; the governor is in someone else's capital, holding a registration certificate issued under someone else's law. No licence text overrides that certificate, and no architecture diagram contains it.
If one suspects this is a peculiarity of free software, of unpaid maintainers and mailing-list governance, last week supplied the correction, from the opposite end of the licensing spectrum. On 13 June 2026 the US Commerce Department directed an American AI company, Anthropic, to suspend access to its two most capable models for all foreign nationals, whether inside or outside the United States, three days after launch. The company, disagreeing on the merits, complied, and withdrew the models from every customer in order to do so, a commercial product serving, by its own account, hundreds of millions of people.
Note what that case is, and what it is not. It is not open source. It is the proprietary, paid, contracted opposite of open source: a commercial model behind a paywall, with terms of service and account managers and an invoice. And it made no difference whatever. The paying customer had no more leverage against the lever than the unpaid kernel contributor did. The contract was not a fork; the subscription was not a sovereignty. Both ends of the licensing spectrum, the freely-open and the dearly-bought, sit on top of the same institutional layer, and that layer answers to a jurisdiction. The lever is orthogonal to the licence. It always was. One simply notices it more clearly when it reaches through a contract that the customer was, until the day before, rather satisfied with.
What Single-Tree Governance Actually Buys
A single-tree project with one release-engineering team is not, by virtue of being single-tree, aligned with any particular jurisdiction. The FreeBSD Foundation is registered in Colorado. OpenBSD is administered from Calgary. Neither is in the EU, neither in China, neither in India. The architectural property travels independently of the upstream's geography, which is the good news, and the institutional property does not, which is the rest of it.
What a permissive single-tree project buys the receiver is a clean break, should they choose to make it. A receiver who forks the tree, builds it locally, and runs it on their own infrastructure is not bound to the upstream foundation's governance. They hold the code and the build process, and the licence does not require them to remain in the foundation's institutional orbit. That break is not free; it costs a staffed release-engineering capability. But the cost is bounded: one tree, one process, one team, not the assembly of an entire distribution.
The honest conclusion is the uncomfortable one. Architecture reduces the institutional lever; it does not remove it. A receiver who runs FreeBSD from the FreeBSD Foundation's tree has improved their position and not escaped it, because the upstream still sits in a jurisdiction. The only complete answer to the institutional lever is to become the institution: to hold the tree yourself, build it yourself, audit it yourself, and govern it under your own law.
A permissive licence lets you become that institution completely. The GPL does not. With the FreeBSD licensing model you can genuinely become the institution that holds and governs the tree. With the GPL variations that Linux is built from, you become an institution that still answers, on the single question of licensing, to the FSF's terms rather than your own.
And this is the decisive point, the one the whole question turns on, and it is precisely where the licence layer of the first Sunday and the architecture layer of this one meet. Fork a permissively-licensed tree and you may govern the result entirely under your own terms, in your own jurisdiction, answerable to no one. Fork a GPL tree and you may govern everything about it except the one thing that matters most for sovereignty: the licence itself, which remains in force, unrepealable, authored by someone else, co-governing your supposedly sovereign system in perpetuity. That is not a small distinction tucked into the appendix. It is the distinction on which the entire sovereignty claim stands or falls.
That said, becoming the institution is expensive. It is a great deal more expensive than a procurement slide tends to admit. The single tree is what makes it affordable enough to attempt. It does not make it free.
One observes the gap between this and the rhetoric in many current programmes. France's Interministerial Digital Directorate ordered ministries in April 2026 to plan European-only stacks by autumn, a serious undertaking; the agency's earlier hardened-Linux CLIP OS is now archived, replaced by new Linux-based platforms such as Sécurix and Bureautix, while the central productivity suite runs on certified domestic infrastructure. Schleswig-Holstein, further north, is moving some thirty thousand administrative workstations off Microsoft onto Linux, LibreOffice and Nextcloud, and reports fifteen million euro of annual saving for its trouble. The observation is architectural, not political: a sovereignty programme that adopts another distribution-as-assembly inherits that assembly's institutional dependencies along with its code, and a programme that licenses a commercial stack inherits the licensor's jurisdiction along with the invoice.
It is worth saying plainly, because almost nobody in these programmes appears to be saying it. Both of these are real improvements over the proprietary arrangements they replace; moving a public administration off a single foreign hyperscaler is a genuine reduction in exposure, and the people who did it deserve more credit than a columnist's raised eyebrow. But both are migrations onto GPL-family software, and both are being described, in the press releases and the ministerial speeches, as sovereignty. They answer the permission question and the where-is-my-vendor question, and they leave the licensing question and the institutional question precisely where they found them. One would like to know, without any great expectation of an answer, how many of the responsible decision-makers, or the consultants advising them at rates that would furnish a small data-centre, have noticed that they have taken the first step of a journey they appear to believe is already finished, and that the permissive licence which would let them actually finish it, become the institution, govern the tree under their own law, is sitting one shelf over, unmentioned in any of the slides. It is not that the migrations are wrong. It is that the word sovereignty is being asked to carry, in those announcements, a great deal more weight than any of the chosen components can bear on its own, and one is entitled to wonder how much of the matter the people spending the public money actually understand.
The Limit
This piece argues that a coherent base system, governed by a single project with a single release-engineering process, is forkable in a way that a Linux distribution is not, and that this forkability reduces, without removing, the institutional lever that sits beneath every licence.
It does not argue that BSD systems are European, sovereign, or final. It does not argue that the institution holding the tree is the last lever either. The receiver who becomes the institution, holds the tree, and governs it under their own law has answered the licence question and the architecture question and the jurisdiction question, and still runs all of it on silicon whose internal logic was decided by someone else entirely.
The architectural layer reduces the foreign attach points. It does not eliminate them. The layer that does not yield to any of the patterns above, the layer one cannot fork, cannot pay one's way out of, and cannot become the institution for, is the hardware. That is next Sunday.
You can fork the source. You cannot fork the jurisdiction. A permissive licence lets you become the institution and govern the tree under your own law; a GPL tree, even forked, keeps the licence as an unrepealable co-governor. With BSD you can become sovereign; with the GPL variations Linux is built from, you cannot. And all of it still runs on silicon someone else designed.