Introducing Valida 0.6.0

We’re thrilled to announce the release of Valida 0.6.0-alpha, a milestone packed with new features, fixes, and improvements for the Valida zkVM and compiler toolchain. This release represents a significant step forward towards proving soundness and in terms of usability and accessibility for developers building with Valida.

‍

Highlights of Valida 0.6.0-alpha

Valida zkVM: More Constraints, Closer to Soundness
‍

Valida continues to evolve with new constraints that strengthen its soundness:

• Signed 32-bit Division Constraints: Adds support for division operations within signed 32-bit integers, ensuring computations adhere to correctness and soundness requirements.
• `JALV` Constraints: Introduces constraints for the `JALV` instruction, enabling jumps to variable locations while linking to a return address.
• Public Trace Interpolation Fixes: Addresses issues in interpolating public traces, improving consistency and reliability.
• Read-From-Address Fixes: Corrects behavior when reading from addresses that were not previously written to, eliminating undefined behavior in such scenarios.

Additionally, the zkVM binary now supports logging timing data directly to the standard output, providing valuable insights into performance and debugging.

Compiler Toolchain: Enhanced Features and Developer Experience

Valida’s compiler toolchain introduces several exciting updates:

• Rust Standard Library Support
• Rust Standard I/O Support: Functions and macros like `println!` are now supported, making debugging and I/O operations more seamless for Rust developers.
• 64-bit Atomics: Added support for 64-bit atomic operations, enabling robust concurrency and parallelism.
• Link Time Optimization (LTO): With the `-flto` flag, developers can now optimize binary size and performance during the linking phase.
• Improved Error Messaging: The toolchain provides detailed error messages for unrecoverable errors in Valida program execution, such as:
• Failed assertions in Rust programs
• Failed memory allocations (`malloc`) in C programs

Other notable changes include fixes for immediate value handling in the disassembler, bundling examples and test scripts with the release, and replacing legacy references to "delendum" with "valida."

Documentation: Simplified and Expanded

We’ve focused on improving clarity and accessibility:

• New Tutorial: Added a step-by-step tutorial to help new users get started quickly with Valida.
• Rust Standard I/O Usage: Updates to documentation reflect the shift to Rust standard I/O functions.
• Simplified Usage for `libc`: Streamlined guidance for using `libc` in Valida projects.
• Updated Reference Materials: Removed outdated references to separate `valida-c-examples` and `valida-rust-examples` repositories.
• `--claimed-output` Specification: Documentation now includes clear details on specifying claimed outputs.
  ‍

Try Valida 0.6.0-alpha

We’re excited for you to try Valida 0.6.0-alpha and experience its improvements firsthand. 

[Download Valida 0.6.0-alpha] and explore the [documentation] for more details.

We’re grateful for your continued support and feedback. If you have questions or run into any issues, feel free to reach out on [our community channels].

‍

Notes of Docker

Currently we provide a Docker image which is built for x86_64. This can run on ARM systems, such as MacOS ARM, with some loss of efficiency compared to native code. We are actively working on building a Docker image of the Valida toolchain for ARM, which will be able to run on systems such as MacOS ARM with the speed of native code.

We understand that using Docker may not offer the best possible developer experience currently. We are planning to work on native support and enabling cargo run on Mac to streamline your workflow. In the meantime, we welcome your feedback to help us improve during this transition period.

‍

What's next?

In our next release (2-4 weeks), you can expect the following features:

• Partial execution proofs, aka continuations
• Groth16 wrapper for Valida proofs
• Valida zkVM API
• Optimizations for Keccak hashes