Le framework Apple Core AI

• Core AI est un nouveau framework destiné à exécuter, optimiser et déployer des modèles d’IA dans les apps sur Apple silicon
• Il exploite le CPU, le GPU et le Neural Engine, et permet d’intégrer l’inférence de fichiers .aimodel dans une app via des API Swift
• Il fournit aussi une chaîne d’outils pour convertir des modèles PyTorch en modèles Core AI, ainsi que pour la compression, le débogage et la précompilation
• Les grands modèles nécessitent une specialization avant l’exécution, ce qui rend essentielle la conception des flux de téléchargement, de cache et de premier lancement
• Des exemples avec SAM 3, Qwen et Transformer montrent également des flux d’optimisation on-device pour la vision, le langage et le cache d’état

---

Le rôle de Core AI

• Core AI est un nouvel ensemble de technologies pour l’exécution d’IA on-device sur l’ensemble des plateformes Apple
  • Pris en charge sur iOS 27.0+ Beta, iPadOS 27.0+ Beta, macOS 27.0+ Beta, tvOS 27.0+ Beta, visionOS 27.0+ Beta et watchOS 27.0+ Beta
  • Il permet d’exécuter une inférence IA hautes performances dans les apps, avec une architecture qui évite d’envoyer les données utilisateur hors de l’appareil
• Core AI ne se limite pas à une simple API d’exécution, mais couvre tout le cycle, de la préparation du modèle à son intégration dans l’app
  • Optimisation du modèle, conversion PyTorch, génération de .aimodel, débogage, profiling dans Xcode et précompilation
  • Les modèles non neuronaux, comme les decision trees ou les modèles de feature engineering tabulaire, relèvent de Core ML

Flux de développement : de PyTorch à une app Swift

• Core AI relie le workflow PyTorch existant au flux de déploiement sur Apple silicon
  • Conversion d’un modèle PyTorch en exported program avec torch.export
  • Génération d’un .aimodel avec TorchConverter des Core AI PyTorch Extensions
  • Application de la compression et des optimisations adaptées à Apple silicon avec Core AI Optimization
• Dans une app Swift, les nouvelles API du framework Core AI servent à charger le modèle et exécuter l’inférence
  • AIModel charge un fichier .aimodel et inspecte ses fonctions d’inférence
  • InferenceFunction correspond à un graphe de calcul unique exécutable
  • NDArray est le type qui contient les données d’entrée et de sortie multidimensionnelles
  • L’appel à run injecte des entrées NDArray et récupère les résultats de l’inférence
• Il est possible d’inspecter directement les fichiers .aimodel dans Xcode
  • Taille du modèle, répartition des opérations, métadonnées et signatures de fonctions
  • Les dimensions de shape dynamiques sont affichées avec ?

Optimisation des performances : state, cache, memory layout

• Dans les architectures où la séquence d’entrée s’allonge, comme les modèles Transformer, le temps d’inférence peut augmenter progressivement
  • Dans l’exemple Snake, faire tourner les deux serpents via un modèle d’IA ralentissait le jeu au fil du temps
  • Core AI Instruments montrait que la durée des phases d’inférence s’allongeait progressivement
• Core AI permet d’implémenter des structures comme le cache key/value via les state
  • L’état est à la fois une entrée du modèle, lu pendant l’inférence et mis à jour en place
  • Les key/value des étapes précédentes sont stockés dans le cache au lieu d’être recalculés
  • Il n’est donc plus nécessaire de réinjecter tout l’historique de la partie à chaque fois
• Côté Swift, on transmet une collection de vues mutables via l’argument states de InferenceFunction.run
  • Le modèle mis à jour conserve une vitesse stable au fil du temps
  • Dans Instruments aussi, l’augmentation de la latence d’inférence devient bien plus lente
• Core AI fournit également des fonctions de contrôle mémoire pour réduire l’overhead de la boucle d’inférence
  • Il est possible d’identifier le memory layout optimal de NDArray et d’allouer selon cette structure
  • Les valeurs de sortie peuvent être préallouées afin d’éviter de nouvelles allocations pendant l’inférence
  • Des valeurs asynchrones permettent de pipeline plusieurs fonctions d’inférence

