Hubbry Logo
Instruments (software)Instruments (software)Main
Open search
Instruments (software)
Community hub
Instruments (software)
logo
7 pages, 0 posts
0 subscribers
Be the first to start a discussion here.
Be the first to start a discussion here.
Contribute something
Instruments (software)
Instruments (software)
Instruments (software)
View on Wikipedia
from Wikipedia

Instruments
DeveloperApple Inc
Stable release
26.0 / September 15, 2025
Operating systemmacOS
TypeTracing & Profiling
LicenseProprietary freeware
Websitehelp.apple.com/instruments

Instruments (formerly Xray) is an application performance analyzer and visualizer by Apple Inc., integrated in Xcode 3.0 and later versions of Xcode. It is built on top of the DTrace tracing framework from OpenSolaris, which was ported to Mac OS X v10.5 and which is available in all following versions of macOS.

Instruments shows a time line displaying any event occurring in the application, such as CPU activity variation, memory allocation, and network and file activity, together with graphs and statistics. Group of events are monitored via customizable "instruments", which have the ability to record user generated events and replay (emulate) them exactly as many times as needed, so a developer can see the effect of code changes without actually doing the repetitive work. The Instrument Builder feature allows the creation of custom analysis instruments.[1]

Features

[edit]

Built-in instruments can track

See also

[edit]

References

[edit]
Revisions and contributorsEdit on WikipediaRead on Wikipedia

Instruments (software)

View on Grokipedia
from Grokipedia
Instruments is a performance analysis and visualization tool developed by Apple Inc. for profiling and debugging applications across its platforms. Integrated into the Xcode integrated development environment since version 3.0, released in 2007 with Mac OS X Leopard, Instruments enables developers to monitor and optimize app behavior in real time. It supports analysis on iOS, iPadOS, macOS, tvOS, watchOS, and visionOS, providing insights into CPU usage, memory allocation, energy consumption, and graphical rendering. Originally codenamed , Instruments evolved from earlier debugging utilities like into a comprehensive suite of instruments, each targeting specific performance metrics such as allocations, leaks, , and thread activity. Key features include time-based tracing, which captures data over app execution to identify bottlenecks, and integration with for low-level system probing without significant overhead. Developers use its graphical interface to visualize timelines, stack traces, and resource graphs, facilitating targeted optimizations like reducing main thread blocks to prevent hangs or minimizing energy impact for battery-powered devices. The tool's extensibility allows custom instrument creation via the Instruments package format and SDK, using languages like C and DTrace for data providers. Recent updates, such as those in Xcode 15 and later, incorporate hardware-assisted profiling for Apple silicon, enhancing accuracy in CPU and GPU optimization on M-series chips. By providing actionable data on app responsiveness, resource efficiency, and stability, Instruments remains essential for creating high-performance software in the Apple ecosystem.

Overview

Development and Release History

Instruments originated as a tool named in early betas of during 2006, serving as a performance analysis utility for developers. It was rebranded to Instruments and officially integrated into 3.0, which Apple released on October 22, 2007, coinciding with the launch of Mac OS X 10.5 Leopard. This rebranding reflected Apple's intent to consolidate various standalone profiling tools into a unified interface for tracing application behavior. A key milestone came with its alignment to , the dynamic tracing framework made available in macOS 10.5 , enabling Instruments to leverage kernel-level for real-time monitoring without requiring code modifications. This integration marked Instruments as a core component of Apple's developer ecosystem, replacing fragmented tools like for sampling-based profiling and MallocDebug for detection, which were deprecated around the same period to streamline developer workflows. Subsequent updates expanded Instruments' capabilities across Xcode versions. 4, released in March 2011, introduced full support for iOS device profiling, allowing developers to analyze performance directly on hardware. 5 in September 2013 enhanced memory debugging features, including improved allocation tracking and integrated with the Debug Navigator. In 8, released in September 2016, energy profiling was added to measure app impact on battery life, addressing growing concerns for mobile efficiency. The most recent version, Instruments 26.0, arrived with 26 on September 15, 2025, featuring advancements in processor tracing for capturing detailed instruction-level execution flows on .

