Exploring the need for altVMs and a look at every altVM we can think of

A special thanks to Nairolf, Shayan (Movement), Zon and Sawit (Initia), Rahul (SOON), Jim (Catalyst), Leland (Succinct), Arjun (LiFi), Nipun (Supra), Andy (The Rollupco), and Luke (Mitosis) for their feedback and review.

‍

Introduction

The Ethereum Virtual Machine (EVM) has been a key innovation in the blockchain ecosystem, enabling the development of smart contracts and decentralized applications (dApps). While it has powered Ethereum and many of the largest projects in crypto today, the EVM faces limitations around scalability and flexibility due to its design.

These challenges have given rise to alternative VMs, or altVMs. AltVMs encompass any non-EVM execution environment. This article explores the altVM landscape and the key players involved, examining their different approaches to solving blockchain scalability.

‍

Back To Basics: Understanding VMs

Before diving deeper, it’s important to understand what VMs are and why they’re so important for blockchains in the first place.

‍

What Is A VM?

A virtual machine (VM) is a software-based environment that emulates a physical computer, enabling programs to run consistently across different hardware and operating systems. By abstracting the underlying infrastructure, VMs create a controlled, standardized execution layer where applications function as if they’re operating on the same system.

In simpler terms, VMs ensure that the same code yields identical results, regardless of the host system. This makes them invaluable for environments requiring consistent and repeatable execution, such as cloud computing and, critically, blockchains.

‍

Blockchain VMs

‍

In the context of blockchains, VMs act as the execution engine for processing and executing transactions. When someone wants to transfer tokens or interact with a smart contract, the VM handles these operations according to specific rules. They are responsible for:

• State Management: The VM manages the blockchain’s state — its record of all transactions, account balances, and contract data at any given point. It reads the current state, processes and executes new transactions, and updates the state.
• Deterministic Execution: To maintain network integrity, VMs process transactions in a consistent manner across all nodes. This ensures every participant reaches the same result, a cornerstone for decentralized trust.
• Smart Contract Execution: VMs enable blockchains to run smart contracts. These contracts are converted into bytecode that the VM interprets and executes according to predefined rules.

For example, when a user interacts with a DeFi application or transfers tokens, the blockchain VM executes the required logic and updates the state of the network accordingly.

For an in-depth explanation on VMs, read more here

‍

Why Do We Need AltVMs?

The EVM has been instrumental in shaping the blockchain landscape, providing a standardized and reliable execution environment for applications and smart contracts. From DeFi platforms to NFT marketplaces and beyond, the EVM has powered some of the most widely used protocols in crypto today, and boasts the largest and most active developer community around. Its extensive ecosystem and compatibility have cemented it as the go-to choice for many projects.

However, although the EVM remains the dominant execution environment today, this doesn’t mean there isn’t room for improvement and experimentation. As developers continue to push the boundaries of what can be built onchain, many are experimenting with alternative approaches to address challenges inherent to the EVM’s design. Some of these key challenges include:

1. Scalability: Sequential transaction processing limits throughput, leading to network congestion and higher gas fees.
2. Security: Tokens in the EVM are represented as basic data types, like integers, without built-in restrictions. This design fails to prevent certain operations like copying, deleting, or modifying token balances, which can lead to vulnerabilities. For example, reentrancy attacks occur when an external contract called by a function re-enters the original contract before execution completes, disrupting the flow and enabling repeated actions like multiple withdrawals.
3. Efficiency: The EVM’s storage model imposes high computational and storage costs, making it less practical for data-intensive applications. Meanwhile the 24KB contract bytecode limit restricts the complexity of smart contracts. As a result, developers may often spend more time optimizing their smart contracts for better performance than building out their apps.
4. Flexibility For Developers: For developers new to Ethereum or the EVM, one of the initial challenges is learning Solidity, the most widely-adopted programming language on Ethereum. While Solidity is purpose-built for smart contracts and has a well-established ecosystem today, it is a new language for most developers, requiring time to familiarize themselves with its syntax, best practices, and potential pitfalls. Although the EVM supports other languages like Vyper and Huff, they also require developers to adapt, as they too are tailored to the EVM’s unique design.
5. Managing State Growth: As more smart contracts are deployed on Ethereum, the network’s data, or state, grows. Nodes need to store this data and stay updated to process new transactions. This means more storage is needed, and new nodes take longer to sync. While this doesn’t slow down transaction processing times, it makes the network continuously harder to manage over time.

