Deep Funding Will Transform Open Source from Donation-Based to Fully Paid

Relevant XKCD

When the Log4j vulnerability was discovered in late 2021, Volkan Yazici worked 22-hour days to fix it. He did this work for free. The vulnerability put billions of machines at risk, affecting tech giants from Microsoft to Apple. Yet Log4j, like much of the internet's critical infrastructure, is maintained by volunteers like Volkan.

This crisis isn't new, but it's getting worse. The Linux Foundation estimates that 70-90% of today's applications are built on open source software. Yet according to recent surveys, 60% of maintainers are unpaid hobbyists, and over half have quit or considered quitting. The developers who maintain the code our digital economy depends on are burning out.

You might wonder: Why can't open source projects just charge for their software? The problem is dependency chains. Modern software is built in layers, with each project depending on dozens or hundreds of others. When company A builds on project B, which uses library C, which depends on tool D, there's no reliable way to ensure value flows through the chain. The result? Only the top layer can effectively monetize, while critical infrastructure remains unpaid.

Enter Deep Funding, introduced by Ethereum co-founder Vitalik Buterin recently. At first glance, it seems like a modest project - a $170k pilot to support Ethereum's dependencies. But look closer and you'll see it's revolutionary: Deep Funding creates a way to quantify exactly how much value each piece of software contributes to the projects built on top of it.

This isn't just another voluntary payment system - it enables something much bigger. For the first time, we can imagine open source software that requires payment while preserving the core benefits of open source. Just as the GPL license transformed software sharing in the 1980s, a new kind of license built on Deep Funding could transform how we compensate open source creators. I call this license the Deep Value License. But before we look at it, let’s understand what deep funding is.

Deep Funding Changes The Game

The idea behind Deep Funding is deceptively simple: instead of asking "How much does project X contribute to humanity?" it asks "How much of project Y's value comes from X?" This shift from absolute to relative value measurement is key: While it's nearly impossible to determine the abstract worth of a software library, we can more easily assess how much it contributes to the projects built on top of it.

