Open-source alternatives to BenchmarkDotNet

Async-profiler is a sampling profiler for Java applications that tracks CPU time and stack traces across execution frames to identify performance bottlenecks. It is designed to capture profiling data without introducing timing bias. The project provides capabilities for JVM memory analysis to locate native and heap allocation hotspots and memory leaks. It also includes system contention analysis to identify resource bottlenecks through the tracking of contended locks and hardware performance counters. The tool converts raw profiling data into visual performance reports, including interactive

Criterion is a statistics-driven microbenchmarking library and performance regression tool for Rust. It provides a framework for isolating and measuring small code segments, using statistical analysis to eliminate noise and ensure reliable, repeatable measurements of execution speed. The tool distinguishes itself through a performance visualization suite that generates HTML reports and graphs to track performance trends and throughput. It includes a system for comparing current execution times against stored baselines to identify and prevent performance drops. The library covers asynchronous

Memory Profiler is a diagnostic library for Ruby applications designed to monitor runtime memory consumption and object lifecycles. It provides tools to track object allocations and memory usage, enabling the identification of performance bottlenecks and potential memory leaks that affect software stability. The tool functions by observing memory behavior during program execution, allowing developers to distinguish between short-lived data and objects that persist beyond their intended lifecycle. It captures the execution context of allocations by walking the call stack, which helps attribute

Async-profiler is a suite of performance tools designed for sampling Java runtimes, tracking memory allocations, and monitoring hardware counters. It functions as a low-overhead sampling profiler for Java applications, collecting stack traces and memory allocation data without safepoint bias. The project provides specialized utilities for generating interactive flame graphs to visualize execution hotspots in a web browser. It includes a hardware performance counter monitor to track low-level system events such as cache misses and page faults. The toolset covers several diagnostic domains, in

This project is a suite of analytical tools for quantifying web performance, specifically designed for benchmarking the rendering speed and memory usage of various JavaScript frameworks. It provides a standardized set of DOM manipulation tests and a comparison tool that uses weighted geometric means to measure efficiency across different web implementations. The benchmark harness distinguishes itself by providing deep analysis of DOM reconciliation strategies, comparing the performance and correctness of keyed versus non-keyed rendering. It also includes a memory profiler for tracking allocat

Scientist is a Ruby code parity testing library and production experimentation framework. It allows for the safe deployment of candidate code paths alongside a control implementation to verify that new logic produces the same outputs and exceptions as the original. The library identifies behavioral divergences between legacy and refactored code by running both versions in a live environment. It functions as a refactoring regression detector, measuring performance parity and detecting mismatches using real-world data without affecting the end user. The system covers broad capabilities for mon

Matrix is a suite of mobile application performance management and analysis tools. It provides a plugin-based monitoring system for capturing crashes, lags, and memory leaks, alongside a static binary auditor for reducing installation package size and a bytecode instrumentation tool for performance tracking. The project distinguishes itself through native memory debugging and a SQLite query linter that identifies inefficient database patterns. It employs native interception techniques to detect memory leaks and heap corruption without requiring source code recompilation, and uses a custom run

Firefox is a cross-platform web browser engine designed to render web content, execute JavaScript, and manage secure browsing sessions. It utilizes a multi-process isolation architecture that distributes browser tasks across independent operating system processes to ensure stability and prevent site-specific failures from impacting the entire application. The engine incorporates a sandboxed execution environment to restrict web content and untrusted scripts to isolated memory compartments, enforcing security policies that prevent unauthorized access to system resources. The project distinguis

FlameGraph is a performance profiling and visualization toolkit designed to identify bottlenecks in software execution. It functions as a processing engine that transforms raw stack trace samples into interactive, hierarchical diagrams. By representing aggregated execution frequency as nested rectangles, the tool allows developers to visualize hot code paths and analyze system behavior across both kernel and user-space environments. The project distinguishes itself through its ability to perform differential profile analysis, which highlights performance regressions or improvements by compari

