How much storage you need for iOS development depends less on Xcode than on what collects around it. Xcode 27 is a 3.1 GB download, and Apple publishes no disk requirement for it. Simulator runtimes, simulators, build files, device symbols and archives are what fill the disk, and each grows with the platforms, projects and devices you work with.
As a rough guide built from the typical sizes below, a 256 GB Mac works for learning and for one small app, if you keep only one or two runtimes and clear build files now and then.
For regular, paid iOS work, 512 GB is a realistic minimum. 1 TB leaves room for several platforms, older OS versions, Android work or local AI tools.
Internal storage is chosen when you buy the Mac, so it's worth planning for the developer you'll be in three years, not the one you are this week. This post shows where the space goes, how it grows over a year, and what a budget looks like for each kind of developer.
For cleaning up a Mac that's already full, see why Xcode takes up so much space; this post is about planning.
How much storage do you need for iOS development?
Start from what you'll keep installed, not from the size of Xcode. The table sums up the profiles this post works through, with the storage we'd suggest for each.
| Kind of developer | What you keep | Suggested internal storage |
|---|---|---|
| Learning, or one hobby app | One iOS runtime, a few simulators, one or two projects | 256 GB, with care |
| Professional iOS and iPadOS | Two to four runtimes, many projects, devices, releases | 512 GB minimum, 1 TB comfortable |
| Several Apple platforms | Runtimes for watchOS, visionOS or tvOS too | 1 TB |
| Agency or consultant | Many clients' projects, archives and Xcode versions | 1 TB or more, plus an external drive |
| Cross-platform, Flutter or React Native | Everything for iOS, plus Android Studio and JavaScript or Dart tools | 1 TB |
These are suggestions from the sizes in this post, not Apple's figures. Your own files, photos and other apps come on top, and so does the free space macOS needs to update itself.
What does Apple publish about storage for Xcode?
Very little. Apple's system requirements page for Xcode lists the macOS version each release needs, the SDKs it includes and the OS versions it can build for, run in a simulator and debug on a device. It doesn't list a disk requirement.
The Mac App Store lists Xcode 27 as a 3.1 GB download. That's the only size Apple publishes, and it covers the app alone.
Why is the Xcode download size misleading?
Because the largest parts are downloaded or created later. Simulator runtimes and some tools, such as the Metal Toolchain, are separate components you choose, and your work adds build files, simulators, device symbols and archives that stay until you remove them.
On a Mac we checked in October 2026, Xcode 27 itself took 3.7 GB once installed. One iOS simulator runtime next to it took 7.8 GB, before any of the files that come from using it.
Apple's requirements for Xcode 27
These come from Apple's system requirements page for Xcode, checked in October 2026. They decide which Mac and which macOS you need, and which simulator runtimes are still worth the space.
| Xcode 27 | Xcode 26.6 | |
|---|---|---|
| macOS needed | Tahoe 26.6 or later | Tahoe 26.2 to 26.x |
| SDKs | iOS, tvOS, watchOS, visionOS and macOS 27 | The 26.5 releases |
| Simulators | iOS 17 or later, watchOS 10 or later | iOS 15 or later, watchOS 8 or later |
| Devices you can debug | iOS 17 or later | iOS 15 or later |
| Swift | 6.4 | 6.3 |
Which Mac do you need?
A Mac that runs macOS Tahoe 26.6 or later, for Xcode 27. Apple adds one hardware rule: developing for visionOS requires a Mac with Apple silicon.
Apple silicon also saves space. Apple's documentation says Xcode downloads an Apple silicon variant of each simulator runtime to save disk space, and the larger universal variant on Intel-based Macs or when you use Rosetta run destinations.
Why do the simulator ranges matter for storage?
Because runtimes outside them are dead weight. Xcode 27 runs simulators for iOS 17 or later, so an iOS 15 or iOS 16 runtime is only useful if you also keep Xcode 26 or older.
The same goes for devices. Xcode 27 debugs devices on iOS 17 or later, so symbol files for older versions matter only for reading old crash reports.
Do you need more than one Xcode?
Sometimes. A beta next to the release, or an older Xcode for a project that doesn't build in the new one yet, is common. Each copy is a complete app of a few gigabytes. Runtimes, simulators and DerivedData live outside the app, so a second copy doesn't duplicate them.
Keep older copies only while a project needs them. When one goes, its runtimes and other data stay behind until you remove them.
Where the space goes in iOS development
Seven parts make up almost all of it. They differ in how fast they grow and in what removing them costs, which is what makes some of them cheap to keep in check and others not.
| Part | Typical size | Grows with | Movable to another drive |
|---|---|---|---|
| The Xcode app | 3.1 GB download | Each copy you keep | Yes |
| Simulator runtimes | 5 to 20 GB each | Each platform and OS version | No supported way |
| Simulators | 10 GB to hundreds | Each device and the apps on it | No supported way |
| DerivedData | 5 to 100 GB | Each project and checkout | Yes, in Locations |
| Device support | 5 to 60 GB | Each OS update on each device | No supported way |
| Archives | 1 to 50 GB | Each build you archive | Yes, in Locations |
| Caches, previews and packages | A few GB to tens of GB | Use, projects and dependencies | No supported way |
The typical sizes come from the research behind the app's rules catalog, apart from the download size, which is the App Store's. Apple's Developer Technical Support has said Xcode and the three items in its Locations settings can live on an external drive.
- All simulator runtimes20–200 GB · Managed by macOS
- DerivedData5–100 GB · Safe
- Device support files5–60 GB · Safe
- Archives1–50 GB · Review first
- Android Studio with emulator, free space16–32 GB
- Xcode caches and preview simulators1–20 GB · Safe
- Swift package and CocoaPods caches1–15 GB · Safe
Typical ranges on Macs that have these items, from the research behind the app's rules catalog. Android Studio's figures are Google's: 16 GB of free space with the emulator, and a recommended 32 GB or more. Simulators are left out because they range from about 10 GB to several hundred.
Simulator runtimes: the biggest planned cost
A runtime is the operating system a simulator boots: one for each platform and OS version you install. The research behind the app's catalog puts each at about 5 to 20 GB; the iOS 26.3.1 runtime on the Mac we checked was 7.8 GB.
CoreSimulator also builds a cache of system libraries for each runtime, which on that Mac took another 3.8 GB. It's managed with the runtimes, so plan for it as part of each one.
Apple's release notes for Xcode 27 say its simulator runtimes now come with a prebuilt cache of this kind, to make the first launch faster. The 3.8 GB cache on that Mac belonged to an iOS 26 runtime, and Apple doesn't say how the change affects space.
Why can a runtime look twice its size?
macOS stores each runtime as a protected disk image and mounts it as a read-only volume while it's in use. The mounted volume doesn't take more space, but a disk tool that adds it up counts the runtime twice, and the mounted copy reports more than the image takes.
On the Mac we checked, the mounted iOS runtime showed 16 GB while its image took 7.8 GB. Plan from the image's size, since that's what the runtime really takes on disk.
You install runtimes in Xcode › Settings › Components, which shows what each one would recover if you removed it. The guide to deleting simulator runtimes covers which to keep.
Simulators: the part that varies most
Each simulator holds the apps you've installed on it and everything they saved. A simulator you use daily for an app that downloads media or keeps large databases can grow large by itself.
They also outlive their runtimes. When you delete a runtime or update Xcode, simulators that used it stay on disk as unavailable until you remove them, which is why the catalog's range runs from about 10 GB to several hundred.
DerivedData: build files for every checkout
Xcode keeps build output, the code index and logs in one folder per project in ~/. It's rebuilt when missing, so it costs time rather than work, and the catalog rates Xcode DerivedData as Safe.
What surprises people is that Xcode makes a separate folder for each place a project is opened from. On the Mac we checked in mid-October 2026, one project opened from eight git worktrees had eight folders, about 10.5 GB of the 16 GB DerivedData held. Working in several checkouts of the same project multiplies it.
Device support: one set per OS update
When you connect a device for development, Xcode copies that OS version's symbol files from it, so it can debug your app and show readable crash reports. Every software update on every device adds a new set, and the old sets stay.
An iPhone, an iPad and an Apple Watch that each update several times a year add up quickly. Older sets are Safe to remove, but versions you can no longer connect can't be copied again.
Archives: the part to keep
Each Product › Archive keeps the exact build with its dSYM files. Apple's documentation says you must retain the Xcode archive for each build you distribute, or you may not be able to diagnose its crash reports.
So archives only grow. A small app's archives stay small: on the Mac we checked, 41 archives of four small apps took 1.9 GB. A large app with many extensions and frequent releases adds far more, and it all needs a backup somewhere.
Caches, previews and packages
Xcode's caches, the simulators it makes for SwiftUI previews and parallel tests, and package caches for Swift Package Manager, CocoaPods and Carthage add a few gigabytes each. They rebuild by themselves, so they matter for a small disk but rarely decide which Mac to buy.
On the Mac we checked, the Swift package cache took 2.7 GB and the CocoaPods cache about 1 GB. Projects with many dependencies keep more, and so do Macs that use both.
Storage budgets by kind of developer
Here's how those parts add up for each profile in the first table. The totals are rough, built from the typical sizes above, and they don't include macOS, your own files or other apps.
Students and hobbyists
You'll keep Xcode, the newest iOS runtime, a few simulators and one or two projects, and maybe connect one iPhone.
For comparison, the Mac we checked, which builds a few small apps and keeps a single iOS runtime, held about 40 GB of Xcode-related files in all. DerivedData made up 16 GB of it, most of that from many checkouts of one project.
Budget 20 to 50 GB for development. That fits on a 256 GB Mac next to everyday use, as long as you don't collect runtimes. The 256 GB post covers what else competes for that space.
Professional iOS and iPadOS developers
You'll keep the newest runtime, one for the oldest OS version you support, and a beta runtime for part of the year. You'll work on several projects, connect devices after every update, and archive every release.
- Runtimes: three or four at 5 to 20 GB each, plus their caches.
- DerivedData: 20 to 100 GB across projects and branches.
- Device support: grows through the year, often 10 GB or more.
- Archives: every release, kept for good.
Budget 100 to 250 GB for development. That's why 512 GB is the realistic minimum, and why 1 TB is comfortable once photos, music, other tools and free space for updates are counted.
Developers for watchOS, visionOS and tvOS
Each platform adds its own runtimes, its own simulators and, for physical devices, its own symbol files. Apple Watch symbol files take much longer to copy again, and visionOS needs a Mac with Apple silicon.
Budget another 20 to 60 GB for each extra platform you test regularly. Two or three platforms on top of iOS make 1 TB the practical choice.
Agencies, freelancers and consultants
Client work multiplies everything: a DerivedData folder for each client's project and branch, runtimes for the oldest OS versions each client supports, and often two or three Xcode versions for projects at different stages.
Archives are the part to plan for. Each client's shipped builds need their archives kept, and moving them off the Mac to a backup drive, then pointing Xcode's Archives location at an external drive, keeps the internal disk for active work. Budget 1 TB or more, plus that drive.
Cross-platform developers: Flutter and React Native
You need everything an iOS developer needs, plus Android's tools. Google lists 16 GB of free space for Android Studio with the emulator and recommends an SSD with 32 GB or more free. It adds that each extra virtual device can need up to 6 GB more.
JavaScript projects keep their own node_modules folders and package caches, and Flutter keeps its pub cache. iOS builds of both also use CocoaPods or Swift packages. Budget 150 to 300 GB for development, and choose 1 TB.
Build machines
A Mac that only builds and tests, such as a self-hosted CI runner, keeps more Xcode versions and runtimes than a person would, and a DerivedData folder for each branch it builds. It has no photos or music, but it often runs unattended until the disk is full.
Size it for the number of Xcode versions and runtimes your pipelines need, and clear DerivedData of old branches on a schedule. Its storage is easier to plan than a laptop's, because nothing personal competes with it.
How a year of iOS development adds up
Development storage doesn't grow evenly. It follows Apple's yearly cycle, your app's releases and your devices' updates, and knowing the rhythm tells you when to check.
What each new Xcode release adds
Each year's Xcode brings new SDKs and simulator runtimes for that year's OS releases. Installing the new runtimes doesn't remove the old ones, and betas earlier in the year leave their runtimes behind too.
So the weeks after a major release are when runtimes pile up most. They're also the best time to remove the previous year's, once your projects build with the new Xcode.
What each of your releases adds
Every archive you keep adds a build with its dSYMs, and every branch and checkout you build adds a DerivedData folder. A team that ships every two weeks archives 26 builds a year; one that ships a few times a year archives a handful.
Archives are the one part to plan rather than clear. Keep them, but keep them where space is cheap, and keep a second copy.
What each device update adds
Each software update on each device you connect adds a set of symbol files. A developer with an iPhone, an iPad and an Apple Watch, each updated several times a year, adds many sets a year without doing anything else.
These are safe to clear for versions your devices no longer run, as long as you don't need readable crash reports from them.
What a year adds in all
On a professional's Mac, the total can grow by tens of gigabytes a year if nothing is removed. None of it is a problem if you plan for it: a few minutes after each Xcode release and each big project change keeps it level.
Measure what you use now before you buy
If you already develop on a Mac, its numbers are a better guide than any table. Three places show them, and none of them needs a command.
Check Xcode's Components settings
Choose Xcode › Settings and click Components. Apple's documentation says it shows the installed and enabled components along with the storage you can recover by removing them, so the runtimes under Other Installed Platforms are listed with their sizes.
Note which runtimes you actually used in the last year. The rest is space you won't need to buy again.
Check your Developer folder in Finder
- In Finder, choose Go › Go to Folder, start typing
~/, then double-click the folder in the list.Library/ Developer - Choose View › as List, then View › Show View Options, and select Calculate all sizes.
- Click the Size column heading, then open Xcode and CoreSimulator and do the same.
DerivedData, Archives, the device support folders and simulators all show up here. Runtimes don't: they live in system folders, which is why Components settings is the place to read them.
Use the File Browser in Storage settings
Choose Apple menu › System Settings, click General, then Storage. Click the information button next to Documents, then File Browser: Apple says it shows the contents of folders across your file system and the storage each uses.
It's a quick way to see your projects folder, your Library folder and anything else large in one place, the same in macOS 26 and macOS 27.
Turn the numbers into a size
- Add up what development takes today, from the three places above.
- Add what you expect to start: another platform, Android, a client with older OS versions, local AI models.
- Add your own files and apps, from the categories in Storage settings.
- Add free space for updates. The post on macOS update space suggests planning on 15 to 20 GB for an update within a version and 35 GB or more for a major upgrade.
- Leave room for the years ahead, since every year of releases adds more.
If the total is close to a size Apple sells, choose the next one up. Running a development Mac near full means clearing space before every Xcode release, which costs time you'd rather spend building.
A worked example for one iPhone app
Say you build one iPhone app, support the last two iOS versions plus a beta in summer, test on an iPhone and an iPad, and ship every month. Here's an estimate built from the sizes measured on the Mac we checked and the typical ranges above.
| Item | Estimate | Based on |
|---|---|---|
| macOS and its Recovery volume | About 17 GB | Measured on macOS 27.0 |
| Xcode 27 | About 4 GB | 3.7 GB installed |
| Three iOS runtimes and their caches | About 35 GB | 7.8 GB plus a 3.8 GB cache for one |
| Simulators | 5 to 20 GB | 4.7 GB for a few, more with test data |
| DerivedData | 15 to 30 GB | 16 GB on the Mac we checked |
| Archives, device support, package caches | 10 to 20 GB | Typical ranges in this post |
| Free space for a major macOS upgrade | 35 GB or more | A planning figure, not Apple's |
That's roughly 120 to 160 GB before your own files, other apps and the rest of System Data. On 512 GB it leaves plenty; on 256 GB it leaves about 100 to 135 GB for everything else you keep on the Mac.
The estimate also shows where the swing is. Runtimes and DerivedData move the total most, and both are the parts you control, through Components settings and by clearing finished projects.
Choosing between 256 GB, 512 GB, 1 TB and more
The table puts the profiles against the sizes Apple sells. "Tight" means it works with regular cleanup; "comfortable" means you can leave things for months.
| Storage | Learning | Professional iOS | Several platforms | Cross-platform |
|---|---|---|---|---|
| 256 GB | Tight | Too small | Too small | Too small |
| 512 GB | Comfortable | Tight | Tight | Tight |
| 1 TB | Comfortable | Comfortable | Comfortable | Comfortable |
| 2 TB or more | More than needed | Comfortable, with room for AI and VMs | Comfortable | Comfortable |
Is 256 GB enough for iOS development?
For learning, yes, with care: one or two runtimes, few simulators, and DerivedData cleared for finished projects. For daily professional work, it isn't: the runtimes, devices and archives of a real app outgrow it within months, and macOS updates need free space on top.
Is 512 GB enough for iOS development?
For one platform and a handful of projects, yes. You'll need to remove old runtimes after each Xcode release, clear unavailable simulators, and move archives off the Mac now and then. Add Android, several Apple platforms or local AI models, and it gets tight.
When is 1 TB worth it?
When you build for more than iOS, work on many projects, run Android Studio or Docker alongside Xcode, or want to stop thinking about space. It's also the safer choice for a Mac you'll keep for four or five years, since every year adds more.
When do you need more than 1 TB?
When the Mac also holds large media, virtual machines or local AI models, or builds for many clients and Xcode versions at once. Apple offers larger internal storage on most of its Macs when you order; an external SSD for archives and older projects is often the cheaper way to get the same room.
How much free space should a development Mac keep?
Apple doesn't publish a single figure. Keep at least enough for the next macOS update and the next Xcode with its runtimes, since both arrive every year and both need room while they install.
Builds and simulators also write as they run, and swap files grow when memory runs short. A disk that's nearly full can stop a build or an install partway, so leave a margin beyond those two updates.
Does memory affect how much storage you need?
A little. When apps need more memory than the Mac has, macOS uses swap files on the startup disk, and Xcode with several simulators running uses a lot of memory. A Mac with more memory swaps less, so it needs a little less free space while you work.
Using an external drive for iOS development
An external SSD can take some of the load, but not the parts that grow fastest. Knowing which is which keeps you from buying a drive that doesn't solve the problem.
What can go on an external drive?
Apple's Developer Technical Support has said Xcode itself, and the three items listed in Xcode › Settings › Locations, Derived Data, Archives and Compilation Cache, can live on an external drive. Your projects can live anywhere you like.
Format the drive as APFS. The same answer warns that Mac-specific work on a FAT32 drive eventually runs into odd problems.
What has to stay on the Mac?
Simulator runtimes, simulators, device support files and Xcode's caches. Apple doesn't document a way to move them, and they're the parts that take the most space on most Macs. That's why an external drive helps a 512 GB Mac more than a 256 GB one: the fixed parts still need room.
Which parts are worth moving?
| Part | Worth moving? | Why |
|---|---|---|
| Archives | Yes | Kept for good, rarely opened |
| Old projects | Yes | Not built every day |
| DerivedData | Sometimes | Read and written on every build, so it needs a fast drive |
| Xcode | Rarely | A few gigabytes; little to gain |
| Runtimes and simulators | No supported way | Managed in Xcode |
Use a fast SSD for anything Xcode builds from. A slow drive makes every build slower, which costs more than the space is worth.
Does a desktop Mac change the plan?
It makes an external drive more practical. A Mac mini or Mac Studio stays next to its drive, so pointing Derived Data and Archives at a fast external SSD is a fixed arrangement rather than something to remember.
On a laptop, a drive set as the Derived Data location has to be connected whenever you build. So on a laptop it's simpler to keep only archives and finished projects on the drive, and to buy enough internal storage for everything you build every day.
Keeping a development Mac within its storage
A plan only works if the parts that can be cleared are cleared now and then. These habits keep a 512 GB Mac working for years.
After each major Xcode release
- Install the new runtimes you need.
- Once your projects build with the new Xcode, open Xcode › Settings › Components and delete last year's runtimes and any betas you don't test on.
- Remove simulators you no longer use, in Device Hub in Xcode 27 or Window › Devices and Simulators in Xcode 26. Device Hub lists only simulators you added or ran, so it may not show every one on disk.
- Move older copies of Xcode to the Trash when no project needs them.
When you finish or pause a project
Move its DerivedData folder to the Trash; Xcode rebuilds it if you come back. Copy its archives to your backup drive, then, if space is short, move the originals to the Trash from Finder.
A few times a year
Remove device support for OS versions your devices no longer run, unless you still read crash reports from them. Check Xcode's caches and the preview simulators, which rebuild by themselves when needed.
What not to remove
Never move the whole ~/ folder to the Trash: it mixes parts that rebuild with archives and device support you can't get back. Don't remove runtimes in Finder either; Components settings is the place.
How the app does it
Wombit shows where a development Mac's space goes on its map, with Xcode's folders explained like everything else on the disk: what each is, how safe it is to remove and what removing it costs, from the catalog's entries. It reads only names, sizes and dates, and file names and paths never leave your Mac.
Cleanup lists developer files by level. DerivedData, device support files, Xcode's caches and package caches are Safe and start checked; archives are Review first; simulators are Usually safe; runtimes are Managed by macOS and left to Xcode's own settings.
/
Library/ Developer/ CoreSimulator/ Images 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
~/
Library/ Developer/ 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 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 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
Seeing all of this is free. Cleanup, What Changed, which shows what grew since your last scan, and alerts when space runs low 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.
Frequently asked questions
Is 512 GB enough for Xcode?
For one platform and a handful of projects, yes, if you remove old simulator runtimes after each Xcode release, clear unavailable simulators and move archives off the Mac now and then. Building for several Apple platforms, or adding Android Studio, Docker or local AI models, makes 1 TB the more comfortable choice.
How big is Xcode 27?
The Mac App Store lists Xcode 27 as a 3.1 GB download, and on a Mac we checked it took 3.7 GB once installed. Simulator runtimes are separate downloads of several gigabytes each, and build files, simulators, device symbols and archives grow as you work.
How much space does an iOS simulator runtime take?
Several gigabytes each. The research behind the app's catalog puts a runtime at about 5 to 20 GB, and the iOS 26.3.1 runtime on a Mac we checked was 7.8 GB, plus a 3.8 GB cache CoreSimulator builds for it. Xcode's Components settings show what each installed runtime would recover.
Can I develop iOS apps on a 256 GB MacBook?
Yes, for learning and small projects. Keep one or two simulator runtimes, a few simulators and DerivedData only for projects you're working on. For daily professional work, the runtimes, device symbols and archives of a real app outgrow 256 GB within months.
Can I put Xcode and its files on an external SSD?
Partly. Apple's Developer Technical Support has said Xcode itself, and the Derived Data, Archives and Compilation Cache locations in Xcode's settings, can live on an external drive formatted as APFS. Apple doesn't document a way to move simulator runtimes, simulators or device support files, so plan for them on the Mac's own disk.
Does iOS development need more storage than Android development?
They're similar in kind: both keep emulator or simulator system images, devices and build caches. Google lists 16 GB of free space for Android Studio with the emulator and recommends 32 GB or more. Cross-platform developers need both, which is why 1 TB suits them.
Do I need an Apple silicon Mac for iOS development?
Xcode 27 needs macOS Tahoe 26.6 or later, and Apple says developing for visionOS requires a Mac with Apple silicon. Apple silicon also saves space: Xcode downloads smaller Apple silicon variants of simulator runtimes, and universal ones on Intel-based Macs.
Sources
- Xcode SDKs and system requirements · Apple
- Downloading and installing additional Xcode components · Apple
- Building your app to include debugging information · Apple
- Xcode on the Mac App Store · Apple
- Can I move Xcode files to an external SSD safely? · Apple Developer Forums
- Install Android Studio · Google