Ethereum Developer Report: Engineering at Scale

What 8.7 Million Contracts Actually Signal

TL;DR:

• Ethereum deployed a record 8.7 million smart contracts in Q4 2025, driven by RWA tokenization, stablecoin activity, and core infrastructure development
• Electric Capital's tracker shows 31,869 active Ethereum developers, the largest active developer base across all blockchain ecosystems
• 16,000 new developers joined Ethereum between January and September 2025, compared to 11,500 for Solana and 7,400 for Bitcoin
• Solana broke Ethereum's 8-year streak of leading new developer growth in 2024, with a 61.7% two-year growth rate, making the competitive dynamic between the two ecosystems the defining story of 2025
• Smart contract deployment volume is a leading indicator of future network activity, typically preceding growth in users, transaction fees, and on-chain economic output
• The L2 ecosystem, including Arbitrum, Optimism, and Unichain, is counted within Ethereum's developer figures, meaning the 31,869 number reflects a genuinely distributed, multi-layer engineering community
• At this scale, developer tooling is no longer a convenience layer; it is the primary determinant of how fast teams can ship, audit, and iterate on production contracts

The result: Ethereum's developer ecosystem has crossed a threshold where the quality and intelligence of the tools developers use matters more than the raw number of developers available.

When Token Terminal published data showing that Ethereum's Q4 2025 smart contract deployments reached 8.7 million, the headline number traveled fast. It is a record, a sharp rebound from the two preceding quarters, and a figure that most coverage treated as a straightforward signal of network health. That framing is not wrong, but it is incomplete. The 8.7 million figure is interesting not because it is large in isolation, but because of what it implies about the engineering infrastructure required to produce it. Contracts do not deploy themselves. Behind every one of those 8.7 million deployments is a developer, a team, a toolchain, and a workflow that had to function well enough to get code from an editor to a live blockchain.

Token Terminal attributes the surge to three primary drivers: real-world asset tokenization, stablecoin activity, and core infrastructure development. Each of those categories represents a different kind of engineering demand. RWA tokenization requires contracts that interact with off-chain legal and financial systems, which means more complex logic, more surface area for bugs, and more pressure on the audit and testing pipeline. Stablecoin activity at scale means high-frequency contract interactions where gas optimization and security are not optional. Core infrastructure development means the foundational layer of the ecosystem is still being actively built, not just maintained. Together, these three drivers paint a picture of an ecosystem that is not coasting on existing code but actively generating new production-grade software at a pace that has no precedent in Ethereum's history.

The broader context from Electric Capital's developer tracker reinforces this. As of early 2026, the platform records 9,400 full-time developers, 32,000 monthly active developers, 634,000 total repositories, and 83 million total commits across the crypto ecosystem. Ethereum sits at the center of that activity with 31,869 active developers, a figure that includes contributors to the L2 networks built on top of it. Understanding what those numbers mean, how they are counted, and what they demand from the tooling layer is the more useful conversation to have.

How Electric Capital Measures Developer Activity

Electric Capital's developer report has become the closest thing the crypto industry has to a canonical measure of ecosystem health. The methodology is worth understanding because it shapes how the numbers should be interpreted. The report tracks open-source developer activity across public repositories, counting commits, contributors, and repository growth over time. It distinguishes between full-time developers, who commit code in ten or more months of a given year, part-time developers, who commit in one to nine months, and one-time contributors. The monthly active developer figure captures everyone who made at least one commit in a given month, regardless of tenure.

This approach has real strengths. It is objective, reproducible, and grounded in actual code output rather than self-reported surveys or token holder counts. It also has known limitations. It only captures open-source activity, which means private repositories, internal tooling, and enterprise development work are invisible to the tracker. The Solana Foundation raised this point explicitly when Electric Capital's 2025 data was published, noting that the dataset may undercount actual developer activity in ecosystems where more work happens in private repos. That caveat applies to Ethereum as well, though Ethereum's culture of open-source development means the gap between tracked and actual activity is probably smaller there than in some other ecosystems.

