Announcing Valida Plus (Continuations, Block Proving, Client-side Proving)

We’re excited to introduce Valida 0.10.0, our most significant release yet. This update brings powerful new features to the Valida zkVM stack, expanding developer tooling, improving performance, and enabling client-side proof generation for web applications.
‍

Highlights:

• Continuations (partial execution proofs) for Valida zkVM
• Full Client-Side WASM API for Browser-Based Proofs
• Updated Rust & LLVM Compiler Toolchain
• Expanded Standard Library and Floating Point Support
• Experimental Secp256k1 & Memcpy Opcodes
• Docker Support for x86 and ARM
• ReVa, an Ethereum block prover implemented in Rust

‍Continuations (partial execution proofs) for Valida zkVM
‍

Valida now supports multi-segment proofs, enabling the zkVM to handle long program executions with improved efficiency. Developers can configure segment sizes to trade off between prover performance and proof size. This makes Valida more flexible for high-throughput applications like block proving or zkML.

In addition, this release introduces public trace commitments, a foundational step toward enabling third-party verification of public inputs and outputs.

Key Components of Continuation Implementation in Valida

Permutation Trace Enhancements

• New Permutation Column: We added a new column to the permutation argument trace to accumulate a running sum for checking persistent (cross-segment) memory interactions.
• Permutation Constraints: Related permutation constraints were implemented to ensure the integrity of the memory traces by checking the truth of the partial running sum values claimed by the proof for each chip in each segment.

BasicMachine Modifications

• Segment Handling: The execution engine now splits off segments upon reaching a configurable trace height limit, creating new instances called SegmentMachine for each segment.
• Memory Processing: The system processes the initial and final memory states, as well as register values for each segment. All segments share one output tape, accommodating the total output within a single trace (up to approximately 128 MB).

Proving and Verifying Segment Processes

• After proving each segment, the prover computes similar products using the initial and final memory states.
• The verifier collects final products to ensure consistency across all segments, confirming the integrity of the overall process.

How Continuations enables Block Proving

Continuations enable block proving by allowing longer executions to be proven, without increasing the RAM requirements of the prover by too much. Without continuations, it is possible to prove small blocks. However, continuations are required in order to prove blocks with typical Ethereum block sizes and gas limits.
‍

Browser-Based zk Proofs with Client-Side WASM API

Valida 0.10.0 makes it possible to generate and verify zk proofs directly in the browser, thanks to our new client-side WASM API. This unlocks powerful UX patterns for consumer-facing ZK apps—from gaming to identity—by enabling real-time, local proof generation on untrusted devices.

Developers can compile Rust programs to Valida, then embed the guest binary and invoke the prover directly in client-side JavaScript. See the included example projects for details.
‍

Rust & C Compiler Improvements

We’ve significantly upgraded the compiler toolchain:

• Updated to Rust 1.86 and LLVM 18.1.7
• Improved ABI compatibility between C and Rust
• Partial support for libc (via LLVM libc)
• Software-emulated floating point support
• Enhanced core::random for better randomness
• Improved support for Rust unit tests

Programs using printf, floating point math, or cryptographic hashes now work out of the box in most cases.
‍

Experimental Features: Secp256k1 and Memcpy

This release adds experimental support for Secp256k1 and memcpy as VM opcodes. These are currently supported in the execution engine but not yet in the prover or verifier.

They lay the groundwork for:

• On-chain signature verification for Ethereum-compatible applications
• Fast memory copying for high-performance programs
  ‍

Valida Docker for x86 and ARM

Valida now provides official Docker images for both x86_64 and ARM64 platforms, making it easy to get started on Intel, AMD, and Apple Silicon machines.

Simply run:

We’ve also added a native Linux installer for Ubuntu 24.04 and Arch Linux users.

‍

Reva: Ethereum Block Execution in Valida

Our open-source project Reva can now execute Ethereum blocks inside Valida, using the lightweight tiny-keccak library. This is a first step toward our full Ethereum block prover, and demonstrates Valida’s suitability for EVM and DeFi applications.
‍

What’s Next?

With Valida 0.10.0, we’re getting close to a production-ready block prover. Here’s what’s coming:

• Finalize proving soundness
• Prover support for Secp256k1 and Memcpy
• Recursive aggregation for multi-block proofs
• Rust no_std and threading support

We’re also hardening Valida’s cryptographic constraints to reach full soundness guarantees.

Thank you to our contributors and community for helping us reach this milestone.

Try Valida 0.10.0 today and join us in building the future of performant, programmable zero-knowledge computing.

👉 Documentation

👉 GitHub

‍