Lib.rs

criterion

Statistics-driven micro-benchmarking library

divan

Statistically-comfy benchmarking library

pprof

An internal perf tools for rust programs

profiling

very thin abstraction over other profiler crates

inferno

Rust port of the FlameGraph performance profiling tool suite

oha

Ohayou(おはよう), HTTP load generator, inspired by rakyll/hey with tui animation

iai-callgrind

High-precision and consistent benchmarking framework/harness for Rust

hdrhistogram

A port of HdrHistogram to Rust

dhat

heap profiling and ad hoc profiling with DHAT

puffin

instrumentation profiler for games

brunch

micro-benchmark runner

tracy-client

High level bindings to the client libraries for the Tracy profiler

memory-stats

A cross-platform memory profiler for Rust

tiny-bench

A tiny benchmarking library

dogstatsd

client for Rust

measureme

Support crate for rustc's self-profiling feature

perf-event

interface to Linux performance monitoring

foyer-bench

bench tool for foyer - Hybrid cache for Rust

criterion2

Statistics-driven micro-benchmarking library

ra_ap_profile

A collection of tools for profiling rust-analyzer

rustracing_jaeger

Jaeger client library created on top of rustracing

codspeed

Core instrumentation library for CodSpeed

pyroscope

Profiler Agent for continuous profiling of Rust, Python and Ruby applications

goku-bench

Goku is an HTTP load testing application written in Rust

fxprof-processed-profile

Create profiles in the Firefox Profiler's processed profile JSON format

goodmetrics

Unlimited cardinality, fast metrics recording - for services

countme

Counts the number of live instances of types

counts

A command line tool for ad hoc profiling

tango-bench

Tango benchmarking harness

rftrace

Function tracer backend. Logs all functions entries and exits. Works on all software compiled with mcount() instrumentation.

benchmarking

can be used to execute something and measure the execution time. It does not output anything to screens and filesystems.

binggan

Benchmarking library for stable Rust

tracing-tracy

Inspect tracing-enabled Rust applications with Tracy

firestorm

A low overhead intrusive flamegraph profiler

glassbench

rust benchmark with memory

legion_prof

Legion Prof: a profiler for Legion

usdt

Dust your Rust with USDT probes

time-graph

Always-on profilling recording function timing and the corresponding call graph

perf-event-open-sys2

Unsafe, direct bindings for Linux's perf_event_open system call, with associated types and constants

inquisitor

fast load testing tool

fun_time

that allows you to easily time your function calls with a simple attribute!

deno_bench_util

Bench and profiling utilities for deno crates

linux-perf-data

A parser for the perf.data format and the jitdump format. These formats are used by the Linux perf tool.

crabgrind

Rust bindings to "Valgrind Client Request" interface

metered

Fast, ergonomic metrics for Rust!

codspeed-criterion-compat

Criterion.rs compatibility layer for CodSpeed

rbspy

Sampling CPU profiler for Ruby

tracing-durations-export

Record and visualize parallelism of tracing spans

windsock

database/service benchmarking framework

criterion-cycles-per-byte

measure time with CPU cycles for criterion

rd-hashd

Latency-sensitive pseudo workload for resctl-demo

readings-probe

Probe for vital metrics process logging

measure_time

Provices macros to measure the time until end of scope

tracing-profile

A span based profiler, utilizing the tracing crate

mq-workload-generator

testing the performance of Apache RocketMQ and Apache Kafka

bpu_trasher

trash the branch prediction unit

labyr

A PDDL benchmarker

pprof2

An internal perf tools for rust programs

blondie

Collect CPU callstack samples from a windows process

speed-levels-rs

speed-level benchmark for AV1 encoders

yab

Benchmarking framework powered by cachegrind

boa_profiler

Profiler for the Boa JavaScript engine

tracing-flame

Tracing layer for creating flamegraphs from span timings

micrometer

Profiling for fast, high frequency events in multithreaded applications with low overhead

shumai

A benchmark framework that empowers efficient and correct multi-thread benchmarks

rustics

statistic library for performance analysis

perf-gauge

