We're partnering with Argot Collective to implement the debug standard Solidity has been missing. Argot grew out of the Ethereum Foundation and continues the core work on Solidity and its toolchain. They steward solc, the official Solidity compiler, which is their highest-impact work. They are also defining ethdebug, the emerging standard for debug metadata, and sponsoring its implementation. Our part is implementing that standard inside solc.
The 2025 Solidity Developer Survey put numbers on the demand. Across 925 responses, debugging still surfaces among top recurring issues, with step-through debugging, variable and state inspection, and transaction replay as the three most-requested improvements. Our work with Argot is the structural fix to that demand.
The problem
A debugger is only as good as the information the compiler hands it, and in Solidity, that information has been thin. This includes source maps, which connect an EVM bytecode instruction back to its corresponding human-authored source code range: enough to highlight "you're roughly here in Counter.sol". This is the foundation every EVM debugger has leaned on, but Solidity's debugging output stops short at the questions that matter when something goes wrong: which stack slot holds amount, which storage slot is balances[user], what a memory region represents.
Tools have always filled that gap by inference. A debugger combines the source map with the ABI, the AST, the storage layout, and the execution trace, then guesses that a particular stack value is probably amount. It works, but breaks the moment the compiler changes how it lays things out. Every team rebuilds that machinery from partial clues, and each tool arrives at its own approximation of the truth.
What ethdebug changes
ethdebug replaces that inference with compiler-emitted facts. It defines, as an open standard, the variables in scope at any point of execution, their high-level types, and pointers to where those values actually live across stack, memory, storage, calldata, and transient storage. The format is similar in spirit to DWARF for C and C++.
The practical value is that compiler-provided facts make Solidity contracts easier and safer to build, audit, and operate. Once solc provides that context directly, then debuggers, frameworks, monitoring tools, block explorers, or agents using those tools, can all read from the same source of truth. Crucially, no team has to reinvent debugging anymore and everyone builds on the same standard. The result is better developer experience, easier audits, faster incident response, stronger security, and less duplicated tooling across Ethereum.
Implementation roadmap
The implementation will be broken down into several phases, starting with testing infrastructure and an internal debug-data spec. From there, the work moves to Yul serialization: solc compiles Solidity through Yul to bytecode, and debug metadata must be preserved across that transformation or it will not be present in the final output. With debug data propagating through Yul, the unoptimized pipeline becomes possible, producing complete per-instruction context for storage variables, locals, memory, and calldata.
The most critical debugging needs, however, are in production, where contracts are deployed, immutable, and compiled with optimizer passes that obscure the mapping between bytecode and source. The final phase covers debug-data propagation through the optimizer, which is what production-grade debugging depends on. Standardized debug information at that level makes deployed contract behavior easier to reason about and feeds directly into audits, monitoring, and incident response.
Work is already underway. Argot is funding the groundwork through testing infrastructure, an internal debug-data specification, and Yul serialization. We are seeking co-sponsors for the unoptimized and optimized pipelines, which deliver the complete debug data needed for storage variables, local variables, memory, calldata, and per-instruction context.
Completing the debugging stack
SolDB, our open-source, ethdebug-based CLI debugger for Solidity, is the first consumer of this work. It reads ethdebug output directly and turns it into source-level call traces, step-through debugging with breakpoints, and variable inspection. The Walnut Debugger will implement SolDB and bring those workflows into our wider tooling. As ethdebug in solc deepens, what SolDB and Walnut can show deepens with it.
ethdebug is the structural fix the Solidity ecosystem has needed for a long time, and we're glad to be working with Argot to get it into solc.
If your team relies on Solidity and wants to help fund better debugging, reach out to Argot or Walnut. More updates as the work develops.