Arbitrum Stylus: A New Standard for Smart Contract Composability
TechFlow Selected TechFlow Selected
Arbitrum Stylus: A New Standard for Smart Contract Composability
Arbitrum Stylus aims to create a new standard for smart contract composability by unifying the execution environments of the EVM and WASM.
Navigating Web3 tides with focused insightsAuthor: Rachel Bousfield, Jay Yu
Translation: TechFlow
Note: This article originally comes from the Stanford Blockchain Review. TechFlow is an official partner of the Stanford Blockchain Review and has been granted exclusive authorization to translate and republish this content.
Introduction
From processing bytecode on Etherscan to defending against various code vulnerabilities in Solidity, the EVM technical stack for blockchain development differs significantly from the Web2 tech stacks familiar to many developers—such as Rust, C++, or Python—creating a "gap" between the Solidity-EVM stack and mainstream programming languages. As the blockchain field continues to evolve, there is an urgent need to bridge this developer gap and enable more composable Web3 development.
In this article, we will introduce Offchain Labs’ latest project, Arbitrum Stylus, which made its debut at the Blockchain Applications Stanford Summit (BASS) during Stanford Blockchain Week. Arbitrum Stylus is a landmark initiative aiming to establish a new standard for smart contract composability by unifying the execution environments of the EVM and WASM. We will first discuss the motivations behind the project, then dive into implementation details, and finally explore its potential impact across the Web3 landscape.
Motivations Behind Arbitrum Stylus
Arbitrum Stylus was developed to address two key challenges in blockchain development: (1) accessibility of blockchain development, and (2) execution efficiency of smart contracts.
Simplifying Blockchain Development
According to Electric Capital’s Developer Report, there are currently around 20,000 monthly active blockchain developers. While this number has grown substantially over recent years, it remains far smaller than the millions (or even tens of millions) of developers working with mainstream general-purpose languages like Rust or C++. As the blockchain ecosystem expands, simplifying the process of attracting millions of new smart contract developers becomes critical.
One of the best ways to achieve this is by integrating smart contract development with existing mainstream programming languages such as Rust or C++. Many non-EVM ecosystems, including Solana and Cosmos, have adopted this approach, making Rust the de facto smart contract language within those ecosystems. However, until now, the EVM ecosystem has primarily relied on its own unique language, Solidity, for writing smart contracts. Arbitrum Stylus aims to change this by allowing blockchain developers to write smart contracts in mainstream languages like Rust and deploy them on EVM-compatible blockchains.
Improving Smart Contract Execution Efficiency
Over the past few years, demand for on-chain computation has surged alongside the popularity of decentralized applications, especially on the Ethereum network. This spike in network demand has led to high gas fees, fueling innovation aimed at increasing public blockchain transaction throughput—one area where Arbitrum stands out. This includes flagship offerings such as the Arbitrum One L2 chain and the Arbitrum Nitro technology stack.
Arbitrum Stylus is a natural extension of these efforts and the newest addition to the Arbitrum toolkit. Unlike previous solutions that focused on optimizing efficiency between transactions (e.g., batching via rollups), Stylus optimizes execution at the intra-transaction level—specifically how each transaction is executed. By enabling contracts to run in WebAssembly (WASM), Stylus achieves faster contract execution, promises lower gas costs, and reduces memory access costs by 100–500 times compared to the EVM.
Stylus: Delivering WASM + EVM Composability
WebAssembly and Arbitrum Nitro
To understand why Stylus is more efficient and composable than traditional EVM engines, it's essential to first grasp the role of WebAssembly, or WASM. WASM is an assembly language—essentially machine-readable binary code—as opposed to human-readable languages like Rust or C++. These higher-level languages require a “compiler” to convert them into machine-readable “assembly” before execution.
Specifically, WASM is an assembly language optimized for web browsers, designed to accelerate the execution of JavaScript-based web applications. By being portable, modular, and fast to execute, WASM enables developers to write code snippets directly in mainstream languages such as Rust or C++.
With Arbitrum’s Nitro upgrade, all disputes on-chain are executed in WASM, meaning Nitro has a valid fraud-proof system for any arbitrary WASM code. Because Arbitrum Nitro can provide fraud proofs for any WASM code, it can do so for any program compiled into WASM.
Arbitrum Stylus builds upon the WASM fraud-proof capability inherited from Arbitrum Nitro by adding a WASM execution engine based on Wasmer—one of the leading WASM runtimes—which executes code much faster than Geth executing EVM bytecode. With both an execution engine and a proof engine, smart contracts can now be fully written, executed, and proven entirely in WASM. Given that many mainstream languages (like Rust and C++) can compile directly to WASM, this is how Arbitrum Stylus enables blockchain developers to write, deploy, and execute smart contracts in a wide range of mainstream general-purpose languages.
Consistency Between EVM and WASM Engines
Arbitrum Stylus gives developers the option to write contracts in Rust and other WASM-compatible languages without sacrificing the ability to write and execute Solidity-based smart contracts. By supporting both EVM and WASM as parallel execution engines, Stylus also allows developers to use Solidity in one part of their application and Rust in another.
However, this raises a question: How does the Stylus VM manage consistency between two different engines? How does it know when to switch between the EVM and the WASM VM?
First, Solidity and other EVM-based contracts are compiled into the same bytecode and executed just as they would be in a pure EVM environment. WASM-based smart contracts, such as those written in Rust, include an additional “header” at the beginning of the contract. When these contracts are invoked, the Stylus VM can identify whether the EVM or WASM engine is required. This design also enables strong interoperability: WASM contracts can call Solidity contracts and vice versa. This is a key differentiator between Stylus and other blockchains adopting WASM execution engines—Stylus ensures full composability and interoperability between WASM and EVM contracts, enabling backward compatibility and allowing WASM contracts to leverage EVM liquidity.
Another way to view Stylus’s dual EVM/WASM engine architecture is to consider the blockchain as a "world state machine" that undergoes specific state transitions according to state transitions defined in the EVM. In Ethereum, on-chain state is represented using a Trie structure—a tree-like data structure optimized for efficient storage and retrieval. Both the EVM and WASM engines in Stylus use the same Trie structure to read and write data to the "world state machine." Both engines produce state changes to update the world state; the only difference lies in how they compute those state changes.
Cost Savings from the EVM + WASM Engine
As previously mentioned, using the WASM execution engine enables significant cost savings due to improved execution efficiency. Now let’s examine how this works. Consider a simple ADD instruction, such as 2 + 3.
In the EVM, the following steps are required:
-
Pay gas fees involving multiple memory table lookups;
-
Account for tracing, even if disabled;
-
Pop two items from the simulated stack;
-
Add them together;
-
Push the result back onto the stack.
We see that only step 4 actually performs the integer addition—the rest are “boilerplate instructions” internal to the EVM system, each consuming substantial gas relative to the actual computation.
In contrast, executing the same ADD operation in WASM requires just one step:
-
Execute a single x86 or ARM ADD instruction.
We observe that this is 150x cheaper than addition in the EVM. Given these gas savings, the Stylus VM introduces a new subunit of “gas” called “ink,” currently defined by default as 1/10,000 of 1 gas and configurable by the chain owner.
However, there is a limitation: activating the Stylus VM incurs a fixed cost of 114,000,000 gas. Additionally, invoking a Stylus program itself currently costs about 128–2048 gas. Therefore, activating the WASM environment solely to optimize a single ADD operation on two integers may not be economical. However, for memory-intensive smart contracts, these savings accumulate and offset the “activation cost.” For example, allocating 3.8 MB of RAM in the EVM costs approximately 32 million gas, whereas in the Stylus WASM VM, it costs only 64,000 gas—a 500x saving. A related implication is that memory-intensive applications are simply infeasible on pure EVMs due to rapid encounters with gas limits. But in the Stylus VM, running under the WASM runtime makes such applications fully viable, as RAM usage under WASM is far less costly.
New Use Cases Unlocked by Stylus
-
Memory-Intensive Applications
As discussed above, one of the most exciting aspects of Arbitrum Stylus is its ability to enable memory-intensive applications on-chain. This opens the door to entirely new categories of applications, such as generative AI NFTs, high-frequency trading, and on-chain gaming. In fact, the Stylus VM could be a landmark technology enabling AI—with its well-known high memory demands—to perform computationally on-chain while maintaining full interoperability with EVM contracts.
-
Composability of Alt-VMs with EVM Liquidity
Furthermore, Stylus’s EVM compatibility and its ability to allow WASM-based contracts to interoperate with native Solidity contracts mean that these WASM contracts can fully leverage the massive liquidity and user base already present on the EVM. Recall that many alternative VMs, such as Solana and Cosmos, use WASM-supporting languages like Rust to execute their smart contracts. The presence of a WASM engine in Stylus means developers from these alternative VMs can easily migrate their contracts to the EVM ecosystem and immediately tap into EVM liquidity.
-
General Libraries, Precompiles, and Debugging Infrastructure
Another advantage of allowing developers to write smart contracts in mainstream languages like Rust and C++ is access to the vast ecosystem of general-purpose libraries available for these languages—covering everything from on-chain computation and cryptographic primitives to file I/O.
More importantly, developers can benefit from the sophisticated tooling infrastructure built for these languages—not only advanced package managers but also familiar debugging tools such as the GDB suite for C/C++. All of this could dramatically increase developer familiarity with Web3 development and make entering blockchain and the EVM stack significantly easier.
-
Bringing On-Chain Computation to IoT for DePIN
Thanks to the enhanced execution efficiency of WASM, the Stylus VM can open the door to integrating on-chain computation with portable IoT devices—including traffic lights, smart fridges, and smartwatches. Although WASM was initially designed for browser environments, its portable, modular architecture and efficient execution make it ideal for IoT devices, which require small and efficient runtimes.
Thus, Arbitrum Stylus’s WASM VM is a natural fit for the growing trend of Decentralized Physical Infrastructure Networks (DePIN), which aim to use blockchain networks and novel token incentives to maintain physical infrastructure ranging from Wi-Fi systems to solar cells. Since many aspects of DePIN rely on integrating blockchain stacks with IoT devices, Arbitrum Stylus can serve as a crucial gateway—enabling these devices to efficiently run WASM-based computations while accessing EVM liquidity through the Arbitrum ecosystem.
Conclusion
In this article, we explored the motivations, implementation, and implications of Arbitrum Stylus. By enabling developers to write and deploy smart contracts in a variety of mainstream languages, Stylus makes blockchain development more accessible and efficient, combining mainstream composability with EVM liquidity to unlock innovative applications—especially memory-intensive ones. As such, Stylus represents a landmark project defining the next generation of composable smart contracts: a platform that blurs the boundary between Web2 and Web3 development, creating a more efficient, integrated, and high-performance blockchain development stack.
Join TechFlow official community to stay tuned
Telegram:https://t.me/TechFlowDaily
X (Twitter):https://x.com/TechFlowPost
X (Twitter) EN:https://x.com/BlockFlow_News
Stanford Blockchain Club
