Vitalik’s recent proposal to replace the EVM with RISC-V is telling. It’s not just a change in virtual machine architecture—it’s an acknowledgement that the current execution model has hit its ceiling. But while the change might make Ethereum’s execution layer marginally cleaner and more ZK-friendly, it doesn’t touch the deeper architectural bottlenecks that limit scalability, latency, sequential execution, and fragmented state

Replacing the EVM with RISC-V is like swapping out a car’s engine while still driving on a crumbling road. The problem isn’t just what’s under the hood—it’s the road itself.

Execution Can Improve, But Structural Bottlenecks Remain

Yes, RISC-V is leaner. Yes, it’s more hardware-aligned and better for proof systems. But Ethereum’s most pressing constraints lie outside the VM. RISC-V doesn’t change how blocks are formed, how data propagates, or how state is managed. It still inherits the same assumptions: sequential execution, CPU-bound processing, and fragmented, domain-specific state. Core architectural bottlenecks that RISC-V doesn’t solve.

Blockspace remains scarce.

Gas markets and blob availability enforce a zero-sum economy on transaction inclusion. Even under RISC-V, block size and propagation latency remain constraints. A faster VM won’t change the fact that L2s depend on limited blob space and compete for the same bandwidth, reintroducing congestion under load.

Liquidity is fragmented.

Ethereum’s rollup-centric design scales vertically per rollup but fragments horizontally across them. Each rollup has a siloed state, requiring bridges and message relays. RISC-V doesn’t unify this liquidity—it just makes each silo a bit faster.

Composability is degraded.

Atomicity only exists when smart contracts share a single state tree and synchronous execution context. Cross-rollup interactions are asynchronous, delayed, and break the design primitives that made DeFi powerful. A new instruction set doesn’t rebuild this cohesion.

Latency, Finality, and Hidden Costs of RISC-V

Even if execution is faster, Ethereum still operates on slow 12-second block intervals, multi-second mempool contention, and 64 to 128 seconds delayed finality. RISC-V doesn’t fix propagation time, MEV-exposed mempools, or CPU queue backlogs. In fact, 256-bit math in Ethereum could slow down under a naive RISC-V implementation unless paired with JIT compilers or vector extensions—ironically adding more complexity.

What High-Demand Use Cases Actually Require

Scalability isn’t about theoretical TPS—in it’s about “delivering performance under real application load”. A high-frequency on-chain DEX isn’t viable if it can’t execute trades with sub-second latency. Composable DeFi protocols don’t work if cross-domain interactions require bridges or retries. On-chain games and real-time apps can’t tolerate the variability of mempool congestion, fee spikes, or minutes-long finality.

These aren’t future problems. They’re already here—and Ethereum’s architecture isn’t built to support them. Even if RISC-V made contract execution 2x more efficient, the surrounding system still enforces latency, fragmentation, and fee asymmetry that break the UX for these applications.

Why Hardware Acceleration is the Only Path Forward

Solayer’s architecture starts from first principles: execution needs to move to hardware. CPUs can’t scale throughput without introducing complexity and cost. Every rollup, sidechain, or VM tweak eventually runs into the same wall—limited single-thread performance, shared memory bottlenecks, and kernel-networking overhead.

InfiniSVM avoids this entirely. It shifts critical workloads—signature verification, hashing, ZK proving, consensus logic—onto FPGAs. These run at wire speed and can be parallelised across dedicated execution pipelines. Memory access is handled over RDMA and InfiniBand, enabling sub-microsecond state propagation between nodes without kernel involvement or context switches. This isn’t theoretical—these are proven HPC techniques already used in low-latency trading, real-time analytics, and distributed simulation.

InfiniSVM breaks the monolithic transaction pipeline into concurrent microservices: deduplication, signature check, speculative execution, and final scheduling. Each service can run on a dedicated node or hardware accelerator. Conflicts are resolved via partial replays rather than global rollbacks, allowing parallel execution to scale without coordination bottlenecks.

The result is a unified, globally consistent state machine that delivers microsecond-level latency, horizontal throughput, and no fragmentation. There are no bridges, no isolated chains, no redundant liquidity. Everything lives in one place—fast, composable, final.

The Bottom Line

RISC-V is a cleaner VM. But it doesn’t change the architecture around it. Ethereum’s scaling crisis isn’t about bad opcodes — it’s about trying to build a real-time internet on top of 2015’s VM design, running on general-purpose hardware, inside a fragmented execution model.

Solayer solves this by flipping the execution stack upside down. We start with hardware, not software. We build a low-latency, parallelized, unified execution layer — not a prettier VM running on the same old bottlenecks.

The future of blockchain execution isn’t just leaner code. It’s a faster pipeline.

And that only happens when you put the right workloads on the right machines.