What the methodology does capture well is the relative trajectory of ecosystems over time. The trend lines matter more than any single data point. Ethereum's 31,869 active developer figure is meaningful not just as a snapshot but as the product of a decade of compounding growth, starting from a handful of contributors in 2015 and building through every market cycle since. The 83 million total commits recorded across the broader crypto ecosystem represent an enormous body of institutional knowledge embedded in code, and a significant portion of that knowledge lives in Ethereum-adjacent repositories.

The 31,869 Number and What It Hides

The headline figure of 31,869 active Ethereum developers is the largest active developer base across all blockchain ecosystems, and it is not particularly close. Solana follows with 17,708 active developers, and Bitcoin trails at 11,036. Those gaps are significant, but the Ethereum number requires some unpacking before it can be used as a clean measure of ecosystem strength. Electric Capital counts contributors to Ethereum's L2 networks, including Arbitrum, Optimism, and Unichain, as part of the Ethereum developer base, using L2Beat's definitions to determine what qualifies as an Ethereum L2. That is a reasonable methodological choice, since L2 developers are building on Ethereum's security model and contributing to its broader ecosystem, but it means the 31,869 figure is not a count of developers writing Solidity for mainnet contracts. It is a count of developers working anywhere in the Ethereum stack.

That distinction matters for tooling. A developer building a Rust-based sequencer for an Optimism-derived rollup has different tooling needs than a developer writing ERC-20 contracts in Solidity. A developer working on Ethereum's consensus layer in Go has different needs again. The 31,869 number encompasses all of them, which means the tooling ecosystem serving Ethereum developers is not a single coherent stack but a collection of overlapping stacks, each with its own conventions, dependencies, and failure modes. Hardhat and Foundry dominate smart contract development. Go-Ethereum and Lighthouse serve the protocol layer. Viem and Ethers.js handle client-side interactions. MetaMask remains the dominant wallet interface for end users. Each of these tools has its own community, its own documentation, and its own learning curve.

The practical implication is that onboarding a new developer into the Ethereum ecosystem is not a single journey but a branching one. A developer who wants to write smart contracts needs to learn Solidity, understand the EVM's execution model, get comfortable with a testing framework like Foundry, and develop intuitions about gas optimization and security patterns that do not exist in any other programming environment. That is a substantial cognitive load, and it is one of the reasons why the 16,000 new developer figure for 2025 is as impressive as it is. Those developers chose to take on that complexity, which says something about the perceived value of the ecosystem they were entering.

New Developer Influx: Reading the 16,000 Figure

Between January and September 2025, over 16,000 new developers joined the Ethereum ecosystem, according to data from the Ethereum Foundation citing Electric Capital's tracker. Solana attracted roughly 11,500 new developers over the same period, and Bitcoin brought in approximately 7,400. These figures track new contributors making their first commits to repositories in each ecosystem, which makes them a reasonable proxy for the rate at which each ecosystem is attracting fresh talent.

The 16,000 figure for Ethereum is notable for a few reasons. First, it comes after Solana broke Ethereum's eight-year streak of leading new developer growth in 2024. That streak had held since 2016, and its end was a genuine signal that Solana's developer experience improvements, particularly around tooling, documentation, and transaction throughput, were resonating with developers who were evaluating where to build. The fact that Ethereum reclaimed the top position in 2025 suggests that the ecosystem responded effectively, whether through L2 improvements that reduced the friction of building on Ethereum, through better tooling, or through the gravitational pull of the existing developer community and the capital deployed in Ethereum-based protocols.

Second, the 16,000 figure needs to be read against the backdrop of what those developers are entering. Ethereum's existing codebase is enormous. The 83 million total commits tracked by Electric Capital represent a decade of accumulated complexity, and new developers are not starting from a blank slate. They are inheriting contracts, libraries, and patterns that were written under different assumptions, at different gas prices, and with different security knowledge than what exists today. The tooling that helps new developers navigate that inherited complexity, understand existing code, identify outdated patterns, and write new code that integrates cleanly with existing systems, is not a nice-to-have. It is the primary determinant of how quickly those 16,000 developers become productive contributors rather than frustrated beginners.

Solana's Challenge and the Competitive Tooling Dynamic

