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
  • 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 [email protected]_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 [email protected]_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
  • 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
  • Did not build successfully under mac Intel

    Did not build successfully under mac Intel

    Here is my failed info :

    ERROR: /Users/karlyu/risc0/risc0/zkvm/sdk/cpp/guest/BUILD.bazel:10:17: Compiling risc0/zkvm/sdk/cpp/guest/cppstd.cpp failed: (Aborted): riscv32-unknown-elf-gcc failed: error executing command external/risc0_toolchain_riscv32im-osx-x86_64/bin/riscv32-unknown-elf-gcc '-DRISCV=1' '-mabi=ilp32' '-march=rv32im' -ffreestanding -fno-strict-aliasing -fno-exceptions -fno-non-call-exceptions -Wall ... (remaining 34 arguments skipped)
    
    Use --sandbox_debug to see verbose messages from the sandbox
    dyld: Symbol not found: __ZTTNSt3__119basic_ostringstreamIcNS_11char_traitsIcEENS_9allocatorIcEEEE
      Referenced from: /private/var/tmp/_bazel_karlyu/06f658563a59c318505fb96938db5614/sandbox/darwin-sandbox/164/execroot/risc0/external/risc0_toolchain_riscv32im-osx-x86_64/bin/riscv32-unknown-elf-gcc (which was built for Mac OS X 12.0)
      Expected in: /usr/lib/libc++.1.dylib
     in /private/var/tmp/_bazel_karlyu/06f658563a59c318505fb96938db5614/sandbox/darwin-sandbox/164/execroot/risc0/external/risc0_toolchain_riscv32im-osx-x86_64/bin/riscv32-unknown-elf-gcc
    
    
    
    FAILED: Build did NOT complete successfully
    //examples/cpp/battleship:test                                        NO STATUS
    //examples/cpp/deck:test                                              NO STATUS
    //examples/rust/battleship:test                                       NO STATUS
    //examples/rust/battleship/core:test                                  NO STATUS
    //examples/rust/digital_signature:test                                NO STATUS
    //examples/rust/votingmachine:test                                    NO STATUS
    //risc0/core/test:test                                                NO STATUS
    //risc0/zkp/accel/test:test                                           NO STATUS
    //risc0/zkp/core/test:test                                            NO STATUS
    //risc0/zkp/prove/test:test                                           NO STATUS
    //risc0/zkvm/circuit/test:add_test                                    NO STATUS
    //risc0/zkvm/circuit/test:addi_test                                   NO STATUS
    //risc0/zkvm/circuit/test:and_test                                    NO STATUS
    //risc0/zkvm/circuit/test:andi_test                                   NO STATUS
    //risc0/zkvm/circuit/test:auipc_test                                  NO STATUS
    //risc0/zkvm/circuit/test:beq_test                                    NO STATUS
    //risc0/zkvm/circuit/test:bge_test                                    NO STATUS
    //risc0/zkvm/circuit/test:bgeu_test                                   NO STATUS
    //risc0/zkvm/circuit/test:blt_test                                    NO STATUS
    //risc0/zkvm/circuit/test:bltu_test                                   NO STATUS
    //risc0/zkvm/circuit/test:bne_test                                    NO STATUS
    //risc0/zkvm/circuit/test:div_test                                    NO STATUS
    //risc0/zkvm/circuit/test:divu_test                                   NO STATUS
    //risc0/zkvm/circuit/test:jal_test                                    NO STATUS
    //risc0/zkvm/circuit/test:jalr_test                                   NO STATUS
    //risc0/zkvm/circuit/test:lb_test                                     NO STATUS
    //risc0/zkvm/circuit/test:lbu_test                                    NO STATUS
    //risc0/zkvm/circuit/test:lh_test                                     NO STATUS
    //risc0/zkvm/circuit/test:lhu_test                                    NO STATUS
    //risc0/zkvm/circuit/test:lui_test                                    NO STATUS
    //risc0/zkvm/circuit/test:lw_test                                     NO STATUS
    //risc0/zkvm/circuit/test:mul_test                                    NO STATUS
    //risc0/zkvm/circuit/test:mulh_test                                   NO STATUS
    //risc0/zkvm/circuit/test:mulhsu_test                                 NO STATUS
    //risc0/zkvm/circuit/test:mulhu_test                                  NO STATUS
    //risc0/zkvm/circuit/test:or_test                                     NO STATUS
    //risc0/zkvm/circuit/test:ori_test                                    NO STATUS
    //risc0/zkvm/circuit/test:rem_test                                    NO STATUS
    //risc0/zkvm/circuit/test:remu_test                                   NO STATUS
    //risc0/zkvm/circuit/test:sb_test                                     NO STATUS
    //risc0/zkvm/circuit/test:sh_test                                     NO STATUS
    //risc0/zkvm/circuit/test:simple_test                                 NO STATUS
    //risc0/zkvm/circuit/test:sll_test                                    NO STATUS
    //risc0/zkvm/circuit/test:slli_test                                   NO STATUS
    //risc0/zkvm/circuit/test:slt_test                                    NO STATUS
    //risc0/zkvm/circuit/test:slti_test                                   NO STATUS
    //risc0/zkvm/circuit/test:sltiu_test                                  NO STATUS
    //risc0/zkvm/circuit/test:sltu_test                                   NO STATUS
    //risc0/zkvm/circuit/test:sra_test                                    NO STATUS
    //risc0/zkvm/circuit/test:srai_test                                   NO STATUS
    //risc0/zkvm/circuit/test:srl_test                                    NO STATUS
    //risc0/zkvm/circuit/test:srli_test                                   NO STATUS
    //risc0/zkvm/circuit/test:sub_test                                    NO STATUS
    //risc0/zkvm/circuit/test:sw_test                                     NO STATUS
    //risc0/zkvm/circuit/test:xor_test                                    NO STATUS
    //risc0/zkvm/circuit/test:xori_test                                   NO STATUS
    //risc0/zkvm/prove/test:test                                          NO STATUS
    //risc0/zkvm/sdk/cpp/guest/test:test                                  NO STATUS
    //risc0/zkvm/sdk/rust/core:test_guest                                 NO STATUS
    //risc0/zkvm/sdk/rust/core:test_host                                  NO STATUS
    //risc0/zkvm/sdk/rust/serde:test_guest                                NO STATUS
    //risc0/zkvm/sdk/rust/serde:test_host                                 NO STATUS
    
    FAILED: Build did NOT complete successfully
    
    bug 
    opened by DecentrilizedMan 4
  • Error when building rust examples on macos m1

    Error when building rust examples on macos m1

    clang: error: linker command failed with exit code 1 (use -v to see invocation)

    might be a bazel bug? https://github.com/bazelbuild/bazel/issues/14395#issuecomment-1009490593 have you worked around it @flaub?

    opened by kobigurk 4
  • Memset and digest_u8_slice benchmark

    Memset and digest_u8_slice benchmark

    Add a throughput measurement for memset and a benchmark that tests the sha::digest_u8_slice API performance which is quite dramatically worse than raw_sha throughput

    opened by stskeeps 0
  • 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
  • added the ability to test in guest environment

    added the ability to test in guest environment

    Added support to run tests in a guest environment.

    These changes allow testing the guest environment with printing results to the console.

    When the test_mode field is set to true in GuestOptions, in addition to build_guest_package() function, embed_methods_with_options() also runs the test_guest_package() function.

    test_guest_package() - installs r0vm in target, runs tests, sets r0vm as a runner for tests and prints outputs.

    Compromises made:

    • A custom test runner is needed as libtest currently requires fmax/sqrt/fmin functions
    • r0vm will always be the latest crates.io upstream, should ideally be parsing guest method Cargo.toml to find the right reference to it

    See corresponding pull request in risc0-rust-starter: https://github.com/risc0/risc0-rust-starter/pull/16

    NOTE: this is my first open source contribution pull request, be gentle but firm, will happily correct issues!

    opened by dymchenkko 0
  • Improve error message for MethodId verification failures

    Improve error message for MethodId verification failures

    A clear error message should be presented when MethodId verification fails. Especially in the case where the generated MethodId is smaller than the number of cycles (we run off the end of the table). A helpful error message directing the user to use the code_limit parameter of embed_methods_with_options function would be good.

    enhancement good first issue 
    opened by flaub 1
  • Add raw byte interface to enable usage of frameworks like rkyv

    Add raw byte interface to enable usage of frameworks like rkyv

    This is probably not the cleanest way to do it but it works. It mostly relies on existing plumbing in place for passing in serde in/out. Main changes:

    • Separate between the input channel for serde serialized input to raw bytes. It didn't seem to make sense to have zero copy tape combined with serde as the reader knows how many bytes to consume for each serde input. This seems difficult to do in zero-copy. The new channel name is kSendRecvChannel_InitialInputAux / SENDRECV_CHANNEL_INITIAL_AUX_INPUT
    • Add interface to write auxiliary input (zero-copy): add_input_u8_slice_aux / add_aux_input. It's more natural to use add_input_u8_slice_aux as serialization is done outside of risc0.
    • Currently only allows for a single struct to be serialized using rkyv. I wasn't sure if we can have a single stream that supports multiple structs or if we will have to separate by index to make it easy to leverage using zero-copy.

    Would love to change the approach if this seems going in the wrong direction

    opened by cpunkzzz 0
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)
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 6 Aug 29, 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 132 Sep 20, 2022
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 49 Mar 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 188 Sep 22, 2022
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 500 Sep 26, 2022
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 16 Aug 12, 2022
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™ 6 Apr 27, 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 69 Jun 10, 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.7k Sep 19, 2022
Tool for computing vanity Gnosis Safe addresses

