Lib.rs

criterion

Statistics-driven micro-benchmarking library

divan

Statistically-comfy benchmarking library

inferno

Rust port of the FlameGraph performance profiling tool suite

hdrhistogram

A port of HdrHistogram to Rust

pprof

An internal perf tools for rust programs

profiling

very thin abstraction over other profiler crates

deno_lint

lint for deno

iai-callgrind

High-precision and consistent benchmarking framework/harness for Rust

flamegraph

cargo subcommand for generating flamegraphs, using inferno under the hood

dhat

heap profiling and ad hoc profiling with DHAT

perf-event-open-sys

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

brunch

micro-benchmark runner

tracy-client

High level bindings to the client libraries for the Tracy profiler

puffin

instrumentation profiler for games

memory-stats

A cross-platform memory profiler for Rust

axum-prometheus

A tower middleware to collect and export HTTP metrics for Axum

criterion2

Statistics-driven micro-benchmarking library

jemalloc_pprof

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

measure_time

Provices macros to measure the time until end of scope

dogstatsd

client for Rust

gix

Interact with git repositories just like git would

dinghy-build

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

rbspy

Sampling CPU profiler for Ruby

tracing-chrome

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

codspeed

Core instrumentation library for CodSpeed

linux-perf-data

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

boa_profiler

Profiler for the Boa JavaScript engine

goodmetrics

Unlimited cardinality, fast metrics recording - for services

tiny-bench

A tiny benchmarking library

goku-bench

Goku is an HTTP load testing application written in Rust

measureme

Support crate for rustc's self-profiling feature

pyroscope

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

rftrace

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

memuse

Traits for measuring dynamic memory usage of types

binggan

Benchmarking library for stable Rust

startled

CLI tool for benchmarking Lambda functions

deno_bench_util

Bench and profiling utilities for deno crates

benchmarking

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

crabgrind

Rust bindings to "Valgrind Client Request" interface

tracing-profile

A span based profiler, utilizing the tracing crate

counts

A command line tool for ad hoc profiling

countme

Counts the number of live instances of types

py-spy

Sampling profiler for Python programs

rustracing_jaeger

Jaeger client library created on top of rustracing

windsock

database/service benchmarking framework

big-o-test

Enforces a maximum space and time Algorithm Complexity when testing

glassbench

rust benchmark with memory

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

tango-bench

Tango benchmarking harness

pprof_util

various utilities for representing and manipulating profiling data

dhat-to-flamegraph

Convert dhat JSON output to a flamegraph

nvbit-rs

Idiomatic library for using the NVIDIA NVBIT binary instrumentation library

precision

Low overhead, high precision measurement crate

mphf_benchmark

The program for benchmarking Minimal Perfect Hash Functions

hitrace-bench

Allows benching of servo on ohos using the hitrace library

codspeed-criterion-compat

Criterion.rs compatibility layer for CodSpeed

resctl-bench

Whole system resource control benchmarks with realistic scenarios

linux-perf-event-reader

Parse Linux perf_event information from raw bytes

netperf

A network performance measurement tool

bench_diff

Reliably compare the latencies of two functions/closures

legion_prof_viewer

Profiler UI frontend component for Legion Prof

fun_time

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

graph-api-benches

Benchmarking utilities and performance tests for the graph-api ecosystem

async-profiler-agent

Rust agent for async-profiler

perf-event

interface to Linux performance monitoring

readings-probe

Probe for vital metrics process logging

ittapi

High-level Rust bindings for ittapi

superluminal-perf

Superluminal Performance API for adding user events to profiler captures

firestorm

A low overhead intrusive flamegraph profiler

tonic_prometheus_layer

Tonic-compatible Tower Layer for Prometheus Metrics

wholesym

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

vcddiff

that can compare two VCD files and point to sources of divergence

swc-coverage-instrument

Istanbul compatible coverage instrumentation visitor for SWC

blueprint-benchmarking

benchmarking Tangle Blueprints

iai

One-shot benchmarking library

ddt

Useful cli tools

inquisitor

fast load testing tool

foyer-storage-bench

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

harness

Precise and reproducible benchmarking

scouter-error

Error logic for Scouter

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…

opentelemetry-resource-detectors

A collection of community supported resource detectors for OpenTelemetry

bma-benchmark

Benchmark for Rust and humans

witchcraft-metrics