Solana's position in the 2025 developer data is worth examining carefully because it illustrates how tooling quality translates directly into ecosystem growth. Solana's two-year developer growth rate of 61.7% is the fastest of any major ecosystem over that period. That growth did not happen by accident. The Solana ecosystem made deliberate investments in developer experience, including Anchor, the framework that abstracts much of the complexity of writing Solana programs, improved documentation, and a more streamlined local development environment. The result was a developer experience that many engineers found more approachable than Ethereum's, particularly for developers coming from a Rust background.

The competitive dynamic between Ethereum and Solana is not primarily a technical debate about consensus mechanisms or throughput. It is a tooling and developer experience competition. Developers choose ecosystems based on how quickly they can go from idea to deployed contract, how good the debugging experience is, how well the testing frameworks work, and how much institutional knowledge is available in the form of documentation, tutorials, and community support. Solana made gains on several of those dimensions, and the developer growth numbers reflect that. Ethereum's response, through L2 networks that offer lower fees and faster finality while inheriting Ethereum's security, and through continued investment in tooling like Foundry, which has become the dominant smart contract testing framework, has been to improve the developer experience without abandoning the properties that make Ethereum valuable.

The broader lesson is that developer ecosystems are not static. They respond to tooling investments, and the ecosystems that invest most aggressively in making developers productive tend to attract the most developers over time. That dynamic is accelerating as AI-assisted development tools enter the picture, because AI tools can compress the learning curve for new developers and amplify the productivity of experienced ones. The ecosystem that integrates AI tooling most effectively into its development workflow will have a structural advantage in attracting and retaining developers, regardless of the underlying technical merits of the chain.

Layer-2 Networks and the Distributed Developer Base

The inclusion of L2 developers in Ethereum's 31,869 figure is not just a methodological footnote. It reflects a genuine architectural reality about how Ethereum development works in 2025. The majority of new application development on Ethereum is happening on L2 networks, not on mainnet. Arbitrum, Optimism, Base, and a growing number of application-specific rollups have collectively shifted the center of gravity for Ethereum application development away from mainnet and toward a distributed set of execution environments that share Ethereum's security model but have their own fee markets, sequencer architectures, and in some cases their own virtual machines.

This distribution creates tooling complexity that did not exist three years ago. A developer building a cross-chain application in 2025 needs to reason about contract deployments across multiple L2s, bridge interactions that can fail in non-obvious ways, differences in opcode support between L2 EVMs and the canonical EVM, and sequencer-specific behaviors that affect transaction ordering and finality. Foundry handles much of the local testing workflow, but the gap between a passing local test suite and a production deployment that behaves correctly across multiple L2 environments is significant. That gap is where most production incidents originate, and it is where better tooling has the most leverage.

The L2 ecosystem also creates a fragmentation problem for developer tooling vendors. A tool that works perfectly for mainnet Solidity development may not handle the nuances of a specific L2's EVM implementation. A deployment script that works on Arbitrum may need modification for Optimism, and may need further modification for a custom rollup built on the OP Stack. Managing that fragmentation at scale, across a developer base of 31,869 active contributors, requires tooling that can abstract over the differences between execution environments without hiding the details that matter for security and correctness.

Smart Contracts as a Leading Indicator

Token Terminal's framing of smart contract deployment volume as a leading indicator of future network activity is worth taking seriously. The logic is straightforward: contracts that are deployed today will generate user interactions, transaction fees, and MEV opportunities over the months and years that follow. A surge in deployments in Q4 2025 suggests that the pipeline of applications entering production is full, which implies that user activity, fee revenue, and on-chain economic output should follow. That is the optimistic reading, and it is supported by the historical pattern of Ethereum's growth cycles.

The more nuanced reading is that not all 8.7 million contracts represent production applications. A significant portion of any deployment surge includes test contracts, factory-deployed minimal proxies, and infrastructure contracts that support other contracts rather than serving end users directly. The ERC-1167 minimal proxy pattern, for example, allows a single factory contract to deploy thousands of lightweight proxy instances, each of which counts as a separate contract deployment. RWA tokenization platforms routinely deploy one contract per tokenized asset, which means a single platform onboarding a few thousand assets can account for thousands of contract deployments. Understanding the composition of the 8.7 million figure matters for assessing what it actually implies about application-layer growth.

