---
title: Detecting available Apple Foundation Models
framework: Foundation Models
role: article
role_heading: Article
path: foundationmodels/detecting-available-apple-foundation-models
---

# Detecting available Apple Foundation Models

Discover which Apple Foundation Models your app can use across devices and platforms.

## Overview

Overview Apple Foundation Models (AFM) power Apple Intelligence. You can call AFM models via the Foundation Models framework, and they come built-in to many Apple devices, making AFM a convenient and powerful option for your app. Smaller AFM models run entirely on-device, while the most powerful AFM models run on Private Cloud Compute (PCC). All AFM models are capable of text and image understanding.  |  |  |   |  |  |   |  |  |   |  |  |  To detect which AFM models can run on a person’s device, consider the following: Availability: Both SystemLanguageModel and PrivateCloudComputeLanguageModel have availability checks that tell you if the operating system is ready to run the model. For PrivateCloudComputeLanguageModel, check additional aspects of availability, including authentication, and the PCC usage quota of the person running your app. Model variant: SystemLanguageModel represents two different AFM on-device variants: AFM Core and AFM Core Advanced. PrivateCloudComputeLanguageModel doesn’t have any variants; it only represents AFM Cloud. Use the variant property at runtime to detect which SystemLanguageModel variant is present on a person’s device. Your app won’t be able to pick: each device has a single on-device AFM. If your app needs to maintain compatibility with older operating system versions, monitor how AFM models change over time: Model version: Apple occasionally updates AFM on-device models, like AFM Core, as part of a regular operating system update. Like variants, your app won’t be able to pick which model version to use. Check the version present on a person’s device using standard Swift if #available checks with the variant property of SystemLanguageModel. Context window size: This number represents how many tokens your app can send a model in a single session. Context window size can vary, even within the same model variant and version. To get the exact number of tokens available, check the contextSize property of SystemLanguageModel and the contextSize property of PrivateCloudComputeLanguageModel. Create a model instance and check availability Before running SystemLanguageModel or PrivateCloudComputeLanguageModel, verify that the models can run on the device. For SystemLanguageModel, start by creating an instance of the default model: let model = SystemLanguageModel.default While you can later customize SystemLanguageModel to other use cases, such as contentTagging, those aren’t available unless the default general use case is available, so check .default first. Creating an instance of PrivateCloudComputeLanguageModel starts an authentication and readiness check with the operating system and the server. Authentication fails (and logs a warning) if your app doesn’t have the com.apple.developer.private-cloud-compute entitlement. For the best performance, create a single PrivateCloudComputeLanguageModel instance and share it across your app so you only call these checks once: // Logs a warning if the entitlement is missing. let pccModel = PrivateCloudComputeLanguageModel() Next, check for availability. The SystemLanguageModel and PrivateCloudComputeLanguageModel classes each provide two properties for availability, following the same shape. Use .isAvailable for a quick Boolean check: let model = SystemLanguageModel.default if model.isAvailable {     // The model is ready to use. } Or, use .availability to discover why the model is unavailable. Each model has its own .unavailable cases designed to give you the information you need to communicate with the person running your app. For example, SystemLanguageModel has these cases: let logger = Logger(subsystem: "com.example.MyApp", category: "ModelAvailability")