Technical Foundations

Instruments is fundamentally built on DTrace, a dynamic tracing framework originally developed by Sun Microsystems for OpenSolaris to enable comprehensive kernel and user-space probing without requiring code recompilation or restarts. Apple ported to macOS 10.5 , released in , integrating it as a core technology for performance analysis tools like Instruments. This port extended DTrace's capabilities to Apple's ecosystem, allowing low-overhead of system calls, function entries, and custom events across processes. At its core, Instruments relies on trace data collection through DTrace scripts, which define probes written in the D programming language to capture events such as CPU usage, memory allocations, and I/O operations. These scripts facilitate event aggregation, where raw trace data is summarized using DTrace's built-in aggregation functions—like count, sum, and average—to produce efficient, queryable datasets for analysis. Complementing this, Instruments employs a templating system for instrument bundles, structured as .instrpkg packages that use XML definitions to specify data schemas, UI layouts, and modeling logic often implemented in the CLIPS expert system language for intelligent event processing. Instruments supports multi-platform tracing across macOS, , , and , enabling on-device profiling for resource-constrained environments like —where runs with restrictions for —and remote collection from host machines for deeper . This is achieved through Apple's unified tracing infrastructure, which streams data via wireless or USB connections while maintaining low system impact. Apple has introduced proprietary extensions to enhance 's flexibility, notably the in macOS 10.14 Mojave, which allows developers to log custom events and intervals directly into trace streams for Instruments visualization. These signposts, integrated with the OS logging subsystem, provide lightweight markers for app-specific performance points without relying solely on DTrace probes.

Core Functionality

Built-in Instruments

Instruments provides a collection of built-in instruments that enable developers to profile specific aspects of application and on Apple platforms. These tools are pre-configured templates within the Instruments application, allowing for targeted of usage without requiring custom setup. Many of these instruments utilize DTrace-based tracing for efficient data collection at the kernel level. The Time Profiler instrument samples CPU usage by periodically capturing the call stacks of running threads, typically at 1 ms intervals, to construct a statistical profile of execution time. This reveals hotspots—functions consuming the most CPU cycles—through hierarchical call trees that display total time (weight) and self-time (excluding callees), aiding in the identification of performance bottlenecks. For instance, it aggregates samples to show percentages like 98.3% usage for a specific method, though it cannot precisely measure individual call frequencies. The Allocations instrument tracks heap memory allocations, monitoring the creation, growth, and persistence of objects to uncover patterns in usage. It categorizes allocations by type (e.g., Malloc or VM), responsible callers, and stack traces, displaying metrics such as persistent bytes (total allocated ) and instance counts (e.g., 41,900 instances totaling 7.67 MB for a class). This helps detect inefficient allocation habits and object lifecycles that contribute to excessive footprints. The Leaks instrument detects memory leaks by taking periodic heap snapshots and scanning for unreferenced blocks in writable , registers, and stacks. It identifies leaks as allocations without retainers, presenting them in table or outline views with details like address, size, and allocation stack traces, enabling developers to trace back to the originating for remediation. The instrument monitors for messages sent to deallocated objects by replacing freed memory with "zombie" placeholders, logging violations to debug "use after free" errors common in and Swift. It captures the object type, deallocation time, and offending message, facilitating investigation of issues even when crash logs lack app-specific frames. The Core Animation instrument profiles graphics rendering by tracking frame rates, layer updates, and GPU resource utilization, highlighting inefficiencies like unnecessary screen redraws. Using the Core Animation Profiling template, it visualizes commits to the render server and enables features like flashing updated regions to pinpoint energy-impacting visual changes. The instrument logs socket-level activity for HTTP and other protocols, capturing packet transmissions, sizes, and timings to analyze throughput and delays. It records transaction states (e.g., sending request, waiting for response) with metadata on headers, bodies, and durations—such as milliseconds for cache lookups versus seconds for blocking—grouped by connection or path for latency optimization. The Power Profiler instrument (successor to Energy Log), measures power consumption on devices by tracing subsystem impacts like CPU, GPU, display, and networking activity. It reports energy usage as a fraction of battery per hour, detailing device states (e.g., thermal throttling, brightness) and allowing on-device recording for up to 10 hours to identify power-hungry operations. Available on 18 and later, 18 and later, macOS Sequoia and later, it supports untethered analysis for real-world battery optimization. The System Trace instrument captures low-level kernel events, thread scheduling decisions, and I/O operations through components like System Call Trace, Thread State Trace, and . It provides a timeline of OS interactions—such as scheduler switches affecting app threads or durations—enabling diagnosis of concurrency issues, blocking operations, and in complex applications. Recent additions as of 2025 include the Processor Trace instrument, introduced in 16.3, which uses hardware-supported tracing on to accurately reconstruct execution paths with low overhead, capturing every function call and branch. Additionally, the instrument, added in Xcode 26, profiles SwiftUI view rendering, body computations, and update cycles to optimize declarative UI performance.

