Ethereum’s EVM vs RISC-V Explained: Everything You Need To Know

Key Takeaways

• EVM still powers the ecosystem due to tooling, trust, and compatibility.
• Vitalik’s April 2025 proposal aims to replace the EVM with RISC-V, an open instruction set architecture.
• RISC-V offers lower-level execution, potential for 100x efficiency in zero-knowledge proofs, and simpler architecture.
• Critics warn of backward compatibility risks and possible fragmentation.

Ethereum is one of the most established and widely used blockchain platforms in the world. However, tech evolves—and that too fast.

Vitalik Buterin, Ethereum’s co-founder, shared a bold new proposal on April 20, 2025: replace Ethereum’s long-standing Ethereum Virtual Machine (EVM) with the RISC-V instruction set. RISC-V is an open instruction set architecture. Vitalik proposes using it as the basis for a software-emulated execution layer to replace the EVM, changing how Ethereum runs smart contracts.

The plan aims to simplify the execution layer and dramatically improve efficiency, especially for zero-knowledge proofs (ZKPs). While the EVM remains central to Ethereum today, this shift could mark a turning point in how smart contracts run on-chain.

This article explores both RISC-V and the EVM, their architectural differences, and the benefits each brings to blockchain processing.

What Is the Ethereum Virtual Machine (EVM)?

The EVM is a decentralized, software-based virtual machine that runs across a network of nodes. It executes smart contracts and processes every transaction on the Ethereum blockchain.

The EVM is deterministic, so it always produces the same output for the same input on every node. This behavior is crucial for keeping all nodes in agreement and maintaining consensus across the blockchain.

The EVM supports a large and mature ecosystem of development tools, programming languages like Solidity, and a global community of developers and decentralized applications (DApps). Many other blockchains—such as BNB Chain, Avalanche, Polygon, and Fantom—are also EVM-compatible, allowing them to run Ethereum-based smart contracts with little or no modification.

This diagram clearly explains the internal structure of the EVM by dividing it into three major parts based on how they behave: volatile machine state, immutable virtual ROM, and persistent world state.

Machine State: Volatile

• Program counter (PC): This shows the EVM where it is in the code. It points to the next instruction to run. With each step, the counter moves forward as the EVM reads and executes one operation at a time. If the code includes a jump, the counter changes direction and moves to a new location in the bytecode, the low-level, machine-readable code that a smart contract runs on the EVM.
• Stack: The EVM stack holds 256-bit values used during contract execution, such as numbers, addresses, flags, and temporary results. Every item is the same size, and the EVM processes them one at a time in strict order.
• Gas: The EVM uses gas to measure the computational effort behind each operation. This system secures the network, prevents abuse, and ensures users pay fairly for the resources they use.
• Memory: The EVM memory holds temporary data during contract execution. It resets after each transaction. As it grows, gas costs increase.

These components help the EVM process instructions step by step, but none last after execution ends.

Virtual ROM: Immutable

This is the read-only code section of the contract.

• EVM code: This is the read-only part of a contract. It holds the smart contract bytecode that the EVM executes. Once deployed, the code never changes. What happens on the blockchain stays on the blockchain. This design keeps contract behavior predictable and easy to verify, even as Ethereum upgrades, reinforcing trust across the network.

World State: Persistent

This part acts as Ethereum’s long-term memory. The EVM uses account storage to keep smart contract data, such as balances, variables, and mappings. Only the changes to this storage stay on the blockchain when a contract runs. Everything else resets. This is the only part that permanently updates Ethereum’s global state.

How RISC-V Differs From Ethereum’s EVM Architecture

RISC-V is a set of instructions engineers use to build physical computer chips. It works at the hardware level and powers devices like phones, laptops, and Internet of Things (IoT) sensors. 

RISC-V would be the basis for a software-emulated execution layer, running on general-purpose hardware (e.g., x86, ARM) across Ethereum nodes. This approach maintains decentralization while leveraging RISC-V’s lean instruction set for efficiency. 

Ethereum’s EVM, by contrast, is a software-based virtual machine that executes smart contracts on existing machines.

Before diving into the detailed comparison, here are some key terms related to Ethereum’s Virtual Machine (EVM), RISC-V, and their roles in blockchain technology that you should know:

• Instruction set architecture (ISA): A blueprint defining how a processor executes commands. RISC-V is an open ISA for flexible chip design, while the EVM uses a custom software-based ISA for smart contract execution.
• Bytecode: Machine-readable, low-level code run by a virtual machine or processor. EVM bytecode powers smart contracts, while RISC-V bytecode, in Vitalik’s plan, would optimize execution in a software-emulated layer.
• Determinism: Ensures that identical inputs yield identical outputs across all nodes, which is vital for blockchain consensus. EVM achieves this through software, and RISC-V achieves this through hardware specifications.
• Backward compatibility: The ability of a new system to run existing applications. A major hurdle for RISC-V adoption is ensuring EVM smart contracts function flawlessly via an interpreter.

Can RISC-V Compete With EVM for Blockchain Processing?

Vitalik aims to simplify Ethereum’s execution layer, improve efficiency, and unlock significant gains in ZKP performance. 

RISC-V appeals to developers focused on rebuilding Ethereum’s execution layer for long-term performance:

• Simplicity: Removes legacy complexity from the EVM and offers a cleaner, more transparent foundation.
• Efficiency: Cuts down on software layers, making execution faster and more resource-friendly.
• Scalability: Creates better conditions for ZKP and future scaling without stacking more systems on top of old ones.

Unlike the EVM, which uses stack-based bytecode, a RISC-V-based execution layer would use RISC-V instructions, emulated in software on general-purpose hardware, for potentially faster and leaner execution, especially for ZKPs. Ethereum’s core features, like accounts and storage, would remain intact, but the execution layer would be restructured. 

That said, RISC-V is not a competitor to the EVM but a proposed replacement, using its instruction set to simplify and optimize Ethereum’s execution environment.

The potential future involves RISC-V taking over the role of the EVM, not as a competitor, but as its successor with a more efficient architecture.

Smart Contracts: RISC-V Vs EVM for WEB3

The EVM runs smart contracts across Ethereum and many leading Web3 platforms, especially those that support EVM-compatible architecture. It processes Solidity and Vyper code on general-purpose machines. It keeps execution consistent across thousands of nodes and supports decentralization, compatibility, and long-term reliability.

RISC-V takes a different path. It compiles smart contracts into RISC-V bytecode for a software-emulated execution layer, running on general-purpose hardware. This shift can boost speed and reduce costs, especially for ZKP. Ethereum’s structure stays the same—accounts, storage, and cross-contract calls remain—but the execution layer changes completely.

Vitalik’s plan moves contract execution from software to hardware-level logic, aiming to simplify Ethereum and unlock performance that the EVM cannot match.

Why the EVM Still Dominates Ethereum’s Ecosystem

Ethereum offers deep integration, unmatched developer support, and contract portability. This foundation benefits EVM-compatible chains, allowing apps to launch across multiple networks without rewriting core logic.

Developers rely on mature tools, clear standards, and battle-tested infrastructure, making building and deploying contracts efficient and predictable. 

Despite long-term discussions about replacing the EVM, its dominance today comes from one thing: trust. Developers know how it works. The community knows how to secure it. 

The Ethereum network still runs on the EVM. However, Ethereum faces scalability challenges. The EVM works reliably and supports optimizations like zkEVM, but it can be slow to prove and scale with zero-knowledge systems.

RISC-V isn’t perfect either. Developed in 2010, it’s a modern, widely adopted instruction set, adaptable for blockchain despite not being designed specifically for it.

But it offers a cleaner base from which to rebuild.

For some, this shift won’t help Ethereum catch up with modern execution models. They see it as trading one outdated system for another with different limitations.

For others, replacing the EVM with RISC-V is not about chasing the latest tech—it is about stripping things down to something lean, testable, and scalable enough for the next phase of Ethereum. The next section examines the debate.

What the Future of Blockchain Hardware Looks Like With RISC-V

Replacing the EVM with RISC-V wouldn’t just shift how code is written and reshape how Ethereum runs at the hardware level. By compiling smart contracts into RISC-V bytecode for a software-emulated environment, RISC-V enables lower power consumption and faster execution, especially for tasks like ZKP.

It is hard to predict how Ethereum’s future will evolve with such a bold shift on the table. Vitalik’s push to replace the EVM with RISC-V has split opinions. Some call it visionary. Others call it risky. Jean Rausis, co-founder of the decentralized finance (DeFi) platform SMARDEX, believes the proposal could change everything:

“Vitalik’s ambitions to make Ethereum ‘as simple as Bitcoin’ by switching from the Ethereum Virtual Machine (EVM) to RISC-V could be just the monumental change DeFi’s biggest blockchain needs.”

But he doesn’t ignore the danger. Rausis warns that the transition would be “insanely monumental” and come with serious risks:

“It would involve changing Ethereum’s entire infrastructure, and this transition would be insanely monumental—but, if it works, it could thwart any competition from other Layer 1 blockchains once and for all.”

He points to backward compatibility as the most significant risk. If Ethereum switches to RISC-V, every smart contract ever written for the EVM must still run smoothly. Vitalik says an interpreter will handle this, but Rausis notes that this hasn’t been fully proven. The shift, he argues, must be handled carefully—but the payoff could be worth it.

“The RISC-V proposal would see Ethereum ‘scaling down to scale up’—getting as close as it is possible to get to the purest form. To achieve mass adoption, blockchain needs to be so simple you can explain it to a six-year-old child in ten minutes, but Ethereum remains complex. Removing this complexity and unifying everything under a single standard could be the gateway to global adoption” he says.

He also highlights what’s at stake for ZKP and DeFi scalability:

“On top of this, the promise of a 100x performance improvement by making ZK-proofs faster and cheaper would remove another major barrier, making DeFi apps easier to use, build, and scale globally. It would also open the door to new projects previously limited by Ethereum’s architecture, giving Ethereum a massive competitive advantage over other leading L1s.”

Only time will tell whether this future takes shape as promised or reveals hidden risks along the way.

Conclusion

Vitalik Buterin may be rewriting the future—or undoing his legacy. 

Replacing the EVM with RISC-V is not a minor upgrade. It’s a foundational shift that could either supercharge Ethereum’s scalability or complicate its trusted model. 

RISC-V promises simplicity, speed, and hardware-level efficiency. But the risks—backward compatibility, migration friction, and complexity in transition—are real.

Whether this move turns Vitalik into the genius who simplified Ethereum or the architect who broke its stability will depend on how the ecosystem reacts, rebuilds, and adapts.

FAQs