A general-purpose metrics library

pprof2

An internal perf tools for rust programs

pyroscope_pprofrs

pprof-rs backend for Pyroscope Profiler

iai-parse

Convert iai benchmark output to CSV

altius-benchtools

A high-performance profiler for tracing RPC server execution

prun

Run 🍺

criterion-cycles-per-byte

measure time with CPU cycles for criterion

shumai

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

coz

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

micrometer

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

statslicer

Guacamole provides a linearly-seekable random number generator

size-of

measuring the total memory usage of an object

usdt

Dust your Rust with USDT probes

rlt

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

function-timer

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

deepsize

measuring the total size of object on the stack and heap

bloaty

package

rallo

Rust allocator for tracking memory usage

easybench

A lightweight benchmarking library

problem_generator

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

cbench

Environment control for benchmarks

historian

a high performance zero-config histogram implementation

yab

Benchmarking framework powered by cachegrind

flamescope

Export flame data to speedscopes profile format

histlog

hdrhistogram crate, provides off-thread serialization of HdrHistogram interval logs to file

rapl-energy

Small library for getting the CPU energy consumption from RAPL

parabuild

A parallel build utility for template heavy projects

tracy-client-sys

Low level bindings to the client libraries for the Tracy profiler

weld

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

venator

A tracing layer for exporting logs and spans to the Venator app

voxell_timer

Perf timers for Rust

fast-float-compare

A lightweight benchmark comparing minimal float comparison implementation against rust_decimal

devtools

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

tracy-gizmos

Bindings for the client library of the Tracy profiler

scs-sdk-telemetry

Rust wrapper for the ETS2 (Euro Truck Simulator 2) and ATS (American Truck Simulator) Telemetry SDK plug-in

vtebench

Terminal emulators benchmark

jrsonnet

Rust jsonnet implementation

hyperwood-bench

Our simplistic yet elegant bench is the first-ever Hyperwood design, embodying the project's essence of simplicity, functionality, and aesthetic clarity

speed-levels-rs

speed-level benchmark for AV1 encoders

granular-metrics

Zero-middleware metrics counter that emits per-key and aggregate RPS/RPM snapshots every second

blondie

Collect CPU callstack samples from a windows process

re_tracing

Helpers for tracing/spans/flamegraphs and such

scuffle-pprof

Helper crate for adding pprof support to your application

tcp-echo-benchmark

A high-performance TCP echo server benchmark tool measuring throughput using concurrent async clients. Supports configurable payload size, connection count, and test duration.

cpu-time

Small crate that provides CPU time measurement

bpu_trasher

trash the branch prediction unit

gloo-console

Convenience crate for working with browser's console

cardamon

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

farmfe_bench

Farm Bench

readings

Graph vital metrics process logging

china-id

一个中国身份证号码解析库

estra

tui for diol

legion_prof

Legion Prof: a profiler for Legion

tracing-flame

Tracing layer for creating flamegraphs from span timings

cpumap

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

cmsketch

A count min sketch implementation in Rust

top-type-sizes

Makes -Zprint-type-size more useful

koute/bytehound-gather

A memory profiler for Linux

shuffling-allocator

A shuffling allocator, randomizing heap object locations; useful for avoiding accidental cache locality during benchmarking, which can obscure performance evaluation

many_cpus_benchmarking

Criterion benchmark harness to easily compare different processor configurations

madeleine

Transparent object persistence with predefined operations and state containers

puffin_http

TCP server/client for puffin profiler data

kcr_opentelemetry_io

Kubernetes Custom Resource Bindings

devtimer

benchmarking code

trace-err

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

nvbit-model

NVIDIA NVBIT models for serialization and deserialization

tracy-rs

Rust bindings for the tracy realtime profiler

resource-meter

A lightweight resource usage measurement library for Rust, providing scoped measurement of wall-clock time, user CPU time, and system CPU time

smt-scope

parsing and analysing SMT traces

coveralls

Send job to Coveralls (coveralls.io)

ambient_profiling

very thin abstraction over other profiler crates

rd-hashd

Latency-sensitive pseudo workload for resctl-demo

efficiency-benchmark

benchmarking tool for measuring the efficiency of your laptop

microbench

A micro-benchmarking library

cloud_profiler_rust

Google Cloud Profiler Rust Agent

flaregun

Tracing and monitoring tools for Linux

optick

