Perfetto v59.12026-10-27
We’re excited to share Perfetto v59.1! This release brings traces that survive device reboots on Android, a much friendlier Trace Processor command line (rustc-style SQL errors, markdown output and a dedicated agent mode for AI coding tools), flamegraphs as call trees and function tables, sampled callstacks over time, a new linux.smaps data source, and a long list of UI, SQL standard library and SDK improvements.
> Note: v59.0 was never released due to a build issue on the Linux and Android release builders. v59.1 contains the same changes plus the build fix.
🔁 Persistent traces across reboots (Android)
Set TraceConfig.persisttraceacrossreboots and the trace file is kept on disk if the device reboots mid-trace, then recovered and uploaded on the next boot via perfetto --upload-after-reboot. Recovered traces record why in the new tracerecovery_reason metadata entry.
🔥 New ways to look at profiles in the UI
Flamegraphs are great for spotting where cost goes, but they're only one way to read a profile. v59 adds two new views over the same data, plus a way to see how stacks change over time.
- Call Tree view: every flamegraph panel now has Flamegraph, Call Tree and Functions tabs. Call Tree is an expandable table with total and self cost for every frame, shown top-down (callees) or bottom-up (callers). The tabs share the same filters, and switching between them doesn't re-run the query.
- Functions view: a flat table with the cost of each function summed over every call path, the quickest way to answer "which function is hottest overall?". Recursion isn't double-counted.
- Available everywhere: CPU callstack samples, heapprofd and Java heap profiles, Heap Dump Explorer, Day Explorer, the pprof (aggregate profiles) page and track event callstacks all get the new views.
- Sampled callstacks over time: each thread with callstack samples now gets a "Callstack flamechart" track beneath its Callstacks track. It draws every sample's stack along the timeline, so you can see how a thread's behaviour changes over time, not just the aggregate. Frames can be coloured by function or by code mapping (library), and clicking a frame shows its details.
- pprof: step through multi-profile pprof archives with the arrow keys, and copy profile names.
- Heap dumps: ART heap dumps can be exported as pprof from the flamegraph Export menu (including in Heap Dump Explorer), and Heap Dump Explorer flags classes potentially merged by R8.
<img width="3200" height="1951" alt="image" src="https://github.com/user-attachments/assets/68a0b425-be09-4591-a47c-220de09a23d9" />
Sampled callstacks over time: the new Callstack flamechart track under surfaceflinger's main thread, with the flamegraph for an area selection and the new Flamegraph / Call Tree / Functions tabs below.
<img width="3200" height="1839" alt="image" src="https://github.com/user-attachments/assets/02bdf39d-bcea-400f-8a33-10be9d897805" />
Call Tree view (top-down, fully expanded) for the same selection: total and self CPU time for every frame.
<img width="3200" height="1255" alt="image" src="https://github.com/user-attachments/assets/ea9064a1-aa83-42bb-80ce-5344faa22e94" />
Functions view: self and total CPU time per function, summed over every call path.
🕸️ Flows that scale to dense graphs
Selecting a slice in a trace with a dense flow graph (build system dependency traces are a common example) used to make the UI follow the entire flow chain, which could grind it to a halt. Many people have hit this over time (#1004).
- Show only direct flows: a new setting on the Settings page that, when enabled, shows only the flows directly connected to the selected slice (one step) instead of the whole chain.
- Off by default: existing behaviour is unchanged unless you turn it on.
💻 A friendlier Trace Processor CLI
- Readable SQL errors: SQL errors are now laid out like rustc diagnostics, with a --> source:line:col location naming where the SQL came from (query, module, macro or metric), a line-number gutter and a caret.
- Markdown output: trace_processor query --format markdown prints compact markdown tables, with configurable --max-rows, --max-bytes and --max-cell-width limits.
- Agent mode: when run by a coding agent (detected from environment variables such as CLAUDECODE or AI_AGENT) with stdout not a terminal, results default to markdown and errors become single-line JSON. Force it on or off with --agent / --no-agent.
- Interactive shell: prints aligned tables and shows the result of every statement, not just the last one.
- Progress and colour: terminal-aware progress reporting, --no-progress, and NOCOLOR / FORCECOLOR support.
<img width="2228" height="1402" alt="image" src="https://github.com/user-attachments/assets/63621a7d-8879-4fa6-9777-ce57d03f73b6" />
Trace Processor CLI: a rustc-style error for a misspelled column, then query results printed as a markdown table with --format markdown.
Learn more about agent mode
🧠 Memory: linux.smaps data source
traced_perf can now record /proc/pid/smaps for selected processes, once or periodically. Processes can be selected by cmdline and uid range. The record page can also capture smaps snapshots alongside ART heap dumps.
🔍 Symbolization without local binaries
Native profiles from Linux machines often arrive without the unstripped binaries needed to symbolize them. Trace Processor can now fetch debug files from debuginfod servers by build ID, so trace_processor bundle --debuginfod input.pftrace output.tar produces a symbolized bundle with no local binaries at all.
- Opt-in and local-first: lookups only happen with --debuginfod. Servers come from --debuginfod-urls or DEBUGINFOD_URLS, and local binaries are always tried first.
- Cached: downloads are cached for later runs (--debuginfod-cache-path to override), with configurable connection and stall timeouts.
- Much less work: mappings are now deduplicated across processes, so large traces send far fewer requests to llvm-symbolizer.
- Clearer results: accurate counts of resolved and unresolved frames, --verbose to see every lookup, --quiet for scripts, and a clean error instead of a crash when llvm-symbolizer can't be run.
- samply profiles: unsymbolized Firefox Profiler (samply) profiles can now be symbolized with bundle.
Learn more about symbolization
🐍 Python: connect to warm sessions
TraceProcessor(remote='my-session') connects to a running trace_processor server unix session, so you can parse a large trace once and query it from many scripts. Only query() is supported over Unix sockets for now. remote also accepts HTTP addresses, and addr is deprecated in its favour.
🖥️ UI Enhancements
- Zoom to slice: double-click a slice to select and zoom into it.
- Track groups: "Expand all" / "Collapse all" in the track menu, and Shift+click on a group header to expand or collapse everything below it.
- Android: frame timeline tracks are grouped by layer, and the AndroidLockContention plugin is revamped.
- Aggregations: CPU slice aggregations gain a "CPU Time / Wall Time" column. Thread slice aggregations gain optional process, thread and track columns, and drill-downs open in a new tab. The old Pivot Table tab has been removed in favour of slice aggregations.
- Permalinks: workspaces are now saved in permalinks.
- Robustness: the timeline recovers from WebGL context loss, and two-finger horizontal scrolling no longer triggers browser back/forward on Chr
Perfetto v58.22026-08-24
We’re excited to share Perfetto v58.2! This release makes it possible to merge traces from different machines onto one timeline, introduces Memscope and Memory Overview for end-to-end memory investigations, lets you keep a parsed trace running and analyze it through lightweight remote clients, adds Zstd trace compression, and substantially improves Perfetto’s AI-assisted analysis workflows. It also introduces a common stack-sampling format, new export options, and a collection of UI and SDK improvements.
> Note: v58.0 and v58.1 were never released due to compilation issues with Windows builds.
Merge multiple traces onto one timeline
Perfetto can now open several traces together and merge their contents onto a single timeline! This makes it much easier to investigate behavior spanning multiple VMs, machines, or separately recorded trace sources without manually converting them into one trace first.
Here's a demo of merging traces in the Perfetto UI:
https://github.com/user-attachments/assets/3f669a65-493c-4bf0-a236-3e253419e95f
In the UI, select Open multiple trace files, select several files in the normal file picker, or drop multiple files onto the page. A new dialog lets you configure how the traces should be merged, shows whether any events would be dropped, and can export the result as a self-contained .tar archive.
<img width="960" height="800" alt="trace-merging-dialog-crop" src="https://github.com/user-attachments/assets/62061021-bd7d-46e0-89dd-ffaf6aa5e187" />
A powerful use of this feature is to visualize traces that span machines and VMs. For example, to visualize traces across a phone and a backend service the phone is communicating with:
<img width="1576" height="485" alt="multimachine-showcase-150" src="https://github.com/user-attachments/assets/b8a09aac-9bb5-41c3-a4c0-92ef3727639e" />
Use the new util merge command which helps avoid common mistakes when merging traces. The resulting trace can be opened in the UI or in the trace processor:
``sh
Merge traces from the same machine recorded with consistent clocks. For multi-machine or multi-clock setups, use the JSON
manifest as described below.
trace_processor util merge \
-o merged.tar \
perf.data \
perfetto.pftrace
Now you can opened merged.tar in the UI or load it in trace processor:
trace_processor merged.tar
`
For more complex setups, a perfetto_manifest JSON file can assign machine names, relate clock domains, and apply fixed clock offsets. The UI can generate both the archive and manifest interactively, providing a convenient starting point for scripted or repeatable workflows.
See the merging traces documentation for much information examples of how to merge traces in common setups, details of the manifest format and details on how to generate pre-merged traces for loading in the UI, without using trace_processor merge
Memscope and Memory Overview (Preview)
Perfetto v58 introduces a connected memory-analysis workflow spanning live monitoring, trace recording, initial triage, and detailed investigation.
> Preview: Memscope and Memory Overview are still preview features.
Memscope is a live memory profiler for Android and Linux. It guides you through connecting to a device or host, displays system-wide and per-process memory statistics as they change, and provides shortcuts for recording a memory trace for a selected process. Instead of constructing a memory-focused recording configuration by hand, you can move directly from observing suspicious memory behavior to capturing the information needed to explain it.
<img width="1280" height="720" alt="memscope-connected" src="https://github.com/user-attachments/assets/dcbc6249-45bd-40c8-b5bf-8076603b2ced" />
After recording, Memory Overview provides a high-level breakdown of where a process’s memory is being used. It combines information from smaps snapshots, ART heap dumps, and native heap profiling into one starting point, with links into more specialized tools such as Heap Dump Explorer.
<img width="1280" height="720" alt="memscope-where-did-memory-go" src="https://github.com/user-attachments/assets/e0e69788-0d19-492e-ae29-0b3079791db8" />
Memory Overview also opens automatically when a trace contains smaps snapshots, making memory traces immediately actionable rather than dropping users onto a generic timeline.
Together, Memscope and Memory Overview provide a path from “this process appears to be using too much memory” to the appropriate native, managed, or system-level investigation.
See the Memscope and Memory Overview guide for a complete recording and analysis walkthrough.
Load once, analyze through lightweight clients
Remote Trace Processor analysis is not new: trace_processor server http already allowed the Perfetto UI to use a native Trace Processor instance instead of the browser’s WebAssembly implementation.
The command-line experience, however, had significant gaps. The Trace Processor CLI could not connect to an existing server, and running several server instances meant manually assigning port numbers, remembering which trace was attached to each port, and dealing with port clashes.
Perfetto v58 turns this into a complete client-server workflow. A trace can be loaded once into a properly named background session, and any number of lightweight command-line clients can connect to it using --remote:
`sh
Parse the trace once and keep it in a named session.
trace_processor server unix \
--name mysession \
--daemonize trace.pftrace
Run queries against the existing session.
trace_processor query \
--remote mysession \
"SELECT count(*) FROM slice"
`
Named local sessions use Unix sockets, so there is no port to allocate or remember. The session name identifies both the running Trace Processor and the trace it contains. The new remote client can also connect to a trace_processor server http instance using --remote host:port, bringing the existing HTTP/WebSocket server workflow to the command-line interface.
Session state persists across invocations: tables created by one query and modules included by one command remain available to the next, allowing expensive intermediate results to be materialized once and reused. The result is a much more usable workflow for large traces: parse once, give the session a meaningful name, and analyze it repeatedly without juggling ports or restarting Trace Processor.
See the command-line analysis guide for session management, remote addresses, and idle-timeout options.
Smaller traces with Zstd compression
Perfetto now supports Zstd as a trace compression option alongside deflate. Zstd generally produces smaller traces than deflate at a similar speed, reducing the storage and transfer costs of longer or more data-intensive recordings.
Compression is selected through the new TraceConfig.compression field:
`protobuf
compression {
zstd {}
}
`
The compression level can also be controlled explicitly:
`protobuf
compression {
zstd {
level: 9
}
}
`
Level 0, or leaving the level unset, uses Zstd’s default level of 3, which provides a good balance for most traces. The older compression_type field remains honored for compatibility but is now deprecated in favor of TraceConfig.compression`.
See the trace configuration documentation for level selection, compatibility behavior, and SDK build requirements.
Faster and more capable AI-assisted analysis
Perfetto’s installable AI skill can now keep a trace loaded across an investigation. Instead of reparsing the same trace for every question, the skil
Perfetto v57.22026-07-07
v57.2 is a point release of Perfetto v57 which fixes an issue in Trace Processor where it failed to parse traces that embed their own proto descriptors after wire-compatible schema changes. Specifically, this addresses failures occurring after widening previouspacketdropped from bool to uint32 and removing AndroidCamera* fields.
Note: For all other changes in Perfetto v57, please refer to the release notes for v57.1.
Perfetto v57.12026-07-02
We're excited to share Perfetto v57.1! This release introduces an installable AI skill that teaches coding agents how to use Perfetto, a long-awaited fix for overlapping events in JSON traces (commonly affecting the PyTorch profiler), state tracks, a brand-new track type alongside slices and counters, end-to-end support for systemd journald logs, a rework of the query results grid, and new SDK capabilities like nested tracks and correlation ids.
> Note: v57.0 was never released due to an issue with the install of the newly introduced AI skill. v57.1 includes a fix for this issue.
🤖 An AI skill for Perfetto
Perfetto now ships an AI skill that teaches coding agents how to record, query, and analyze traces, including guided workflows for common investigations. It works with any Agent Skills-compatible agent (Claude Code, OpenAI Codex, Gemini CLI, OpenCode, and others) and bundles a working trace_processor for the agent to use:
``sh
Claude Code
/plugin marketplace add google/perfetto@ai-agents
Codex
codex plugin marketplace add google/perfetto --ref ai-agents
Other agents
curl -fsSL https://get.perfetto.dev/agents-install | python3 - --agent <opencode|antigravity|pi>
`
See the Using AI with Perfetto docs for agent-specific install paths and what the skill can do.
🧩 Overlapping events in JSON traces now work
Perfetto now imports overlapping "ph": "X" (complete) events in JSON (Chrome Trace Event Format) traces instead of silently dropping them. This was a long-standing pain point (#4280) for tools which emit overlapping synchronous events, notably traces from the PyTorch profiler: the affected slices vanished from both the timeline and SQL, and some users were resorting to self-hosting old versions of the UI. Overlapping events are now ingested onto overflow tracks which the UI merges back into a single thread track, so everything is visible in the timeline and queryable in SQL.
<img width="3340" height="1108" alt="overlapping JSON events rendering in the timeline" src="https://github.com/user-attachments/assets/956d133a-8320-470c-bae4-ce37dd1b29dc" />
Note that overlapping "X" events remain outside the Trace Event Format spec: the importer records stats naming the offending events (surfaced in the UI's import warnings) so you can flag them to your tracing tool's maintainers. If you maintain such a tool, prefer async ("b"/"e") events, which is how the format natively represents genuinely overlapping intervals.
🚦 State tracks
Slices and counters have a new sibling: state tracks, a first-class way to record the state of a system or subsystem over time (e.g. "Buffering", "Playing", "Paused"). A state track always has exactly one current value; each event simply transitions it to a new state, and clearing it marks the track as idle.
<img width="3200" height="1520" alt="state_tracks" src="https://github.com/user-attachments/assets/cc65f9a8-19c6-40bb-9ab4-117c61338da6" />
You can emit states from all the SDKs:
`cpp
// C++ SDK
perfetto::StateTrack track("Player state");
TRACE_STATE("player", "Buffering", track);
`
`c
// C SDK (high-level API)
PERFETTOTE(player, PERFETTOTE_STATE("Buffering"),
PERFETTOTEREGISTEREDTRACK(&playerstate_track));
`
The Android Java SDK gets the same capability. Trace Processor ingests state events into a new state SQL table, and the UI renders state tracks natively with a dedicated details panel.
📜 systemd journald logs
Linux system logs can now be captured as part of a trace, end to end:
- A new linux.systemdjournald data source records journald entries while tracing, with filters for minimum syslog priority, SYSLOGIDENTIFIERs, and systemd unit names.
- Trace Processor stores them alongside Android logcat entries in a unified log table, distinguished by a new logsource column (plus a linuxsystemdjournaldlogs view in the standard library).
- The UI gained a JournaldLog plugin: a logs track on the timeline plus a filterable logs tab (priority, tags, free text).
<img width="3200" height="1600" alt="journald" src="https://github.com/user-attachments/assets/594c1ff4-2d89-4883-8501-fd539dc0fea1" />
Big thanks to @staticfloat for contributing this feature!
🖥️ UI
The query results grid got a big upgrade: columns can be sorted, reordered, and hidden, the sidebar is collapsible, and SQL errors are now surfaced properly in the grid.
<img width="3600" height="1800" alt="query_grid" src="https://github.com/user-attachments/assets/babb3b03-394a-4bbc-a349-f913aba6f16e" />
- Shift + mouse-wheel scrolls the timeline horizontally.
- The Heap Dump Explorer now opens by default on more traces, keeps its state in shared permalinks, and shows oomscoreadj in the overview.
- Saved custom textproto record configs can be re-opened and edited.
- Adjacent slices that share a boundary timestamp now render with a 1px gap, so back-to-back instances of the same slice are visually distinguishable.
- A new smaps plugin shows an instants track with a datagrid details panel for traces containing /proc/<pid>/smaps data.
- A new opt-in Arm Telemetry Solution plugin adds an Arm CPU page (under Support) for loading Arm CPU telemetry specs, which turn raw PMU counters into derived per-CPU metrics (e.g. IPC, cache misses) shown as tracks.
🧰 SDK
- Nested tracks with sibling ordering and merging in the C SDK high-level ABI and the Android Java SDK (PerfettoTrack): build multi-level track hierarchies and control how sibling tracks are sorted and merged in the UI.
- Correlation ids: tag events that belong to the same logical operation without implying a causal link (use flows for those), via PERFETTOTECORRELATIONID() / PERFETTOTECORRELATIONID_STR() in the C SDK and PerfettoTrackEventBuilder.setCorrelationId() in the Java SDK.
- The TRACESTATE / PERFETTOTE_STATE() APIs for state tracks described above.
🔬 Profiling
heapprofd's processcmdline now supports partial wildcard matching (e.g. system or /system/bin/), with the same semantics as the perf profiling and Java heap dump data sources. Wildcards only match already-running processes, so configs using them must set nostartup = true.
🧠 Trace Processor
- traceprocessor can now load traces directly from URLs and ui.perfetto.dev permalinks**:
`sh
traceprocessor query "https://ui.perfetto.dev/#!/?s=<hash>" "select count() from slice"
`
- Track descriptors support explicit thread and process ordering, so producers can control how their processes and threads are sorted in the UI.
- The Adreno GPU adrenocmdbatchretired and adrenocmdbatchsync ftrace events are now parsed into GPU timeline slices.
- The perfetto Python package now defaults to a traceprocessor binary pinned to the package version instead of downloading the latest build at runtime, making analysis scripts reproducible. Opt back into the old behavior with TraceProcessorConfig.fetchlatesttraceprocessor.
⚙️ Tracing service & probes
- The RelayPort IPC service (multi-machine tracing) is now only exposed on producer sockets that explicitly opt in; the new --enable-relay-endpoint-on=<sock> flag enables it per-socket, while --enable-relay-endpoint keeps its existing semantics.
- New ftrace events: pscidomainidleenter / pscidomainidleexit for finer-grained CPU power-state insight than cpuidle alone, plus dispdpulineunderrun and panel settings events.
- The Windows ETW data source now supports systemioprovider_events.
🛠️ v57.1 patch fixes
- AI: Fixed the AI skill missing its bundled trace_processor` wrapper. The wrapper now ships inside the skill dire
Perfetto v56.12026-06-10
v56.1 is a point release of Perfetto v56 which fixes a compile issue with the SDK which can appear on certain compilers.
Note: For all other changes in Perfetto v56, please refer to the release notes for v56.0
Perfetto v56.02026-06-03
Perfetto v56.0 is out! This release adds more to the Heap Dump Explorer, a round of UI improvements, easier-to-read multi-machine traces, kernel-assisted stack sampling in traced_perf, and a few new SDK knobs.
🔥 Heap Dump Explorer: flamegraphs & bitmaps
The Heap Dump Explorer now has a built-in flamegraph viewer, so you can jump between the class/object/dominator views and a flamegraph without leaving the page. There's also a new bitmap metadata page for bitmaps captured in Android heap dumps, and a feature flag to control whether the explorer auto-opens on traces with heap-graph data.
<img width="3367" height="909" alt="heap_dump" src="https://github.com/user-attachments/assets/6a0aad04-d546-4115-b16f-905147337461" />
> Heads up: the explorer's setting ID is now prefixed with com.android, so if you'd saved a setting before you'll need to re-enable it.
Under the hood, Android heap dumps now include process and package metadata, and Trace Processor exposes bitmap metadata via a new table in the standard library. Java soft references are treated as strong during reachability analysis, and the HPROF parser no longer aborts when a sub-record straddles a segment boundary.
🖥️ UI
Selecting a slice now shows a distribution histogram of matching slices, with the selected slice highlighted and a one-click shortcut to a Debug Track.
<img width="3418" height="1242" alt="histogram_demo" src="https://github.com/user-attachments/assets/d107331b-8b0b-4c2a-ab16-2d0e5619852a" />
- Hover previews on screenshot tracks.
- Trace start time and duration in the timeline header.
- A matching-slice action on selection flamegraphs and a scroll-to-root command for top-down/bottom-up/pivot views.
- SQL formatting and per-query column refresh on the Query page.
- Faster rendering for incomplete-slice fetches and quicker trace_processor worker startup.
- Memcg reclaim tracks, now grouped under Memory.
- Details panels and process navigation in the AndroidStartup and AndroidAnr plugins.
- Fixed pinned tracks getting unpinned when the timeline loaded.
🌐 Multi-machine tracing
Traces gathered across machines with traced_relay are easier to attribute:
- TracingServiceState now carries machineid and machinename, and perfetto --query / --query-raw show a MACHINE column when more than one machine is involved. Host-only output is unchanged.
- The stats table reports per-machine and per-trace statistics.
``
PRODUCER PROCESSES CONNECTED:
ID PID UID FLAGS MACHINE NAME SDK
== === === ===== ======= ==== ===
1 0 501 guest-B examplesystemwide Perfetto v56.0
2 0 501 guest-A examplesystemwide Perfetto v56.0
3 -1 0 (host) examplesystemwide Perfetto v56.0
`
⚡ Kernel-assisted stack sampling
tracedperf can now use in-kernel frame pointer unwinding** for faster stack sampling on callstack-heavy workloads.
🦊 Firefox Profiler markers
Markers from the Firefox Profiler now import as slices, so you can line them up against the rest of the trace.
🧰 SDK
- New trackeventbufferexhaustedpolicy in TracingInitArgs to decide what happens when the TrackEvent buffer fills up.
- The Java SDK now runs on non-ART JVMs (e.g. on host/desktop).
🐛 Fixes & build
- Process and package metadata added to Android heap dumps.
- Fixed an intermittent service crash from a use-after-free in the lock-free task runner.
- Fixed builds on FreeBSD (tracebox), musl, and recent Fedora.
- Trace Processor: faster startup, hardened parsers and SQL engine.
📚 Docs
- Docs for the new subcommand-based trace_processor` CLI and for multi-machine tracing.
- A Data Explorer doc stub, a better architecture doc, and new images/videos.
- Updated heap profiler docs.
Happy Tracing!
---
A huge thanks to everyone, both inside and outside of Google, who contributed to making Perfetto v56 a success. ♥️
For complete details, see the changelog or view all changes on GitHub.
Download Perfetto v56.0 from our releases page, get started at docs.perfetto.dev, or try the UI directly at ui.perfetto.dev.
Perfetto v55.32026-05-19
v55.3 is a point release of Perfetto v55 which relaxes embedded proto descriptor loading to allow wire-compatible extensions re-declared under renamed packages and defaults the UI to the Heap Dump Explorer view for traces with heap graph data. It also includes the fix from v55.2 which addressed an issue with how the "classic" CLI interface of trace_processor worked on Windows, preventing breakage of the Python API on that platform.
Note: For all other changes in Perfetto v55, please refer to the release notes for v55.1
Perfetto v55.22026-05-14
v55.2 is a point release of Perfetto v55 which fixes an issue with how the "classic" CLI interface of trace_processor worked on Windows. This would cause breakage of the Python API on Windows.
Note: For all other changes in Perfetto v55, please refer to the release notes for v55.1
Perfetto v55.12026-05-13
We're excited to share Perfetto v55.1! Highlights include GPU-accelerated trace rendering, a new Heap Dump Explorer, native Linux heap profiling, a redesigned trace_processor shell, multi-GPU analysis, and a major docs refresh.
> Note: v55.0 was never released due to a build failure on Windows and an issue with parsing of some important ftrace events. v55.1 includes fixes to these issues.
⚡ WebGL rendering & virtual track scrolling
Opening big traces (hundreds of processes, thousands of tracks, millions of slices) should be significantly smoother in v55. Two changes drive this:
- WebGL rendering for slice and counter tracks moves the per-frame drawing work onto the GPU, lifting the budget for dense tracks by a wide margin.
- Partial virtual track scrolling means that tracks off screen only render a "skeleton" of their layout to allow for browser Ctrl-F while not doing unnecessary work.
> Note: for the largest traces, there's more coming with full virtual track scrolling in the works!
🧠 Heap Dump Explorer
Investigating Android and Java memory issues gets a significant improvement in Perfetto UI through the new Heap Dump Explorer page. Instead of just showing the flamegraph for the heap dump, this is an interactive exploration tool on the classes, objects and references in the dump. Specifically:
- A high-level Overview with retained bytes per heap.
- Classes ranked by retained / shallow size to help you find which type is hogging memory.
- An Objects browser for navigating individual instances and following references.
- Dominators view to find which objects "retain" the largest memory chunks.
- Bitmap gallery, Strings, and Arrays views (require an Java/ART .hprof heap dump).
The Java HPROF importer also got a major upgrade: primitive fields, array contents, and Bitmap-specific metadata are now preserved when parsing the traces to power this functionality.
<img width="3840" height="2400" alt="image" src="https://github.com/user-attachments/assets/bd1d906b-a58c-4bc7-aba5-510d25bb6d38" />
Learn more in the Heap Dump Explorer guide
🐧 heap_profile host: native Linux heap profiling
heap_profile is no longer Android-only. The new host subcommand lets you capture an allocation-attributed memory profile of a local Linux process and open the result in the same UI:
``sh
tools/heapprofile host -- ./mybinary --some-flag
`
It auto-downloads the bits it needs, launches a bundled daemon, and produces a flamegraph that behaves exactly like the Android equivalent (drill in by stack frame, deobfuscate symbols, etc.). The existing Android workflow lives under heap_profile android and is unchanged.
Get started with native heap profiling On Linux
🐚 Subcommand-based traceprocessorshell
traceprocessorshell has been rebuilt around purpose-built subcommands that read more like git, replacing the flat-CLI-with-flags model:
`sh
trace_processor query # one-shot SQL
trace_processor interactive # REPL
trace_processor server # serve the UI over RPC
trace_processor metrics # run metrics
trace_processor summarize # high-level summaries
trace_processor export # write to other formats
trace_processor convert # legacy conversions
`
The query subcommand also gained a structured query mode for programmatic callers. Existing scripts that use the classic flat CLI keep working just as it is today but all new functionality will be exposed through subcommands only.
New trace_processor subcommand docs
🎮 Multi-GPU support
Trace Processor now models multiple GPUs as first-class citizens. The new gpu and gpu_context tables let you slice slice and memory tracks per-GPU and per-machine, so workloads spanning a discrete + integrated pair, a multi-GPU host, or a multi-machine setup attribute correctly all the way through analysis.
On the recording side, the GPU data source gained InstrumentedSamplingConfig for fine-grained sampling control, custom counter groups in GpuCounterConfig, and CUDA / HIP added to the graphics-context APIs; useful for compute workloads beyond traditional rendering.
GPU data source documentation
🐍 Python: polars DataFrame support
The Python TraceProcessor API can now return query results as polars DataFrames as well as pandas.
`python
df = tp.query("SELECT FROM slice").aspolars_dataframe()
`
📈 Data Explorer dashboards
The Data Explorer (formerly "Explore") now has a full dashboard environment with side-by-side Graph and Dashboard views, an in-sidebar chart editor, smarter graph with cycle detection, import/export of dashboards between sessions, and built-in tutorials & solution recipes.
<img width="1920" height="1080" alt="08-data-explorer" src="https://github.com/user-attachments/assets/6036f3ca-1f7c-41c4-a5f5-702a11b8b52d" />
📊 New chart types and UI polish
A handful of new chart and aggregation types ship across the UI:
- Sankey chart for flow visualisations (scheduling transitions, call relationships, anything with sources and destinations).
- Stats widget for one-glance summaries (count, mean, min, max).
- New percentile and count-distinct aggregations in the SQL table viewer.
- Line charts now support stacking, series hovering, and selection alongside brushing.
- Counter detail panels now reflect counter mode and handle rate-delta counters correctly — particularly noticeable on Android GPU events.
🚀 Tracing service and probes
- android.aflags data source captures Android aconfig flags in effect during the trace, surfaced through Trace Processor and the UI.
- /proc/slabinfo polling added to sys_stats for tracking kernel slab allocations.
- tracedperf gained a CPU filter for per-CPU sampling, and raw perf events can specify a dynamic PMU by name**.
- Any trace can now carry generic trace-level metadata for your own annotations. See
- Multi-machine tracing setups can restrict data sources to specific remote producers (traceallmachines in TraceConfig).
- Stack sampling can be filtered by source (user-space / kernel / hypervisor).
🌐 More importers
Perfetto can now ingest more formats end-to-end:
- ART Method v2 streaming traces from Android.
- Firefox profiler markers are imported as slices so you can correlate profiling information with high level timeline markers
☕ Java SDK
The Java SDK now understands @CompileTimeConstant annotations and static track names — so instrumentation can be more efficient when the compiler can prove the strings are constant.
📚 Refreshed documentation
The documentation site received a signifcant facelift
- Reorganised top-level table of contents.
- Filter chips for narrowing pages by topic (OS, role, cookbook, etc.).
- Refreshed typography, visuals, and navigation.
- Substantially rewritten or brand-new guides:
- PerfettoSQL getting started (rewritten)
- GPU data source (full rewrite)
- Symbolization & deobfuscation
- Heap Dump Explorer user guide
- heapprofile** with both host and android subcommands
- traceconv (rewritten from scratch)
- traceprocessor** shell + C++ embedding
- Multi-machine tracing with traced_relay
- Rust SDK getting started
- Periodic trace snapshots cookbook
- traceprocessor and traceconv on Windows**
- Community-maintained Chinese docs are now linked from the site.
⚠️ Breaking changes from previous releases
- The TraceMetadata proto was renamed to TraceAttributes`.
Perfetto v54.02026-03-02
``
v54.0 - 2026-02-27:
Tracing service and probes:
Breaking change: Removed TraceConfig.noflushbeforewriteintofile and
replaced it with TraceConfig.writeflushmode enum to provide more
granular control over flushing behavior when streaming traces into a file.
Breaking change for tracedrelay users: data sources no longer match
remote machine producers by default. To restore the previous behaviour,
set TraceConfig.traceallmachines to true.
* Added perfetto --no-clobber CLI option to prevent overwriting existing
files.
* Fixed a bug that would cause remote producers (data sources in VMs) to
lose data on the end of the trace due to lack of scraping.
Added android.userlist data source to list Android users.
Added support for FWTP counter traces and fwtpperfetto_slice ftrace
event.
* Added suppport for referring to target buffers by name rather than index.
Trace Processor:
* Added support for Collapsed Stack format (from Brendan Gregg's FlameGraph
tools). This format uses semicolon-separated stack frames with a count,
e.g., "main;foo;bar 100".
* Added support for Firefox Profiler's preprocessed JSON format.
* Removed deprecated RegisterSqlModule() C++ API (use
RegisterSqlPackage() instead) and
--add-sql-module/--override-sql-module shell flags (use
--add-sql-package/--override-sql-package instead). These were
deprecated in v48.0.
* Added support for specifying custom package names in --add-sql-package
and --override-sql-package flags using PATH[@PACKAGE] syntax. The
Python API now provides a SqlPackage class for typed configuration.
Breaking change: Removed stackid and parentstackid
columns from the slice table. The ancestorsliceby_stack and
descendantsliceby_stack table functions have been moved to the
slices.stack stdlib module. These features were poorly named and often
misused. See https://perfetto.dev/docs/analysis/perfetto-sql-backcompat
for migration guidance.
* Breaking change: TrackEvent log messages are now parsed into
"trackevent.logmessage.message" arg instead of "trackevent.logmessage"
to ensure that arg set can be converted into a valid json.
Breaking change: machineid is now a non-nullable column in all Trace
Processor tables. The host machine is now consistently represented by 0
instead of NULL.
* Breaking change: Refactored the metadata table to support multi-trace
and multi-machine traces. Added traceid and machineid columns to
associate entries with their specific context.
* Added support for R8 retracing during deobfuscation. Improves
deobfuscation quality for some supported profiling types.
SQL Standard library:
Added heapgraph_stats module and added dmabuf support.
Added intent and component columns to androidanrs table.
* Added relevant threads jank CUJ module and counter-based weighted jank
metrics.
UI:
* Added support for opening any public-readable https:// trace using url=
parameter. See https://perfetto.dev/docs/visualization/deep-linking-to-perfetto-ui#option-1-direct-url-for-public-traces
for more information.
* Changed the way heap profiles are rendered: rather than an arrow with a
snapshot from start, use a slice that represents the time period covered
since the last snapshot. Also support aggregation on area selection.
* Added summary tracks for slice tracks and merged them with scheduling
summaries.
* Added present configs to the recording page to allow easy configuration
of traces for common system health problems on Android and Chrome.
* Added capability to download trace config files in one click from
the recording page.
* Landed various improvements for DataGrid (table viewer component):
* Added configurable pivot table support.
* Added glob, contains, and not-contains filters.
* Added a distinct value picker for filters.
* Added snap-to-boundaries feature for precise time selection. When
dragging selection handles or creating area selections, the cursor
automatically snaps to nearby slice boundaries to enable exact
measurement of slice durations. Hold Alt to temporarily disable snapping.
* Performance optimizations:
* Improved dataset search performance
* Optimized visualization of argument values.
* Reduced jank when panning/zooming on busy tracks.
SDK:
* Added inotify support for UNIX sockets: if traced is unavailable or
crashes, on Linux and Android we reconnect immediately after the socket
has been recreated rather than relying on periodic retries.
* Added ClearIncrementalState method to data source traits to allow
data sources to have custom clearing logic instead of creating/destroying
state on every clear.
Misc:
* Added automatic detection of profile type when using traceconv profile.
* Upgraded standalone Bazel version to 8.5.0.
* Switched Bazel usage to be fully based on bzlmod as, on Bazel 8,
WORKSPACE builds are no longer supported.
``