> Xcode Hidden Command Line Tools

Build, test, archive, and export Xcode projects from the command line. The headless equivalent of every button on the Xcode toolbar.

Compiles asset catalogs (.xcassets) into the runtime binary format used by your app.

Compiles, lints, and upgrades storyboards and XIB files. Backs the Interface Builder editor.

A background daemon that ibtool talks to during builds.

Compiles Core Data managed object models (.xcdatamodeld) into the .momd format your app loads at runtime.

Compiles and optimizes Core ML models so they can be loaded at runtime with minimal overhead.

Compiles App Intents definitions into the runtime metadata that powers Siri and Shortcuts integration.

Compiles Core Data mapping models used during lightweight migrations between schema versions.

Precompiles SceneKit Metal shaders so they do not have to be compiled at first use.

Copies and optimizes PNG files during the build phase, including premultiplying alpha for the iOS device runtime.

Copies and processes SceneKit asset catalogs into the format the runtime expects.

Converts plists to binary format and optimizes PNG files inside an app bundle. Run automatically during release builds.

Apple's linker. Combines compiled object files into a final executable, framework, or dylib.

Front ends to the Clang compiler for C, C++, and Objective-C source. Despite the name, these are not GNU GCC.

Used by the App Store to rebuild apps from their bitcode representation. Mostly historical now.

Reads .xcresult bundles and emits structured JSON. Useful for parsing test output in CI without scraping logs.

Runs an XCTest bundle directly without going through xcodebuild. The same runner Xcode invokes when you press Cmd+U.

Records Instruments traces from the command line so you can profile apps in CI or on a build server.

Reads code coverage data out of .xcresult bundles. Often used to gate PRs on coverage thresholds.

Lints and validates asset catalogs to catch missing image variants and other problems before they reach a build.

The debugger that powers everything you see in the Xcode debug bar. You can also drive it directly for advanced workflows.

An adapter that exposes LLDB through the Debug Adapter Protocol so editors like VS Code can use it.

Attaches to a running process and reports memory leaks. The CLI version of the Instruments Leaks tool.

Inspects heap allocations in a running process and groups them by class.

Prints a virtual memory map for a process so you can see where every region comes from.

Shows the call stack that allocated a given address. Helpful when chasing down where a leaked object came from.

Finds duplicate string literals in a binary that could be deduped to save memory.

Periodically samples a running process to produce a CPU profile without attaching a full instrument.

Filters and inverts call trees produced by Instruments so you can focus on the slow paths.

Looks up debug symbols for addresses, useful for symbolicating crash data outside of Xcode.

Translates raw memory addresses into symbol names for a binary plus dSYM.

Symbolicates and parses .crash and .ips crash report files.

Dumps and analyzes archived system log bundles when Console.app is not enough.

An internal helper used by Xcode itself for debugging session setup. Rarely invoked directly outside of Apple internals.

Collects diagnostic bundles for Apple Developer Technical Support cases.

Builds custom Instruments packages so you can ship your own profiling tools.

Drives the iOS Simulator from the command line. Boot, install, launch, screenshot, set permissions, push notifications.

Manages physical devices over USB or Wi-Fi. Install apps, capture logs, run tests, and inspect device state.

Lists and queries connected devices. Older but still useful for scripting device discovery.

Submits notarization requests to Apple and polls for results. The modern replacement for altool notarization.

Staples a notarization ticket onto an app or installer so Gatekeeper can verify it offline.

The legacy uploader and validator. Mostly replaced by notarytool and Transporter, but still around.

Uploads builds to App Store Connect. Now mostly a wrapper that defers to the Transporter app.

Performs code signing operations as part of the build pipeline.

Signs XAR archives, used for some installer formats.

Validates that embedded binaries inside an app bundle conform to App Store rules.

Builds an IPA archive suitable for App Store submission.

Process and validate IPA files outside of the GUI export flow.

Bumps version and build numbers across an Xcode project in one command. Replaces hand-editing the Info.plist before each release.

Opens files or projects in Xcode from the terminal. Useful in shell scripts and Makefiles.

Launches FileMerge to diff or merge files visually.

Tests Xcode indexing behavior, used internally for diagnosing slow autocomplete.

Scans source code for NSLocalizedString calls and generates a Localizable.strings file from the keys it finds.

Extracts localized strings out of a compiled binary, the reverse of genstrings.

Manages the newer .xcstrings catalog format from the command line.

Strips rich text formatting from a file and writes the plain ASCII equivalent.

Apple's bundled copy of the PNG optimizer. Run during builds to shrink raster assets without quality loss.

Creates texture atlases for SpriteKit by packing many small images into one larger texture.

Converts texture data between formats for use in graphics pipelines.

Processes SceneKit scene files (.scn) for inclusion in app bundles.

Processes RealityKit assets like .usdz and .reality files used in AR experiences.

Compiles ARKit reference objects produced by the Reality Composer scanning workflow.

Generates placeholder app icons for builds where the real icons are not yet ready.

Processes icon and image assets, primarily for the App Store metadata pipeline.

Generates MD5 checksums for App Store assets to verify integrity during upload.

Manages CloudKit schemas and records from the command line, including importing and exporting.

An internal bridge used by Xcode for Model Context Protocol integration so AI tools and assistants can interact with the project.

Packages Background Assets content into the archive format the runtime downloads.

Serves Background Assets packs over a local network for testing without uploading to a CDN.

Simulates BackgroundAssets extension events so you can exercise download flows on demand.

Converts Chrome or Firefox extensions into Safari Web Extension projects.

Packages a Safari Web Extension into the format the App Store accepts.

Compiles classic Mac resource description files (.r) into resource forks. Almost entirely historical at this point.

Decompiles a resource fork back into the .r source representation.

Merges multiple resource fork files into one.

Splits a file into separate resource and data fork files.

Reads HFS file attributes like creator code and type.

Writes HFS file attributes like creator code and type.

Generates HTML documentation from HeaderDoc comments in headers and source files.

Combines HeaderDoc output across multiple files into a single table of contents.

Converts HeaderDoc XML output into the XML format used by xml2man.

Converts XML descriptions into Unix man pages.

Extracts the scripting definition from an app so you can see what AppleScript or JavaScript for Automation can drive.

Converts scripting definitions between formats, useful when generating headers for Scripting Bridge.

A development tool for Apple's Siri natural language understanding stack.

Tests how a specific app integrates with the Siri stack.

Exercises the natural language understanding component on its own.

Reads and writes the system game policy enforcement settings used by the Game Mode feature.

Prints information about the bundled Swift compiler and runtime versions.

Queries the database of Apple product type identifiers, useful when targeting specific hardware.

Extracts scripting information out of an app bundle.

Resolves symbolic links in a path and prints the canonical destination. Generic filesystem helper used during builds.

Standard Git, bundled with Xcode so it works out of the box on a fresh Mac.

Server side handler for git push operations.

A restricted login shell that only permits Git operations, used on Git servers.

Server side handler for git archive over SSH.

Server side handler for git fetch and clone operations.

A wrapper around Git designed to scale to very large repositories.

The Python interpreter bundled with Xcode for use by build scripts and tooling.

The Python package manager that pairs with the bundled interpreter.

The Python documentation viewer.

A migration tool for converting Python 2 source to Python 3.

GNU Make, bundled so build scripts that depend on it work without a separate Homebrew install.