How to uninstall Xcode completely, and what to keep

To uninstall Xcode completely, removing the app is the last big step, not the first. Dragging Xcode to the Trash removes the app and the tools inside it, and nothing else. Simulator runtimes, simulators, build files, archives, caches and settings stay where they are, and together they're usually much larger than the app.

So the order matters. Delete simulator runtimes in Xcode's own Components settings while Xcode is still installed, because that's the only place with a button for them. Then move the app to the Trash, and go through ~/Library/Developer one folder at a time.

Before any of that, save what you can't easily get back: archives of builds you shipped, with their dSYM files; your signing identities, above all a Developer ID; and any provisioning profiles you manage by hand. Signing identities live in your keychain, so removing Xcode doesn't touch them, but a full cleanup is the right moment for a backup.

The Command Line Tools are a separate question. They're a different package, and tools such as git and Homebrew may need them once Xcode is gone. If you're keeping Xcode and only want space back, read why Xcode takes up so much space instead.

What uninstalling Xcode actually removes

Xcode is one app, but it writes to many places on your Mac. Only one of those places is the Applications folder, and that's the only one that dragging the app to the Trash clears.

What does moving Xcode to the Trash remove?

The app bundle, with everything inside it: the compilers, the SDKs, the build tools, and the developer apps Xcode opens from Xcode › Open Developer Tool, such as Instruments, Accessibility Inspector and FileMerge. In Xcode 27, Device Hub lives inside the app too.

Apple's technical note on command-line builds says Xcode includes all of the command-line tools. So if you use git, clang or make in Terminal through Xcode, rather than through the separate Command Line Tools package, those go with the app. The section on the Command Line Tools below explains what to do about that.

What stays behind?

Everything Xcode downloaded or made after its first launch. Apple's support article on uninstalling says deleting an app doesn't remove the files you created with it. For Xcode, that's most of its footprint.

Part	Where it lives	Typical size	Level
Simulator runtimes	System folders macOS manages	20–200 GB	Managed by macOS
Simulators	~/Library/Developer/CoreSimulator/Devices	10 GB to several hundred	Usually safe
DerivedData	~/Library/Developer/Xcode/DerivedData	5–100 GB	Safe
Device support files	~/Library/Developer/Xcode/iOS DeviceSupport	5–60 GB	Safe
Archives	~/Library/Developer/Xcode/Archives	1–50 GB	Review first
Caches and preview simulators	~/Library/Caches/com.apple.dt.Xcode, ~/Library/Developer/Xcode/UserData/Previews	1–20 GB	Safe
Your Xcode setup and profiles	~/Library/Developer/Xcode/UserData, ~/Library/Preferences	A few MB	Your settings

The typical ranges come from developers' reports collected for the app's rules catalog. Each folder is in your own Library, except the runtimes, which macOS keeps in system folders and protects.

How much space does all of it take?

It depends on how many projects, devices and OS versions you've worked with. Here's one real example, measured on the Mac this post was written on, which runs Xcode 27 with a single iOS runtime installed.

• Xcode 27, on disk3.7 GB
• DerivedData16 GB · Safe
• One iOS simulator runtime7.8 GB · Managed by macOS
• Simulators and their caches4.7 GB · Usually safe
• Simulator library cache3.8 GB · Managed by macOS
• Swift package cache3.5 GB · Safe
• Archives1.9 GB · Review first
• Command Line Tools1.8 GB

Measured in October 2026 on one developer's Mac. Developers' reports collected for the app's catalog often put Xcode's total between 50 and 300 GB.

On that Mac, the app took about a tenth as much space as what Xcode had left around it. Its files add up to about 9.6 GB, but they used only 3.7 GB on disk, because many of them are stored compressed. Finder's Get Info shows both numbers.

Everything else came to roughly 38 GB, and none of it would have left with the app.

Are you removing Xcode for good?

Not every uninstall needs every step. What you remove depends on why you're removing Xcode.

