Frequently asked questions

Zig EVM is an open-source (MIT) implementation of the Ethereum Virtual Machine, written from scratch in the Zig programming language. It is an embeddable execution core — not a chain — that executes EVM bytecode across 96+ opcodes with spec-accurate gas metering, runs independent transactions in parallel for a measured 5-6x throughput gain over sequential execution, and offers native FFI bindings for Python, Rust, JavaScript and C.

No. Zig EVM is an execution engine, not a chain. There is no consensus, networking, mempool, or token — by design. You embed the engine into your own system (an L2 sequencer, rollup prover, agent runtime, simulator, or indexer) and bring your own network. That is what makes it cheap to adopt: you get parallel EVM execution without migrating to a new chain.

Yes. Zig EVM is MIT-licensed and the full source is on GitHub at github.com/cryptuon/zig-evm — including every opcode implementation, the parallel executor and the test suite.

It is an embeddable execution core for research, tooling, testing and high-throughput transaction execution — anywhere you want a fast, understandable parallel EVM without pulling in a full Ethereum client. In 2026 that increasingly means agent-driven, high-frequency workloads: agentic payments, on-chain and verifiable AI, and RWA settlement.

Zig offers zero-overhead abstractions, compile-time evaluation and manual memory management (arena allocators and memory pools) with no garbage collector — a good fit for a performance-sensitive interpreter. The blog post "Why Zig for Blockchain" covers the reasoning.

More than 96, spanning arithmetic (ADD, MUL, DIV, EXP…), comparison and bitwise (LT, GT, AND, SHL…), stack (PUSH1–PUSH32, DUP, SWAP, POP), memory (MLOAD, MSTORE, MSIZE), flow control (JUMP, JUMPI, RETURN, REVERT) and environmental/block-information opcodes.

Gas costs match Ethereum specifications: a 21,000-gas base transaction cost, per-opcode costs from getGasCost(), and dynamically computed memory-expansion gas. Gas is charged before each opcode runs, with out-of-gas protection.

A BigInt system represents 256-bit integers as 4×64-bit words and provides full arithmetic, comparison and bitwise operations, with conversion utilities for EVM compatibility.

Zig EVM analyses dependencies between transactions — address read/write, balance modifications and nonce conflicts — and groups independent transactions into waves. Each wave runs concurrently on a work-stealing thread pool with speculative execution and rollback.

A measured 5-6x throughput improvement over sequential execution for independent transactions, scaling linearly up to 8 threads. The optimized dependency analysis is O(n) hash-based — faster than a naive O(n²) path on large batches. This is the only performance figure we state as measured; other numbers on the site are labelled representative.

Transactions that conflict on the same accounts are not run in the same wave; they are scheduled so that observable results remain equivalent to sequential execution.

No — and we would rather be honest than oversell. The 5-6x gain holds for batches of largely independent transactions (many distinct senders and receivers, little shared state). Workloads dominated by shared-state contention — many trades against one AMM pair, or long single-sender nonce chains — parallelize far less, closer to 1-2x. The right move is to measure on your own transaction mix.

Single-threaded EVM execution has become the bottleneck for the workloads growing fastest: agentic payments and machine-initiated, high-frequency transactions; on-chain and verifiable AI that settles results to the EVM; and RWA settlement that needs deterministic, auditable execution. Parallel EVM is the industry answer to that bottleneck. Zig EVM delivers it as an embeddable core so you get the throughput headroom without adopting a new chain.

Monad is a full parallel L1 chain/client; reth (revm) and geth are full Ethereum execution clients (sequential by default, though revm is embeddable in Rust); the Solana SVM is a non-EVM parallel runtime. Zig EVM occupies a different spot: an embeddable EVM engine with wave-based parallel execution and a stable C ABI plus four language bindings. If you want an EVM you can link into your own system and run in parallel, that is the gap it fills. Cross-project performance depends on hardware and workload, so treat comparisons as qualitative.

For an embeddable engine, "production" means a spec-conformant, versioned library others can safely embed — not launching a chain. The cheapest path is shipping the library plus one reference integration on a cheap devnet or L2, with production-viability defined by a checklist: Ethereum execution-spec / consensus-test conformance, differential fuzzing against a reference EVM, a security audit, a stable versioned FFI, and reproducible benchmarks. Broadening conformance, fuzzing, and audit are tracked roadmap items in progress — see the roadmap in the GitHub repository.

Python (ctypes), Rust (safe wrappers over the C ABI), JavaScript (Node.js N-API via the zigevm package, Node >= 14) and C (a zigevm.h header). All of them go through the stable C ABI exported from src/ffi.zig.

Yes — the playground is a browser-based bytecode editor with real-time disassembly, stack visualisation and step-by-step execution tracing. No install required.

The site is a static build on GitHub Pages, and a Docker container is provided for the web demo.