On September 3, 2024, Offchain Labs launched Arbitrum Stylus on mainnet, transforming Arbitrum One and Nova into multi-virtual-machine platforms capable of executing WebAssembly alongside the traditional Ethereum Virtual Machine. For developers proficient in Rust, C, or C++, this opens an entirely new paradigm for smart contract development. This walkthrough covers the technical foundations you need to start building production-grade smart contracts using Rust on Arbitrum Stylus.
The Objective
The goal of this guide is to walk experienced developers through the architecture of Stylus smart contracts, explain the compilation and deployment pipeline, and demonstrate how to write, test, and deploy a basic Rust smart contract to Arbitrum One. By the end, you should understand the key differences between EVM and Stylus development, the performance characteristics of Wasm-based contracts, and the tooling ecosystem available for Stylus development.
Stylus represents a fundamental shift because it allows programs to execute up to 70 times faster than equivalent Solidity implementations while maintaining full interoperability with the EVM. This means your Rust contracts can call Solidity functions and vice versa, enabling a gradual migration path for existing protocols.
Prerequisites
Before diving into Stylus development, you should have the following prerequisites in place. A working installation of Rust and Cargo, the Rust package manager, is essential. Familiarity with Rust’s ownership model, trait system, and macro ecosystem will be necessary for understanding the Stylus SDK patterns. Basic knowledge of Ethereum smart contract concepts — including accounts, transactions, and gas metering — is assumed.
You will also need an Arbitrum RPC endpoint for testing and deployment. Public endpoints are available for development, but production deployments should use dedicated RPC providers for reliability. A wallet funded with Arbitrum ETH for gas costs on the testnet is recommended for initial experimentation before moving to mainnet deployment.
The Stylus SDK provides the core abstractions for building smart contracts in Rust. It handles the serialization and deserialization of contract inputs and outputs, manages storage operations, and provides the interface between your Rust code and the Stylus execution environment.
Step-by-Step Walkthrough
Step 1: Setting up the development environment. Begin by installing the Stylus CLI tools, which provide commands for initializing, compiling, and deploying Stylus contracts. The SDK uses a project structure familiar to Rust developers, with Cargo.toml for dependency management and a src directory for your contract logic.
Step 2: Understanding the storage model. Stylus contracts interact with blockchain state through a storage API that mirrors the persistent storage model of the EVM. Values are stored as 32-byte keys with arbitrary byte values. The Stylus SDK provides type-safe wrappers around these raw storage operations, allowing you to define storage slots with specific data types that automatically handle serialization.
Step 3: Writing contract entry points. Stylus contracts expose public functions that can be called by external accounts or other contracts. These entry points are annotated with macros that generate the necessary boilerplate for argument decoding, execution, and return value encoding. The SDK supports Solidity-compatible ABI encoding, ensuring seamless interoperability with existing EVM tooling.
Step 4: EVM interoperability. One of the most powerful features of Stylus is the ability to call EVM contracts from Wasm and vice versa. The SDK provides mechanisms for invoking Solidity functions from your Rust code, enabling hybrid architectures where performance-critical components are written in Rust while interface and governance logic remains in Solidity.
Step 5: Testing and deployment. Stylus contracts can be tested using standard Rust testing frameworks for unit tests. For integration testing, the Stylus testnet environment provides a faithful simulation of the mainnet execution environment. Deployment is handled through the CLI tools, which compile your Rust code to Wasm, optimize the binary, and submit the deployment transaction to the Arbitrum network.
Step 6: Gas optimization. Wasm contracts on Stylus benefit from significantly lower gas costs compared to equivalent EVM operations. Memory operations, arithmetic computations, and control flow are all substantially cheaper in Wasm. However, storage operations remain the dominant cost factor, so optimizing storage access patterns — batching reads and writes, caching values in memory — remains critical for gas efficiency.
Troubleshooting
Developers transitioning from Solidity to Stylus may encounter several common challenges. The compilation pipeline for Rust-to-Wasm is more complex than Solidity compilation, and tooling is still maturing. Build errors related to Wasm target compatibility are common when using crates that rely on platform-specific features. Ensure that all dependencies compile to the wasm32-unknown-unknown target.
Storage costs in Stylus can be higher than expected if your contract makes excessive storage reads. Profile your contract’s storage access patterns during testing and optimize hot paths by caching frequently accessed values in contract memory rather than reading from storage on every call.
Debugging Stylus contracts currently requires familiarity with both Rust debugging tools and on-chain transaction analysis. The Stylus SDK provides logging utilities that output to transaction receipts, which can be queried through standard Ethereum JSON-RPC methods.
Mastering the Skill
To advance your Stylus development skills, explore the growing ecosystem of Stylus-specific libraries and tools. The Arbitrum developer documentation provides comprehensive references for the SDK APIs, and the community-maintained examples repository demonstrates common contract patterns including tokens, governance, and cross-contract communication.
Consider contributing to open-source Stylus projects to gain practical experience and build connections within the developer community. As the Stylus ecosystem grows, expertise in Wasm-based smart contract development will become an increasingly valuable skill in the Web3 job market.
The launch of Stylus represents an opportunity to be among the first wave of developers building on a fundamentally new smart contract platform. With the performance advantages of Wasm and the security guarantees of the Arbitrum Layer 2, the technical foundations are in place for a new generation of decentralized applications.
Disclaimer: This article is for educational purposes only and does not constitute financial or investment advice. Development on blockchain platforms carries technical risks. Always test thoroughly before deploying to mainnet.
been writing Rust for 3 years and the idea of deploying it on Arbitrum without touching Solidity is beautiful. cargo stylus deploy and done
The Wasm-to-EVM interop layer is the impressive part here. You can call Solidity contracts from Rust and vice versa. Full composability.
Viktor Novak nailed it. the composability between Wasm and EVM is the real breakthrough here. not just performance, but being able to incrementally migrate
rust devs entering the building
Would love to see a follow-up article comparing gas costs between equivalent Solidity and Rust contracts on Stylus. The 70x claim needs real benchmarks.
Anika Patel asking for gas benchmarks months ago and still no solid data. the 70x claim is just marketing at this point
rust on arbitrum without touching solidity is the dream for systems devs. the evm interop is what makes it practical instead of a curiosity
70x faster than solidity is the headline but the dev experience matters more. cargo stylus deploy is genuinely smooth
cargo stylus deploy is genuinely smooth. the tooling is what will actually get devs to try this, not the 70x benchmark claims
the real question is audit tooling. you can write rust contracts but slither and mythril dont work on wasm. how do you secure this