Your goal	Remove	Keep
Fix a damaged install	The app only	Everything else, which the new copy uses
Replace an old version	The old copy of the app	Runtimes, simulators and data you still use
Free space but keep developing	Nothing in this post	Follow the Xcode space post instead
Stop developing for Apple platforms	Everything below, in order	Shipped archives and a Developer ID backup
Pass the Mac to someone else	Erase the whole Mac instead	Backups of what you keep

If you're reinstalling, remove only the app. Removing runtimes and simulators first just means downloading and setting them up again with the new copy.

What to keep before you uninstall Xcode

Most of what Xcode leaves behind comes back by itself, or with a download. A few things don't, and they're worth ten minutes before you start.

Archives of builds you shipped

Each time you choose Product › Archive, Xcode keeps the exact app you built with its dSYM files. A dSYM turns crash reports from that build into readable function names and line numbers, and it matches only the build it came from.

Apple recommends keeping the archive of every build you distribute. The catalog rates Xcode archives as Review first for that reason: once an archive is gone, crash reports from that build may show only addresses, unless you uploaded its symbols to App Store Connect or kept the dSYMs elsewhere.

To save them before you uninstall:

1. In Xcode, choose Window › Organizer and click Archives.
2. Control-click an archive and choose Show in Finder.
3. Copy the archives you shipped to an external drive or a backup folder. Each archive is a bundle, so Finder copies it like a folder, dSYMs and all.

If you changed the Archives location in Xcode › Settings › Locations, they may not be in your Library folder at all. Check there first.

Signing identities in your keychain

A signing identity is a certificate plus its private key. Xcode keeps both in your keychain, usually the login keychain, not in its own folders. Moving Xcode to the Trash leaves them exactly where they are.

The risk comes later: a new Mac, an erased disk, or a cleanup of the keychain itself. An Apple Developer Technical Support engineer calls Developer ID signing identities "precious" and recommends keeping your own backup.

Apple Development identities are different. If you lose one, you can revoke it and create a replacement on the developer website, or let Xcode's automatic signing make a new one.

How do you back up a signing identity?

Older versions of Xcode could export every account and signing asset to one file. Apple's support engineer wrote in 2025 that, as he understood it, the feature had been removed, so Keychain Access is the route now:

1. Open Keychain Access with Spotlight.
2. Click My Certificates at the top, and select the keychain that holds your identities, usually login.
3. Select the identity, then choose File › Export Items.
4. Choose Personal Information Exchange (.p12) as the file format, and save it.
5. Enter a strong password to protect the file when asked, and store that password somewhere safe.

Keep the .p12 file somewhere secure. Anyone with it and its password can sign code as you.

Provisioning profiles

Xcode 16 and later keep downloaded provisioning profiles in ~/Library/Developer/Xcode/UserData/Provisioning Profiles, according to Apple's release notes. Older versions used ~/Library/MobileDevice/Provisioning Profiles, and Xcode still reads profiles from there.

With automatic signing, you don't need to save them. Apple's account help says Xcode requests a new profile when it can't find a suitable one on the Mac.

Profiles you created by hand on the developer website can be downloaded again from Certificates, Identifiers & Profiles › Profiles by an Account Holder or Admin. Expired ones need to be generated again. If you rely on manual profiles, copying both folders is the quickest insurance.

Your Xcode setup

~/Library/Developer/Xcode/UserData holds your custom key bindings, editor themes and code snippets. It's small, and it's the only copy. If you might come back to Xcode, copy the folder somewhere safe before you remove anything.

Your projects and source code

Xcode doesn't keep your projects in its Library folders. They stay wherever you saved them, and uninstalling Xcode never touches them. Repositories you push to a remote, and builds already on App Store Connect or TestFlight, are on servers and aren't affected either.

What	Where	How to save it	If you lose it
Shipped archives	~/Library/Developer/Xcode/Archives	Copy to a backup drive	Gone; later builds can't stand in
Developer ID identity	Your keychain	Export a .p12 in Keychain Access	You create a replacement
Apple Development identity	Your keychain	Optional	Xcode makes a new one
Manual provisioning profiles	UserData/Provisioning Profiles	Copy the folder	Download or generate again
Key bindings, themes, snippets	~/Library/Developer/Xcode/UserData	Copy the folder	Set them up again by hand