Gauging performance of network services. Snapshot or continuous, supports Prometheus metrics.

everscale-raptorq

RaptorQ (RFC6330)

big-o-test

Enforces a maximum space and time Algorithm Complexity when testing

top-type-sizes

Makes -Zprint-type-size more useful

coz

Rust support for the coz Causal Profiler: https://github.com/plasma-umass/coz

py-spy

Sampling profiler for Python programs

bma-benchmark

Benchmark for Rust and humans

guacamole

linearly-seekable random number generator

benchers

Bencher for Rust

cpumap

GUI/TUI to view and edit CPU affinities of processes and threads on Linux

precision

Low overhead, high precision measurement crate

stak-profiler

Profiling for Stak Scheme

nvbit-model

NVIDIA NVBIT models for serialization and deserialization

function-timer

Macro that allow to time a function and emit a metric using metrics crate

perf_monitor

A toolkit designed to be a foundation for applications to monitor their performance

samply

A command line profiler for macOS and Linux

tremor-otelapis

OpenTelemetry v1 API binding based on tonic/prost

nvbit-io

NVIDIA NVBIT streaming encoder and decoder implementations using serde

opentelemetry-http

Helper implementations for sending HTTP requests. Uses include propagating and extracting context over http, exporting telemetry, requesting sampling strategies.

cardamon

help development teams measure the power consumption and carbon emissions of their software

prima-tracing

Prima.it opentelemetry standard library

swc-coverage-instrument

Istanbul compatible coverage instrumentation visitor for SWC

rotour

The path planner and motion profiler for the Tektite-R Robot Tour kit!

cargo-criterion

Cargo extension for running Criterion.rs benchmarks and reporting the results

re_memory

Run-time memory tracking and profiling

benchmark-rs

Benchmarks for Rust libraries

lading-capture

load testing daemons

rlt

A universal load testing library for Rust, with real-time TUI support

easybench

A lightweight benchmarking library

problem_generator

TD Mk Landscape benchmark generator, for use with black-box optimization algorithms

weld

language and runtime for improving the performance of data-intensive applications

diesel-tracing

Connection telemetry middleware for diesel and tracing

pfm

High-level wrapper of libpfm4

wholesym

A complete solution for fetching symbol files and resolving code addresses to symbols and debuginfo

carrot_utils

Utils library

statslicer

Guacamole provides a linearly-seekable random number generator

legion_prof_viewer

Profiler UI frontend component for Legion Prof

bencher

port of the libtest (unstable Rust) benchmark runner to Rust stable releases. Supports running benchmarks and filtering based on the name. Benchmark execution works exactly the same…

flamescope

Export flame data to speedscopes profile format

komihash

implemenation of komihash

p3-field-testing

Plonky3 field testing utilities

tpctools

generating and converting TPC-H and TPC-DS data sets

tracy-gizmos

Bindings for the client library of the Tracy profiler

puffin_http

TCP server/client for puffin profiler data

vtebench

Terminal emulators benchmark

microbench

A micro-benchmarking library

mntime

Execute "m" commands "n" times to calculate mean of usage time and memory. As an alternative to "time", "gnu-time" is used internally.

energy-bench

Methods for benchmarking the energy consumption of programs

rubbler

RISC-V assembler written in Rust 🦀. This library was written with the main purpose of embedding a simple RISC-V assembler inside of a RISC-V CPU test bench code written with verilator.

iai-parse

Convert iai benchmark output to CSV

rpc-perf

RPC Performance Testing

instrumenter

Basic framework to allow collecting tracing data and hw counters on multithreaded applications

perf-event-data

Types and traits for parsing records emitted by perf_event_open

latency_trace

supports latency measurement for functions and code blocks, both sync and async

microchassis

A chassis to increase observability of services and tools

re_tracing

Helpers for tracing/spans/flamegraphs and such

dynamic-proxy

Dynamic Proxy Implementation for Rust

workflow-perf-monitor

A toolkit designed to be a foundation for applications to monitor their performance

autoperf

Automate the recording and instrumentation of programs with performance counters

harness

Precise and reproducible benchmarking

nexmark