Super Lightweight Performance Profiler

macrotime

efficient timing

wind_tunnel_core

Core components for Wind Tunnel

mq-workload-generator

testing the performance of Apache RocketMQ and Apache Kafka

flamelens

Flamegraph viewer in the terminal

lading-capture

load testing daemons

perf_monitor

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

divan-macros

Macros for Divan, a statistically-comfy benchmarking library

codspeed-criterion-compat-walltime

Statistics-driven micro-benchmarking library

benchmark-rs

Benchmarks for Rust libraries

benchers

Bencher for Rust

mntime

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

rust_hawktracer

Rust bindings for hawktracer profiling library

aad

Automatic adjoint differentiation library

cn-font-utils

utils of cn-font-split

custom-labels

Custom labels for profilers

perf-event-data

Types and traits for parsing records emitted by perf_event_open

fast-bernoulli

Efficient sampling with uniform probability

autoperf

Automate the recording and instrumentation of programs with performance counters

workflow-perf-monitor

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

cpuprofiler

Bindings to google's cpu profiler

alumet

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

xi-trace

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

timbal

Instrumentations for functions, and more

rs_tracing

trace events in the trace event format

batched

rust macro util for batching expensive operations

feldera-size-of

measuring the total memory usage of an object

latency_trace

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

cargo-criterion

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

ppd

Interact with power-profiles-daemon with Rust

slow_function_warning

macro that prints a warning if a function takes longer than expected

gperftools

Bindings to google's gperftools

weggli

fast and robust semantic search tool for C and C++ codebases. It is designed to help security researchers identify interesting functionality in large codebases.

rspack_plugin_progress

rspack progress plugin

tracing-datadog-macros

Collection of convenience macros to use with Datadog tracing

unity_native

A Rustified wrapper around the Unity Native Plugin API

trace-time

Easily trace time to execute a scope

tempus_fugit

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

carrot_utils

Utils library

benchmark

A high-precision Rust benchmarking library for measuring execution time (microseconds), memory usage, and other performance metrics. Ideal for profiling and optimizing Rust code.

benchie

A benchmarking tool

wind_tunnel_runner

The Wind Tunnel runner

zeknox_p2

ZEro KNOwledge Xcelerated (accelerated ZKP) compatible with 0xPolygonZero/plonky2

howlong

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

embedded-profiling

Profiling for no-std embedded targets

koute/bytehound-cli

A memory profiler for Linux

usereport-rs

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

coarse-prof

Tiny library for coarse-grained hierarchical profiling

performance_measure

measuring the performance of Rust code

profi

Scope-based single and multithreaded profiling

profserve

HTTP-Enabled Profiling for Rust

lightswitch-object

Deals with object files

datadog-statsd

A dogstatsd client for rust

wtf

A frame-based profiling crate

scopetime

log runtime of arbitrary scope

loates

load testing framework, with focus on ease of use and flexiblity

scaling

A lightweight benchmarking library that measures scaling behavior

tracing-span-tree

tracing subscriber for hierarchical profiling

perfcnt

configure and read hardware performance counters in rust

calliper

Fine-grained benchmarking made easy

iai-callgrind-runner

Binary package needed by the iai-callgrind library

microprofile

small library for profiling and optimizing multithreaded programs

cargo-options-serializable

Reusable common Cargo command line options

venator-app

A log and trace viewer for Rust tracing and OpenTelemetry

codspeed-divan-compat-walltime

A temporary compatibility layer for CodSpeed to use Divan's walltime entrypoint

energy-bench

Methods for benchmarking the energy consumption of programs

cbdr

Tools for comparitive benchmarking

perfmon

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

moneta_fn

A set of macros to function profiling

trawler

A workload generator that emulates the traffic to lobste.rs

function_benchmarker

A proc macro for benchmarking Rust code

benchman

A benchmark tool that focuses on one-shot benchmark

pyroscope-rbspy-oncpu

Sampling CPU profiler for Ruby

exponential-histogram

Auto-scaling approximate histogram

breezy-timer

Painless and production friendly timers

axum-server-timings

Simplify adding the server-timings header to your Axum applications

rftrace-frontend

Rftracer frontend for writing uftrace compatible traces

ittapi-sys

Rust bindings for ittapi

nvbit-io

NVIDIA NVBIT streaming encoder and decoder implementations using serde

marsupial