0xdeadbeef Tool used for computing vanity Gnosis Safe addresses. This tool is currently hard-coded to only support the v1.3.0 Safe deployment: GnosisS

Nicholas Rodrigues Lordello 41 Jun 5, 2022
Keyhouse is a skeleton of general-purpose Key Management System written in Rust.

Keyhouse Keyhouse is a skeleton of general-purpose Key Management System. Keyhouse is not an off-the-shelf system, and it's not ready for production.

Bytedance Inc. 143 Sep 14, 2022
Composable proof transcripts for public-coin arguments of knowledge

Merlin: composable proof transcripts for public-coin arguments of knowledge Merlin is a STROBE-based transcript construction for zero-knowledge proofs

dalek cryptography 96 Sep 15, 2022
CKB's vm, based on open source RISC-V ISA

Nervos CKB VM About CKB VM CKB VM is a pure software implementation of the RISC-V instruction set used as scripting VM in CKB. Right now it implements

Nervos Network 287 Sep 16, 2022
Parser and test runner for testing compatable common Ethereum full node tests against Polygon Zero's EVM.

EVM Test Parses and runs compatible common Ethereum tests from ethereum/tests against Polygon Zero's EVM. Note: This repo is currently very early in d

Mir Protocol 2 Aug 25, 2022
DexiosGUI - Simple cross-platform drag-and-drop Dexios file encryption

DexiosGUI Simple cross-platform drag-and-drop Dexios file encryption. Latest Windows x64 release is here. DexiosGUI is a Qt/C++ app for encrypt and de

Fabrice Corraire 4 Jul 25, 2022
The powerful analysis platform to explore and visualize data from blockchain.

Mars: The powerful analysis platform to explore and visualize data from Web3 Features Blazing Fast Create from scratch with Rust. Pipeline Processor E

DeepETH 55 Sep 20, 2022
A Secure Capability-Based Runtime for JavaScript Based on Deno

Secure Runtime secure-runtime, as the name implies, is a secure runtime for JavaScript, designed for the multi-tenant serverless environment. It is an

Gigamono 6 Sep 18, 2022
Substrate: The platform for blockchain innovators

Substrate · Substrate is a next-generation framework for blockchain innovation ?? . Trying it out Simply go to substrate.dev and follow the installati

Parity Technologies 7.4k Sep 27, 2022