erigon.eth

Zilkworm v0.1.0-alpha.1 is out 🚀 The first and only zkEVM with a full C++ stack including State Transition and EVM (EVMOne) moves one step closer to production. github.com/erigontech/zil… Performance and strict testing standards have been the priority from the beginning of the project. Going forward we would also focus on security, robustness and interoperability. What's inside: 🔧 Pure C++ guest: compiled with GCC, we have removed all rust dependencies from the elf ⚡ EVMOne optimized for bare-metal RISC-V 64IM (SP1 Hypercube) 🧱 Full Osaka hardfork with native precompile implementations: BLS12-381 suite, modexp , P256verify, KZG verification 🔐 Crypto precompiles built-in (Keccak, BN254, BLS12-381, modexp, KZG, ecrecover) each accelerated by native SP1 ecalls 🌳 GridMPT: a stateless Merkle Patricia Trie built for zkVMs running on a fixed memory stack 🔩 Hand-tuned RISC-V memcpy from musl libc 🔋 Batteries included: CPU and NVIDIA GPU proving, including EthProofs integration out of the box ✅ Ethereum Execution Spec Tests across three architectures: native x86_64, rv32im, rv64im (qemu) 📦 Binaries with Docker image, ready to go (P.S. No worms or butterflies were harmed during the making of this release 🐛🦋)

🗓️ Save the date! Mark Holt will be talking about an alternative, zk-aligned model for state storage and commitment provision at the Stateless Summit (@StatelessEth) tomorrow at 15:10. efdn.notion.site/Stateless-Summ… #EVM #Ethereum #ZKVM

🚀Big updates from @somnergy and the Zilkworm team straight from @EthCC ! We’re pushing the boundaries of ZKVM performance with our Alpha 1 release. Key highlights: - Alpha 1 is LIVE: Full prover code and build instructions now published. - Speed Boost: EVM1 v19 brings ~40% faster ECC and optimized signature verification. - Efficient Memory: New stateless MPT algorithm lowers memory footprint by loading subtrees on the fly. - Native Control: Moved to a 100% C++ guest program for maximum performance tuning. - Expanding Ecosystem: Native integration with @SuccinctLabs SP1 and progressing on @zksync Airbender. The road to production is moving fast. Check out the video for more details! drive.google.com/file/d/1wtm1xV… #Zilkworm #EVM #Ethereum #RISCV #ZKVM #EthCC

Mark from the @ErigonEth team will talk about an alternative, zk aligned model for state storage and commitment provision at the Stateless Summit. Learn more and apply to join the event! 👇

🚀 Erigon v3.3.10 "Rocky Romp" is out! 🚀 🚨THIS IS A MANDATORY UPGRADE FOR ALL GNOSIS CHAIN USERS 🔹 Gnosis Fusaka Scheduled: Set for April 14, 2026, 12:06:20 UTC. 🔹 Osaka Readiness: Improved txpool handling for blob transactions and auto-conversion of legacy blob sidecars to v1 cell proofs. 🔹 RPC Enhancements: New blockRangeLimit parameter for better API range management. 🔹 CL Stability: Improved fork choice validation and better fallback for checkpoint sync failures. All Gnosis nodes must upgrade. Recommended also for all Erigon users. Full release notes: github.com/erigontech/eri… #Ethereum #GnosisChain #Erigon #Blockchain #CryptoUpdate

The Ethereum Foundation is investing tens of millions into zkVM infrastructure: formal verification, Poseidon cryptanalysis, and L2beat-style tracking via @eth_proofs. Zilkworm is already live on EthProofs, contributing to client diversity with the only native C++ implementation. If you're building: → Rollups that need faster finality → Enterprise chains with privacy requirements → Prover-as-a-service infrastructure We want to hear from you. What would make Zilkworm useful for your stack?

Ethereum validators today re-execute every block to verify it. With Zilkworm proofs, that changes: download the block header + proof, verify in milliseconds, done. No full block replay. No heavy compute. Consumer hardware can validate Gigagas blocks. This is the path to Ethereum's 1 Ggas/sec goal — and it runs on a single RTX 5090. Live benchmarks → ethproofs.org

How does ZK enable transaction privacy? Here's the key insight: to verify a block's correctness, you don't need to see every transaction. You only need cryptographic proof that the state transition was computed correctly. Zilkworm separates EVM execution from the consensus layer. Validators verify proofs, not raw transaction data. This unlocks private enterprise chains — businesses can keep internal transactions confidential while still anchoring to Ethereum's security. The ZK flow de-facto enables privacy. That's not a side effect — it's a feature. #Zilkworm #EVM #Ethereum #RISCV #ZKVM

ZK proof systems used to be hand-crafted nightmares. Every new feature meant months of cryptographer time. Every iteration felt like starting from scratch. Not anymore. RISC-V changed the game. With Zilkworm, we compile existing C++ EVM code directly to rv32im/rv64im and prove it using off-the-shelf zkVM backends. No custom circuits. No specialized DSLs. The same EVMone that powers Erigon now powers verifiable proofs. That's the beauty of general-purpose proving. #Zilkworm #EVM #Ethereum #RISCV #ZKVM 📚 zilkworm.erigon.tech

How does Zilkworm achieve 2x fewer cycles than competitors? It's not magic — it's C++ engineering on EVMone. We optimized code paths to generate fewer RISC-V instructions per EVM opcode. Same block execution, half the cycles for the prover to verify. Succinct's Tamir Hemo called it "unexpected gain for free" — turns out decades of C++ optimization practices translate directly to zkVM performance. EVM × zkVM = zkEVM. That's the formula. 📚 zilkworm.erigon.tech #Zilkworm #EVM #Ethereum #RISCV #ZKVM

