RealityKit et Reality Composer Pro 3 en 2026

Reality Composer Pro 3 a quitté le bundle Xcode et est livré comme une application à part entière, que vous lancez depuis le dossier Applications. Le détail se lit comme une note d’empaquetage, mais c’est le signal le plus clair de toute l’histoire spatiale de la WWDC26 : l’outil de création est désormais une destination, et non plus un accessoire, et le moteur qui le sous-tend a grandi pour être à la hauteur.¹

La version 2026 fait avancer les deux moitiés du pipeline en même temps. RealityKit gagne les fonctionnalités de rendu et de simulation qui rendent une scène crédible : ombres douces, lightmaps précalculées, textures projectives qui débordent sur vos murs réels, tissu, maillages de navigation, gaussian splats et acoustique avec lancer de rayons. Reality Composer Pro 3 gagne le flux de travail qui relie ces fonctionnalités sans cycle de compilation : aperçu en direct sur un casque, prototypes et instances, graphes à nœuds et un assistant IA qui génère du contenu 3D. Un troisième fil les relie, le code : les plug-ins Xcode exécutent vos composants personnalisés à l’intérieur de l’outil de création, et une nouvelle boîte à outils de modèles structurés alimente des applications collaboratives de revue de conception. Les pièces ont cessé d’être des démos séparées pour devenir une manière de travailler cohérente.

Cet article parcourt les cinq sessions de la WWDC26 qui définissent cette année le pipeline de création spatiale, chacune avec l’extrait qui l’ancre et l’idée qui change votre façon de construire.

TL;DR / Points clés

• L’éclairage et la simulation de RealityKit ont mûri : ombres douces pilotées par lightSize, lightmaps précalculées, textures projectives accompagnées de l’éclairage de l’espace physique sur votre pièce réelle, tissu, maillages de navigation, gaussian splats et réverbération avec lancer de rayons.²
• Reality Composer Pro 3 est livré comme une application autonome (ce n’est plus un outil de développement Xcode), conçue pour une itération rapide : un onglet de simulation ancrable, des prototypes et des instances avec surcharges, un aperçu en direct sur l’appareil, des lightmaps précalculées et un assistant d’IA générative.³
• Vous étendez l’éditeur avec des plug-ins Xcode : composants et systèmes s’y exécutent grâce au protocole RealityComposerProPlugin, des actions d’animation personnalisées s’insèrent dans le séquenceur via EntityAction, et la macro @Scriptable expose des composants à Script Graph.⁴
• Les outils visuels à nœuds (Animation Graph, Behavior Tree, Script Graph, Compute Graph, Shader Graph) permettent aux designers de créer le comportement des personnages, des particules GPU et des matériaux sans cycle de compilation.⁵
• visionOS 27 ajoute une boîte à outils de modèles 3D structurés pour la revue de conception collaborative : placement de ManipulationComponent piloté par la hiérarchie, un nouveau ClippingComponent pour les coupes transversales, et une variance pondérée par le volume pour déployer automatiquement les assemblages.⁶

RealityKit a obtenu les fonctionnalités qui vendent le réalisme

RealityKit est le moteur 3D multiplateforme d’Apple depuis 2019, la couche que vous construisez une fois et déployez sur visionOS, iOS, iPadOS, macOS et tvOS.² Les ajouts de 2026 comblent l’écart entre « rend correctement » et « a l’air réel », démontrés à l’intérieur d’un seul jeu, Chaparral Village, qui donne à la session un fil conducteur plutôt qu’une liste de fonctionnalités.

Commençons par les ombres, car le choix de l’API révèle la façon de penser de l’équipe. Les ombres de RealityKit sont par défaut à bords nets, ce qui n’est correct que lorsque la source lumineuse est infinitésimale. Une vraie lumière a une surface, et une surface produit une pénombre, cet adoucissement où la lumière n’est que partiellement bloquée. RealityKit modélise cela avec un seul bouton intuitif : le lightSize d’une ombre, soit le diamètre de la lumière en mètres. Réglez-le sur 0,7 et les bords s’adoucissent ; plus la lumière est grande, plus la pénombre est large. Un réglage quality complémentaire échange des échantillons contre des performances (low force une ombre nette ; medium suffit à une distance de visionnage typique).² Les contrôles correspondent à des grandeurs physiques, le schéma à intérioriser.

