awesome-repositories.com
Blog
MCP
awesome-repositories.com

Discover the best open-source repositories with AI-powered search.

ExploreCurated searchesOpen-source alternativesSelf-hosted softwareBlogSitemap
ProjectMCP serverAboutHow we rankPress
LegalPrivacyTerms
© 2026 Bringes Technology SRL·VAT RO45896025·hello@awesome-repositories.com
KDAB avatar

KDAB/hotspot

0
View on GitHub↗
5,074 stars·287 forks·C++·25 views

Hotspot

Hotspot is a graphical user interface for analyzing and visualizing performance data captured by the Linux perf tool. It functions as a performance profiling visualizer and assembly-level profiler that maps performance costs to specific instructions synchronized with original source code.

The project distinguishes itself through a remote symbol resolver that maps performance data from embedded targets to local host debug symbols and sysroots. It also includes a specialized off-CPU analysis tool designed to identify thread wait times and I/O blocks using kernel scheduler tracepoints.

The tool covers a broad range of performance analysis capabilities, including CPU profiling, low-level code inspection, and timeline-based data filtering. It provides visualization methods such as flame graphs and call graphs to identify system bottlenecks and inlined functions.

The system supports recording data by launching profiling tools for new applications or attaching to existing processes, and allows the export of analyzed performance profiles into portable formats for cross-machine sharing.

Features

  • CPU Profilers - Provides a comprehensive workflow for recording and visualizing CPU execution patterns to identify bottlenecks in Linux applications.
  • Performance Profilers - Provides a graphical interface for measuring and analyzing execution time and resource usage to identify software bottlenecks.
  • Debug Symbol Resolvers - Resolves raw memory addresses to function names and source lines using local sysroots or remote debug symbol servers.
  • Hierarchical Performance Visualizers - Provides interactive flame graphs and call graphs to visualize hierarchical stack trace data and identify performance bottlenecks.
  • Perf Data Parsers - Parses Linux perf.data files to extract hardware counters and tracepoints for graphical visualization.
  • Assembly-Level Profilers - Functions as a specialized disassembler that maps execution costs to assembly instructions synchronized with the original source code.
  • Off-CPU Latency Analyzers - Detects I/O blocks and lock contention by tracking the time threads spend in non-running states via kernel tracepoints.
  • Binary-to-Source Mapping - Links disassembled machine instructions back to their original source code locations for detailed performance debugging.
  • Instruction-Level Cost Analysis - Determines the specific performance cost of individual assembly instructions by correlating sampled execution counts with disassembled code.
  • Remote Symbol Fetching - Automatically downloads required debug symbols from remote servers to enable symbolization of performance data.
  • Kernel Scheduler Trace-Mapping - Analyzes off-CPU time by correlating kernel scheduler tracepoints with thread states to identify blocking I/O or lock contention.
  • Low-Level Machine Code Optimizations - Enables optimization of critical paths by examining the cost of individual assembly instructions synchronized with source code.
  • Cross-Machine Symbol Resolution - Maps performance data recorded on embedded systems to local host debug symbols by specifying sysroots and paths.
  • Linux Performance Analysis - Provides a graphical interface to visualize and analyze system bottlenecks using Linux perf data.
  • Linux perf GUIs - Provides a full graphical user interface for analyzing and visualizing performance data captured by the Linux perf tool.
  • Performance Profiling Tools - Visualizes system bottlenecks using interactive flame graphs, call graphs, and timeline-based performance analysis.
  • Temporal & Process Filters - Allows updating performance data views by filtering results based on specific time ranges, processes, or threads.
  • Temporal Range Filters - Allows refining performance datasets by slicing profiles based on specific temporal windows or process IDs.
  • Embedded Systems Debugging - Supports debugging software on embedded architectures by mapping performance data to local host debug symbols.
  • Application Performance Profiling - Captures performance data by launching profiling tools for new applications or attaching to existing running processes.
  • Assembly Inspection Tools - Displays the specific cost per instruction in assembly with synchronized highlighting back to the source code.
  • Debugging And Tracing - Provides a GUI for Linux perf analysis.
  • Performance Analysis Tools - Linux perf GUI for performance analysis and visualization.

Star history

Star history chart for kdab/hotspotStar history chart for kdab/hotspot

How this analysis was created: This summary and feature list are AI-generated from collected project material and can contain mistakes. Stars, license and language are imported from GitHub. Inclusion does not mean that we have tested or audited this project. Check the source documentation for any feature you depend on. Learn more on our About page.

AI search

Explore more awesome repositories

Describe what you need in plain English — the AI ranks thousands of curated open-source projects by relevance.

Start searching with AI

Projects sharing features with Hotspot

These projects share indexed features with Hotspot. Shared tags can include platform or build tooling; verify the primary use case before treating a result as a replacement.
  • brendangregg/flamegraphbrendangregg avatar

    brendangregg/FlameGraph

    19,307View on GitHub↗

    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

    Perl
    View on GitHub↗19,307
  • microsoft/perfviewmicrosoft avatar

    microsoft/perfview

    4,633View on GitHub↗

    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

    C#dotnetdotnet-coreperformance
    View on GitHub↗4,633
  • grafana/pyroscopegrafana avatar

    grafana/pyroscope

    11,503View on GitHub↗

    Pyroscope is a continuous profiling platform designed to collect, store, and visualize application performance data. It functions as an application performance management suite that tracks historical resource usage to identify bottlenecks and detect performance regressions over time. The platform distinguishes itself through its use of kernel-level instrumentation and dynamic runtime hooks, which allow for performance monitoring without requiring manual code modifications or application restarts. It employs a sidecar agent architecture to offload telemetry processing, utilizing delta-encoded

    Gocontinuous-profilingdeveloper-toolsdevops
    View on GitHub↗11,503
  • mstange/samplymstange avatar

    mstange/samply

    4,263View on GitHub↗

    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

    Rust
    View on GitHub↗4,263
Compare all 30 related projects→

Frequently asked questions

What does kdab/hotspot do?

Hotspot is a graphical user interface for analyzing and visualizing performance data captured by the Linux perf tool. It functions as a performance profiling visualizer and assembly-level profiler that maps performance costs to specific instructions synchronized with original source code.

What are the main features of kdab/hotspot?

The main features of kdab/hotspot are: CPU Profilers, Performance Profilers, Debug Symbol Resolvers, Hierarchical Performance Visualizers, Perf Data Parsers, Assembly-Level Profilers, Off-CPU Latency Analyzers, Binary-to-Source Mapping.

Which projects share features with kdab/hotspot?

Projects with overlapping indexed features include: brendangregg/flamegraph — FlameGraph is a performance profiling and visualization toolkit designed to identify bottlenecks in software… microsoft/perfview — PerfView is a set of integrated profiling and tracing tools built on Windows Event Tracing for Windows (ETW), designed… grafana/pyroscope — Pyroscope is a continuous profiling platform designed to collect, store, and visualize application performance data.… mstange/samply — Samply is a cross-platform CPU sampling profiler and performance analysis utility. It consists of a command-line tool… wolfpld/tracy — Tracy is a real-time performance profiling framework for C and C++ applications. It provides a software… iovisor/bcc — BCC is an eBPF development toolkit and tracing framework used for monitoring and analyzing the Linux kernel. It…