safe bindings to the xkcp/k12 implementation of the kangarootwelve hash function

spirit-dipstick

Automatic configuration of dipstick backends

rvv-vroom

Hand tuned RISC-V vector instruction inner loops

codspeed-divan-compat

Divan compatibility layer for CodSpeed

qbsdiff_test_bench_utils

private utilities of the qbsdiff crate for tests and benchmarks

rspack_plugin_remove_empty_chunks

rspack remove emty chunks plugin

t-cmd

CLI utility to measure CPU time and RSS of a process

tracing-bunyan-formatter

A Bunyan formatter for the tracing crate

llvm-mca

Macros for generating llvm-mca marker comments

profl

timings profiler

timedilator-2

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

kcr_telemetry_istio_io

Kubernetes Custom Resource Bindings

tracing-timing

Inter-event timing metrics on top of tracing

update_rate

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

newrelic-unofficial

New Relic instrumentation in pure Rust

mappings

Get the mappings of a process (currently only on Linux)

lading

load testing daemons

metrics-catalogue

Metrics Catalogue

gimbal

Gimball package

triglyceride

realtime event loop profiler with egui ui

prometheus

instrumentation library for Rust applications

performance-mark-impl

performance_mark is an attribute macro that adds performance (time) logging to methods. This crate is implementation detail, you should depend on performance-mark-attribute instead.

tracy_full

Fully featured bindings for the Tracy profiler

pdc-core

A network load testing library

coz-temporary

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

scope_timer

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

vignette

A sampling profiler as a library. Particularly oriented towards shipping software where symbols need to be hydrated later.

maelstrom-common

boilerplate abstraction for running a Maelstrom node

tracing-perf

Performance and time reporting for tracing

lightswitch-proto

Protocol buffers wrappers for use in profiling tools

wind_tunnel_instruments

Instruments for measuring performance with Wind Tunnel

intel-seapi

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

harness-probe-perf

harness probe for reporting linux perf-event counter values

tracing-opentelemetry

OpenTelemetry integration for tracing

quanta

high-speed timing library

ianaio-console

Convenience crate for working with browser's console

tele_codegen

A CSS code generator that generates CSS code from the AST generated by tele_parser

critcmp

A command line utility for comparing benchmark data generated by Criterion

criterion-table

Generate markdown comparison tables from cargo-criterion benchmark output

mm0_deepsize

MM0 port of deepsize crate

mbench

easy to use microbenchmark macro. Zero deps.

observability

Experimental tracing ideas

memoria

Memory allocation tracker. A bad memory profiler for production.

crate-race

Comparing Rust crate function speeds

cortex-m-microclock

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

tracing-coz

Bridge between the Coz profiler and rust tracing

pew

A benchmarking library for Rust based on google/benchmark

petr-profiling

tools for profiling the performance of the petr compiler

gbenchmark

A benchmark library for Rust with inspiration from Go benchmarking

ppk2

A driver for Nordic's Power Profiler Kit 2

malory

benchmark Async Functions (Futures)

pibench-parser

parser to parse the text output from pibench

criterion-perf-events

Measure perf events for criterion

lcov-diff

get deltas of lcov coverage files

tracing-perfetto

Tracing layer for recording spans and events as perfetto event format

performance-mark-attribute

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

persil

minimal and simple profiling library based on measureme

poee

Functions for efficient development

wrk-api-bench

perform HTTP benchmarks using wrk and produce useful performance regression information

metered

Fast, ergonomic metrics for Rust!

lucky_commit

Make your git commits lucky!

might_sleep

limit cpu usage by estimating sleep time

virust

'benchmarking' tool or software that allows you to fill the desired amount of memory with random values, to see how your computer performs with limited RAM

libipt

The Intel Processor Trace (Intel PT) Decoder Library is Intel's reference implementation for decoding Intel PT

devtools-core

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

goku

HTTP load testing application written in Rust

tokio-metrics

Runtime and task level metrics for Tokio applications

sightglass

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

mem_println

Shortcuts for debugging the size of value in bytes

hermes_bench

benchmark suite generator in Rust

traceon

An easy to use log and tracing formatter with a flattened json or pretty output

lttng-ust

Semi-automatically generate lttng-ust tracepoints (client code)

likwid-marker

Bindings for the LIKWID marker API

cargo-profile

Cargo subcommand to profile performance

