Why is Xcode so big? Xcode download size explained

You installed Xcode, checked your storage, and were surprised by how much space it’s taking? The Xcode download size in the App Store is one thing. The number of gigabytes Xcode takes up on your Mac is completely another. ~/Library/Developer may quietly grow to 50, 100, or even 150, being the sole reason you see the "Your disk is almost full" warning.

If you can’t work out why Xcode is so big, let’s break it down. In this article, we'll answer that, show you exactly where the space is going, and walk you through getting it back safely.

What is Xcode?

Xcode is Apple’s integrated development environment (IDE) for creating software for iOS, iPadOS, macOS, watchOS, tvOS, and visionOS. It supports source code for the most popular languages, including Apple’s own Swift, C, C++, Objective-C, Objective-C++, Java, AppleScript, Python, and Ruby. It’s free to download from the App Store and can be used for most of the development process, including creating the user interface, writing code, compiling it, and then testing and debugging. Once it’s complete, you can use Xcode to submit apps to Apple’s App Store. That’s the only part of the process that requires you to be a registered developer. If you want to use Xcode to learn new skills or improve existing ones, or just for fun, it’s free.

How much space does Xcode need?

Xcode needs way more than the App Store tells you. The size specified on the Mac App Store is the compressed download, which takes around 7- 13 GB over the last few versions. Once it's unpacked, Xcode.app itself is around 7–15 GB, and a fresh install with a simulator or two comes to roughly 35 GB.

There's a catch during installation, too. Your Mac needs room for the compressed file and the unpacked app at the same time. In practice, you require at least 45–50 GB free before you start.

After six months of development, Xcode files may consume 50–100 GB. Almost none of that growth is Xcode.app. It's everything Xcode creates around itself: build caches in DerivedData, simulator runtimes, debug symbols for every device you've plugged in, and archives of every build.

256 GB may be enough for a fresh install and light use. For daily iOS development, you may run out of space within 6–12 months. If you're buying a Mac for app development, 512 GB is the comfortable minimum.

Why is Xcode so large?

Because it isn't one app, Xcode bundles the SDKs, compilers, debuggers, and simulators for six Apple platforms—iOS, iPadOS, macOS, watchOS, tvOS, and visionOS—and supports several versions of each.

Every time you build a project, launch a simulator, plug in an iPhone, or archive an app for the App Store, Xcode writes more files to your disk. So the 12 GB download becomes a 35 GB install, and the 35 GB install becomes a 100 GB developer folder without you ever choosing to put anything there.

Where is all that space actually going?

Let’s see where all these Xcode files are stored on your Mac. Open Terminal and paste these commands one at a time. Each one shows the size of a folder Xcode uses:

du -sh ~/Library/Developer/Xcode/DerivedData

du -sh ~/Library/Developer/CoreSimulator

du -sh ~/Library/Developer/Xcode/iOS\ DeviceSupport

du -sh ~/Library/Developer/Xcode/Archives

du -sh ~/Library/Caches/com.apple.dt.Xcode

If one of them says "No such file or directory," that's means you don't have that kind of clutter yet.

For most developers who've been at it a year or more, the total sum is somewhere between 50 and 150 GB. Here's what each folder is, how big it usually gets, and whether you can get rid of it:

We'll go through them one at a time. Each section follows the same pattern: what it is, how to check it, whether it's safe to delete, and how to delete it.

DerivedData

DerivedData is where Xcode keeps everything it generates while building your projects: compiled objects, indexes, module caches, build logs. Every project you've ever opened in Xcode has a folder in here, including the ones you deleted years ago.

It's usually 20–50 GB, and 100 GB+ isn't rare. It got noticeably worse with Xcode 16.3, which added a CompilationCache.noindex folder inside DerivedData. Developers on the Apple Developer Forums reported DerivedData more than doubling after that update — from around 20 GB to 47 GB in one case — with the new cache adding 10–30 GB on its own. That hasn't gone away in Xcode 26 or 27.

