RealityKit e Reality Composer Pro 3 em 2026

O Reality Composer Pro 3 saiu do pacote do Xcode e passou a ser um app próprio, que você abre pela pasta Aplicativos. O detalhe soa como uma nota de empacotamento, mas é o sinal mais claro de toda a história espacial da WWDC26: a ferramenta de autoria agora é um destino, e não um apêndice, e o motor por baixo dela cresceu à altura.¹

A versão de 2026 move as duas metades do pipeline ao mesmo tempo. O RealityKit ganha os recursos de renderização e simulação que fazem uma cena parecer real: sombras suaves, lightmaps pré-calculados, texturas projetivas que se derramam sobre as suas paredes reais, tecido, malhas de navegação, gaussian splats e acústica por traçado de raios. O Reality Composer Pro 3 ganha o fluxo de trabalho que costura esses recursos sem um ciclo de build: prévia ao vivo num headset, protótipos e instâncias, grafos baseados em nós e um assistente de IA que gera conteúdo 3D. Um terceiro fio conecta os dois — o código: plug-ins do Xcode executam seus componentes personalizados dentro da ferramenta de autoria, e um novo conjunto de ferramentas para modelos estruturados dá vida a apps de revisão colaborativa de design. As peças deixaram de ser demos separadas e viraram um jeito coerente de trabalhar.

Este artigo percorre as cinco sessões da WWDC26 que definem o pipeline de autoria espacial deste ano, cada uma com o trecho que a torna concreta e a percepção que muda a forma como você constrói.

TL;DR / Principais conclusões

• A iluminação e a simulação do RealityKit amadureceram: sombras suaves controladas por lightSize, lightmaps pré-calculados, texturas projetivas mais o Physical Space Lighting incidindo sobre o seu cômodo real, tecido, malhas de navegação, gaussian splats e reverberação por traçado de raios.²
• O Reality Composer Pro 3 chega como app independente (não é mais uma ferramenta de desenvolvedor do Xcode), feito para iteração rápida: uma aba de simulação acoplável, protótipos e instâncias com overrides, prévia ao vivo no dispositivo, lightmaps pré-calculados e um assistente de IA generativa.³
• Você estende o editor com plug-ins do Xcode: componentes e sistemas rodam dentro dele pelo protocolo RealityComposerProPlugin, ações de animação personalizadas se encaixam no sequenciador via EntityAction, e a macro @Scriptable expõe componentes ao Script Graph.⁴
• Ferramentas visuais baseadas em nós (Animation Graph, Behavior Tree, Script Graph, Compute Graph, Shader Graph) deixam designers criarem comportamento de personagem, partículas de GPU e materiais sem um ciclo de build.⁵
• O visionOS 27 acrescenta um conjunto de ferramentas para modelos 3D estruturados voltado à revisão colaborativa de design: posicionamento do ManipulationComponent guiado pela hierarquia, um novo ClippingComponent para cortes transversais e variância ponderada por volume para expandir montagens automaticamente.⁶

O RealityKit ganhou os recursos que vendem realismo

O RealityKit é o motor 3D multiplataforma da Apple desde 2019 — a camada que você constrói uma vez e implanta em visionOS, iOS, iPadOS, macOS e tvOS.² As adições de 2026 fecham a distância entre “renderiza corretamente” e “parece real”, demonstradas dentro de um único jogo, Chaparral Village, que dá à sessão um fio condutor em vez de uma lista de recursos.

Comece pelas sombras, porque a escolha de API revela como a equipe pensa. As sombras do RealityKit assumem por padrão bordas duras, corretas apenas quando a fonte de luz é infinitesimalmente pequena. Uma luz real tem área, e a área produz uma penumbra, a transição suave em que apenas parte da luz é bloqueada. O RealityKit modela isso com um único botão de formato intuitivo: o lightSize de uma sombra, o diâmetro da luz em metros. Ajuste para 0,7 e as bordas suavizam; quanto maior a luz, mais larga a penumbra. Uma configuração complementar de quality troca amostras por desempenho (baixa força uma sombra dura; média basta a uma distância de visualização típica).² Os controles mapeiam grandezas físicas — o padrão que vale a pena internalizar.

Dois recursos empurram a luz para além da fronteira virtual. As texturas projetivas emulam fazer uma lanterna brilhar através de um pedaço de filme, lançando um padrão sobre o que quer que o holofote aponte, cáusticas animadas ou as estrelas e nebulosas de um planetário. O Physical Space Lighting então permite que essas luzes virtuais interajam com o cômodo real através da malha de compreensão de cena do RealityKit, de modo que as estrelas projetadas se conformem às suas paredes reais. A ativação é quase um anticlímax: você adiciona um componente SurroundingsLight ao holofote (no momento, holofotes e luzes pontuais).² Transformar uma luz virtual numa luz de cômodo real é um componente que você anexa, não um caminho de renderização à parte.