These technical challenges have led developers to create new virtual machines that work differently from the EVM. This is where altVMs come into the picture.

‍

The Rise of AltVMs

As the blockchain landscape grows, the need for more flexible and scalable execution environments becomes evident. Today, alternative virtual machines (altVMs) are typically defined as any non-EVM execution environment. This framing reflects the EVM’s dominance as the most widely adopted execution environment among chains and applications.

That said, it can be argued that altVMs actually predate Ethereum. Bitcoin’s scripting system introduced basic decentralized computation by enabling simple, predefined operations like validating transactions and unlocking funds. Its limited functionality eventually gave way to the EVM, which expanded programmability and established the standard for blockchain-based computation.

Modern altVMs have emerged as a direct response to the limitations of the EVM. By offering increased performance, broader programming language support, and tailored environments for specific workloads, altVMs unlock new possibilities for applications requiring high performance and precision, whether its gaming, high-frequency trading, on-chain AI, and beyond.

This evolution has been accelerated by modular blockchains like Celestia, which separate execution, consensus, and data availability to create a foundation for more specialized VMs. By enabling flexible experimentation and tailored design, modular blockchains have contributed to the growing diversity of the altVM landscape. Each altVM offers distinct solutions to challenges like scalability, security, and performance.

With this in mind, let’s explore the key players driving this transformation.

‍

The AltVM Landscape Today

So what does the altVM landscape look like today?

‍

The SVM

The Solana Virtual Machine (SVM) is the core execution environment for Solana and now, a new emerging generation of L2s and app-chains. It compiles smart contracts (called Programs on Solana) into bytecode, allowing validators to process transactions efficiently.

‍

Unlike Bitcoin and the EVM which process transactions sequentially, the SVM was designed from the ground-up to process and execute multiple transactions at once, or in parallel. Parallelization is a core feature of the SVM, making it well-suited for high-performance chains and the applications built on top of them. This functionality is enabled by Sealevel, Solana’s runtime environment. Sealevel predefines the accounts a transaction needs to interact with ahead of time, allowing multiple non-overlapping transactions to run at the same time.

Who’s Building On The SVM?

The SVM was designed as a core component of Solana’s infrastructure, enabling the high throughput and low latency the L1 is known for. This performance has helped Solana become one of the largest activity hubs in crypto today, compelling developers to start exploring ways to adopt the SVM on their own.

A new class of L2s are emerging, utilizing the SVM for execution while maintaining the flexibility to settle on Solana or other blockchains, such as Ethereum. Some of the most notable developments include:

• Eclipse is the first blockchain to leverage the SVM outside of Solana. It’s an L2 that uses the SVM for execution, posts transaction data to Celestia, and settles to Ethereum. By taking advantage of the SVM’s parallel execution, Eclipse is able to deliver fast transaction speeds, high throughput, and low costs. Read our 2024 SVM Recap featuring Eclipse here.
• Soon — The Solana Optimistic Network (SOON) takes a unique approach to expanding the capabilities of the SVM through its Decoupled SVM architecture, which separates the SVM from Solana’s runtime environment. SOON mainnet is an L2 that settles on Ethereum, with data availability powered by EigenDA. It uses the OP Stack and a unique Decoupled SVM framework that improves efficiency by removing unnecessary vote transactions. In addition, the SOON Stack is an open-source rollup framework that merges the OP Stack with the decoupled SVM to power high-performance SVM-based L2s.
• Sonic is building a high performance onchain gaming experience powered by the SVM. It is the first L2 built on top of the Hypergrid framework, an SVM rollup framework which introduces Grids: app-specific chains secured by Solana, designed for high-demand use cases such as gaming.

Beyond L2s, some teams are also building L1s around the SVM optimized for high performance. Fogo is a new SVM-based L1 which will run on the upcoming Firedancer client. Solana restaking protocol Solayer recently announced InfiniSVM, a hardware-accelerated SVM chain.

For a comprehensive overview of the SVM landscape, read more.

‍

The Move VM

The MoveVM is a specialized execution environment built for the Move programming language. Move is a programming language from the team behind the former Libra project, designed to enhance the security, reliability, and efficiency of smart contract development. The key innovation with Move is its resource-oriented programming approach, in which digital assets are treated as unique entities, or resources, that cannot be easily duplicated or inadvertently destroyed.

MoveVM helps enforce Move’s unique resource model. It runs smart contracts written in Move by processing Move bytecode modules in a secure and isolated environment. It separates user data, which is treated as resources, from program code, designed to enhance security while running efficiently.