Before you remove the app: runtimes, components and simulators

Many uninstall guides skip this step, and it's often where most of the space is.

Why does the order matter?

Simulator runtimes don't go with the app. They stay installed until they're deleted, in system folders that macOS manages and protects, and Xcode's Components settings are the only place with a button to delete them.

Remove Xcode first, and that button goes with it. Getting the space back then means installing Xcode again just to delete the runtimes.

Delete simulator runtimes in Components

1. Shut down any running simulators, then choose Xcode › Settings and click Components.
2. Under Other Installed Platforms, look at each runtime. Xcode shows how much space removing each one recovers.
3. Click the information button next to a runtime, then click Delete.
4. Repeat for every runtime, since you're removing Xcode for good.

Runtimes deleted here don't go to the Trash; they're gone at once. The space can take a little while to appear in Finder. If a runtime won't leave or comes back after a restart, the post on deleting simulator runtimes covers the known problems and what Apple says about them.

Turn off optional components

Apple's documentation describes two more sections in the same window. Platform Support lists the platforms you build for, and Other Components lists optional features, such as the Metal Toolchain.

Click the information button next to anything you've installed there and choose Delete or Turn Off, depending on the component. Removing them now, while Xcode can, saves guessing later where each one was stored.

Remove simulators and unpair devices

Simulators are folders in your own Library, so you could move them to the Trash in Finder later. Removing them in Xcode first is cleaner, because Xcode's simulator service knows about each one.

In Xcode 27, choose Xcode › Open Developer Tool › Device Hub. Control-click each simulator you don't need and choose Remove. Apple notes that the sidebar shows only simulators you added there or used as run destinations, so some may not appear; those are handled in Finder below.

In the same sidebar, Control-click each paired iPhone, iPad or other device and choose Unpair. Then, on each device, turn off Developer Mode in Settings › Privacy & Security and restart it, as Apple describes, if you won't run apps from Xcode on it again.

Task	Xcode 26	Xcode 27
Delete runtimes	Xcode › Settings › Components	Xcode › Settings › Components
Remove a simulator	Window › Devices and Simulators, Simulators, Control-click, Delete	Device Hub, Control-click, Remove
Open the device list	Window › Devices and Simulators	Xcode › Open Developer Tool › Device Hub
Find your archives	Window › Organizer, Archives	Window › Organizer, Archives
Check where data lives	Xcode › Settings › Locations	Xcode › Settings › Locations

Everything on a removed simulator is deleted with it: its apps, their data and its settings. Since you're uninstalling, that's the point, but copy out any test data you want first.

Remove the Xcode app

Now the app itself. This part works the same on macOS 27 Golden Gate and macOS 26 Tahoe.

Quit Xcode and everything it opened

Quit Xcode, and quit any developer tools it opened, such as Instruments, Device Hub or Simulator. macOS won't move an app that's in use, and a running simulator service can keep writing to its folders while you clear them.

Move Xcode to the Trash

1. In Finder, click Applications in the sidebar.
2. Drag Xcode to the Trash, or select it and choose File › Move to Trash.
3. If macOS asks, enter an administrator's name and password.

Don't empty the Trash yet. Until you do, File › Put Back returns the app, and the space isn't freed anyway. If you installed Xcode from the App Store, you can download it again from there later.

Betas, older versions and renamed copies

Each copy of Xcode is a complete app, so a beta or an older version is another several gigabytes. Look in Applications for names such as Xcode-beta, and for copies with version numbers in their names, which some version-management tools create.

A Finder search for Xcode, narrowed to applications, finds copies kept in other folders. Remove every copy you don't need. If you keep one, keep its runtimes and data too, and skip the rest of this post.

Clear out ~/Library/Developer, folder by folder

Most of what's left is in ~/Library/Developer. With Xcode gone, most of it has no use, but a few folders are yours or belong to other tools.

How do you open it?

In Finder, choose Go › Go to Folder, enter ~/Library/Developer, and press Return. Switch to list view and turn on Calculate all sizes in View › Show View Options to see what each folder holds.

Which folders can go once Xcode is gone?

