The profiler for agents and humans.

Find it, fix it, share it. Any running program, no code changes.

curl -fsSL https://perfr.dev/install.sh | sh

The service runs on Linux, macOS and Windows. The viewer runs in any browser.

The evolution of Orbit, from its original author.

Drag to pan · wheel over the ruler to zoom · click a thread · right-click a scope · Home to fit Open it on its own

4.6 MB stream

Coming soon Sharing a capture with a link, and annotating it.

From the whole run down

These recordings go from the shape of the run down to one core. The platform table says what the service records on each operating system. The features page has the rest.

Attach & record

Hit Record, and the timeline starts

Pick the process and hit Record. Nothing to rebuild. The timeline streams live and the capture timer ticks. Function hooks need no code change; Frida is the default.

In the manual

Sampling flame graph

Where the run spends time

The sampling flame graph is the whole run, at 1 kHz. Click a frame to highlight that function on the timeline. Double-click to zoom into its subtree.

In the manual

Auto-profiling

Then time the hot functions

Auto-profiling hooks the functions the samples point at and drops whatever costs too much, inside a budget you set. No rebuild and no source edits. On Linux it needs root or CAP_SYS_ADMIN. It is not available on macOS or Windows. You can also hook one function yourself.

In the manual

Scheduler & thread states

Down to one core

The scheduler track is one lane per core. A slice is the time that thread was on that core; the thread-state strip shows Running and Sleeping. Select a stretch of the run and the report recomputes for that window, down to a single context switch.

In the manual

Timeline zoom, scope search, call trees, live statistics, disassembly, traces and the rest of the recordings are on the features page.

How it works

The capture agent runs on the machine you profile. The viewer is a web page, so you can open it on another device.

In the manual

Supported

Linux

Call stacks at 1 kHz, a lane per core, dynamic instrumentation with no code change, and manual scopes. The tested build is x86-64.

Supported

Windows

Call stacks at 1 kHz, a lane per core and thread states from the kernel logger (an elevated prompt), Frida function hooks and manual scopes without one. x86-64.

Partial

macOS

Manual scopes and Frida function hooks, on Intel and Apple silicon. Sampling, the scheduler, and auto-profiling are not in this build.

perfr

The capture agent, on that machine

It attaches to a process that is already running and serves the viewer on the same port.

Web viewer

  • Desktop
  • Tablet
  • Phone

A Rust and WebAssembly page. Any device with a browser can open it, including one that is not the machine being profiled. A saved capture also opens with no service at all.

  1. Target process

    Already running

    A native binary. perfr does not rebuild it and does not relaunch it.

  2. perfr

    What this machine records

    On Linux: call stacks at 1 kHz, the scheduler, and dynamic instrumentation with no code change. Auto-profiling picks what to hook and keeps the cost under a budget. It needs root or CAP_SYS_ADMIN. On Windows: the same call stacks, scheduler and thread states from the kernel logger, which needs an elevated prompt; Frida hooks and manual scopes without one. On macOS: manual scopes and Frida function hooks. Sampling, the scheduler, and auto-profiling are not in that build.

  3. Web viewer

    Live, in the browser

    Timeline, flame graph, call trees, live table, selection reports, and, on Linux and Windows, disassembly (next to source on Linux).

What the service records

Status of perfr on main. The viewer itself runs in any browser.

Supported means it runs and is tested on that operating system. Partial means some of it works, with a limit named below. Not yet means this service does not do it.
Feature Linux Windows macOS
Call-stack sampling Supported Supported Not yet
Scheduler and context switches Supported Supported Not yet
Thread states Supported Supported Not yet
Dynamic instrumentation (no code change) Supported Supported Supported
Auto-profiling Supported Not yet Not yet
Manual instrumentation Supported Supported Supported
Symbols Supported Supported Partial
Disassembly and source Supported Partial Not yet
Service CPU and memory Supported Supported Supported
  • Linux is the x86-64 service. Sampling is fixed at 1 kHz and unwound with DWARF. Arm64 has the register and unwind paths and is not run in CI; the static binary is x86-64.
  • macOS function hooks are tested on Apple Silicon and Intel. Attaching needs a task port. Code signing, the hardened runtime, and SIP can refuse it; these builds do not bypass that. Shared-cache images whose symbols Frida cannot read may be missing from the function list. Hook-safety analysis is the Linux path. The release binary is universal and ad-hoc signed, not notarized.
  • Dynamic instrumentation needs no code change. Frida is the default. On Linux, auto-profiling uses a kernel engine and needs root or CAP_SYS_ADMIN.
  • Auto-profiling is supported on Linux and needs root or CAP_SYS_ADMIN. It is not available on macOS or Windows.
  • Windows is the x86-64 service. Sampling (1 kHz, the kernel walks the stacks), the scheduler and thread states come from the NT Kernel Logger (ETW), which needs a prompt opened with Run as administrator; manual scopes and Frida hooks need no privilege. Symbols come from PDBs and export tables. Disassembly is partial: there is no source interleave, since the line table lives in the PDB. No GPU lanes. The binaries link the C runtime statically and are not code-signed.

Get started

The script installs the build for this machine, including the Frida files function hooks need.

Run it

# install (Linux x86-64 or macOS)
curl -fsSL https://perfr.dev/install.sh | sh

# install (Windows x64, PowerShell)
irm https://perfr.dev/install.ps1 | iex

perfr
# http://127.0.0.1:44766/

The scripts download a GitHub Release tagged perfr-v*. Linux x86-64, macOS (one universal binary, Intel and Apple silicon) and Windows x86-64 are all in that release. Until a stable release exists the script stops and says so. Function hooks ship beside the binary and do not need root. On macOS, attaching needs a task port.

On Linux, sampling works at perf_event_paranoid 2 or below, and the scheduler needs 0 or below. Root, CAP_PERFMON or CAP_SYS_ADMIN bypass the sysctl. Auto-profiling needs root or CAP_SYS_ADMIN. On Windows, sampling, the scheduler and thread states need a prompt opened with Run as administrator. Those are not in the macOS build.

Quick start in the manual

Where it runs

The service runs on the machine you profile. The viewer runs in any browser, on any device, including a phone.

One small API for Rust, C, C++ and Python is in the manual, alongside the HTTP API. The platform table is the feature-by-feature status.

Instrumentation and the HTTP API

About

The evolution of Orbit, from its original author: the same DNA, with new capabilities. The capture agent and the web viewer are the work in this repository.

Site built 2026-11-05 at commit 38c2252. Recordings are of the live viewer at da8aa05c, profiling game_loop. The embedded capture is a .perfr.stream.