MicroPython is a lean implementation of Python 3 optimized to run on microcontrollers and other resource-constrained systems. It serves as a cross-platform embedded runtime and hardware abstraction layer, providing a firmware framework that maps high-level software commands to specific microcontroller registers across diverse processor architectures. The project functions as an embedded language interpreter that enables rapid prototyping on hardware through an interactive read-eval-print loop. It supports a wide range of target environments, including ARM, ESP32, STM32, RISC-V, and WebAssembl

This project is a collection of diagnostic tools designed for auditing IP quality, analyzing network stability, profiling server environments, and benchmarking hardware performance. It provides a suite of utilities to evaluate virtual private servers through hardware performance benchmarking and system environment diagnostics. The toolset includes a streaming service unlock checker to determine regional content access, an IP reputation audit tool for blacklist and geolocation verification, and a network quality analyzer for measuring latency and throughput. It covers broader capability areas

This project is a diagnostic tool and memory profiler designed to identify and track memory allocation patterns within native code layers. It functions as a native code debugging utility that monitors heap usage and resource lifecycle management to assist in the resolution of memory leaks and resource exhaustion issues. The tool utilizes hook-based allocation interception to maintain a real-time map of active memory blocks and employs shadow-stack call tracing to associate these blocks with specific code locations. By performing periodic reachability analysis and differential memory snapshott

Grafika is a collection of reference implementations and benchmarking tools for the Android platform. It provides technical demonstrations for validating camera lifecycles, GPU performance, and media codec configurations, including a suite of OpenGL ES examples and a graphics reference application. The project distinguishes itself through specialized tools for measuring graphics performance, such as benchmarks for texture upload speeds and pixel read latency. It also implements specific hardware-focused patterns, such as using circular buffers for continuous video capture and utilizing virtua

Bytehound is a Linux memory profiler that utilizes a custom global allocator to intercept memory requests and track allocations and deallocations. It records full call-stack traces for every memory operation to map allocations back to their originating source code. The project features a remote memory profiling system that streams capture data via network sockets to a separate machine, minimizing resource overhead on the target system. Analysis is supported by a specialized domain-specific query language used to automate the detection of memory patterns and anomalies. The tool covers heap al

pi-autoresearch is an autonomous research extension that automates iterative code-editing and performance-measurement loops driven by large language models. It functions as an experiment lifecycle automator, executing repetitive cycles of changes and benchmarks until a specific goal is reached. The system distinguishes itself by organizing successful experimental trials into independent git branches for review and merging. It includes a real-time research dashboard for monitoring metrics and status, and utilizes median absolute deviation to calculate confidence scores that filter benchmark no

Catch2 is a comprehensive framework for C++ software validation, providing an environment for unit testing, integration verification, and performance analysis. It enables developers to define and execute automated test suites and micro-benchmarks directly within their applications. The framework is distinguished by its header-only distribution, which allows for integration into existing build systems without requiring complex external dependencies. It utilizes a hierarchical section-based execution model that supports behavior-driven testing, allowing for shared setup and teardown logic acros

Ghidra is a software reverse engineering suite designed to analyze compiled binaries and reconstruct program logic without access to original source code. It provides an interactive environment for disassembly and decompilation, utilizing a platform-independent intermediate representation to maintain consistency across diverse hardware architectures. The framework supports automated binary analysis through programmatic routines, enabling the investigation of complex code patterns and security indicators. The platform distinguishes itself through a modular architecture that allows for extensiv

gperftools is a collection of specialized tools for profiling CPU usage, detecting memory errors, and providing high-performance memory allocation. It provides a memory profiling toolkit for C++ applications, including a sampling CPU profiler and a heap profiler for analyzing consumption patterns. The project includes a high-performance memory allocator designed as a multi-threaded replacement for standard allocation to reduce contention and improve execution speed. It further provides a memory debugger to identify illegal memory access and double frees. The toolkit covers broad diagnostic c

