Last year, we announced a partnership with Offchain Labs to build debugging tools for Arbitrum Stylus. At the time, Stylus had no proper debugger. Stylus contracts run as WASM, so standard Ethereum debugging tools don't apply, and any tools developers could reach for had no understanding of blockchain transactions or contract state, which made tracking down and fixing issues in Stylus contracts genuinely difficult.
We built StylusDB to fill that gap. It's now part of Arbitrum's official Stylus toolchain, shipped inside Stylus CLI and recommended in Arbitrum docs. It's also the only open-source debugger for Stylus.
Walnut was among the most reliable teams in the Stylus Sprint cohort. They delivered consistently across eight milestones, building out cross-VM debugging capabilities and tackling one of the hardest problems Stylus developers faced: tracing transactions across the EVM and WASM boundary. Their debugger was merged into the official Stylus SDK, which reflects both the technical quality of the work and a tangible contribution to the developer experience on Arbitrum.
What We Built
StylusDB supports step-by-step debugging of Rust-based Stylus contracts to set breakpoints, inspect state, and walk through execution at the source level. There's also execution tracing, which records exactly what a contract did during a transaction at the function level.
It handles multi-contract debugging too. Developers can step through execution across multiple contracts in a single session, switch context between them, and inspect each contract's state independently.
The code is fully open-source. Anyone building on Stylus can use it, and any tooling layer can integrate it.
What Is Stylus
Arbitrum Stylus adds a second execution environment to Arbitrum alongside the EVM. EVM contracts are written in Solidity; Stylus contracts compile to WebAssembly (WASM), so developers can write them in Rust, C, or C++.
For compute-heavy workloads, WASM execution is faster and more memory-efficient than the EVM, while staying fully compatible with the Ethereum developer model. For teams whose infrastructure is already in Rust or C++, Stylus removes the need to rewrite core systems in Solidity just to deploy on-chain, which matters most for teams that already have large Rust or C++ codebases.
It also means two execution models running side by side, contracts in two different languages, and cross-boundary calls between them. Debugging across that boundary is where things get genuinely hard.
The Hard Part: Stylus<>Solidity Interoperability
Most real-world Stylus applications don't run in isolation. They call Solidity contracts, get called by them, or both. Until now, source-level debugging stopped at that boundary: you could trace across it, but you couldn't step through both sides.
Stylus contracts run on WASM; Solidity contracts run on the EVM. The two don't share a debugging model, and getting meaningful data from both sides of a single transaction requires collecting trace data from each environment and stitching it into a coherent view.
We made StylusDB talk with soldb, our Solidity debugger, to produce unified traces across Rust<>Solidity contract calls. A developer gets one session with full source context on both sides. As far as we know, this is the first interop debugger of its kind for any blockchain VM stack.
We're releasing this shortly. When it lands, developers will be able to trace transactions that span both Stylus and Solidity contracts end to end.
Who This Is For
Anyone writing contracts for Arbitrum Stylus needs a debugger. The ecosystem is growing, and some of the largest names in finance are already building on it.
Robinhood is building its own Layer 2 blockchain on Arbitrum. Their matching engine and ledger infrastructure are written in C++ or Rust, and Arbitrum Stylus is explicitly what makes that code deployable as EVM-compatible smart contracts without rewriting it in Solidity. Debugging tools aren't optional at that scale, and Robinhood won't be the last financial institution building on it.
What's Next
Next, we're planning to bring Stylus support into Walnut Web Debugger, which currently supports Starknet and EVM chains. Adding Stylus to that layer means developers get the same visual, browser-based transaction debugging experience on Stylus that we already built for EVM and Starknet developers. We're also planning to add step-by-step debugging across Rust<>Solidity boundaries.
Blockchains are getting more interoperable, and smart contract systems already span multiple VMs and languages. The Stylus<>Solidity interop work is the first real proof that cross-VM debugging is solvable at the source level and that's the problem we're focused on next.