xctrace CLI Reference

Command-line interface for Instruments profiling. Enables headless performance analysis without GUI.

Overview

xctrace is the CLI tool behind Instruments.app. Use it for:

• Automated profiling in CI/CD pipelines
• Headless trace collection without GUI
• Programmatic trace analysis via XML export
• Performance regression detection

Requires: Xcode 12+ (xctrace 12.0+). This reference tested with Xcode 26.2.

Quick Reference

bash
1# Record a 10-second CPU profile
2xcrun xctrace record --instrument 'CPU Profiler' --attach 'MyApp' --time-limit 10s --output profile.trace
3
4# Export to XML for analysis
5xcrun xctrace export --input profile.trace --toc  # See available tables
6xcrun xctrace export --input profile.trace --xpath '/trace-toc/run[@number="1"]/data/table[@schema="cpu-profile"]'
7
8# List available instruments
9xcrun xctrace list instruments
10
11# List available templates
12xcrun xctrace list templates

Recording Traces

Basic Recording

bash
1# Using an instrument (recommended for CLI automation)
2xcrun xctrace record --instrument 'CPU Profiler' --attach 'AppName' --time-limit 10s --output trace.trace
3
4# Using a template (may fail on export in Xcode 26+)
5xcrun xctrace record --template 'Time Profiler' --attach 'AppName' --time-limit 10s --output trace.trace

Note: In Xcode 26+, use --instrument instead of --template for reliable export. Templates may produce traces with "Document Missing Template Error" on export.

Target Selection

bash
1# Attach to running process by name
2xcrun xctrace record --instrument 'CPU Profiler' --attach 'MyApp' --time-limit 10s
3
4# Attach to running process by PID
5xcrun xctrace record --instrument 'CPU Profiler' --attach 12345 --time-limit 10s
6
7# Profile all processes
8xcrun xctrace record --instrument 'CPU Profiler' --all-processes --time-limit 10s
9
10# Launch and profile
11xcrun xctrace record --instrument 'CPU Profiler' --launch -- /path/to/app arg1 arg2
12
13# Target specific device (simulator or physical)
14xcrun xctrace record --instrument 'CPU Profiler' --device 'iPhone 17 Pro' --attach 'MyApp' --time-limit 10s
15xcrun xctrace record --instrument 'CPU Profiler' --device 947DF45C-4ACB-4B3E-A043-DF2CD59A59B3 --all-processes --time-limit 10s

Recording Options

Core Instruments

CPU Profiler

CPU sampling for finding hot functions.

bash
1xcrun xctrace record --instrument 'CPU Profiler' --attach 'MyApp' --time-limit 10s --output cpu.trace

Schema: cpu-profile Columns: time, thread, process, core, thread-state, weight (cycles), stack

Allocations

Memory allocation tracking.

bash
1xcrun xctrace record --instrument 'Allocations' --attach 'MyApp' --time-limit 30s --output alloc.trace

Schema: allocations Use for: Finding memory growth, object counts, allocation patterns

Leaks

Memory leak detection.

bash
1xcrun xctrace record --instrument 'Leaks' --attach 'MyApp' --time-limit 30s --output leaks.trace

Schema: leaks Use for: Detecting unreleased memory, retain cycles

SwiftUI

SwiftUI view body analysis.

bash
1xcrun xctrace record --instrument 'SwiftUI' --attach 'MyApp' --time-limit 10s --output swiftui.trace

Schema: swiftui Use for: Finding excessive view updates, body re-evaluations

Swift Concurrency

Actor and Task analysis.

bash
1xcrun xctrace record --instrument 'Swift Tasks' --instrument 'Swift Actors' --attach 'MyApp' --time-limit 10s --output concurrency.trace

Schemas: swift-task, swift-actor Use for: Task scheduling, actor isolation, async performance

All Available Instruments

Activity Monitor          Audio Client              Audio Server
Audio Statistics          CPU Counters              CPU Profiler
Core Animation Activity   Core Animation Commits    Core Animation FPS
Core Animation Server     Core ML                   Data Faults
Data Fetches              Data Saves                Disk I/O Latency
Disk Usage                Display                   Filesystem Activity
Filesystem Suggestions    Foundation Models         Frame Lifetimes
GCD Performance           GPU                       HTTP Traffic
Hangs                     Hitches                   Leaks
Location Energy Model     Metal Application         Metal GPU Counters
Metal Performance Overview Metal Resource Events    Network Connections
Neural Engine             Points of Interest        Power Profiler
Processor Trace           RealityKit Frames         RealityKit Metrics
Runloops                  Sampler                   SceneKit Application
Swift Actors              Swift Tasks               SwiftUI
System Call Trace         System Load               Thread States
Time Profiler             VM Tracker                Virtual Memory Trace

Exporting Traces

Table of Contents

bash
1# See all available data tables in a trace
2xcrun xctrace export --input trace.trace --toc

Output structure:

xml
1<trace-toc>
2    <run number="1">
3        <info>
4            <target>...</target>
5            <summary>...</summary>
6        </info>
7        <processes>...</processes>
8        <data>
9            <table schema="cpu-profile" .../>
10            <table schema="thread-info"/>
11            <table schema="process-info"/>
12        </data>
13    </run>
14</trace-toc>

XPath Export

