Arbitrum Stylus: Smart Contracts in Rust (On-Chain Chess)

Arbitrum Stylus: smart contracts in Rust and an on-chain chess engine

Overview

What if you could write smart contracts in Rust, C or C++ instead of only Solidity? In this MERGE Madrid workshop, Offchain Labs presents Arbitrum Stylus, explains how it works and demonstrates its potential with a complex case: a full chess engine running on-chain, hard to achieve with the traditional EVM.

What you'll learn

• What Stylus is: a WASM virtual machine that coexists with the EVM and is interoperable with it
• New languages: writing contracts in Rust, C, C++ and others that compile to WASM
• Benefits: attracting web2 developers, more tooling and new use cases
• The on-chain chess challenge: why complex computation clashes with gas limits
• Reusing libraries: how to integrate an existing chess engine into a contract
• Tools and limits: the Rust SDK, contract size and the deterministic environment

Session summary

What Arbitrum Stylus is: it is presented as an upgrade to the smart contract development environment on EVM chains; thanks to a new WASM virtual machine that coexists with the EVM, it lets you write contracts in Rust, C, C++ and other languages, fully interoperable with Solidity contracts.

Benefits: it highlights access to a broader development ecosystem (onboarding web2 developers without them learning Solidity), the use of general-purpose language tooling, and new use cases such as advanced cryptography, generative art and complex computation.

Tools and resources: it mentions the Rust SDK (the most developed), proof-of-concept SDKs for C and C++, and resources such as the quick start guide and “Stylus by example”, with a small “counter” contract in Rust as an example.

The on-chain chess challenge: it explains that a chess engine requires a lot of computation (validating each piece's legal moves) and that doing this in Solidity usually clashes with gas limits; with WASM, by contrast, that kind of computation is more feasible.

Reusing libraries: instead of coding everything from scratch, it integrates an existing library (crate) that implements a full chess engine in Rust; it discusses considerations such as avoiding the standard library, the lack of parallelization or randomness and the deterministic blockchain environment.

The demo: it shows the contract (with the whole board encoded in a 256-bit integer), its deployment on a local chain and a sample game, including the contract size and how it shrinks when the board-display functions are removed.

Watch the full talk

Watch the full recording on MERGE's YouTube channel, with Offchain Labs on Arbitrum Stylus and on-chain chess.

FAQs

What is Arbitrum Stylus?
It is a technology that lets you write smart contracts in languages like Rust, C or C++ via a WASM virtual machine that coexists with the EVM and is interoperable with Solidity.

What advantages does it offer over Solidity?
It lets you use languages and tooling already known by web2 developers and tackle complex computation that would clash with gas limits on the traditional EVM.

Why is an on-chain chess engine a good example?
Because it requires a lot of computation to validate moves; with WASM it is feasible to run a full engine on-chain, something hard to achieve with Solidity alone.

Where can I try it?
According to the workshop, the example is available in a public repository, along with the documentation and the Stylus community channels.