Agent skill

iOS Ettrace Performance

by omarshahine in omarshahine/HomeClaw

Capture and interpret ETTrace profiles for iOS simulator apps, including symbolicated launch and runtime flamegraphs.

MITAuto-check passedMobile

Install iOS Ettrace Performance

skills CLI
$ npx skills add omarshahine/HomeClaw --skill ios-ettrace-performance -a claude-code

Project install by default; add -g for ~/.claude/skills/.

GitHub CLI
$ gh skill install omarshahine/HomeClaw ios-ettrace-performance --agent claude-code

Project scope by default; add --scope user for a personal install. Needs GitHub CLI 2.90.0 or later (public preview).

Manual copy
$ git clone --depth 1 https://github.com/omarshahine/HomeClaw.git skills-src && mkdir -p .claude/skills && cp -r skills-src/.claude/skills/ios-ettrace-performance .claude/skills/ios-ettrace-performance && rm -rf skills-src

Use ~/.claude/skills/ instead of .claude/skills for a personal install. The folder must contain SKILL.md.

Claude Code skills documentation · loads skills from .claude/skills/

Facts

Skill name
ios-ettrace-performance
GitHub stars
176
Used in
1 other repo
Token cost
~2.3k tokens
SKILL.md length
787 words
Files
4 (incl. scripts)
Skills in repo
14
Repo updated
First seen
Licence
MIT

At a glance

Capture and interpret ETTrace profiles for iOS simulator apps, including symbolicated launch and runtime flamegraphs.

  • Works in 7 steps: Pick one focused flow and write down the… → Build the exact simulator app that will… → Temporarily link ETTrace into that app… → …
  • Asked to profile an iOS app flow
  • SKILL.md covers Core Workflow, Setup, Link ETTrace Into The App and Symbolication Gate, plus 4 more sections
  • Runs Python and Shell scripts from its folder; calls xcodebuild, brew and git; reaches github.com

What it does

iOS Ettrace Performance is an agent skill from omarshahine/HomeClaw. Capture and interpret ETTrace profiles for iOS simulator apps, including symbolicated launch and runtime flamegraphs. Use when asked to profile an iOS app flow, gather simulator performance traces, identify CPU-heavy stacks, compare before/after traces, or produce flamegraph evidence for startup, scrolling, navigation, rendering, or other user-visible latency.

Its SKILL.md is about 2.3k tokens, which your agent loads only when the skill is triggered. The skill folder holds 5 other files, including scripts (for example `agents/openai.yaml`, `scripts/analyze_flamegraph_json.py` and `scripts/collect_ios_dsyms.sh`).

It sits in Mobile, covering iOS development. It works with iOS and macOS. The repository describes itself as: HomeKit smart home control via MCP — lights, locks, thermostats, and scenes for Claude Desktop, Claude Code, and OpenClaw. The licence is MIT.

When your agent uses it

  • Asked to profile an iOS app flow
  • Gather simulator performance traces
  • Identify CPU-heavy stacks
  • Compare before/after traces

Example prompts

  • “/ios-ettrace-performance”

Requirements

  • Python 3
  • A Bash shell

Workflow steps

7 steps, taken from the first numbered list in SKILL.md.

  1. Pick one focused flow and write down the expected start and stop points.
  2. Build the exact simulator app that will be installed and profiled.
  3. Temporarily link ETTrace into that app target for simulator/debug profiling.
  4. Collect UUID-matched dSYMs for the app executable and embedded dynamic frameworks.
  5. Capture one launch or runtime trace.
  6. Preserve the processed flamegraph JSON immediately after the run.
  7. Analyze only the processed JSON and report the flow, artifacts, hotspots, and caveats.

What it can do on your machine

