Skip to content
Velloreth
Technology 10 min read

Open Source Sustainability: The Funding Problem

Most commercial software depends on unpaid maintainers. Here is how the funding gap happened, what AI-generated noise made worse, and which models are actually working.

By

Open source is the foundation of nearly all modern software, and a large share of that foundation is maintained by people who are not paid for it. That arrangement has worked for decades on a combination of idealism, employment goodwill, and sponsorship. It is fraying. Burnout is routine, AI-generated noise has flooded maintainer inboxes, and a series of high-profile incidents — from the xz backdoor to abandoned critical packages — have made the economics impossible to ignore.

This is not a guilt piece. It is a look at how the funding gap actually works, what made it worse recently, and which solutions are producing results rather than press releases.

The shape of the problem

Start with the dependency graph. Synopsys’s 2025 Open Source Security and Risk Analysis (OSSRA) found that more than 97% of commercial software projects contain open source components. The same report found that 91% of audited open source components showed no clear signs of active maintenance in the past two years — some of that is stable, finished software, but a great deal of it is quietly abandoned code sitting in production dependency trees.

The people doing the maintaining are, overwhelmingly, not compensated for it. The 2024 Tidelift maintainer survey reported that roughly 60% of open source maintainers are unpaid, and about 60% have either quit or seriously considered quitting — primarily due to burnout and lack of recognition. Of those who do earn something, only about 26% reported more than $1,000 per year from their open source work.

The concentration is extreme. Research presented at the State of Open conference in 2025 noted that many projects classified as critical infrastructure are supported by very few people, often with one person doing most of the work. Google’s Sophia Vargas summarized the situation plainly: projects are chronically undersupported relative to how much the industry depends on them.

Why voluntary funding has not scaled

If 97% of commercial products depend on open source, why does the money not flow? Three structural reasons.

Free riding. Any single company can decide that someone else will fund the dependency. The value is diffuse across thousands of firms; the cost of contributing is borne by whoever volunteers first. This is a textbook collective-action problem, and voluntary generosity does not solve it at the scale required.

Misaligned incentives around visibility. Companies fund the projects with conference presence and logo-friendly branding more readily than the unglamorous libraries everyone silently depends on. The most critical packages are often the least photogenic.

No procurement category for open source maintenance. A company has budget lines for cloud services, security tools, and contractor engineering. “Pay the person who maintains our JSON parser” does not map to any of them cleanly, so it never gets proposed.

What AI changed, and mostly for the worse

Generative AI has been a mixed gift for open source. It has made contribution easier for newcomers — and it has flooded maintainers with low-quality submissions at a scale they cannot triage.

The numbers are grim. OpenSSF has reported that only about 5% of bug bounty submissions are genuine vulnerabilities. Daniel Stenberg, founder and maintainer of cURL, ultimately shut down cURL’s bug bounty program, describing the flood of AI-driven, low-quality reports as a “death by a thousand slops” that was damaging maintainers’ ability to do real work.

ESET’s H1 2026 threat research added a supply-chain angle: malicious “AI skills” — components designed to let AI agents access systems and exfiltrate data — rose fivefold between March and May 2026. Maintainers are not only receiving noise; they are receiving deliberately malicious noise engineered to look like helpful contributions.

The result is a perverse inversion: the tools that made writing software easier also made maintaining other people’s software harder, and the people doing the maintaining are the least resourced to absorb the load.

When burnout becomes a security incident

The clearest case study is xz Utils. In 2024, a backdoor was discovered in the compression library — code that would have given an attacker remote access to sshd on affected systems. The attack worked over years: an account (“Jia Tan”) contributed steadily, gained trust, and was offered co-maintainership. A decisive factor in that offer was that the sole maintainer, Lasse Collin, was burned out and genuinely needed help.

The xz backdoor is the funding problem expressed as an exploit. An exhausted maintainer, no institutional support, and an attacker willing to supply the labor the ecosystem would not fund.

Hector Martin’s abrupt departure from Asahi Linux in early 2025 — citing burnout and demanding users — is the same pattern in a less dramatic form. The Register’s coverage of the State of Open conference that year collected several such stories; they are not outliers, they are the median experience of maintaining a popular project.

Models that are actually working

Pessimism about funding is easy. Several models are producing real money for maintainers, and they are worth understanding in detail.

Corporate pledges and direct funds

The Open Source Pledge (championed by Sentry and others) asks companies to pay a meaningful annual amount per developer toward the maintainers of packages they actually use. Sentry’s own fund has distributed hundreds of thousands of dollars per year directly to maintainers of Sentry’s dependencies. The model works because it ties the payment to real dependency use rather than to a general donation.

Foundation programs

The Linux Foundation and CNCF route corporate membership money to project maintenance, infrastructure, and security work. OpenSSF has been particularly active:

  • Alpha-Omega invested $5.8 million across 14 critical open source projects in 2025 and completed over 60 security audits and engagements.
  • OpenSSF’s Technical Advisory Council awarded over $660,000 across 14 technical initiatives in the same period.
  • Focused security engagements resulted in 52 vulnerabilities fixed and 5 fuzzing frameworks implemented.

OpenSSF’s funding partners now include Anthropic, AWS, Google, Google DeepMind, GitHub, Microsoft, and OpenAI — notable precisely because the firms benefiting most from open source (the AI industry especially) have begun paying into the pool that maintains it.

Endowments and dedicated funds

HeroDevs committed $20 million to an Open Source Sustainability Fund aimed at maintainers of critical, often end-of-life components — the category with the least commercial incentive and the highest risk. New endowments continue to form; the pattern is “large one-time capital, invested, proceeds distributed to maintainers” rather than annual fundraising drives.