Data Visualization and Analysis

Instruments presents collected trace through a timeline view, which features a horizontal graph depicting events and metrics over time. This view enables developers to visualize peaks in resource usage, such as CPU, , or I/O activity, using graphical elements like and colored bars; for instance, in hang analysis, red rectangles indicate severe hangs, while blue bars represent CPU usage on the main thread. Developers can zoom into specific intervals by dragging to select time ranges and apply filters to isolate tracks for particular processes or threads, facilitating targeted investigation of bottlenecks. Developers can record traces while manually interacting with the app to capture user actions and correlate them with for analysis of issues like responsiveness delays. Complementing the timeline, detail panes provide in-depth processing of selected events, including extended backtraces, statistics tables, and histograms. The call tree detail view aggregates data by function or thread, displaying expandable outlines with quantitative metrics like percentage of CPU time spent (e.g., 98.3% in a specific getter during a hang); the heaviest stack trace pane further summarizes this with a single, prioritized , color-coding frames based on source availability. These panes dynamically update with timeline selections, offering conceptual insights into execution patterns without requiring exhaustive numerical listings. For example, when analyzing memory from the Allocations instrument, detail panes reveal allocation backtraces and generation . Aggregation modes in Instruments include live processing, where data streams in real-time during recording for immediate feedback, and , which analyzes the full trace post-recording for comprehensive review. Processed data can be exported to CSV for tabular integration with external tools or GPX for location-specific traces, enabling further offline examination.

Usage and Integration

Launching and Recording Sessions

Instruments, Apple's performance analysis tool integrated into , can be launched directly from the Xcode IDE or as a standalone application. To initiate a profiling session from within , developers select the Product > Profile menu option, which builds the app using the current scheme's configuration—typically Release for optimized profiling—and automatically opens Instruments with a suggested template based on common performance issues. Alternatively, Instruments can be accessed independently via 's Open Developer Tool > Instruments menu, allowing selection of any target project or process without an immediate build. Upon launching, users select from pre-built templates that bundle multiple instruments tailored to specific profiling goals, streamlining the setup process. For instance, the Leaks template uses the Leaks instrument, which detects allocations not properly deallocated. The Zombies instrument, which tracks messaging to deallocated objects to identify use-after-free errors, can be added separately or via its own template for more comprehensive analysis. These templates provide a ready-to-use configuration, though users can customize by adding or removing individual instruments from the template library. Target attachment determines how Instruments connects to the application under test, supporting launches on simulators, physical devices, or attachment to existing . When profiling from , the scheme's run configuration dictates the target: selecting an iOS simulator launches the app virtually on the host Mac, while a connected device requires the app to be built and installed accordingly. For attaching to a running , Instruments offers a chooser dialog listing active applications, enabling on-the-fly profiling without restarting; this is particularly useful for live sessions on macOS apps. Schemes can be edited in (via Product > Scheme > Edit Scheme) to specify build-and-profile actions, ensuring the app launches in a profiled state upon recording. Once configured, recording begins with the prominent Record button in Instruments' toolbar, which initiates data capture and launches or attaches to the target as specified. Basic controls include a Stop button to end the session and save the trace file, alongside Pause and Resume buttons for temporarily halting during non-reproducible scenarios without losing the session . Advanced options support extended traces for prolonged monitoring, such as multi-hour battery impact assessments, and integration with signposts—custom timing events emitted via the os_signpost in —which appear as annotated intervals in the trace timeline for correlating app-specific milestones. For and other device-based platforms, remote profiling introduces specific setup requirements to ensure secure and authorized access. Physical devices must have the app signed with a valid development provisioning profile from an Apple Developer account, which includes device UDIDs and entitlements; without this, Instruments cannot install or attach to the target, resulting in launch failures. Simulators bypass these restrictions, allowing immediate profiling on the development machine, while —enabled via Xcode's Window > Devices and Simulators—requires initial USB pairing and the same provisioning setup.