Fuite is a web application memory leak detector and browser heap snapshot analyzer. It functions as an automated interaction tester that monitors heap growth during repeated browser sequences to identify leaking DOM nodes and collections. The tool differentiates itself by executing scripted interaction loops to amplify memory growth, making leaks easier to detect. It captures and compares heap snapshots across different timestamps and exports detailed reports containing stack traces and the specific code locations where listeners were declared. The project covers browser automation and orche

This project is a performance measurement framework and microbenchmarking library designed for C++ and Python. It provides a toolset for measuring the execution time of small code fragments using high-resolution timers, calculating statistical aggregates, and analyzing asymptotic complexity. The framework distinguishes itself through specialized capabilities for multithreaded performance testing, using synchronized execution to measure parallel throughput. It includes mechanisms to prevent compiler optimizations from removing benchmarked code and supports complex parameterization via Cartesia

stats.js is a JavaScript performance monitor and visual diagnostic tool. It provides a real-time overlay for tracking frame rates, memory allocation, and the rendering efficiency of web graphics and applications. The project includes a visual meter for measuring frames per second and a browser memory profiler that displays allocated memory in megabytes to help detect resource leaks. It is designed as a web graphics debugger to monitor the efficiency of WebGL and Canvas rendering. The tool covers a range of monitoring and observability capabilities, including the creation of custom performanc

This project is a comprehensive performance programming guide and reference for the Go language, focusing on runtime efficiency and memory optimization. It provides a collection of patterns and techniques designed to increase execution speed by reducing garbage collection overhead and optimizing memory usage. The resource distinguishes itself through detailed reference implementations for memory optimization, such as escape analysis, object pooling, and structure memory alignment. It offers specific strategies for reducing binary size and improving CPU cache efficiency through structure memor

Optimize-js is a JavaScript parsing optimizer designed to reduce the time browsers spend pre-parsing scripts to improve initial execution speed. It transforms source code to minimize the overhead associated with browser parsing. The project implements a technique that wraps function calls in parentheses to bypass initial pre-parsing and reduce double-parsing overhead. To maintain the utility of the transformed code, it includes a source map generator that links the optimized output back to the original source. The toolset also includes performance benchmarking capabilities to measure the exa

Catch is a C++ testing toolset providing frameworks for unit testing, behavior-driven development, and micro-benchmarking. It serves as a utility for software quality assurance and test-driven development, allowing developers to validate code correctness and measure the execution time of small code fragments. The project features a header-only distribution, enabling integration by including a single file. It utilizes expression-decomposition assertions to provide detailed failure messages and employs a self-registering test discovery system that uses macros to register test cases without manu

rustls is a memory-safe implementation of the Transport Layer Security protocol written in Rust. It provides a cryptographic stack for secure network communication, supporting both TLS 1.3 and 1.2 standards for client and server implementations. The project is designed as a modular cryptographic library that allows swapping underlying cryptographic backends and primitive providers to meet specific security or performance requirements. It incorporates a post-quantum cryptography stack, utilizing hybrid key exchanges and signatures to protect data against future quantum computing threats. The

This project provides a suite of diagnostic and validation utilities for container runtimes that implement the Kubernetes Container Runtime Interface. It serves as a command-line interface for interacting with and managing container lifecycles, images, and sandboxes directly on a host machine without requiring a full cluster deployment. The toolset distinguishes itself through its focus on interface compliance and performance verification. It includes automated test suites that validate whether a runtime adheres to defined interface specifications and handles resource plugin integration corre

TensorFlow.js is a JavaScript machine learning library used for training and deploying models in web browsers and server-side environments. It functions as a browser-based model trainer, a WebAssembly inference engine, and a WebGPU accelerated tensor library for low-level linear algebra. The project also includes a model converter to transform Python-based models into optimized formats for JavaScript execution. The library distinguishes itself through a pluggable backend architecture that allows mathematical operations to be executed via CPU, WebGL, or WebGPU. It supports the conversion of Py