Revenue shares

OpenJS and HeroDevs announced a revenue-sharing approach that directs a slice of commercial revenue back to projects. This is promising because it scales with the commercial value extracted, rather than relying on a fixed donation that does not grow with usage.

Government and public funding

Germany’s Sovereign Tech Fund has funded maintenance of public-interest digital infrastructure directly. This model treats open source as a public good with a maintenance cost, the way roads are maintained — politically imperfect, but structurally honest.

Tiered registry access

The most controversial model, and possibly the most important. In September 2025, major package registries sent an open letter via OpenSSF calling for tiered access models: free access for hobbyists and open source projects, mandatory contributions for high-volume commercial consumers.

The justification is infrastructure, not ideology. Analysis cited in the letter found that 82% of registry bandwidth demand came from less than 1% of IP addresses — companies effectively using public registries as free CDNs, downloading the same artifacts hundreds of thousands of times per day. “Commercial-scale use without commercial-scale support is unsustainable,” the letter stated. Michael Winser of Alpha-Omega put it more bluntly at FOSDEM: people conflate open source software (free to use) with open source infrastructure (expensive to operate).

What companies should do

If you run a company that ships software, the responsible baseline in 2026 looks like this:

  1. Know your critical dependencies. You cannot fund what you have not identified. Generate an SBOM, or at minimum list the 20–50 packages your production systems cannot run without.
  2. Pay the maintainers of those dependencies. GitHub Sponsors, Open Collective, or a pooled program like the Open Source Pledge. Per-developer annual contributions are a simple model: pick a number, allocate it to the maintainers of your real dependencies.
  3. Fund work, not just wallets. Maintain time for engineers to work on upstream issues the maintainers have asked for. Drive-by refactors and unrequested “improvements” add review burden; ask what is needed.
  4. Hire maintainers where you can. Several critical projects are sustained primarily because one company employs the lead maintainer. That arrangement is fragile but real, and better than the alternative.
  5. Treat registry bandwidth as infrastructure you should pay for. Cache. Mirror. Stop hammering public endpoints from CI at a scale that would embarrass you if it were your own server.

What individual developers can do

You do not need a corporate budget to contribute to sustainability:

  • Sponsor the packages you install most, even at $3–5 per month. Small recurring amounts are more useful than one-off $50 donations because maintainers can plan around them.
  • Triage before you report. If you think you found a bug, reproduce it on the latest version, search existing issues, and write a minimal example. Every high-quality report is one less hour of maintainer triage.
  • Contribute documentation and tests. These are the contributions maintainers consistently say they need and volunteers consistently skip.
  • Say something kind occasionally. The State of Open research found user hostility to be a significant factor in maintainer attrition. It costs nothing and measurably matters.

The uncomfortable comparison

It is worth stating plainly how out of scale the current arrangement is. A mid-size SaaS company might spend $50,000 a year on observability tooling, $30,000 on a project management suite, and $0 on the compression library, JSON parser, and HTTP client that every request in that product depends on. The line items are not irrational in isolation — the tools have invoices, support contracts, and procurement owners; the open source dependency has none of those things. The aggregation is irrational, and aggregating is exactly what an economy of software firms is supposed to be good at.

The models described above — pledges, funds, endowments, tiered access — are all attempts to give the uninvoiceable dependency an invoice. Some of them will work at scale. The question for any individual company is not whether the ecosystem will solve this collectively, but whether it will be the kind of company that helped before a forced settlement became necessary.

Where this goes

The ecosystem is not collapsing, but it is consolidating risk into fewer, more exhausted hands. The funding models above are working at the margins and beginning to work at scale — corporate pledges, foundation grants, endowments, and the emerging tiered-access approach each attack a different slice of the problem.

The unresolved question is whether the industry will treat open source maintenance as a shared cost worth paying proactively, or whether it will take another xz-scale incident — or a package quietly going dark under a major product — to force the issue. The evidence from xz, from cURL’s abandoned bounty program, and from the registry bandwidth analyses all points the same direction: the current equilibrium is unstable, and stability will cost money.

The only honest conclusion is also the boring one: open source is infrastructure, infrastructure needs maintenance budgets, and the people maintaining it are currently subsidizing the entire software industry out of their evenings. That is not a moral failing of individual developers. It is a market failure with known, fundable solutions — solutions that require someone, somewhere, to put a line item in a budget.

Frequently asked questions

Why don't big companies just pay open source maintainers?
Many do contribute, but the incentive structure rewards free riding: any single company can let others fund a dependency and still benefit. Collective-action problems like this usually need pooled funding (foundations, pledges) or mandatory contributions (tiered registry access), not voluntary generosity alone.
What was the xz backdoor and what does it have to do with funding?
In 2024, a backdoor was discovered in xzUtils, a compression library. The attacker spent years building trust and was offered co-maintainership in part because the sole maintainer, Lasse Collin, was burned out and needed help. Maintainer exhaustion is not just a wellbeing issue — it is a supply-chain attack surface.
How can a small company help sustainably?
Join or emulate programs like the Open Source Pledge (pay maintainers of the packages you depend on a meaningful annual amount), fund through GitHub Sponsors or Open Collective, hire maintainers for part-time work, or contribute engineering time on issues the maintainers actually want done — not drive-by refactors.
Are paid tiers for package registries a good idea?
They are gaining serious traction. In September 2025, major registries sent an open letter via OpenSSF calling for tiered access models that keep hobbyist use free while charging high-volume commercial consumers — because some companies effectively use public registries as free CDNs, with 82% of bandwidth demand coming from under 1% of IPs.