tracers

Generates very low overhead native trace points using stable Rust

trackingalloc

fast tracking allocator

cargo-llvm-codecov-converter

conversion utility from llvm-cov format to codecov format

tracing-opentelemetry-instrumentation-sdk

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

wegglix

weggli is a fast and robust semantic search tool for C and C++ codebases. It is designed to help security researchers identify interesting functionality in large codebases.

downtown

A realtime BPF profiler

hermit_bench_output

interface to the hermit-bench benchmarking framework

opentelemetry-application-insights

OpenTelemetry exporter for Azure Application Insights

rprofiler

profiling your code with HTML reports as result

gloo-console-timer

Convenience crate for working with JavaScript timers

callgrind

rtm-yaml

Rust Type Mapper (RTM) crate rtm-yaml

ark-algebra-bench-templates

A benchmark library for finite fields and elliptic curves

easytiming

easy timing functions, code blocks, etc

serde-bench

Minimal serialization format for benchmarking Serde

zoomies

An asynchronous DogStatsD client

otlp-sigv4-client

AWS SigV4 authentication client for OpenTelemetry

diol-cbind

benchmark lib

big_o

Infers asymptotic computational complexity

venator-engine

The core functionality that drives the Venator app

tracing-chrometrace

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

screeps-profiler

WASM profiling helper libarary for Screeps

kvbench

A key-value store benchmark framework with customizable workloads

mybench

(and very primitive) benchmarking macro

bench-rs

A benchmark library

webbundle-bench

WebBundle Bench

lief

Official Rust bindings for LIEF

hypcmp

Extension to run hyperfine with toml files w/ commit switches

loadem

Command line tool for emulating web load from thousands of clients

async-instrumenter

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

nvbit-build

Build-time helpers for compiling NVIDIA NVBIT instrumentation

cargo-instruments

Profile binary targets on macOS using Xcode Instruments

autometrics

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

switchy_telemetry

Switchy telemetry package

llvm_profparser

Parsing and interpretation of llvm coverage profiles and generated data

twiggy

code size profiler

jeep-train-prelude

prelude for jeep train

cadence

An extensible Statsd client for Rust

superluminal-perf-sys

Superluminal Performance C API bindings

partial-callgrind

Callgrind client requests in Rust

holochain_client_instrumented

An instrumented wrapper around the holochain_client

codspeed-bencher-compat

Bencher compatibility layer for CodSpeed

bench_timer

bench library for rust

hamming-bitwise-fast

A fast, zero-dependency implementation of bitwise Hamming Distance using a method amenable to auto-vectorization

crust-trust

An outstanding Rust crate to manage workspaces with optimal crate handling

hala-pprof

Hala performance profiling toolkit

exec_duration

Stupid and easy to use Rust code instrumentalization library

profiling-procmacros

very thin abstraction over other profiler crates

hyperwood

open-source system for crafting furniture from simple wooden slats

tracing-wasm

tracing subscriber for browser WASM

tracing-durations-export

Record and visualize parallelism of tracing spans

tracelogging

TraceLogging for Rust

gimli

reading and writing the DWARF debugging format

pyroscope-cli

Pyroscope Profiler CLI

criterion-polyglot

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

prom-timer

RAII Prometheus Timer for monitoring & tracing

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.

opentelemetry

API for Rust

rftrace-frontend-ffi

Default rftracer frontend as a static library so it can be called from C code

datafusion-tracing

DataFusion tracing of execution plans

loggix

A powerful, structured logging library for Rust inspired by Logrus. Features thread-safe logging, structured fields, custom formatters, and beautiful terminal output.

wasm-tracing

Tracing subscriber for WebAssembly. Maintained fork of tracing-wasm.

ipp-sys

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

tracing-serde-structured

An alternative, structured, compatibility layer for serializing trace data with serde

prime_bench

A prime finding benchmarking tool

benchme

Macros to easily / cleanly benchmark code blocks

eventheader_dynamic

Rust API for runtime-specified eventheader-encoded Linux Tracepoints via user_events

stainless

Organized, flexible testing framework

exonum_flamer

a procedural macro to insert flame::start_guard(_) calls

redox-kprofiling

Conversion tool from Redox kernel profiling data into perf script

tsc-trace

low overhead tracing of rust code using time stamp counter (x86 rdtsc)

logwise

an opinionated logging library for Rust