Deux fonctionnalités poussent la lumière au-delà de la frontière virtuelle. Les textures projectives imitent l’éclairage d’une lampe torche à travers un morceau de film, projetant un motif sur ce que vise le projecteur, caustiques animées ou étoiles et nébuleuses d’un planétarium. L’éclairage de l’espace physique permet ensuite à ces lumières virtuelles d’interagir avec la pièce réelle grâce au maillage de compréhension de scène de RealityKit, de sorte que les étoiles projetées épousent vos murs réels. L’activation est presque anticlimatique : vous ajoutez un composant SurroundingsLight au projecteur (actuellement les projecteurs et les lumières ponctuelles).² Transformer une lumière virtuelle en lumière de pièce réelle est un composant que vous attachez, et non un chemin de rendu distinct.

Le reste de la session fait le tour de la simulation et de la capture. La simulation de tissu décrit l’étoffe comme un maillage de particules-sommets reliées par des arêtes-ressorts ; épingler un rideau marque certains sommets comme cinématiques. Les maillages de navigation définissent des régions praticables avec des coûts de traversée par zone et des connexions hors maillage, alimentés par un NavigationComponent et interrogés par un NavigationController. Les gaussian splats restituent des captures du monde réel sous forme d’ellipsoïdes définis par position, échelle, rotation, opacité et harmoniques sphériques, assemblés dans un GaussianSplatComponent. L’audio immersif gagne un maillage de réverbération personnalisé fondé sur une acoustique géométrique avec lancer de rayons, où un ReverbMeshResource définit la géométrie de la pièce et l’acoustique par matériau.² Le fil conducteur : chaque capacité est un composant que vous composez sur une entité, exactement la forme entité-composant-système que RealityKit a toujours eue.

Reality Composer Pro 3 ferme la boucle d’itération

Le changement le plus lourd de conséquences dans l’éditeur n’a aucune API. Reality Composer Pro 3 n’est plus un outil de développement Xcode ; vous le lancez depuis Applications, et toute la version s’organise autour de la réduction du temps entre une modification et le moment où vous la voyez.³

L’éditeur conserve le modèle entité-et-composant. Vous importez un fichier USD sous forme de bundle optimisé, vous le glissez dans la fenêtre comme une entité, et vous le façonnez grâce aux composants dans l’inspecteur. Ce qui change, c’est le retour. Appuyez sur Lecture et la scène s’exécute ; ancrez l’onglet de simulation à côté de l’onglet de scène et vous continuez à créer pendant que le jeu tourne, en ajustant un graphe et en observant le résultat sans aucune étape de déploiement. La formule de JP est celle à retenir : l’onglet de simulation retire le processus de déploiement de la boucle interne, si bien que la friction entre vous et l’expérience finale disparaît presque.³

Trois systèmes prolongent cette boucle. Les prototypes transforment une entité en un asset réutilisable que l’on glisse dans le Project Browser ; vous l’instanciez de nombreuses fois, surchargez n’importe quelle instance, réinitialisez une surcharge ou la propagez vers la source, et rien ne change durablement à moins que vous ne le décidiez. L’aperçu en direct cible un Vision Pro connecté via une application compagnon (livrée plus tard cette année), de sorte que vous créez sur le Mac et voyez les mises à jour instantanément sur l’appareil, là où l’éclairage de l’espace physique doit réellement être jugé.³ Les lightmaps gèrent l’éclairage statique : un composant Lightmap précalcule l’éclairage indirect, l’occlusion ambiante ou le rendu final dans une texture, avec un onglet d’aperçu montrant l’impact avant un calcul complet. La session se conclut sur le Reality Composer Pro Assistant, un panneau d’IA qui génère des objets 3D et des matériaux à la demande.³ Le schéma se répète : voir la conséquence d’un changement avant d’en payer le prix.

Étendre l’éditeur avec Xcode

