8 stable releases

✓ Uses Rust 2018 edition

1.3.0 Nov 30, 2019
1.2.2 Oct 6, 2019
1.2.0 Aug 26, 2019

#47 in Cargo plugins

Download history 40/week @ 2019-10-01 17/week @ 2019-10-08 11/week @ 2019-10-15 35/week @ 2019-10-22 14/week @ 2019-10-29 12/week @ 2019-11-05 4/week @ 2019-11-12 17/week @ 2019-11-19 30/week @ 2019-11-26 33/week @ 2019-12-03 103/week @ 2019-12-10 3/week @ 2019-12-17 12/week @ 2019-12-24 5/week @ 2019-12-31 35/week @ 2020-01-07

111 downloads per month




A cargo subcommand, that runs valgrind and collects its output in a helpful manner.

Latest version Documentation

This command extends cargo with the capability to directly run valgrind on the executable (either a bin-crate or an example). The output of valgrind is then used to mark the binary as pass/fail.

This command should not be necessary for ordinary Rust programs, especially if you are only using safe Rust code. But if you do FFI-related stuff (either by simply using a FFI-binding crate or because you are developing a safe wrapper for such FFI bindings) it may be really helpful to check, whether the memory usages across the FFI borders are correct.


A typical mistake would be:

use std::ffi::CString;
use std::os::raw::c_char;

extern "C" {
    fn puts(s: *const c_char);

fn main() {
    let string = CString::new("Test").unwrap();

    let ptr = string.into_raw();
    unsafe { puts(ptr) };

    // unsafe { CString::from_raw(ptr) };

The memory of the variable string will never be freed. If you run cargo valgrind it your shell, it detects the leak:

$ cargo valgrind
    Finished dev [unoptimized + debuginfo] target(s) in 0.01s
   Analyzing `target/debug/cstring`
       Error Leaked 5 bytes
        Info at realloc (vg_replace_malloc.c:826)
             at realloc (alloc.rs:125)
             at realloc (alloc.rs:184)
             at reserve_internal<u8,alloc::alloc::Global> (raw_vec.rs:666)
             at reserve_exact<u8,alloc::alloc::Global> (raw_vec.rs:411)
             at reserve_exact<u8> (vec.rs:482)
             at std::ffi::c_str::CString::from_vec_unchecked (c_str.rs:355)
             at std::ffi::c_str::CString::_new (c_str.rs:330)
             at std::ffi::c_str::CString::new (c_str.rs:324)
             at cstring::main (main.rs:9)
             at std::rt::lang_start::{{closure}} (rt.rs:64)
             at {{closure}} (rt.rs:49)
             at std::panicking::try::do_call (panicking.rs:293)
             at __rust_maybe_catch_panic (lib.rs:85)
             at try<i32,closure> (panicking.rs:272)
             at catch_unwind<closure,i32> (panic.rs:394)
             at std::rt::lang_start_internal (rt.rs:48)
             at std::rt::lang_start (rt.rs:64)
             at main
     Summary Leaked 5 B total

Un-commenting the unsafe { CString::from_raw(ptr) }; re-takes the memory and frees it correctly. cargo valgrind will compile the binary for you and won't detect a leak, since there is no leak anymore.



You need to have valgrind installed and in the PATH (you can test this by running valgrind --help in your shell).

You'll also need to have cargo installed and in the PATH, but since this is a cargo subcommand, you will almost certainly have it already installed.

Install the binary

Run the following command to install from crates.io:

$ cargo install cargo-valgrind

This will install the latest official released version.

If you want to use the latest changes, that were not yet published to crates.io, you can install the binary from the git-repository like this:

$ cargo install --git https://github.com/jfrimmel/cargo-valgrind


Licensed under either of Apache License, Version 2.0 or MIT license at your option.

Unless you explicitly state otherwise, any contribution intentionally submitted for inclusion in cargo-valgrind by you, as defined in the Apache-2.0 license, shall be dual licensed as above, without any additional terms or conditions.


~55K SLoC