Imagine if any Solidity developer could build or migrate more secure and efficient DApps on Move with almost zero barriers. Wouldn’t that be amazing?

In 2019, Libra, which briefly shook the entire tech industry before quickly fading away, probably didn’t expect that after its downfall, Aptos, Sui, Linera, and Movement would successively take up the mantle, pushing the new Move-based public chains to a new peak.

Interestingly, unlike Aptos, Sui, and Linera, which are all L1 public chains based on the Move language, the new generation Movement has set its sights on L2. It has launched the first Ethereum L2 based on the Move language, aiming to leverage Move’s execution performance and security advantages, while integrating EVM’s ecosystem benefits. This allows developers to launch Solidity projects on M2 without writing Move code.

As the first new Move-based public chain to transition from being an “Ethereum killer” to “joining Ethereum” with an integrative approach, Movement’s high-performance architecture at the L2 level, with final state security based on the Ethereum mainnet, secured a substantial $38 million funding round in April.

So, what exactly is Movement aiming to achieve, and what kind of magic does it have to attract top investment institutions like Polychain Capital, Binance Labs, OKX Ventures, and Hack VC to bet on it?

Movement: Integrating Move into the EVM Ecosystem

Since a programming language reflects the core characteristics of a blockchain project, it’s essential to review the intrinsic features of the Move language before understanding what Movement aims to achieve.

As many know, Move is a new smart contract language developed by Facebook. Aside from its initial use in Facebook’s Libra (Diem) project, Web3 products that publicly adopt the Move language are mainly found in new public chain ecosystems like Aptos and Sui.

From a public chain perspective, the Move language is essentially designed for digital assets. Compared to blockchain programming languages like Solidity, Move’s core logic highlights two main aspects: “asset security” and “native high performance.”

• On one hand, it is built on Rust and designed as an object-oriented language for writing smart contracts with secure resource management. This design emphasizes the importance of digital assets, enabling developers to define and manage digital assets on-chain more flexibly and securely.
• On the other hand, Move IR, the intermediate representation of the Move language, can decouple transaction scripts from modules, separating transaction logic from smart contracts. This allows Move-based public chains to achieve TPS (transactions per second) often in the tens of thousands or even hundreds of thousands, which is significantly higher than the performance of EVM-based public chains.

In short, blockchain networks built on Move inherently possess superior security and high-performance advantages compared to Solidity-based public chains, providing new developers with a better starting point for building on-chain applications.

However, for public chains, technical strengths are often not the main battlefield. The key to success is whether they can attract enough users and capital. This is also why the term “Ethereum killer” has rarely been mentioned in recent years. Compared to Ethereum’s continuous application layer innovations, most new public chains suffer from the “ghost town effect,” with very low user activity and liquidity on most networks.

For this reason, Movement chose a different approach, aiming to combine the security and high-performance advantages of Move-based smart contracts with the liquidity and user base advantages of the EVM ecosystem. By leveraging the concept of “bringing Move into Ethereum,” it seeks to merge the strengths of both.

For instance, Movement’s M1 and M2 public chain architectures not only naturally possess efficient transaction processing capabilities but also integrate the Ethereum Virtual Machine (EVM). This allows developers to launch and introduce mature DApps from the EVM ecosystem on M2 without writing Move code.

In other words, Movement can automatically convert Solidity scripts into opcodes that Move can understand, enabling interoperability between Move and Ethereum as well as other EVM networks.

Therefore, rather than merely bringing Move into the EVM ecosystem, Movement is effectively integrating the funds and users of the EVM ecosystem into the Movement Labs stack and the broader Move ecosystem. Ultimately, it aims to siphon traffic from the EVM ecosystem to build a more secure and efficient blockchain system.

Modular Development Suite: Movement SDK

The Movement SDK is the primary development tool for realizing the core vision of “bringing Move into Ethereum.”

As a modular development suite, it mainly consists of three core components: MoveVM, Fractal, and custom adapters (Adaptors) for the sequencer network and data availability (DA) services.

MoveVM: A Secure and Efficient Runtime Environment

Firstly, as the core of the Movement SDK, MoveVM provides a secure, efficient, and resource-oriented runtime environment for smart contracts.

This capability allows the Movement SDK to execute complex smart contracts and manage digital assets, making it an indispensable part of the M2 network (as detailed below). Thus, MoveVM is also the key to supporting the M2 network in achieving ultra-high transaction throughput and extremely fast response times. Its main features include:

• Resource-Oriented Programming: MoveVM treats assets as tangible, non-replicable resources, ensuring higher security and integrity in asset management.
• Strict Security Guarantees: Utilizing a bytecode verification process, MoveVM ensures all running code follows strict security protocols, minimizing vulnerabilities and enhancing the blockchain system’s robustness.
• Efficient Asset Management: MoveVM provides a controlled environment for precise digital asset management, ensuring transactions are executed with the highest fidelity and reliability.
• Type Safety and Formal Verification: MoveVM emphasizes type safety with a strict type system that catches errors at compile time. Combined with formal verification methods, it ensures smart contracts adhere to specified properties and security standards, reducing the risk of errors and vulnerabilities.
• Isolation and Encapsulation: In MoveVM, assets and code are encapsulated within modules, enforcing strict access control and isolation. This encapsulation prevents unauthorized access and interaction, ensuring each module operates within its defined parameters, thus enhancing overall system security and integrity.
• Bytecode Verification: MoveVM employs a thorough bytecode verification process to meticulously examine smart contracts before execution. This step ensures all contracts meet the platform’s security and correctness standards, significantly reducing the risk of executing malicious or flawed code.

It is worth noting that Movement’s MoveVM uses parallel processing technology and a modular architecture. The former optimizes the order and priority of transactions in the memory pool through algorithms, reducing congestion and delays in transaction processing through parallel processing.

The latter extends the functionality of the original MoveVM to external environments (such as EVM), creating a multifunctional virtual machine aimed at encompassing a broader interoperable blockchain ecosystem.

Just a couple of days ago, senior Move engineer @artoriatech publicly criticized the fragmentation issues currently faced by the Move ecosystem, bluntly stating that “developers face significant resistance when transitioning from one Move chain to another”:

Take Sui Move and Aptos Move as examples. Each chain is an isolated ecosystem with its unique VM and toolkit, with significant differences that continue to grow as new features are released by the protocol, to the point where they are almost different languages, and no project attempts to reduce these differences.

Movement’s modular MoveVM, as a multifunctional virtual machine, aims to be fully compatible with EVM and other Move ecosystems—currently supporting the deployment of Aptos and EVM code, and soon to cover the Sui ecosystem as well.

This means that DApps from the Aptos, Ethereum, and other EVM ecosystems can be deployed within 10 minutes—developers do not need to learn Move additionally, just keep the code in the original language architecture such as Solidity to achieve parallel deployment.

Fractal: Bridging Solidity and MoveVM

Fractal is essentially a compiler that allows Solidity smart contracts to run in the MoveVM environment. This creates a secure framework that seamlessly connects the Solidity and Move languages, enabling developers to deploy their Solidity contracts on MoveVM (M2 network).

The advantages are clear: developers can benefit from the flexibility of Solidity while utilizing the security and high performance of Move to solve some inherent issues in Solidity.

The compilation process of Fractal is mainly divided into the following 5 steps:

• Tokenization and Parsing: This process first breaks down the Solidity script into tokens that represent the basic elements of the script (such as variables, functions, and control structures). Parsing these tokens involves analyzing the syntax structure of the Solidity code and organizing the elements into an Abstract Syntax Tree (AST) that describes the logic and organization of the code;
• Abstract Syntax Tree (AST): The AST is a tree representation of the syntactic structure of Solidity code. It details the hierarchy of operations and the relationships between different segments of code;
• Intermediate Language (IL): Once the AST is constructed, the code is converted into an Intermediate Language (IL), bridging the gap between high-level Solidity code and the low-level instructions needed for execution;
• MoveVM Opcodes: The IL is then compiled into MoveVM operation codes (opcodes), which are the basic instructions that the virtual machine understands and executes, indicating specific operations that MoveVM should perform;
• MoveVM Bytecode: In the final stage, the opcodes are converted into MoveVM bytecode, the executable binary representation of the program, fully compiled from the original Solidity script and ready to run in MoveVM’s secure and resource-oriented environment.

According to the official blog, Fractal is still in the development phase, currently undergoing comprehensive testing and improvements to expand its capabilities beyond the present features.

Custom Adaptes

Custom Adaptors are the final core component of the Movement SDK (essentially the M1 architecture described below), designed to provide seamless integration with Sorter Networks and Data Availability (DA) services:

• Data Availability Services (DA): The Movement SDK integrates with DA services, allowing DA services to run directly on L1 or operate as standalone dedicated DA services, ensuring reliable access to transaction data;
• Support for Danksharding: To align with Ethereum’s development roadmap, the Movement SDK has reserved the capability to collaborate with exclusive DA service providers, including Celestia and EigenDA, which provide guaranteed data availability;
• Validator Node Management and Sorter Integration Services: The custom adaptors in the Movement SDK are also responsible for the strategic management and reconfiguration of validator nodes. By interfacing with consensus mechanisms such as Snowman and Proof of Stake (PoS), the SDK enhances the blockchain’s defense against Sybil attacks;
• Inclusivity Across DA Layers: These custom adaptors can support various DA layers, including Ethereum-4844 and several sovereign DA solutions like Celestia, EigenDA, and Avail, ensuring users can choose the DA layer that best meets their application needs;

Overall, the Movement SDK provides a comprehensive development suite that includes an environment for deploying and testing smart contracts, compilers, and adaptors, aimed at simplifying the development process. This makes it easier for developers, especially Solidity developers, to build, test, and optimize DApps based on the Move language.