Interpreting Results in Xcode

After capturing trace data in Instruments, developers analyze results directly within to identify and refine code issues. This integration transforms raw performance metrics into actionable insights by linking traces to , facilitating targeted . Instruments processes the data through its timeline views, where events like function calls or allocations are displayed chronologically for examination. Symbolication automatically maps addresses from traces to human-readable lines and function names, using dSYM files generated during app builds to provide symbols. These files ensure that even optimized or stripped binaries can be correlated back to original code, enabling precise identification of bottlenecks without manual resolution. To add or manage symbols if automatic detection fails, developers select File > Symbols in Instruments, where dSYM folders or can be imported for comprehensive coverage across app binaries and frameworks. For deeper inspection, double-clicking any or event in the trace timeline jumps directly to the corresponding source code in the editor, highlighting the exact line responsible. This feature streamlines navigation, allowing immediate code review and edits without switching tools, and works seamlessly across custom code, system frameworks, and third-party libraries once symbolicated. Instruments integrates with the LLDB to combine tracing with interactive during live sessions. Developers can attach LLDB breakpoints to traced processes, pausing execution at key points to inspect variables, stack traces, and runtime state alongside Instruments data. Recorded sessions can be exported and saved as .trace files via File > Save As, preserving all trace data, instruments, and annotations for offline review. These files are shareable among teams for collaborative or can be submitted to Apple diagnostics for further investigation, maintaining to the original recording environment. Error correlation in Instruments links anomalies like memory leaks or hangs to specific API interactions. In the Leaks instrument, for instance, trace events reveal unbalanced retain-release cycles in or strong reference loops in Swift, pinpointing responsible objects and call stacks. Similarly, the Zombies instrument detects over-releases or messaging by simulating deallocated objects, correlating hangs to invalid API calls and guiding fixes through symbolized backtraces.

Advanced Capabilities

Custom Instrument Creation

