Original author: Yuki, PaperMoon

From the initial Substrate to the current Polkadot SDK, Polkadot's goal has never been to pursue the ultimate performance of a single chain, but to build a universal foundation for serving heterogeneous multi-chains, allowing anyone to create their own blockchain like building blocks.

This system emphasizes composability rather than compatibility; system-level collaboration rather than single-point optimization. Through modular governance, security mechanisms, and a native cross-chain protocol (XCM), it provides future developers with a "reusable underlying order."

As Gavin Wood stated, Polkadot is not "a new chain with volume compatibility," but rather a chain-building system that serves ecosystem innovation and the future of multiple chains. The Polkadot SDK is the latest form of this machine—a unified interface, a standardized development stack, and a cross-VM chain-building engine.

The history and limitations of Substrate

Launched by Parity in 2018, Substrate is a modular blockchain development framework written in Rust, providing the core technical foundation for the Polkadot mainnet and dozens of chains in its ecosystem. Its greatest innovation lies in breaking down consensus algorithms, runtime logic, account models, asset governance, and smart contracts into freely combinable pallet modules. Any team can assemble a customized blockchain like building blocks, making Substrate widely recognized as the industry's first truly Layer-0 framework.

Polkadot Substrate pioneered a new approach to blockchain development, transforming the concept of building a chain from an independent and closed design to a "lego-like" customizable blockchain. Developers can freely assemble functional modules such as governance, staking, contracts, identity, and DEX through the FRAME system, achieving "chain-level modular development" and quickly building application chains for DeFi, NFT, DID, and other scenarios.

This design enabled the early Polkadot ecosystem to foster a rich variety of chain-level innovations in a very short period of time.

However, the high degree of customization freedom offered by modularity also brings the burden of fragmentation at the ecosystem level. After years of iteration, the code and functionality for building a parachain are scattered across multiple code repositories, such as Substrate, Cumulus, and Polkadot. Each project depends on different versions and uses different branches, resulting in a severe disconnect between APIs and documentation systems.

To avoid conflicts with the main branch, many teams have to fork their own runtimes and manually maintain versions, resulting in difficulties merging the ecosystem with the main branch, complex inter-repository synchronization, and delayed version updates. As underlying dependencies and interfaces evolve independently, the entire ecosystem faces three major bottlenecks:

● Difficult to upgrade: The main trunk is progressing slowly, module updates require manual synchronization, and many chains remain on the old version for a long time.

● Difficulty in collaboration: Runtimes from different teams cannot be directly reused, and cross-chain or shared module development requires repetitive work.

● Difficult to disseminate: Fragmented documentation and toolchains, steep learning curve, making it difficult for new developers to systematically master chain-level development.

The end result was that Substrate's modular freedom actually created fragmentation at the ecosystem level. Therefore, Parity took a crucial step: unifying and integrating all core modules, interfaces, and repositories into a complete and standardized Polkadot SDK.

The birth of the Polkadot SDK: Refactoring a unified framework

After years of fragmented collaboration, Parity finally chose to carry out a historic architectural consolidation in 2023–2024.

The official team has merged Substrate, Cumulus, Polkadot (as well as FRAME and node-related repositories) into a single codebase: Polkadot SDK.

For a long time, the independent evolution of multiple repositories has caused developers to spend a lot of energy on cross-project collaboration, dependency updates, and version management.

The Polkadot SDK completely eliminates frequent synchronization and conflicts between multiple repositories through unified dependency management, standardized development specifications, and a synchronous code update mechanism.

In its merger announcement, Parity explicitly stated that this step aims to transform Substrate from merely a "flexible engineering framework" into a standardized protocol stack supporting the entire Polkadot ecosystem. The new Polkadot SDK library integrates all of Polkadot's core components.

● Substrate: Provides blockchain runtime, consensus, and core modules;

● FRAME: Build a pallet module system to implement pluggable runtime logic;

● Cumulus: As a parachain adapter layer, it enables chains to directly connect to relay chains;

● Polkadot Node: Defines the master node protocol stack and network communication logic.

The core technical structure of the Polkadot SDK

All modules, dependencies, and documentation are now unified in one repository , with complete migration documentation and update history.

This means that developers no longer need to search, piece together, and debug in multiple code repositories, but can build, debug, and deploy the entire chain in a unified environment, improving the developer experience from "flexible modularity" to "composable across the entire ecosystem".

The subsequent Polkadot SDK has gained widespread recognition from developers and the ecosystem community.