switch model.availability { case .available:     logger.info("The model is available and ready to use.") case .unavailable(.deviceNotEligible):     logger.info("The model isn't downloaded and cannot run on this device.") case .unavailable(.appleIntelligenceNotEnabled):     logger.info("Apple Intelligence isn't enabled on the device.") case .unavailable(.modelNotReady):     logger.info("The model isn't ready due to download or system reasons.") @unknown default:     logger.info("The model is unavailable for a reason added after you wrote this code.") } Meanwhile, PrivateCloudComputeLanguageModel has these cases: switch pccModel.availability { case .available:     logger.info("The PCC model is available and ready to use.") case .unavailable(.deviceNotEligible):     logger.info("The device doesn't support Apple Intelligence.") case .unavailable(.systemNotReady):     logger.info("The system isn't yet ready to serve PCC requests.") @unknown default:     logger.info("The PCC model is unavailable for a reason added after you wrote this code.") } An easy mistake to make is that PrivateCloudComputeLanguageModel returns .available even if your app isn’t permitted to run the model. This is because availability checks whether PrivateCloudComputeLanguageModel is ready to run at the operating system level, but it assumes you’re already authenticated because creating a PrivateCloudComputeLanguageModel instance would’ve automatically performed an authentication check. For the system to authenticate your app with PCC, your app must have the com.apple.developer.private-cloud-compute entitlement. Without the PCC entitlement, your app crashes with a fatal error when you send the model a prompt for the first time. For PrivateCloudComputeLanguageModel, check whether the person using your app has enough of their daily quota left to access PCC, use quotaUsage. After you’ve checked model availability, treat the quota as a final extra availability check: if pccModel.quotaUsage.isLimitReached {     // The PCC model is unavailable for the rest of the day. } else {     // The PCC model is ready to use. } For more on how the quota works, when it resets, and what your app can do, see Adding server-side intelligence with Private Cloud Compute. Handle different unavailable reasons When your availability check returns .unavailable, the model won’t run. The steps you take to solve the problem depend on the unavailability reason that the .available property provides: note: In iOS 27, iPadOS 27, macOS 27, and visionOS 27 or later, Apple Intelligence is on by default and can no longer be turned off. Ultimately, your app may run on devices that aren’t compatible with any version of AFM. But that doesn’t mean you need to turn off your feature entirely. For these situations, consider whether your app can use a different model as backup, such as another server-based large language model. Alternatively, consider a custom on-device model, as described in Running a Core AI model in a Foundation Models session. Detect the exact model variant and version After confirming model availability, your app can start calling the model. For PrivateCloudComputeLanguageModel, the AFM Cloud model is the same no matter which device or OS version you call it from, allowing you to use the same prompt across everywhere your app ships. AFM Cloud occasionally updates to improve quality and performance, and these updates can occur at any time. You may need to occasionally update your prompt to maintain the best quality, but you won’t need to maintain older prompt versions: after AFM Cloud updates, it’s updated for everyone. Treat SystemLanguageModel as a single model, but you’ll often get the highest quality if you customize your app’s feature to the specific model present. There are currently two SystemLanguageModel variants: AFM Core Advanced and AFM Core, as noted in the table earlier. The SystemLanguageModel defines “the system’s language model.” Every device has just one SystemLanguageModel, so your app can’t choose which variant or version to use. That’s because even a small foundation model is a large asset in storage and memory. To protect a device’s performance, the operating system ensures a single on-device AFM is present. People may have AFM Core or AFM Core Advanced on their device, but not both. Similarly, each device has a single version of the model downloaded, so your app runs with whichever model is present. This table shows the versions of SystemLanguageModel your app may encounter:  |  |   |  |   |  |   |  |  To determine the exact model present, use a runtime check. In iOS 27, iPadOS 27, macOS 27, and visionOS 27 or later, read the variant property, which returns a SystemLanguageModel.Variant. For earlier releases, use a standard Swift if #available check, starting from the newest release and ending with the oldest: let logger = Logger(subsystem: "com.example.MyApp", category: "ModelVariant")

// In iOS 27, iPadOS 27, macOS 27, and visionOS 27 or later, use the `variant` property. if #available(iOS 27.0, iPadOS 27.0, macOS 27.0, visionOS 27.0, *) {     let variant = SystemLanguageModel.default.variant     switch variant {     case .core3:         // This logs AFM 3 Core.         logger.info("Model detected: \(variant.displayName)")     case .coreAdvanced3:         // This logs AFM 3 Core Advanced.         logger.info("Model detected: \(variant.displayName)")     default:         logger.warning("Detected an unrecognized model variant: \(variant.displayName)")     } } else if #available(iOS 26.4, iPadOS 26.4, macOS 26.4, visionOS 26.4, *) {     // iOS 26.4, iPadOS 26.4, macOS 26.4, and visionOS 26.4 or later have AFM 2.1 Core.     logger.info("Model detected: AFM 2.1 Core") } else {     // iPadOS 26.0 to 26.3, macOS 26.0 to 26.3, and visionOS 26.0 to 26.3 have AFM 2 Core.     logger.info("Model detected: AFM 2 Core") } For more information about adapting your app for different model variants and versions, see Updating prompts for new model versions. Check model-device compatibility Use the following table as a quick reference to the devices that can run Apple Foundation Models, but remember that language, region, and device storage space requirements also affect availability. For the most up-to-date information, including the latest list of supported languages, see How to get the next generation of Apple Intelligence.  |  |  |  |   |  |  |  |   |  |  |  |   |  |  |  |   |  |  |  |   |  |  |  |   |  |  |  |   |  |  |  |   |  |  |  |   |  |  |  |   |  |  |  |  note: A compatible Apple Watch must be paired with an Apple Intelligence-enabled iPhone to run AFM Cloud. Devices compatible with both AFM Core and AFM Core Advanced run AFM Core on iOS 26.0 to 26.3, iPadOS 26.0 to 26.3, macOS 26.0 to 26.3, and visionOS 26.0 to 26.3, and AFM Core Advanced on iOS 27.0, iPadOS 27.0, macOS 27.0, and visionOS 27.0 or later. The system downloads the best available model, so it downloads AFM Core Advanced when possible, because it’s the more powerful model.

## See Also

### Apple Foundation Models

- [SystemLanguageModel](foundationmodels/systemlanguagemodel.md)
- [PrivateCloudComputeLanguageModel](foundationmodels/privatecloudcomputelanguagemodel.md)
