I've been thinking about this very hard problem while walking the dog.

Individuals and companies love open source software, but the current donation models don’t really work.

I thought this problem was bad for programming libraries (e.g. the recent Tailwind stuff), but after using Linux desktop open source—which has much less incentive for companies to donate or sponsor—oh boy, it’s bad.

Open source evokes a lot of emotions, but at its core, to me, it’s two things:

A collection of “features” (depending on license / governance):

* You can use it for free, no matter what

* You can see how it works

* You can modify the software

etc.

These are genuinely valuable features, which is why open source has won.

But these features are unavoidably coupled to business models and incentive structures for the developers who create this value.

Right now, open source developers and companies can only extract a relatively small percentage of the (considerable) value they create. As a result, only very large or strategically important projects become financially sustainable.

I agree with the article that the solution likely involves a different business model or incentive alignment—but this is a very hard problem.

We’ve seen major business model shifts outside open source during my career:

- SaaS software (used to be one-time payments)

- Microtransactions in games (personally dislike them, but they radically changed incentives and revenue)

These shifts are often counterintuitive and closely tied to human behavior.

I don’t agree with the specific solution proposed in the article, but I don’t have a clean answer either.

My best (very rough) idea:

Create a non-profit that builds tooling and infrastructure to measure open source usage (tricky!).

Loosely, you run something like:

  oss-usage

And it generates a report for a machine (or an entire company):

  'tailwind': 5   # units TBD
  'npm': 8
  'haskell': 1

Then a centralized registry where individuals and companies can disclose usage and donations:

  'stripe': {
    usage: {
      'tailwind': 5,
      'npm': 40,
      'haskell': 1,
      'ruby': 60
    },
    totalDonationDollars: 100000,
    donationBreakdown: {
      'ruby': 10000,
      'haskell': 100,
      'tailwind': 5000
    }
  }

  'oracle': 'not yet claimed'

  'dave': {
    usage: {
      'svelte': 20,
      'pnpm': 40
    },
    totalDonationDollars: 100,
    donationBreakdown: {
      'svelte': 20,
      'pnpm': 40
    }
  }

Donated funds are held centrally and can be claimed by project maintainers.

Companies can claim (or not) their usage. Developers can claim (or not) their projects and funds.

Donations are aggregated into one transaction per month, solving the microtransaction problem.

This creates a public, open record of who is funding open source. I think that could be a strong incentive for larger companies—engineers will notice when choosing where to work.

Bad actors who under-donate or refuse to disclose won’t be invisible; we’ll know where they stand.

Anyway - if you’ve read this far and are interested in working on or funding this idea, come find me: https://richardgill.org