L’éditeur autonome serait une impasse pour les équipes sérieuses si les artistes ne pouvaient utiliser que des composants intégrés. Le système de plug-ins est la réponse, qui fait passer Reality Composer Pro d’un outil que l’on utilise à un outil que l’on programme. Il est livré plus tard cette année.⁴

La structure de l’équipe est le point de départ. Un projet de type Chaparral Village associe un projet Reality Composer Pro (artistes et designers) à un projet Xcode (ingénieurs) dans le même dépôt git. Les fichiers importés sont convertis en JSON interne sur le disque, de sorte que l’outillage git standard les fusionne, et l’éditeur ajoute un outil de fusion personnalisé avec moins de conflits qu’un simple git merge.⁴ Les ingénieurs construisent deux schémas à partir d’un code partagé : l’application, et un plug-in RCPCustomComponents.framework exposant leurs composants et systèmes à l’éditeur. Les scènes sont exportées vers un Reality File, le format de sérialisation de RealityKit, que l’application charge. Le code arrive dans l’éditeur sous forme de plug-in ; le contenu arrive dans l’application sous forme de Reality File.

Le mécanisme est une poignée de main d’enregistrement. Vous écrivez une classe conforme à RealityComposerProPlugin (issue du package Swift RealityComposerPro, ajouté automatiquement lorsque vous liez le projet), et dans sa méthode setup, vous enregistrez vos composants et systèmes avec le contexte que l’éditeur vous transmet. Une fonction createRealityComposerProPlugin(), exportée comme un symbole C pour que le chargeur la trouve, renvoie le plug-in. Construisez le schéma du plug-in, ouvrez le projet, acceptez l’invite de confiance, et votre composant personnalisé apparaît dans l’inspecteur ; un artiste fait glisser le curseur du niveau d’eau et la surface réagit parce que votre système Swift s’exécute à l’intérieur de l’éditeur.⁴ Vous pouvez même attacher le débogueur Xcode et atteindre des points d’arrêt dans le code du plug-in. La remarque honnête de la session mérite d’être gardée : Script Graph et le code font des choses similaires, et la vraie raison de recourir au code, c’est que les grands Script Graphs deviennent difficiles à maintenir et que le code peut appeler des API Apple (dont SwiftUI) que Script Graph ne peut pas.⁴

La surface d’extension des plug-ins atteint trois systèmes de l’éditeur. Les composants et systèmes personnalisés sont le cas de base. Les actions d’animation personnalisées implémentent EntityAction (et Codable), puis se glissent sur le séquenceur avec des paramètres modifiables. Et la macro @Scriptable déploie un composant en un schéma que vous enregistrez, afin que les designers le câblent directement dans les nœuds de Script Graph.⁴ Les mêmes données personnalisées, accessibles depuis le code, la timeline et la couche de scripting visuel à la fois.

Les graphes à nœuds qui construisent le comportement sans code

Si la session 281 est l’histoire du code, la session 393 en est le miroir : jusqu’où un designer va sans code, en utilisant les graphes visuels de l’éditeur. La réponse de 2026, c’est presque tout le chemin vers un personnage interactif.

La construction empile quatre types de graphes. L’Animation Graph est un éditeur d’exécution à nœuds avec un nœud Final Pose à sa racine ; Vincent y dépose une State Machine, définit les états Idle et Walk avec des transitions conditionnées, et pilote le mélange avec un seul booléen isWalking basculé à l’exécution. Le Behavior Tree crée la routine autonome : un composite Sequence exécute dans l’ordre les nœuds Rotate To Face, Move To et Wait, des nœuds Parameter Setter font basculer isWalking autour du déplacement, et une Precondition fait attendre l’alchimiste jusqu’à ce qu’un drapeau readyToBrew passe à vrai. Script Graph fournit la colle pilotée par les événements : un nœud On Tap définit readyToBrew, de sorte qu’un tap envoie le personnage vers le chaudron.⁵ L’idée qui compte pour la vélocité de l’équipe : parce que les graphes sont visuels et pilotés par les événements, n’importe qui dans l’équipe construit et teste des comportements directement dans l’éditeur sans cycle de compilation.⁵