Deep Funding is designed to fund the entire open source graph. (Source: Vitalik's Post)

Here's how it works: Deep Funding creates a comprehensive map of software dependencies, showing how projects rely on each other. Then, it opens up a market where anyone (particularly AI models) can propose weights for these dependencies - essentially saying "30% of Project A's value should be credited to Library B that it depends on." Finally, a jury of experts performs spot-checks on random parts of the weighted graph to validate the proposed allocations.

This approach solves the core problem that has plagued open source funding: scaling human judgment about what the value of open source software is. Traditional funding mechanisms either require extensive public campaigning (when using large groups of evaluators) or create bottlenecks through private relationship building (when using small groups of evaluators). Deep Funding circumvents these issues by combining AI-driven initial assessments with targeted human expertise for validation.

The goal of deep funding is to make better voluntary contributions to open source software. But here's where it gets really interesting, we can go further.

From Voluntary to Required: The Deep Value License

If we can accurately measure how much value flows through software dependency chains, we can do more than just suggest voluntary payments - we can require them. Imagine a new kind of open source license that preserves all the benefits of open source (source code access, right to modify, right to redistribute) but adds one crucial element: a requirement to pay based on the value derived. I call it the Deep Value License - a new kind of open source license made possible by Deep Funding's ability to track value creation through dependency chains.

Here's the key insight: Deep Funding doesn't just measure value - it makes payment flow-through possible. Remember the dependency chain problem? Where company A builds on project B, which uses library C, which depends on tool D? The Deep Value License requires that any software incorporating a licensed component must also adopt the license and flow through payments. When company A's software generates revenue, they must make payments that flow through to B, C, and D based on their measured contributions. Every piece of the stack gets paid.

Think of it like the GPL's viral nature - just as the GPL requires derivative works to also be GPL-licensed, the Deep Value License requires software that incorporates it to maintain the payment flow-through requirement. But unlike the GPL, which only ensures code remains open, this ensures value flows back to the creators who made it possible.

The real innovation is that Deep Funding makes these payment requirements practically enforceable. Without Deep Funding, trying to require payments through dependency chains would be an accounting nightmare - how much should each layer get? Who tracks all the dependencies? Who handles the payments? But Deep Funding's algorithmic value attribution gives us clear, automated answers to these questions. We can finally answer both "who should get paid?" and "how much?" in a way that's both fair and scalable.

Of course, this raises important questions: What about non-commercial use? What about other open source projects that want to use the software? The Deep Value License can handle these gracefully - keeping the software free for educational use and open source development, while requiring payments only when it's used to generate business value. And just as the GPL has safe harbor provisions to protect good-faith compliance efforts, the Deep Value License would include protections for users making reasonable attempts to meet its requirements. This will encourage compliance with the payment terms.

The Price Problem: You Can't Just Pick a Number

Here's a tricky challenge with required-payment open source: anyone can decide to use your software at any time. That's the beauty of open source - but it creates a pricing puzzle. Unlike traditional software sales where you can negotiate with each customer, open source by nature means unknown users will incorporate your software in ways you never imagined.

So how do you set pricing that works for every possible use case? A large tech company might use your database software to process millions of transactions, while a small startup might use it for internal tooling. A cloud provider might build services around it, while a research lab might use it for data analysis. You can't negotiate with each user - you need defaults that make sense across all these scenarios.

This gets even more complex when you consider payment flow-through. The price can't just work for your software - it needs to generate fair compensation for all the dependencies in your stack. Set the price too high and you'll stifle adoption; too low and the whole dependency chain gets underpaid.

Value Chain Roles Create Smart Defaults

The solution is to think about software not in terms of fixed prices, but in terms of how it creates value. Different types of software create value in fundamentally different ways. Infrastructure software like operating systems enables computation itself. Service software like databases handles critical operations. Application software directly serves end users.

Each of these roles needs different payment models. For infrastructure software, payment might be based on compute resources consumed - if you're running Linux with this license, you might pay based on CPU hours × a standard rate. For service software like databases, usage metrics like data throughput could determine payment. Application software might take a small percentage of end-user revenue.

This approach creates sensible defaults that scale automatically with value created. A small startup using infrastructure lightly pays little, while a tech giant running millions of servers pays proportionally more. A database processing thousands of transactions pays based on actual usage. Frontend applications contribute based on the revenue they generate.

Of course, no set of defaults will be perfect for every situation. That's why the Deep Value License would include provisions for mediation when the standard calculations don't fit. But for most users, these value chain role calculations provide a reasonable starting point that scales naturally with the value they derive from the software. This might sound complex, but it's designed to be simple for end users. When you use software under the Deep Value License, you only need to track your usage and make payments to a single specified payment processor. The processor handles distributing funds through the dependency chain based on the Deep Funding algorithm's weight assignments. Think of it like how credit card processors handle complex networks of payments behind a simple swipe.

This Could Transform Software Production Entirely

Think about what happens when open source maintainers can actually capture the value they create. Suddenly, the choice between "make it open source" and "make it profitable" disappears. Teams could build sophisticated software in the open, knowing they'll be compensated proportionally to its use and value.

This isn't just about better funding for existing open source - it could fundamentally change what gets built as open source in the first place. Today, companies often keep their most valuable software proprietary or use complex "open core" models where only basic features are open source. With value-based required payments, they might choose to make everything open source. After all, if you're going to get paid either way, why not get the benefits of open collaboration?

Consider what happened when MySQL was introduced - it transformed the database market by making powerful database technology accessible to everyone. Now imagine that same democratizing effect, but across all types of software. The key difference? This time the creators get paid.

DAOs Could Revolutionize How Software Gets Made

There's an even more radical possibility here that wasn't part of Deep Funding's original vision: truly decentralized software organizations. Think about it - if we have a system that can automatically track value creation through dependency chains and enforce payment flow-through, we could enable entirely new organizational structures for creating software.

Imagine a DAO (Decentralized Autonomous Organization) that exists solely to create and maintain open source software. The software generates revenue through the Deep Value License, with payments flowing to the DAO. But here's where it gets interesting: the DAO could distribute this value in all sorts of ways. It might pay contributors directly based on their work, issue tokens that represent ownership shares, reward community members who contribute in non-coding ways, or create complex incentive structures we haven't even imagined yet. The key is that these decisions about value distribution could be made collectively through the DAO's governance mechanisms, rather than through traditional corporate hierarchies.

This isn't just a minor tweak to how software companies operate - it's a fundamental reimagining of how software development could be organized. Traditional software companies need centralized structures to handle sales, licensing, and revenue distribution. But with Deep Funding's automated value attribution and the Deep Value License's payment requirements, much of this coordination could happen through smart contracts and community governance. Of course, there are thorny legal questions to solve. Can a DAO own copyright? How does intellectual property law interface with decentralized organizations? These aren't simple problems. But the technical foundation - automatically tracking value creation and enforcing payment flow-through - could enable new organizational structures that were previously impossible.

This points to something profound: Deep Funding and the Deep Value License might not just change how we pay for software - they might transform how we organize to create it in the first place. The same way Bitcoin enabled new forms of decentralized value storage and Ethereum enabled new forms of decentralized applications, this system could enable new forms of decentralized software development organizations.

But Yes, There Are Real Challenges To Solve

The Deep Value License isn't without complexities. How do we handle international enforcement? What about educational or non-commercial use? The license will need careful provisions for these edge cases - perhaps keeping it free for educational use while requiring payments only for business purposes.

There's also the community question. Open source has thrived on voluntary contribution and collaboration. Will adding money to the equation change these dynamics? It might. Some developers might feel less motivated when money is involved. But it could also bring in new contributors who previously couldn't afford to work on open source.

The technical challenges are substantial too. We'll need new infrastructure for handling payments, new businesses to process and distribute funds, and clear protocols for how different payment processors interact. But these are solvable problems - similar to how the credit card network evolved to handle complex payment flows.

This Is How Open Source Grows Up

The current crisis in open source isn't just about funding - it's about the fundamental mismatch between value created and value captured. When critical infrastructure like Log4j can take down the internet, yet its maintainers work for free, something is broken in our system.

Deep Funding gives us a way out. Not just through better voluntary payments, but by enabling an entirely new model: open source software that's both truly open and properly compensated. Just as the GPL made "free software" a viable alternative to proprietary code, the Deep Value License could make "value-based open source" a new standard. This isn't about abandoning the ideals of open source - it's about making them sustainable at global scale. The volunteer-based model worked brilliantly for getting us here, for building the foundation of our digital world. But that world has grown far beyond what volunteers can sustainably maintain.

The next chapter of open source needs to combine the best of both worlds: the innovation and collaboration of open source, with the sustainability and professionalism of commercial software. Deep Funding makes that possible. Now it's up to us to build it.