The VM uses a stack-based architecture to organize instructions and handle temporary data. Its strict execution paths help prevent bugs and security risks, such as re-entrancy attacks. Additionally, MoveVM ensures that smart contracts execute consistently across all blockchain nodes, supporting the network’s consensus mechanism.

Who’s Building On The Move VM?

Move has been adopted in two distinct flavors: Aptos Move and Sui Move, each with its own technical approach and design philosophy. Aptos Move builds on the original Move language, focusing on scalability and compatibility, while Sui Move introduces modifications like globally unique object IDs for optimized parallel processing.

• Aptos is a Move-based L1 developed by Aptos Labs. Aptos uses a parallel transaction execution engine called BlockSTM for high transaction throughput with low latency. The Aptos ecosystem saw significant growth in TVL in 2024, with more than 180 projects in its ecosystem today.
• Movement Labs is building Move Stack Chains, a network of Move-based rollups secured by Ethereum. The Move Stack is a modular framework for building customizable Move-based rollups, which includes the Move Executor, a high throughput execution layer with MoveVM and EVM compatibility. Movement’s flagship product will be Movement Network, a general-purpose L2 on Move.
• Supra is a high-throughput L1 that integrates the MoveVM to efficiently manage Move-based smart contracts. Beyond its sub-second consensus, Supra’s architecture is designed for full vertical integration, from smart contract execution to features such as native oracle price feeds, on-chain randomness, interoperability, and automation tools. Supra aims to provide developers with the tools needed to build scalable and efficient applications on a unified platform.
• Sui is a Move-based L1 developed by Mysten Labs. It introduces a modified version of the Move language with globally unique object IDs and an object-based data storage system. The Sui ecosystem is becoming home to a diverse range of high-performance applications across DeFi, gaming, NFTs, and more.

‍

The CosmWasm VM

The CosmWasm VM is the execution environment for CosmWasm, a smart contract platform for the Cosmos ecosystem. The CosmWasm VM simplifies smart contract development, enhances portability, and ensures consistent behavior regardless of the underlying blockchain. It offers enhanced smart contract performance through contract pinning, which stores frequently used contracts in an in-memory cache, significantly reducing waiting times and gas costs. This feature allows the CosmWasm VM to support high-performance applications on Cosmos chains.

The CosmWasm VM enables developers to build contracts, which are then compiled into WebAssembly (Wasm) bytecode to be executed. The VM acts as a mediator between the smart contract and the blockchain, ensuring that contracts can interact with the blockchain’s storage, manage accounts, and monitor resource usage (like gas), all while maintaining compatibility across various blockchain environments. Rust is the primary language for CosmWasm contracts, though other languages that compile to Wasm may also be used.

‍

Who’s Building on CosmWasm?

CosmWasm is home to many projects across the Cosmos ecosystem, enabling teams to build flexible and efficient smart contracts for a wide variety of use cases. A few examples of the many projects leveraging CosmWasm today include:

• Stride is a blockchain within the Cosmos ecosystem that provides liquidity for staked assets, allowing users to earn both staking and DeFi yields across the Cosmos IBC ecosystem. Built using the Cosmos SDK and Tendermint, Stride enables users to liquid stake any IBC-compatible Cosmos SDK native appchain token.
• Skip Protocol is an infrastructure team in the Cosmos ecosystem that has developed a suite of developer tools for enhancing interoperability in the Cosmos ecosystem. This includes Skip Go Fast, a unified REST API, widget, and core package designed to facilitate seamless cross-chain experiences for end-users utilizing the Inter-Blockchain Communication (IBC) protocol.
• Mitosis: Mitosis is an EVM-compatible Cosmos chain designed to serve as a liquidity hub for connected chains and rollups. Cosmos assets collateralized across multiple chains, like TIA from Neutron and TIA from Osmosis, can be unified on Ethereum L1 before they reach L2. Mitosis users can deposit an asset from any supported chain and receive a corresponding miAsset that they can use for DeFi. As core contributors to the cw-Hyperlane implementation, Mitosis has long since played an active role in the broader CosmWasm ecosystem.

‍

The CairoVM

The Cairo Virtual Machine (CairoVM) is a specialized execution environment designed to support the Cairo programming language using zk-STARKs. Optimized for efficient computation and verification of cryptographic proofs, it processes programs written in the Cairo programming language, which breaks down complex computations into simpler steps that can be easily verified.

CairoVM operates on a unified memory model, designed for creating provable computations to support secure high-performance and scalability.