Read from SKILL.md and the folder at commit da69700. It shows what the files ask for, not the result of running them.

  • Tool permissions

    Pre-approves nothing: there is no allowed-tools line, so your agent's usual permission prompts apply.

    From allowed-tools in the SKILL.md frontmatter.

  • Runs code

    Ships 2 files in scripts/ (Python and Shell), which the agent can run.

    Shell commands in SKILL.md call:

    • xcodebuild
    • brew
    • git
    • python3

    From the folder's file list and the shell code blocks in SKILL.md.

  • Network

    Hosts in commands or code, which the agent is likely to contact:

    • github.com

    From URLs in SKILL.md, links to its own repository left out.

  • Credentials

    Names no API keys, tokens, secrets or passwords.

    From names ending in _API_KEY, _TOKEN, _SECRET, _KEY or _PASSWORD in SKILL.md.

Context cost

iOS Ettrace Performance loads about 2.3k tokens when it runs. Until then it costs about 97 tokens; SKILL.md has 787 words of instructions outside code blocks.

Always · name and description, kept in context so the agent knows when to use it
~97
When it runs · the whole SKILL.md, loaded when a task matches
~2.3k

Estimates: characters ÷ 4, the usual rule of thumb; real counts depend on the model's tokenizer. Scripts and assets cost tokens only if the agent reads them.

Safety

Auto-check passed

The automated check found no risky patterns in SKILL.md.

Automated static check — not a guarantee. Review scripts before installing. It scans the text of SKILL.md for risky patterns (piping downloads into a shell, reading credential files, hidden Unicode, destructive commands); the scripts in this folder are not scanned.

SKILL.md

The full file from omarshahine/HomeClaw at commit da69700, republished under its MIT licence (© omarshahine). 787 words, ~2,262 tokens.