Custom instrument creation allows developers to extend Instruments by defining specialized probes and visualizations tailored to specific application behaviors or frameworks. This process involves building .instrument bundles using projects, which encapsulate logic, rules, and user interface components. These bundles can be distributed as templates for team-wide reuse, enabling consistent performance analysis across projects. The Instrument Builder, an Xcode-based editor integrated into the Instruments workflow, facilitates the creation of these bundles by providing templates for custom instruments. Developers start by selecting a blank template in Instruments and adding components via the plus icon, or by creating a new Instruments Distribution Package target in for more advanced setups. This editor supports defining the instrument's metadata, such as name, category, and description, while allowing integration of data sources like os_signpost events or legacy scripts. For macOS applications, remains a viable option for low-level tracing, though os_signpost is preferred for cross-platform compatibility on and macOS. Custom probes are implemented by writing predicates to capture app-specific events, such as tracing custom calls or milestones. Using os_signpost, developers log begin/end intervals or discrete events with metadata, which Instruments captures efficiently without significant overhead. For instance, in a mobile navigation app like the sample GoatList project, signposts mark "Mobile Agent Exec" and "Mobile Agent Moved" events to track subgoal progress. In -based probes, predicates filter events using conditional logic (e.g., matching specific function calls), while actions define data aggregation, such as counting occurrences or printing stack traces. These probes reference scripting concepts, like providers (e.g., syscall or fbt) and variable scoping, to ensure precise event isolation. Visualization plugins enhance the instrument's output by integrating custom charts, tables, or tracks directly into Instruments' timeline view. Developers use the Instruments framework in (or Swift) to define UI extensions, such as plot templates for interval-based graphs or engineering-type tracks for dynamic display. For complex processing, the CLIPS rules engine models raw signpost into meaningful facts, applying conditional elements (e.g., "and" or "not") to aggregate events before rendering. This enables visualizations like per-thread plots avoiding overlaps or narrative-enriched tables that summarize performance stories. may be used in limited contexts for scripting dynamic behaviors, but primary integration relies on native APIs for seamless performance. Distribution of custom instruments occurs through packaging as .instrument bundles, which can be saved as templates in the user's Library/Application Support/Instruments/Templates directory for easy access in future sessions. These bundles support team environments by allowing export and import via , ensuring reproducibility without rebuilding from scratch. For broader adoption, developers compile the package target and share the resulting bundle, integrating it into organizational workflows for specialized analysis. Examples of custom instruments include Apple's Mobile Agent extension for modeling navigation tasks in apps, as well as third-party implementations for domain-specific needs. In frameworks, custom probes trace inference latencies using signposts around model execution calls, visualized as timeline intervals. Similarly, for game engines, extensions monitor rendering pipelines by draw calls and GPU events, providing targeted insights into frame rates and resource usage. These adaptations demonstrate how custom instruments bridge general-purpose tools with specialized requirements.

Performance Optimization Workflows

Instruments provides developers with targeted workflows to optimize application performance by addressing key bottlenecks in , CPU, responsiveness, and energy consumption. These workflows leverage built-in instruments to profile, diagnose, and resolve issues, enabling iterative improvements that enhance app efficiency on Apple platforms. As of 26 (2025), new features such as Processor Trace and hardware-assisted CPU profiling further support these workflows on . By systematically analyzing traces, developers can implement data-driven refactors that reduce resource usage without compromising functionality.

Memory Optimization

Memory optimization begins with the Allocations instrument, which tracks heap allocations, object lifecycles, and counts to identify inefficiencies. To detect persistent objects—those remaining in memory longer than necessary—developers record a session during app usage scenarios prone to leaks, such as repeated view controller loads or data caching. The instrument's timeline reveals allocation patterns, highlighting objects with extended retention times that contribute to increased memory footprints. For instance, filtering by object type in the statistics view can pinpoint over-retained instances, such as undismissed modal views or unoptimized image caches. Reducing the involves refactoring based on these insights, such as implementing proper deallocation in viewDidDisappear methods or using weak references in delegates to break retain cycles. Developers can set heapshot markers at critical points—like before and after a complex operation—to compare live object graphs and isolate growth areas. This approach minimizes dirty memory pages, where writing even a single byte to new memory can allocate up to 16 KB on , by encouraging reuse of existing buffers or of assets. Overall, regular profiling with Allocations can help reduce an app's peak memory usage in scenarios with heavy data processing, improving background survival rates.

CPU Bottleneck Resolution

Resolving CPU bottlenecks starts with the Time Profiler instrument, which generates call graphs to visualize execution paths and identify hot paths consuming disproportionate processing time. As of Xcode 26, Processor Trace provides detailed capture of every function call, and hardware-assisted tools enable precise optimization on . During a recording session focused on compute-intensive tasks, such as data parsing or algorithm execution, the call graph highlights functions with high self-time percentages, indicating inefficient code segments. Developers drill down into inverted call trees to trace stack frames, revealing bottlenecks like nested loops or redundant computations in frequently called methods. Refactoring hot paths typically involves optimizing algorithms—for example, replacing O(n²) searches with hash tables—or vectorizing operations for efficiency. By comparing before-and-after traces, developers confirm reductions in CPU utilization for targeted functions. The Time Profiler, as detailed in the Built-in Instruments section, integrates with CPU Counters to categorize bottlenecks by type, such as instruction delivery or branch misprediction, guiding precise code adjustments.