What is clear is that the engineering infrastructure required to produce 8.7 million deployments in a single quarter is substantial. Each deployment requires a developer or an automated system to compile Solidity code, run a test suite, estimate gas costs, sign a transaction, and monitor the deployment for success. At scale, that workflow needs to be automated, auditable, and reliable. The teams shipping the most contracts are not doing it manually. They are running CI/CD pipelines that integrate Foundry or Hardhat for testing, Slither or similar tools for static analysis, and deployment scripts that handle gas estimation and retry logic automatically. The 8.7 million number is, in part, a measure of how mature those automated workflows have become.

RWA, Stablecoins, and the Infrastructure Demand They Create

Real-world asset tokenization and stablecoin activity are not just growth drivers for Ethereum's contract deployment numbers. They represent a qualitative shift in what Ethereum developers are being asked to build. RWA tokenization requires contracts that interface with legal structures, compliance systems, and off-chain data sources in ways that pure DeFi contracts do not. A tokenized treasury bond contract needs to handle transfer restrictions based on investor accreditation status, integrate with oracle systems that provide real-time pricing data, and interact with custodian systems that hold the underlying assets. That is a fundamentally different engineering problem than writing an AMM or a lending protocol, and it requires a different set of tools and skills.

Stablecoin activity at scale creates its own engineering demands. The stablecoin ecosystem on Ethereum in 2025 is not a single protocol but a layered system of issuers, bridges, yield-bearing wrappers, and integration contracts that interact with each other in complex ways. A developer building a new stablecoin integration needs to understand the specific mechanics of each stablecoin they are integrating, including rebasing behavior, fee-on-transfer quirks, and upgrade patterns that can change the contract's behavior after deployment. Getting those integrations wrong has historically been one of the most common sources of DeFi exploits, and the complexity is only increasing as the number of stablecoin variants grows.

The infrastructure demand created by RWA and stablecoin growth is, in practical terms, a demand for better tooling. Teams building in these categories cannot afford to rely on manual code review and informal testing practices. They need automated security scanning that understands the specific vulnerability patterns relevant to their contract type, test frameworks that can simulate complex multi-contract interactions, and deployment pipelines that enforce security checks before any code reaches a testnet, let alone mainnet. The 8.7 million deployment figure is partly a reflection of how much of that infrastructure has been built and is now functioning reliably enough to support production-scale deployment activity.

The Tooling Gap at 31,000-Developer Scale

There is a version of the Ethereum developer story that focuses entirely on the growth numbers and concludes that the ecosystem is healthy and self-sustaining. That version is not wrong, but it misses the most important operational challenge facing the ecosystem right now. At 31,869 active developers, the Ethereum ecosystem has grown large enough that the quality of its tooling has become a binding constraint on its ability to ship secure, production-grade software at scale.

The tooling gap manifests in several ways. First, there is the onboarding problem. New developers entering the ecosystem face a fragmented landscape of tools, frameworks, and conventions that have evolved organically over a decade. Foundry has largely displaced Hardhat for testing among experienced developers, but Hardhat still dominates in tutorials and documentation aimed at beginners. Viem has become the preferred client library for new projects, but Ethers.js remains deeply embedded in existing codebases. A new developer trying to understand how to build on Ethereum in 2025 will encounter conflicting recommendations, outdated tutorials, and a learning curve that is steeper than it needs to be. That friction is a real cost, and it is one of the reasons why Solana's more opinionated tooling ecosystem has been effective at attracting developers who prioritize a smooth onboarding experience.

Second, there is the security tooling gap. The 8.7 million contracts deployed in Q4 2025 were not all audited. The economics of professional smart contract auditing mean that only a fraction of deployed contracts receive formal security review before going live. Static analysis tools like Slither and Mythril can catch a significant class of vulnerabilities automatically, but they require integration into the development workflow to be effective. Many teams, particularly smaller ones and individual developers, are not running automated security checks as part of their standard workflow. The result is a long tail of deployed contracts with known vulnerability patterns that were never caught because the tooling to catch them was not in the critical path of the development process.

AI-Assisted Development and the Next Phase of Ethereum Engineering

