RISC Zero is a zero-knowledge verifiable general computing platform based on zk-STARKs and the RISC-V microarchitecture.

Overview

RISC Zero

WARNING: This software is still experimental, we do not recommend it for production use (see Security section).

RISC Zero is a zero-knowledge verifiable general computing platform based on zk-STARKs and the RISC-V microarchitecture.

A zero knowledge proof allows one party (the prover) to convince another party (the verifier) that something is true without revealing all the details. In the case of RISC Zero, the prover can show they correctly executed some code (known to both parties), while only revealing to the verifier the output of the code, not any of its inputs or any state during execution.

The code runs in a special virtual machine, called the ZKVM. The RISC Zero ZKVM emulates a small RISC-V computer, allowing it to run arbitrary code in any language, so long as a compiler toolchain exists that targets RISC-V. Currently, SDK support exists for Rust, C, and C++.

Protocol overview and terminology

First, the code to be proven must be compiled from its implementation language into a method. A method is represented by a RISC-V ELF file with a special entry point that runs the code of the method. Additionally, one can compute for a given method its method ID which is a special type of cryptographic hash of the ELF file, and is required for verification.

Next, the prover runs the method inside the ZKVM. The logical RISC-V machine running inside the ZKVM is called the guest and the prover running the ZKVM is called the host. The guest and the host can communicate with each other during the execution of the method, but the host cannot modify the execution of the guest in any way, or the proof being generated will be invalid. During execution, the guest code can write to a special append only log called the journal that represents the official output of the computation.

Presuming the method terminated correctly, a receipt is produced, which provides the proof of correct execution. This receipt consists of 3 parts: the method ID of the method run, the journal written during execution, and a blob of opaque cryptographic data called the seal.

The verifier can then verify the receipt and examine the log. If any tampering was done to the method ID, the journal, or the seal, the receipt will fail to verify. Additionally, it is cryptographically infeasible to generate a valid receipt unless the output of the journal is the exactly correct output for some valid execution of the method whose method ID is in the receipt. In summary, the receipt acts as a zero knowledge proof of correct execution.

Additionally, since the protocol is zero knowledge, the verifier cannot infer anything about the details of the execution or any data passed between the host and the guest (aside from what is implied by the data written to the journal and the correct execution of the code).

Security

This code is based on the well studied zk-STARK protocol, which has been proven secure under the random oracle model, with the only assumption being the security of the cryptographic hash used. Our implementation uses SHA-256 for that hash and targets a security factor of 100 bits of security.

That said, this code is still under heavy development and has not been audited. There may be bugs in the zk-STARK implementation, the arithmetic circuit used to instantiate the RISC-V ZKVM, or any other element of the code's implementation. Such bugs may impact the security of receipts, leak information, or cause any other manner of problems. Caveat emptor.

Rust Crates

name crates.io docs.rs
risc0-build x
risc0-core-sys x
risc0-zkp-core x
risc0-zkp-sys x
risc0-zkvm-circuit-gen x
risc0-zkvm-circuit-sys x
risc0-zkvm-core x
risc0-zkvm-guest x
risc0-zkvm-host x
risc0-zkvm-platform-sys x
risc0-zkvm-serde x
risc0-zkvm-sys x
risc0-zkvm-verify x

Examples

In addition to the RISC Zero proof system, we include a number of small examples, each with their own README, in the 'examples' directory.

Building RISC Zero

We use Bazel for its strong multi-language multi-platform features and performance.

We recommend using Bazelisk to make bazel version management seamless.

In order to build RISC Zero executables you'll need a RISC-V toolchain. Bazel will automatically fetch and manage the toolchain for the following platforms:

  • Linux - Ubuntu 18+ (x86_64)
  • macOS (x86_64)
  • macOS (arm64)
  • Windows (x86_64)

Other platforms will be supported in the future.

You should be able to build and run all tests with:

bazelisk test //...

Linux

A C++ compiler must be installed; both gcc and clang should work. Let us know if you run into any issues.

macOS

RISC Zero development on macOS requires a full installation of Xcode (not just command line tools).

Windows

Our usage of Bazel requires symlink support to be enabled. This is possible on Windows by enabling Developer Mode, or by running Bazel as an administrator.

A C++ compiler must be installed. Visual Studio 2019 Build Tools is known to work (as does the Community edition). Let us know if you run into any issues.