data stream generator

cpu-time

Small crate that provides CPU time measurement

superluminal-perf

Superluminal Performance API for adding user events to profiler captures

devtimer

benchmarking code

rust_hawktracer

Rust bindings for hawktracer profiling library

datadog-statsd

A dogstatsd client for rust

cbench

Environment control for benchmarks

devtools

CrabNebula devtools for Tauri: Inspect, monitor, and understand your application with ease

flamelens

Flamegraph viewer in the terminal

pyroscope-rbspy-oncpu

Sampling CPU profiler for Ruby

coveralls

Send job to Coveralls (coveralls.io)

boomhammer

small HTTP load testing tool

witchcraft-metrics

A general-purpose metrics library

ambient_profiling

very thin abstraction over other profiler crates

iai

One-shot benchmarking library

hala-pprof-memory

A memory profile data collector for pprof

perfmon

A toolkit designed to be a foundation for applications to monitor their performance

likwid-marker

Bindings for the LIKWID marker API

efficiency-benchmark

benchmarking tool for measuring the efficiency of your laptop

microperf

A small tool using perf to provide more performance insights

alumet

Modular framework for hardware and software measurement (including energy consumption and more)

pddl_rs

PDDL parser

tracy-rs

Rust bindings for the tracy realtime profiler

trace-err

A small extension to the tracing crate, which provides a single method 'trace_expect()' for Result<T, E> and Option<T>

optick

Super Lightweight Performance Profiler

fast-bernoulli

Efficient sampling with uniform probability

opentelemetry-user-events-metrics

OpenTelemetry metrics exporter to user events

foyer-storage-bench

storage engine bench tool for foyer - the hybrid cache for Rust

cpuprofiler

Bindings to google's cpu profiler

mondrian-charts

Abstract chart generator and renderer

scaling

A lightweight benchmarking library that measures scaling behavior

calliper

Fine-grained benchmarking made easy

trace-time

Easily trace time to execute a scope

wind_tunnel_core

Core components for Wind Tunnel

performance_measure

measuring the performance of Rust code

xi-trace

Library-based distributed tracing API to meet the needs of xi-core, frontends and plugins

l2r0-profiler-guest

Profiler for RISC Zero, guest side program

codspeed-bencher-compat

Bencher compatibility layer for CodSpeed

nvbit-build

Build-time helpers for compiling NVIDIA NVBIT instrumentation

rs_tracing

trace events in the trace event format

acumen

Collect info about your system

timing_rdtsc

Easily time a block of code

peekbufread

Implements a peekable std::io::Read with support for checkpoints

pore

a performance oriented reimplementation of repo

pyo3-tracing-subscriber

A Python module for configuring and initializing tracing subscribers from Python

tracing-span-tree

tracing subscriber for hierarchical profiling

rprofile

measure processor timings in selected samples of execution

tide-tracing

middleware for tide using the tracing crate for logging

duck-chess

duck chess

tracing-axiom

The tracing layer for shipping traces to Axiom

chord-output

async parallel case executor

iai-callgrind-runner

Binary package needed by the iai-callgrind library

flaregun

Tracing and monitoring tools for Linux

ipp-sys

toplevel convenience crate (part of ipp-sys Intel IPP bindings)

analyzeme

common functionality for measureme tools

perfdata

Parsing and handling performance data for monitoring engines like Nagios, Icinga2,

macroquad-profiler

Profiler UI for macroquad

aoc-runner

A runner for the Advent of Code

onesignal-tracing-tail-sample

Tail sampling support for tracing with OpenTelemetry

fliplru

A LRU cache that shows effectiveness of cache capacity

billion-row-gen

Generates a large number of rows for the one billion row challenge

profile-demo

a brief introduction

moneta_fn

A set of macros to function profiling

howlong

Measure how long it takes for a program to execute in different clocks

embedded-profiling

Profiling for no-std embedded targets

benchie

A benchmarking tool

hermit_bench_output

interface to the hermit-bench benchmarking framework

gbench

tools to benchmark code for further analyzation using Chrome tracing

cbdr

Tools for comparitive benchmarking