Déploiement des modèles : téléchargement, specialization, précompilation

• Les modèles Core AI sont une représentation source exécutable sur tous les appareils Apple, mais nécessitent une specialization par appareil avant l’exécution réelle
  • Au chargement du modèle, le système vérifie d’abord si un résultat de specialization existe déjà dans le cache
  • Sinon, il génère un artifact d’exécution adapté à l’appareil et à la version d’OS concernés
• La specialization des grands modèles peut prendre du temps, d’où l’importance de ne pas l’insérer au milieu d’une interaction utilisateur
  • Dans l’exemple SAM 3, au premier lancement, le spinner restait affiché longtemps à cause du chargement du modèle et d’un important événement de specialization
  • Le flux proposé consiste à télécharger le modèle avec Background Assets uniquement lorsque l’utilisateur essaie la fonctionnalité depuis un écran de présentation
• La commande coreai-build permet d’effectuer à l’avance une partie de la compilation sur la machine de développement
  • Elle génère un compiled model ciblant une architecture d’appareil donnée
  • La specialization reste nécessaire sur l’appareil utilisateur, mais le travail restant diminue, ce qui réduit le temps de préparation
• AIModelCache permet de contrôler le cache des modèles par programmation
  • Suppression des éléments inutiles
  • Contrôle de la politique de conservation des éléments
  • Partage du cache entre plusieurs apps d’un même app group

Optimisation et débogage des modèles

• Core AI Optimization fournit des fonctions de compression et de quantification des modèles
  • Prise en charge de la compression de poids INT4, INT8, FP4 et FP8
  • API de quantification avec données de calibration ou quantization aware training
• Dans l’exemple SAM 3, l’asset de base en 32 bits dépassait 3 Go, puis passait à environ 430 Mo après compression en 4 bits
  • En appliquant une compression agressive à toutes les couches, une fleur masquée n’était plus détectée
  • À partir de la seule sortie, il était difficile d’identifier quelle couche posait problème
• Le Core AI Debugger compare les valeurs internes du modèle converti à celles du modèle PyTorch d’origine
  • Visualisation de la structure du modèle sous forme de graphe
  • Inspection des valeurs des tenseurs intermédiaires
  • Traçage jusqu’à une ligne précise du code source Python
  • Affichage des opérations présentant de forts écarts selon le critère PSNR
• Dans la comparaison SAM 3, la plupart des sync points à faible PSNR apparaissaient dans le detector decoder
  • Le bloc detector ne représente que 4 % des paramètres totaux, donc le gain de compression y est faible
  • En excluant le detector de la quantification, toutes les fleurs ont de nouveau été détectées et la qualité de base a été restaurée

Core AI Models et API de haut niveau

• Le dépôt Core AI Models fournit des modèles populaires et des recettes d’export pouvant être convertis et optimisés pour les apps
  • Il permet de trouver des modèles de la famille SAM 3 et Qwen et de les convertir en modèles Core AI
  • Les packages Swift abstraient le prétraitement et le post-traitement propres à chaque modèle
• Un modèle de segmentation comme SAM 3 peut être utilisé avec CoreAIImageSegmenter
  • Segmentation d’objets à partir de prompts textuels
  • Extraction de masques via une API Swift sans manipuler directement les raw tensor shapes
• Un modèle de langage comme Qwen peut être chargé avec CoreAILanguageModel
  • Abstraction du chargement des assets, de la création du moteur et de la configuration du tokenizer
  • Utilisation possible en connexion avec LanguageModelSession de FoundationModels
  • Prise en charge des réponses en streaming et des sorties structurées basées sur @Generable

Points à retenir pour les développeurs

• Core AI est plus qu’une « API pour exécuter un modèle dans une app » : c’est une infrastructure de déploiement d’IA on-device au sens large
  • Un flux pour convertir des modèles PyTorch en .aimodel pour Apple silicon
  • Des API pour exécuter les modèles dans des apps Swift de manière sûre et efficace
  • Des outils de diagnostic des performances et de la précision via Xcode, Instruments et Debugger