Client diversity isn't just important for consensus — it matters for ZK infrastructure too. Most zkVMs in the @eth_proofs ecosystem are Rust-based. Zilkworm is the only native C++ implementation tracking on the dashboard. Different codebase = different bugs = ecosystem resilience. We're currently faster than competition in cycle count, running on cheaper hardware. Track our progress live → ethproofs.org #Zilkworm #EVM #Ethereum #RISCV #ZKVM

Selective proofs vs prove-everything: which approach wins? Zilkworm gives you the choice. Generate block-transition proofs for Ethereum L1, or plug into rollup validity pipelines — same performant C++ core, flexible prover backend. Currently integrates with: • Succinct's SP1 • RISC Zero • Pico GPU Prover • and more coming ... One zkEVM core. Multiple proving backends. Your architecture, your rules. #Zilkworm #EVM #Ethereum #RISCV #ZKVM

Every great Ethereum client started somewhere. Erigon began as TurboGeth — a hobby project in late 2017. Silkworm pushed C++ execution boundaries. Now we're shipping Erigon 3, the first all-in-one EVM node on the efficient software frontier. Zilkworm is the next chapter: proving Ethereum blocks natively, efficiently, and with full client diversity. Same DNA. New mission: ZK-scale Ethereum. 🔗 zilkworm.erigon.tech #Zilkworm #EVM #Ethereum #RISCV #ZKVM

Most zkEVMs are tightly coupled to one prover. Zilkworm isn't. We built a pluggable architecture targeting RISC-V ISAs (rv32im and rv64im). That means the same C++ core works across: → Succinct SP1 → RISC Zero → Pico GPU Prover → Any future RISC-V zkVM Why does this matter? Prover tech evolves fast. Your execution layer shouldn't be locked to yesterday's proving stack. One zkEVM core. Multiple backends. Future-proof by design. 🔗 zilkworm.erigon.tech/documentation #Zilkworm #EVM #Ethereum #RISCV #ZKVM

Proving Ethereum blocks shouldn't require a PhD. Two commands. One block proof. That's the Zilkworm developer experience. We're live on ethproofs.org running on a single 5090 GPU and a modest consumer desktop — no GPU cluster required. Check our benchmarks! #Zilkworm #EVM #Ethereum #RISCV #ZKVM

What actually makes Zilkworm different from other zkVMs? It's a stateless execution engine: takes the pre-state of a block from an existing execution trace and generates a cryptographic proof of the state transition function. No full chain replay. No Rust dependency. Pure C++ performance, aggressively tuned for RISC-V instruction sets. The result? 2.5x faster cycle counts at 100-bit security on @eth_proofs. #Zilkworm #EVM #Ethereum #RISCV #ZKVM

From Silkworm to Zilkworm: our C++ journey continues. Back in 2021, we built Silkworm — a green-field C++ Ethereum client pushing performance boundaries. That battle-tested codebase now powers Zilkworm, bringing much-needed client diversity to the zkEVM space. Why C++ when everyone's writing Rust? Because decades of optimization know-how shouldn't be left on the table. 📚 zilkworm.erigon.tech #Zilkworm #EVM #Ethereum #RISCV #ZKVM

🚀 Erigon v3.3.9 "Rocky Romp" is here! 🚨 Mandatory for all Chiado users: This release schedules the Fusaka upgrade for March 16. Update now to ensure your node stays in sync! Plus: ✅ Smoother transaction pool (no more "zombie" txns) ✅ Improved peer discovery ✅ Enhanced RPC reliability Upgrade today: github.com/erigontech/eri… #Erigon #EVM #Ethereum #gnosischain

Zero-knowledge proving has a hidden enemy: state access. Generating the cryptographic witnesses needed to prove state transitions is often more computationally expensive than the execution itself. This is exactly where Zilkworm’s heritage pays off. By inheriting the highly optimized data model pioneered by Erigon and refined in Silkworm, Zilkworm fundamentally changes how a ZK guest program interacts with Ethereum's state. Here is how our architecture accelerates the prover: - O(1) State Reads: Instead of traversing deep, fragmented trie structures just to read a balance or a smart contract variable, Zilkworm leverages flat storage. The guest program fetches data instantly. - Decoupled Witness Generation: By separating the raw storage layer from the cryptographic state trie, the prover only has to compute complex hashes when strictly necessary, drastically reducing computational overhead. - Memory Purity: A leaner, more efficient state footprint means the Zilkworm guest program fits much more comfortably within the strict memory constraints of modern ZK virtual machines. The evolution to ZK isn't just about implementing advanced cryptography; it's about how quickly and efficiently you can feed data to the prover. #Zilkworm #EVM #RISCV #ZKVM

The true test of any ZK prover isn't just whether it works—it's how fast and how affordably it operates at scale. Because Zilkworm is built on years of optimizing data models and Staged sync architecture, we attack latency at the source. Here is how a highly optimized C++ foundation changes the math for ZK rollups: - State Access Speeds: Our optimized database layout means reading the state required for a proof happens in a fraction of the time, directly reducing overall prover latency. - Compute Efficiency: A lighter, more memory-efficient guest program requires fewer resources to generate a proof, dramatically lowering cloud compute costs. - Throughput Scaling: Faster individual proofs mean higher transaction throughput for the entire network. Zilkworm isn't just proving blocks; it's proving that foundational node architecture is the key to affordable ZK scaling. #Zilkworm #EVM #RISCV #ZKVM