‍

A Cairo program is compiled into Cairo bytecode, known as CASM. Cairo Zero compiles directly to CASM, while Cairo first compiles to an intermediate representation called Sierra before converting to a safe version of CASM. The CairoVM interprets this bytecode, executes the program and generates an execution trace. This trace is then used by the Cairo Prover to create a STARK proof, verifying the program’s correct execution. Generating this validity proof is Cairo’s main purpose.

Who’s Building on CairoVM?

• Starknet is a zero-knowledge rollup designed to enhance scalability and reduce transaction costs. The CairoVM allows Starknet to execute complex computations off-chain and provide succinct validity proofs on-chain, increasing throughput while maintaining Ethereum’s security. CairoVM’s performance capabilities are helping drive Starknet towards becoming a hub for high-performance applications, across DeFi, gaming, and more.
• Paradex is a high-performance decentralized perpetuals exchange, and the first appchain to be built on Starknet. It provides a seamless trading experience while allowing users to maintain full custody of their assets. Powered by the CairoVM, Paradex uses zk-STARKs to ensure fast, secure, and low-cost transactions. At the time of writing, there is over $21m in open interest and $31m in TVL across 78 markets on Paradex.

‍

The TonVM

The Open Network (TON) blockchain is a high-performance L1 originally developed by Telegram, optimizing for speed, scalability, and user accessibility. The TON Virtual Machine (TVM) is a specialized execution environment designed to run smart contracts on the TON chain. It operates as a stack-based virtual machine, utilizing a last-in, first-out (LIFO) structure to manage data during computation. This design ensures efficient execution of smart contracts by handling complex operations with reduced resource consumption.

The TVM executes smart contracts through a structured process. It begins by compiling smart contract code into bytecode, which is stored on-chain. When triggered by a message containing data or TON coins, TVM initializes a stack-based execution environment to process instructions sequentially. During execution, it manages computations, state changes, and gas consumption while enabling the contract to send messages and interact with other contracts. Finally, the blockchain state is updated, and execution logs are recorded to ensure transparency and traceability.

‍

The FuelVM

Fuel is an operating system purpose built to enhance Ethereum’s scalability by maximizing throughput, reducing latency, and optimizing application performance. The Fuel stack is made up of several key components including Fuel Ignite, a high performance L2, Sway, its own programming language, various developer tools for building in Sway, and at the heart of it all — the FuelVM. Inspired by prior blockchain VM designs including the EVM and SVM, the FuelVM is designed to deliver the performance of the SVM to an EVM-compatible environment.

The FuelVM uses a register-based design with 64-bit words, contrasting with EVM’s stack-based approach. This architecture reduces instruction count for operations, leading to better performance and lower gas costs. The VM also implements a UTXO (Unspent Transaction Output) model, allowing transactions to be processed in parallel without conflicts. This approach significantly improves throughput and reduces latency, scaling effectively with modern hardware.

The FuelVM introduces several key innovations for efficient blockchain applications. It offers state-minimized application development, such as native assets and ephemeral scripting, addressing common inefficiencies in stateful designs. Additionally, the FuelVM supports parallelized transaction execution, improving throughput and reducing latency.

‍

Arbitrum Stylus

Stylus is built for the Arbitrum ecosystem, including Arbitrum One, Arbitrum Nova, and Arbitrum Orbit chains. It introduces a second virtual machine alongside the EVM in the Arbitrum Nitro tech stack, creating what’s known as a MultiVM system, where both VMs run together and can interact seamlessly. This second VM executes WASM bytecode instead of EVM bytecode.

‍

By enabling smart contracts in languages that compile to WebAssembly (WASM), Stylus allows developers to tap into the broader ecosystem of programming tools, particularly Rust, C, and C++. Other languages like Go, Sway, Move, and Cairo are also compatible. It was built to offer:

• Faster execution and lower gas fees for compute and memory-intensive applications.
• Broader language support to attract developers beyond the Solidity ecosystem.

‍

Aztec Network

Aztec is a zk-rollup designed to enable privacy-preserving transactions while relying on Ethereum for security and data availability. It uses zk proofs to execute private functions within a Private Execution Environment (PXE) while public functions run on the Aztec Virtual Machine (AVM). This architecture allows users to choose whether they would like to keep their transaction information private or public. By integrating privacy features directly into its zk-rollup architecture, Aztec opens up Ethereum for new innovative use cases, such as private payments and identity management.

‍

Kadena