• Dans la conception d’une app, le processus de préparation a souvent plus d’impact sur l’expérience utilisateur que le modèle lui-même
  • Il faut décider s’il faut embarquer le modèle dans l’app ou le distribuer via Background Assets
  • Il faut concevoir la manière de présenter le téléchargement et la specialization lors du premier lancement
  • La politique de cache et la stratégie de précompilation influent directement sur l’utilisabilité des grands modèles
• Core AI propose un flux de développement on-device pour les modèles de vision, de langage et les modèles basés sur Transformer sur les plateformes Apple
  • L’exemple SAM 3 illustre le flux de compression, de séparation et de débogage d’un modèle de segmentation
  • L’exemple Qwen montre comment relier un modèle de langage personnalisé à l’API Foundation Models
  • L’exemple Snake Transformer présente l’optimisation du cache key/value basée sur les state

Liens de référence

• Documentation Apple Core AI : https://developer.apple.com/documentation/coreai/
• WWDC26 : Découvrir Core AI : https://www.youtube.com/watch?v=XJFfCVW1UZ0
• WWDC26 : Intégrer des modèles d’IA on-device dans une app avec Core AI : https://www.youtube.com/watch?v=gl5lD2gEhb0
• WWDC26 : Exploration approfondie de la création et de l’optimisation de modèles Core AI : https://www.youtube.com/watch?v=MdlyLT_y3i0

[GN⁺]

Avis sur Hacker News

• La mise à jour Foundation Models on-device qui arrive bientôt suscite encore plus d’attente : https://developer.apple.com/documentation/updates/foundation...
  Il n’y a pas encore beaucoup d’informations.
  Cela dit, je maintiens https://github.com/Arthur-Ficial/apfel, donc je suis peut-être biaisé.

  • Je me demande si tu as vu l’ajout de l’outil fm. Il a été mentionné dans le Platforms State of the Union.
    Quand on l’exécute, on obtient ce genre de résultat : https://gist.github.com/robgough/7893602895e7580117475076198...
  • D’accord. L’idée d’avoir un modèle on-device utilisable à l’échelle du système et de toute la plateforme comme élément central de l’API de l’OS est très séduisante.
    En général, je préfère quand les logiciels sont plus fragmentés, mais chez Apple il y a beaucoup de fonctionnalités intégrées que j’apprécie.
    Ce qui m’attire particulièrement, c’est que le logiciel puisse savoir que « cette plateforme dispose de ce modèle » et l’exploiter pour toutes sortes de petites tâches d’IA générative, puis de plus en plus ambitieuses.
  • Apfel a l’air utile. J’expérimente avec Apple Foundation Models depuis presque un an, et ça semble exploitable pour des applications embarquées.
    Je creuse aussi davantage les outils de codage de type agent local, en commençant par little-coder --model ollama/gemma4:12b-it-qat.
    J’ai aussi fait un petit livre gratuit qui peut faire gagner quelques minutes de configuration : https://leanpub.com/read/local-coding-agents
    Je suis assez agacé par l’exagération autour de la croissance de l’IA centrée sur les hyperscalers, en particulier par les coûts environnementaux et sociaux des datacenters, donc je soutiens toute initiative qui favorise une IA locale et privée.
  • Je suis surpris qu’Apple ne semble pas avoir retenu l’idée d’ajouter à Core AI un endpoint compatible OpenAPI, au moins comme outil de test.
    Maintenant qu’ils offrent le support de MCP, j’aimerais aussi en savoir plus sur leur stratégie de conteneurisation / seatbelt.
    Je n’ai encore rien vu sur la manière dont Darwin est utilisé dans le système de conteneurs d’Apple.
    Apfel est un super projet, et c’était la seule raison qui me donnait envie de passer à Tahoe.

