Once Arbitrum Stylus Let Rust Actually Run on an L2, What Really Changed?
Arbitrum Stylus landed on Nitro mainnet in February 2025. Most headlines flattened that into “L2 now supports Rust”. If you only write Solidity your first reaction is probably “fine, I don’t need to switch”. Yet Stylus is more than adding a language. It is the first time an execution environment runs alongside the EVM and shares the same state within the Ethereum perimeter, and its gas model, performance ceiling and portability all differ from the Solidity era.
What Stylus actually is
Stylus is a second virtual machine Arbitrum added on top of Nitro. Nitro ships with an Ethereum-compatible EVM, while Stylus adds a virtual machine based on WebAssembly (WASM). Both share the same onchain state. A Rust contract can read and write the same storage slot as a Solidity contract and vice versa. The point is shared storage, not bridge-style message passing.
In short, Stylus gives developers:
- The ability to write contracts in Rust, C and C++, compiled to WASM
- A separate bytecode region on Arbitrum to deploy into
- Execution under the Stylus VM, but storage operations land in the same slots EVM uses
- A gas accounting model different from the EVM
A point often missed in the Arbitrum vs Optimism vs Base comparison is that Arbitrum is the only top L2 with a production-grade multi-language VM, which may matter more in the long run than its #1 TVL.
Why WASM, not Move or Sealevel
Theoretically Arbitrum could have chosen Solana’s Sealevel, Sui’s Move or Cosmos’s CosmWasm. It chose WASM for three reasons:
- Mature tooling: Rust, C++ and Go all compile to WASM with much smaller learning curves than Move
- Battle-tested security model: WASM has been used in browsers, CDNs and edge for years
- Easy EVM interop: WASM is a stack VM with clean interfaces into EVM bytecode
WASM does have a price. WASM has no built-in ABI standard, so Stylus had to define its own host function interface. First-time devs find it as alien as raw Solana.
Why the gas model differs entirely
The Solidity-era gas model meters each EVM opcode. SSTORE costs X, CALL costs Y, fully transparent. Stylus splits gas in two:
- Compute gas: estimated from WASM CPU cycles, far cheaper than EVM
- Storage gas: identical to EVM since both share the same storage backend
In practice:
- Compute-heavy contracts (signature verification, ZK proofs, ML inference): Stylus is 10x to 100x cheaper
- Storage-heavy contracts (ERC-20 transfers): Stylus saves almost nothing since SSTORE is the bottleneck
- Mixed contracts (DEX order matching): about 30-50% savings
That explains which projects exploded on Stylus over the past year. Many things that previously had to live offchain are pulled back onto chain, like onchain BLS aggregate signatures, onchain zkSNARK verifiers, and onchain ML inference. Solidity made all of these gas-prohibitive. Stylus puts them back in reach.
A concrete example: onchain ML inference
Imagine running a small neural network onchain for realtime risk scoring, say a DeFi protocol scoring address credit:
- Solidity implementation: about 8 million gas per inference, $50 on mainnet or $5 on L2 after EIP-4844
- Stylus implementation: about 500k gas equivalent, around $0.05 per inference
A two-orders-of-magnitude gap turns the old “infer offchain, post a hash onchain” pattern into “infer onchain natively”. This connects directly with the AI compute networks in the DePIN beginner guide.
What it means for developers
Three developer profiles:
Type 1, pure Solidity veterans. No immediate reason to switch. The EVM half of Arbitrum is unchanged, existing contracts keep running.
Type 2, teams building novel apps. If your work touches ZK, onchain AI, cryptographic libraries or complex math, Stylus is basically the only option that does not bottleneck on gas.
Type 3, infrastructure and middleware builders. Stylus lets you write a high-performance Rust core and wrap it with a thin Solidity ABI shell. Frontends still call EVM interfaces while the engine is Rust. That is a step change for SDK design.
Limits worth knowing
One, activation cost. The first execution of a Stylus contract activates the WASM bytecode and burns startup gas. For rarely called functions Stylus can end up more expensive than Solidity.
Two, weaker debugging tooling. Hardhat and Foundry have five years on EVM. Stylus tooling like cargo-stylus and stylus-sdk is still in early 2026 fast-iteration mode.
Three, scarce auditors. People who can audit Rust contracts plus the WASM security model are far rarer than Solidity auditors. Market rates in 2026 sit 1.5-2x above EVM audit prices.
Four, Arbitrum lock-in. Optimism, Base and zkSync have not shipped equivalent multi-VM systems. Either use Solidity or accept Arbitrum exclusivity.
Five, the security boundary is still settling. WASM escape, stack overflow and host call abuse are fresh attack surfaces inside the Ethereum context. Some of the Solidity-era pitfalls have to be relearned.
Will it replace Solidity?
Not soon. 2026 data:
| Dimension | Solidity | Stylus |
|---|---|---|
| Share of total contracts | ~98% | ~2% |
| Share of new deploys (quarterly) | ~92% | ~8% |
| Protocol TVL share | ~99% | ~1% |
| Adoption by top teams | high | selective |
Stylus is not replacing Solidity. It is a high-performance side runtime next to Solidity, similar to how C and assembly coexist. You do not write whole projects in assembly, but for tight performance corners you switch. Once you understand what zk Rollups are, Stylus also makes ZK-friendly cryptography a realistic onchain choice.
Indicators worth tracking through 2026
The practical Stylus dashboard:
- Production Stylus contracts passing 10k: signals it is past research phase
- Share of onchain ZK verification calls: Stylus should host 50%+ of Arbitrum’s ZK calls
- Stylus SDK ports to OP Stack and zkSync: signals multi-language L2 is not exclusive to Arbitrum
- Stable gas pricing between Solidity and Stylus interop: no more frequent coefficient changes
- Dedicated Stylus audit firms appearing: engineering culture has matured
Treat Stylus as the marker for “L2 entering phase two” rather than just a developer tool. Phase one of L2 raced on TPS and gas. Phase two races on which things you can do onchain that were impossible before. Stylus is the front door to that second space.