Kadena is a blockchain platform built for enterprise and institutional adoption. Its stack consists of Chainweb, a public proof-of-work chain, Pact, Kadena’s own smart contract programming language, and Kadena.js, a collection of Javascript libraries for building on Kadena.

Instead of employing a separate VM layer, Kadena integrates its execution framework directly into its architecture, powered by the Pact smart contract language. Pact avoids the complexities of traditional VMs, focusing instead on a secure, deterministic execution model that eliminates common vulnerabilities through features like formal verification and built-in error detection. This unique approach enables Kadena to provide robust state management and transaction execution without relying on a conventional VM design. Combined with Kadena’s Chainweb architecture, this execution environment has demonstrated scalability and reliability, with over 150 million transactions processed to date.

‍

zkVMs

‍

While general altVMs aim to enhance execution efficiency, flexibility, or performance for specific use cases, zkVMs stand apart by introducing verifiable computation as their core feature. They generate cryptographic proofs that validate program execution without requiring anyone to rerun the computation or even know its inputs. This makes them fundamentally different from general altVMs, which primarily optimize runtime environments for broader application performance and developer flexibility.

The key innovation of zkVMs lies in their ability to ensure correctness and trustless validation while also addressing scalability and privacy. By enabling cryptographic proof generation, zkVMs reduce the computational and storage burden on networks while preserving sensitive information.

This ability to ensure correctness and privacy makes zkVMs particularly suited for applications like rollups, private transactions, and systems requiring robust scalability without sacrificing privacy.

Notable zkVMs in production today include:

• SP1: SP1 is an open-source zkVM, it lets developers verify program execution using zero-knowledge proofs. SP1 supports Rust and any language that compiles to LLVM, allowing developers to use familiar tools without needing deep knowledge of cryptography. This makes SP1 highly accessible for building ZK applications.
• RISC Zero: RISC Zero is a zkVM that enables developers to prove the correct execution of arbitrary code. It supports languages like Rust and C++, making it easier to build zero-knowledge applications. Developers can focus on building apps and features in languages they’re familiar with.
• Jolt: Jolt is a zkVM framework for generating succinct proofs of execution for high-level programming languages. It uses the Lasso lookup argument to simplify proof generation while remaining compatible with compiled programs. It is actively developed as part of ongoing research into performant and scalable zkVMs.
• Delphinus: zkWASM is a zero-knowledge virtual machine specifically designed for WebAssembly (WASM) applications. It allows programs written for WASM to generate zero-knowledge proofs without modifying the original code. This makes it easy for developers to integrate ZKPs into their WASM-based applications.
• Nexus VM: The Nexus zkVM is an open-source virtual machine optimized for parallelized proving. It compiles and runs Rust programs, creates an execution trace, and splits the trace into chunks for parallel processing by nodes in the Nexus Network. These nodes generate proofs that are later combined into a single proof, improving speed and scalability for large computations.
• Polygon Miden: Miden VM is a Rust-based zkVM optimized for generating STARK-based proofs of execution. When a program runs on Miden VM, it automatically generates a STARK proof, which anyone can use to verify the execution without rerunning the program.
• ZKsync VM: ZKsync VM is designed for efficiently creating proofs for rollups using its State Transition Function (STF). Unlike Ethereum’s stack-based EVM, zkSync VM is a register-based machine, using 16 registers and memory, similar to modern CPUs. This design makes it more efficient for handling rollup transactions. Transactions for zkSync VM are primarily written in native ZKsync VM bytecode, making them straightforward to execute.

For a complete list of zkVMs see here.

‍

Exploring The Multi-VM Approach

So far we’ve examined a handful of different VMs and their unique approaches to blockchain scalability and performance. However, these VMs are built to exist in isolation, meaning developers still have to choose one that is best suited for their needs.

But what if developers don’t want to settle for just one VM?

The multi-VM approach is already being explored with Arbitrum Stylus. Additionally, there are several teams building dedicated solutions to enable developers to leverage the strengths of multiple VMs as opposed to just one:

• Fluent takes a different approach to VMs with blended execution, which enables new types of applications that can operate across multiple VMs and programming languages. The Fluent VM is a lightweight Wasm-based VM that enables multiple VMs to work together by converting them into rWasm format, using compatibility contracts and a Journaled ZK Trie to manage cross-VM communication and ensure reliable execution⁠. Fluent will initially support the EVM and CosmWasm, with support for SVM in development as well.

‍