• Vidéos WWDC 2026 Core AI
  Meet Core AI - https://developer.apple.com/videos/play/wwdc2026/324/
  Dive into Core AI model authoring and optimization - https://developer.apple.com/videos/play/wwdc2026/325/
  Integrate on-device AI models into your app using Core AI - https://developer.apple.com/videos/play/wwdc2026/326/

• Cela ressemble à une nouvelle manière de convertir des modèles PyTorch dans un format qui s’exécute sur le CPU, le GPU et l’Apple Neural Engine (ANE) [0].
  Je me demande si cela remplace complètement Core ML, l’API existante [1].
  [0]: https://apple.github.io/coreai-optimization/
  [1]: https://developer.apple.com/documentation/coreml/

  • Oui. D’après la documentation de Core AI, si une app utilise des types de modèles autres que des réseaux neuronaux, comme des arbres de décision ou du feature engineering tabulaire, il faut se tourner vers Core ML.
  • C’est assez intéressant, mais je me demande quelles seront les performances par rapport aux approches existantes, par exemple charger et utiliser dans quelque chose comme llama.cpp un modèle optimisé pour Metal.
    unsloth est un bon exemple de ce genre de chose fourni avec « batteries incluses ».
  • On dirait qu’ils veulent remplacer Core ML, mais pour l’instant la relation entre Core AI, Core ML, MLX et coremltools est encore plus confuse.
    Apple devrait mieux expliquer les avantages et inconvénients de chacun, ainsi que jusqu’où va l’équivalence fonctionnelle.
  • Comme il faut OS 27 ou plus, la compatibilité descendante fait que Core ML reste utile.

• Ils disent offrir gratuitement aux apps avec moins de 2 millions de téléchargements l’accès à des modèles de niveau serveur, avec les mêmes garanties de confidentialité.
  J’espère qu’avec le temps cela sera étendu à toutes les apps. Il y aura sans doute des contraintes matérielles et de coût, mais les plus gros développeurs pourraient probablement payer.
  https://developer.apple.com/private-cloud-compute/

  • À en juger par la mention des Apple Intelligence Extensions, il semble qu’à court terme ils ne vont pas beaucoup élargir cela, et qu’à la place ils permettront aux développeurs de s’intégrer avec d’autres fournisseurs auprès desquels les utilisateurs ont déjà un compte.

• L’avenir de l’IA est clairement local, et ces derniers temps on la décrit même comme à « jetons illimités »
  Un MacBook Pro M1 peut le faire, et une RTX 3090 aussi
  Pas besoin de payer des centaines de dollars par mois, et ce n’est pas un cas isolé

  • Dans les années 1980, on pensait clairement que l’avenir de l’informatique était local. Il y avait les ordinateurs personnels, les PC, les Mac, les serveurs de bureau (Novell, puis Windows NT avec partage de disques)
    40 ans plus tard, nous sommes revenus à une infrastructure centralisée qui ressemble davantage à des terminaux intelligents modernes
    L’avenir de l’IA finira probablement par suivre la même trajectoire. Il est même probable qu’il oscille entre local et centralisé
    Cela dit, tant qu’il est possible de gagner de l’argent en vendant des produits qui tournent en local, la centralisation semble générer plus de pouvoir et plus d’argent
  • Des « jetons illimités » limités à 10 jetons par seconde, cela fait 26 millions de jetons par mois
  • Le vrai argent se trouve dans le code autour du modèle, pour le rendre efficace sur des tâches spécialisées
    Le grand public veut des modèles généralistes, donc les applis de chat IA vont continuer d’exister
    La plupart des programmes peuvent tirer profit d’une IA spécialisée tournant en local, et il y a bien plus de programmes que d’utilisateurs

• Apple semble aussi travailler sur les activations. D’après ce que je sais, c’est du w4a8, w4a16
  S’ils y arrivent vraiment — et c’est un gros si — alors, vu la portée commerciale d’Apple, cela pourrait largement influencer la manière dont les modèles de moins de 100 milliards de paramètres sont entraînés et distribués
  Le principal usage sera l’on-device, probablement davantage sur macOS que sur iOS dans la majorité des cas

