A license file changes hands

A maintainer edits one file on a Tuesday. By Friday the same engine exists in three places: the original repository, a community fork registered under a foundation, and a hosted copy with a monthly invoice attached. Not one function was added or removed. What moved was the line between the part anyone could run and the part someone would pay for — and both the community and the revenue ended up thinner than before.

That is not a cautionary tale invented for effect. Commercial open source startups had raised a cumulative $26.4 billion by 2024, at roughly 250 deals and about $9 billion deployed per year across 2019–2024, according to the Linux Foundation, COSSA and Serena. The category is funded well enough that a misplaced boundary becomes an expensive mistake rather than a stylistic preference (Linux Foundation / COSSA / Serena).

What the numbers actually reward

The same report found that 12% of commercial open source companies had gone public or been acquired. Median IPO valuation among those firms was $1.3 billion, against $171 million for closed-source peers — about seven times as much. Acquisition figures were $482 million versus $34 million, roughly fourteen times. Read that twice: the companies that drew a deliberate, fairly generous boundary around the core did not shrink their exit. They multiplied it.

Demand is not the missing piece either. A separate Linux Foundation and Canonical survey reports that 83% of enterprises see open source as valuable to their future, 46% say its commercial value rose year over year, and 86% credit open source software with higher productivity. The open source services market is projected to reach $50 billion in 2026 (Linux Foundation × Canonical). On the far side of a well-drawn line there is a real buyer with a real budget.

Laying the boundary out

Decision pointLeft of the line, freeRight of the line, paidWhat breaks if the line moves
Execution coreSandbox, runtime, basic APIs, fully auditableNothing; this stays openRestrict it and contributors fork within days
Identity and signingPublic spec, reference hooksHosted signing, key rotation, SLA-backed verificationHosts refuse to embed code they cannot verify
DistributionOne build, open catalog entryCurated placement, discovery, revocation toolingThe catalog floods with unverified entries
GovernancePublished spec, open issue trackerReview board, appeals, trust badgesThe label says open, the license says otherwise
SupportCommunity forumsContracted response times, a named ownerRevenue never quite materializes

The case for drawing no line at all

There is a sincere argument for putting everything under a permissive license and letting hosting and support revenue arrive on their own. It works in narrow categories where integration itself is the product. But it sidesteps what the exit data says: the deliberate boundary is what pays for the maintainers who keep the free core healthy. A boundary is not a tax on the community; it is the mechanism that settles the bill for something the community consumes every day.

Here is the reversal, and it matters more than any slogan. If the paid layer is simply the core with a license gate bolted in front, the arrangement collapses from both directions at once. Contributors walk because the value they created was enclosed after the fact, and buyers refuse to pay a second time for code they were already free to read. The Open Source Initiative found that about 23% of models calling themselves open use Apache 2.0, while nearly 60% of claimed-open models carry no license at all (OSI). An open label without a license is not openness. It is a boundary drawn in fog, and trust erodes on both sides of it.

The developer survey published in IEEE Transactions on Software Engineering points the same way: 67.9% of Rust, OpenStack and Linux kernel developers view corporate involvement positively, and the reason they give is that the community and the company both win (IEEE TSE). Contributors are not hostile to commercial layers as such. They are hostile to layers that extract without returning anything to the commons they still depend on.

Where the line belongs

For a runtime intended to be embedded by several hosts at once, the principle gets concrete quickly. Put the execution core, the sandbox and the basic capability APIs in the free layer, under a license nobody has to parse twice. Put the work that requires continuous human effort — signing, identity brokering, catalog review, revocation, incident response — in the paid layer, because those items burn money every month and are worth paying for. CrossMiniApp sits on that side of the line: one open runtime core, with the governance and distribution layer sold to the hosts that need it.

That placement is defensible precisely because a shared runtime cannot be owned by a single vendor's legal department. It has to be a product decision that contributors can audit and hosts can procure against. Draw it well and the free engine grows the community while the paid layer funds its upkeep. Draw it badly and the fork shows up on a Friday.

Sources