Skip to content
The Linux perf GUI for performance analysis.
C++ CMake Shell Other
Branch: master
Clone or download


Type Name Latest commit message Commit time
Failed to load latest commit information.
.github/ISSUE_TEMPLATE Update issue templates May 23, 2019
3rdparty Optionally enable rustc_demangle when user sets include+lib paths May 16, 2020
cmake cmake/FindLibElf.cmake - insert full BSD license text, as required. Mar 24, 2017
screenshots Add screenshots for the record page to the README Sep 28, 2017
scripts Fix elfutils packaging in AppImage May 17, 2020
src Fix hidpi issues May 16, 2020
tests various - update copyright year Apr 1, 2020
.clang-format Add .clang-format and reformat the sources accordingly Jul 25, 2018
.clang-tidy Add .clang-tidy Nov 2, 2017
.dockerignore Add scripts to build appimage locally using docker Jan 9, 2019
.gitignore Add script to build and package rustc-demangle May 16, 2020
.gitmodules Make perfparser point to our KDAB fork on GitHub again Jun 2, 2017
.krazy various - update copyright year Mar 18, 2019
.travis.yml Update elfutils to 0.179 and enable rustc-demangle on May 17, 2020
CMakeLists.txt Increase minimum supported Qt version to 5.10 Feb 5, 2020 Create Jan 8, 2018 Create Jan 8, 2018
LICENSE.GPL.txt various - update copyright year Apr 1, 2020
LICENSE.US.txt Add license files Dec 20, 2016
LICENSE.txt various - update copyright year Apr 1, 2020 Update minimum Qt requirement in May 15, 2020
com.kdab.Hotspot.appdata.xml various - update copyright year Apr 1, 2020
hotspot-config.h.cmake various - update copyright year Apr 1, 2020
hotspot.desktop Improve the XDG desktop file Aug 15, 2019
hotspot.kdev4 Add kdevelop project file and ignore .kdev4 config dir Jan 24, 2018

Hotspot - the Linux perf GUI for performance analysis

This project is a KDAB R&D effort to create a standalone GUI for performance data. As the first goal, we want to provide a UI like KCachegrind around Linux perf. Looking ahead, we intend to support various other performance data formats under this umbrella.

Table of Contents


Here are some screenshots showing the most important features of hotspot in action:

Visualize Data

The main feature of hotspot is visualizing a file graphically.

hotspot summary page

hotspot FlameGraph page

hotspot caller-callee page

hotspot bottom-up page

hotspot top-down page

Time Line

The time line allows filtering the results by time, process or thread. The data views will update accordingly.

hotspot timeline filtering by time

hotspot timeline filtering by thread or process

hotspot timeline filtering applied to FlameGraph

Record Data

You can also launch perf from hotspot, to profile a newly started application or to attach to already running process(es). Do take the caveats below into account though.

hotspot launch application

hotspot attach to process

Building Hotspot

Required Dependencies

As of now, you will need the following dependencies to build this project:

  • CMake 3.1.0 or higher
  • any C++11 enabled compiler
  • Qt 5.10.0 or higher
  • libelf
  • libelfutils
  • gettext
  • extra-cmake-modules
  • KDE Frameworks 5 (packages are usually called libkf5-*-devel):
    • threadweaver
    • i18n
    • configwidgets
    • coreaddons
    • itemviews
    • itemmodels
    • kio
    • solid
    • windowsystem

On Debian/Ubuntu

add-apt-repository ppa:kubuntu-ppa/backports 
apt-get update
apt-get install libkf5threadweaver-dev libkf5i18n-dev libkf5configwidgets-dev \
    libkf5coreaddons-dev libkf5itemviews-dev libkf5itemmodels-dev libkf5kio-dev \
    libkf5solid-dev libkf5windowsystem-dev libelf-dev libdw-dev cmake \
    extra-cmake-modules gettext

On Fedora