La session complète deux éléments que la session 279 avait décrits côté code. Le composant Navigation Mesh est le pendant côté création de cette API : une boîte englobante Shapes sélectionne quelle géométrie échantillonner, les Off-Mesh Connections relient des régions disjointes, et des Generation Parameters comme la taille des cellules contrôlent la résolution d’échantillonnage. Une fois créé, le maillage alimente un Behavior Tree, un Animation Graph ou un système Swift personnalisé.⁵ Compute Graph construit des simulations de particules GPU adossées à Metal sur quatre phases (Emitter, Initialize, Simulate, Output), et la fumée du chaudron utilise une force de gravité négative pour que la vapeur dérive vers le haut. Shader Graph ajoute RealityKit PBR Surface 2 (lustre et diffusion sous la surface), une surface de cheveux dédiée, ainsi qu’une surface et une géométrie de portail modifiables.⁵

Collaborer sur des modèles 3D structurés

La dernière session est l’aboutissement, ce que vous construisez lorsque le moteur et l’éditeur sont aussi capables. visionOS 27 livre une boîte à outils pour la revue de conception collaborative, où des personnes réunies dans un appel SharePlay manipulent le même assemblage complexe, l’ouvrent, le coupent et en détachent des pièces, à la même fidélité dans le même espace.⁶

La fondation, c’est la structure, et le point le plus aigu de la session est qu’une géométrie sans hiérarchie est inutile au code. Un bloc-moteur aplati à la racine s’affiche très bien mais n’offre rien à saisir ou à animer, les pistons enfouis dans une liste plate de noms du genre InteriorPart_47. Une hiérarchie imbriquée rend chaque pièce trouvable, la condition préalable à tout le reste.⁶ Sur cette hiérarchie, la manipulation est une décision de placement : mettez un ManipulationComponent à la racine et tout l’assemblage bouge comme un seul objet ; descendez-le vers les enfants (avec InputTargetComponent et CollisionComponent à ses côtés, releaseBehavior réglé sur .stay) et chaque pièce devient saisissable individuellement tandis que le reste demeure en place. La formule de Bill est l’énoncé le plus net de la philosophie ECS des cinq sessions : le passage de « chose à regarder » à « chose à explorer » se produit entièrement à cause de l’endroit où vit le composant dans l’arbre.⁶

Le clipping est la capacité véritablement nouvelle de RealityKit. Le ClippingComponent écarte à chaque image la géométrie située en dehors d’un bounds aligné sur les axes (shouldClipChildren vaut false par défaut, le piège courant ; shouldClipSelf vaut true par défaut), exposant l’intérieur aussi facilement que l’extérieur.⁶ Le modèle d’interaction est délibérément réduit : les six faces de la boîte englobante deviennent six plans déplaçables, chacun contrôlant un scalaire. Rendre ces glissements naturels est la leçon de mathématiques de la session : un delta de glissement se transforme du repère monde au repère du modèle, puis se projette sur la normale du plan, de sorte que les bounds ne changent que le long de l’axe que vous avez saisi. Le déploiement automatique recourt à la même honnêteté statistique, en calculant une variance de position pondérée par le volume le long de chaque axe et en écartant en éventail les sous-assemblages le long de celui de plus grande variance.⁶ La leçon de clôture de Bill est inhabituelle pour une conférence sur le graphisme : familiarisez-vous avec la variance, la projection vectorielle et les transformations de repère, car les interactions qui semblent sans effort reposent sur ces mathématiques.

Par où commencer

Tout adopter d’un coup est le mauvais choix. Séquencez selon ce qui débloque le reste.