Download SKILL.mdSave it as .claude/skills/ios-ettrace-performance/SKILL.md (or your agent's skills folder). This skill also uses 3 other files; get the full folder from GitHub.
name
ios-ettrace-performance
description
Capture and interpret ETTrace profiles for iOS simulator apps, including symbolicated launch and runtime flamegraphs. Use when asked to profile an iOS app flow, gather simulator performance traces, identify CPU-heavy stacks, compare before/after traces, or produce flamegraph evidence for startup, scrolling, navigation, rendering, or other user-visible latency.

iOS ETTrace Performance

Use this skill to capture a focused, symbolicated ETTrace profile from an iOS simulator app. Pair it with ../ios-debugger-agent/SKILL.md when the task also needs simulator build, install, launch, UI driving, logs, or screenshots.

Core Workflow

  1. Pick one focused flow and write down the expected start and stop points.
  2. Build the exact simulator app that will be installed and profiled.
  3. Temporarily link ETTrace into that app target for simulator/debug profiling.
  4. Collect UUID-matched dSYMs for the app executable and embedded dynamic frameworks.
  5. Capture one launch or runtime trace.
  6. Preserve the processed flamegraph JSON immediately after the run.
  7. Analyze only the processed JSON and report the flow, artifacts, hotspots, and caveats.

Avoid broad "use the app for a while" captures. One trace should correspond to one user-visible flow.

Setup

Use a writable run folder for each profiling session:

bash
if [ -z "${RUN_DIR:-}" ]; then
  RUN_DIR="$(mktemp -d "${TMPDIR:-/tmp}/codex-ios-ettrace.XXXXXX")"
fi
mkdir -p "$RUN_DIR"

Install the ETTrace runner CLI if it is not already available:

bash
brew install emergetools/homebrew-tap/ettrace

ettrace is the host-side macOS runner. The app must also link an ETTrace.xcframework for the iOS Simulator architecture. This workflow is validated for ETTrace v1.1.0 processed output_<thread>.json files with top-level nodes.

Wire ETTrace into the exact app target being profiled. Keep the integration in a clearly temporary patch and remove it when the profiling task is done unless the user explicitly asks to keep it.

Preferred options:

  • Reuse an existing simulator-compatible ETTrace.xcframework if the repo already vendors one.
  • If none exists, build a simulator-only copy into RUN_DIR from the upstream ETTrace package.
  • Link the framework directly into the app target, not only into tests, resources, data files, or a nested launcher target.
  • Confirm launch logs print Starting ETTrace.
  • Profile only one ETTrace-instrumented simulator app at a time because simulator mode listens on a fixed localhost port.

Build a simulator framework when needed:

bash
ETTRACE_TAG="${ETTRACE_TAG:-v1.1.0}" # Override to match the installed runner when Homebrew updates.
ETTRACE_SRC="$RUN_DIR/ETTrace-src"
if [ ! -d "$ETTRACE_SRC" ]; then
  git clone --depth 1 --branch "$ETTRACE_TAG" https://github.com/EmergeTools/ETTrace "$ETTRACE_SRC"
fi

rm -rf "$RUN_DIR/ETTrace-iphonesimulator.xcarchive" "$RUN_DIR/ETTrace.xcframework"
pushd "$ETTRACE_SRC" >/dev/null
xcodebuild archive \
  -scheme ETTrace \
  -archivePath "$RUN_DIR/ETTrace-iphonesimulator.xcarchive" \
  -sdk iphonesimulator \
  -destination 'generic/platform=iOS Simulator' \
  BUILD_LIBRARY_FOR_DISTRIBUTION=YES \
  INSTALL_PATH='Library/Frameworks' \
  SKIP_INSTALL=NO \
  CLANG_CXX_LANGUAGE_STANDARD=c++17

xcodebuild -create-xcframework \
  -framework "$RUN_DIR/ETTrace-iphonesimulator.xcarchive/Products/Library/Frameworks/ETTrace.framework" \
  -output "$RUN_DIR/ETTrace.xcframework"
popd >/dev/null

For Bazel apps, a temporary import usually looks like:

python
load("@rules_apple//apple:apple.bzl", "apple_dynamic_xcframework_import")

package(default_visibility = ["//visibility:public"])

apple_dynamic_xcframework_import(
    name = "ETTrace",
    xcframework_imports = glob(["ETTrace.xcframework/**"]),
)

For Xcode projects, temporarily add the simulator ETTrace.xcframework to the app target's Link Binary With Libraries / Embed Frameworks phases for the debug simulator build you are profiling, then remove that wiring after profiling.

Symbolication Gate

Do not draw conclusions from an unsymbolicated flamegraph. Before every capture, prepare a dSYM folder that includes the app dSYM and any embedded first-party dynamic framework dSYMs.

Collect dSYMs after the final build that produced the installed app:

bash
SKILL_DIR="<absolute path to this loaded skill folder>"
APP="<path-to-built-simulator-App.app>"
DSYMS="$RUN_DIR/dsyms"

"$SKILL_DIR/scripts/collect_ios_dsyms.sh" \
  --app "$APP" \
  --out-dir "$DSYMS" \
  --search-root "$(dirname "$APP")" \
  --search-root "$PWD" \
  --extra-dsym "$RUN_DIR/ETTrace-iphonesimulator.xcarchive/dSYMs/ETTrace.framework.dSYM"

Add --require-framework <FrameworkName> for app-owned dynamic frameworks that must symbolicate; use --require-all-frameworks only when every embedded framework is app-owned or expected to have symbols. If the helper reports a missing required app or framework dSYM, rebuild the exact simulator app with dSYM generation before tracing, or add the build output directory that contains those dSYMs as another --search-root.

Verify important UUIDs before tracing when the report looks suspicious:

bash
dwarfdump --uuid "$APP/$(/usr/libexec/PlistBuddy -c 'Print :CFBundleExecutable' "$APP/Info.plist")"
find "$DSYMS" -maxdepth 1 -type d -name '*.dSYM' -print -exec dwarfdump --uuid {} \;

After ETTrace exits, read its symbolication summary. Treat meaningful first-party "have library but no symbol" lines as a failed trace unless they are tiny noise. Unsymbolicated system-framework or ETTrace internal buckets are usually acceptable.

Show full SKILL.md (300 more words)Show less

Capture

For launch traces:

bash
cd "$RUN_DIR"
CAPTURE_MARKER="$RUN_DIR/.ettrace-capture-start"
: > "$CAPTURE_MARKER"
find "$RUN_DIR" -maxdepth 1 \( -name 'output.json' -o -name 'output_*.json' \) -delete
ettrace --simulator --launch --verbose --dsyms "$DSYMS"

Use --launch only when measuring startup or first render. The first launch connection can force quit the app; relaunch from the simulator home screen rather than Xcode if prompted. For first-launch-after-install traces, temporarily set ETTraceRunAtStartup=YES in the app Info.plist, then run ettrace --simulator and launch from the home screen.

For runtime flow traces:

bash
cd "$RUN_DIR"
CAPTURE_MARKER="$RUN_DIR/.ettrace-capture-start"
: > "$CAPTURE_MARKER"
find "$RUN_DIR" -maxdepth 1 \( -name 'output.json' -o -name 'output_*.json' \) -delete
ettrace --simulator --verbose --dsyms "$DSYMS"

Start from a stable screen, start ETTrace, perform exactly one focused flow, wait until visible work is complete, then stop the runner. For wider attribution, add --multi-thread; otherwise start with the main thread.

In Codex, run ettrace with a TTY and answer prompts with write_stdin. Without a TTY, the runner can exit without a useful trace.

Preserve Outputs

The next ETTrace run can overwrite processed flamegraph files, so preserve fresh output_<thread-id>.json files immediately. Do not analyze a saved output.json; ETTrace also serves a viewer route with that name, and raw emerge-output/output.json files are not the processed flamegraph artifacts this workflow expects.

bash
PRESERVED_DIR="$(mktemp -d "$RUN_DIR/run-$(date +%Y%m%d-%H%M%S).XXXXXX")"
: > "$PRESERVED_DIR/summary.txt"
if [ ! -e "$CAPTURE_MARKER" ]; then
  echo "error: capture marker missing; start a fresh ETTrace capture before preserving outputs" >&2
  exit 1
fi
find "$RUN_DIR" -maxdepth 1 -name 'output_*.json' -newer "$CAPTURE_MARKER" -print | while IFS= read -r json; do
  preserved="$PRESERVED_DIR/${json##*/}"
  cp "$json" "$preserved"
  {
    echo "## ${preserved##*/}"
    python3 "$SKILL_DIR/scripts/analyze_flamegraph_json.py" "$preserved"
  } >> "$PRESERVED_DIR/summary.txt"
done
if [ ! -s "$PRESERVED_DIR/summary.txt" ]; then
  echo "error: no fresh processed ETTrace output JSON found in $RUN_DIR" >&2
  exit 1
fi

Analyze only processed output_*.json files in RUN_DIR. Ignore output.json and raw emerge-output/output.json files unless debugging ETTrace itself. If the analyzer rejects the JSON shape, capture again with the Homebrew ETTrace runner and matching app-side ETTrace.xcframework tag instead of trying to interpret the rejected file.

Read The Profile

Start from run-*/summary.txt, then inspect processed JSON directly if needed.

Report:

  • exact flow, app build, simulator model/runtime, and run count
  • processed flamegraph JSON paths
  • top active leaves and inclusive first-party stacks with sample weights or percentages
  • whether symbols were complete for app-owned binaries
  • caveats such as first-run setup, simulator-only cost, network variance, or low sample count
  • before/after deltas only when the same flow was captured with comparable setup

Cleanup

Remove temporary ETTrace app wiring when profiling is complete unless the user asked to keep it. Keep or discard run artifacts based on the active task.

© omarshahine, MIT. Rendered from Markdown: HTML in the file is shown as text, images as links, and headings moved down two levels. Raw file

Files

SKILL.md and 3 other files (scripts) in .claude/skills/ios-ettrace-performance of omarshahine/HomeClaw.

  • SKILL.md
  • agents/openai.yaml
  • scripts/analyze_flamegraph_json.py
  • scripts/collect_ios_dsyms.sh

Open the folder on GitHubat commit da69700

Used in 1 other repository

We found 1 copy of this SKILL.md (exact, near-identical or edited) in other folders, from 1 other GitHub owner. This page covers the copy in omarshahine/HomeClaw, which our catalogue first saw on October 7, 2026.

Compare with similar skills

iOS Ettrace Performance next to the 5 skills that share the most tags, products or categories with it. Stars are the repository's; “used in” counts other GitHub owners with a copy.

iOS Ettrace Performance compared with similar skills
SkillStarsUsed inTokensAuto-checkLicenceRepo updated
iOS Ettrace Performance this skillomarshahine/HomeClaw1761 repos~2.3kAutomated safety check: PassMIT
Orca iOS Simulator Controlstablyai/orca87k1 repos~584Automated safety check: PassApache-2.0
Apple Crash Log .NET Symbolicationdotnet/skills5.6k1 repos~2.4kAutomated safety check: PassMIT
Phoneagentrounak/PhoneAgent798—~2.2kAutomated safety check: PassMIT
Apple Designvrcm-team/VRCM1791 repos~6.2kAutomated safety check: PassMIT
Hig Project Contextraintree-technology/hig-doctor1435 repos~1.2kAutomated safety check: PassMIT

Similar skills

  • iOS Simulator control from inside Orca, with the live device view in Orca's emulator pane. Use when driving a booted Apple Simulator on macOS: taps, gestures…

    87k GitHub starsUsed in 1 repo~584 tokens
    MobileAuto-check passed
  • Official

    Resolves .NET runtime frames in Apple .ips crash logs to function names, source files and line numbers using dSYM symbols, atos and the Microsoft symbol server.

    5.6k GitHub starsUsed in 1 repo~2.4k tokens
    MobileAuto-check passed
  • Phoneagent

    rounak/PhoneAgent

    Control a connected iPhone, iOS simulator, Android emulator, or Android device from macOS through PhoneAgent's JSON-RPC bridge.

    798 GitHub stars~2.2k tokensUpdated 1 mo ago
    MobileAuto-check passed
  • Apple Design

    vrcm-team/VRCM

    Cross-platform UI/UX design reviewer grounded in Apple's Human Interface Guidelines (122 pages pulled from developer.apple.com, including 57 component pages) plus a design-craft lens for…

    179 GitHub starsUsed in 1 repo~6.2k tokens
    MobileAuto-check passed
  • Hig Project Context

    raintree-technology/hig-doctor

    Create or update a shared Apple design context document that other HIG skills use to tailor guidance.

    143 GitHub starsUsed in 5 repos~1.2k tokens
    MobileAuto-check passed
  • Swiftui Expert Skill

    Eslzzyl/Pixiv-SwiftUI

    A skill your agent uses when writing, reviewing, or refactoring SwiftUI code for iOS or macOS, including state and @Observable data flow, view composition, resizable layouts, safe areas, display…

    111 GitHub starsUsed in 1 repo~2.9k tokens
    MobileAuto-check passed

More from omarshahine/HomeClaw

All 14 skills in this repo
  • Swiftui Expert Skill

    omarshahine/HomeClaw

    A skill your agent uses when writing, reviewing, or refactoring SwiftUI code for iOS or macOS, including state management, view composition, performance, Liquid Glass adoption, or Instruments .trace…

    176 GitHub starsUsed in 4 repos~2.8k tokens
    Auto-check passed
  • Spm Build Analysis

    omarshahine/HomeClaw

    Analyze Swift Package Manager dependencies, package plugins, module variants, and CI-oriented build overhead that slow Xcode builds.

    176 GitHub starsUsed in 1 repo~1.5k tokens
    Auto-check passed
  • Xcode Build Benchmark

    omarshahine/HomeClaw

    Benchmark Xcode clean and incremental builds with repeatable inputs, timing summaries, and timestamped .build-benchmark/ artifacts.

    176 GitHub starsUsed in 1 repo~1.2k tokens
    Auto-check passed
  • Xcode Build Fixer

    omarshahine/HomeClaw

    Apply approved Xcode build optimization changes following best practices, then re-benchmark to verify improvement.

    176 GitHub starsUsed in 1 repo~3.1k tokens
    Auto-check passed
  • Xcode Build Orchestrator

    omarshahine/HomeClaw

    Orchestrate Xcode build optimization by benchmarking first, running the specialist analysis skills, prioritizing findings, requesting explicit approval, delegating approved fixes to…

    176 GitHub starsUsed in 1 repo~2.9k tokens
    Auto-check passed
  • Xcode Compilation Analyzer

    omarshahine/HomeClaw

    Analyze Swift and mixed-language compile hotspots using build timing summaries and Swift frontend diagnostics, then produce a recommend-first source-level optimization plan.

    176 GitHub starsUsed in 1 repo~1.4k tokens
    Auto-check passed

Works with

Categories

Questions about iOS Ettrace Performance

What does iOS Ettrace Performance do?

Capture and interpret ETTrace profiles for iOS simulator apps, including symbolicated launch and runtime flamegraphs. iOS Ettrace Performance is an agent skill from omarshahine/HomeClaw. Capture and interpret ETTrace profiles for iOS simulator apps, including symbolicated launch and runtime flamegraphs.

When should I use iOS Ettrace Performance?

iOS Ettrace Performance fits situations like: asked to profile an iOS app flow; gather simulator performance traces; identify CPU-heavy stacks; compare before/after traces.

How do I install iOS Ettrace Performance in Claude Code?

Run `npx skills add omarshahine/HomeClaw --skill ios-ettrace-performance -a claude-code`. Or copy the skill folder (.claude/skills/ios-ettrace-performance in omarshahine/HomeClaw) into .claude/skills/ios-ettrace-performance in your project. Claude Code loads it when a task matches its description.

How do I install iOS Ettrace Performance in Codex?

Run `npx skills add omarshahine/HomeClaw --skill ios-ettrace-performance -a codex`. Or copy the skill folder (.claude/skills/ios-ettrace-performance in omarshahine/HomeClaw) into .agents/skills/ios-ettrace-performance in your project. Codex loads it when a task matches its description.

Can I use iOS Ettrace Performance in Cursor, Gemini CLI or GitHub Copilot?

Cursor, Gemini CLI, GitHub Copilot and OpenCode also load SKILL.md folders. With the skills CLI, run `npx skills add omarshahine/HomeClaw --skill ios-ettrace-performance -a cursor` (or -a gemini-cli, github-copilot or opencode for the others). To copy it by hand, put the folder in .cursor/skills/ios-ettrace-performance, .gemini/skills/ios-ettrace-performance, .github/skills/ios-ettrace-performance and .opencode/skills/ios-ettrace-performance in your project.

What does iOS Ettrace Performance need to run?

Going by SKILL.md and its folder, iOS Ettrace Performance needs Python and a shell for the scripts in its folder and the command-line tools its instructions call (xcodebuild, brew, git and python3). Our summary lists: Python 3; A Bash shell.

Does iOS Ettrace Performance access the network?

SKILL.md names 1 domain. In commands or code: github.com; the agent is likely to contact it when it follows the instructions. This is read from the text; nothing was executed.

Is iOS Ettrace Performance safe to install?

Our automated static check of SKILL.md found no risky patterns, such as piping downloads into a shell, reading credential files or hidden Unicode. It is not a guarantee. The check reads SKILL.md only: the scripts in the folder are not scanned, so read them before running anything.

What licence does iOS Ettrace Performance use?

iOS Ettrace Performance is published under the MIT licence (the repository's licence). It allows redistribution, so the full SKILL.md is shown on this page.

How many tokens does iOS Ettrace Performance use?

About 2.3k tokens (SKILL.md is roughly 9k characters). Agents keep only the skill's name and description in context until a task matches; then they load SKILL.md in full.

What are the alternatives to iOS Ettrace Performance?

Skills that share tags, products or a category with iOS Ettrace Performance: Orca iOS Simulator Control (stablyai/orca, 87k stars), Apple Crash Log .NET Symbolication (dotnet/skills, 5.6k stars), Phoneagent (rounak/PhoneAgent, 798 stars) and Apple Design (vrcm-team/VRCM, 179 stars). The comparison table on this page puts their stars, adoption, token cost, safety result and licence side by side.

Who maintains iOS Ettrace Performance?

omarshahine (a GitHub user) maintains it in omarshahine/HomeClaw, which has 176 GitHub stars. The repository holds 14 skills in this directory. The repository was last updated on October 8, 2026.

Source: omarshahine/HomeClaw on GitHub. Facts on this page come from the repository at the commit we read; the author's words are quoted as theirs.