Comments
  • `risc0-zkp-accel` 0.4.0 build failed on docs.rs

    `risc0-zkp-accel` 0.4.0 build failed on docs.rs

    I was monitoring the docs.rs recent build failures and noticed that risc0-zkp-accel 0.4.0 is failing because it attempts to access the network in its build script: https://docs.rs/crate/risc0-zkp-accel/0.4.0

    It should be sufficient to omit the network accesses when the crate is being built by docs.rs. You can check for the DOCS_RS environment variable and skip the network access, or just fail gracefully without panicking.

    (In fact, it seems like a lot of your crates are failing to build, such as risc0-zkvm-host-sys, risc0-zkvm-prove, and risc0-zkvm-host.)

    bug 
    opened by LoganDark 8
  • Support Traditional Rust Build?

    Support Traditional Rust Build?

    I was just trying to build risc0 and unfortunately ran into issues because I'm behind an HTTP proxy that requires authentication and has a custom HTTPS certificate, and Java, which is apparently what bazel is using to download files, really doesn't like proxies.

    I've never gotten Java to successfully go through my proxy. :confused:

    Anyway, that's not really your fault or anything you can do about it, but I was also wondering whether or not you would be open to supporting alternative build systems, such as would allow you to add the Rust crate to a normal Rust project and have it built without requiring Bazel to be installed.

    Usually this is done in the Rust build.rs script, which will compile the C++ automatically and setup the linker so that the Rust user doesn't really have to think about the C++, other than making sure they have a C++ compiler installed.

    I could probably setup a separate git Repo that would add this one as a submodule and contain the build scripts if it wasn't something you wanted to worry about integrating into this repo, but I wanted to see how you felt about it.


    Somewhat related I was also wondering if you had any warnings for me if I attempted to do a pure Rust port. :)

    Rust is my favorite language and the most-used in projects I'm investing in, and I noticed that this project wasn't massive on lines of code. Only 6.3k lines of C++ code, which is awesome that you've been able to keep the codebase so small!

    Also, I'm thinking from the perspective of needing to compile to WASM, and I'm not sure how well compiling a hybrid C++/Rust project will work when I need to target WASM. I'm not sure if that requires building the C++ to WASM and then the Rust to WASM and linking the two WASM modules? ( I think that's experimentally supported by something, but I can't remember where I saw that. )


    Anyway, I'm just getting into a closer investigation of the project and I'm not sure if I'll actually have time to mess around much longer or if I'll get to using it for anything, but I really appreciate your time!

    enhancement 
    opened by zicklag 8
  • Inlining failed in call to 'always_inline' when building the project

    Inlining failed in call to 'always_inline' when building the project

    I try to build and run all tests by executing bazelisk test //... but then I get a compilation error:

    ERROR: /home/kamos/.cache/bazel/_bazel_kamos/76ead71fc5575ebd7e484e2e8c787a36/external/.workspace.oneTBB/BUILD.bazel:25:11: Compiling src/tbb/task_dispatcher.cpp [for host] failed: (Exit 1): gcc failed: error executing command /usr/bin/gcc -U_FORTIFY_SOURCE -fstack-protector -Wall -Wunused-but-set-parameter -Wno-free-nonheap-object -fno-omit-frame-pointer -g0 -O2 '-D_FORTIFY_SOURCE=1' -DNDEBUG -ffunction-sections ... (remaining 31 arguments skipped)
    
    Use --sandbox_debug to see verbose messages from the sandbox
    In file included from /usr/lib/gcc/x86_64-pc-linux-gnu/11.2.0/include/x86gprintrin.h:81,
                     from /usr/lib/gcc/x86_64-pc-linux-gnu/11.2.0/include/immintrin.h:27,
                     from external/.workspace.oneTBB/include/oneapi/tbb/detail/_machine.h:42,
                     from external/.workspace.oneTBB/include/oneapi/tbb/detail/_utils.h:26,
                     from external/.workspace.oneTBB/src/tbb/task_dispatcher.h:20,
                     from external/.workspace.oneTBB/src/tbb/task_dispatcher.cpp:17:
    /usr/lib/gcc/x86_64-pc-linux-gnu/11.2.0/include/waitpkgintrin.h: In function 'void tbb::detail::r1::prolonged_pause()':
    /usr/lib/gcc/x86_64-pc-linux-gnu/11.2.0/include/waitpkgintrin.h:53:1: error: inlining failed in call to 'always_inline' 'unsigned char _tpause(unsigned int, long long unsigned int)': target specific option mismatch
       53 | _tpause (unsigned int __A, unsigned long long __B)
          | ^~~~~~~
    In file included from external/.workspace.oneTBB/src/tbb/task_dispatcher.h:24,
                     from external/.workspace.oneTBB/src/tbb/task_dispatcher.cpp:17:
    external/.workspace.oneTBB/src/tbb/scheduler_common.h:230:16: note: called from here
      230 |         _tpause(0, time_stamp + 700);
          |         ~~~~~~~^~~~~~~~~~~~~~~~~~~~~
    In file included from /usr/lib/gcc/x86_64-pc-linux-gnu/11.2.0/include/x86gprintrin.h:81,
                     from /usr/lib/gcc/x86_64-pc-linux-gnu/11.2.0/include/immintrin.h:27,
                     from external/.workspace.oneTBB/include/oneapi/tbb/detail/_machine.h:42,
                     from external/.workspace.oneTBB/include/oneapi/tbb/detail/_utils.h:26,
                     from external/.workspace.oneTBB/src/tbb/task_dispatcher.h:20,
                     from external/.workspace.oneTBB/src/tbb/task_dispatcher.cpp:17:
    /usr/lib/gcc/x86_64-pc-linux-gnu/11.2.0/include/waitpkgintrin.h:53:1: error: inlining failed in call to 'always_inline' 'unsigned char _tpause(unsigned int, long long unsigned int)': target specific option mismatch
       53 | _tpause (unsigned int __A, unsigned long long __B)
          | ^~~~~~~
    In file included from external/.workspace.oneTBB/src/tbb/task_dispatcher.h:24,
                     from external/.workspace.oneTBB/src/tbb/task_dispatcher.cpp:17:
    external/.workspace.oneTBB/src/tbb/scheduler_common.h:230:16: note: called from here
      230 |         _tpause(0, time_stamp + 700);
          |         ~~~~~~~^~~~~~~~~~~~~~~~~~~~~
    In file included from /usr/lib/gcc/x86_64-pc-linux-gnu/11.2.0/include/x86gprintrin.h:81,
                     from /usr/lib/gcc/x86_64-pc-linux-gnu/11.2.0/include/immintrin.h:27,
                     from external/.workspace.oneTBB/include/oneapi/tbb/detail/_machine.h:42,
                     from external/.workspace.oneTBB/include/oneapi/tbb/detail/_utils.h:26,
                     from external/.workspace.oneTBB/src/tbb/task_dispatcher.h:20,
                     from external/.workspace.oneTBB/src/tbb/task_dispatcher.cpp:17:
    /usr/lib/gcc/x86_64-pc-linux-gnu/11.2.0/include/waitpkgintrin.h:53:1: error: inlining failed in call to 'always_inline' 'unsigned char _tpause(unsigned int, long long unsigned int)': target specific option mismatch
       53 | _tpause (unsigned int __A, unsigned long long __B)
          | ^~~~~~~
    In file included from external/.workspace.oneTBB/src/tbb/task_dispatcher.h:24,
                     from external/.workspace.oneTBB/src/tbb/task_dispatcher.cpp:17:
    external/.workspace.oneTBB/src/tbb/scheduler_common.h:230:16: note: called from here
      230 |         _tpause(0, time_stamp + 700);
          |         ~~~~~~~^~~~~~~~~~~~~~~~~~~~~
    INFO: Elapsed time: 45.283s, Critical Path: 28.89s
    INFO: 99 processes: 29 internal, 70 linux-sandbox.
    FAILED: Build did NOT complete successfully
    

    Is this somewhat known and already solved?

    The system is archlinux, kernel 5.17.1, gcc version 11.2.0.

    opened by alexmikhalevich 8
  • rust: Implement cc wrapper

    rust: Implement cc wrapper

    This PR is for providing a wrapper for the cc crate that compiles to riscv32im if the CARGO_CFG_TARGET_ARCH is set to riscv32 with no boilerplate and reasonable defaults. It's useful for libraries that depend on c/cpp.

    e.g.

    fn main() {
        risc0_zkvm::build::rcc::Build::new()
            .file("src/foo.c")
            .compile("foo");
    }
    

    is equivalent to...

    fn main() {
         cc::Build::new() // The normal `cc` crate
             .target("riscv32im-unknown-none-elf")
             .no_default_flags(true)
             .flag("-O3")
             .flag("--target=riscv32-unknown-none-elf")
             .flag("-mabi=ilp32")
             .flag("-mcmodel=medany")
             .flag("-fdata-sections")
             .flag("-ffunction-sections")
             .flag("-dead_strip")
             .flag("-flto")
             .flag("-march=rv32im")
             .file("src/foo.c")
             .flag("-static")
             .flag("--sysroot=/opt/riscv/riscv32-unknown-elf")
             .flag("--gcc-toolchain=/opt/riscv")
             .compile("foo");
    }
    
    opened by cemozerr 7
  • Use memcpy and memset from musl for performance benefit

    Use memcpy and memset from musl for performance benefit

    Base: commit 37e18b7bf307fa4a8c745feebfcba54a0ba74f30

    • src/string/memcpy.c
    • src/string/memset.c

    This was compiled into assembly with:

    clang-14 -target riscv32 -march=rv32im -O3 -S memcpy.c -nostdlib -fno-builtin -funroll-loops

    and labels manually updated to not conflict.

    License is MIT, see https://git.musl-libc.org/cgit/musl/tree/COPYRIGHT

    This work was prompted by slow performance seen in compiler-builtins in Rust being the memcpy/memset:

    https://github.com/rust-lang/compiler-builtins/blob/master/src/mem/mod.rs#L25

    cargo bench output from risc0/zkvm/sdk/rust, initially ran on baseline of f99fe08babce1f679fbf6b660028b89d99d35eb0 / current main at the time, with all CPUs in performance governor on a Intel(R) Xeon(R) CPU E3-1275 v5 @ 3.60GHz - please confirm independently (impact seen in memset and memcpy benchmarks):

    Benchmarking raw_sha/0: Warming up for 3.0000 s
    Benchmarking raw_sha/0: Collecting 100 samples in estimated 20.002 s (20k iterations)
    Benchmarking raw_sha/0: Analyzing
    raw_sha/0               time:   [1.0618 ms 1.0627 ms 1.0640 ms]
                            thrpt:  [0.0000   B/s 0.0000   B/s 0.0000   B/s]
                     change:
                            time:   [+0.1294% +0.2691% +0.4031%] (p = 0.00 < 0.05)
                            thrpt:  [-0.4015% -0.2684% -0.1293%]
                            Change within noise threshold.
    Found 6 outliers among 100 measurements (6.00%)
      3 (3.00%) high mild
      3 (3.00%) high severe
    Benchmarking raw_sha/64
    Benchmarking raw_sha/64: Warming up for 3.0000 s
    Benchmarking raw_sha/64: Collecting 100 samples in estimated 20.049 s (20k iterations)
    Benchmarking raw_sha/64: Analyzing
    raw_sha/64              time:   [1.1025 ms 1.1036 ms 1.1051 ms]
                            thrpt:  [56.555 KiB/s 56.633 KiB/s 56.691 KiB/s]
                     change:
                            time:   [+1.1370% +1.3065% +1.4829%] (p = 0.00 < 0.05)
                            thrpt:  [-1.4612% -1.2897% -1.1242%]
                            Performance has regressed.
    Found 5 outliers among 100 measurements (5.00%)
      2 (2.00%) high mild
      3 (3.00%) high severe
    Benchmarking raw_sha/512
    Benchmarking raw_sha/512: Warming up for 3.0000 s
    Benchmarking raw_sha/512: Collecting 100 samples in estimated 20.061 s (18k iterations)
    Benchmarking raw_sha/512: Analyzing
    raw_sha/512             time:   [1.3080 ms 1.3089 ms 1.3103 ms]
                            thrpt:  [381.59 KiB/s 382.00 KiB/s 382.28 KiB/s]
                     change:
                            time:   [-1.1905% -1.0083% -0.8434%] (p = 0.00 < 0.05)
                            thrpt:  [+0.8506% +1.0186% +1.2049%]
                            Change within noise threshold.
    Found 3 outliers among 100 measurements (3.00%)
      3 (3.00%) high severe
    Benchmarking raw_sha/2048
    Benchmarking raw_sha/2048: Warming up for 3.0000 s
    Benchmarking raw_sha/2048: Collecting 100 samples in estimated 20.134 s (6600 iterations)
    Benchmarking raw_sha/2048: Analyzing
    raw_sha/2048            time:   [4.0441 ms 4.0465 ms 4.0500 ms]
                            thrpt:  [493.83 KiB/s 494.25 KiB/s 494.54 KiB/s]
                     change:
                            time:   [+0.0022% +0.0709% +0.1631%] (p = 0.08 > 0.05)
                            thrpt:  [-0.1628% -0.0708% -0.0022%]
                            No change in performance detected.
    Found 7 outliers among 100 measurements (7.00%)
      1 (1.00%) low mild
      2 (2.00%) high mild
      4 (4.00%) high severe
    Benchmarking raw_sha/8192
    Benchmarking raw_sha/8192: Warming up for 3.0000 s
    Benchmarking raw_sha/8192: Collecting 100 samples in estimated 22.252 s (200 iterations)
    Benchmarking raw_sha/8192: Analyzing
    raw_sha/8192            time:   [342.26 ms 342.38 ms 342.53 ms]
                            thrpt:  [23.356 KiB/s 23.366 KiB/s 23.374 KiB/s]
                     change:
                            time:   [+0.5052% +0.5480% +0.5962%] (p = 0.00 < 0.05)
                            thrpt:  [-0.5927% -0.5450% -0.5027%]
                            Change within noise threshold.
    Found 5 outliers among 100 measurements (5.00%)
      3 (3.00%) high mild
      2 (2.00%) high severe
    
    Benchmarking memset/memset/32
    Benchmarking memset/memset/32: Warming up for 3.0000 s
    Benchmarking memset/memset/32: Collecting 100 samples in estimated 5.1077 s (4400 iterations)
    Benchmarking memset/memset/32: Analyzing
    memset/memset/32        time:   [1.4813 ms 1.4826 ms 1.4848 ms]
                            change: [+5.8207% +6.0225% +6.2050%] (p = 0.00 < 0.05)
                            Performance has regressed.
    Found 7 outliers among 100 measurements (7.00%)
      5 (5.00%) high mild
      2 (2.00%) high severe
    Benchmarking memset/memset/64
    Benchmarking memset/memset/64: Warming up for 3.0000 s
    Benchmarking memset/memset/64: Collecting 100 samples in estimated 5.1182 s (3900 iterations)
    Benchmarking memset/memset/64: Analyzing
    memset/memset/64        time:   [1.7197 ms 1.7215 ms 1.7244 ms]
                            change: [-14.422% -14.312% -14.160%] (p = 0.00 < 0.05)
                            Performance has improved.
    Found 9 outliers among 100 measurements (9.00%)
      5 (5.00%) high mild
      4 (4.00%) high severe
    Benchmarking memset/memset/128
    Benchmarking memset/memset/128: Warming up for 3.0000 s
    Benchmarking memset/memset/128: Collecting 100 samples in estimated 5.0341 s (2500 iterations)
    Benchmarking memset/memset/128: Analyzing
    memset/memset/128       time:   [2.4919 ms 2.4948 ms 2.4990 ms]
                            change: [-18.771% -18.663% -18.531%] (p = 0.00 < 0.05)
                            Performance has improved.
    Found 10 outliers among 100 measurements (10.00%)
      6 (6.00%) high mild
      4 (4.00%) high severe
    Benchmarking memset/memset/256
    Benchmarking memset/memset/256: Warming up for 3.0000 s
    Benchmarking memset/memset/256: Collecting 100 samples in estimated 5.0387 s (2000 iterations)
    Benchmarking memset/memset/256: Analyzing
    memset/memset/256       time:   [3.3286 ms 3.3320 ms 3.3372 ms]
                            change: [-39.949% -39.831% -39.715%] (p = 0.00 < 0.05)
                            Performance has improved.
    Found 7 outliers among 100 measurements (7.00%)
      2 (2.00%) high mild
      5 (5.00%) high severe
    Benchmarking memset/memset/512
    Benchmarking memset/memset/512: Warming up for 3.0000 s
    Benchmarking memset/memset/512: Collecting 100 samples in estimated 5.2650 s (1200 iterations)
    Benchmarking memset/memset/512: Analyzing
    memset/memset/512       time:   [5.5545 ms 5.5604 ms 5.5694 ms]
                            change: [-49.845% -49.787% -49.692%] (p = 0.00 < 0.05)
                            Performance has improved.
    Found 6 outliers among 100 measurements (6.00%)
      2 (2.00%) high mild
      4 (4.00%) high severe
    Benchmarking memset/memset/1024
    Benchmarking memset/memset/1024: Warming up for 3.0000 s
    Benchmarking memset/memset/1024: Collecting 100 samples in estimated 5.7669 s (700 iterations)
    Benchmarking memset/memset/1024: Analyzing
    memset/memset/1024      time:   [9.9648 ms 9.9737 ms 9.9878 ms]
                            change: [-60.101% -60.002% -59.921%] (p = 0.00 < 0.05)
                            Performance has improved.
    Found 5 outliers among 100 measurements (5.00%)
      3 (3.00%) high mild
      2 (2.00%) high severe
    Benchmarking memset/memset/2048
    Benchmarking memset/memset/2048: Warming up for 3.0000 s
    Benchmarking memset/memset/2048: Collecting 100 samples in estimated 6.3538 s (400 iterations)
    Benchmarking memset/memset/2048: Analyzing
    memset/memset/2048      time:   [24.343 ms 24.416 ms 24.524 ms]
                            change: [-54.541% -54.365% -54.156%] (p = 0.00 < 0.05)
                            Performance has improved.
    Found 10 outliers among 100 measurements (10.00%)
      3 (3.00%) high mild
      7 (7.00%) high severe
    Benchmarking memset/memset/4096
    Benchmarking memset/memset/4096: Warming up for 3.0000 s
    Benchmarking memset/memset/4096: Collecting 100 samples in estimated 6.2785 s (200 iterations)
    Benchmarking memset/memset/4096: Analyzing
    memset/memset/4096      time:   [51.883 ms 51.952 ms 52.065 ms]
                            change: [-58.149% -58.049% -57.944%] (p = 0.00 < 0.05)
                            Performance has improved.
    Found 8 outliers among 100 measurements (8.00%)
      4 (4.00%) high mild
      4 (4.00%) high severe
    
    Benchmarking memcpy/memcpy-aligned/32
    Benchmarking memcpy/memcpy-aligned/32: Warming up for 3.0000 s
    Benchmarking memcpy/memcpy-aligned/32: Collecting 100 samples in estimated 5.0745 s (4400 iterations)
    Benchmarking memcpy/memcpy-aligned/32: Analyzing
    memcpy/memcpy-aligned/32
                            time:   [1.5943 ms 1.5958 ms 1.5980 ms]
                            thrpt:  [19.555 KiB/s 19.583 KiB/s 19.601 KiB/s]
                     change:
                            time:   [-36.552% -36.378% -36.236%] (p = 0.00 < 0.05)
                            thrpt:  [+56.828% +57.179% +57.610%]
                            Performance has improved.
    Found 6 outliers among 100 measurements (6.00%)
      5 (5.00%) high mild
      1 (1.00%) high severe
    Benchmarking memcpy/memcpy-src-unaligned/32
    Benchmarking memcpy/memcpy-src-unaligned/32: Warming up for 3.0000 s
    Benchmarking memcpy/memcpy-src-unaligned/32: Collecting 100 samples in estimated 5.1645 s (2000 iterations)
    Benchmarking memcpy/memcpy-src-unaligned/32: Analyzing
    memcpy/memcpy-src-unaligned/32
                            time:   [4.7691 ms 4.7752 ms 4.7859 ms]
                            thrpt:  [6.5296 KiB/s 6.5442 KiB/s 6.5525 KiB/s]
                     change:
                            time:   [+48.326% +48.690% +49.060%] (p = 0.00 < 0.05)
                            thrpt:  [-32.913% -32.746% -32.581%]
                            Performance has regressed.
    Found 8 outliers among 100 measurements (8.00%)
      6 (6.00%) high mild
      2 (2.00%) high severe
    Benchmarking memcpy/memcpy-dst-unaligned/32
    Benchmarking memcpy/memcpy-dst-unaligned/32: Warming up for 3.0000 s
    Benchmarking memcpy/memcpy-dst-unaligned/32: Collecting 100 samples in estimated 5.1212 s (2300 iterations)
    Benchmarking memcpy/memcpy-dst-unaligned/32: Analyzing
    memcpy/memcpy-dst-unaligned/32
                            time:   [3.0566 ms 3.0613 ms 3.0676 ms]
                            thrpt:  [10.187 KiB/s 10.208 KiB/s 10.224 KiB/s]
                     change:
                            time:   [-9.7214% -9.5813% -9.3898%] (p = 0.00 < 0.05)
                            thrpt:  [+10.363% +10.597% +10.768%]
                            Performance has improved.
    Found 7 outliers among 100 measurements (7.00%)
      2 (2.00%) high mild
      5 (5.00%) high severe
    Benchmarking memcpy/memcpy-both-unaligned/32
    Benchmarking memcpy/memcpy-both-unaligned/32: Warming up for 3.0000 s
    Benchmarking memcpy/memcpy-both-unaligned/32: Collecting 100 samples in estimated 5.1614 s (2000 iterations)
    Benchmarking memcpy/memcpy-both-unaligned/32: Analyzing
    memcpy/memcpy-both-unaligned/32
                            time:   [4.7674 ms 4.7749 ms 4.7871 ms]
                            thrpt:  [6.5279 KiB/s 6.5446 KiB/s 6.5549 KiB/s]
                     change:
                            time:   [+47.505% +47.852% +48.250%] (p = 0.00 < 0.05)
                            thrpt:  [-32.546% -32.365% -32.206%]
                            Performance has regressed.
    Found 5 outliers among 100 measurements (5.00%)
      3 (3.00%) high mild
      2 (2.00%) high severe
    Benchmarking memcpy/memcpy-aligned/64
    Benchmarking memcpy/memcpy-aligned/64: Warming up for 3.0000 s
    Benchmarking memcpy/memcpy-aligned/64: Collecting 100 samples in estimated 5.0931 s (2600 iterations)
    Benchmarking memcpy/memcpy-aligned/64: Analyzing
    memcpy/memcpy-aligned/64
                            time:   [3.6453 ms 3.6504 ms 3.6589 ms]
                            thrpt:  [17.082 KiB/s 17.121 KiB/s 17.145 KiB/s]
                     change:
                            time:   [-18.152% -17.915% -17.676%] (p = 0.00 < 0.05)
                            thrpt:  [+21.471% +21.826% +22.177%]
                            Performance has improved.
    Found 5 outliers among 100 measurements (5.00%)
      3 (3.00%) high mild
      2 (2.00%) high severe
    Benchmarking memcpy/memcpy-src-unaligned/64
    Benchmarking memcpy/memcpy-src-unaligned/64: Warming up for 3.0000 s
    Benchmarking memcpy/memcpy-src-unaligned/64: Collecting 100 samples in estimated 5.3355 s (1300 iterations)
    Benchmarking memcpy/memcpy-src-unaligned/64: Analyzing
    memcpy/memcpy-src-unaligned/64
                            time:   [7.5037 ms 7.5145 ms 7.5318 ms]
                            thrpt:  [8.2981 KiB/s 8.3173 KiB/s 8.3292 KiB/s]
                     change:
                            time:   [-0.1381% +0.1473% +0.4127%] (p = 0.36 > 0.05)
                            thrpt:  [-0.4111% -0.1470% +0.1383%]
                            No change in performance detected.
    Found 7 outliers among 100 measurements (7.00%)
      2 (2.00%) high mild
      5 (5.00%) high severe
    Benchmarking memcpy/memcpy-dst-unaligned/64
    Benchmarking memcpy/memcpy-dst-unaligned/64: Warming up for 3.0000 s
    Benchmarking memcpy/memcpy-dst-unaligned/64: Collecting 100 samples in estimated 5.2836 s (1600 iterations)
    Benchmarking memcpy/memcpy-dst-unaligned/64: Analyzing
    memcpy/memcpy-dst-unaligned/64
                            time:   [6.1180 ms 6.1255 ms 6.1388 ms]
                            thrpt:  [10.181 KiB/s 10.203 KiB/s 10.216 KiB/s]
                     change:
                            time:   [-24.664% -24.449% -24.218%] (p = 0.00 < 0.05)
                            thrpt:  [+31.958% +32.362% +32.738%]
                            Performance has improved.
    Found 2 outliers among 100 measurements (2.00%)
      1 (1.00%) high mild
      1 (1.00%) high severe
    Benchmarking memcpy/memcpy-both-unaligned/64
    Benchmarking memcpy/memcpy-both-unaligned/64: Warming up for 3.0000 s
    Benchmarking memcpy/memcpy-both-unaligned/64: Collecting 100 samples in estimated 5.3421 s (1300 iterations)
    Benchmarking memcpy/memcpy-both-unaligned/64: Analyzing
    memcpy/memcpy-both-unaligned/64
                            time:   [7.4843 ms 7.4940 ms 7.5110 ms]
                            thrpt:  [8.3211 KiB/s 8.3400 KiB/s 8.3508 KiB/s]
                     change:
                            time:   [-1.4076% -1.1277% -0.8816%] (p = 0.00 < 0.05)
                            thrpt:  [+0.8895% +1.1405% +1.4277%]
                            Change within noise threshold.
    Found 2 outliers among 100 measurements (2.00%)
      2 (2.00%) high severe
    Benchmarking memcpy/memcpy-aligned/128
    Benchmarking memcpy/memcpy-aligned/128: Warming up for 3.0000 s
    Benchmarking memcpy/memcpy-aligned/128: Collecting 100 samples in estimated 5.1577 s (2000 iterations)
    Benchmarking memcpy/memcpy-aligned/128: Analyzing
    memcpy/memcpy-aligned/128
                            time:   [5.5651 ms 5.5719 ms 5.5830 ms]
                            thrpt:  [22.389 KiB/s 22.434 KiB/s 22.461 KiB/s]
                     change:
                            time:   [-38.617% -38.458% -38.303%] (p = 0.00 < 0.05)
                            thrpt:  [+62.082% +62.491% +62.910%]
                            Performance has improved.
    Found 6 outliers among 100 measurements (6.00%)
      3 (3.00%) high mild
      3 (3.00%) high severe
    Benchmarking memcpy/memcpy-src-unaligned/128
    Benchmarking memcpy/memcpy-src-unaligned/128: Warming up for 3.0000 s
    Benchmarking memcpy/memcpy-src-unaligned/128: Collecting 100 samples in estimated 5.4060 s (900 iterations)
    Benchmarking memcpy/memcpy-src-unaligned/128: Analyzing
    memcpy/memcpy-src-unaligned/128
                            time:   [12.341 ms 12.356 ms 12.380 ms]
                            thrpt:  [10.097 KiB/s 10.117 KiB/s 10.129 KiB/s]
                     change:
                            time:   [-20.704% -20.500% -20.288%] (p = 0.00 < 0.05)
                            thrpt:  [+25.451% +25.786% +26.109%]
                            Performance has improved.
    Found 6 outliers among 100 measurements (6.00%)
      4 (4.00%) high mild
      2 (2.00%) high severe
    Benchmarking memcpy/memcpy-dst-unaligned/128
    Benchmarking memcpy/memcpy-dst-unaligned/128: Warming up for 3.0000 s
    Benchmarking memcpy/memcpy-dst-unaligned/128: Collecting 100 samples in estimated 5.0109 s (1000 iterations)
    Benchmarking memcpy/memcpy-dst-unaligned/128: Analyzing
    memcpy/memcpy-dst-unaligned/128
                            time:   [11.045 ms 11.059 ms 11.082 ms]
                            thrpt:  [11.280 KiB/s 11.303 KiB/s 11.317 KiB/s]
                     change:
                            time:   [-29.840% -29.640% -29.454%] (p = 0.00 < 0.05)
                            thrpt:  [+41.751% +42.126% +42.532%]
                            Performance has improved.
    Found 8 outliers among 100 measurements (8.00%)
      4 (4.00%) high mild
      4 (4.00%) high severe
    Benchmarking memcpy/memcpy-both-unaligned/128
    Benchmarking memcpy/memcpy-both-unaligned/128: Warming up for 3.0000 s
    Benchmarking memcpy/memcpy-both-unaligned/128: Collecting 100 samples in estimated 5.3790 s (900 iterations)
    Benchmarking memcpy/memcpy-both-unaligned/128: Analyzing
    memcpy/memcpy-both-unaligned/128
                            time:   [12.246 ms 12.259 ms 12.283 ms]
                            thrpt:  [10.177 KiB/s 10.196 KiB/s 10.208 KiB/s]
                     change:
                            time:   [-21.285% -21.079% -20.869%] (p = 0.00 < 0.05)
                            thrpt:  [+26.373% +26.709% +27.040%]
                            Performance has improved.
    Found 4 outliers among 100 measurements (4.00%)
      3 (3.00%) high mild
      1 (1.00%) high severe
    Benchmarking memcpy/memcpy-aligned/256
    Benchmarking memcpy/memcpy-aligned/256: Warming up for 3.0000 s
    Benchmarking memcpy/memcpy-aligned/256: Collecting 100 samples in estimated 5.0056 s (1000 iterations)
    Benchmarking memcpy/memcpy-aligned/256: Analyzing
    memcpy/memcpy-aligned/256
                            time:   [13.227 ms 13.248 ms 13.277 ms]
                            thrpt:  [18.830 KiB/s 18.871 KiB/s 18.900 KiB/s]
                     change:
                            time:   [-39.723% -39.590% -39.432%] (p = 0.00 < 0.05)
                            thrpt:  [+65.104% +65.534% +65.902%]
                            Performance has improved.
    Found 5 outliers among 100 measurements (5.00%)
      2 (2.00%) high mild
      3 (3.00%) high severe
    Benchmarking memcpy/memcpy-src-unaligned/256
    Benchmarking memcpy/memcpy-src-unaligned/256: Warming up for 3.0000 s
    Benchmarking memcpy/memcpy-src-unaligned/256: Collecting 100 samples in estimated 5.1123 s (500 iterations)
    Benchmarking memcpy/memcpy-src-unaligned/256: Analyzing
    memcpy/memcpy-src-unaligned/256
                            time:   [26.605 ms 26.630 ms 26.673 ms]
                            thrpt:  [9.3727 KiB/s 9.3880 KiB/s 9.3969 KiB/s]
                     change:
                            time:   [-21.295% -21.217% -21.078%] (p = 0.00 < 0.05)
                            thrpt:  [+26.707% +26.931% +27.056%]
                            Performance has improved.
    Found 9 outliers among 100 measurements (9.00%)
      2 (2.00%) low mild
      4 (4.00%) high mild
      3 (3.00%) high severe
    Benchmarking memcpy/memcpy-dst-unaligned/256
    Benchmarking memcpy/memcpy-dst-unaligned/256: Warming up for 3.0000 s
    Benchmarking memcpy/memcpy-dst-unaligned/256: Collecting 100 samples in estimated 5.8625 s (600 iterations)
    Benchmarking memcpy/memcpy-dst-unaligned/256: Analyzing
    memcpy/memcpy-dst-unaligned/256
                            time:   [22.837 ms 22.867 ms 22.911 ms]
                            thrpt:  [10.912 KiB/s 10.933 KiB/s 10.947 KiB/s]
                     change:
                            time:   [-33.115% -32.968% -32.809%] (p = 0.00 < 0.05)
                            thrpt:  [+48.830% +49.182% +49.509%]
                            Performance has improved.
    Found 14 outliers among 100 measurements (14.00%)
      7 (7.00%) high mild
      7 (7.00%) high severe
    Benchmarking memcpy/memcpy-both-unaligned/256
    Benchmarking memcpy/memcpy-both-unaligned/256: Warming up for 3.0000 s
    Benchmarking memcpy/memcpy-both-unaligned/256: Collecting 100 samples in estimated 5.1244 s (500 iterations)
    Benchmarking memcpy/memcpy-both-unaligned/256: Analyzing
    memcpy/memcpy-both-unaligned/256
                            time:   [26.658 ms 26.683 ms 26.726 ms]
                            thrpt:  [9.3541 KiB/s 9.3691 KiB/s 9.3779 KiB/s]
                     change:
                            time:   [-21.284% -21.205% -21.085%] (p = 0.00 < 0.05)
                            thrpt:  [+26.718% +26.912% +27.039%]
                            Performance has improved.
    Found 6 outliers among 100 measurements (6.00%)
      4 (4.00%) high mild
      2 (2.00%) high severe
    Benchmarking memcpy/memcpy-aligned/512
    Benchmarking memcpy/memcpy-aligned/512: Warming up for 3.0000 s
    Benchmarking memcpy/memcpy-aligned/512: Collecting 100 samples in estimated 5.4270 s (400 iterations)
    Benchmarking memcpy/memcpy-aligned/512: Analyzing
    memcpy/memcpy-aligned/512
                            time:   [58.562 ms 58.599 ms 58.660 ms]
                            thrpt:  [8.5237 KiB/s 8.5325 KiB/s 8.5380 KiB/s]
                     change:
                            time:   [-26.740% -26.685% -26.612%] (p = 0.00 < 0.05)
                            thrpt:  [+36.262% +36.398% +36.500%]
                            Performance has improved.
    Found 5 outliers among 100 measurements (5.00%)
      3 (3.00%) high mild
      2 (2.00%) high severe
    Benchmarking memcpy/memcpy-src-unaligned/512
    Benchmarking memcpy/memcpy-src-unaligned/512: Warming up for 3.0000 s
    Benchmarking memcpy/memcpy-src-unaligned/512: Collecting 100 samples in estimated 5.0885 s (200 iterations)
    Benchmarking memcpy/memcpy-src-unaligned/512: Analyzing
    memcpy/memcpy-src-unaligned/512
                            time:   [116.51 ms 116.60 ms 116.72 ms]
                            thrpt:  [4.2836 KiB/s 4.2882 KiB/s 4.2916 KiB/s]
                     change:
                            time:   [-4.5735% -4.4402% -4.3179%] (p = 0.00 < 0.05)
                            thrpt:  [+4.5128% +4.6465% +4.7926%]
                            Performance has improved.
    Found 5 outliers among 100 measurements (5.00%)
      2 (2.00%) high mild
      3 (3.00%) high severe
    Benchmarking memcpy/memcpy-dst-unaligned/512
    Benchmarking memcpy/memcpy-dst-unaligned/512: Warming up for 3.0000 s
    Benchmarking memcpy/memcpy-dst-unaligned/512: Collecting 100 samples in estimated 5.0658 s (200 iterations)
    Benchmarking memcpy/memcpy-dst-unaligned/512: Analyzing
    memcpy/memcpy-dst-unaligned/512
                            time:   [116.91 ms 116.99 ms 117.11 ms]
                            thrpt:  [4.2697 KiB/s 4.2739 KiB/s 4.2767 KiB/s]
                     change:
                            time:   [-3.6594% -3.5414% -3.4122%] (p = 0.00 < 0.05)
                            thrpt:  [+3.5328% +3.6715% +3.7983%]
                            Performance has improved.
    Found 5 outliers among 100 measurements (5.00%)
      3 (3.00%) high mild
      2 (2.00%) high severe
    Benchmarking memcpy/memcpy-both-unaligned/512
    Benchmarking memcpy/memcpy-both-unaligned/512: Warming up for 3.0000 s
    Benchmarking memcpy/memcpy-both-unaligned/512: Collecting 100 samples in estimated 5.1402 s (200 iterations)
    Benchmarking memcpy/memcpy-both-unaligned/512: Analyzing
    memcpy/memcpy-both-unaligned/512
                            time:   [117.23 ms 117.30 ms 117.42 ms]
                            thrpt:  [4.2581 KiB/s 4.2625 KiB/s 4.2653 KiB/s]
                     change:
                            time:   [-3.9466% -3.8320% -3.7054%] (p = 0.00 < 0.05)
                            thrpt:  [+3.8480% +3.9847% +4.1087%]
                            Performance has improved.
    Found 4 outliers among 100 measurements (4.00%)
      3 (3.00%) high mild
      1 (1.00%) high severe
    Benchmarking memcpy/memcpy-aligned/1024
    Benchmarking memcpy/memcpy-aligned/1024: Warming up for 3.0000 s
    
    Warning: Unable to complete 100 samples in 5.0s. You may wish to increase target time to 5.4s, or reduce sample count to 90.
    Benchmarking memcpy/memcpy-aligned/1024: Collecting 100 samples in estimated 5.3572 s (100 iterations)
    Benchmarking memcpy/memcpy-aligned/1024: Analyzing
    memcpy/memcpy-aligned/1024
                            time:   [440.01 ms 440.35 ms 440.77 ms]
                            thrpt:  [2.2688 KiB/s 2.2709 KiB/s 2.2727 KiB/s]
                     change:
                            time:   [-2.4192% -2.3331% -2.2312%] (p = 0.00 < 0.05)
                            thrpt:  [+2.2821% +2.3888% +2.4791%]
                            Performance has improved.
    Found 6 outliers among 100 measurements (6.00%)
      2 (2.00%) high mild
      4 (4.00%) high severe
    Benchmarking memcpy/memcpy-src-unaligned/1024
    Benchmarking memcpy/memcpy-src-unaligned/1024: Warming up for 3.0000 s
    
    Warning: Unable to complete 100 samples in 5.0s. You may wish to increase target time to 6.6s, or reduce sample count to 70.
    Benchmarking memcpy/memcpy-src-unaligned/1024: Collecting 100 samples in estimated 6.5826 s (100 iterations)
    Benchmarking memcpy/memcpy-src-unaligned/1024: Analyzing
    memcpy/memcpy-src-unaligned/1024
                            time:   [452.05 ms 452.93 ms 453.83 ms]
                            thrpt:  [2.2035 KiB/s 2.2079 KiB/s 2.2121 KiB/s]
                     change:
                            time:   [-2.0596% -1.8762% -1.6849%] (p = 0.00 < 0.05)
                            thrpt:  [+1.7138% +1.9120% +2.1029%]
                            Performance has improved.
    Benchmarking memcpy/memcpy-dst-unaligned/1024
    Benchmarking memcpy/memcpy-dst-unaligned/1024: Warming up for 3.0000 s
    
    Warning: Unable to complete 100 samples in 5.0s. You may wish to increase target time to 6.5s, or reduce sample count to 70.
    Benchmarking memcpy/memcpy-dst-unaligned/1024: Collecting 100 samples in estimated 6.5283 s (100 iterations)
    Benchmarking memcpy/memcpy-dst-unaligned/1024: Analyzing
    memcpy/memcpy-dst-unaligned/1024
                            time:   [446.84 ms 447.56 ms 448.34 ms]
                            thrpt:  [2.2305 KiB/s 2.2343 KiB/s 2.2379 KiB/s]
                     change:
                            time:   [-3.0021% -2.8397% -2.6701%] (p = 0.00 < 0.05)
                            thrpt:  [+2.7434% +2.9227% +3.0950%]
                            Performance has improved.
    Found 18 outliers among 100 measurements (18.00%)
      18 (18.00%) high severe
    Benchmarking memcpy/memcpy-both-unaligned/1024
    Benchmarking memcpy/memcpy-both-unaligned/1024: Warming up for 3.0000 s
    
    Warning: Unable to complete 100 samples in 5.0s. You may wish to increase target time to 6.6s, or reduce sample count to 70.
    Benchmarking memcpy/memcpy-both-unaligned/1024: Collecting 100 samples in estimated 6.6369 s (100 iterations)
    Benchmarking memcpy/memcpy-both-unaligned/1024: Analyzing
    memcpy/memcpy-both-unaligned/1024
                            time:   [449.23 ms 449.67 ms 450.19 ms]
                            thrpt:  [2.2213 KiB/s 2.2238 KiB/s 2.2260 KiB/s]
                     change:
                            time:   [-2.0304% -1.9207% -1.8147%] (p = 0.00 < 0.05)
                            thrpt:  [+1.8482% +1.9584% +2.0725%]
                            Performance has improved.
    Found 9 outliers among 100 measurements (9.00%)
      2 (2.00%) high mild
      7 (7.00%) high severe
    Benchmarking memcpy/memcpy-aligned/2048
    Benchmarking memcpy/memcpy-aligned/2048: Warming up for 3.0000 s
    
    Warning: Unable to complete 100 samples in 5.0s. You may wish to increase target time to 21.6s, or reduce sample count to 20.
    Benchmarking memcpy/memcpy-aligned/2048: Collecting 100 samples in estimated 21.553 s (100 iterations)
    Benchmarking memcpy/memcpy-aligned/2048: Analyzing
    memcpy/memcpy-aligned/2048
                            time:   [646.24 ms 646.77 ms 647.37 ms]
                            thrpt:  [3.0894 KiB/s 3.0923 KiB/s 3.0948 KiB/s]
                     change:
                            time:   [-3.0802% -2.9934% -2.8965%] (p = 0.00 < 0.05)
                            thrpt:  [+2.9829% +3.0858% +3.1781%]
                            Performance has improved.
    Found 11 outliers among 100 measurements (11.00%)
      3 (3.00%) high mild
      8 (8.00%) high severe
    Benchmarking memcpy/memcpy-src-unaligned/2048
    Benchmarking memcpy/memcpy-src-unaligned/2048: Warming up for 3.0000 s
    
    Warning: Unable to complete 100 samples in 5.0s. You may wish to increase target time to 24.9s, or reduce sample count to 20.
    Benchmarking memcpy/memcpy-src-unaligned/2048: Collecting 100 samples in estimated 24.893 s (100 iterations)
    Benchmarking memcpy/memcpy-src-unaligned/2048: Analyzing
    memcpy/memcpy-src-unaligned/2048
                            time:   [665.93 ms 666.16 ms 666.45 ms]
                            thrpt:  [3.0010 KiB/s 3.0023 KiB/s 3.0033 KiB/s]
                     change:
                            time:   [-28.022% -27.973% -27.926%] (p = 0.00 < 0.05)
                            thrpt:  [+38.746% +38.838% +38.932%]
                            Performance has improved.
    Found 6 outliers among 100 measurements (6.00%)
      4 (4.00%) high mild
      2 (2.00%) high severe
    Benchmarking memcpy/memcpy-dst-unaligned/2048
    Benchmarking memcpy/memcpy-dst-unaligned/2048: Warming up for 3.0000 s
    
    Warning: Unable to complete 100 samples in 5.0s. You may wish to increase target time to 24.9s, or reduce sample count to 20.
    Benchmarking memcpy/memcpy-dst-unaligned/2048: Collecting 100 samples in estimated 24.890 s (100 iterations)
    Benchmarking memcpy/memcpy-dst-unaligned/2048: Analyzing
    memcpy/memcpy-dst-unaligned/2048
                            time:   [665.98 ms 666.25 ms 666.59 ms]
                            thrpt:  [3.0003 KiB/s 3.0019 KiB/s 3.0031 KiB/s]
                     change:
                            time:   [-28.079% -28.039% -27.998%] (p = 0.00 < 0.05)
                            thrpt:  [+38.885% +38.964% +39.041%]
                            Performance has improved.
    Found 7 outliers among 100 measurements (7.00%)
      4 (4.00%) high mild
      3 (3.00%) high severe
    Benchmarking memcpy/memcpy-both-unaligned/2048
    Benchmarking memcpy/memcpy-both-unaligned/2048: Warming up for 3.0000 s
    
    Warning: Unable to complete 100 samples in 5.0s. You may wish to increase target time to 24.8s, or reduce sample count to 20.
    Benchmarking memcpy/memcpy-both-unaligned/2048: Collecting 100 samples in estimated 24.759 s (100 iterations)
    Benchmarking memcpy/memcpy-both-unaligned/2048: Analyzing
    memcpy/memcpy-both-unaligned/2048
                            time:   [661.32 ms 661.56 ms 661.87 ms]
                            thrpt:  [3.0217 KiB/s 3.0231 KiB/s 3.0243 KiB/s]
                     change:
                            time:   [-28.640% -28.583% -28.529%] (p = 0.00 < 0.05)
                            thrpt:  [+39.918% +40.023% +40.134%]
                            Performance has improved.
    Found 12 outliers among 100 measurements (12.00%)
      1 (1.00%) low mild
      6 (6.00%) high mild
      5 (5.00%) high severe
    Benchmarking memcpy/memcpy-aligned/4096
    Benchmarking memcpy/memcpy-aligned/4096: Warming up for 3.0000 s
    
    Warning: Unable to complete 100 samples in 5.0s. You may wish to increase target time to 64.2s, or reduce sample count to 10.
    Benchmarking memcpy/memcpy-aligned/4096: Collecting 100 samples in estimated 64.241 s (100 iterations)
    Benchmarking memcpy/memcpy-aligned/4096: Analyzing
    memcpy/memcpy-aligned/4096
                            time:   [1.2954 s 1.2960 s 1.2966 s]
                            thrpt:  [3.0850 KiB/s 3.0865 KiB/s 3.0878 KiB/s]
                     change:
                            time:   [-3.0484% -2.9906% -2.9388%] (p = 0.00 < 0.05)
                            thrpt:  [+3.0278% +3.0827% +3.1442%]
                            Performance has improved.
    Found 10 outliers among 100 measurements (10.00%)
      7 (7.00%) high mild
      3 (3.00%) high severe
    Benchmarking memcpy/memcpy-src-unaligned/4096
    Benchmarking memcpy/memcpy-src-unaligned/4096: Warming up for 3.0000 s
    
    Warning: Unable to complete 100 samples in 5.0s. You may wish to increase target time to 106.8s, or reduce sample count to 10.
    Benchmarking memcpy/memcpy-src-unaligned/4096: Collecting 100 samples in estimated 106.82 s (100 iterations)
    Benchmarking memcpy/memcpy-src-unaligned/4096: Analyzing
    memcpy/memcpy-src-unaligned/4096
                            time:   [1.3275 s 1.3279 s 1.3283 s]
                            thrpt:  [3.0113 KiB/s 3.0123 KiB/s 3.0132 KiB/s]
                     change:
                            time:   [-27.869% -27.840% -27.808%] (p = 0.00 < 0.05)
                            thrpt:  [+38.520% +38.582% +38.638%]
                            Performance has improved.
    Found 6 outliers among 100 measurements (6.00%)
      2 (2.00%) high mild
      4 (4.00%) high severe
    Benchmarking memcpy/memcpy-dst-unaligned/4096
    Benchmarking memcpy/memcpy-dst-unaligned/4096: Warming up for 3.0000 s
    
    Warning: Unable to complete 100 samples in 5.0s. You may wish to increase target time to 107.3s, or reduce sample count to 10.
    Benchmarking memcpy/memcpy-dst-unaligned/4096: Collecting 100 samples in estimated 107.30 s (100 iterations)
    Benchmarking memcpy/memcpy-dst-unaligned/4096: Analyzing
    memcpy/memcpy-dst-unaligned/4096
                            time:   [1.3365 s 1.3369 s 1.3374 s]
                            thrpt:  [2.9909 KiB/s 2.9919 KiB/s 2.9929 KiB/s]
                     change:
                            time:   [-27.403% -27.369% -27.332%] (p = 0.00 < 0.05)
                            thrpt:  [+37.613% +37.682% +37.746%]
                            Performance has improved.
    Found 9 outliers among 100 measurements (9.00%)
      6 (6.00%) high mild
      3 (3.00%) high severe
    Benchmarking memcpy/memcpy-both-unaligned/4096
    Benchmarking memcpy/memcpy-both-unaligned/4096: Warming up for 3.0000 s
    
    Warning: Unable to complete 100 samples in 5.0s. You may wish to increase target time to 107.7s, or reduce sample count to 10.
    Benchmarking memcpy/memcpy-both-unaligned/4096: Collecting 100 samples in estimated 107.74 s (100 iterations)
    Benchmarking memcpy/memcpy-both-unaligned/4096: Analyzing
    memcpy/memcpy-both-unaligned/4096
                            time:   [1.3384 s 1.3388 s 1.3392 s]
                            thrpt:  [2.9868 KiB/s 2.9878 KiB/s 2.9887 KiB/s]
                     change:
                            time:   [-27.310% -27.276% -27.243%] (p = 0.00 < 0.05)
                            thrpt:  [+37.443% +37.506% +37.571%]
                            Performance has improved.
    Found 3 outliers among 100 measurements (3.00%)
      2 (2.00%) high mild
      1 (1.00%) high severe
    

    Signed-off-by: Carsten Munk [email protected]

    opened by stskeeps 6
  • Port C++ merkle tests to Rust

    Port C++ merkle tests to Rust

    These tests are arguably less elegant, and definitely more complex, in Rust. The core reason for this is that the C++ tests check specific lines for exceptions which they can catch and continue from. In the Rust tests, we need to handle panics from assertions failing, which happens at the level of the full test, not a specific line. While Rust does have std::panic::catch_unwind, the specific places we would need to use it do not appear to be unwind safe.

    I also want to call attention to the change making verify::merkle a public module. This is necessary to get access to ReadIOP during the tests in prove::merkle.

    opened by tzerrell 6
  • Add constructor to Receipt

    Add constructor to Receipt

    Summary

    The fields of the Receipt structure are currently private. I do not actually know why this is the case - from reading the source, I would think that Rust would believe they are public. But it does not, and I need a way to build Receipts, so I wrote this PR.

    opened by intoverflow 6
  • Build fails on macOS(arm64)

    Build fails on macOS(arm64)

    I am experiencing an issue with building on a Mac Mini M1. bazelisk test //... results in the error detailed below.

    Steps to Reproduce

    I'm not sure how to reproduce this error. The build was successful on a Macbook Air with similar specs listed below.

    Environment

    • macOS Monterey 12.3.1 (21E258)
    • Xcode Version 13.3.1 (13E500a)
    • Apple clang version 13.1.6 (clang-1316.0.21.2.3)
    • Target: arm64-apple-darwin21.4.0

    Logs

    INFO: Options provided by the client:
      Inherited 'common' options: --isatty=1 --terminal_columns=175
    INFO: Reading rc options for 'test' from /path/to/risc0/.bazelrc:
      Inherited 'build' options: -c opt --announce_rc --enable_runfiles --nobuild_python_zip --incompatible_enable_cc_toolchain_resolution --flag_alias=accel=//risc0/zkp/accel:flag --//bazel/rules/clang_format:config=//:.clang-format --@rules_rust//:rustfmt.toml=//bazel/rules/rust:rustfmt.toml
    INFO: Repository crates_host instantiated at:
      /path/to/risc0/WORKSPACE:109:18: in <toplevel>
    Repository rule crates_repository defined at:
      /private/var/tmp/_bazel_ck/23e37feca6eb160088e3173bb952b18e/external/rules_rust/crate_universe/private/crates_repository.bzl:102:36: in <toplevel>
    ERROR: An error occurred during the fetch of repository 'crates_host':
       Traceback (most recent call last):
    	File "/private/var/tmp/_bazel_ck/23e37feca6eb160088e3173bb952b18e/external/rules_rust/crate_universe/private/crates_repository.bzl", line 24, column 34, in _crates_repository_impl
    		host_triple = get_host_triple(repository_ctx)
    	File "/private/var/tmp/_bazel_ck/23e37feca6eb160088e3173bb952b18e/external/rules_rust/cargo/private/cargo_utils.bzl", line 95, column 38, in get_host_triple
    		cpu = _query_cpu_architecture(repository_ctx, supported_architectures["macos"])
    	File "/private/var/tmp/_bazel_ck/23e37feca6eb160088e3173bb952b18e/external/rules_rust/cargo/private/cargo_utils.bzl", line 33, column 13, in _query_cpu_architecture
    		fail(_CPU_ARCH_ERROR_MSG.format(
    Error in fail: Command failed with exit code '1': ["uname", "-m"]
    ----------stdout:
    
    ----------stderr:
    src/main/tools/process-wrapper-legacy.cc:80: "execvp(uname, ...)": No such file or directory
    
    ERROR: /path/to/risc0/WORKSPACE:109:18: fetching crates_repository rule //external:crates_host: Traceback (most recent call last):
    	File "/private/var/tmp/_bazel_ck/23e37feca6eb160088e3173bb952b18e/external/rules_rust/crate_universe/private/crates_repository.bzl", line 24, column 34, in _crates_repository_impl
    		host_triple = get_host_triple(repository_ctx)
    	File "/private/var/tmp/_bazel_ck/23e37feca6eb160088e3173bb952b18e/external/rules_rust/cargo/private/cargo_utils.bzl", line 95, column 38, in get_host_triple
    		cpu = _query_cpu_architecture(repository_ctx, supported_architectures["macos"])
    	File "/private/var/tmp/_bazel_ck/23e37feca6eb160088e3173bb952b18e/external/rules_rust/cargo/private/cargo_utils.bzl", line 33, column 13, in _query_cpu_architecture
    		fail(_CPU_ARCH_ERROR_MSG.format(
    Error in fail: Command failed with exit code '1': ["uname", "-m"]
    ----------stdout:
    
    ----------stderr:
    src/main/tools/process-wrapper-legacy.cc:80: "execvp(uname, ...)": No such file or directory
    
    INFO: Reading rc options for 'test' from /path/to/risc0/.bazelrc:
      Inherited 'build' options: -c opt --announce_rc --enable_runfiles --nobuild_python_zip --incompatible_enable_cc_toolchain_resolution --flag_alias=accel=//risc0/zkp/accel:flag --//bazel/rules/clang_format:config=//:.clang-format --@rules_rust//:rustfmt.toml=//bazel/rules/rust:rustfmt.toml
    ERROR: //bazel/rules/clang_format:config :: Error loading option //bazel/rules/clang_format:config: no such package '@crates_host//': Command failed with exit code '1': ["uname", "-m"]
    ----------stdout:
    
    ----------stderr:
    src/main/tools/process-wrapper-legacy.cc:80: "execvp(uname, ...)": No such file or directory
    
    
    bug 
    opened by kandizzy 5
  • Unwanted bindgen artifacts in WASM file.

    Unwanted bindgen artifacts in WASM file.

    Problem

    My goal is running risc0 verifier inside the WASM VM.

    Here is my example:

    risc0-zkvm included in dependencies:

    [dependencies]
    risc0-zkvm = { version = "1.0.0-rc.2", features = [ "verify-only" ] }
    

    verifier.rs is my source code. It's enough to use risc0_zkvm, no need to interact with any code like Recipt:

    #![no_main]
    
    use risc0_zkvm;
    
    extern "C" {
        pub fn load_data() -> u8;
    }
    
    #[no_mangle]
    unsafe fn verify() {
        let _ = load_data();
    }
    

    See full code here: https://github.com/zie1ony/risc0-wasm-unwanted-bindgen

    Compile it to wasm:

    $ cargo build --release --target wasm32-unknown-unknown
    

    Now I can inspect it using wasm2wat from WABT package.

    $ wasm2wat target/wasm32-unknown-unknown/release/verify.wasm
    (module
      (type (;0;) (func (param i32 i32)))
     ...
      (type (;21;) (func (param i32 i32 f64 i32 i32)))
      (import "env" "load_data" (func $load_data (type 11)))
      (import "__wbindgen_placeholder__" "__wbindgen_describe" (func $_ZN12wasm_bindgen19__wbindgen_describe17h402830b0880612dcE (type 12)))
      (import "__wbindgen_placeholder__" "__wbindgen_throw" (func $_ZN12wasm_bindgen16__wbindgen_throw17hc7b411560c64c5a5E (type 0)))
      (import "__wbindgen_externref_xform__" "__wbindgen_externref_table_grow" (func $_ZN12wasm_bindgen9externref31__wbindgen_externref_table_grow17h5d8fced3e7917d66E (type 13)))
      (import "__wbindgen_externref_xform__" "__wbindgen_externref_table_set_null" (func $_ZN12wasm_bindgen9externref35__wbindgen_externref_table_set_null17h644009d4f22d60bcE (type 12)))
      (func $verify (type 14)
        call $load_data
    

    Those __wbindgen_placeholder__ imports, are not expected, and the wasm file has much more of bindgen artifacts.

    $` wasm2wat target/wasm32-unknown-unknown/release/verify.wasm | grep bindgen | wc -l
    9544
    

    Of course WASM hosts outside the browser or Node will not be able to satisfy those imports and will fail.

    Reason

    The reason is getrandom crate in the dependencies of risc0-zkvm. It comes from rand's dependencies. getrandom devs supports wasm32-unknown-unknown target only when the js feature is on, but this expects the wasm file to be used in JS environment, which is really naive. And to support JS they use... wasm-bindgen. You can read more in the source code: https://github.com/rust-random/getrandom/blob/master/src/lib.rs#L60

    Solutions

    I see three solutions:

    1. Drop the random from dependencies for verify-only feature.
    2. Remove bindgen artifacts somehow from the wasm file. There are WASM tools like wasm-bindgen or WABT, but I haven't found any way of doing so.
    3. Improve getrandom and make PR to their repo.

    My preferable solution is the first one, as it reduces dependecies and improves the rist0 repo. I might be wrong, but the random values are not needed for verification, right?

    opened by zie1ony 4
  • Add METHOD_ELF static const

    Add METHOD_ELF static const

    Currently, prover have a hard link to guest's elf files, which is inconvenient for deployment. This PR makes it possible that prover can embedded the guest's elf content and running alone.

    opened by Vesnica 4
  • Possibility of using SNARKs instead of STARKs

    Possibility of using SNARKs instead of STARKs

    Hi guys,

    Really great project. So I was going through the code and according to my understanding it should be possible to swap the current zkp module from using STARKs to SNARKs. Is there any assumptions on zkvm side which would stop me in doing that?

    opened by jinankjain 4
  • Allow building and running without Metal on MacOS

    Allow building and running without Metal on MacOS

    Metal is currently required as a build dependency on MacOS even if it will not be used. As a result, the codebase cannot be built without it.

    This PR refactors the use of Metal to gate building dependant code behind the "metal" feature flag. As an alternative to the current method, this means users may have to explicitly enable "metal" as a feature at build-time (if the turn off defeault features).

    opened by nategraf 1
  • Where is code of rule checks to validate RISC computation?

    Where is code of rule checks to validate RISC computation?

    Hi, I am reading the documentation of RISC Zero where said the below description.

    In the full RISC-V implementation, the rules make up what it means to execute RISC-V instructions properly (i.e. checking that the program counter increments after every instruction). We check thousands of rules in order to validate the execution trace.

    I want to know what those rules are, and I tried to find them in implementation but did not find them. Does anyone know where is the implementation of those rules?

    opened by wangtsiao 2
  • cargo bench fails to compile on Ubuntu 22.04

    cargo bench fails to compile on Ubuntu 22.04

    Attempting to run either cargo bench --bench fib or simply cargo bench from HEAD (currently 8b90fbe), I get a failure to build, with stderr output ending like this:

      cargo:warning=cxx/step_exec.cpp: In function ‘risc0::Fp risc0::circuit::rv32im::step_exec(void*, void (*)(void*, const char*, const char*, const risc0::Fp*, size_t, risc0::Fp*, size_t), size_t, size_t, risc0::Fp**)’:
      cargo:warning=cxx/step_exec.cpp:32:4: note: variable tracking size limit exceeded with ‘-fvar-tracking-assignments’, retrying without
      cargo:warning=   32 | Fp step_exec(void* ctx, HostBridge host, size_t steps, size_t cycle, Fp** args) {
      cargo:warning=      |    ^~~~~~~~~
      exit status: 0
      exit status: 0
      cargo:warning=c++: fatal error: Killed signal terminated program cc1plus
      cargo:warning=compilation terminated.
      exit status: 1
    
      --- stderr
    
    
      error occurred: Command "c++" "-O3" "-ffunction-sections" "-fdata-sections" "-fPIC" "-g" "-fno-omit-frame-pointer" "-m64" "-Wall" "-Wextra" "-std=c++17" "-o" "/home/mars/risc0/target/release/build/risc0-circuit-rv32im-2df37cb2210a07d8/out/cxx/poly_fp.o" "-c" "cxx/poly_fp.cpp" with args "c++" did not execute successfully (status code exit status: 1).
    
    

    Complete output:

    benchfail.txt

    bug 
    opened by mars-risc0 6
  • Solidity/Toy Verifier

    Solidity/Toy Verifier

    Are they any plans to implement a solidity verifier?

    I think this would significantly boost adoption of risc0 as a plug and play layer 2.

    If there is not currently a solidity verifier in the roadmap, our team would be happy to work on/contribute a Solidity implementation if there was more documentation of the zkSTARK protocol used or a toy reference implementation to work off of.

    See also #222

    opened by cf 5
  • At runtime, ZKVM should inform the guest of its MethodId

    At runtime, ZKVM should inform the guest of its MethodId

    Summary

    ZKVM uses MethodId to identify guest images. Mechanically, MethodId is the Merkle-root of a data structure that contains the guest's ELF image. It is therefore impossible for the guest to know this value at compile time.

    However, there are cases where the guest benefits from knowing its own MethodId. For example, suppose the guest wants to filter a list of receipts to identify other journals written by itself. This particular use case keeps coming up for me.

    Proposed fix

    At runtime, ZKVM can load the ELF, then it can write the ELF's MethodId to some read-only memory region. If the ZKVM circuit is updated to enforce the accuracy of this data, then the guest will be able to rely on it at runtime.

    enhancement 
    opened by intoverflow 4
Releases(v0.11.1)
  • v0.11.1(Aug 13, 2022)

    What's Changed

    This patch release updates internal crate dependencies to 0.11 (instead of 0.11.0-rc.4)

    • Release version 0.11.1 by @flaub in https://github.com/risc0/risc0/pull/235

    Full Changelog: https://github.com/risc0/risc0/compare/v0.11.0...v0.11.1

    Source code(tar.gz)
    Source code(zip)
  • v0.11.0(Aug 13, 2022)

    Release Notes

    Thanks to community members @cemozerr, @ianklatzco, and @hcho1989 for their contributions to this release!

    Breaking Changes

    Crate dependencies

    Crates have been simplified:

    • Consolidation into risc0-zkp
      • risc0-zkp-core
    • Consolidation into risc0-zkvm
      • risc0-zkvm-host
      • risc0-zkvm-core
      • risc0-zkvm-serde
      • risc0-zkvm-verify

    Look at this password checker Cargo.toml file for an example. Previously, the listed dependencies were:

    risc0-zkvm-host = "0.10"
    risc0-zkvm-core = "0.10"
    risc0-zkvm-serde = "0.10"
    

    Now, the dependencies are:

    risc0-zkp = "0.11"
    risc0-zkvm = "0.11"
    

    Guest SHA usage

    If your project uses our in-house SHA implementation (optimized for the zkVM), you'll want to refer to risc0_zkp::core::sha rather than risc0_zkvm_core::sha. As an example, see our changes to the digital signature Rust example:

    pub fn get_identity(&self) -> Result<risc0_zkp::core::sha::Digest> {...}
    

    Projects that need to use risc0-zkp in the guest should set default-features = false. See our digital signatures Rust example:

    risc0-zkp = { version = "0.11.0-rc.4", default-features = false }
    

    CHANGELOG

    Our pure Rust implementation of the prover is nearly complete:

    • Part 1 (includes both prove and verify implementation) by @flaub in https://github.com/risc0/risc0/pull/196
    • Part 2 by @flaub in https://github.com/risc0/risc0/pull/181
    • The Rust prover is integrated with cirgen by @flaub in #218
    • The Rust prover runs until it has been halted by @flaub in #220

    We've simplified the crate system:

    • The ZKP portion of the pure Rust implementation risc0-zkvm-verify/zkp has also been moved into risc0-zkp by @flaub in #183
    • risc0-build and risc0-zkvm-guest have been extracted from risc0-zkvm by @flaub in #210
    • risc0_zkvm_guest is now its own workspace by @tzerrell in #212
    • The Rust prover APIs (FFI-based and in pure Rust) have been adjusted to behave more similarly by @shkoo in #221
    • For details on how these changes impact your projects, see our notes on updating your project dependencies.

    We’ve made the following zkVM improvements:

    • The Rust standard library support continues to improve by @shkoo in https://github.com/risc0/risc0/pull/216
    • You can now embed methods with features by @cemozerr in #204
    • Code limits are now configurable with DEFAULT_METHOD_ID_LIMIT by @flaub in #203
    • Method ID now has Clone and PartialEq methods by @flaub in #186
    • You can now run the guest without generating a proof by @shkoo in #177
    • Support has been added for parsing ELF files by @flaub in #200
    • Compatibility with older C++ has been fixed by @flaub in https://github.com/risc0/risc0/pull/209

    We’ve made the following build and benchmarking improvements:

    • We added a cargo-risc0 tool to manage the risc0 toolchain by @shkoo in https://github.com/risc0/risc0/pull/198
    • Cargo is now the source of truth for dependencies by @flaub in https://github.com/risc0/risc0/pull/199
    • Update to rules_rust 0.7.0 by @flaub in https://github.com/risc0/risc0/pull/206
    • Benchmark and CI have been repaired by @flaub in https://github.com/risc0/risc0/pull/215
    • Guest builds show their progress when run interactively by @shkoo in https://github.com/risc0/risc0/pull/217
    • Added cargo check —benches by @flaub in https://github.com/risc0/risc0/pull/225

    Here are this release’s documentation updates:

    • Bad link fixed by @hcho1989 in https://github.com/risc0/risc0/pull/201
    • Documentation for `ProveRoundInfo::new() by @BoltonBailey in https://github.com/risc0/risc0/pull/187
    • Documentation compilation warnings fixed by @tzerrell in https://github.com/risc0/risc0/pull/211
    • Additional comments for receipt methods by @elakn in https://github.com/risc0/risc0/pull/197
    • Markdown fix by @BoltonBailey in https://github.com/risc0/risc0/pull/181
    • zkVM language clarification by @ianklatzco in https://github.com/risc0/risc0/pull/188
    Source code(tar.gz)
    Source code(zip)
  • v0.10.0(Jun 24, 2022)

    What's Changed

    We've made quite a few changes this time! This release includes improvements to the guest zkVM, progress towards a pure Rust implementation, work on the Receipt object, an API improvement, and expanded documentation.

    Improvements have been made to the guest zkVM:

    • Rust standard library is now supported in the guest by @shkoo in https://github.com/risc0/risc0/pull/161
    • To allow users greater control over guest execution limits, the MethodID code size limit is now configurable by @flaub in https://github.com/risc0/risc0/pull/167
    • The zkVM guest now has access to more resources by @shkoo in https://github.com/risc0/risc0/pull/176
    • To improve I/O between the host and guest, A "SendRecv" GPIO call has been added by @shkoo in https://github.com/risc0/risc0/pull/173

    We've also made progress towards a pure Rust zkVM implementation:

    • We've begun implementing the prover in pure Rust (part 1) by @flaub in https://github.com/risc0/risc0/pull/139
    • The r0vm is also reimplemented in Rust by @shkoo in https://github.com/risc0/risc0/pull/174
    • While a Rust implementation is underway, we have two Receipt types; to support their conversion, the visibility of a Receipt's journal and seal was changed by @flaub in https://github.com/risc0/risc0/pull/162

    The following improvements have been made to Receipts and verification:

    • The Rust verifier now uses error handling instead of panics by @flaub in https://github.com/risc0/risc0/pull/169
    • A constructor has been added for the Receipt by @intoverflow in https://github.com/risc0/risc0/pull/171
    • The Receipt constructor was also added in C++ by @flaub in https://github.com/risc0/risc0/pull/172

    Our API can now take in-memory buffers:

    • ELF-handling APIs take an in-memory buffer instead of a file by @shkoo in https://github.com/risc0/risc0/pull/170

    Lastly, we've improved our documentation:

    • Documentation has been added for ntt.rs by @BoltonBailey in https://github.com/risc0/risc0/pull/160
    • The interactive oracle proof has additional documentation by @pdg744 in https://github.com/risc0/risc0/pull/159
    • Crates are now alphabetized using cargo-sort by @rlukata in https://github.com/risc0/risc0/pull/175

    • Release: v0.10.0 by @flaub in https://github.com/risc0/risc0/pull/180

    Full Changelog: https://github.com/risc0/risc0/compare/v0.9.0...v0.10.0

    Source code(tar.gz)
    Source code(zip)
  • v0.9.0(Jun 11, 2022)

    What's Changed

    • Minor improvements have been made to the Prover API by @spaugh in https://github.com/risc0/risc0/pull/132
    • We now avoid accumulating cached MethodIDs by @flaub in https://github.com/risc0/risc0/pull/155 Cargo is used to check rustfmt to catch files that Bazel doesn't touch by @shkoo in https://github.com/risc0/risc0/pull/157
    • Release: v0.9.0 by @flaub in https://github.com/risc0/risc0/pull/158

    Full Changelog: https://github.com/risc0/risc0/compare/v0.8.0...v0.9.0

    Source code(tar.gz)
    Source code(zip)
  • v0.8.0(Jun 9, 2022)

    What's Changed

    • The README includes a table of crate version badges by @flaub in https://github.com/risc0/risc0/pull/138
    • The merkle.rs function is now extensively commented by @BoltonBailey in https://github.com/risc0/risc0/pull/140
    • Fixed #141: including required cstddef library by @flaub in https://github.com/risc0/risc0/pull/146 (thanks @lyqingye for the bug report).
    • Guest method crates are now built automatically. As a performance improvement, method IDs are only computed when necessary by tracking changes to the SHA of corresponding ELFs. by @shkoo in https://github.com/risc0/risc0/pull/152
    • Looking for digital signature and voting machine examples? We’ve moved them to their own repository: risc0-rust-examples. by @spaugh
    • Release: v0.8.0 by @flaub in https://github.com/risc0/risc0/pull/154
    Source code(tar.gz)
    Source code(zip)
  • v0.7.2(May 27, 2022)

    What's Changed

    • Looking for our Rust battleship example? We’ve moved it to its own repository:battleship-example
    • (cargo-release) version 0.7.2 by @flaub in https://github.com/risc0/risc0/pull/137

    Full Changelog: https://github.com/risc0/risc0/compare/v0.7.1...v0.7.2

    Source code(tar.gz)
    Source code(zip)
The Zero Knowledge Whitelist Tool is a powerful utility for managing an address whitelist using Zero-Knowledge (ZK) proofs.

zk_whitelist: A Zero Knowledge Whitelist Tool The Zero Knowledge Whitelist Tool is a powerful utility for managing an address whitelist using Zero-Kno

Nikos Koumbakis 4 Nov 21, 2023
Experiments on blockchain technology (also known as Hashed & Zero-trust Verifiable Linked List)

AngeloChain Experiments on blockchain technology (also known as Hashed & Zero-trust Verifiable Linked List) ⚠️ Before We Get Started Before we get sta

Angelo 1 Jan 20, 2022
Zero-Knowledge Assembly language and compiler

zkAsm A Zero-Knowledge circuit assembly language, designed to represent Zero-Knowledge circuits in a compressed format, to be stored on blockchains. I

null 1 Dec 30, 2021
Vector OLE and zero-knowledge for Z2k.

Mozzarella Benchmarking Code This repository contains the code developed for the benchmarking experiments in our paper: "Moz $\mathbb{Z}_{2^k}$ arella

null 7 Dec 20, 2022
STARK - SNARK recursive zero knowledge proofs, combinaison of the Winterfell library and the Circom language

STARK - SNARK recursive proofs The point of this library is to combine the SNARK and STARK computation arguments of knowledge, namely the Winterfell l

Victor Colomb 68 Dec 5, 2022
A Software Development Kit (SDK) for Zero-Knowledge Transactions

Aleo SDK The Aleo SDK is a developer framework to make it simple to create a new account, craft a transaction, and broadcast it to the network. Table

Aleo 270 Jan 5, 2023
Zerocaf: A library built for EC operations in Zero Knowledge.

Dusk-Zerocaf WARNING: WIP Repo. Fast, efficient and bulletproof-friendly cryptographic operations. This repository contains an implementation of the S

Dusk Network 50 Oct 31, 2022
Noir is a domain specific language for zero knowledge proofs

The Noir Programming Language Noir is a Domain Specific Language for SNARK proving systems. It has been designed to use any ACIR compatible proving sy

null 404 Jan 1, 2023
OpenZKP - pure Rust implementations of Zero-Knowledge Proof systems.

OpenZKP OpenZKP - pure Rust implementations of Zero-Knowledge Proof systems. Overview Project current implements ?? the Stark protocol (see its readme

0x 529 Jan 5, 2023
Safeguard your financial privacy with zero-knowledge proofs.

Spinner The Spinner project (https://spinner.cash) takes a privacy first approach to protect users crypto assets. It is a layer-2 protocol built on th

Spinner 21 Dec 28, 2022
Zero Knowledge Light Client Implementation by Zpoken team.

zkp for chain state Prerecusites This project requires using the nightly Rust toolchain, which can be used by default in this way: rustup default nigh

Zpoken 40 Mar 6, 2023
A fast zero-knowledge proof friendly Move language runtime environment.

zkMove Lite zkMove Lite is a lightweight zero-knowledge proof friendly Move language virtual machine. Move bytecode is automatically "compiled" into c

YoungRocks 43 May 20, 2023
Spartan2: High-speed zero-knowledge SNARKs.

Spartan2: High-speed zero-knowledge SNARKs. Spartan is a high-speed zkSNARK, where a zkSNARK is type cryptographic proof system that enables a prover

Microsoft 7 Jul 28, 2023
Implementation of zero-knowledge proof circuits for Tendermint.

Tendermint X Implementation of zero-knowledge proof circuits for Tendermint. Overview Tendermint X's core contract is TendermintX, which stores the he

Succinct 3 Nov 8, 2023
As part of the IOP Stack™ Morpheus is a toolset to have gatekeeper-free identity management and verifiable claims as a 2nd layer on top of a blockchain

Internet of People Internet of People (IoP) is a software project creating a decentralized software stack that provides the building blocks and tools

We are building a complete decentralized ecosystem with the IOP Stack™ 9 Nov 4, 2022
A distributed, cryptographically-verifiable blog / social network

FeoBlog FeoBlog is a distributed blogging platform. It takes a lot of its inspiration from Mastodon and Scuttlebutt. It aims to solve a couple of prob

Cody Casterline 71 Dec 11, 2022
A cryptographically verifiable code review system for the cargo (Rust) package manager.

A cryptographically verifiable code review system for the cargo (Rust) package manager.

crev - Code REView system 1.8k Jan 2, 2023
Arkworks circuits for verifiable time-lock encryption

zk-timelock This repo contains arithmetic circuits for verifiable time-lock encryption made using arkworks-rs toolkit. For more details on such an enc

Timofey 68 Apr 5, 2023
A "Type 0" zkEVM. Prove validity of Ethereum blocks using RISC Zero's zkVM

zeth NEW: Zeth now supports Optimism blocks! Just pass in --network=optimism! Zeth is an open-source ZK block prover for Ethereum built on the RISC Ze

RISC Zero 222 Oct 26, 2023