bash
1# Export specific table by schema
2xcrun xctrace export --input trace.trace --xpath '/trace-toc/run[@number="1"]/data/table[@schema="cpu-profile"]'
3
4# Export process info
5xcrun xctrace export --input trace.trace --xpath '/trace-toc/run[@number="1"]/data/table[@schema="process-info"]'
6
7# Export thread info
8xcrun xctrace export --input trace.trace --xpath '/trace-toc/run[@number="1"]/data/table[@schema="thread-info"]'

CPU Profile Schema

xml
1<schema name="cpu-profile">
2    <col><mnemonic>time</mnemonic><name>Sample Time</name></col>
3    <col><mnemonic>thread</mnemonic><name>Thread</name></col>
4    <col><mnemonic>process</mnemonic><name>Process</name></col>
5    <col><mnemonic>core</mnemonic><name>Core</name></col>
6    <col><mnemonic>thread-state</mnemonic><name>State</name></col>
7    <col><mnemonic>weight</mnemonic><name>Cycles</name></col>
8    <col><mnemonic>stack</mnemonic><name>Backtrace</name></col>
9</schema>

Each row contains:

• sample-time: Timestamp in nanoseconds
• thread: Thread ID and name
• process: Process name and PID
• core: CPU core number
• thread-state: Running, Blocked, etc.
• cycle-weight: CPU cycles
• backtrace: Call stack with function names

Process Discovery

Find Running Simulator Apps

bash
1# List apps in booted simulator
2xcrun simctl spawn booted launchctl list | grep UIKitApplication
3
4# Output format: PID  Status  com.apple.UIKitApplication:com.bundle.id[xxxx][rb-legacy]

Find Device UUID

bash
1# List booted simulators (JSON)
2xcrun simctl list devices booted -j
3
4# List all devices
5xcrun simctl list devices

Find Process by Name

bash
1# Get PID of running app
2pgrep -f "MyApp"
3
4# List all processes with app name
5ps aux | grep MyApp

Automation Patterns

CI/CD Integration

bash
1#!/bin/bash
2# performance-test.sh
3
4APP_NAME="MyApp"
5TRACE_DIR="./traces"
6TIME_LIMIT="30s"
7
8# Boot simulator if needed
9xcrun simctl boot "iPhone 17 Pro" 2>/dev/null || true
10
11# Wait for app to launch
12sleep 5
13
14# Record CPU profile
15xcrun xctrace record \
16    --instrument 'CPU Profiler' \
17    --device "iPhone 17 Pro" \
18    --attach "$APP_NAME" \
19    --time-limit "$TIME_LIMIT" \
20    --no-prompt \
21    --output "$TRACE_DIR/cpu.trace"
22
23# Export for analysis
24xcrun xctrace export \
25    --input "$TRACE_DIR/cpu.trace" \
26    --xpath '/trace-toc/run[@number="1"]/data/table[@schema="cpu-profile"]' \
27    > "$TRACE_DIR/cpu-profile.xml"
28
29# Parse and check thresholds
30# (Use xmllint, python, or custom tool to parse XML)

Before/After Comparison

bash
1# Record baseline
2xcrun xctrace record --instrument 'CPU Profiler' --attach 'MyApp' --time-limit 10s --output baseline.trace
3
4# Make changes, rebuild app
5
6# Record after changes
7xcrun xctrace record --instrument 'CPU Profiler' --attach 'MyApp' --time-limit 10s --output after.trace
8
9# Export both for comparison
10xcrun xctrace export --input baseline.trace --xpath '...' > baseline.xml
11xcrun xctrace export --input after.trace --xpath '...' > after.xml

Troubleshooting

"Document Missing Template Error" on Export

Cause: Recording used --template flag in Xcode 26+ Fix: Use --instrument instead:

bash
1# Instead of
2xcrun xctrace record --template 'Time Profiler' ...
3
4# Use
5xcrun xctrace record --instrument 'CPU Profiler' ...

"Unable to attach to process"

Causes:

1. Process not running
2. Insufficient permissions
3. System Integrity Protection blocking

Fix:

bash
1# Verify process exists
2pgrep -f "AppName"
3
4# For simulator apps, verify simulator is booted
5xcrun simctl list devices booted
6
7# Try with --all-processes instead of --attach
8xcrun xctrace record --instrument 'CPU Profiler' --all-processes --time-limit 5s

Empty Trace Export

Cause: Recording too short or no activity during recording Fix: Increase --time-limit or ensure app is actively used during recording

Symbolication Issues

Raw addresses in backtraces (e.g., 0x18f17ed94) instead of function names.

Fix: Ensure dSYMs are available:

bash
1# Symbolicate trace (if needed)
2xcrun xctrace symbolicate --input trace.trace --dsym /path/to/App.dSYM

Limitations

1. Privacy restrictions: Some instruments require privacy permissions granted in System Preferences
2. Device support: Physical device profiling requires Developer Mode enabled
3. Background apps: Limited profiling of backgrounded apps
4. Export format: XML only (no JSON export)
5. Template vs Instrument: In Xcode 26+, templates may not export properly

Resources

Skills: axiom-performance-profiling, axiom-memory-debugging, axiom-swiftui-performance

Docs: /xcode/instruments, /os/logging/recording-performance-data