This repository serves as the primary home for Deep Funding, representing the project as a whole through its core infrastructure, data, and methodology. Deep Funding is an experimental mechanism for allocating public goods funding across Ethereum's open source ecosystem. Created by Vitalik Buterin and developed in collaboration with Gitcoin, Allo Capital, Open Source Observer, and leading Ethereum researchers, Deep Funding traces value through dependency graphs to reward not just high-visibility projects, but the foundational libraries, tools, and infrastructure that make the ecosystem possible.

Deep Funding addresses a fundamental challenge in public goods funding: how to fairly compensate the complex web of dependencies that underlies any successful open source ecosystem. Instead of voting directly on projects, Deep Funding builds a weighted dependency graph showing how Ethereum projects rely on each other, then uses a combination of expert jury evaluation, machine learning models, and prediction markets to determine how funding should flow through that graph.

The mechanism works in three phases. First, we map Ethereum's dependency structure—starting from core infrastructure like consensus clients, execution clients, and development tools, then tracing their dependencies through package managers and GitHub. Second, a jury of high-context individuals (including Vitalik Buterin, core client developers, and ecosystem leaders) provides comparative judgments on a subset of dependencies. Third, AI models and prediction markets extrapolate those judgments across the entire graph of thousands of projects. The result is a system where you can send funding to a single address for "supporting Ethereum," and have it intelligently routed to everyone who contributes—including the maintainer of an obscure but critical library that hundreds of projects depend on.

The first Deep Funding trial completed in 2025 with 45 expert jurors (including Vitalik, Mark Tyneway from Optimism, Toni Wahrstatter and Alex Stokes from the Ethereum Foundation, and core developers from major clients) providing 650+ comparative evaluations between 45 repositories from Protocol Guild, Argot Collective, and the Dev Tooling Guild. Over 12,000 participants competed in the model-building competition, with $30,000 in prizes awarded across provisional leaderboard rankings, composite model contributions, and research writeups.

Deep Funding is actively evolving. We are adding a jury improvement track focused on better data collection methods, juror UI enhancements with LLM summaries, and quality control mechanisms. The mechanism is integrated with prediction markets via Seer (deep.seer.pm), allowing anyone to stake on repository valuations. Deep Funding is participating in Gitcoin Grants Round 24 with $350,000 in funding to be allocated using this methodology, with the graph expanding to include 45-60 additional repositories and their dependencies.

This repository serves as the source of truth for Ethereum's dependency graph structure, a dataset for researchers exploring funding mechanism design, and the project record for ongoing Deep Funding development and future funding rounds.

The Deep Funding project involves analyzing a depth-2 directed graph of dependencies and using it to allocate funding. The graph consists of nodes representing repositories (on GitHub and various package managers) that are one or two hops away from Ethereum.

• Total number of Level 1 (seed) nodes: 31
• Total number of Level 2 (dependency) nodes: 5,024
• Total number of edges: 14,927

Here is a visualization of the V1 graph of the graph.

Here is an example of a single edge in the graph:

{
   "relation": "GOLANG",
   "weight": 0.1,
   "source": "https://github.com/prysmaticlabs/prysm",
   "target": "https://github.com/multiformats/go-multihash"
}

The source in the graph is the dependent node and the target is the dependency node. By weighting the edges of the graph, we aim to signal the most important dependencies and allocate funding proportionally to them.

Your job is to submit a list of weights for the edges, where the weight of an edge source (dependent) -> target (dependency) represents the portion of the credit for source (dependent) that belongs to target (dependency). The weights coming out of a source node into its target nodes should sum to less than one; the remainder represents the portion of credit that rests with the source node itself.

You can mine GitHub, dependency, and blockchain data for free from OSO's BigQuery or connect to other data sources.

1. Explore the dependency data at ./graph/unweighted_graph.json. In this version, every edge has a weight of zero. You can also use ./graph/unweighted_graph.csv if you prefer a CSV format.
2. Try running the example oso_forks_and_funding_weighting.ipynb notebook in the notebooks/weighting_examples directory to see how we might construct a weighted graph. This version uses a simple approach based on data from Gitcoin, Optimism Retro Funding, and fork counts. The result is exported to oso_forks_and_funding_weighted_graph.json.
3. Experiment! You can access more public datasets from OSO's BigQuery and use Vertex AI to train your own model. Or you can take things in a completely different direction!

The initial graph is seeded with the primary repos of the top consensus and execution layer projects (according to https://clientdiversity.org). We also include a set of related infrastructure projects as seed nodes.

The full list of seed nodes is:

• Consensus Clients: prysmaticlabs/prysm, sigp/lighthouse, consensys/teku, status-im/nimbus-eth2, chainsafe/lodestar, grandinetech/grandine
• Execution Clients: ethereum/go-ethereum, nethermindeth/nethermind, hyperledger/besu, erigontech/erigon, paradigmxyz/reth
• Other Infra & Dev Tools: a16z/helios, alloy-rs/alloy, apeworx/ape, eth-infinitism/account-abstraction, ethereum-lists/chains, ethereum/fe, ethereum/py-evm, ethereum/remix-project, ethereum/solidity, ethereum/sourcify, ethereum/web3.py, ethereumjs/ethereumjs-monorepo, ethers-io/ethers.js, foundry-rs/foundry, hyperledger-web3j/web3j, nethereum/nethereum, nomicfoundation/hardhat, openzeppelin/openzeppelin-contracts, safe-global/safe-smart-account, scaffold-eth/scaffold-eth-2, vyperlang/titanoboa, vyperlang/vyper, wevm/viem

The latest version of the graph no longer includes web3/web3.js following the announcement that the project is being sunsetted.

Next, we pull the Software Bill of Materials (SBOM) for each of the above repositories and identify all packages in Go, Rust, JavaScript, and Python.

This gives us a list of approximately 7,000 packages:

• JavaScript: 5575 (hosted on npm)
• Rust/Cargo: 1363 (hosted on crates.io)
• Go/Golang: 387 (hosted on GitHub)
• Python: 162 (hosted on PyPi)

Finally, we try to map each package to an open source repository and build a dependency graph. In total, we are left with 2,046 unique package maintainers on GitHub.

The notebook used to create the initial graph is generate_unweighted_graph.ipynb. You can experiment with adding layers or changing the seed nodes, and getting fresh data from OSO's BigQuery.

Let us know if you find any issues with the data or the graph construction.

There are several data dumps included in ./datasets to get you going, including two from OSO and one from Drips.

The largest is a parquet file that contains a snapshot of GitHub activity data for all relevant repositories, indexed by Git user ID:

In the directory ./notebooks/weighting_examples, we also show some examples of how you can join the graph on other datasets and start weighting the graph. These examples export JSON data to ./graph/weighting_examples.

We've included a few utilities for validating and serializing the graph:

• validate_graph.py: Validate the graph edge weights add up to 1.0 or less for each seed node.
• serialize_graph.py: Serialize the graph to a JSON file.

• Get more data (free): OSO Documentation
• Ask questions: OSO Discord
• Report issues: Open an issue in this repository