tauri-plugin-devtools

CrabNebula devtools for Tauri: Inspect, monitor, and understand your application with ease

coarse-prof

Tiny library for coarse-grained hierarchical profiling

cyfs-raptorq

RaptorQ (RFC6330)

pprof_server

pprof server in Rust

tempus_fugit

A tiny library to measure the execution time of Rust expressions, with nanosecond precision

gperftools

Bindings to google's gperftools

rd-hashd-intf

Latency-sensitive pseudo workload for resctl-demo (interface library)

microtime

Time tracked in microseconds

papi-bindings

Rust PAPI bindings

pkgcruft

QA library and tools based on pkgcraft

chess_perft

package runs a 'perft' test on a particular chess position. This makes every move out to a certain depth, and counts the number of leaf-nodes. This is used to verify that move generation is correct and fast…

opentelemetry-user-events-logs

OpenTelemetry-Rust exporter to userevents

tracy-client-sys

Low level bindings to the client libraries for the Tracy profiler

benchrs

Apache Benchmark style http bench tool written in async rust

kvbench

A key-value store benchmark framework with customizable workloads

chain_reaction

beautiful timed function chaining

sirun

A benchmark test runner

aoc-main

A macro which defines a handful main for the Advent of Code

breezy-timer

Painless and production friendly timers

tracing-timing

Inter-event timing metrics on top of tracing

scopetime

log runtime of arbitrary scope

function_benchmarker

A proc macro for benchmarking Rust code

queuecheck

A thread-safe queue testing and benchmarking library

diol-cbind

benchmark lib

perf-focus

A post-processing tool for analyzing perf data

zerg

HTTP throughput benchmarking library

wtf

A frame-based profiling crate

resctl-bench-intf

Whole system resource control benchmarks with realistic scenarios (interface library)

lcov-diff

get deltas of lcov coverage files

s3lsio

command line utility for AWS S3 operations. It support V2 and V4 signatures. It also does benchmarking for S3. It can be used in scripts, called from other apps, cron etc. It's driven by JSON and can return data in JSON…

flame

a profiling / flamegraph library

hitrace-sys

Bindings to the HiTrace tracing system of OpenHarmony

usereport-rs

Collect system information for the first 60 seconds of a performance analysis

speed_test

allows for easy performance profiling, seamlessly

nokia/nwind

A sampling CPU profiler for Linux

spirit-dipstick

Automatic configuration of dipstick backends

microprofile

small library for profiling and optimizing multithreaded programs

tic

a high-performance stats library focused on rates and latencies from timestamped events

bitbelay-cli

Command line facilities for the bitbelay package ecosystem

criterion-table

Generate markdown comparison tables from cargo-criterion benchmark output

timedilator-2

Faster real-time TUI tracing profiler for the nanoprof C library

getr

A benchmarking wrapper around getrusage

puffin_egui

Show puffin profiler flamegraph in-game using egui

cargo-criterion-means

Cargo command to gather the mean and standard error values from criterion benchmarks

update_rate

A generic, low-overhead rate counter for FPS counters and the like

exponential-histogram

Auto-scaling approximate histogram

dinghy-test

Cross-compilation made easier - see main crate cargo-dinghy

benchy

benchmarking long-running tasks

chord-util

async parallel case executor

macos-profiler

A macOS profiler for Rust programs

wrk-api-bench

perform HTTP benchmarks using wrk and produce useful performance regression information

observability

Experimental tracing ideas

rftrace-frontend

Rftracer frontend for writing uftrace compatible traces

metrics-catalogue

Metrics Catalogue

coz-temporary

Rust support for the coz Causal Profiler: https://github.com/plasma-umass/coz

newrelic-unofficial

New Relic instrumentation in pure Rust

critcmp

A command line utility for comparing benchmark data generated by Criterion

cliff

Find the load at which a benchmark falls over

print_perf

Ergonomic print optimization for Rust. This crate will provide a struct and a helper macro that you can use to measure and print out the time between two points in your code.

axum-prometheus

A tower middleware to collect and export HTTP metrics for Axum

rapl-energy

