# Memory profilers

> AI-ranked search results for `memory profilers` on awesome-repositories.com — ordered by an LLM for relevance, best match first. 114 total matches; showing the top 30.

Explore on the web: https://awesome-repositories.com/q/memory-profilers

**Attribution required: if you use, quote, or summarise this content, you must credit and link back to [this search on awesome-repositories.com](https://awesome-repositories.com/q/memory-profilers).**

## Results

- [bloomberg/memray](https://awesome-repositories.com/repository/bloomberg-memray.md) (14,885 ⭐) — Memray is a memory profiler for Python that tracks heap allocations in both Python code and native C or C++ extensions. It captures memory events by hooking into the language runtime and traversing call stacks, providing a comprehensive view of how an application consumes memory. The tool is designed to minimize performance impact on the target application by using thread-local buffering and streaming data to an external process or file.

The project distinguishes itself through its ability to monitor complex, multi-threaded systems and child processes in real-time. It provides diagnostic util
- [microsoft/perfview](https://awesome-repositories.com/repository/microsoft-perfview.md) (4,633 ⭐) — PerfView is a set of integrated profiling and tracing tools built on Windows Event Tracing for Windows (ETW), designed to diagnose CPU, memory, and ETW-based performance issues in .NET applications. It captures ETW events to analyze runtime behavior, CPU usage, and memory allocations, serving as a .NET performance profiler that measures both CPU time and garbage collection events.

The tool distinguishes itself with a diff comparison engine that compares two performance traces side-by-side to highlight changes in method costs and event rates. It renders profiled call stacks as flame graphs whe
- [kde/heaptrack](https://awesome-repositories.com/repository/kde-heaptrack.md) (4,107 ⭐) — Heaptrack is a heap memory profiler and diagnostic tool for applications running on Linux. It functions as a memory leak detector and performance analysis system that records heap allocations and stack traces to identify memory hotspots and consumption patterns.

The project provides a graphical heap allocation visualizer for exploring memory usage through tree views and peak memory reports. It utilizes flame graphs and allocation charts to visualize memory hotspots and assist in the detection of leaks.

The toolset includes capabilities for heap memory allocation tracing and the generation of
- [clinicjs/node-clinic](https://awesome-repositories.com/repository/clinicjs-node-clinic.md) (5,948 ⭐) — Node-clinic is a performance profiling suite for Node.js designed to diagnose CPU bottlenecks, memory leaks, and asynchronous event loop issues. It provides specialized diagnostic tools for visualizing asynchronous flows, generating CPU flame graphs, and analyzing heap memory allocation.

The suite includes a CPU flame graph tool to identify functions consuming the most processing time, a heap memory analyzer to track object allocation and leaks, and an asynchronous I/O profiler to map operation flows and find event loop bottlenecks.

These tools cover broader capabilities in CPU execution pro
- [bytedance/memory-leak-detector](https://awesome-repositories.com/repository/bytedance-memory-leak-detector.md) (1,189 ⭐) — 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
- [gperftools/gperftools](https://awesome-repositories.com/repository/gperftools-gperftools.md) (8,959 ⭐) — 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
- [google/orbit](https://awesome-repositories.com/repository/google-orbit.md) (4,316 ⭐) — Orbit is a set of specialized tools for C and C++ performance profiling, binary symbol mapping, and remote process and thread analysis. It provides a system for analyzing execution time and resource usage, utilizing a call graph visualizer to map function entries and exits into hierarchical execution flows for individual threads.

The project distinguishes itself with a remote process profiler capable of capturing performance data from applications running on remote hosts. It also includes a thread scheduling analyzer that tracks context switches and processor core utilization to visualize thr
- [facebook/memlab](https://awesome-repositories.com/repository/facebook-memlab.md) (4,981 ⭐) — Memlab is an automated browser memory profiler and JavaScript memory leak analyzer. It provides a toolkit for detecting and analyzing memory leaks by inspecting and comparing heap snapshots to identify unbound object growth and detached DOM elements.

The system distinguishes itself through an automated leak testing framework that executes end-to-end browser interaction sequences to programmatically isolate memory regressions. It utilizes heap snapshot diffing, retainer chain tracing, and heuristic-based filtering to determine why objects remain in memory and to map the shortest path from garb
- [samsaffron/memory_profiler](https://awesome-repositories.com/repository/samsaffron-memory-profiler.md) (1,765 ⭐) — 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
- [nolanlawson/fuite](https://awesome-repositories.com/repository/nolanlawson-fuite.md) (4,625 ⭐) — 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
- [nvdv/vprof](https://awesome-repositories.com/repository/nvdv-vprof.md) (3,979 ⭐) — vprof is a visual profiling tool for Python designed to identify execution bottlenecks and monitor memory consumption. It functions as a CPU and memory profiler that transforms performance data into interactive visualizations to analyze processor time and call stacks.

The project distinguishes itself through a suite of visual diagnostics, including flame graphs for stack visualization and heatmaps that map execution frequency and duration directly onto source code. It also includes a remote performance monitor capable of capturing function-specific metrics from a running server and streaming
- [tencent/mleaksfinder](https://awesome-repositories.com/repository/tencent-mleaksfinder.md) (5,437 ⭐) — MLeaksFinder is a diagnostic framework and profiling utility designed for the automatic detection of memory leaks and unfreed objects in iOS applications. It functions as a memory leak detector and profiling tool that identifies retain cycles and analyzes object lifecycles for both Swift and Objective-C code.

The tool identifies circular dependencies by tracing reference chains and traversing object graphs, starting from a root view controller. It provides precise debugging data by capturing the allocation stacks of leaked objects to trace the origin of the memory leak.

The framework include
- [plasma-umass/scalene](https://awesome-repositories.com/repository/plasma-umass-scalene.md) (13,449 ⭐) — Scalene is a high-performance diagnostic utility designed to measure resource consumption during the execution of Python applications. It functions as a line-level monitor, providing granular insights that pinpoint the specific source code responsible for performance overhead.

The tool distinguishes itself through statistical profiling that captures stack traces and resource usage without requiring manual instrumentation of the source code. It tracks CPU, GPU, and memory consumption by intercepting library-level calls and hardware driver commands, allowing for the analysis of both managed and
- [square/leakcanary](https://awesome-repositories.com/repository/square-leakcanary.md) (29,923 ⭐) — LeakCanary is a diagnostic tool designed to identify memory leaks by monitoring object lifecycles and analyzing heap snapshots. It automatically detects objects that fail to be garbage collected after their expected lifespan, providing developers with actionable insights to prevent performance degradation and application crashes.

The project distinguishes itself by offloading memory-intensive heap parsing to a separate background process, which minimizes performance impact on the main application during runtime. It includes sophisticated deobfuscation capabilities that map obfuscated stack tr
- [mrdoob/stats.js](https://awesome-repositories.com/repository/mrdoob-stats-js.md) (9,127 ⭐) — 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
- [joerick/pyinstrument](https://awesome-repositories.com/repository/joerick-pyinstrument.md) (7,638 ⭐) — pyinstrument is a statistical sampling profiler for Python that records the call stack at regular intervals to identify performance bottlenecks with low overhead. It tracks wall-clock time, including I/O and external service calls, and provides specialized profiling for asynchronous programs by attributing time spent awaiting tasks to the calling function.

The project converts captured execution data into interactive HTML reports, JSON, and flamecharts. It includes a call stack visualizer to simplify the analysis of execution paths and supports the profiling of individual cells within interac
- [pythonprofilers/memory_profiler](https://awesome-repositories.com/repository/pythonprofilers-memory-profiler.md) (4,571 ⭐) — This project is a diagnostic utility for monitoring and analyzing memory consumption in Python applications. It provides tools for tracking resource usage at the process level and performing detailed, line-by-line analysis to identify memory leaks and performance bottlenecks.

The tool distinguishes itself through its ability to aggregate memory metrics across entire process trees, capturing the total resource impact of both parent and child processes. It supports time-series visualization of memory usage over the duration of a script, allowing for the identification of long-term consumption p
- [chewiebug/gcviewer](https://awesome-repositories.com/repository/chewiebug-gcviewer.md) (4,641 ⭐) — GCViewer is a JVM garbage collection visualizer and memory analysis tool. It functions as a log parser and metrics exporter that transforms verbose JVM garbage collection logs into structured data, visual charts, and summary reports.

The project enables the visualization of heap size, generation usage, and collection timing through multi-line charts. It specifically tracks stop-the-world pause durations, concurrent collection cycles, and memory footprint to assist in detecting memory leaks and tuning heap sizes.

The tool covers log processing capabilities such as timestamp alignment and the
- [benfred/py-spy](https://awesome-repositories.com/repository/benfred-py-spy.md) (15,272 ⭐) — py-spy is a sampling profiler and process debugger for Python. It allows for the analysis of running processes to identify performance bottlenecks and diagnose hanging programs without requiring code changes or restarts.

The tool operates by reading the memory of a running process from the outside, which enables non-invasive sampling and state collection without pausing execution. It can resolve binary symbols to capture performance data from native extensions written in compiled languages and generate visual flame graphs for both native extensions and subprocesses.

The project provides capa
- [facebook/fbretaincycledetector](https://awesome-repositories.com/repository/facebook-fbretaincycledetector.md) (4,233 ⭐) — FBRetainCycleDetector is a runtime memory profiling tool and analyzer for iOS applications. It identifies circular references and retain cycles within the Objective-C object graph to prevent memory leaks.

The tool analyzes the live memory heap and inspects runtime metadata to discover object relationships. It identifies closed-loop reference chains, including those involving associated objects and timers, and uses custom logic to filter out known safe cycles from reports.

The project covers memory management capabilities including allocation tracking by class name, runtime object graph analy
- [google/pprof](https://awesome-repositories.com/repository/google-pprof.md) (9,212 ⭐) — pprof is a tool for visualizing and analyzing performance profiling data. It converts sampled call stacks into a directed graph rendered as an SVG, enabling visual identification of execution hotspots. The tool also parses Linux perf.data files, converting them into an internal profile representation for further analysis.

Beyond visualization, pprof provides a command-line REPL for interactive exploration of profiling data, allowing users to filter, refine, and query performance information on the fly. It generates sorted text reports that highlight the most resource-intensive call stacks, an
- [richardwarburton/honest-profiler](https://awesome-repositories.com/repository/richardwarburton-honest-profiler.md) (1,253 ⭐) — honest-profiler
- [uber-common/jvm-profiler](https://awesome-repositories.com/repository/uber-common-jvm-profiler.md) (1,802 ⭐) — Uber JVM Profiler provides a Java Agent to collect various metrics and stacktraces for Hadoop/Spark JVM processes in a distributed way, for example, CPU/Memory/IO metrics.
- [vipshop/vjtools](https://awesome-repositories.com/repository/vipshop-vjtools.md) (7,636 ⭐) — vjtools is a comprehensive Java development toolset and runtime monitor designed for optimizing application performance and ensuring codebase consistency. It provides a suite of JVM diagnostics tools, a performance profiler, and a static analysis system for enforcing coding standards.

The project distinguishes itself through specialized runtime observability, including the ability to attach to processes via process ID and inject dynamic probes to monitor method calls without restarting the system. It features container-aware resource detection that reads control group files to report actual C
- [jvm-profiling-tools/async-profiler](https://awesome-repositories.com/repository/jvm-profiling-tools-async-profiler.md) (9,063 ⭐) — 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
- [alibaba/arthas](https://awesome-repositories.com/repository/alibaba-arthas.md) (37,367 ⭐) — Arthas is a Java diagnostic tool and runtime debugger designed for real-time troubleshooting of applications. It functions as a remote diagnostics agent that allows users to inspect the runtime state of a Java process, including its heap objects and classloader hierarchies, without requiring a process restart.

The project distinguishes itself through advanced bytecode manipulation capabilities, enabling live class hotswapping and the modification of bytecode in running processes. It supports in-memory source compilation and runtime bytecode decompilation to verify and update logic instantly w
- [google/sanitizers](https://awesome-repositories.com/repository/google-sanitizers.md) (12,402 ⭐) — This project is a suite of runtime diagnostic tools designed to detect memory leaks, concurrency races, and language-specification violations during software execution. It provides a collection of dynamic analysis tools that identify addressability issues, uninitialized memory usage, and memory safety bugs in applications.

The toolset includes a thread safety analyzer to identify data races and deadlocks in concurrent code, as well as an undefined behavior sanitizer to detect operations that violate language specifications.

The system covers broad capabilities in memory safety monitoring and
- [async-profiler/async-profiler](https://awesome-repositories.com/repository/async-profiler-async-profiler.md) (8,871 ⭐) — 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
- [google/perfetto](https://awesome-repositories.com/repository/google-perfetto.md) (5,558 ⭐) — Perfetto is a platform for system-level performance tracing and analysis on Linux and Android. It combines a high-throughput trace recorder, a SQL-based query engine, and a browser-based visualizer into a single toolchain. The platform covers CPU scheduling and call-stack profiling, native and Java heap memory allocation tracking, GPU and graphics events, and system-wide counters such as CPU frequency and power consumption.

The architecture decouples trace recording from offline analysis, using a compact protobuf format for event encoding and columnar storage for efficient SQL queries. The we
- [yse/easy_profiler](https://awesome-repositories.com/repository/yse-easy-profiler.md) (2,360 ⭐) — Easy Profiler is a performance profiling library for C++ applications designed to measure execution duration and identify bottlenecks. It provides a framework for instrumenting code blocks to track performance metrics, allowing for the analysis of thread activity and system behavior through detailed timeline visualization.

The library distinguishes itself by utilizing scope-based instrumentation to automatically track code lifecycles, minimizing manual overhead. It employs thread-local buffering and asynchronous data flushing to reduce synchronization contention, ensuring that performance dat