dnf install cmake gcc glibc-static gcc-c++ libstdc++-static qt5 qt5-devel \
    extra-cmake-modules elfutils-devel kf5-threadweaver-devel kf5-ki18n-devel \
    kf5-kconfigwidgets-devel kf5-kitemviews-devel kf5-kitemmodels-devel \
    kf5-kio-devel kf5-solid-devel kf5-kwindowsystem-devel

Arch Linux

pacman -Sy cmake gcc extra-cmake-modules threadweaver ki18n kconfigwidgets \
    kitemviews kitemmodels kwindowsystem kio solid libelf gettext qt5-base


zypper in cmake gcc-c++ extra-cmake-modules threadweaver-devel ki18n-devel kio-devel \
    solid-devel kcoreaddons-devel threadweaver-devel kconfigwidgets-devel \
    kitemmodels-devel kitemviews-devel kwindowsystem-devel \
    libqt5-qtbase-devel libelf-devel libdw-devel gettext glibc-devel-static

Building Hotspot itself

git clone --recurse-submodules
mkdir build-hotspot
cd build-hotspot
cmake ../hotspot
# now you can run hotspot from the build folder:
# or `make install` it and launch it from your $PATH

If you need help building this project for your platform, contact us for help.

Getting Hotspot

Note: Hotspot is not packaged for most Linux distributions yet -- you'll likely have to resort to using the AppImage which will work on any recent Linux distro just fine