• Xcode/DerivedData: build files, indexes and logs for every project. Xcode DerivedData is Safe; a reinstalled Xcode rebuilds what it needs.
• Xcode/iOS DeviceSupport and its watchOS, tvOS and visionOS siblings: symbols copied from your devices. Safe, and useless without Xcode.
• CoreSimulator: the simulators you didn't remove in Xcode, with their caches. Everything on them is deleted, which is what you want now.
• XCTestDevices and XCPGDevices: simulator clones from parallel test runs, and the simulators that ran playgrounds.
• Xcode/UserData/Previews: the simulators that showed SwiftUI previews.

Restart before you move the simulator folders, so no part of the simulator service is still running. Then move them to the Trash.

Which folders should you check first?

• Xcode/Archives: copy the builds you shipped before this folder goes, as above.
• Xcode/UserData: your setup and provisioning profiles. Copy it if you might come back.
• Toolchains: Swift toolchains you installed from swift.org. They're not Xcode's, and projects, scripts or editors may still be set to use them.
• Folders you don't recognize: other developer tools write here too. Leave anything you can't tie to Xcode.

CoreDevice is a special case. It's where Xcode's device service shows the files of paired devices, and disk tools that follow it can count those files, but it's a view of files stored elsewhere. On the Mac we measured, the folder itself took 4 KB. It's harmless either way.

