To delete old simulator runtimes, open Xcode, choose Xcode › Settings and click Components. Under Other Installed Platforms, click the information button next to a runtime you no longer test on, then click Delete. That works the same way in Xcode 26 and Xcode 27, and it's the way Apple documents.
Runtimes and simulators are two different things, and removing one doesn't remove the other. A runtime is the operating system a simulator boots, several gigabytes each. A simulator, which Xcode also calls a simulated device, is one virtual iPhone, iPad, Apple Watch, Apple TV or Vision Pro, with the apps and data you put on it.
So after you delete a runtime, remove the simulators that used it too. In Xcode 27, open Xcode › Open Developer Tool › Device Hub, Control-click a simulator and choose Remove. In Xcode 26, choose Window › Devices and Simulators instead.
Don't look for runtimes in Finder. They live in folders macOS protects, and some runtimes end up there without Xcode listing them at all. This post covers those too, along with what each removal costs and how to keep the pile from growing back.
Runtimes and devices: two different things
Most advice treats "simulators" as one thing. On disk they're two, kept in different places, removed in different windows, and costing you different things when they go.
What is a simulator runtime?
A runtime is a complete system image for one platform and version: iOS 26.3, watchOS 26, visionOS 26 and so on. Xcode downloads it when you install it in Components settings, when you click Get next to a run destination, or when you first set up Xcode.
macOS stores each runtime as a protected disk image and mounts it as a read-only volume while it's in use. One runtime serves every simulator of that version, so ten iOS 26 simulators share a single iOS 26 runtime. The iOS runtime runs iPad simulators too; there's no separate one for iPadOS.
What is a simulator device?
A simulator is the device you pick as a run destination: an iPhone 17 Pro on iOS 26, say. Each one is a folder of its own with its settings, the apps you've installed on it, and everything those apps saved: databases, downloaded images, caches, documents.
Simulators start small and grow as you test. A simulator you've run a media-heavy app on for a year can hold more than the runtime it boots.
How do they depend on each other?
A simulator needs its runtime to start. When the runtime is gone, the simulator stays on disk, is listed as unavailable, and can't start until you install that runtime again. Its apps and data are still there, taking space.
The reverse doesn't hold. Removing every simulator of a version leaves its runtime installed, ready for the next simulator you create.
| Simulator runtime | Simulator device | |
|---|---|---|
| What it is | The OS image simulators boot | One virtual device with its apps and data |
| Typical size | About 5 to 20 GB each | Grows with the apps and data on it |
| Who uses it | Every simulator of that version | Only itself |
| Where to remove it | Xcode's Components settings | Device Hub, or Devices and Simulators in Xcode 26 |
| What you lose | A download | The apps and test data on it |
Which one takes more space?
It depends on how you work. Runtimes are large and arrive in sets: a new iOS, watchOS, tvOS and visionOS every year, plus point releases and betas. Simulators start small but grow with test data, and on some Macs they overtake the runtimes.
- One simulator runtime5–20 GB · Managed by macOS
- All installed runtimes20–200 GB · Managed by macOS
- Xcode caches, preview and test simulators1–20 GB · Safe
Typical ranges on Macs that have these files, from the research behind the app's catalog. Your own simulators vary the most and are left out: from about 10 GB to, in rare cases, several hundred.
Where simulator runtimes and devices live on a Mac
Runtimes are installed for the whole Mac, in system folders. Simulators belong to each user account, in that person's own Library folder. That's why deleting a runtime affects everyone on the Mac, while deleting a simulator affects only you.
Where are simulator runtimes stored?
Depending on how a runtime was installed, its disk image sits in one of two places. Runtimes Xcode downloads through macOS's asset system go to /, in one folder per platform such as com_apple_MobileAsset_iOSSimulatorRuntime. Others, such as runtimes installed by older versions of Xcode, keep their images in /.
While a runtime is in use, macOS mounts it under /, with a folder named after its platform and build, such as iOS_23D8133. That folder is a view of the disk image, not a second copy.
CoreSimulator also keeps a cache of prebuilt system libraries for each runtime in /. Apple's notes for Xcode 27 say its runtimes now include a prebuilt cache, so a first launch is much faster.
Where are simulators stored?
Your simulators are in ~/, one folder for each, named with a long identifier. That identifier is the simulator's UUID, which Device Hub shows in its Info inspector in Xcode 27. Inside each folder, a small settings file describes the device, and a data folder holds everything installed on it.
What's inside a simulator's folder?
Its data folder looks like a small iPhone's storage. A Containers folder holds the apps you installed and, next to them, each app's data and its shared app group data. A Media folder holds the photos and videos you added to the simulator's Photos library.
That's where the size comes from. An app that downloads images, caches video or keeps a large database does all of it inside the simulator, and none of it is cleared when you rebuild.
Which simulators does Xcode keep for itself?
Xcode keeps three more sets of simulators for its own use, each in its own folder: one for SwiftUI previews, one for parallel test runs and one for playgrounds. They don't appear in your list of run destinations.
Where everything lives, at a glance
| What | Where it lives | Whose it is |
|---|---|---|
| Runtime disk images | /System/Library/AssetsV2 or /Library/Developer/CoreSimulator/Images | The whole Mac |
| Mounted runtimes | /Library/Developer/CoreSimulator/Volumes | The whole Mac |
| Runtime library cache | /Library/Developer/CoreSimulator/Caches/dyld | The whole Mac |
| Your simulators | ~/Library/Developer/CoreSimulator/Devices | Your account |
| SwiftUI preview simulators | ~/Library/Developer/Xcode/UserData/Previews | Your account |
| Parallel testing clones | ~/Library/Developer/XCTestDevices | Your account |
| Playground simulators | ~/Library/Developer/XCPGDevices | Your account |
Why do some sizes look counted twice?
Because some of these folders are windows onto others. A mounted runtime in the Volumes folder shows the contents of a disk image stored elsewhere, and the mount takes no extra space. A disk tool that adds both is counting one runtime twice.
Xcode 27 adds another view. Apple's documentation says the files of started simulators and paired devices can be browsed at ~/, which Finder shows as Devices. That's a mount point too, not a copy.
Why doesn't Storage settings show them?
System Settings › General › Storage has no category for simulator runtimes in Apple's description of it. Files that fit no category land in System Data, which Apple says you can't manage there. The System Data guide explains what else ends up in it.
The one place that lists each runtime with its size is Xcode's Components settings. For your simulators, Finder's Get Info on the Devices folder gives the total.
Before you delete: which runtimes and simulators to keep
Deleting is quick; downloading a runtime again isn't. A few minutes deciding what you still test on saves a long wait later.
Which simulator runtimes can you safely delete?
Any runtime you don't run apps on. Nothing breaks when a runtime goes: your projects still build, and the simulators that used it simply wait. A practical set to keep is the newest runtime for each platform you ship on, plus any older version you test regularly.
Good candidates to delete:
- runtimes for platforms you don't build for, such as tvOS or visionOS installed out of curiosity
- earlier point releases when you have a newer one of the same version, such as iOS 26.2 next to iOS 26.5
- beta runtimes, after the final release ships
- runtimes your current Xcode can't use at all
Which simulators are worth keeping?
Keep the ones that hold something you'd have to rebuild by hand: a signed-in test account, a saved demo state, a long onboarding you've already clicked through. Keep one simulator for each screen size you design for, too.
Everything else is cheap to recreate. A new simulator of the same model and version takes seconds to create and starts empty, which is often what you want for testing anyway.
Will scripts and test plans notice?
They can. A build script, test plan or continuous integration job that names a simulator, or asks for a particular OS version, fails when that simulator or runtime is gone. Check what your automation asks for before you delete the versions it uses.
Do you need an old runtime to support an old iOS version?
No. The deployment target is a build setting, and it doesn't need a runtime. Apple's requirements table lists deployment targets from iOS 15 to iOS 27 in Xcode 27, while its simulators start at iOS 17. You can ship an app that supports iOS 15 without an iOS 15 runtime on your Mac.
What a runtime gives you is the chance to see your app running on that version. If you test old versions on a physical device instead, you don't need their runtimes either.
Which runtimes does each Xcode version support?
Apple's system requirements list a range of simulator versions for each Xcode. A runtime outside the range of every Xcode you run is space with no use.
| Platform | Xcode 26 simulators | Xcode 27 simulators |
|---|---|---|
| iOS and iPadOS | iOS 15 or later | iOS 17 or later |
| watchOS | watchOS 8 or later | watchOS 10 or later |
| tvOS | tvOS 15 or later | tvOS 17 or later |
| visionOS | visionOS 1 or later | visionOS 1 or later |
In Xcode 27's Device Hub, there's one more limit. Apple's release notes say keyboard and mouse input isn't accepted by simulators running versions before iOS 18, tvOS 18, watchOS 11 and visionOS 2. An iOS 17 runtime still boots, but you can do little with it by hand.
What changes on an Intel-based Mac?
Xcode 27 installs and runs only on Mac computers with Apple silicon, so an Intel-based Mac stays on Xcode 26. There, Xcode downloads the universal variant of each runtime, which is larger because it runs on both kinds of Mac.
On Apple silicon, Xcode downloads the smaller Apple silicon variant unless you use Rosetta run destinations. Apple's notes for Xcode 26.1 describe a fixed bug where Add Platforms showed the same runtime twice with different sizes; the larger one included Intel support.
Should you remove runtimes before updating to macOS 27?
It's worth doing. Apple lists Xcode 27 as needing macOS Tahoe 26.6 or later, and no Xcode 26 release as supported on anything later than macOS Tahoe. After you move to Golden Gate, Xcode 27 is the version supported there, and it may not show runtimes it can't use.
If you keep runtimes for Xcode 26, delete the ones you're finished with in Xcode 26 while you still run it. It's the copy of Xcode that knows about them. The same holds before you uninstall Xcode completely.
A worked example
Say you build an iPhone app with Xcode 27 on an Apple silicon Mac, with a minimum deployment target of iOS 17. Components lists iOS 26.2, iOS 26.5 and iOS 27 runtimes, plus watchOS 26 and visionOS 26 from a weekend experiment.
Keep iOS 27, your main target, and iOS 26.5, the version most of your users still run. Delete iOS 26.2, an earlier point release of the same version. Delete watchOS 26 and visionOS 26 unless you plan to ship on them. If you see a bug report from iOS 17, install that runtime when you need it.
How to delete old simulator runtimes in Xcode
Components settings is the same in Xcode 26 and Xcode 27, and it's the route Apple documents. In older versions of Xcode, the same list was called Platforms.
Delete a runtime, step by step
- Quit any app you're running in a simulator that uses the runtime, and shut that simulator down.
- In Xcode, choose Xcode › Settings, then click Components in the sidebar.
- Find the runtime under Other Installed Platforms. Xcode shows the space you'd recover next to each component.
- Click the information button next to the runtime.
- In the dialog that appears, click Delete.
Repeat for each runtime. Xcode doesn't move a runtime to the Trash; it's removed from the Mac, so there's nothing to put back.
What about platform support in the same list?
Platform Support at the top of Components is what Xcode needs to build for a platform. It's a separate item from the runtimes below it. Deleting a runtime leaves platform support in place, so your projects keep building.
Other Components holds optional features, such as the Metal Toolchain, which you remove with Delete or Turn Off, depending on the component. Only remove what your projects don't use; Xcode offers the Metal Toolchain again when a project needs it.
Why doesn't the free space appear straight away?
A runtime in use has to be unmounted first, so any simulators running it are shut down before it goes. Let running tests finish before you delete one.
If you use Time Machine, its local snapshots can keep a deleted runtime's blocks for a while, because the asset folders live on your Mac's Data volume. The space comes back as the snapshots age out. The guide to Time Machine's local snapshots explains how to check.
How do you get a runtime back?
In Components settings, click Add Platforms under Other Installed Platforms. Choose a platform, type a version in the filter field if the list is long, select the versions you want and click Download & Install.
There's a shortcut when you open a project for a platform with no runtime installed: Xcode shows a Get button next to the run destination, which downloads the newest runtime for that platform. Simulators that were waiting for a runtime can start again once that same version is installed, with their apps and data intact.
How to delete simulators in Device Hub and Xcode 26
Removing simulators is separate from removing runtimes, and the window changed in Xcode 27. In Xcode 27, simulators run in Device Hub, and that's where you manage them.
Remove a simulator in Xcode 27
- Open Device Hub: choose Manage Devices… from the run destination menu, or choose Xcode › Open Developer Tool › Device Hub.
- To see only simulators, choose Simulators from the filter pop-up menu at the top of the sidebar.
- If the simulator is running, Control-click it and choose Shut Down.
- Control-click the simulator and choose Remove.
Apple notes that Device Hub's sidebar lists only simulators you added there or chose as run destinations in Xcode. Older simulators can exist on disk without appearing in it, so the sidebar isn't a full inventory.
Delete a simulator in Xcode 26
Choose Window › Devices and Simulators, then click Simulators. Control-click a simulator in the list and choose Delete, then confirm. To clear a simulator's contents instead, start it and choose Device › Erase All Content and Settings in the Simulator app.
| Task | Xcode 26 | Xcode 27 |
|---|---|---|
| Delete a runtime | Xcode › Settings › Components | Xcode › Settings › Components |
| Delete a simulator | Window › Devices and Simulators, Control-click, Delete | Device Hub, Control-click, Remove |
| Erase a simulator | In Simulator, Device › Erase All Content and Settings | In Device Hub, shut it down, then Device › Reset Content and Settings |
Should you erase a simulator instead?
Erasing keeps the simulator, with its device type and OS version, and removes every app and its data. It suits the simulator you use every day, once it has filled up with test data. In Xcode 27, shut it down, select it in Device Hub and choose Device › Reset Content and Settings.
Deleting suits simulators you won't use again: old device models, duplicates, and anything left unavailable by a runtime you removed. A fresh simulator of the same kind is quick to create, and it starts empty either way.
Can you remove just one app's data?
Yes, and it's the gentlest option. In Xcode 27, select the simulator in Device Hub, click Apps in the inspector's toolbar, select the apps and click the Remove button below the list. For a simulator that isn't running, click Start in the canvas first so its apps can be listed.
Removing an app takes its data container with it. The simulator, its other apps and its settings stay as they are.
What about unavailable simulators?
A simulator becomes unavailable when its runtime is gone, often after an Xcode update or a runtime cleanup. It keeps its apps and data but can't start, so it holds space for nothing unless you plan to install that runtime again.
Remove them one by one in the window for your Xcode version. Xcode's command-line tool can also delete every unavailable simulator at once. The page on Simulator devices describes both.
What about preview and test simulators?
SwiftUI previews, parallel test runs and playgrounds each use simulators of their own, in the folders listed earlier. They're Safe: Xcode creates them again when it needs them, at the cost of a slower first preview or test run. Apple doesn't document a way to remove them from Xcode's windows.
Inside every simulator, discarded app data can also collect in a folder named Dead. The Xcode post covers those folders, along with DerivedData and device support files.
Runtimes Xcode no longer lists
Sometimes the Components list and the disk disagree: a disk map or Finder shows tens of gigabytes of runtimes, and Xcode lists one. There are three common reasons, and only the first has an easy fix.
How can you tell what Xcode isn't listing?
Add up the sizes Components shows under Other Installed Platforms. Then, in Finder, choose Go › Go to Folder, enter /, select the folders whose names end in SimulatorRuntime, and choose File › Get Info.
If the folders hold much more than Components lists, the difference is runtimes Xcode isn't showing you. Look, but don't move anything there: those folders belong to macOS.
Runtimes from an older Xcode
Runtimes your current Xcode can't use may be left out of its list, and Apple doesn't document how Components treats them. The copy of Xcode that installed them is the one that shows them reliably.
If you still have that version, open it and delete them there before you move on. Xcode's command-line tool also lists the runtime disk images the simulator service knows about, whichever Xcode installed them, and can delete them. There's no other app interface for this.
Runtimes stuck in the protected asset folder
Since early 2026, developers on Apple's forums have reported runtimes left in / that neither Xcode nor its command-line tool lists. They can't be moved to the Trash or deleted as an administrator, because System Integrity Protection guards that folder. Some report tens of gigabytes held this way.
An Apple engineer answered there that deleting through Components works "when everything is working correctly", and that these reports show it isn't. Apple asked developers to file bug reports. When asked about reinstalling macOS, the engineer said it might be the only supported way to recover.
Runtimes that come back after a restart
Apple lists this as a known issue in Xcode 27's release notes: some runtimes aren't completely deleted when removed, and reappear after a restart. Developers report the same with Xcode's command-line tool, sometimes with the runtime returning under a new identifier.
If a deleted runtime returns, keep Xcode up to date and check again after each update. Some developers reported that a newer Xcode or runtime cleared their leftovers, though Apple hasn't documented a fix.
What not to try
- Turning off System Integrity Protection to delete the files. Forum posts describe it, and Apple's engineer called changing these folders behind the running system's back unsupported. It also lowers a protection your Mac relies on.
- Ejecting the runtime in Disk Utility or Finder. That only unmounts it. The disk image stays on the disk, and it can be mounted again when a simulator needs it.
- Reinstalling Xcode. Runtimes live outside the app, and developers report that a fresh copy of Xcode doesn't remove leftovers.
- Cleanup apps or scripts that force the files out. Anything that can delete them has to work around the same protection.
The supported step is a report to Apple. Use Feedback Assistant, and include the runtime's version, your Xcode version and your macOS version.
What each removal costs
Every option here frees space in a different way and costs something different. None of them touches your projects, source code, archives or physical devices.
| What you remove | What you lose | How you get it back |
|---|---|---|
| A simulator runtime | Nothing of yours; simulators of that version can't start | Download it again in Components |
| A simulator | Its apps, their data and its settings | Create a new, empty one |
| A simulator's contents | Every app and its data; the device stays | Reinstall apps from Xcode |
| One app on a simulator | That app's data | Run the app from Xcode again |
| Preview, test and playground simulators | Nothing; Xcode makes them again | By itself, on the next run |
| An unavailable simulator | Data you couldn't reach anyway | Not needed |
How long does a runtime take to come back?
A runtime is a download of several gigabytes, so it depends on your connection. After installing, the first simulator launch may take longer while the runtime's library cache is prepared, which Apple says is much faster with Xcode 27's runtimes.
On a slow or metered connection, keep the runtime you'll need next week, even if you haven't used it this week.
Is there an undo?
No. Runtimes and simulators deleted in Xcode or Device Hub don't go to the Trash; they're removed at once. Apple doesn't document a way to restore one, so treat the deletion as final.
Before you remove a simulator with test data you care about, such as a carefully built demo state, save the app's data first. In Xcode 27, Device Hub can download an app's data container to your Mac.
Does removing simulator files make a Mac faster?
No. It frees disk space and nothing else. The space matters when the disk is nearly full, for example to fit a macOS update, but your Mac doesn't run faster with fewer runtimes installed. If anything, the first simulator launch after a reinstall is slower.
Can you keep runtimes on an external drive?
Apple doesn't document a way to. Locations in Xcode's settings lets you choose where DerivedData and archives go, but Components settings has no location for runtimes. Their folders are managed and protected by macOS, so treat runtimes as something you delete and download again, not move.
Mistakes to avoid
- Moving the whole CoreSimulator folder to the Trash. It takes every simulator's data and leaves the runtimes, which live elsewhere, untouched.
- Deleting a runtime to "reset" simulators. It frees the runtime's space but keeps every simulator's data; erase the simulator instead.
- Clearing runtimes in the middle of a release. Keep the versions you're testing a fix on until it ships.
- Deleting a runtime on a shared Mac without asking. It's installed for every account, so someone else's simulators stop starting too.
Keeping runtimes and simulators from piling up
Nothing here is removed automatically. Runtimes stay through Xcode updates, simulators outlive their runtimes, and every beta season adds a new set.
A routine for each Xcode release
- Open Components settings and note the size of each runtime under Other Installed Platforms.
- Delete last cycle's betas and earlier point releases you no longer test on.
- In Device Hub or Devices and Simulators, remove simulators left unavailable.
- Reset the simulators you keep if they're full of old test data.
- After a few days, check Components again for runtimes that came back.
Habits that keep it small
- Install runtimes for a platform only when you build for it. Xcode's Get button fetches one the moment a project needs it.
- Create simulators for a one-off test, then remove them when you're done.
- Prefer one simulator per device size you care about over one for every model.
- On a Mac shared by several developers, agree on runtimes before deleting, because they're installed for everyone.
What about build servers?
Macs that build in continuous integration collect runtimes fastest, because each Xcode image or update can bring a new set. Apple documents downloading runtimes once and installing them on several Macs with Xcode's command-line tools, which also makes it easier to install only the ones a pipeline needs.
The rest of Xcode's data, from DerivedData to archives, is covered in the guide to cleaning up after Xcode.
How the app does it
Wombit explains simulator files like everything else on the disk. Select a folder in the map, the app's home screen, 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.
Runtimes are Managed by macOS: the app explains them with Xcode's own steps and never moves them, because macOS protects them and Components settings removes them. The runtime library cache is managed together with them.
Your simulators are Usually safe. They're explained with the steps for your Xcode version, and the app leaves removing them to Xcode, because only you know which test data matters.
CoreSimulator's caches and logs, the Dead folders inside simulators, and the preview, test and playground simulators are Safe. They count toward the safe total and start checked.
Folders go to the Trash, where you can put them back. For the three sets of simulators Xcode makes for itself, the app runs Xcode's own tool after the review sheet instead, and the sheet says that can't be undone.
What the app runs, after you review itPRO
- xcrun simctl --set previews delete all
- The simulators Xcode made for SwiftUI previews
- xcrun simctl --set testing delete all
- The simulator clones left behind by parallel test runs
- xcrun simctl --set playgrounds delete all
- The simulators Xcode made to run playgrounds
/
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/ CoreSimulator/ 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/ Devices/ */ data/ Library/ Caches/ com.apple.containermanagerd/ Dead Data from apps you reinstalled or removed in a simulator, which the simulator set aside to delete but kept.
Safe · Moves it to the Trash
~/
Library/ Developer/ CoreSimulator/ Caches Cached data that the simulator service keeps for your user account.
Safe · Moves it to the Trash
Seeing all of this is free. Cleanup is 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
Can I delete simulator runtimes in Finder?
No. Runtimes are disk images in folders macOS manages and protects, so Finder isn't the way to remove them. Remove them in Xcode: choose Xcode › Settings, click Components, then use the information button next to a runtime and click Delete.
Does deleting a simulator runtime delete my simulators?
No. Simulators that used the runtime stay on disk with their apps and data, listed as unavailable. Remove them separately in Device Hub in Xcode 27, or in Devices and Simulators in Xcode 26, if you don't plan to install that runtime again.
How much space does an iOS simulator runtime take?
Usually about 5 to 20 GB each, and Xcode's Components settings shows the exact amount next to every runtime. On Apple silicon, Xcode downloads a smaller variant by default; the universal variant, which also runs on Intel, is larger.
Why did a runtime I deleted reappear?
Apple lists it as a known issue in Xcode 27: some runtimes aren't completely deleted and come back after a restart. Keep Xcode up to date and check Components again after updates. Don't turn off System Integrity Protection to remove the files.
Is it safe to delete all my simulators?
It's safe for your projects, which live in your own folders. You lose every app installed on the simulators and the test data they saved. Xcode creates new, empty simulators when you need them, so keep only the ones whose data matters to you.
Do I need the iOS 15 runtime to support iOS 15 in my app?
No. The deployment target is a build setting, and Xcode 27 builds for iOS 15 and later without that runtime. A runtime only lets you run the app on that version in a simulator. Test old versions on a device if you have one.
Does updating Xcode remove old simulator runtimes?
No. Runtimes stay installed through every Xcode update, and so do the simulators that use them. After a major update, open Components settings and delete the runtimes you no longer test on, betas included.
Sources
- Downloading and installing additional Xcode components · Apple
- Managing your simulated and physical devices in Device Hub · Apple
- Xcode 27 Release Notes · Apple
- Xcode SDKs and system requirements · Apple
- How to delete iOS simulator runtimes? · Apple Developer Forums
- Orphaned 9GB Simulator Runtime in /System/Library/AssetsV2 · Apple Developer Forums