“M1+M2” public chain architecture

Based on the Movement SDK, Movement Labs has developed a public chain architecture that includes M1 and M2.

M1 is designed as a community-first network capable of achieving extremely high transaction throughput and instant finality, providing a decentralized sorter network and consensus layer. M2, on the other hand, is a ZK-Rollup L2 solution based on M1 and Ethereum (supporting both Sui Move and Aptos Move), integrating EVM to allow Ethereum-compatible DApps to run on M2.

M1: Decentralized Orderer Network and Consensus Layer

M1 is officially defined as a “community-first blockchain” based on Move, capable of providing the highest possible TPS through architectures like instant finality and modular customization. Its core goal is to support complex transactions and smart contract functionalities through the high security and customizability of the Move language, while ensuring platform reliability and user-friendliness.

However, according to current public information, it is gradually transitioning into a decentralized sorter network, playing the role of “shared sorter” and “consensus layer” components in the entire Movement Labs ecosystem and any blockchain network. This aims to achieve interoperability between Move and other networks, supporting various applications and services.

Notably, due to M1’s adoption of the improved Snowman consensus mechanism, which allows nodes to reach consensus by mimicking social interactions (i.e., “chit-chat” between nodes), it naturally supports larger-scale node participation and faster consensus speeds, achieving high throughput and efficient transaction sorting.

On this basis, M1 serves as the PoS sorter network and consensus layer for M2. On one hand, it ensures the security of the M2 network through staking, and on the other hand, it provides M2 with an efficient consensus mechanism. To become a sorter in the M1 network, one needs to stake MOVE tokens and use the Slash mechanism to prevent malicious activities, enhancing the network’s security and reliability.

As the PoS sorter network for M2, M1 ensures the correctness, accessibility, and verifiability of transactions through Data Availability (DA) services and the Prover Marketplace.

M2: ZK-Rollup L2 Based on M1 and Ethereum

M2 can be regarded as the “mainnet” of the Movement ecosystem. It introduces a ZK-Rollup architecture based on Move, composed of MoveVM, Fractal, and M1, responsible for deploying specific DApp applications.

The term “ZK-Rollup architecture based on Move” is used because M2 plans to use zero-knowledge proofs to enhance privacy and security (i.e., zk-Move technology). This will give M2 not only advantages in processing speed and cost-effectiveness but also unique benefits in privacy protection.

MoveVM and Fractal enable it to execute standard EVM smart contracts and support smart contracts written in the Move language (Aptos Move, Sui Move). By utilizing the Move language and the Sui parallelization model, it can provide high throughput and low latency services for EVM transactions.

This means that developers using languages like Solidity can easily launch secure, high-performance, and high-throughput MoveVM Rollup applications, directly leveraging the native advantages of the Move language.

Finally, all transactions executed on M2 will be sorted by the M1 sorter network, with transaction data packaged and sent back to Ethereum. The finality of validity proofs is achieved through the zk-provers network of the Prover Marketplace, with the results of the ZK proofs posted on the Ethereum mainnet. The detailed transaction data is published to Celestia, thereby synchronizing the data states between the two:

With the help of Blobstream technology, the modular data availability layer of Celestia can be transmitted to Ethereum, and developers can integrate Blobstream to create high-throughput Ethereum L2s just like developing smart contracts.

In simple terms, M1 is responsible for the consensus layer and transaction sorting, M2 handles the Solidity-Move conversion and transaction execution, while Celestia/Ethereum ensures the final data availability and state security. This modular architecture undoubtedly maximizes the high performance and security of Move, along with the user and traffic advantages of EVM.

summary

Aside from the technical aspects, the ability to quickly build a large and thriving ecosystem from scratch is crucial.

Currently, Movement Labs has developed toolkits such as the Movement SDK, the messaging infrastructure Hyperlane, and the Movement Shared Sorter (M1) to provide developers with the necessary resources to easily build and deploy applications based on Move.

According to official disclosures, the Move Stack runtime environment from Movement Labs will also begin testing this summer. As an execution layer framework, it plans to be compatible with many Rollup frameworks from companies like Optimism, Polygon, and Arbitrum.

From this perspective, the combination of toolkits like M1, M2, and Move Stack could potentially create a comprehensive MoveVM universe that includes the Solidity ecosystem and the Aptos Move and Sui Move ecosystems. This would enable protocols not based on the Move language to utilize Move’s functionalities, thereby expanding the influence of the Move language.

Disclaimer：

1. This article is reprinted from [LFG Labs], All copyrights belong to the original author [LFG Labs]. If there are objections to this reprint, please contact the Gate Learn team, and they will handle it promptly.
2. Liability Disclaimer: The views and opinions expressed in this article are solely those of the author and do not constitute any investment advice.
3. Translations of the article into other languages are done by the Gate Learn team. Unless mentioned Gate.io, copying, distributing, or plagiarizing the translated articles is prohibited.