Folder in ~/Library/Developer	What it is	After uninstalling Xcode
Xcode/DerivedData	Build files and indexes	Move to the Trash
Xcode/* DeviceSupport	Symbols from your devices	Move to the Trash
CoreSimulator	Simulators and their caches	Move to the Trash after a restart
XCTestDevices, XCPGDevices	Test and playground simulators	Move to the Trash
Xcode/Archives	Shipped builds and dSYMs	Back up first, then remove
Xcode/UserData	Settings, snippets, profiles	Copy if you may return
Toolchains	Swift toolchains from swift.org	Keep if anything uses them

Why not move the whole folder at once?

Because it mixes folders that rebuild with folders you can't get back, and folders of other tools with Xcode's. Going folder by folder takes a few more minutes and costs nothing. The post on what every folder in ~/Library/Developer does covers the smaller ones in detail.

Xcode's other files in your Library folder

A few more things sit elsewhere in your Library. They're small, apart from one cache, but a complete uninstall removes them too.

To open your Library folder, hold down Option in Finder, choose Go, then Library. Most of Xcode's own files start with com.apple.dt, and the simulator's with com.apple.CoreSimulator or com.apple.iphonesimulator. Other names starting with com.apple belong to macOS or Apple's other apps, so leave those.

Caches

~/Library/Caches/com.apple.dt.Xcode and ~/Library/Caches/com.apple.dt.xcodebuild hold cached network data and temporary files. Xcode caches are Safe.

~/Library/Caches/org.swift.swiftpm holds the package repositories your projects depended on, and can reach several gigabytes. It's a Safe cache, also used by Swift on the command line, which downloads packages again when it needs them.

Preferences, saved state and support files

Xcode's settings are in ~/Library/Preferences/com.apple.dt.Xcode.plist, with smaller files for xcodebuild, Instruments and the simulator beside it. When you're removing Xcode for good, they can go: they're the app's settings, and nothing else uses them.

If you might reinstall, keep them. They're tiny, and they're what brings your Xcode settings back. A com.apple.dt.Xcode folder in Application Support and a saved window state, if you have one, follow the same rule.

Logs, web data and the older profiles folder

~/Library/Logs/CoreSimulator holds simulator logs, which are only useful for troubleshooting. HTTPStorages has small folders of Xcode's web data. Both can go.

The older ~/Library/MobileDevice/Provisioning Profiles folder holds profiles from versions before Xcode 16. Remove it once you've copied any manual profiles you need.

Item in ~/Library	What it is	Remove when uninstalling for good?
Caches/com.apple.dt.Xcode	Xcode's cache	Yes
Caches/org.swift.swiftpm	Swift package cache	Yes, unless you build packages in Terminal
Preferences/com.apple.dt.Xcode.plist	Xcode's settings	Yes, unless you'll reinstall
Logs/CoreSimulator	Simulator logs	Yes
HTTPStorages/com.apple.dt.Xcode	Xcode's web data	Yes
MobileDevice/Provisioning Profiles	Older profiles	After copying manual ones

The system-wide parts: /Library/Developer and the Command Line Tools

Some of what Xcode installed belongs to the whole Mac, in the Library folder at the top of the disk. Most of it should stay.

What did Xcode install for every account?

On its first launch, Xcode installs system components: device and simulator support in /Library/Developer, in folders such as CoreDevice, DeviceKit and PrivateFrameworks, and updated device-connection components in a folder that System Integrity Protection guards.

On the Mac we measured, those folders in /Library/Developer took about 300 MB, not counting the simulator cache below. Apple doesn't document removing them, a new copy of Xcode installs them again, and the protected ones can't be removed. Leave them.

What about runtimes you forgot to delete?

If you've already removed Xcode, the runtimes are still there, in system folders that macOS manages and Finder shouldn't touch. Simulator runtimes are Managed by macOS, and the supported route is the one above: install Xcode again, delete them in Components, then remove it again.

That's a large download for a cleanup, so weigh it against the space. One runtime is often 5 to 20 GB, and many Macs have several.

The simulator library cache in /Library/Developer/CoreSimulator/Caches belongs to the runtimes. CoreSimulator creates and updates it itself, so it's Managed by macOS too, and the way to shrink it is to have fewer runtimes.

Do you still need the Command Line Tools?

Apple's documentation describes the Command Line Tools for Xcode as a separate package at /Library/Developer/CommandLineTools. It has the same macOS SDK, manual pages and compilers as Xcode, without the app. Commands such as xcodebuild ship only with Xcode.

Commands macOS provides in /usr/bin, such as git, clang, make and python3, run from whichever set of developer tools is selected, according to the xcode-select manual page. With Xcode gone, they need the Command Line Tools.

You use	Need the Command Line Tools?
git, make or clang in Terminal	Yes
Homebrew, building from source	Yes, or Xcode
Homebrew bottles and casks on Apple silicon	Not for installing them
Swift on the command line	Yes
None of the above	No

If you only had Xcode, download Command Line Tools for Xcode from the More Downloads page of Apple's developer site, signing in with your Apple Account, and open the installer. Apple notes that on a new Mac, running a command such as git also offers to install them.

If your tools were set to use Xcode, they may keep looking for it after it's gone, even with the package installed. Resetting that choice is a Terminal-only step, described in the xcode-select manual page; there's no setting for it in System Settings.

Can you remove the Command Line Tools too?

Yes, but Apple documents it only as administrator commands in Terminal, with no app or Finder route. Apple also notes that Software Update keeps offering new releases of the package until its receipt is removed, which is another Terminal step.

On the Mac we measured, the package took 1.8 GB. If anything you use might need it, leaving it is the better trade.

A worked example, start to finish

Here's the whole process on the Mac measured above. Say its owner is moving to web development and wants Xcode gone, but still uses git and Homebrew every day.

Before touching anything

They shipped two apps, so the archives of those releases go to an external drive, about 1.9 GB together. They export their Developer ID identity from Keychain Access as a .p12 file and keep it with the drive.

Their profiles are managed by Xcode, so there's nothing to copy there. They copy UserData anyway: it's 37 MB, and it holds their key bindings.

Inside Xcode

In Components, they delete the one iOS runtime, 7.8 GB, and remove the Metal Toolchain. In Device Hub, they remove their simulators and unpair an iPhone, then turn off Developer Mode on the phone. Then they quit Xcode and drag it to the Trash.

In Finder

After a restart, they move DerivedData, CoreSimulator, XCTestDevices and XCPGDevices to the Trash from ~/Library/Developer, followed by the Archives folder, now that it's backed up. They leave a third-party tool's folder there alone.

In the Library folder, Xcode's caches, the 3.5 GB Swift package cache, simulator logs and Xcode's preferences go too. They leave the Command Line Tools in place, because git and Homebrew need them.

The result

About 34 GB moves to the Trash or out of the runtimes' system folders, on top of the 3.7 GB the app took on disk. The simulator library cache is left for CoreSimulator to manage, and the 1.8 GB of Command Line Tools stays on purpose.

After a day of normal work in Terminal, with git and Homebrew behaving as before, they empty the Trash.

What if the Mac has more than one account?

Each account has its own ~/Library/Developer and its own Library folder. Log in to each account that used Xcode and repeat the Finder steps there. Runtimes and the system-wide parts are shared, so they're handled once.

After uninstalling Xcode

Empty the Trash, then check the space

Use your Mac normally for a day, then choose Finder › Empty Trash. Until then, the app and the folders you moved still take space.

Check the result in System Settings › General › Storage. The numbers can take a few minutes to update after a large deletion. Runtimes deleted in Components may take a little longer to show up as free space.

Reinstalling Xcode later

A new copy starts clean. On first launch it installs its system components again, and Components settings offers runtimes to download. Automatic signing fetches profiles again. Import your .p12 by double-clicking it, and copy back your UserData folder if you saved it.

If you'll reinstall soon, think again about the runtimes. Deleting them and downloading them a week later costs time and bandwidth for no gain.

Mistakes to avoid

• Removing the app first. It takes the only button for deleting runtimes with it.
• Moving ~/Library/Developer as a whole. It takes shipped archives and your setup along with the parts that rebuild.
• Deleting archives you shipped without a copy elsewhere.
• Deleting certificates in Keychain Access to tidy up. You don't need to, and a lost Developer ID identity has to be replaced.
• Removing everything named com.apple. Only the com.apple.dt items and the simulator's own are Xcode's.
• Pasting removal scripts from a web page. Commands that delete files don't use the Trash and can't be undone.
• Expecting a faster Mac. Removing Xcode frees space. It doesn't make anything else run faster.

How the app does it

Wombit explains Xcode's folders like everything else on the disk. Select one in the map or the list, and the inspector says what it is, how safe it is to remove and what removing it costs, from the catalog's entry. It reads only names, sizes and dates, and file names and paths never leave your Mac.

Cleanup lists Xcode's data by level:

• DerivedData, device support files, Xcode's caches, the Swift package cache, and the preview, test and playground simulators are Safe. They count toward the safe total and start checked.
• Archives are Review first and wait for you to check them.
• Simulators are Usually safe and runtimes are Managed by macOS. Both are explained with Xcode's own steps, and the app leaves removing them to Xcode, so do that before you remove the app.

Folders go to the Trash, where Undo and Put Back work. For the preview, test and playground simulators, the app runs Xcode's own tool instead, after the review sheet. What a command removes can't be put back, and the sheet says so.

• ~/Library/Developer/Xcode/DerivedData

  Xcode DerivedData

  Build products, indexes and logs Xcode keeps for every project you've built.

  Safe · Moves it to the Trash

• ~/Library/Developer/Xcode/* DeviceSupport

  Xcode device support files

  Symbol files Xcode copies from each iPhone, iPad, Apple Watch, Apple TV or Apple Vision Pro you connect, one set per OS version.

  Safe · Moves it to the Trash

• ~/Library/Developer/Xcode/Archives/*/*.xcarchive

  Xcode archives

  Copies of each build you archived in Xcode, with the dSYM files needed to read crash reports from that build.

  Review first · Moves it to the Trash

• ~/Library/Developer/CoreSimulator/Devices

  Simulator devices

  The simulated devices you run apps on from Xcode, each with its own installed apps, data and settings.

  Usually safe · Explained only: the app shows you how

• /Library/Developer/CoreSimulator/Images

  Simulator runtimes

  The iOS, watchOS, tvOS and visionOS system images that simulators run on, each several gigabytes.

  Managed by macOS · Explained only: the app shows you how

The Applications section lists every app with its size, what it has left around the Mac and when you last opened it, with Uninstall…. For each leftover it shows why the file belongs to the app, and folders that may hold your data start unchecked.

Seeing all of this is free. Cleanup and the uninstaller are PRO, one $4.99 payment with lifetime access. Every Pro tool's review is free to open, so you see what would go and why before you buy.