Ethereum developers have hit a wall in the Glamsterdam upgrade. Two scaling changes that would deliver a 3.3x capacity increase break assumptions baked into thousands of existing smart contracts, forcing a choice between network performance and backward compatibility.
The conflict surfaced during a core dev call, where developers confirmed that the proposed changes disrupt logic relied upon by an estimated 15,000 deployed applications. The upgrade’s scaling improvements hinge on modifications that alter how certain operations behave at the protocol layer, invalidating assumptions contract developers made when they wrote and deployed their code.
The Incompatibility
Smart contracts on Ethereum are immutable once deployed. That’s a feature, not a bug, it’s what makes them trustless. But it also means contracts written to expect specific protocol behavior can’t be patched when that behavior changes. The Glamsterdam scaling changes touch precisely those low-level assumptions. Contracts that query state, handle gas refunds, or interact with certain precompiles in ways now considered standard would fail or behave unpredictably under the new rules.
A 3.3x capacity boost is significant. It’d push Ethereum closer to the throughput targets the community has chased since the DAO fork era. That kind of improvement doesn’t come from optimizing a few opcodes, it requires structural changes to how the EVM processes transactions and manages state access. The same changes that unlock that capacity are the ones breaking contracts.
No Clean Exit
Developers didn’t present a workaround. The options are stark: ship the upgrade and accept that a subset of deployed contracts stop working, or pull the changes and settle for a smaller performance gain. Some contracts can be migrated to new versions, but only if their developers are still active and their users are willing to move funds. Protocols with locked governance or large user bases face higher friction. The 15,000 figure isn’t a worst-case scenario, it’s the current estimate of contracts that depend on the behaviors Glamsterdam alters.
Ethereum’s history includes hard forks that changed the rules (EIP-1559, the merge), but those were broadly telegraphed and didn’t break existing contract logic. This is different. The upgrade offers material scaling gains, but the cost is compatibility with a non-trivial slice of the application layer. Developers now have to decide how much disruption they’re willing to impose on the ecosystem for a 3.3x bump in capacity.