The intersection of AI-assisted development tools and Ethereum's engineering ecosystem is where the most interesting near-term changes are happening. The 16,000 new developers who joined Ethereum in 2025 are entering an ecosystem where AI code generation, AI-assisted debugging, and AI-powered security scanning are becoming standard parts of the development workflow. That changes the calculus around onboarding, productivity, and security in ways that the raw developer count numbers do not capture.

On the productivity side, AI-assisted development tools can compress the learning curve for new Solidity developers significantly. A developer who is new to the EVM can use an AI assistant to understand why a particular gas optimization pattern works, what the security implications of a specific storage layout are, or how to structure a proxy upgrade pattern correctly. That kind of contextual, on-demand explanation was previously only available through documentation, Stack Exchange, or asking a more experienced colleague. AI tools make it available instantly, in the context of the specific code the developer is working on. The practical effect is that new developers can become productive faster, and experienced developers can spend less time on routine explanations and more time on the hard problems.

On the security side, AI-assisted static analysis can surface vulnerability patterns that rule-based tools miss. Traditional static analysis tools like Slither work by matching code patterns against a library of known vulnerability signatures. They are effective at catching well-understood vulnerability classes like reentrancy, integer overflow, and unchecked return values, but they struggle with novel vulnerability patterns and with vulnerabilities that emerge from the interaction between multiple contracts rather than from a single contract in isolation. AI-powered analysis tools can reason about contract interactions, simulate attack scenarios, and identify vulnerability patterns that do not match any existing signature. That capability is particularly valuable in the RWA and stablecoin categories, where the complexity of contract interactions creates vulnerability surfaces that traditional tools are not well-equipped to analyze.

The risk, which is well-documented in research on AI-assisted coding, is that AI tools can also introduce vulnerabilities when developers use them without sufficient understanding of the code being generated. Studies on AI-assisted development have found that developers using AI code generation are more likely to introduce security vulnerabilities than developers writing code manually, particularly when they accept generated code without carefully reviewing it. In a smart contract context, where deployed code is immutable and vulnerabilities can result in permanent financial losses, that risk is not theoretical. It is a structural challenge that the tooling ecosystem needs to address by building AI tools that keep developers in the loop rather than encouraging them to treat generated code as a black box.

Where Cheetah AI Fits in This Ecosystem

The numbers from Electric Capital's 2025 report describe an ecosystem at an inflection point. Ethereum has the largest active developer base in crypto, the highest new developer inflow, and a record-breaking smart contract deployment rate driven by real economic activity in RWA tokenization and stablecoin infrastructure. The ecosystem is not struggling for developers or for demand. What it is struggling with is the tooling infrastructure required to help 31,869 active developers ship secure, production-grade code at the pace that 8.7 million quarterly deployments implies.

That is the problem Cheetah AI is built to address. As a crypto-native AI IDE, Cheetah AI is designed for the specific demands of Ethereum and Web3 development, not as a general-purpose coding assistant with blockchain support bolted on. That distinction matters because the failure modes in smart contract development are different from the failure modes in traditional software. Code is immutable once deployed. Vulnerabilities are exploitable by anyone. The cost of a missed security issue is not a bug report and a patch; it is a permanent loss of funds. Tooling that does not account for those constraints is not just less useful; it is actively dangerous in the hands of developers who trust it too much.

If you are building on Ethereum, whether on mainnet, on an L2, or across multiple execution environments, the tooling you use is not a secondary concern. It is the primary determinant of how fast you ship, how secure your contracts are, and how well your team can maintain and extend the code you write. Cheetah AI is worth exploring if you want an IDE that understands the Ethereum stack deeply enough to be genuinely useful rather than generically helpful.

The 8.7 million contracts deployed in Q4 2025 represent an enormous amount of engineering work, and the developers who shipped that code needed tools that could keep up with the pace and complexity of what they were building. As the ecosystem continues to grow, as RWA tokenization matures, as L2 fragmentation increases, and as the next 16,000 developers arrive looking for a productive entry point into Ethereum development, the tooling layer will only become more important. Cheetah AI is built for that environment, and if you are working anywhere in the Ethereum stack, it is worth seeing what a purpose-built crypto-native IDE actually feels like in practice.