Small library for getting the CPU energy consumption from RAPL

firestorm-enabled

A dependency of firestorm. Do not use directly.

kperf-rs

Rust safe wrapper over kperf-sys library

jemalloc_pprof

Convert jemalloc heap profiles to pprof to understand memory usage, fix memory leaks, and fix OOM Kills

scope_timer

A freaking easy-to-use timer for measuring scope time for execution

plummerprimes

Builds, Runs, and reports benchmarks from https://github.com/PlummersSoftwareLLC/Primes

cpubaker

program that turns every core to 100%

telemetry

mechanism used to capture metrics in an application, to later store the data locally or upload it to a server for statistical analysis

libtracecmd

Rust wrapper of libtracecmd

tracing-actions

Tracing subscriber that vends action trace structures to a callback

mm0_deepsize

MM0 port of deepsize crate

tracing-bunyan-formatter

A Bunyan formatter for the tracing crate

profiling-procmacros

very thin abstraction over other profiler crates

wind_tunnel_runner

The Wind Tunnel runner

ulid-rs

Rewrites https://github.com/suyash/ulid from C++ to Rust

async-instrumenter

A wrapper over futures which allows to time how long the future takes to execute

craftingbench

benchmarking macro :)

qbsdiff_test_bench_utils

private utilities of the qbsdiff crate for tests and benchmarks

kant

a high performance zero-config metric implementation

tracing-perf

Performance and time reporting for tracing

intel-seapi

Mid-level wrapper for Intel Single Event API (SEAPI) and ittnotify, as used by Intel VTune

lading

load testing daemons

hprof

hierarchical profiler

flamegraph

cargo subcommand for generating flamegraphs, using inferno under the hood

profl

timings profiler

autometrics

Easily add metrics to your code that actually help you spot and debug issues in production. Built on Prometheus and OpenTelemetry.

hala-pprof

Hala performance profiling toolkit

tracing-profile-perfetto-sys

Low-level bindings to Perfetto, optionally used by the tracing-profile crate

sightglass

A benchmark suite and tool to compare different implementations of the same primitives

webbundle-bench

WebBundle Bench

autophagy-llvm

LLVM backend for Autophagy

lua-perf

A perf tool for C and Lua hybrid code

mybench

(and very primitive) benchmarking macro

streaming-harness

A benchmarking harness for streaming systems

mbench

easy to use microbenchmark macro. Zero deps.

crate-race

Comparing Rust crate function speeds

ppk2

A driver for Nordic's Power Profiler Kit 2

criterion-single-page-html

Collect criterion generated html files and provide them as a single html file, servable from s3 into your browser

tracing-coz

Bridge between the Coz profiler and rust tracing

ratel

JavaScript transpiler in Rust

keyvalint_bench

standardized key-value store benchmarks

dinghy-build

Cross-compilation made easier - helpers for build.rs scripts

tracing-opentelemetry

OpenTelemetry integration for tracing

opentelemetry-etw-logs

OpenTelemetry logs exporter to ETW (Event Tracing for Windows)

cortex-m-microclock

software clock for Cortex-M devices based on the CYCCNT hardware counter

opentelemetry-application-insights

OpenTelemetry exporter for Azure Application Insights

rbspy-oncpu

Sampling CPU profiler for Ruby

gimli

reading and writing the DWARF debugging format

cadence

An extensible Statsd client for Rust

grid_search_maze

Maze generator for testing and benchmarking grid-searching algorithms

bench-rs

A benchmark library

redox-kprofiling

Conversion tool from Redox kernel profiling data into perf script

cargo-instruments

Profile binary targets on macOS using Xcode Instruments

tracing-chrome

A Layer for tracing-subscriber that outputs Chrome-style traces

measured

A better way to measure your application statistics

ttimer

A tiny crate used for timing individual functions

l2r0-profiler-host

Profiler for RISC Zero, host side program

cargo-llvm-codecov-converter

conversion utility from llvm-cov format to codecov format

polonius-engine

Core definition for the Rust borrow checker

performance-mark-attribute

performance_mark is an attribute macro that adds performance (time) logging to methods

