Projects sharing features with Py Spy

Samply is a cross-platform CPU sampling profiler and performance analysis utility. It consists of a command-line tool for recording process stack traces at regular intervals and a visual interface for analyzing the resulting execution data. The system includes a debug symbol resolver that maps raw memory addresses to human-readable function names using local or remote symbol information. It transforms recorded execution data into flame graphs and timelines to pinpoint function-level hotspots. The tool provides capabilities for CPU execution recording, stack unwinding, and symbol resolution a

xCrash is an Android crash reporting SDK and diagnostic tool designed to monitor application health. It captures Java exceptions, native C/C++ crashes, and application not responding events without requiring root or system permissions. The system generates diagnostic tombstones that include process memory, file descriptors, and network statistics. It utilizes a unified pipeline to handle both JVM exceptions and native signal failures, providing thread-state snapshotting and register states for analysis. The toolset includes capabilities for thread dump filtering via regular expressions to re

Pwntools is a Python-based framework designed for rapid prototyping and automation in binary exploitation, reverse engineering, and security research. It serves as a comprehensive toolkit for interacting with local and remote processes, providing the primitives necessary to manage complex exploit workflows and streamline security analysis tasks. The framework distinguishes itself through its specialized capabilities for binary manipulation and automated exploit construction. It includes dedicated utilities for parsing executable file formats, assembling and disassembling machine code, and gen

backward-cpp is a C++ stack trace library and debugging utility designed to capture, resolve, and print detailed execution traces and crash reports. It functions as a crash reporter and call stack printer that translates raw memory addresses into human-readable function names, filenames, and line numbers. The project provides automated crash reporting by registering system handlers for fatal errors, such as segmentation faults, to automatically generate execution traces upon program failure. It distinguishes itself by extracting source file fragments from disk to display specific lines of cod

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

Delve is a command-line debugger designed for programs written in the Go programming language. It provides an interactive interface for runtime analysis, allowing developers to control program execution, inspect memory and variable states, and navigate call stacks to identify logic errors. The tool distinguishes itself through deep integration with the Go runtime, specifically by providing goroutine-aware stack unwinding and the ability to manage concurrent execution threads. It utilizes a client-server protocol to decouple the debugger engine from the user interface, enabling both local and

He is like Batman, but for Node.js stack traces

Icecream is a Python debugging utility designed for inspecting variable values and execution flow during development. It provides a variable inspector that automatically labels values and attaches file and line number metadata to each output. The tool features a builtins injector that adds debugging functions to the global namespace, allowing for universal access across all project files without manual imports. It also includes an inline debugging tool that returns its arguments to the caller, enabling the insertion of inspection calls directly into active expressions without altering program

Integration of IPython pdb

Full-screen console debugger for Python

A toolbar overlay for debugging Flask applications

Debugging manhole for python applications.

django-debug-toolbar is a developer tool that provides a browser-based set of diagnostic panels for inspecting HTTP requests and responses within a Django web application. It serves as a server-side diagnostics tool and web framework development suite, allowing developers to profile and inspect request-response cycles. The tool focuses on Django application troubleshooting, database optimization, and general web development. It enables the analysis of SQL queries and database performance to identify slow calls and reduce the number of requests per page. The software includes capabilities for

Hunter is a flexible code tracing toolkit.

An lldb plugin for Node.js and V8, which enables inspection of JavaScript states for insights into Node.js processes and their core dumps.

Laravel Debugbar is a web-based debugging toolbar and application profiler for Laravel. It provides a visual interface to inspect database queries, logs, and performance metrics in real time to identify and resolve bugs during development. The tool features a database query monitor to capture SQL statements and timings, as well as a request inspector for analyzing route metadata, loaded views, and HTTP request data. It includes a profiler for measuring execution time and memory usage to identify bottlenecks in the request lifecycle. Its observability capabilities cover exception capture, app

VizTracer is a Python runtime instrumentation system and execution profiler used to trace and visualize code execution. It functions as a multi-process performance analyzer and trace visualizer, providing an interactive timeline and flamegraph interface to identify performance bottlenecks and analyze call sequences. The project distinguishes itself by its ability to aggregate execution data from multiple threads, subprocesses, and asynchronous tasks into a single unified report. It also features live process instrumentation, allowing users to attach to and detach from running Python applicati

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

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

This project is a performance analysis suite for Python applications, providing tools for both application-wide profiling and granular code benchmarking. It enables developers to identify execution bottlenecks and measure function call frequency through a combination of deterministic tracing and statistical sampling methods. The tool distinguishes itself by offering a terminal-based interactive interface that allows for real-time navigation and filtering of complex call stacks. It supports non-intrusive data collection through signal-based process interception, enabling performance monitoring

System Informer is a diagnostic utility designed for the monitoring and management of Windows system components. It provides comprehensive visibility into process execution, system services, and hardware resource utilization, allowing users to track real-time performance metrics and analyze active system activity. The software distinguishes itself through deep integration with the operating system, utilizing kernel-mode driver interfacing to access low-level data and perform administrative actions. It features a plugin-based architecture that allows for the integration of external modules to

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

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

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

pwndbg is a GDB plugin and binary analysis framework designed for reverse engineering, exploit development, and low-level program analysis. It extends the core functionality of the debugger to provide advanced memory inspection and automation tools. The project distinguishes itself with specialized capabilities for heap analysis across glibc, jemalloc, and musl, as well as a comprehensive kernel debugging toolkit for inspecting Linux kernel tasks and slab allocators. It includes an integrated ROP gadget searcher for constructing exploit chains and an LLM-powered debugging assistant that provi

vtop is a terminal system monitor and interactive process manager that provides a real-time command line dashboard for tracking system resources. It displays CPU and memory activity through graphical charts and process lists. The tool features a customizable interface that supports predefined and custom visual theme files. It allows for the identification and termination of active system tasks and process groups using keyboard and mouse support.

This project is a performance analysis tool for Ruby applications using the Rack interface. It monitors request execution times and resource usage, serving as a profiler for web applications to measure latency and identify bottlenecks. The tool provides specific analyzers for database query performance, memory allocations, and garbage collection statistics. It generates call stack flamegraphs to visualize time distribution across methods and renders speed badges and timing metrics directly onto HTML pages. The system covers broader performance profiling capabilities including custom code blo