Responsiveness Fixes

Main thread analysis in Instruments uses templates like Hitches or Time Profiler to detect hangs and ensure UI fluidity, targeting operations that block user interactions. The new SwiftUI instrument, introduced in Xcode 26, helps profile view updates and data-driven changes for SwiftUI apps. Recording during user flows, such as scrolling lists or transitioning views, reveals main thread overloads through timeline spikes exceeding 100 ms thresholds, which cause perceived freezes. The thread tracks display call stacks for these events, identifying culprits like synchronous network calls or heavy computations on the UI thread. Fixes center on offloading non-UI work to Dispatch queues, using async/await in Swift concurrency for structured parallelism or DispatchQueue.global() for legacy tasks. For example, image decoding or file I/O can be dispatched concurrently, updating the main thread only for final UI renders via DispatchQueue.main.async. Post-refactor traces in Instruments verify hitch reductions, with benchmarks showing frame rates stabilizing at 60 FPS and hang durations dropping below 16 ms. This workflow prioritizes XCTest performance tests to enforce main thread budgets, preventing regressions in responsiveness.

Battery Impact Reduction

Battery optimization employs the Energy Log (via Energy Diagnostics template) or Power Profiler to quantify an app's , focusing on wakeups and network activity that drain resources. Enhancements in 26 improve Power Profiler for better battery and thermal analysis. To address idle wakeups, developers enable logging on the device and import traces into Instruments, where the timeline exposes frequent background activations from timers or push notifications. High wakeup counts, visible as CPU spikes during idle periods, signal inefficient polling; refactoring consolidates timers using Background App Refresh or coalesces events to availability. For network efficiency, instrument within Power Profiler tracks transfers, revealing energy-intensive patterns like frequent small requests. Strategies include batching calls, compressing payloads, or switching to efficient protocols like to minimize radio wakeups. Traces post-optimization show reductions in energy impact scores, extending battery life during prolonged sessions. Integrating MetricKit reports further validates real-user , ensuring sustained efficiency.

Case Studies

In optimizing a video streaming app's rendering , developers used the Time Profiler to identify a hot path in frame decoding that spiked CPU usage during playback. By offloading AVFoundation processing to a serial Dispatch queue and batching buffer updates, the refactor reduced decoding time, smoothing 4K playback on without frame drops. Concurrent Allocations tracing confirmed no memory leaks from video caches, further lowering the footprint through timed purges. For a physics-based game, Instruments' CPU profiling revealed bottlenecks in the simulation loop, where collision detections in a accounted for a significant portion of frame time on . Refactoring involved spatial partitioning to cull unnecessary checks and vectorizing computations with Accelerate framework, yielding a in physics updates. Energy Log analysis then targeted idle wakeups from background syncing, batching them to cut battery drain during extended play sessions. These changes maintained 120 FPS while enhancing device longevity.