hotspot is available in AUR (


hotspot ebuilds are available from our overlay (


hotspot is available in Fedora repositories.

For any Linux distro: AppImage

Head over to our download page and download the latest AppImage release and just run it.

Please use the latest Continuous release to get the most recent version. If it doesn't work, please report a bug and test the latest stable version.

Note: Your system libraries or preferences are not altered. In case you'd like to remove Hotspot again, simply delete the downloaded file. Learn more about AppImage here.


First of all, record some data with perf. To get backtraces, you will need to enable the dwarf callgraph mode:

perf record --call-graph dwarf <your application>
[ perf record: Woken up 58 times to write data ]
[ perf record: Captured and wrote 14.874 MB (1865 samples) ]

Now, if you have hotspot available on the same machine, all you need to do is launch it. It will automatically open the file in the current directory (similar to perf report). Alternatively, you can specify the path to the data file on the console:

hotspot /path/to/

Embedded Systems

If you are recording on an embedded system, you will want to analyze the data on your development machine with hotspot. To do so, make sure your sysroot contains the debug information required for unwinding (see below). Then record the data on your embedded system:

embedded$ perf record --call-graph dwarf <your application>
[ perf record: Woken up 58 times to write data ]
[ perf record: Captured and wrote 14.874 MB (1865 samples) ]
embedded$ cp /proc/kallsyms /tmp/kallsyms # make pseudo-file a real file

It's OK if your embedded machine is using a different platform than your host. On your host, do the following steps then to analyze the data:

host$ scp embedded:/tmp/kallsyms .
host$ hotspot --sysroot /path/to/sysroot --kallsyms kallsyms \

If you manually deployed an application from a path outside your sysroot, do this instead:

host$ hotspot --sysroot /path/to/sysroot --kallsyms kallsyms --appPath /path/to/app \

If your application is also using libraries outside your sysroot and the appPath, do this:

host$ hotspot --sysroot /path/to/sysroot --kallsyms kallsyms --appPath /path/to/app \
              --extraLibPaths /path/to/lib1:/path/to/lib2:... \

And, worst-case, if you also use split debug files in non-standard locations, do this:

host$ hotspot --sysroot /path/to/sysroot --kallsyms kallsyms --appPath /path/to/app \
              --extraLibPaths /path/to/lib1:/path/to/lib2:... \
              --debugPaths /path/to/debug1:/path/to/debug2:... \

Known Issues

If anything breaks in the above and the output is less usable than perf report, please report an issue on GitHub. That said, there are some known issues that people may trip over:

Broken Backtraces

Unwinding the stack to produce a backtrace is a dark art and can go wrong in many ways. Hotspot relies on perfparser (see below), which in turn relies on libdw from elfutils to unwind the stack. This works quite well most of the time, but still can go wrong. Most notably, unwinding will fail when:

  • an ELF file (i.e. executable or library) referenced by the file is missing
    • to fix this, try to use one of the following CLI arguments to let hotspot know where to look for the ELF files:
      • --debugPaths <paths>: Use this when you have split debug files in non-standard locations
      • --extraLibPaths <paths>: Use this when you have moved libraries to some other location since recording
      • --appPath <paths>: This is kind of a combination of the above two fields. The path is traversed recursively, looking for debug files and libraries.
      • --sysroot <path>: Use this when you try to inspect a data file recorded on an embedded platform
  • an ELF file is missing debug information
    • to fix this, install the debug package from your distro
    • or compile the code in "release with debug" mode, i.e. ensure your compiler is invoked with something like -O2 -g. You will have to repeat the perf record step
    • potentially both of the above is not an option for you, e.g. when the library is closed source and supplied by a thirdparty vendor. If that is the case, you may be lucky and the library contains frame pointers. If so, then try to build elfutils from current git master (you want commit a55df2c1, which should be part of 0.170). This version of elfutils will try to fallback to the frame pointer for unwinding, when the debug information is missing.
  • your call stacks are too deep
    • by default, perf record only copies a part of the stack to the data file. This can lead to issues with very deep call stacks, which will be cut off at some point. This issue will break the top-down call trees in hotspot, as visualized in the Top-Down view or the Flame Graph. To fix this, you can try to increase the stack dump size, i.e.:

      perf record --call-graph dwarf,32768

      Note that this can dramatically increase the size of the files - use it with care. Also have a look at man perf record.

    • For some scenarios, recursive function calls simply fail to be unwound. See also

Missing Features

Compared to perf report, hotspot misses a lot of features. Some of these are planned to be resolved in the future. Others may potentially never get implemented. But be aware that the following features are not available in hotspot currently:

  • tracepoints: we only analyze and show samples. This means that it is currently impossible to do off-CPU profiling with hotspot.
  • annotate: the caller/callee view shows cost attributed to individual source lines. But a proper annotation view like perf annotate, esp. on the instruction level, is currently missing.
  • the columns in the tables are currently hardcoded, while potentially a user may want to change this to show e.g. cost per-process or thread and so forth
  • many of the more advanced features, such as --itrace, --mem-mode, --branch-stack and --branch-history, are unsupported

Recording with perf without super user rights

It is not a good idea to launch hotspot with sudo or as root user. See e.g. Editing Files As Root for an article on that matter. Issue #83 is also relevant in this contact.

But without superuser rights, you may see error messages such as the following when using hotspot's record feature:

You may not have permission to collect stats.
Consider tweaking /proc/sys/kernel/perf_event_paranoid:
  -1 - Not paranoid at all
   0 - Disallow raw tracepoint access for unpriv
   1 - Disallow cpu events for unpriv
   2 - Disallow kernel profiling for unpriv

To workaround this limitation, hotspot can temporarily elevate the perf privileges. This is achieved by applying these steps, bundled into a script that is run via kdesudo or kdesu. The resulting elevated privileges are also required for kernel tracing in general and Off-CPU profiling in particular.

Qt Creator

This project leverages the excellent perfparser utility created by The Qt Company for their Qt Creator IDE. If you are already using Qt Creator, consider leveraging its integrated CPU Usage Analyzer.


Hotspot is dual-licensed under the GPL v2+ or under a commercial KDAB license. See LICENSE.GPL.txt, LICENSE.txt and LICENSE.US.txt for more information, or contact if any conditions of this licensing are not clear to you.

You can’t perform that action at this time.