The argument

1. Open source is good

We'd use a standard open-source licence if it paid for itself. We release our own small libraries under MIT and depend on open-source software every day. Nothing here is an attack on the people who build it. Open source is one of the most generous things people have ever done for each other.

2. Freedom zero sets the price at zero

Open source rests on "freedom zero": the freedom to run the program for any purpose, with no conditions. That freedom is why open source spreads so well. It also means nobody can attach any condition to using the software — including a contribution, however small.

Open ownership changes exactly that one thing, and we want to say so openly rather than bury it.

3. From a price of zero, two engines are left

When using software costs nothing, the work of building it gets paid for in one of two ways:

• Volunteers, giving their spare time out of passion; or
• Companies, funding it because it serves their business.

Both have built remarkable things. Both have limits.

4. Companies pay for what serves them

This isn't a complaint about companies. A company's directors are legally obliged to act in the company's interest. So when a company funds a commons, it does so because it gets something back, and the project's direction tends to follow what the funder needs. You can't wish for nicer companies; the duty is the duty.

That's an observation about economics, not people. It also means a well-funded company can take a permissively licensed project, build a better free version, and out-compete the original.

5. So the price of zero is how capture happens

Put those together and you get the uncomfortable part. For big software, the freedom that keeps open source open is also what leaves it with nobody to pay but those who'll eventually steer it. Freedom zero isn't the defence against capture; for this kind of project, it's the route in.

We know that's a sharp thing to say on a site about licences. We say it carefully, and only about large, user-facing software that needs sustained money. It doesn't apply to most open source.

6. Volunteer time can no longer keep big software safe

AI has raised the cost of security. Each new model can find bugs in large codebases faster than the last, and only well-resourced, paid teams using the same tools can respond at that speed. The input to secure software used to be time. Now it's money.

We don't want big software to depend on volunteers — our own time or anyone else's. The people who maintain it should be paid properly, and so should the people who come after them.

7. So: change one thing

You can't take a little from a lot, so you have to take a lot from a few.

That's the usual answer, and it's why the few end up in charge. A million-dollar project with a million users costs a dollar each — or a million from one funder, or a hundred thousand from ten. Every option except "a little from everyone" hands control to whoever paid.

Open ownership is the "a little from everyone" option, made workable. Each person who uses the software is a member, and members pay a little or declare hardship. The people who fund it own it, one vote each. You can't capture it by funding it, because funding it is being one member with one vote.

There is a minimum, and it isn't money

The real minimum is attention: five minutes, once a year, on a short declaration. Paying alone isn't participation, and someone on hardship who does the declaration has done everything that's asked. Open source sets the minimum at zero, which is right for most software. For this kind of project, we set it at five minutes — freedom isn't quite free.

Open source doesn't give genuine ownership

Open source gives you ownership of your copy. That's real: you can run it, change it, fork it. But it gives you no say over the project itself — its direction, priorities, who merges what, who funds it, what happens to it in ten years. All of that sits with whoever pays the maintainers.

"You can always fork" sounds like ultimate ownership. But forking means taking on the whole cost of maintaining it yourself. A right that only works if you become the thing you couldn't afford to be is a right almost nobody can use.

Make the prize worthless

Any membership-based structure can be attacked by someone with enough money: hire enough real people and you can flood any pool. So open ownership doesn't rely on keeping attackers out. It makes the prize worthless. The trust that holds the software can't sell it, can't profit from it, can't close the source and can't stop a fork. If someone captures it and does something the members hate, the members fork and walk, and the captor is left holding an empty name.

The security isn't the lock on the door. It's that the room is empty.

Never build the cage

The obvious way to enforce a condition on use is technical: licence keys, activation, phone-home, lockouts. Open ownership refuses all of it. Those tools would turn the software into the thing it's meant to replace.

Make the right thing easy and the wrong thing clearly wrong — then stop.

Enforcement is honour plus law. Large organisations don't knowingly breach licences, so compliance concentrates where it matters most. Some individuals will get away without paying, and we'd rather accept that than build surveillance into software people are meant to own.

This is a bet, and we might be wrong

Open ownership is a conditional bet: if the cost of keeping big software good and safe keeps rising the way we expect, someone should have built this already. If we're wrong, the design fails safe. Every obligation in the licence falls away when there's no working way to meet it, and if the trust ever ends, the software simply becomes permissive open source.

We expect people who hold freedom as an absolute to reject this, and we respect that. It may never be universal. A small project with a community that loves it would be enough.

How the model works →   Is it for your project? →   What we haven't settled →