References

  1. https://developer.apple.com/documentation/xcode/using-instruments
  2. https://developer.apple.com/forums/forums/topics/developer-tools-and-services/developer-tools-and-services-instruments
  3. https://developer.apple.com/library/archive/documentation/AnalysisTools/Conceptual/WhatsNewInstruments/Introduction/Introduction.html
  4. https://developer.apple.com/tutorials/instruments
  5. https://developer.apple.com/videos/play/wwdc2018/410/
  6. https://developer.apple.com/videos/play/wwdc2025/308/
  7. https://developer.apple.com/videos/play/wwdc2019/411/
  8. https://xcodereleases.com/
  9. https://apple.stackexchange.com/questions/30837/no-shark-on-os-x-lion
  10. https://developer.apple.com/library/archive/documentation/Performance/Conceptual/EnergyGuide-iOS/MonitorEnergyWithInstruments.html
  11. https://developer.apple.com/documentation/xcode-release-notes/xcode-26-release-notes
  12. https://www.blackhat.com/presentations/bh-usa-08/Beauchamp_Weston/BH_US_08_Beauchamp-Weston_DTrace.pdf
  13. https://bcantrill.dtrace.org/2006/08/07/dtrace-on-mac-os-x/
  14. https://www.objc.io/issues/19-debugging/dtrace
  15. https://developer.apple.com/documentation/xcode/creating-custom-modelers-for-intelligent-instruments
  16. https://developer.apple.com/documentation/xcode/instruments
  17. https://developer.apple.com/videos/play/wwdc2016/411/
  18. https://developer.apple.com/videos/play/wwdc2018/405/
  19. https://developer.apple.com/library/archive/documentation/DeveloperTools/Conceptual/InstrumentsUserGuide/index.html
  20. https://developer.apple.com/tutorials/instruments/determining-execution-frequency
  21. https://developer.apple.com/library/archive/technotes/tn2434/_index.html
  22. https://developer.apple.com/library/archive/documentation/Performance/Conceptual/ManagingMemory/Articles/FindingLeaks.html
  23. https://developer.apple.com/documentation/xcode/investigating-crashes-for-zombie-objects
  24. https://developer.apple.com/documentation/foundation/analyzing-http-traffic-with-instruments
  25. https://developer.apple.com/documentation/xcode/measuring-your-app-s-power-use-with-power-profiler
  26. https://developer.apple.com/documentation/xcode/analyzing-the-performance-of-your-metal-app
  27. https://developer.apple.com/documentation/xcode-release-notes/xcode-16_3-release-notes
  28. https://developer.apple.com/videos/play/wwdc2025/306/
  29. https://developer.apple.com/tutorials/instruments/getting-started-with-hang-analysis
  30. https://developer.apple.com/tutorials/instruments/analyzing-main-thread-activity
  31. https://developer.apple.com/library/archive/documentation/AnalysisTools/Conceptual/WhatsNewInstruments/NewFeatures42/NewFeatures42.html
  32. https://stackoverflow.com/questions/32785857/why-am-i-unable-to-export-my-xcode-instruments-data-as-a-csv-the-option-is-grey
  33. https://developer.apple.com/documentation/xcode/making-changes-to-reduce-memory-use
  34. https://developer.apple.com/documentation/xcode/customizing-the-build-schemes-for-a-project
  35. https://developer.apple.com/library/archive/referencelibrary/GettingStarted/RoadMapiOS-Legacy/chapters/CreateYourAppinXcode/StartYourProjectinXcode/StartYourProjectinXcode.html
  36. https://developer.apple.com/videos/play/wwdc2021/10211/
  37. https://developer.apple.com/library/archive/documentation/Xcode/Conceptual/RN-Xcode-Archive/Chapters/xc5_release_notes.html
  38. https://developer.apple.com/documentation/xcode/finding_memory_leaks_using_instruments
  39. https://developer.apple.com/documentation/xcode/creating-custom-modelers-for-intelligent-instruments#Design-a-Custom-Modeler-for-MobileAgent-Activity
  40. https://developer.apple.com/documentation/xcode/creating-custom-modelers-for-intelligent-instruments#CLIPS-Modeler-Functions
  41. https://developer.apple.com/documentation/xcode/reducing-your-app-s-memory-use
  42. https://developer.apple.com/documentation/xcode/reducing-your-app-s-memory-use#View-data-on-memory-use
  43. https://developer.apple.com/documentation/xcode/gathering-information-about-memory-use
  44. https://developer.apple.com/documentation/xcode/reducing-your-app-s-memory-use#Understand-memory-use-metrics
  45. https://developer.apple.com/documentation/xcode/addressing-cpu-bottlenecks
  46. https://developer.apple.com/documentation/xcode/understanding-and-improving-swiftui-performance
  47. https://developer.apple.com/documentation/apple-silicon/tuning-your-code-s-performance-for-apple-silicon
  48. https://developer.apple.com/documentation/xcode/improving-app-responsiveness
  49. https://developer.apple.com/documentation/xcode/analyzing-your-app-s-battery-use
  50. https://developer.apple.com/videos/play/wwdc2022/10106/
Add your contribution
Related Hubs
Contribute something
User Avatar
No comments yet.