O restante da sessão passeia pela simulação e pela captura. A simulação de tecido descreve o pano como uma malha de vértices-partícula conectados por arestas-mola; fixar uma cortina marca vértices específicos como cinemáticos. As malhas de navegação definem regiões transitáveis com custos de travessia por área e conexões fora da malha, alimentadas por um NavigationComponent e consultadas por um NavigationController. Os gaussian splats renderizam capturas do mundo real como elipsoides definidos por posição, escala, rotação, opacidade e harmônicos esféricos, reunidos num GaussianSplatComponent. O áudio imersivo ganha uma malha de reverberação personalizada construída sobre acústica geométrica por traçado de raios, em que um ReverbMeshResource define a geometria do cômodo e a acústica por material.² O fio condutor: cada capacidade é um componente que você compõe sobre uma entidade, exatamente o formato entity-component-system que o RealityKit sempre teve.

O Reality Composer Pro 3 fecha o ciclo de iteração

A mudança mais consequente no editor não tem API nenhuma. O Reality Composer Pro 3 não é mais uma ferramenta de desenvolvedor do Xcode; você o abre por Aplicativos, e toda a versão se organiza em torno de encurtar o tempo entre uma edição e o seu resultado visível.³

O editor mantém o modelo de entidade e componente. Você importa um arquivo USD como um pacote otimizado, arrasta-o para a viewport como uma entidade e o molda por componentes no inspetor. O que muda é o retorno. Pressione Play e a cena roda; acople a aba de simulação ao lado da aba de cena e você continua criando enquanto o jogo está no ar, ajustando um grafo e observando o resultado sem qualquer etapa de implantação. A formulação de JP é a que vale a pena guardar: a aba de simulação remove o processo de implantação do ciclo interno, de modo que o atrito entre você e a experiência final quase desaparece.³

Três sistemas estendem esse ciclo. Os protótipos transformam uma entidade num ativo reutilizável arrastado para o Navegador de Projeto; você o instancia muitas vezes, sobrepõe qualquer instância, redefine uma sobreposição ou a propaga de volta para a origem, e nada muda permanentemente a menos que você decida que sim. A prévia ao vivo mira um Vision Pro conectado por meio de um app complementar (que chega ainda este ano), de modo que você cria no Mac e vê as atualizações instantaneamente no dispositivo, onde o Physical Space Lighting de fato precisa ser avaliado.³ Os lightmaps cuidam da iluminação estática: um componente Lightmap pré-calcula iluminação indireta, oclusão de ambiente ou o resultado final numa textura, com uma aba de prévia mostrando o impacto antes de um cálculo completo. A sessão se encerra com o Reality Composer Pro Assistant, um painel de IA que gera objetos e materiais 3D sob demanda.³ O padrão se repete: veja a consequência de uma mudança antes de pagar por ela.

Estendendo o editor com o Xcode

O editor independente seria um beco sem saída para times sérios se os artistas só pudessem usar componentes embutidos. O sistema de plug-ins é a resposta, requalificando o Reality Composer Pro de uma ferramenta que você usa para uma ferramenta que você programa. Ele chega ainda este ano.⁴

A estrutura do time é a premissa. Um projeto no estilo de Chaparral Village combina um projeto do Reality Composer Pro (artistas e designers) com um projeto do Xcode (engenheiros) no mesmo repositório git. Os arquivos importados convertem-se em JSON interno em disco, de modo que as ferramentas git padrão os mesclam, e o editor acrescenta uma ferramenta de mesclagem personalizada com menos conflitos do que um git merge comum.⁴ Os engenheiros constroem dois schemes a partir de código compartilhado: o app e um plug-in RCPCustomComponents.framework que expõe seus componentes e sistemas ao editor. As cenas exportam para um Reality File, o formato de serialização do RealityKit, que o app carrega. O código flui para o editor como plug-in; o conteúdo flui para o app como um Reality File.

O mecanismo é um handshake de registro. Você escreve uma classe que adota RealityComposerProPlugin (do pacote Swift RealityComposerPro, adicionado automaticamente quando você vincula o projeto) e, no seu método setup, registra seus componentes e sistemas com o contexto que o editor lhe entrega. Uma função createRealityComposerProPlugin(), exportada como símbolo C para que o carregador a encontre, retorna o plug-in. Construa o scheme do plug-in, abra o projeto, aceite o aviso de confiança — e seu componente personalizado aparece no inspetor; um artista arrasta o controle deslizante do nível d’água e a superfície reage, porque o seu sistema em Swift roda dentro do editor.⁴ Você pode até anexar o depurador do Xcode e parar em breakpoints no código do plug-in. O aparte honesto da sessão vale a pena guardar: o Script Graph e o código fazem coisas parecidas, e a verdadeira razão para recorrer ao código é que grafos grandes do Script Graph ficam difíceis de manter e o código pode chamar APIs da Apple (entre elas o SwiftUI) que o Script Graph não alcança.⁴