It not only forms the backbone of Polkadot's future chain-level innovations, but also makes it easier for developers to build their own Appchains or Rollups in a modular way.

The documentation system, API structure, and build tools are fully unified, significantly reducing the learning curve and greatly improving collaboration efficiency.

For Parity, this integration represents a significant architectural evolution since the inception of Polkadot; for the entire ecosystem, the Polkadot SDK marks the true beginning of the shift from "multi-chain coexistence" to "multi-chain collaboration." Substrate provides the freedom to create chains, while the SDK provides the ecosystem with order.

From SDK to REVM: The Inevitable Result of EVM Nativeization

The native EVM is natively supported on Polkadot. The emergence of REVM allows chains based on the Polkadot SDK to easily incorporate all of Ethereum's functionalities. This signifies that Polkadot no longer relies on any external EVM compatibility solutions, but instead directly integrates the core execution environment of the Ethereum ecosystem into its own system.

In the early days of the Polkadot ecosystem, EVM compatibility was handled independently by each parachain. Chains like Moonbeam, Astar, and Acala adopted the Frontier framework provided by Parity, a modular approach to implementing EVM functionality. This model gave parachains high flexibility but also created engineering fragmentation, requiring each chain to independently maintain the Frontier module, manage RPC compatibility, debug EVM logic, and fix compatibility issues.

The Parity team directly embedded the EVM engine as REVM into the main SDK, placing it alongside FRAME, Cumulus, and XCM as a core module. EVM is compatible with add-ons from various parachains and has been formally incorporated into the system core, becoming a standard capability of Polkadot.

REVM was rewritten in Rust by Parity and is natively compatible with the Polkadot SDK architecture. Its creation is not an additional compatibility layer, but rather a system-level integration.

The core features include:

● Rust implementation: High performance, memory safe, and seamlessly integrates with other SDK components;

● Native integration: REVM is compiled directly into the Polkadot SDK, eliminating the need for the Frontier add-on;

● Unified developer experience: Compatible with the entire Ethereum toolchain (Foundry, Hardhat, Ethers.js), developers can directly use existing Ethereum tools "out of the box";

● Zero migration cost: Solidity contracts can be deployed to the Polkadot mainnet or any SDK chain without modification;

● Ecosystem-level unification: All new chains have EVM execution capabilities by default, no longer relying on individual projects such as Moonbeam to provide compatibility entry points.

This means that the deployment and execution of EVM contracts will become a native function at the Polkadot mainnet level for the first time.

The emergence of REVM was not a result of external competition, but rather an inevitable product of SDK integration. When the underlying modules and protocols are fully standardized, EVM compatibility will naturally be absorbed into the system standard, rather than becoming an additional plugin. This is also the first time Polkadot has truly "absorbed Ethereum" at the execution layer, achieving a leap from "compatibility" to "native".

In 2025, Parity decided to rewrite the entire development framework.

The new Polkadot SDK not only inherits the essence of Substrate, but also compiles Ethereum's EVM directly into its core.

This is not just a version iteration, but a reconstruction of the underlying philosophy.

Polkadot is no longer just compatible with Ethereum, but rather it has absorbed it and made it a native part of it.

But the question is—Polkadot could have maintained the status quo, so why risk rewriting the entire SDK in 2025 and putting the EVM directly into the system kernel?