1. Téléchargez d’abord l’éditeur autonome. Le départ de Reality Composer Pro 3 du bundle Xcode est le changement dont dépend tout autre flux de travail ; réimportez une scène pour avoir en main l’onglet de simulation, les prototypes et l’aperçu des lightmaps.³
2. Obtenez la boucle d’itération avant les fonctionnalités. Ancrez l’onglet de simulation pour créer pendant que la scène tourne, puis reliez l’aperçu en direct sur l’appareil à un Vision Pro. Juger l’éclairage de l’espace physique ou les ombres douces sur un écran Mac plat vous induira en erreur.³²
3. Recourez aux fonctionnalités de RealityKit comme à des composants, non à des réécritures. Des ombres douces, une lightmap précalculée et un SurroundingsLight sur un projecteur sont chacun un composant ou une propriété, et chacun achète une quantité disproportionnée de réalisme.²
4. N’ajoutez le plug-in Xcode que lorsque les artistes ont besoin de vos données. L’enregistrement de RealityComposerProPlugin justifie sa place dès qu’un designer veut régler un composant personnalisé en direct ; jusque-là, les composants intégrés et Script Graph couvrent beaucoup de terrain.⁴⁵
5. Construisez sur la hiérarchie pour la revue de conception. La boîte à outils de modèles structurés ne fonctionne que sur un asset bien imbriqué, alors corrigez la hiérarchie avant d’écrire du code d’interaction.⁶

Le fil conducteur des cinq sessions : cette année, le pipeline spatial récompense la composition plutôt que la construction. Le réalisme est un composant que vous attachez, l’itération un onglet que vous ancrez, la collaboration une hiérarchie que vous respectez.

FAQ

Reality Composer Pro 3 fait-il encore partie de Xcode ?

Non. Reality Composer Pro 3 est désormais une application autonome que vous téléchargez depuis le site développeur et lancez depuis votre dossier Applications. Elle se lie toujours à un projet Xcode pour construire l’application et charger les plug-ins, mais l’éditeur s’exécute de façon indépendante.³

Comment fonctionnent les ombres douces dans RealityKit en 2026 ?

La propriété lightSize d’une ombre est le diamètre de la lumière en mètres ; la valeur par défaut 0 produit une ombre nette, et une valeur plus grande (la session utilise 0,7) élargit la pénombre. Réglez quality sur medium ou high, car low force une ombre nette quelle que soit la taille de la lumière, medium étant recommandé à une distance de visionnage typique pour maîtriser le coût.²

Puis-je exécuter mon propre code Swift à l’intérieur de l’éditeur Reality Composer Pro ?

Oui. Construisez un plug-in conforme au protocole RealityComposerProPlugin et enregistrez vos composants et systèmes dans sa méthode setup ; l’éditeur exécute ce code en direct, de sorte qu’un artiste ajuste une propriété et voit le système réagir sans recompiler l’application. Vous pouvez attacher le débogueur Xcode pour atteindre des points d’arrêt dans le code du plug-in. La fonctionnalité est livrée plus tard en 2026.⁴

Quelle est la nouvelle fonctionnalité de clipping dans visionOS 27 ?

ClippingComponent écarte à chaque image toute géométrie située en dehors d’une boîte englobante alignée sur les axes (bounds), vous laissant voir à travers un assemblage complexe jusqu’à son intérieur. Notez que shouldClipChildren vaut false par défaut, de sorte qu’un assemblage parent ne clippe pas ses enfants tant que vous ne l’avez pas réglé sur true.⁶

Dois-je écrire du code pour qu’un personnage s’anime et réagisse aux taps ?

Non. Les graphes visuels de Reality Composer Pro 3 s’en chargent : une machine à états Animation Graph mélange les animations d’attente et de marche, un Behavior Tree séquence la routine et la conditionne à un booléen, et un Script Graph câble un nœud On Tap pour faire basculer ce booléen, le tout créé sans cycle de compilation.⁵

L’ensemble du cluster Apple Ecosystem : le modèle mental spatial qui explique pourquoi RealityKit est un système entité-composant plutôt que du SwiftUI en 3D ; les patterns spatiaux de visionOS pour structurer les scènes et les styles d’immersion ; les nouveautés de visionOS 27 pour les fonctionnalités de la plateforme autour de ces outils ; et la matrice des plateformes Apple pour la façon dont RealityKit se déploie sur visionOS, iOS, iPadOS, macOS et tvOS. Le hub se trouve dans la série Apple Ecosystem. Pour un contexte plus large autour d’iOS avec des agents IA, voyez le guide de développement d’agents iOS.

Références