EVM (Ethereum Virtual Machine)

What the EVM does

The EVM takes smart contract bytecode and executes it deterministically. "Deterministic" is critical: every node running the EVM on the same input must produce the exact same output, regardless of hardware, operating system, or other context.

This determinism is what lets the network reach consensus. Every validator independently re-executes every transaction; if all honest validators arrive at the same final state, they agree on the new chain head.

The EVM is a stack-based virtual machine — operations push and pop values on a stack, with a separate memory area and persistent storage. It supports:

• Arithmetic and logic operations
• Memory and storage manipulation
• Cryptographic operations (hashing, signature verification)
• Calling other contracts
• Reading transaction and block data
• Transferring ETH

Each operation has a defined gas cost; transactions pay validators per unit of gas consumed.

EVM compatibility

A blockchain is "EVM-compatible" if it can run programs written for the EVM with little or no modification. The benefits:

• Code reuse. Existing Solidity contracts deploy with minimal changes.
• Tooling reuse. MetaMask, Hardhat, Foundry, OpenZeppelin contracts — all just work.
• Developer onboarding. Solidity developers can build on the chain immediately.
• Wallet support. EVM wallets (MetaMask) work across all EVM chains by default.

Major EVM-compatible chains:

• Ethereum mainnet — the original.
• Layer 2s — Arbitrum, Optimism, Base, Polygon zkEVM, zkSync (close), Starknet (different VM but EVM-bridge planned).
• Other L1s — BNB Chain, Polygon PoS, Avalanche C-Chain, Berachain, Monad, Linea, Celo.
• Sidechains — many smaller networks operating EVM-compatible execution.

The result: the EVM has become the de facto standard for smart-contract platforms. Even chains that aren't EVM-native often add EVM compatibility layers (Solana's Neon EVM, Cosmos's Ethermint).

Non-EVM alternatives

A few major non-EVM smart-contract platforms:

• Solana — runs the Sealevel runtime, with programs in Rust and C. Different programming model.
• Sui, Aptos — use the Move language, originally from Meta's Diem project. Object-oriented model.
• Cardano — runs Plutus, based on Haskell. Extended UTXO model.
• TON — uses Func and TVM (Telegram Virtual Machine).

These platforms argue their architectural choices produce better performance, security, or developer experience. They give up the EVM ecosystem effects in exchange.

EVM limitations

The EVM has well-known constraints:

• Sequential execution. The standard EVM executes transactions one at a time. Parallelization has been a long-standing challenge; chains like Monad and Sei work to parallelize EVM execution while preserving compatibility.
• 256-bit word size. Operations work on 256-bit values, which is overkill for many use cases but mandatory in the EVM. This adds gas cost compared to native 64-bit operations.
• Limited cryptography. Native cryptographic operations are limited; many useful primitives (BLS signatures, certain elliptic-curve operations) require expensive workarounds.
• No native parallelism. Solana and other chains parallelize transactions touching different state; the standard EVM doesn't.

EVM upgrades through EIPs gradually expand its capabilities (precompiles for new cryptographic primitives, new opcodes), but the core model has been remarkably stable.

EVM bytecode and Solidity

Most developers write smart contracts in Solidity, which compiles to EVM bytecode. Other languages targeting EVM:

• Vyper — Python-syntax language emphasizing safety and simplicity. Used by Curve, originally by Yearn.
• Yul — low-level language used internally by Solidity for optimization, sometimes written directly for performance.
• Huff — assembly-like language for the most performance-critical code.

Most production contracts are Solidity. Vyper has a smaller but engaged user base. The compiler stack continues to evolve, with newer versions producing more efficient bytecode for the same source code.

Beyond Ethereum

The EVM has become a portable computational standard that increasingly runs in places beyond Ethereum:

• Optimistic and ZK rollups — execute EVM-compatible bytecode off-chain, posting state changes to L1.
• Arbitrum Stylus — adds WebAssembly support alongside Solidity, allowing programs in Rust, C, C++.
• EVM-compatible appchains — Cosmos's Ethermint, Polkadot parachains, OP Stack chains.

For practical purposes, learning the EVM and Solidity provides access to a much broader development surface than Ethereum alone — the standard runs across thousands of chains and billions in TVL.