opentelemetry-appender-log

An OpenTelemetry appender for the log crate

bench_timer

bench library for rust

perf-count

performance counters with rust

tracing-ext-ffi-subscriber

forwarding tracing subscriber for a FFI host profiler

hypcmp

Extension to run hyperfine with toml files w/ commit switches

cargo-benchcmp

comparing Rust micro-benchmark output

s2n-netbench-driver-s2n-tls

s2n-netbench driver for s2n-tls

goku

HTTP load testing application written in Rust

cyfs-perf-client

package

criterion-macro

Custom Test Framework macro for Criterion.rs

tracing-opentelemetry-instrumentation-sdk

A set of helpers to build OpenTelemetry instrumentation based on tracing crate

mbryant-aoc2021

Commented solutions to AoC 2021

rsperftools

An internal perf tools for rust programs

zoomies

An asynchronous DogStatsD client

tracers

Generates very low overhead native trace points using stable Rust

pfm-sys

Binding of libpfm4

benchlib-rs

A libary to benchmark closures

downtown

A realtime BPF profiler

prom-timer

RAII Prometheus Timer for monitoring & tracing

kprofiling

Forgot to rename this to redox-kprofiling, email me if you'd like this crate name

one_billion_rows_challenge

one billion rows challend

rtm-json

Rust Type Mapper (RTM) crate rtm-json

serde-bench

Minimal serialization format for benchmarking Serde

tonic_prometheus_layer

Tonic-compatible Tower Layer for Prometheus Metrics

rprofiler

profiling your code with HTML reports as result

prometheus

instrumentation library for Rust applications

pyroscope-cli

Pyroscope Profiler CLI

deepsize

measuring the total size of object on the stack and heap

float-quickly

Faster, inline-friendly versions of some libm f32/f64 intrinsics

hermes_bench

benchmark suite generator in Rust

nokia/nperf

A sampling CPU profiler for Linux

chairmark

benchmarking library without unstable stuff

might_sleep

limit cpu usage by estimating sleep time

ssh-wrap

ssh wrap

t-cmd

CLI utility to measure CPU time and RSS of a process

disturbance

Monitor disturbances in a web service's behaviour

big_o

Infers asymptotic computational complexity

feldera-size-of

measuring the total memory usage of an object

thread_profiler

A thread profiling library that outputs profiles in the chromium trace format

time-cmd

Time how long a process takes to run

perfrecord

A macOS command line profiler

molt-shell

Molt Application Frameworks

nvbit-sys

Native bindings to the NVIDIA NVBIT binary instrumentation library

persil

minimal and simple profiling library based on measureme

perf-tools

tools for Linux perf

tracing-chrometrace

A Layer for tracing-subscriber that outputs Chrome-style traces

opentelemetry-etw-metrics

OpenTelemetry metrics exporter to ETW (Event Tracing for Windows)

chord-cli

async parallel case executor

bitbelay-providers

Data providers for the bitbelay package ecosystem

criterion-decimal-throughput

Criterion.rs measurement for decimal throughput (MB/s, GB/s, etc.)

esl01-minibench

Minimal benchmark library

pyo3-opentelemetry-macros

Macro for passing OpenTelemetry context from Python to Rust

winstacks

Collect CPU call stack samples from a windows process

harness-probe-perf

harness probe for reporting linux perf-event counter values

ssdbench

Lightweight SSD benchmark written in Rust

partial-callgrind

Callgrind client requests in Rust

criterion-polyglot

An extension trait for criterion providing benchmark methods for various non-Rust programming languages

mphf_benchmark

The program for benchmarking Minimal Perfect Hash Functions

rust-bench-output

interface to the hermit-bench benchmarking framework

loadem

Command line tool for emulating web load from thousands of clients

xwytools

lib for myself

rbench

lightweight benchmarking tool

trackingalloc

fast tracking allocator

ibench

Extremely simple and small Rust library for quickly timing a closure

wind_tunnel_instruments

Instruments for measuring performance with Wind Tunnel

callgrind

ep-systick

embedded-profiling implementation using systick

netperf

A network performance measurement tool