• Initia allows developers to build full-stack apps by combining appchains and altVMs. Through Initia’s Interwoven Stack, developers can select between EVM, MoveVM, and CosmWasm VM for their rollup, while accessing essential infrastructure — including oracles, data availability, native USDC, and interoperability — allowing them to focus entirely on building their product. All of these rollups, regardless of VM, then seamlessly interoperate, powered by a MoveVM-based Initia L1.
• As mentioned previously, Supra is currently adopting the MoveVM to handle Move-based smart contracts. However, as a multiVM L1, its architecture is actually designed to support additional VMs. More specifically, by leveraging its Tribe-Clan architecture, Supra offers developers flexibility in VM choice while maintaining unified security and atomic composability between VMs. Beyond the MoveVM, Supra plans to launch support for EVM, SVM and CosmWasm in the future.
• SkateChain enables app-level interoperability across different VMs with stateless apps. These applications are not tied to any single blockchain or VM, allowing them to operate across multiple environments. The first Stateless App is live today with Polymarket on Eclipse. Polymarket, a decentralized prediction market live on Polygon, is accessible for users on Eclipse and TON as a Telegram app, recently surpassing $5M in trading volume.

It’s important to note that while these initiatives demonstrate the growing interest in adopting multiVM solutions, it remains to be seen how effective they will be in practice. Many of these solutions are still in their early stages, and their long-term impact on the broader altVM landscape is uncertain.

Just as developers didn’t settle for the EVM, it can be argued that they will continue to seek multiple VMs to choose from, leveraging the strengths of each for diverse applications. On the other hand, one could say that there is no need for multi-VM solutions, as a single, well-optimized VM could address most developer needs. Either way, the future of the altVM landscape is still unfolding, and teams are actively experimenting with different approaches today.

‍

The Big Challenge: Connecting All The VMs

The rise of altVMs highlights a growing need for seamless cross-VM interoperability. While altVMs excel in specialized tasks, whether its high performance or enhanced security, the real challenge lies in connecting them with one another. Each altVM operates within its own framework, and enabling them to communicate and interact seamlessly with other blockchains and applications is no easy task. And so the key question becomes: how do we connect all these distinct environments?

For altVM developers, the journey is anything but straightforward. Beyond the significant effort required to build and deploy their VM, they must also ensure interoperability protocols can support them in order to seamlessly connect with other ecosystems. For interoperability protocols, the process is equally demanding. Integrating new VMs is no easy task, as each VM has its own architecture, programming language, and technical nuances. Supporting just one VM can require weeks or even months of work, from developing a deep understanding of its core design to implementing the necessary integrations. These challenges are only magnified when scaling to support multiple VMs.

However, without interoperability, altVMs and their ecosystems risk being isolated from the users, applications, and liquidity that drive external ecosystems. This risk is magnified if one particular chain or altVM attracts a majority of activity. For instance, Solana reestablished itself as a key economic hub in the past 2 years, prompting many interoperability protocols to integrate support for its unique execution environment, the SVM. These dynamics emphasize the importance of cross-VM interoperability in a rapidly evolving blockchain landscape, which will only continue to grow throughout 2025 and beyond.

‍

Hyperlane: Accelerating AltVM Expansion

That’s where Hyperlane comes in. As a permissionless interoperability framework that empowers any team to adapt it for any environment, Hyperlane meets the growing demand of new VMs and their respective integration needs. Currently, Hyperlane supports multiple altVMs, including the SVM, CosmWasm VM, and CairoVM, with more implementations planned for 2025.

What makes Hyperlane so powerful in the growing altVM landscape is that VM expansion is not bottlenecked by any single team or entity: anyone can deploy Hyperlane to any environment, all on their own terms. For example, as mentioned earlier, the Hyperlane implementation on CosmWasm was an independent effort by the Many Things team. Similarly, for the CairoVM, the Pragma team was able to independently deploy an implementation of Hyperlane on Starknet, connecting it to the 100+ chains Hyperlane is already live on. These community-led contributions could only be possible with an open source, permissionless framework like Hyperlane.

More chains. More VMs. Connected by Hyperlane.

AltVM Expansion.

See Hyperlane’s altVM implementations here.

Interested in getting Hyperlane on your VM? Reach out here

‍

More about Hyperlane

Hyperlane is the open interoperability framework. It empowers developers to connect anywhere onchain and build applications that can easily and securely communicate between multiple blockchains. Importantly, Hyperlane is fully open-source and always permissionless to build with.

Website | Docs | Twitter | Discord | Careers