A superfície do plug-in alcança três sistemas do editor. Componentes e sistemas personalizados são o caso básico. As ações de animação personalizadas implementam EntityAction (e Codable) e então são arrastadas para o sequenciador com parâmetros editáveis. E a macro @Scriptable expande um componente num schema que você registra para que os designers o conectem diretamente em nós do Script Graph.⁴ Os mesmos dados personalizados, alcançáveis a partir do código, da linha do tempo e da camada de scripting visual ao mesmo tempo.

Os grafos de nós que constroem comportamento sem código

Se a sessão 281 é a história do código, a sessão 393 é o seu espelho: até onde um designer chega sem código, usando os grafos visuais do editor. A resposta de 2026 é: quase todo o caminho até um personagem interativo.

A construção empilha quatro tipos de grafo. O Animation Graph é um editor de runtime baseado em nós com um nó Final Pose em sua raiz; Vincent insere uma State Machine, define os estados Idle e Walk com transições condicionadas e dirige a mesclagem com um único booleano isWalking alternado em runtime. A Behavior Tree cria a rotina autônoma: um composto Sequence executa os nós Rotate To Face, Move To e Wait em ordem, nós Parameter Setter alternam isWalking em torno do movimento, e uma Precondition mantém o alquimista esperando até que uma flag readyToBrew se torne verdadeira. O Script Graph fornece a cola orientada a eventos — um nó On Tap define readyToBrew, de modo que um toque envia o personagem ao caldeirão.⁵ A percepção que importa para a velocidade do time: como os grafos são visuais e orientados a eventos, qualquer pessoa do time constrói e testa comportamentos diretamente no editor sem um ciclo de build.⁵

A sessão preenche duas peças que a sessão 279 descreveu pelo lado do código. O componente Navigation Mesh é a contraparte de autoria daquela API: uma caixa delimitadora Shapes seleciona qual geometria amostrar, as Off-Mesh Connections ligam regiões disjuntas, e Generation Parameters como o tamanho da célula controlam a resolução de amostragem. Uma vez criada, a malha alimenta uma Behavior Tree, um Animation Graph ou um sistema Swift personalizado.⁵ O Compute Graph constrói simulações de partículas de GPU apoiadas em Metal ao longo de quatro fases (Emitter, Initialize, Simulate, Output), e a fumaça do caldeirão usa uma força de gravidade negativa para que o vapor suba à deriva. O Shader Graph acrescenta o RealityKit PBR Surface 2 (sheen e subsurface scattering), uma superfície de cabelo dedicada e superfície e geometria de portal editáveis.⁵

Colaborando em modelos 3D estruturados

A última sessão é a recompensa, o que você constrói quando o motor e o editor são tão capazes assim. O visionOS 27 entrega um conjunto de ferramentas para revisão colaborativa de design, em que pessoas numa chamada do SharePlay manipulam a mesma montagem complexa, abrem-na, fazem um corte transversal e puxam peças para fora, na mesma fidelidade e no mesmo espaço.⁶

O alicerce é a estrutura, e o ponto mais afiado da sessão é que geometria sem hierarquia é inútil para o código. Um bloco de motor achatado na raiz renderiza bem, mas não oferece nada para agarrar ou animar, com os pistões enterrados numa lista plana de nomes do tipo InteriorPart_47. Uma hierarquia aninhada torna cada peça localizável, a precondição para todo o resto.⁶ Sobre essa hierarquia, a manipulação é uma decisão de posicionamento: ponha um ManipulationComponent na raiz e a montagem inteira se move como um único objeto; mova-o para os filhos (com InputTargetComponent e CollisionComponent ao lado, e releaseBehavior definido como .stay) e cada peça se torna individualmente agarrável enquanto o resto permanece no lugar. A formulação de Bill é o enunciado mais limpo da filosofia ECS nas cinco sessões: a passagem de “coisa para olhar” para “coisa para explorar” acontece inteiramente por causa de onde o componente mora na árvore.⁶

O recorte é a capacidade genuinamente nova do RealityKit. O ClippingComponent descarta a cada quadro a geometria fora de uma bounds alinhada aos eixos (shouldClipChildren assume false por padrão, a pegadinha comum; shouldClipSelf assume true), expondo o interior com a mesma facilidade que o exterior.⁶ O modelo de interação é deliberadamente enxuto: as seis faces da caixa delimitadora viram seis planos arrastáveis, cada um controlando um escalar. Fazer com que esses arrastes pareçam naturais é a lição de matemática da sessão: um delta de arraste é transformado do espaço do mundo para o quadro do modelo e então projetado sobre a normal do plano, de modo que a bounds muda apenas ao longo do eixo que você agarrou. A expansão automática usa a mesma honestidade estatística, computando uma variância de posição ponderada por volume ao longo de cada eixo e abrindo em leque as submontagens ao longo daquele de maior variância.⁶ A lição final de Bill é incomum para uma palestra de computação gráfica: fique à vontade com variância, projeção de vetores e transformações de quadro de coordenadas, porque as interações que parecem sem esforço são construídas sobre essa matemática.