Substrate, originally developed by Parity (the company behind Polkadot's core development), is a modular blockchain development framework for Rust. It's used to build arbitrary blockchains and includes core modules such as consensus, storage, network, and runtime. It forms the underlying technological foundation of the Polkadot network.

Between 2023 and 2024, Parity merged Substrate, Cumulus (a cross-chain module), and the Polkadot client into a single repository named the Polkadot SDK (Software Development Kit) to simplify development structure and API management.

This integration allows developers to complete all development work for chain-level modules, consensus, cross-chain, nodes, assets, and governance using a single SDK main repository, thus transforming the process from "multiple projects using the same library" to "unified stack integrated development".

The core components of the current Polkadot SDK:

In the future, REVM will be part of the PolkaVM/PVM ecosystem as a virtual machine backend module that supports EVM (Ethereum Virtual Machine) compatibility, forming part of the "EVM-compatible solution" along with pallet-revive + ETH-RPC.

In the latest iteration of the Polkadot SDK, REVM has been explicitly incorporated into the core components (i.e., the standard module for the smart contract execution layer). All future SDK chains will automatically support REVM/EVM without the need for third-party add-ons or compatibility packages. The strategy of "providing native EVM compatibility for the Polkadot ecosystem" has been solidified in the main codebase and official development documentation.

The core technology of Polkadot SDK

The Polkadot SDK is not just an "integrated repository," but a standardized protocol stack that redefines the logic of blockchain creation. Its core goal is to ensure "system-level consistency" in blockchain construction, upgrades, cross-chain interactions, and governance, freeing developers from complex engineering configurations so they can focus on business and innovation.

This structure makes the Polkadot SDK more than just a "chain-building framework," but more like an operating system that can continuously evolve.

As the official documentation emphasizes: the SDK not only provides modules, but also defines how modules can collaborate securely, share resources, and upgrade.

From Substrate to the Polkadot SDK: Why the EVM Entered the "Native Era" with Polkadot

Substrate itself does not come with an EVM; instead, it is dynamically integrated through pallets and RPC modules in the Frontier repository. Any Substrate chain (such as Moonbeam, Astar, Acala, etc.) needs to import these modules.

Frontier nodes maintain additional data structures (Ethereum block hashes, transaction indexes, logs, etc.) to meet RPC index query functions, thus incurring higher resource overhead than pure Substrate nodes.

Some developers call it "Ethereum sandbox in Substrate" because it simulates the full EVM execution and storage model outside the Substrate environment.

However, it also brings some limitations:

User experience segmentation: Polkadot.js-like wallets need to be combined with Metamask. EVM/ERC20 and Substrate assets usually operate independently (some projects alleviate this through address mapping and custom front-ends, but the essence remains the same).

High resource consumption: Nodes need to perform dedicated indexing and block parsing for EVM-related RPCs, increasing data and storage pressure (especially for ETH-style_block/explorer, etc.).

EVM & Substrate module isolation: EVM contracts have difficulty directly calling or manipulating Substrate's native pallets, making logic reuse/permission management more complex, and the "sandbox effect" is obvious.

To overcome these limitations, Polkadot's parachain Moonbeam has achieved a deeper integration with EVM compatibility on top of the existing frontier. Moonbeam is not simply "integrating with Frontier"—it has extensively rewritten Frontier and deeply bound it to Substrate, embedding EVM pallets, Ethereum pallets, account management, and XCM cross-chain consensus interfaces into the main runtime, and unifying the distribution of underlying Substrate with EVM assets, events, and governance.

Moonbeam uses a multi-mapping and bridge pallet design to map EVM addresses to Substrate addresses, allowing accounts to transfer funds, manage assets, and call native pallets smoothly between the EVM and Substrate layers, greatly alleviating the disconnect between users' "dual wallets" (although the private key formats are different, most support dual signatures and automatic recognition).

Moonbeam nodes expose both Ethereum JSON-RPC and Substrate RPC to the outside world, allowing developers to interact with the same assets using Metamask/Hardhat/tools and Polkadot.js/app.

However, although Moonbeam implements a mapping bridge between EVM addresses and Substrate addresses, the underlying user private key types and signature algorithms (Ethereum secp256k1 and Substrate sr25519/ed25519) are always different. Not all hardware wallets or ecosystem tools can "automatically support" dual-chain signatures, which can easily cause compatibility obstacles in extreme scenarios.

Some advanced operations (especially chain-native governance, delegation, etc.) require a dedicated Substrate wallet, and the connectivity experience is still inferior to that of a pure EVM chain.

Cross-chain scenarios involving multiple assets and tokens (Native, ERC20, Substrate assets) still require managing different forms of address/ID, Approve logic, and mapping tables. Development and operation still involve maintenance complexity, and some inter-chain transfers rely on XCM or bridge protocols for post-processing, resulting in synchronization delays.

While most EVM contracts can be upgraded through governance, the flexibility and access control of upgrades are not entirely equivalent to those of Substrate runtime upgrades. In extreme cases, the migration of some assets and contract states may require chain-level coordination rather than pure EVM operations.

Disclaimer

The material provided by PaperMoon and included in this article is for educational purposes only. It does not constitute financial or investment advice, nor should it be construed as guidance for any business decisions. We recommend that readers conduct independent research and consult with professionals before making any investment or business-related decisions. PaperMoon assumes no responsibility for any actions taken based on the content of this article.

Read more

https://polkadot-evm.github.io/frontier/overview

https://github.com/polkadot-evm/frontier