• Je ne l’ai encore vu mis en avant nulle part, mais l’inférence distribuée entre Mac est intéressante. Cela inclut JACCL sur Thunderbolt 5, mlx_lm.server compatible OpenAI, et une exécution de type agent sur Mac
  Apple garde MLX (import direct des poids) séparé de Foundation Models / Core AI

• C’est pour ça que les entreprises d’IA se dépêchent d’entrer en Bourse
  D’ici la fin de l’année prochaine, la plupart des IA tourneront directement sur les appareils
  Elles n’ont pas de fossé défensif, elles ont atteint les limites de l’échelle, et la majeure partie de ce qui paraît magique peut être distillée dans des modèles plus petits — et elles le savent

  • Les modèles Qwen de l’ordre de 30 milliards sont déjà réellement utilisables dès qu’on a une machine avec assez de bande passante mémoire pour tourner à 30–90 jetons par seconde
    Le fait que Qwen ait cessé de sortir des modèles de l’ordre de 120 milliards est très révélateur
    Dans les 10 prochaines années, peut-être même dans les 3 ans, quelqu’un sortira un modèle de 256 milliards au niveau d’Opus 4.5 qu’on pourra faire tourner en local
    En ce moment, nos ingénieurs dépensent environ 800 dollars par mois en jetons Opus, et à ce rythme la période d’amortissement d’un LLM local est d’environ 10 mois
  • Je ne sais pas si on a vraiment atteint les limites de l’échelle
    Malheureusement, les modèles plus gros ont toujours l’air d’être meilleurs
  • Dans le domaine du code, on verra sans doute des modèles de 35, 70 et 150 milliards vendus contre quelques centaines à quelques milliers de dollars en paiement initial, avec des mises à jour mensuelles ou bimestrielles entraînées sur les nouveaux documents et dépôts de code pendant un an
  • Hourra, leur domination par étranglement prend fin. Vive la révolution !
  • Je veux juste un tout petit modèle qui tourne sur l’appareil. Par exemple, quelque chose qui sache qu’en autocomplétion je veux écrire « I'll be right back » et non « I'll be right Brian »
    C’est actuellement ma demande IA numéro un. S’il te plaît, Apple

• Je me demande s’il existe quelque chose de ce genre sur Linux
  Par exemple, un développeur d’applications pourrait-il supposer qu’au-delà d’une certaine version du noyau, il existe un genre de GNU Core AI ?

  • Sur les plateformes autres qu’Apple, il faut généralement se soucier d’autant de frameworks IA que du nombre de fondeurs de silicium pris en charge, plus deux ou plus
    Apple semble désormais se retrouver aussi dans cette situation entre Core ML, MLX et Core AI
    Je ne vois aucun signe indiquant que le problème de fragmentation des frameworks va disparaître bientôt
    NVIDIA veut que tout le monde fasse l’entraînement et l’inférence avec CUDA, et essaie de nier l’utilité des NPU
    Chaque fabricant de NPU a son architecture propre, ainsi qu’un framework séparé adapté à ses limites héritées de matériels conçus avant l’ère des LLM. La plupart ont aussi un autre framework visant les GPU
    Les éditeurs de systèmes d’exploitation ont eux aussi souvent un ou deux frameworks qu’ils voudraient voir utilisés à la place des frameworks propres au matériel
  • En pratique, llama.cpp remplit ce rôle. Il suffit de lier la bibliothèque ou d’utiliser l’API réseau
  • Non. En revanche, Red Hat et IBM font ce genre de choses pour leurs propres distributions
  • Il y a onnxruntime, llama.cpp, et plus précisément ggml ; iree.dev essaie aussi

• Je me demande si cela veut dire qu’on peut exécuter tout ce qu’on veut sur l’ANE
  La dernière fois que j’ai essayé, cela semblait réservé aux fonctionnalités propriétaires d’Apple comme Face ID

  • On pouvait déjà le faire en convertissant le modèle vers Core ML
    Ce qui ne pouvait pas du tout utiliser l’ANE, c’était MLX
  • On fait ça avec Core ML depuis des années