Check how large yours is:

du -sh ~/Library/Developer/Xcode/DerivedData

DerivedData is safe to delete. Xcode rebuilds everything the next time you build a project. However, the first build may be a bit slower: it takes a minute or two for a small project, up to five for a big one.

To delete it DerivedData:

rm -rf ~/Library/Developer/Xcode/DerivedData

If you don’t want to erase everything, open the folder in Finder (Go > Go to Folder, paste the path) and delete only the projects you no longer work on. Each folder is named after its project, followed by a string of random characters.

One thing that doesn't work: Product > Clean Build Folder (Shift-Command-K) in Xcode. It only clears the current project's build products and leaves the rest of DerivedData alone.

Simulator runtimes

A simulator runtime is a full copy of an operating system — iOS 26, watchOS 27, and so on — that Xcode runs on your Mac so you can test without a device. Each Xcode version downloads its own set, and when you upgrade, the old ones stay behind.

Each runtime is 5–8 GB. If you go through two or three major Xcode versions while developing for more than one platform, you can easily end up with 15–20 runtimes and 30–125 GB of simulators. On most developer Macs, this is the single biggest category.

Check for simulator runtimes:

xcrun simctl runtime list

That lists every installed runtime with its version, size, and state.

The easiest way to delete old simulator runtimes is in Xcode itself. Go to Xcode > Settings > Components (it was called Platforms in older versions). You'll see every runtime with its size next to it. Right-click one you don't need and choose Delete.

You can also delete them through Terminal, using a version from the list:

xcrun simctl runtime delete "iOS 17.2"

Anything two or more major versions behind the current release is safe to remove. You're unlikely to need iOS 17 simulators in late 2026, and if you ever do, Xcode will offer to download the runtime again. Keep the versions you actually test against.

Then there's a kind of clutter Xcode users often overlook: orphaned simulators. If a simulator crashes or an Xcode update goes sideways, its data folder can stay on disk under a random UUID while disappearing from Xcode's own list. It's pure dead weight, and this command finds and removes it:

xcrun simctl delete unavailable

One thing about Xcode 27 worth knowing: Apple's release notes list a known issue where some simulator runtimes aren't completely deleted when removed, and they reappear after a reboot. If a runtime you deleted shows up again after a restart, that's the bug, not you. Delete it again.

Device support files

When you plug in an iPhone, iPad, or Apple Watch running an OS version Xcode hasn't seen before (even a 0.1 update or a beta), Xcode downloads a set of debug symbols for that version. Every version gets its own folder, and Xcode never removes any of them.

Each one is 1–3 GB. If you've been running betas on your devices, they pile up fast, and 10–20 GB is what you may typically get.

Check for device support files:

du -sh ~/Library/Developer/Xcode/iOS\ DeviceSupport/

ls ~/Library/Developer/Xcode/iOS\ DeviceSupport/

The second command lists the versions you've collected. If you develop for Apple Watch or Apple TV, look for watchOS DeviceSupport and tvOS DeviceSupport in the same Xcode folder, too.

You can safely delete any of them. The next time you connect a device, Xcode downloads what it needs for that device's OS version. Or you can only keep the folders matching the OS on devices you actively debug. Note that Xcode 27 supports on-device debugging in iOS 17 and later, so anything older in this folder can't be used anyway.

Delete everything in one go:

rm -rf ~/Library/Developer/Xcode/iOS\ DeviceSupport/*

Alternatively, you can do this in Finder: Go > Go to Folder, paste ~/Library/Developer/Xcode/iOS DeviceSupport, drag the version folders to the Trash, and empty it.

Archives

Every time you choose Product > Archive to release a build to the App Store or TestFlight, Xcode saves an .xcarchive: the compiled app, its debug symbols (dSYMs), and some metadata. It never deletes them. With monthly releases, archives alone can accumulate 12–60 GB per app each year.

With Xcode 26, archives have grown. Developers on the Apple Developer Forums have reported dSYM files roughly doubling in size, so newer archives take up noticeably more than older ones.

To check for archives:

du -sh ~/Library/Developer/Xcode/Archives

Archives are mostly safe to delete. Keep the archives for builds that are live or still in review, since you may need them to read a crash report. Anything older can be removed, with one caveat: if you use a crash reporting service like Crashlytics or Sentry, make sure the dSYMs have been uploaded before you delete the archive. Once the archive is gone, so are they, and crash reports for that build become unreadable.

The easiest way to manage archives is in Xcode: Window > Organizer > Archives. Select the ones you don't need and press Delete. Or open ~/Library/Developer/Xcode/Archives in Finder. Archives are sorted into folders by date, which makes it easy to clear out anything older than a few months.

Xcode caches

The last folder on the list, ~/Library/Caches/com.apple.dt.Xcode, stores Xcode's general-purpose cache. It's usually 1–5 GB and completely safe to delete (Xcode rebuilds it as needed). Quit Xcode first, then run this command:

rm -rf ~/Library/Caches/com.apple.dt.Xcode

What's changed in Xcode 26 and Xcode 27

The Xcode app itself has been getting smaller. With Xcode 26, Apple unbundled the Metal toolchain and slimmed down the Apple Silicon build. Bitrise measured Xcode 26 beta 5 at around 22% smaller to download and 25% smaller on disk than Xcode 16.4. Xcode 27, released in September 2026, goes a step further: it will only install and run on Apple Silicon Macs, so there's no Intel code in the download at all.

However, everything around Xcode keeps growing in size. The CompilationCache.noindex folder from Xcode 16.3 is still there. dSYMs roughly doubled in Xcode 26. Xcode 27's simulator runtimes now include a pre-built dyld cache, which speeds up the first launch of a simulator but won't make runtimes any smaller.

Xcode 27 has two small wins worth knowing about. CoreSimulator logs are now rotated continually rather than only when the service restarts, so they can't grow without limit on a Mac that's been running for weeks. And if you run a build server, Interface Builder can now compile UIKit documents without downloading a simulator, which is one less 5–8 GB download on your CI machine.

So, although the app is a smaller share of the problem than ever, the folders around it are a bigger one. That's why the cleanup matters more with every version.

A faster way: CleanMyMac CLI

If you'd rather not run all those commands by hand every few months, CleanMyMac CLI does most of the job for you, from the same Terminal window.

CleanMyMac CLI is a Terminal version of CleanMyMac, built by MacPaw's own developers for their own Macs. Install it with Homebrew:

brew install --cask macpaw/taps/cleanmymac-cli

First, analyze your developer folder to see where the space is going:

cleanmymac analyze ~/Library/Developer

You get an interactive view of every folder sorted by size, the same picture as the five du -sh commands above, in one go. Press O on any folder to reveal it in Finder.

Then clean the items that are safe to delete:

cleanmymac clean junk

CleanMyMac CLI scans for DerivedData, device support files, the module cache, the documentation cache, and other Xcode leftovers and lists what it found with sizes. All that’s left for you to do is confirm the removal. You can also add --force to skip the confirmation, which is handy if you want to run it from a script. While you're there, it clears Homebrew's own cache too, which is worth a cleanup of its own.

If you'd rather not touch Terminal, the desktop version of CleanMyMac handles Xcode clutter too.

Xcode is big because of what it does. It's a development environment for six platforms, and the 12 GB download file is only the start. The app itself isn't what fills your disk. DerivedData, simulator runtimes, device support files, and archives quietly grow in ~/Library/Developer. Check them with the commands above, delete what you don't need, and you'll free up tens of gigabytes. And if you'd rather do it in one step, CleanMyMac CLI or CleanMyMac will do the heavy lifting for you.