Apple spent nine years teaching developers to think in Core ML. Then, in June 2026, at WWDC, it introduced a second framework called Core AI, built specifically for large language models and generative workloads, and let both frameworks run side by side. For a lot of iOS developers, that single announcement changed how they plan on-device AI work for the year ahead.
If you build for iPhone, iPad, or Mac, you now have three overlapping tools for AI on Apple hardware: Core ML, the Foundation Models framework, and the newer Core AI. Each one solves a different problem, and picking the wrong one for a project can mean months of rework later.
This guide covers what Core ML in 2027 actually looks like, how it fits alongside Apple Intelligence and Core AI, where each framework earns its place in a real app, and how Core ML is used for on-device AI for iOS in 2027 across real shipping apps. Whether you shipped your first Core ML model back in 2017 or you are starting from zero, this is the practical version.
A Brief History: From Core ML to Core AI
It helps to see the timeline before going any further, because most of the confusion around Core ML in 2027 comes from treating it as one continuous story instead of two related ones.
Reading that table, the pattern is straightforward. Core ML was never replaced. It was joined by two newer tools that took over the workloads it was never really designed to carry in the first place.
What Core ML Still Does in 2027
Core ML has been part of the iOS SDK since iOS 11, and it has not gone anywhere. It is a general purpose inference engine. You train a model somewhere else, usually in PyTorch or TensorFlow, convert it with coremltools into an .mlpackage file, and Core ML runs that model on the device using whichever hardware suits the job best: the Neural Engine, the GPU, or the CPU.
That description has barely changed since 2017. What has changed is the scale of what Apple silicon can run without breaking a sweat. The Neural Engine in current generation chips handles well over 30 trillion operations per second, and Core ML automatically schedules work across compute units based on model architecture, so most developers never touch that logic directly.
The framework itself is built around a small set of ideas that have held up well over nine years:
• A unified model container. Whether a model started life in PyTorch, TensorFlow, or scikit learn, Core ML wraps it in the same .mlpackage format, so the rest of your app code does not need to know or care how the model was originally trained.
• Automatic hardware selection. Core ML decides, model by model and sometimes layer by layer, whether the Neural Engine, GPU, or CPU is the best place to run a given operation, based on precision, memory, and power tradeoffs.
• On-device execution by default. Nothing about a standard Core ML model requires a network connection. Inference happens locally, which is part of why it remains popular for anything privacy sensitive.
• Tooling that plugs into a normal ML workflow. coremltools works from a Python environment most data science teams already use, so converting a model does not mean retraining it from scratch in a new framework.
None of that changed with the arrival of Core AI. What changed is the type of model developers reach for Core ML to run in the first place.
Core ML in 2027 is still the right tool for:
• Image classification and object detection
• Facial and body pose analysis
• Custom recommendation models trained on your own data
• Sound classification and audio event detection
• Small, task specific models that need to run in milliseconds, not seconds
Apple has been explicit that Core ML is not being retired. Generative AI, chat interfaces, and large transformer models moved to Core AI and Foundation Models, but classification, detection, and other traditional machine learning tasks are still Core ML's job. If your app needs a model that answers one narrow question quickly and cheaply, Core ML in 2027 remains the default answer, not a legacy one.
The Big Shift: Apple Intelligence, Foundation Models, and Core AI
Apple Intelligence launched in iOS 18.1 back in October 2024, and it introduced the first version of an on-device large language model that developers could tap into indirectly through system features like Writing Tools and Genmoji. iOS 26 opened that model up directly with the Foundation Models framework, giving developers a roughly 3 billion parameter on-device language model accessible through native Swift APIs, with zero setup and no model file to ship.
Then WWDC 2026 raised the stakes again. Apple introduced Core AI, a framework purpose built for large language models, diffusion models, and multimodal generative workloads, folding the existing Foundation Models capability directly into it. Core AI ships with its own model format, its own conversion tools built around PyTorch, and a native Swift inference API designed to run everything from compact 3 billion parameter vision models up to large reasoning models with tens of billions of parameters, scheduled across the CPU, GPU, and Neural Engine.
That is a genuinely different tool from Core ML, not a renamed version of it. Here is how Apple itself draws the line:
How Core ML Is Used for On-Device AI for iOS in 2027
Despite the new framework, most of the day to day work developers do with on-device machine learning still runs through Core ML. Here is where it shows up in shipping apps.
Vision and camera features. Apps that scan documents, detect objects in a live camera feed, blur backgrounds, or tag photos by content almost always run a Core ML model behind the scenes, often paired with the Vision framework for preprocessing.
Health and fitness tracking. Workout classification, gait analysis, and sleep stage estimation on watchOS and iOS lean heavily on Core ML models trained on sensor data, because these tasks need to run continuously with minimal battery draw.
Audio and speech tasks. Sound classification, keyword spotting, and on-device transcription pipelines that do not need a full language model still rely on Core ML for speed and predictability.
Personalization without a server round trip. Recommendation and ranking models that adapt to a single user's behavior, like sorting a news feed or suggesting the next action in a productivity app, run locally through Core ML so the logic works offline and the raw usage data never leaves the device.
Accessibility features. Text recognition, scene description, and sound recognition for users who are deaf or hard of hearing are Core ML use cases that predate Apple Intelligence entirely and remain untouched by the shift toward generative models.
This is really the core of how Core ML is used for on-device AI for iOS in 2027: narrow, fast, predictable tasks that do not need a conversation, just an answer. Generative features, by contrast, are increasingly built on Foundation Models or Core AI instead.
Core ML Development Trends 2027
A few patterns stand out if you look at where Core ML development trends 2027 are heading, based on what Apple shipped at WWDC and what developers are actually building.
1. Hybrid pipelines are becoming normal
Instead of picking one framework for an entire app, more teams are combining Core ML for narrow perception tasks with Foundation Models or Core AI for the conversational or generative layer on top. A photo app might use Core ML to detect and classify objects in an image, then hand a text description to Foundation Models to generate a caption.
2. Model compression keeps improving
Core ML Tools now offers more granular weight compression, including palettization and low bit quantization, so larger models fit into tighter memory and battery budgets. This matters more every year as models grow while phones need to run them for longer without draining the battery.
3. Privacy stays the selling point
With around 81 percent of Apple Intelligence queries handled fully on device and only a small share routed to Private Cloud Compute or opt-in third party models like ChatGPT, privacy remains Apple's core argument for on-device processing, and Core ML fits directly into that story since it never sends data off the device at all.
4. Third party model support is opening up
Core AI's PyTorch based conversion tools and its unified language model protocol make it easier to bring third party and open source models onto Apple silicon, something Core ML supported in a more limited way through coremltools for years.
5. On-device AI is now a baseline expectation, not a differentiator
A few years ago, shipping any on-device AI feature was a selling point. Now, with a meaningful share of iOS developers already building Apple Intelligence or Core ML features into their apps, users expect offline functionality, instant responses, and local personalization as the default, not a bonus.
6. Tooling is converging around PyTorch
Both coremltools and Core AI's conversion pipeline now lean heavily on PyTorch as the starting point, which reduces the amount of framework specific glue code teams need to maintain. This is one of the more practical Core ML development trends 2027 has brought, since it shortens the distance between a research notebook and a shipping model.
7. Smaller, task specific models are making a comeback
Alongside the push toward larger generative models, there is a parallel trend toward smaller, more efficient Core ML models trained for a single job. Teams that tried building everything around a large language model in 2025 and 2026 are now pulling narrow tasks back out into dedicated Core ML models, because a two megabyte classifier is still faster and cheaper to run than asking a language model to do the same job.
Taken together, these seven points are the clearest signal of where Core ML development trends 2027 are headed: not a single framework winning out, but a more deliberate split between narrow, efficient models and larger generative ones, with clearer guidance from Apple about which framework each job belongs to.
Market Snapshot: On-Device AI for iOS
A few numbers help explain why so many teams are investing in Core ML in 2027 rather than treating it as optional.
• Apple Intelligence was active on roughly 940 million iPhone, iPad, and Mac devices by early 2026, up from about 280 million a year earlier.
• Around 81 percent of Apple Intelligence requests are processed entirely on device, with the remainder split between Apple's Private Cloud Compute and opt-in third party models.
• iOS held about 28 percent global mobile operating system share by early 2026, but captured roughly 69 percent of global in app purchase revenue, which is part of why so many product teams prioritize iOS first for premium AI features.
• The global on-device AI market was valued at roughly 33 billion dollars in 2026 and is projected to grow at a compound annual rate near 25 percent through the early 2030s, driven largely by smartphone adoption and privacy regulation.
• iOS 26 reached close to 79 percent adoption across the measured App Store install base within its first year, and 86 percent among iPhones released in the previous four years, which matters because Foundation Models and Core AI both require recent hardware and current software to function.
Integrating Apple Intelligence Into Your App
Apple Intelligence is not a single API. It is a collection of system features and developer entry points that sit on top of Foundation Models and, increasingly, Core AI. The main integration paths worth knowing:
• App Intents. Lets your app expose specific actions to Siri, Spotlight, and the system, so users can trigger app functionality through natural language without opening the app directly.
• Writing Tools. Text fields built with standard UIKit or SwiftUI components automatically gain Apple's proofreading, rewriting, and summarization tools, with very little extra work required.
• Foundation Models framework. Gives direct Swift access to Apple's on-device language model for tasks like summarization, structured data extraction, and conversational features, using the @Generable macro to convert Swift types into structured output the model can fill in.
• Genmoji and Image Playground extensibility. Apps that handle images or messaging can plug into Apple's generative image tools rather than building their own image generation pipeline from scratch.
• Guided generation. Instead of parsing free form text back from a model, developers can constrain output to a defined JSON schema, which makes on-device generative features far more predictable in production.
These integration points sit above Core ML, not in place of it. A single app might use App Intents for voice control, Foundation Models for a chat style feature, and Core ML underneath both for the actual image classification or sensor analysis that feeds them accurate data.
A Quick Walkthrough: Getting a Model Into a Core ML App
For developers who have not touched Core ML recently, or who are evaluating it against Core AI for a new project, the basic workflow still follows the same five steps it has for years.
1. Train or source a model. Most teams either train a model in PyTorch or TensorFlow, or start from a pretrained open source model that fits the task.
2. Convert it with coremltools. The Python based coremltools library takes the trained model and converts it into the .mlpackage format Core ML expects, applying quantization or palettization at this stage if needed.
3. Drop the .mlpackage into your Xcode project. Xcode automatically generates a Swift interface for the model, so calling it from code looks like calling any other typed Swift object.
4. Run inference through Vision or Core ML directly. For image tasks, most developers wrap the model in a VNCoreMLRequest through the Vision framework. For everything else, Core ML's own API handles input and output directly.
5. Profile on device and adjust compute unit preferences if needed. Core ML lets you hint whether a model should prefer the Neural Engine, GPU, or CPU, which matters most on older devices with a less capable Neural Engine.
That workflow has not meaningfully changed since Core ML's early days, which is exactly why it remains approachable for teams that do not want to rebuild their entire pipeline just to add an on-device AI feature. Contrast that with Core AI, which introduces its own .aimodel format, its own PyTorch export path through coreai-torch, and a newer set of runtime types like InferenceFunction and NDArray that developers coming from Core ML will need to learn from scratch.
Core ML vs Foundation Models vs Core AI: Which One to Use
This is the decision developers ask about most, and the honest answer is that most production apps will end up using more than one.
Best Practices for Building With Core ML in 2027
Profile on real hardware, not the simulator. The Neural Engine, GPU, and CPU behave differently under real thermal and battery conditions than they do in Xcode's simulator. Always benchmark on a physical device before shipping.
Compress before you optimize anything else. Palettization and quantization through Core ML Tools often cut model size and latency more than any amount of manual tuning elsewhere in the pipeline.
Design for the device you will actually ship to. Not every user has the latest iPhone. Build a tiered experience: a lightweight Core ML model for older or budget devices, and a richer Foundation Models or Core AI feature for devices that support it.
Keep data on device wherever the task allows. This is not just a privacy nicety anymore. App Store reviewers and users both scrutinize apps that route data to a server when an on-device option was clearly possible.
Version your models deliberately. As Core ML Tools and Core AI's conversion pipeline both evolve quickly, pin specific tool versions in your build pipeline so a routine dependency update does not silently change model behavior in production.
Test conversion output against the original model. A model that scored well in PyTorch or TensorFlow can behave differently after conversion to .mlpackage or .aimodel, particularly at reduced precision. Always validate outputs after conversion, not just before.
Watch battery and thermal impact, not just speed. A model that runs in 50 milliseconds but pushes the device into thermal throttling after repeated use will hurt the overall experience more than a slightly slower model that stays within a reasonable power budget.
Build a clear fallback path for unsupported devices. Check for Foundation Models and Core AI availability at runtime rather than assuming every user's device supports them, and route unsupported devices to a Core ML based version of the feature wherever that is realistic.
Keep an eye on App Review guidance around AI features. Apple has been updating its App Store guidelines around how apps disclose AI generated content, how they label features powered by third party models routed through Apple Intelligence, and how they handle any data that leaves the device. Build this into your release checklist rather than discovering it during review.
Together, these practices are less about any single framework and more about treating on-device AI the way you would treat any other performance sensitive part of an app: measured, tested on real hardware, and shipped with a fallback for the users who are not on this year's flagship device.
Common Pitfalls to Avoid
• Treating Core AI as a drop in replacement for Core ML. They serve different workloads. Moving a working classifier to Core AI usually adds complexity without improving results.
• Ignoring older devices. Foundation Models and Core AI both require recent Apple silicon. An app built exclusively around them can lock out a real share of the install base.
• Skipping on device validation after model conversion. Accuracy drops after quantization are common and easy to miss if testing only happens in the training environment.
• Overusing generative features where a simple classifier would do the job faster and cheaper. Not every feature needs a language model behind it.
• Underestimating App Store review scrutiny around AI generated content and data handling. Apple has tightened guidelines around how apps disclose AI generated content and how they handle data sent to any cloud component, including Private Cloud Compute.
Key Takeaways
• Core ML in 2027 is still the standard tool for classification, detection, and other narrow, fast machine learning tasks on Apple platforms, and it has not been discontinued.
• Apple Intelligence, Foundation Models, and Core AI extend what apps can do with generative and conversational features, but they work alongside Core ML rather than replacing it.
• Core ML development trends 2027 point toward hybrid pipelines, deeper model compression, and on-device AI becoming a baseline user expectation rather than a differentiator.
• Understanding how Core ML is used for on-device AI for iOS in 2027 comes down to picking the right tool for each task: Core ML for perception and classification, Foundation Models for built in language features, and Core AI for custom generative and reasoning workloads.
• Device coverage still matters. Plan a Core ML based fallback for users on older hardware rather than assuming every user has access to the newest frameworks.
Conclusion
The set of frameworks available to iOS developers looks more layered than it did even two years ago, but it is not more confusing once you separate the pieces. Core ML still does what it has always done, and does it well. Apple Intelligence gave users a reason to expect AI features by default. Core AI gave developers a proper home for generative models that Core ML was never built to carry. None of that makes Core ML in 2027 optional or outdated. It makes it one part of a bigger toolkit, and for a large share of what apps actually need to do, it is still the fastest, cheapest, and most predictable part of that toolkit to reach for.
The teams that get the most out of this shift are not the ones chasing every new framework the moment it ships. They are the ones who match each task to the tool actually built for it, test on real devices, and keep a working fallback for users who are not on the newest hardware yet.