Por onde começar

Adotar tudo de uma vez é o movimento errado. Sequencie pelo que destrava o resto.

1. Baixe primeiro o editor independente. O Reality Composer Pro 3 deixando o pacote do Xcode é a mudança da qual todo o resto do fluxo de trabalho depende; reimporte uma cena para ter em mãos a aba de simulação, os protótipos e a prévia de lightmap.³
2. Garanta o ciclo de iteração antes dos recursos. Acople a aba de simulação para criar enquanto a cena roda, e então conecte a prévia ao vivo no dispositivo a um Vision Pro. Avaliar o Physical Space Lighting ou sombras suaves numa tela plana de Mac vai enganar você.³²
3. Recorra aos recursos do RealityKit como componentes, não como reescritas. Sombras suaves, um lightmap pré-calculado e um SurroundingsLight num holofote são, cada um, um único componente ou propriedade, e cada um compra uma quantidade desproporcional de realismo.²
4. Adicione o plug-in do Xcode apenas quando os artistas precisarem dos seus dados. O registro do RealityComposerProPlugin justifica seu valor no momento em que um designer quer ajustar um componente personalizado ao vivo; até lá, componentes embutidos e o Script Graph cobrem bastante terreno.⁴⁵
5. Construa sobre a hierarquia para a revisão de design. O conjunto de ferramentas para modelos estruturados só funciona sobre um ativo bem aninhado, então conserte a hierarquia antes de escrever código de interação.⁶

O fio condutor das cinco sessões: o pipeline espacial deste ano recompensa a composição em vez da construção. O realismo é um componente que você anexa, a iteração é uma aba que você acopla, a colaboração é uma hierarquia que você respeita.

FAQ

O Reality Composer Pro 3 ainda faz parte do Xcode?

Não. O Reality Composer Pro 3 agora é um app independente que você baixa no site do desenvolvedor e abre pela sua pasta Aplicativos. Ele ainda se vincula a um projeto do Xcode para construir o app e carregar plug-ins, mas o editor roda de forma independente.³

Como funcionam as sombras suaves no RealityKit em 2026?

A propriedade lightSize de uma sombra é o diâmetro da luz em metros; o padrão 0 produz uma sombra dura, e um valor maior (a sessão usa 0,7) alarga a penumbra. Defina quality como média ou alta, já que baixa força uma sombra dura independentemente do tamanho da luz, com média recomendada a uma distância de visualização típica para administrar o custo.²

Posso rodar meu próprio código Swift dentro do editor do Reality Composer Pro?

Sim. Construa um plug-in que adote o protocolo RealityComposerProPlugin e registre seus componentes e sistemas no seu método setup; o editor roda esse código ao vivo, de modo que um artista ajusta uma propriedade e vê o sistema reagir sem reconstruir o app. Você pode anexar o depurador do Xcode para parar em breakpoints no código do plug-in. O recurso chega ainda em 2026.⁴

O que é o novo recurso de recorte no visionOS 27?

O ClippingComponent descarta a cada quadro qualquer geometria fora de uma caixa delimitadora alinhada aos eixos (bounds), deixando você ver através de uma montagem complexa até o seu interior. Note que shouldClipChildren assume false por padrão, então uma montagem pai não recorta seus filhos até que você o defina como true.⁶

Preciso escrever código para fazer um personagem animar e responder a toques?

Não. Os grafos visuais do Reality Composer Pro 3 dão conta: uma máquina de estados do Animation Graph mescla as animações de idle e walk, uma Behavior Tree sequencia a rotina e a condiciona a um booleano, e um Script Graph conecta um nó On Tap para alternar esse booleano, tudo criado sem um ciclo de build.⁵

O cluster completo da série Apple Ecosystem: o modelo mental espacial explicando por que o RealityKit é um entity-component-system em vez de SwiftUI em 3D; os padrões espaciais do visionOS para estruturar cenas e estilos de imersão; o que há de novo no visionOS 27 para os recursos de plataforma em torno dessas ferramentas; e a matriz de plataformas da Apple para como o RealityKit se implanta em visionOS, iOS, iPadOS, macOS e tvOS. O hub fica na Apple Ecosystem Series. Para um contexto mais amplo de iOS com agentes de IA, veja o guia de Desenvolvimento de Agentes para iOS.

Referências