Linea Shifts to RISC-V Proving Architecture

Linea Shifts to RISC-V after three years of zkEVM design

Linea confirmed the shift through its official X, following a presentation by researcher Alexander Belling at EthProofs. The team made it clear that maintaining EVM-specific constraints had become a bottleneck, slowing progress and consuming engineering resources.

After three years of pushing direct arithmetization, the project is now moving toward a simpler execution model.

From technical ambition to maintenance burden

Linea originally took one of the most ambitious approaches in the zkEVM race. Instead of abstracting execution, it directly translated EVM opcodes into polynomial constraints for zero-knowledge proofs. That decision gave it strong technical credibility and deep Ethereum equivalence.

But it came with a cost. Every Ethereum upgrade required significant rewrites across constraint modules, turning what started as innovation into ongoing maintenance overhead. The team acknowledged this directly, noting they were “fighting complexity instead of pushing the frontier.”

Why RISC-V changes the equation

RISC-V offers a fundamentally different path. It is a simple, standardized instruction set with a small number of core instructions and broad developer familiarity.

That simplicity matters in proving systems. Instead of dealing with complex, evolving EVM logic, the prover now operates on a cleaner and more predictable execution layer.

It also aligns with broader direction from the Ethereum Foundation, which has been moving toward RISC-V as part of its long-term proving roadmap. This alignment reduces the risk of fragmentation between Layer 2 systems and Ethereum itself.

Loading chart...

What actually changes under the hood

Linea is not rebuilding everything from scratch. Key components remain intact, including its zkC language, Vortex and Arcane proving systems, and formal verification framework. The shift happens at the execution layer.

Instead of encoding EVM opcodes directly into constraints, the system will execute RISC-V instructions and prove those computations. This results in narrower traces, faster proving initiation, and reduced need for constant rewrites.

For developers, nothing changes at the surface level. Smart contracts continue to run as before, with the RISC-V system operating underneath the EVM abstraction.

What this leads to next

The team plans to release deeper technical details and outline the migration timeline in the coming weeks. The current system will continue running in parallel during the transition to avoid disruption.

The next phase will focus on benchmarking performance and validating the new architecture under real workloads. For the broader ecosystem, this could accelerate the shift toward RISC-V as a standard proving layer. Or it could highlight new challenges that still need to be solved.