# google/perfetto

**Attribution required: if you use, quote, or summarise this content, you must credit and link back to [awesome-repositories.com](https://awesome-repositories.com/repository/google-perfetto).**

5,558 stars · 698 forks · C++ · apache-2.0

## Links

- GitHub: https://github.com/google/perfetto
- Homepage: https://www.perfetto.dev
- awesome-repositories: https://awesome-repositories.com/repository/google-perfetto.md

## Description

Perfetto is a platform for system-level performance tracing and analysis on Linux and Android. It combines a high-throughput trace recorder, a SQL-based query engine, and a browser-based visualizer into a single toolchain. The platform covers CPU scheduling and call-stack profiling, native and Java heap memory allocation tracking, GPU and graphics events, and system-wide counters such as CPU frequency and power consumption.

The architecture decouples trace recording from offline analysis, using a compact protobuf format for event encoding and columnar storage for efficient SQL queries. The web UI renders multi-gigabyte timelines in the browser without a backend server, using virtual scrolling and WebGL. Perfetto also provides an instrumentation SDK for emitting custom trace events from C++, Rust, or Java code, and includes a dedicated memory profiler that captures heap snapshots, allocation call stacks, and object graphs for leak detection.

Beyond core tracing, the toolset offers command-line automation for batch trace collection and non-interactive analysis, plus import and export for formats such as Chrome JSON, Firefox profiles, Android Systrace, pprof, and Fuchsia traces. The trace processor supports a PerfettoSQL dialect with module imports, macro definitions, and span-join operators for complex correlation queries. The UI includes timeline navigation with flow events, track pinning and filtering, flamegraph visualization, and a command palette for keyboard-driven workflows. The viewer can also be embedded in external web pages via iframes and programmatic cross-window messaging.

Documentation and prebuilt binaries are available for Android, Linux, macOS, and Windows, with SDK bindings for Python and Rust.

## Tags

### System Administration & Monitoring

- [Performance Tracing Platforms](https://awesome-repositories.com/f/system-administration-monitoring/performance-tracing-platforms.md) — Records system-wide performance events and provides tools for visualization, SQL analysis and memory profiling.
- [Application Tracing Libraries](https://awesome-repositories.com/f/system-administration-monitoring/application-event-loggers/application-tracing-libraries.md) — Perfetto instruments C/C++ and Rust applications on desktop and embedded systems to capture timestamped events. ([source](https://www.perfetto.dev/docs/))
- [Profiling Event Annotations](https://awesome-repositories.com/f/system-administration-monitoring/application-event-loggers/profiling-event-annotations.md) — Marks code sections with TRACE_EVENT macros that profiling tools capture as duration slices and counters. ([source](https://www.perfetto.dev/docs/instrumentation/tracing-sdk))
- [System Call Tracing](https://awesome-repositories.com/f/system-administration-monitoring/diagnostic-tools/diagnostics/execution-tracers/kernel-tracing-frameworks/system-call-tracing.md) — Records system call numbers during execution and displays them alongside per-thread slices. ([source](https://www.perfetto.dev/docs/data-sources/syscalls))
- [Trace Recording](https://awesome-repositories.com/f/system-administration-monitoring/diagnostic-tools/diagnostics/execution-tracers/kernel-tracing-frameworks/system-call-tracing/trace-recording.md) — Records system-level performance traces capturing CPU scheduling, frequency, and app events. ([source](https://www.perfetto.dev/docs/getting-started/system-tracing))
- [Application Trace Event Recorders](https://awesome-repositories.com/f/system-administration-monitoring/diagnostic-tools/diagnostics/execution-tracers/kernel-tracing-frameworks/system-call-tracing/trace-recording/application-trace-event-recorders.md) — Perfetto records application-specific trace events through a client library API integrated with system-wide tracing. ([source](https://www.perfetto.dev/docs/design-docs/api-and-abi))
- [Background Trace Sessions](https://awesome-repositories.com/f/system-administration-monitoring/diagnostic-tools/diagnostics/execution-tracers/kernel-tracing-frameworks/system-call-tracing/trace-recording/background-trace-sessions.md) — Records trace sessions in the background, writing to a file without blocking the terminal. ([source](https://www.perfetto.dev/docs/learning-more/tracing-in-background))
- [Command-Line Trace Captures](https://awesome-repositories.com/f/system-administration-monitoring/diagnostic-tools/diagnostics/execution-tracers/kernel-tracing-frameworks/system-call-tracing/trace-recording/command-line-trace-captures.md) — Provides a CLI tool for recording system and application traces with protobuf-based session configuration. ([source](https://www.perfetto.dev/docs/reference/perfetto-cli))
- [Kernel Trace Event Recorders](https://awesome-repositories.com/f/system-administration-monitoring/diagnostic-tools/diagnostics/execution-tracers/kernel-tracing-frameworks/system-call-tracing/trace-recording/kernel-trace-event-recorders.md) — Captures kernel ftrace events using a provided configuration and writes a protobuf trace file. ([source](https://www.perfetto.dev/docs/getting-started/ftrace))
- [System and App Trace Recorders](https://awesome-repositories.com/f/system-administration-monitoring/diagnostic-tools/diagnostics/execution-tracers/kernel-tracing-frameworks/system-call-tracing/trace-recording/system-and-app-trace-recorders.md) — Records execution traces from system processes and application code for detailed performance data. ([source](https://cdn.jsdelivr.net/gh/google/perfetto@main/README.md))
- [Custom Application Event Recorders](https://awesome-repositories.com/f/system-administration-monitoring/diagnostic-tools/diagnostics/execution-tracers/kernel-tracing-frameworks/system-call-tracing/trace-recording/system-and-app-trace-recorders/custom-application-event-recorders.md) — Perfetto configures a tracing session to capture custom events from instrumented code and writes the output to a file. ([source](https://www.perfetto.dev/docs/getting-started/in-app-tracing))
- [System-Level Performance Trace Recorders](https://awesome-repositories.com/f/system-administration-monitoring/diagnostic-tools/diagnostics/execution-tracers/kernel-tracing-frameworks/system-call-tracing/trace-recording/system-level-performance-trace-recorders.md) — Records system-level performance traces by capturing kernel events, scheduling, syscalls, and counters. ([source](https://www.perfetto.dev/docs/getting-started/start-using-perfetto))
- [Tracing Session Managers](https://awesome-repositories.com/f/system-administration-monitoring/diagnostic-tools/diagnostics/execution-tracers/kernel-tracing-frameworks/system-call-tracing/trace-recording/tracing-session-managers.md) — Orchestrates multiple concurrent tracing sessions with secure buffer allocation. ([source](https://www.perfetto.dev/docs/reference/traced))
- [Scheduling Timeline Visualizers](https://awesome-repositories.com/f/system-administration-monitoring/execution-path-visualization/thread-execution-state-visualizers/execution-timeline-visualizers/scheduling-timeline-visualizers.md) — Displays kernel scheduling events as interactive timeline slices and per-thread tracks for inspecting thread states. ([source](https://www.perfetto.dev/docs/data-sources/cpu-scheduling))
- [Unified CPU-GPU Timeline Visualizers](https://awesome-repositories.com/f/system-administration-monitoring/execution-time-profilers/gpu-kernel-profilers/gpu-workload-activity-profilers/unified-cpu-gpu-timeline-visualizers.md) — Links host-side API calls to GPU kernel submissions and visualizes execution flows. ([source](https://www.perfetto.dev/docs/data-sources/gpu))
- [Execution Tracing](https://awesome-repositories.com/f/system-administration-monitoring/execution-tracing.md) — Marks start and end of synchronous code sections to measure elapsed time on a single thread. ([source](https://www.perfetto.dev/docs/getting-started/atrace))
- [Heap Graph Snapshot Analyzers](https://awesome-repositories.com/f/system-administration-monitoring/heap-memory-monitoring/heap-graph-snapshot-analyzers.md) — Queries object graphs from heap snapshots to identify retained objects and diagnose memory bloat. ([source](https://www.perfetto.dev/docs/analysis/perfetto-sql-getting-started))
- [Java Heap Snapshot Capturers](https://awesome-repositories.com/f/system-administration-monitoring/heap-memory-monitoring/java-heap-snapshot-capturers.md) — Records heap dumps of Java processes at trace points, preserving object allocations, class metadata, and references. ([source](https://www.perfetto.dev/docs/data-sources/java-heap-profiler))
- [System Metrics Collection](https://awesome-repositories.com/f/system-administration-monitoring/logging/system-metrics-collection.md) — Gathers per-process and system-level statistics from /proc and /sys including CPU, memory, and thread data. ([source](https://www.perfetto.dev/docs/reference/traced_probes))
- [Process Trace Data Contributors](https://awesome-repositories.com/f/system-administration-monitoring/monitoring-and-observability/execution-tracing-analysis/execution-tracing/process-lifecycle-tracing/process-trace-data-contributors.md) — Registers a process as a producer with the tracing service and writes data into shared memory. ([source](https://www.perfetto.dev/docs/concepts/service-model))
- [Tracing Control Interfaces](https://awesome-repositories.com/f/system-administration-monitoring/monitoring-and-observability/execution-tracing-analysis/execution-tracing/tracing-control-interfaces.md) — Controls trace sessions by configuring data sources, starting and stopping traces, and retrieving trace data via IPC or file output. ([source](https://www.perfetto.dev/docs/concepts/service-model))
- [Trace Service & Probe Initialization](https://awesome-repositories.com/f/system-administration-monitoring/monitoring-and-observability/execution-tracing-analysis/execution-tracing/tracing-control-interfaces/trace-service-probe-initialization.md) — Automatically bundles and starts the tracing service and system data probes from a single command. ([source](https://www.perfetto.dev/docs/reference/tracebox))
- [Metric and Performance Monitors](https://awesome-repositories.com/f/system-administration-monitoring/monitoring-and-observability/observability-platforms/metric-performance-monitors.md) — Polls Linux kernel metrics like CPU frequency, memory usage, and per-process stats at configurable intervals. ([source](https://www.perfetto.dev/docs/reference/trace-config-proto))
- [Numerical Data Recorders](https://awesome-repositories.com/f/system-administration-monitoring/numerical-data-visualizers/numerical-data-recorders.md) — Logs numeric data points over time to visualize trends like memory usage or framerate. ([source](https://www.perfetto.dev/docs/instrumentation/track-events))
- [Trace Data Producers](https://awesome-repositories.com/f/system-administration-monitoring/observability-tracing/trace-data-producers.md) — Provides a stable binary protocol for processes to contribute trace data to the system. ([source](https://www.perfetto.dev/docs/design-docs/api-and-abi))
- [Trace Data Recorders](https://awesome-repositories.com/f/system-administration-monitoring/observability-tracing/trace-data-recorders.md) — Ships a high-throughput trace recorder that captures system and application events. ([source](https://www.perfetto.dev/docs/getting-started/rust-sdk))
- [Frame Timing Trackers](https://awesome-repositories.com/f/system-administration-monitoring/performance-monitoring-tools/performance-resource-management/frame-rate-monitors/frame-timing-trackers.md) — Analyzes expected and actual frame durations to detect jank sources per application. ([source](https://www.perfetto.dev/docs/data-sources/frametimeline))
- [Programmatic Trace Analysis](https://awesome-repositories.com/f/system-administration-monitoring/programmatic-trace-analysis.md) — Defines and runs trace summaries that produce consistent, structured protobuf outputs for large-scale analysis. ([source](https://www.perfetto.dev/docs/analysis/getting-started))
- [SQL-Based Trace Queries](https://awesome-repositories.com/f/system-administration-monitoring/trace-querying/sql-based-trace-queries.md) — Treats recorded event data as relational tables queried with standard SQL.
- [Structured Metric Computation](https://awesome-repositories.com/f/system-administration-monitoring/trace-querying/sql-based-trace-queries/structured-metric-computation.md) — Processes trace data through user-defined SQL queries to generate structured tabular metrics. ([source](https://www.perfetto.dev/docs/analysis/trace-summary))
- [Trace Slice Search and Navigation](https://awesome-repositories.com/f/system-administration-monitoring/trace-querying/sql-based-trace-queries/trace-slice-search-and-navigation.md) — Searches timeline slices with pattern matching and navigates to matching events from query results. ([source](https://www.perfetto.dev/docs/getting-started/android-trace-analysis))
- [Execution Stack Samplers](https://awesome-repositories.com/f/system-administration-monitoring/trace-sampling/execution-stack-samplers.md) — Periodically samples call stacks from running processes to attribute CPU usage to specific functions. ([source](https://www.perfetto.dev/docs/))
- [Trace Visualization](https://awesome-repositories.com/f/system-administration-monitoring/trace-visualization.md) — Connects query output to chart and dashboard visualizations for trace data analysis. ([source](https://www.perfetto.dev/docs/design-docs/data-explorer-architecture))
- [Event Category Filters](https://awesome-repositories.com/f/system-administration-monitoring/tracing-configuration/event-category-filters.md) — Provides configuration patterns to select which event categories are traced at runtime. ([source](https://www.perfetto.dev/docs/instrumentation/track-events))
- [Tracing Session Parameter Definitions](https://awesome-repositories.com/f/system-administration-monitoring/tracing-configuration/tracing-session-parameter-definitions.md) — Uses protobuf configuration to define trace duration, buffers, and data sources. ([source](https://www.perfetto.dev/docs/concepts/config))
- [Function Auto-Instrumentation Macros](https://awesome-repositories.com/f/system-administration-monitoring/automatic-tracing-instrumentation/function-auto-instrumentation-macros.md) — Provides a procedural macro to automatically instrument functions and capture all parameters as debug annotations. ([source](https://www.perfetto.dev/docs/getting-started/rust-sdk))
- [System Call Event Augmenters](https://awesome-repositories.com/f/system-administration-monitoring/diagnostic-tools/diagnostics/execution-tracers/kernel-tracing-frameworks/system-call-tracing/system-call-event-augmenters.md) — Adds tracing of synchronization system calls to correlate lock operations with scheduling events. ([source](https://www.perfetto.dev/docs/case-studies/scheduling-blockages))
- [Concurrent Trace Sessions](https://awesome-repositories.com/f/system-administration-monitoring/diagnostic-tools/diagnostics/execution-tracers/kernel-tracing-frameworks/system-call-tracing/trace-recording/background-trace-sessions/concurrent-trace-sessions.md) — Supports running multiple independent tracing sessions in parallel for collecting different event types. ([source](https://www.perfetto.dev/docs/concepts/concurrent-tracing-sessions))
- [Android Trace Event Collectors](https://awesome-repositories.com/f/system-administration-monitoring/diagnostic-tools/diagnostics/execution-tracers/kernel-tracing-frameworks/system-call-tracing/trace-recording/command-line-trace-captures/android-trace-event-collectors.md) — Perfetto captures system and app trace events from Android processes as slices and counters. ([source](https://www.perfetto.dev/docs/data-sources/atrace))
- [Cross-Machine Trace Recorders](https://awesome-repositories.com/f/system-administration-monitoring/diagnostic-tools/diagnostics/execution-tracers/kernel-tracing-frameworks/system-call-tracing/trace-recording/cross-machine-trace-recorders.md) — Captures events from two Linux machines in one trace via producer IPC forwarding. ([source](https://www.perfetto.dev/docs/learning-more/multi-machine-tracing))
- [Memory Profilers](https://awesome-repositories.com/f/system-administration-monitoring/diagnostic-tools/diagnostics/memory-profilers.md) — Profiles heap memory by capturing native and Java heap allocations to identify leaks. ([source](https://cdn.jsdelivr.net/gh/google/perfetto@main/README.md))
- [Subsystem Energy Profilers](https://awesome-repositories.com/f/system-administration-monitoring/energy-management/subsystem-energy-profilers.md) — Measures energy drained by individual hardware subsystems using on-device power rail monitors. ([source](https://www.perfetto.dev/docs/data-sources/battery-counters))
- [Memory Event Histogram Recorders](https://awesome-repositories.com/f/system-administration-monitoring/event-monitoring-systems/kernel-event-tracers/event-distribution-histograms/memory-event-histogram-recorders.md) — Periodically records histograms of memory events like page faults and compaction for analysis. ([source](https://www.perfetto.dev/docs/data-sources/memory-counters))
- [Custom Kernel Tracepoint Parsers](https://awesome-repositories.com/f/system-administration-monitoring/event-monitoring-systems/kernel-event-tracers/tracepoint-monitoring/custom-kernel-tracepoint-parsers.md) — Extends the toolchain to parse custom kernel tracepoints via protobuf descriptors. ([source](https://www.perfetto.dev/docs/getting-started/ftrace))
- [Trace Event Details Panels](https://awesome-repositories.com/f/system-administration-monitoring/event-payload-inspections/trace-event-details-panels.md) — Opens detail panels for selected trace events and navigates between adjacent events. ([source](https://www.perfetto.dev/docs/visualization/perfetto-ui))
- [Low Memory Kill Tracers](https://awesome-repositories.com/f/system-administration-monitoring/kernel-event-observability/low-memory-kill-tracers.md) — Captures kernel and userspace low-memory killer events and OOM score adjustments to diagnose OOM conditions. ([source](https://www.perfetto.dev/docs/data-sources/memory-counters))
- [Dominator Tree Displays](https://awesome-repositories.com/f/system-administration-monitoring/memory-inspection/jvm-memory-analysis/dominator-tree-displays.md) — Displays the dominator tree to identify objects that gate the largest retained memory in heap dumps. ([source](https://www.perfetto.dev/docs/visualization/heap-dump-explorer))
- [Structured Metric Export](https://awesome-repositories.com/f/system-administration-monitoring/metrics-exporters/structured-metric-export.md) — Exports structured trace metric specifications with dimensions for offline reuse. ([source](https://www.perfetto.dev/docs/visualization/data-explorer))
- [Trace Data Mergers](https://awesome-repositories.com/f/system-administration-monitoring/monitoring-and-observability/execution-tracing-analysis/execution-tracing/process-lifecycle-tracing/process-trace-data-contributors/trace-data-mergers.md) — Merges data from CPU sampling, scheduling, frequency, and system call traces onto a single timeline for correlation. ([source](https://www.perfetto.dev/docs/getting-started/cpu-profiling))
- [Pluggable Trace Loaders](https://awesome-repositories.com/f/system-administration-monitoring/monitoring-and-observability/execution-tracing-analysis/execution-tracing/trace-customizers/pluggable-trace-loaders.md) — Defines a pluggable protocol for loading traces from different sources. ([source](https://www.perfetto.dev/docs/design-docs/batch-trace-processor))
- [Trigger-Based Tracing Lifecycles](https://awesome-repositories.com/f/system-administration-monitoring/monitoring-and-observability/execution-tracing-analysis/execution-tracing/trigger-based-tracing-lifecycles.md) — Provides trigger-based lifecycle control for trace sessions, enabling on-demand recording from external process signals. ([source](https://www.perfetto.dev/docs/concepts/config))
- [Trace Metadata](https://awesome-repositories.com/f/system-administration-monitoring/monitoring-and-observability/execution-tracing-analysis/trace-metadata.md) — Perfetto adds key-value context such as device model to computed metrics for cross-trace grouping. ([source](https://www.perfetto.dev/docs/analysis/trace-summary))
- [Power Data Collectors](https://awesome-repositories.com/f/system-administration-monitoring/monitoring-and-status-pages/device-power-monitors/power-data-collectors.md) — Collects power, battery, and charge statistics from Linux sysfs and Android HAL interfaces. ([source](https://www.perfetto.dev/docs/reference/traced_probes))
- [Browser Tracing](https://awesome-repositories.com/f/system-administration-monitoring/observability-tracing/browser-tracing.md) — Perfetto captures performance traces from a desktop browser across all open tabs. ([source](https://www.perfetto.dev/docs/getting-started/chrome-tracing))
- [Native Tracing Backend Integrations](https://awesome-repositories.com/f/system-administration-monitoring/performance-tracing-platforms/native-tracing-backend-integrations.md) — Perfetto integrates with operating system tracing backends such as Windows ETW, systemd journal, and QNX. ([source](https://www.perfetto.dev/docs/reference/trace-config-proto))
- [Wakeup Latency Measurements](https://awesome-repositories.com/f/system-administration-monitoring/resource-scheduling/kernel-schedulers/scheduling-delay-analysis/wakeup-latency-measurements.md) — Enables additional ftrace events to measure the time between a thread becoming runnable and its execution. ([source](https://www.perfetto.dev/docs/data-sources/cpu-scheduling))
- [SQL-Driven Track Generators](https://awesome-repositories.com/f/system-administration-monitoring/sql-driven-track-generators.md) — Generates slice or counter tracks from SQL queries, with optional pivoting for multiple tracks. ([source](https://www.perfetto.dev/docs/visualization/commands-automation-reference))
- [GPU Metric Gatherers](https://awesome-repositories.com/f/system-administration-monitoring/telemetry-collection/gpu-metric-gatherers.md) — Perfetto gathers GPU frequency, counters, memory usage, render stage timelines, and debug logs. ([source](https://www.perfetto.dev/docs/data-sources/gpu))
- [Trace Clock Domain Converters](https://awesome-repositories.com/f/system-administration-monitoring/trace-clock-domain-converters.md) — Converts event timestamps across different clock domains using ClockSnapshot packets. ([source](https://www.perfetto.dev/docs/concepts/clock-sync))
- [Batch Trace Loaders](https://awesome-repositories.com/f/system-administration-monitoring/trace-querying/sql-based-trace-queries/batch-trace-loaders.md) — Loads traces from filesystem paths, directory globs, or custom URI resolvers for batch SQL analysis. ([source](https://www.perfetto.dev/docs/analysis/batch-trace-processor))
- [Configurable Trace Summaries](https://awesome-repositories.com/f/system-administration-monitoring/trace-querying/sql-based-trace-queries/configurable-trace-summaries.md) — Computes configurable summaries of trace data based on user-defined metric specifications. ([source](https://www.perfetto.dev/docs/analysis/trace-processor-python))
- [Cross-Trace SQL Queryers](https://awesome-repositories.com/f/system-administration-monitoring/trace-querying/sql-based-trace-queries/cross-trace-sql-queryers.md) — Runs SQL queries across a batch of traces and returns results as Pandas or Polars DataFrames. ([source](https://www.perfetto.dev/docs/analysis/batch-trace-processor))
- [GPU Trace SQL Queries](https://awesome-repositories.com/f/system-administration-monitoring/trace-querying/sql-based-trace-queries/gpu-trace-sql-queries.md) — Ships SQL module functions for querying GPU counter intervals and kernel durations from traces. ([source](https://www.perfetto.dev/docs/data-sources/gpu))
- [Aggregated Stack Sample Analysis](https://awesome-repositories.com/f/system-administration-monitoring/trace-sampling/aggregated-stack-sample-analysis.md) — Queries aggregated profiling samples by call stack to identify hot functions and performance hotspots. ([source](https://www.perfetto.dev/docs/analysis/perfetto-sql-getting-started))
- [Backend Mode Selectors](https://awesome-repositories.com/f/system-administration-monitoring/tracing-configuration/backend-mode-selectors.md) — Selects between in-process or system daemon mode for trace collection. ([source](https://www.perfetto.dev/docs/instrumentation/tracing-sdk))

### Part of an Awesome List

- [Heap Profile Importers](https://awesome-repositories.com/f/awesome-lists/data/backend-as-a-service/heap-profile-importers.md) — Provides a CLI script to initiate, stop, and retrieve heap allocation profiles for memory analysis. ([source](https://www.perfetto.dev/docs/instrumentation/heapprofd-api))
- [On-Demand Snapshot Triggers](https://awesome-repositories.com/f/awesome-lists/data/backend-as-a-service/heap-profile-importers/on-demand-snapshot-triggers.md) — Forces a snapshot of all profiled processes at a specific moment by signaling the daemon. ([source](https://www.perfetto.dev/docs/data-sources/native-heap-profiler))
- [CPU Frequency](https://awesome-repositories.com/f/awesome-lists/data/sql-query-builders/cpu-frequency.md) — Exposes CPU frequency and idle states as SQL counters and a dedicated table for analysis. ([source](https://www.perfetto.dev/docs/data-sources/cpu-freq))
- [CPU Frequency and Idle State Recorders](https://awesome-repositories.com/f/awesome-lists/data/sql-query-builders/cpu-frequency/cpu-frequency-and-idle-state-recorders.md) — Captures CPU frequency and idle state changes through kernel instrumentation for performance analysis. ([source](https://www.perfetto.dev/docs/data-sources/cpu-freq))
- [Combined Frequency-Idle Tracks](https://awesome-repositories.com/f/awesome-lists/data/sql-query-builders/cpu-frequency/cpu-frequency-and-idle-state-recorders/combined-frequency-idle-tracks.md) — Renders a combined CPU track showing frequency as height and idle state as color. ([source](https://www.perfetto.dev/docs/data-sources/cpu-freq))
- [GPU Debugging and Profiling Suites](https://awesome-repositories.com/f/awesome-lists/devtools/debugging-and-profiling-tools/gpu-debugging-and-profiling-suites.md) — Captures GPU events, counters, and render stages to debug graphics performance and frame timing.
- [Allocation Loggers](https://awesome-repositories.com/f/awesome-lists/devtools/memory-allocators/allocation-loggers.md) — Ships a configurable Poisson-sampling allocator that records every malloc call to reduce overhead while capturing large allocations. ([source](https://www.perfetto.dev/docs/design-docs/heapprofd-design))
- [System-Wide Stat Pollers](https://awesome-repositories.com/f/awesome-lists/devtools/memory-and-system/system-wide-stat-pollers.md) — Reads /proc/stat, /proc/vmstat, and /proc/meminfo at intervals to collect system-level counters. ([source](https://www.perfetto.dev/docs/data-sources/memory-counters))
- [Trace Symbol and Deobfuscation Enrichers](https://awesome-repositories.com/f/awesome-lists/devtools/unpacking-and-deobfuscation/trace-symbol-and-deobfuscation-enrichers.md) — Enriches captured traces with native symbol tables and app-level deobfuscation mappings. ([source](https://www.perfetto.dev/docs/quickstart/traceconv))
- [Trace Symbol Resolvers](https://awesome-repositories.com/f/awesome-lists/devtools/unpacking-and-deobfuscation/trace-symbol-resolvers.md) — Converts raw instruction addresses and obfuscated method names into readable function names in traces. ([source](https://www.perfetto.dev/docs/learning-more/symbolization))

### Data & Databases

- [Trace Event Columnar Stores](https://awesome-repositories.com/f/data-databases/columnar-analytics/trace-event-columnar-stores.md) — Stores parsed trace events in a column-oriented database for fast analytic queries.
- [Trace Event Correlation Operators](https://awesome-repositories.com/f/data-databases/data-joins/sql-join-variants-and-use-cases/trace-event-correlation-operators.md) — Provides SQL operators for correlating trace events through span joins and flow functions. ([source](https://www.perfetto.dev/docs/analysis/perfetto-sql-getting-started))
- [UI-Embedded SQL Execution](https://awesome-repositories.com/f/data-databases/database-management-systems/database-systems-management/database-operations/sql-query-execution/ui-embedded-sql-execution.md) — Runs arbitrary SQL queries from the browser UI and displays results in a dedicated tab. ([source](https://www.perfetto.dev/docs/visualization/commands-automation-reference))
- [Custom Performance Counters](https://awesome-repositories.com/f/data-databases/event-tracking/custom-performance-counters.md) — Records named integer values over time from any thread as custom performance counters. ([source](https://www.perfetto.dev/docs/getting-started/atrace))
- [Time-Series Value Trackers](https://awesome-repositories.com/f/data-databases/event-tracking/metric-rate-tracking/time-series-value-trackers.md) — Records sampled metrics like memory usage or CPU frequency as counter tracks for continuous monitoring. ([source](https://www.perfetto.dev/docs/getting-started/converting))
- [Flat-File SQL Analysis](https://awesome-repositories.com/f/data-databases/flat-file-sql-analysis.md) — Applies SQL queries to analyze structured profiling data imported from pprof files. ([source](https://www.perfetto.dev/docs/design-docs/pprof-support))
- [Heap Flamegraph Visualizations](https://awesome-repositories.com/f/data-databases/in-memory-databases/in-memory-state-stores/heap-inspection-tools/production-heap-monitors/heap-visualization/heap-flamegraph-visualizations.md) — Renders aggregated unreleased or total allocation sizes and counts in a flamegraph to identify memory churn. ([source](https://www.perfetto.dev/docs/getting-started/memory-profiling))
- [Protobuf Serialization](https://awesome-repositories.com/f/data-databases/protobuf-serialization.md) — Encodes trace events in a compact, extensible binary format using Protocol Buffers.
- [Process Context Retrievers](https://awesome-repositories.com/f/data-databases/query-contexts/process-context-retrievers.md) — Fetches process names, IDs, and UIDs as join keys for trace analysis queries. ([source](https://www.perfetto.dev/docs/getting-started/android-trace-analysis))
- [Custom SQL Functions](https://awesome-repositories.com/f/data-databases/sql-aggregate-functions/custom-sql-functions.md) — Creates scalar or table-valued functions using a SQL SELECT statement for custom analysis logic. ([source](https://www.perfetto.dev/docs/analysis/perfetto-sql-syntax))
- [SQL Module Distributions](https://awesome-repositories.com/f/data-databases/sql-module-distributions.md) — Includes pre-built SQL modules providing high-level tables, views, and functions for trace analysis. ([source](https://www.perfetto.dev/docs/analysis/stdlib-docs))
- [Embedded SQL Query Engines](https://awesome-repositories.com/f/data-databases/sql-query-execution-engines/embedded-sql-query-engines.md) — Runs SQL queries on callstack and performance data using an embedded query engine in the UI. ([source](https://www.perfetto.dev/docs/getting-started/cpu-profiling))
- [Union All Result Combinations](https://awesome-repositories.com/f/data-databases/task-result-storage/query-result-persistence/union-all-result-combinations.md) — Unions, joins, or finds overlapping intervals across multiple query outputs for trace analysis. ([source](https://www.perfetto.dev/docs/design-docs/data-explorer-architecture))
- [Time Interval Operations](https://awesome-repositories.com/f/data-databases/time-series-sql-querying/time-interval-operations.md) — Converts counter data to intervals, intersects time ranges, and pairs events into slices for analysis. ([source](https://www.perfetto.dev/docs/visualization/data-explorer))
- [Point-In-Time Snapshots](https://awesome-repositories.com/f/data-databases/consistency-tuning/point-in-time-snapshots.md) — Captures a consistent snapshot of all active trace buffers without halting collection. ([source](https://www.perfetto.dev/docs/reference/android-version-notes))
- [Trace Analysis Extension Distributors](https://awesome-repositories.com/f/data-databases/data-analysis-visualization/analytical-platforms-engines/data-analysis-tools/extensible-analysis-platforms/trace-analysis-extension-distributors.md) — Distributes macros, SQL modules, and proto descriptors via HTTP for team reuse. ([source](https://www.perfetto.dev/docs/visualization/extending-the-ui))
- [Per-Process Resource Metrics](https://awesome-repositories.com/f/data-databases/data-analysis-visualization/telemetry-usage-analytics/metrics-collection/per-process-resource-metrics.md) — Queries per-process RSS, swap, and OOM scores from trace data using SQL modules. ([source](https://www.perfetto.dev/docs/getting-started/android-trace-analysis))
- [Trace Format Normalization](https://awesome-repositories.com/f/data-databases/data-format-converters/trace-format-normalization.md) — Converts binary trace files into text, JSON, HTML, or aggregated profile formats for external analysis. ([source](https://www.perfetto.dev/docs/quickstart/traceconv))
- [Trace Data Importers](https://awesome-repositories.com/f/data-databases/data-format-converters/trace-format-normalization/trace-data-importers.md) — Ingests trace data from Chrome JSON, Firefox Profiler, and pprof for unified analysis. ([source](https://www.perfetto.dev/docs/getting-started/other-formats))
- [Shared Identifier Highlighting](https://awesome-repositories.com/f/data-databases/data-joins/sql-join-variants-and-use-cases/trace-event-correlation-operators/shared-identifier-highlighting.md) — Highlights related trace events in the UI by assigning shared correlation identifiers. ([source](https://www.perfetto.dev/docs/reference/synthetic-track-event))
- [Query Result Transformations](https://awesome-repositories.com/f/data-databases/data-serialization-formats/structured-data-exporters/analysis-result-exporters/query-result-analysis/query-result-transformations.md) — Filters, sorts, aggregates, and paginates trace data query results for analysis. ([source](https://www.perfetto.dev/docs/design-docs/data-explorer-architecture))
- [Trace Performance Charts](https://awesome-repositories.com/f/data-databases/data-visualization-charts/scatter-charts/trace-performance-charts.md) — Generates interactive charts from trace query results for visual data exploration. ([source](https://www.perfetto.dev/docs/visualization/data-explorer))
- [Data Visualization Dashboards](https://awesome-repositories.com/f/data-databases/data-visualization-dashboards.md) — Ships a GUI tool for building interactive dashboards from trace data without writing SQL. ([source](https://www.perfetto.dev/docs/deployment/deploying-bigtrace-on-kubernetes))
- [Heap Dump Summary Views](https://awesome-repositories.com/f/data-databases/in-memory-databases/in-memory-state-stores/heap-inspection-tools/production-heap-monitors/heap-visualization/heap-dump-summary-views.md) — Shows an overview with reachable instance count, per-heap bytes, and duplicate detection for common types. ([source](https://www.perfetto.dev/docs/visualization/heap-dump-explorer))
- [Metric Definition Templates](https://awesome-repositories.com/f/data-databases/sql-metric-definitions/metric-definition-templates.md) — Generates multiple related trace metrics from a single reusable query specification. ([source](https://www.perfetto.dev/docs/analysis/trace-summary))
- [Heap Graph SQL Editors](https://awesome-repositories.com/f/data-databases/sql-query-editors/heap-graph-sql-editors.md) — Exposes heap object, class, and reference data as relational tables for custom queries. ([source](https://www.perfetto.dev/docs/data-sources/java-heap-profiler))
- [System State Querying](https://awesome-repositories.com/f/data-databases/sql-query-interfaces/system-state-querying.md) — Queries SurfaceFlinger layer visibility and WindowManager containers through SQL tables. ([source](https://www.perfetto.dev/docs/analysis/sql-tables))
- [Heap Allocation SQL Profilers](https://awesome-repositories.com/f/data-databases/sql-query-profilers/heap-allocation-sql-profilers.md) — Analyzes heap profile data using SQL queries against tables of call stacks and allocations. ([source](https://www.perfetto.dev/docs/data-sources/native-heap-profiler))
- [Table Discovery](https://awesome-repositories.com/f/data-databases/table-discovery.md) — Automatically generates a starting query graph from all populated trace tables. ([source](https://www.perfetto.dev/docs/visualization/data-explorer))
- [Analytic Table Optimizations](https://awesome-repositories.com/f/data-databases/virtual-table-querying/table-creation/analytic-table-optimizations.md) — Creates read-only tables from SQL queries optimized for analytic performance on trace data. ([source](https://www.perfetto.dev/docs/analysis/perfetto-sql-syntax))
- [Visual Query Builders](https://awesome-repositories.com/f/data-databases/visual-query-builders.md) — Provides a visual canvas for constructing trace query pipelines without writing SQL. ([source](https://www.perfetto.dev/docs/visualization/data-explorer))

### Development Tools & Productivity

- [Runtime Call-Stack Capturers](https://awesome-repositories.com/f/development-tools-productivity/call-stack-navigators/runtime-call-stack-capturers.md) — Perfetto samples callstacks triggered by performance counter events and unwinds them without instrumentation. ([source](https://www.perfetto.dev/docs/getting-started/cpu-profiling))
- [Custom Trace Data Source Implementations](https://awesome-repositories.com/f/development-tools-productivity/custom-trace-data-source-implementations.md) — Implements custom trace data sources that emit strongly-typed packets via subclassing and registration. ([source](https://www.perfetto.dev/docs/instrumentation/tracing-sdk))
- [CPU Profilers](https://awesome-repositories.com/f/development-tools-productivity/debugging-profiling-testing/debugging-diagnostics/performance-resource-profilers/cpu-profilers.md) — Sampling call stacks and heap allocations to identify CPU hotspots, memory leaks, and allocation patterns.
- [Detachable Editor Sessions](https://awesome-repositories.com/f/development-tools-productivity/editor-session-management/detachable-editor-sessions.md) — Decouples trace sessions from the CLI, allowing tracing to continue after the client exits using a session key. ([source](https://www.perfetto.dev/docs/concepts/detached-mode))
- [Event Flow Visualizers](https://awesome-repositories.com/f/development-tools-productivity/event-flow-visualizers.md) — Connects related slices across different tracks using flow events in the timeline. ([source](https://www.perfetto.dev/docs/instrumentation/track-events))
- [Headless Trace Analysis Commands](https://awesome-repositories.com/f/development-tools-productivity/non-interactive-cli-modes/headless-trace-analysis-commands.md) — Provides one-shot CLI commands for querying, summarizing, converting, and serving traces without an interactive session. ([source](https://www.perfetto.dev/docs/analysis/trace-processor))
- [Time-Bounded Operation Recordings](https://awesome-repositories.com/f/development-tools-productivity/time-bounded-operation-recordings.md) — Perfetto marks the start and end of operations to capture their duration in a trace. ([source](https://www.perfetto.dev/docs/instrumentation/track-events))
- [Trace Data Source Definitions](https://awesome-repositories.com/f/development-tools-productivity/trace-data-source-definitions.md) — Defines custom trace data sources with protobuf schemas for configuration and packet emission. ([source](https://www.perfetto.dev/docs/concepts/service-model))
- [Trace Event Emissions](https://awesome-repositories.com/f/development-tools-productivity/trace-event-emissions.md) — Perfetto records scoped, begin/end, and instant trace events with user-defined categories and debug arguments. ([source](https://www.perfetto.dev/docs/getting-started/rust-sdk))
- [Trace Event Extension Fields](https://awesome-repositories.com/f/development-tools-productivity/trace-event-extension-fields.md) — Perfetto defines protobuf extension fields on track events, delivers descriptors for parsing, and writes them from any language. ([source](https://www.perfetto.dev/docs/instrumentation/extensions))
- [Profile-Based Stack Reconstructors](https://awesome-repositories.com/f/development-tools-productivity/asynchronous-debugging-toolkits/asynchronous-stack-trace-reconstruction/profile-based-stack-reconstructors.md) — Retrieves and assembles full call stacks from profiling data using frame and callsite identifiers. ([source](https://www.perfetto.dev/docs/analysis/builtin))
- [Named UI Command Sequences](https://awesome-repositories.com/f/development-tools-productivity/cli-command-frameworks/command-chaining/macro-sequences/named-ui-command-sequences.md) — Defines named sequences of UI commands triggered from the command palette. ([source](https://www.perfetto.dev/docs/visualization/ui-automation))
- [Shared Analysis Macros](https://awesome-repositories.com/f/development-tools-productivity/cli-command-frameworks/command-chaining/macro-sequences/shared-analysis-macros.md) — Hosts shared trace-analysis macros that appear in the command palette for team reuse. ([source](https://www.perfetto.dev/docs/visualization/extension-servers))
- [Command Palettes](https://awesome-repositories.com/f/development-tools-productivity/command-execution-interfaces/command-palettes.md) — Triggers UI actions by typing their name into a fuzzy-matching command palette. ([source](https://www.perfetto.dev/docs/visualization/ui-automation))
- [Command Palettes](https://awesome-repositories.com/f/development-tools-productivity/command-palettes.md) — Provides a fuzzy-searchable command palette for executing common UI tasks via keyboard. ([source](https://www.perfetto.dev/docs/visualization/perfetto-ui))
- [Programmatic Trace Inspectors](https://awesome-repositories.com/f/development-tools-productivity/debugging-profiling-testing/debugging-diagnostics/execution-trace-log-analyzers/trace-inspection-tools/programmatic-trace-inspectors.md) — Exposes an API to programmatically open traces in the viewer using cross-window messaging. ([source](https://www.perfetto.dev/docs/visualization/deep-linking-to-perfetto-ui))
- [Stack Unwinding Offloaders](https://awesome-repositories.com/f/development-tools-productivity/dynamic-variable-evaluators/stack-frame-inspectors/native-stack-unwinders/stack-unwinding-offloaders.md) — Sends raw stack data to a separate daemon for unwinding so the profiled process resumes quickly. ([source](https://www.perfetto.dev/docs/design-docs/heapprofd-design))
- [Initialization Command Sequences](https://awesome-repositories.com/f/development-tools-productivity/terminal-shell-cli/cli-tooling-frameworks/cli-tooling/argument-configuration-management/command-configurations/initialization-command-sequences.md) — Runs a predefined sequence of commands automatically each time a session opens. ([source](https://www.perfetto.dev/docs/visualization/ui-automation))
- [Trace Event Callstack Attachments](https://awesome-repositories.com/f/development-tools-productivity/trace-event-callstack-attachments.md) — Embeds call stack sequences in trace events to reveal code paths during performance analysis. ([source](https://www.perfetto.dev/docs/getting-started/converting))
- [GPU Trace Event Types](https://awesome-repositories.com/f/development-tools-productivity/trace-event-extension-fields/gpu-trace-event-types.md) — Perfetto emits GPU counter events, render stage events, and Vulkan events into the trace using dedicated protobuf fields. ([source](https://www.perfetto.dev/docs/getting-started/rust-sdk))
- [URL-Based File Openers](https://awesome-repositories.com/f/development-tools-productivity/url-based-file-openers.md) — Allows users to open a publicly accessible trace file directly in the viewer by specifying the URL as a parameter. ([source](https://www.perfetto.dev/docs/visualization/deep-linking-to-perfetto-ui))

### DevOps & Infrastructure

- [On-Demand Daemon Launching](https://awesome-repositories.com/f/devops-infrastructure/daemon-management/on-demand-daemon-launching.md) — Dynamically launches tracing daemons when data sources are requested and stops them after idle periods. ([source](https://www.perfetto.dev/docs/reference/traced))
- [CPU Scheduling Policies](https://awesome-repositories.com/f/devops-infrastructure/task-scheduling-policies/cpu-scheduling-policies.md) — Queries kernel scheduling slices and thread states to reconstruct per-thread CPU timelines for execution analysis. ([source](https://www.perfetto.dev/docs/analysis/sql-tables))
- [CPU Scheduling Event Recorders](https://awesome-repositories.com/f/devops-infrastructure/task-scheduling-policies/cpu-scheduling-policies/cpu-scheduling-event-recorders.md) — Captures fine-grained kernel scheduling events via ftrace for thread execution pattern analysis. ([source](https://www.perfetto.dev/docs/data-sources/cpu-scheduling))
- [Remote Trace Resolvers](https://awesome-repositories.com/f/devops-infrastructure/cloud-infrastructure/cloud-service-mocks/base-uri-resolvers/remote-trace-resolvers.md) — Registers custom Python resolvers that fetch trace bytes from remote or cloud storage. ([source](https://www.perfetto.dev/docs/analysis/batch-trace-processor))
- [Context Switch Callstack Samplers](https://awesome-repositories.com/f/devops-infrastructure/task-scheduling-policies/cpu-scheduling-policies/cpu-scheduling-event-recorders/context-switch-callstack-samplers.md) — Perfetto records samples triggered by context switches for lock contention analysis. ([source](https://www.perfetto.dev/docs/case-studies/scheduling-blockages))

### Graphics & Multimedia

- [Flamegraph Renderers](https://awesome-repositories.com/f/graphics-multimedia/canvas-rendering/flamegraph-renderers.md) — Renders interactive flamegraph views from callstack samples over selected time regions. ([source](https://www.perfetto.dev/docs/getting-started/cpu-profiling))
- [Heap Profile Flamegraph Views](https://awesome-repositories.com/f/graphics-multimedia/canvas-rendering/flamegraph-renderers/heap-profile-flamegraph-views.md) — Displays allocation summaries as interactive flamegraph slices in the web UI for memory analysis. ([source](https://www.perfetto.dev/docs/data-sources/native-heap-profiler))
- [Memory Allocation](https://awesome-repositories.com/f/graphics-multimedia/canvas-rendering/flamegraph-renderers/memory-allocation.md) — Renders captured heap dump data as interactive flamegraphs that reveal allocation depth for analysis. ([source](https://www.perfetto.dev/docs/data-sources/java-heap-profiler))
- [Timeline Track Hierarchies](https://awesome-repositories.com/f/graphics-multimedia/element-organizers/ui-hierarchy-organizers/timeline-track-hierarchies.md) — Provides an interactive timeline where related trace tracks are nested under expandable parent containers for structured navigation. ([source](https://www.perfetto.dev/docs/getting-started/converting))
- [Large Trace Renderers](https://awesome-repositories.com/f/graphics-multimedia/graphics-engines-rendering/rendering/systems/dom-web-rendering-strategies/client-side-rendering/large-trace-renderers.md) — Renders multi-gigabyte trace timelines entirely in the browser using virtual scrolling and WebGL.
- [Timeline Visualization Tools](https://awesome-repositories.com/f/graphics-multimedia/timeline-visualization-tools.md) — Represents activities as intervals on visual timeline tracks with start time and duration for trace analysis. ([source](https://www.perfetto.dev/docs/getting-started/converting))
- [Bitmap Preview Galleries](https://awesome-repositories.com/f/graphics-multimedia/bitmap-rendering/bitmap-preview-galleries.md) — Renders bitmap instances as a gallery with dimensions, DPI, and reference path overlays for inspection. ([source](https://www.perfetto.dev/docs/visualization/heap-dump-explorer))
- [Flamegraph Navigation Views](https://awesome-repositories.com/f/graphics-multimedia/canvas-rendering/flamegraph-renderers/flamegraph-navigation-views.md) — Opens a new tab with every object allocated along a selected flamegraph path for comparison. ([source](https://www.perfetto.dev/docs/visualization/heap-dump-explorer))
- [pprof](https://awesome-repositories.com/f/graphics-multimedia/canvas-rendering/flamegraph-renderers/pprof.md) — Renders interactive flamegraph charts from imported pprof profile data. ([source](https://www.perfetto.dev/docs/design-docs/pprof-support))
- [Display Event Captures](https://awesome-repositories.com/f/graphics-multimedia/display-event-captures.md) — Perfetto captures GPU command execution, layer composition, display timing, and window transitions. ([source](https://www.perfetto.dev/docs/reference/trace-config-proto))
- [System Event Track Organizers](https://awesome-repositories.com/f/graphics-multimedia/instrument-track-assignments/track-organization/system-event-track-organizers.md) — Organizes trace events onto distinct timeline tracks based on thread, process, or custom identifiers. ([source](https://www.perfetto.dev/docs/instrumentation/track-events))

### Networking & Communication

- [Tracing Session Lifecycle Controllers](https://awesome-repositories.com/f/networking-communication/api-integration-frameworks/communication-apis/messaging-platform-integrations/whatsapp-integrations/tracing-session-lifecycle-controllers.md) — Starts or stops tracing on event triggers, delays start, limits sessions, and filters output. ([source](https://www.perfetto.dev/docs/reference/trace-config-proto))
- [Dependency Flow Arrows](https://awesome-repositories.com/f/networking-communication/communication-protocols-architectures/communication-paradigms/client-to-server-event-emission/ui-interaction-events/dependency-flow-arrows.md) — Draws arrows between trace slices on different tracks to visualize event dependencies. ([source](https://www.perfetto.dev/docs/getting-started/converting))

### Operating Systems & Systems Programming

- [Ftrace Utilities](https://awesome-repositories.com/f/operating-systems-systems-programming/ftrace-utilities.md) — Captures high-frequency kernel events like scheduling, system calls, and interrupts via ftrace. ([source](https://www.perfetto.dev/docs/reference/traced_probes))
- [Java Heap Dump Capturers](https://awesome-repositories.com/f/operating-systems-systems-programming/heap-analyzers/java-heap-dump-capturers.md) — Captures snapshots of the Java object graph to analyze object references and memory usage. ([source](https://www.perfetto.dev/docs/case-studies/memory))
- [Heap Allocation Tracers](https://awesome-repositories.com/f/operating-systems-systems-programming/kernel-core-internals/process-and-memory-management/memory-management/allocation-strategies/dynamic-memory-allocation/memory-allocation-tracers/heap-allocation-tracers.md) — Captures native and Java heap allocations, stack traces and object graphs to diagnose memory leaks and churn.
- [Trace Buffer Managers](https://awesome-repositories.com/f/operating-systems-systems-programming/kernel-core-internals/process-and-memory-management/memory-management/buffer-and-cache-management/binary-buffer-managers/trace-buffer-managers.md) — Uses ring buffers for continuous high-frequency trace data collection. ([source](https://www.perfetto.dev/docs/getting-started/periodic-trace-snapshots))
- [Performance Counter Sampling](https://awesome-repositories.com/f/operating-systems-systems-programming/performance-counter-sampling.md) — Samples per-CPU hardware counters based on a configurable timebase event and frequency for detailed performance measurement. ([source](https://www.perfetto.dev/docs/getting-started/cpu-profiling))
- [Scheduler Analysis Tools](https://awesome-repositories.com/f/operating-systems-systems-programming/scheduler-analysis-tools.md) — Provides a query engine that exposes scheduling slices and thread states as relational tables for custom analysis. ([source](https://www.perfetto.dev/docs/analysis/perfetto-sql-getting-started))
- [Custom Allocator Instrumentation](https://awesome-repositories.com/f/operating-systems-systems-programming/kernel-core-internals/process-and-memory-management/memory-management/allocation-strategies/dynamic-memory-allocation/custom-memory-allocators/custom-allocator-instrumentation.md) — Provides an API for custom allocators to report allocation and free events via registration and reporting function calls. ([source](https://www.perfetto.dev/docs/instrumentation/heapprofd-api))
- [Heap Allocation Call Stack Recorders](https://awesome-repositories.com/f/operating-systems-systems-programming/kernel-core-internals/process-and-memory-management/memory-management/allocation-strategies/dynamic-memory-allocation/memory-allocation-tracers/heap-allocation-tracers/heap-allocation-call-stack-recorders.md) — Records full call stacks for every heap allocation and deallocation event on Android and Linux to enable detailed memory analysis. ([source](https://www.perfetto.dev/docs/data-sources/native-heap-profiler))
- [Heap Profile Recorders](https://awesome-repositories.com/f/operating-systems-systems-programming/kernel-core-internals/process-and-memory-management/memory-management/allocation-strategies/dynamic-memory-allocation/memory-allocation-tracers/heap-allocation-tracers/heap-profile-recorders.md) — Captures native memory allocation traces from a process on Android or Linux, supporting continuous snapshots. ([source](https://www.perfetto.dev/docs/reference/heap_profile-cli))
- [Kernel Memory Event Tracers](https://awesome-repositories.com/f/operating-systems-systems-programming/kernel-core-internals/process-and-memory-management/memory-management/allocation-strategies/dynamic-memory-allocation/memory-allocation-tracers/kernel-memory-event-tracers.md) — Captures kernel memory events like RSS, ION usage, and memory pressure to visualize consumption over time. ([source](https://www.perfetto.dev/docs/case-studies/memory))
- [Mmap Syscall Profilers](https://awesome-repositories.com/f/operating-systems-systems-programming/kernel-core-internals/process-and-memory-management/memory-management/allocation-strategies/dynamic-memory-allocation/system-memory-allocation/mmap-allocation-utilities/mmap-syscall-profilers.md) — Records every mmap syscall with arguments and call stacks to find direct kernel memory allocations. ([source](https://www.perfetto.dev/docs/case-studies/memory))
- [Kernel Event Track Definitions](https://awesome-repositories.com/f/operating-systems-systems-programming/kernel-event-track-definitions.md) — Structures kernel event fields so the viewer auto-renders them as timeline tracks. ([source](https://www.perfetto.dev/docs/reference/kernel-track-event))
- [Object Reference Path Inspectors](https://awesome-repositories.com/f/operating-systems-systems-programming/object-reference-path-inspectors.md) — Opens a detailed view showing reference paths, dominator paths, and field details for heap objects. ([source](https://www.perfetto.dev/docs/visualization/heap-dump-explorer))

### Software Engineering & Architecture

- [Asynchronous Tracing](https://awesome-repositories.com/f/software-engineering-architecture/asynchronous-tracing.md) — Records begin and end events of logical operations spanning multiple threads using unique cookies. ([source](https://www.perfetto.dev/docs/getting-started/atrace))
- [Collection and Analysis Decoupling](https://awesome-repositories.com/f/software-engineering-architecture/collection-and-analysis-decoupling.md) — Separates trace recording from offline analysis for independent scaling of workloads.
- [Multi-Process Trace Orchestrators](https://awesome-repositories.com/f/software-engineering-architecture/event-driven-architectures/activity-tracing/multi-consumer-trace-distributors/multi-process-trace-orchestrators.md) — Coordinates producers and consumers, manages shared trace buffers, and routes configuration for multi-process tracing. ([source](https://www.perfetto.dev/docs/concepts/service-model))
- [Tracing Instrumentation](https://awesome-repositories.com/f/software-engineering-architecture/tracing-instrumentation.md) — Instruments application code with custom trace events via SDKs to visualize internal execution on the timeline. ([source](https://www.perfetto.dev/docs/getting-started/start-using-perfetto))
- [Real-Time Trace Collectors](https://awesome-repositories.com/f/software-engineering-architecture/tracing-instrumentation/trace-filters/trace-packet-interceptors/real-time-trace-collectors.md) — Activates data sources, streams trace packets from producers to a shared buffer, and delivers them to a consumer in real time. ([source](https://www.perfetto.dev/docs/design-docs/life-of-a-tracing-session))
- [Protobuf Schema Decoders](https://awesome-repositories.com/f/software-engineering-architecture/custom-format-decoders/protobuf-schema-decoders.md) — Supplies protobuf schemas to decode custom event payloads in traces. ([source](https://www.perfetto.dev/docs/visualization/extension-server-protocol))
- [Multi-Consumer Trace Distributors](https://awesome-repositories.com/f/software-engineering-architecture/event-driven-architectures/activity-tracing/multi-consumer-trace-distributors.md) — Intercepts trace packets and routes them to custom handlers instead of the default pipeline for external processing. ([source](https://www.perfetto.dev/docs/reference/trace-config-proto))
- [Log Event Enrichment](https://awesome-repositories.com/f/software-engineering-architecture/event-logging/log-event-enrichment.md) — Enriches trace events with key-value metadata such as request IDs and error codes for inspection. ([source](https://www.perfetto.dev/docs/getting-started/converting))
- [Producer-Consumer Access Isolators](https://awesome-repositories.com/f/software-engineering-architecture/event-sourcing/event-consumers/custom-data-consumers/producer-consumer-access-isolators.md) — Separates public producer endpoints from restricted consumer sockets so only trusted consumers read data. ([source](https://www.perfetto.dev/docs/design-docs/security-model))
- [Standalone Service Component Execution](https://awesome-repositories.com/f/software-engineering-architecture/integration-extensibility/extensibility/plugin-architectures/application-plugins/dynamic-component-invocation/standalone-service-component-execution.md) — Invokes any individual tracing service component as a standalone process for flexible deployment. ([source](https://www.perfetto.dev/docs/reference/tracebox))
- [Custom Module Implementations](https://awesome-repositories.com/f/software-engineering-architecture/integration-extensibility/extensibility/plugin-architectures/developer-authoring-interfaces/custom-module-implementations.md) — Runs TypeScript modules that add custom tracks, tabs, commands, and visualizations. ([source](https://www.perfetto.dev/docs/visualization/extending-the-ui))
- [Periodic Trace Disk Persisters](https://awesome-repositories.com/f/software-engineering-architecture/periodic-trace-disk-persisters.md) — Periodically streams in-memory trace buffers to disk for large trace sessions. ([source](https://www.perfetto.dev/docs/concepts/config))
- [Scheduling Blockage Visualizers](https://awesome-repositories.com/f/software-engineering-architecture/request-validation/validation-chains/wakeup-chain-mappers/scheduling-blockage-visualizers.md) — Visualizes sequences of thread wakeups to identify scheduling blockages and dependencies. ([source](https://www.perfetto.dev/docs/case-studies/scheduling-blockages))
- [Time Interval Filtering](https://awesome-repositories.com/f/software-engineering-architecture/sorting-algorithms/merge-sorts/interval-merging-algorithms/interval-querying/time-interval-filtering.md) — Filters trace query results to include only rows overlapping with specified time intervals. ([source](https://www.perfetto.dev/docs/analysis/trace-summary))
- [Timestamp-Based Trace Merge Sorters](https://awesome-repositories.com/f/software-engineering-architecture/sorting-algorithms/merge-sorts/timestamp-based-trace-merge-sorters.md) — Merges and sorts trace events from multiple streams by timestamp with a windowed algorithm. ([source](https://www.perfetto.dev/docs/design-docs/trace-processor-architecture))
- [Profile Symbolizers and Deobfuscators](https://awesome-repositories.com/f/software-engineering-architecture/symbol-resolution-engines/profile-symbol-cleaners/profile-symbolizers-and-deobfuscators.md) — Replaces raw addresses and obfuscated Java or Kotlin names with readable function names in profiles. ([source](https://www.perfetto.dev/docs/data-sources/native-heap-profiler))
- [Trace Analysis Workspaces](https://awesome-repositories.com/f/software-engineering-architecture/trace-analysis-workspaces.md) — Manages named workspaces to organize trace analysis tracks into focused compartments. ([source](https://www.perfetto.dev/docs/visualization/commands-automation-reference))
- [Process Name Tracepoint Filters](https://awesome-repositories.com/f/software-engineering-architecture/tracing-instrumentation/trace-filters/static-tracepoint-filtering/process-name-tracepoint-filters.md) — Applies kernel-level string filters to tracepoint fields to record events for specified threads. ([source](https://www.perfetto.dev/docs/case-studies/scheduling-blockages))
- [Trace Packet Interceptors](https://awesome-repositories.com/f/software-engineering-architecture/tracing-instrumentation/trace-filters/trace-packet-interceptors.md) — Provides a mechanism to intercept and redirect trace packets to user-defined handlers for custom processing. ([source](https://www.perfetto.dev/docs/instrumentation/interceptors))

### Web Development

- [Trace Visualizers](https://awesome-repositories.com/f/web-development/browser-rendering/trace-visualizers.md) — Renders multi-gigabyte system trace timelines interactively in the browser without a backend server.
- [Text-Based Command Dispatchers](https://awesome-repositories.com/f/web-development/routing-systems/routing/matching-algorithms/regex-based-url-dispatchers/text-based-command-dispatchers.md) — Sends text commands to trigger actions like opening a help dialog or reloading styles via the viewer's command palette. ([source](https://www.perfetto.dev/docs/visualization/embedding-api-reference))

### Artificial Intelligence & ML

- [Tracing SDK Integrations](https://awesome-repositories.com/f/artificial-intelligence-ml/tracing-sdk-integrations.md) — Routes span and event data from the Rust tracing crate into the system-wide trace pipeline. ([source](https://www.perfetto.dev/docs/getting-started/rust-sdk))

### Content Management & Publishing

- [Trace](https://awesome-repositories.com/f/content-management-publishing/file-size-optimizations/trace.md) — Reduces trace file size via interning and incremental packet writing. ([source](https://www.perfetto.dev/docs/reference/synthetic-track-event))

### Mobile Development

- [Log Event Recorders](https://awesome-repositories.com/f/mobile-development/android-log-management/log-event-recorders.md) — Perfetto records Android log events into a trace, synchronized with other trace data, enabling long-duration log capture. ([source](https://www.perfetto.dev/docs/data-sources/android-log))
- [Trace Log and State Collectors](https://awesome-repositories.com/f/mobile-development/android-log-management/trace-log-and-state-collectors.md) — Perfetto streams logcat messages and periodically polls system properties, packages, CPU, wakelocks, and display state. ([source](https://www.perfetto.dev/docs/reference/traced_probes))

### Programming Languages & Runtimes

- [Custom Macro Definitions](https://awesome-repositories.com/f/programming-languages-runtimes/language-features-paradigms/metaprogramming-macros/custom-macro-definitions.md) — Runs sequences of analysis actions triggered from a trace viewer extension. ([source](https://www.perfetto.dev/docs/visualization/extension-server-protocol))
- [SQL Macros](https://awesome-repositories.com/f/programming-languages-runtimes/language-features-paradigms/metaprogramming-macros/custom-macro-definitions/sql-macros.md) — Defines syntactic SQL macros that expand before execution for flexible trace query templates. ([source](https://www.perfetto.dev/docs/analysis/perfetto-sql-syntax))
- [Retained Size Class Browsers](https://awesome-repositories.com/f/programming-languages-runtimes/language-features-paradigms/ownership-borrowing/reference-counting/retain-count-calculation-analyzers/retained-size-class-browsers.md) — Lists every class in a heap dump sorted by retained bytes, showing count, shallow, and retained sizes. ([source](https://www.perfetto.dev/docs/visualization/heap-dump-explorer))
- [Protobuf Descriptor Loading](https://awesome-repositories.com/f/programming-languages-runtimes/protobuf-descriptor-loading.md) — Delivers protobuf descriptors from an HTTP server so the UI decodes custom message types. ([source](https://www.perfetto.dev/docs/visualization/extension-servers))

### Testing & Quality Assurance

- [GPU Trace Track Organizers](https://awesome-repositories.com/f/testing-quality-assurance/performance-testing-analysis/performance-profiling/gpu-performance-profilers/gpu-hardware-metric-visualizers/gpu-trace-track-organizers.md) — Organizes GPU traces into timelines by device and process, displaying per-kernel metric tables and details. ([source](https://www.perfetto.dev/docs/data-sources/gpu))

### User Interface & Experience

- [Event Field Definitions](https://awesome-repositories.com/f/user-interface-experience/field-customization/model-field-definitions/event-field-definitions.md) — Extends track events with protobuf-encoded fields automatically parsed and stored for SQL analysis. ([source](https://www.perfetto.dev/docs/reference/synthetic-track-event))
- [Per-Process Memory Stat Pollers](https://awesome-repositories.com/f/user-interface-experience/form-and-input-management/interaction-and-event-handling/event-handling-architectures/event-handling-systems/event-queue-polling/kernel-event-polling/procfs-polling-monitors/per-process-memory-stat-pollers.md) — Polls /proc/pid/status and /proc/pid/oom_score_adj at configurable intervals to track memory and OOM scores. ([source](https://www.perfetto.dev/docs/data-sources/memory-counters))
- [Inline Viewer Integration](https://awesome-repositories.com/f/user-interface-experience/image-embeddings/inline-viewer-integration.md) — Provides an embeddable trace viewer that can be integrated into third-party web pages via iframe and programmatic data feeding. ([source](https://www.perfetto.dev/docs/visualization/embedding-the-ui))
- [Process-Scoped Track Assignments](https://awesome-repositories.com/f/user-interface-experience/process-scoped-track-assignments.md) — Defines custom timeline tracks explicitly linked to specific OS processes and threads with descriptions. ([source](https://www.perfetto.dev/docs/reference/synthetic-track-event))
- [Row Pinning](https://awesome-repositories.com/f/user-interface-experience/table-row-management/row-pinning.md) — Allows users to pin specific trace tracks to the top of the timeline for persistent visibility during scrolling. ([source](https://www.perfetto.dev/docs/visualization/perfetto-ui))
- [Timeline Region Selection](https://awesome-repositories.com/f/user-interface-experience/timeline-region-selection.md) — Defines time ranges and track sets by click-dragging on the trace timeline. ([source](https://www.perfetto.dev/docs/visualization/perfetto-ui))