Metal para machine learning em 2026

O M5 da Apple traz um novo bloco de hardware chamado neural accelerator, e ele não fica sobre a Neural Engine nem em algum coprocessador isolado. Ele fica dentro de cada GPU shader core, ao lado dos pipelines já existentes, construído para acelerar trabalho denso e limitado por computação, como o estágio de prefill de um LLM.¹ Essa localização é toda a história do Metal em 2026. A GPU que você usa para desenhar triângulos é agora a GPU que você usa para executar multiplicações de matrizes, e a Apple passou a WWDC26 entregando aos desenvolvedores as APIs para usá-la diretamente. O Metal é uma superfície de computação de machine learning de primeira classe, e o enquadramento como framework gráfico já não dá conta do que ele faz.

Por anos, a história do ML no dispositivo corria acima do Metal: o Core ML mirava a Neural Engine, o MLX envolvia a GPU em uma API de arrays com formato de NumPy, o MetalFX dava aos jogos um upscaler lacrado. O Metal em si era o substrato sobre o qual esses frameworks se apoiavam, não uma camada que a maioria dos desenvolvedores de ML programava. A WWDC26 mudou a altitude. A Apple lançou uma API de Metal Shading Language para matemática de tensores, tornou kernels personalizados plugáveis no Core AI e mostrou redes neurais rodando inline dentro de shaders. As razões para descer ao nível do Metal agora são concretas o bastante para serem nomeadas.

TL;DR

• O neural accelerator do M5 é um novo bloco de hardware localizado dentro de cada GPU shader core, projetado para acelerar trabalho denso e limitado por computação, como o prefill de um LLM.¹
• O TensorOps é uma API de Metal Shading Language que acelera operações de tensor (multiplicação de matrizes, convolução) na GPU e usa automaticamente a aceleração de hardware disponível em todas as gerações de Apple silicon.¹
• Os Metal tensors suportam tipos de dados quantizados nativamente: inteiros de 4 e 8 bits na atualização do macOS e do iOS 26, com tipos de ponto flutuante de 4 e 8 bits e inteiros de 2 bits, além de fatores de escala por bloco E8M0, chegando no macOS e no iOS 27.¹
• O neural rendering abrange três níveis no Metal 4: o denoising do MetalFX como uma caixa-preta, o ML command encoder para modelos treinados no seu command buffer e o TensorOps para redes minúsculas construídas diretamente em um shader.²
• O MLX Swift mantém o caminho de alto nível para computação numérica: código de arrays que se lê como a matemática, avaliação preguiçosa, diferenciação automática e execução na GPU por padrão.⁴
• Novas ferramentas de desempenho (coleta de traces retroativos, metalperftrace e a StateReporting API) fecham o ciclo de medir tudo isso ao longo de sessões longas.³

Metal tensors e kernels de ML personalizados

A Apple descreve a pilha de ML como camadas: Core AI e MLX no topo, para implantação com código mínimo; Metal Performance Shaders abaixo, para kernels de alto desempenho; e, sob tudo isso, os Metal Performance Primitives e a biblioteca TensorOps fazendo a aceleração de baixo nível.¹ Você desce ao nível do Metal por uma razão específica. A pesquisa em ML avança rápido, então talvez você implemente uma operação personalizada que se pluga em um framework de mais alto nível como o Core AI. Talvez você esteja contribuindo para um framework como o MLX ou o llama.cpp. Ou talvez esteja escrevendo um aplicativo baseado em Metal que precisa da operação inline.¹

Shiyao, da Apple, sobre o neural accelerator do M5: um bloco de hardware dentro de cada shader core, construído para trabalho denso e limitado por computação, como o prefill de um LLM (WWDC26, sessão 330).

O TensorOps é uma API de Metal Shading Language que acelera operações de tensor na GPU, entre elas multiplicação de matrizes e convolução, e tira pleno proveito do neural accelerator do M5 sem que você precise escrever código específico para cada geração.¹ A biblioteca lê o hardware disponível e o usa. Essa portabilidade é justamente o sentido de trabalhar através do TensorOps em vez de escrever à mão matemática de SIMD-group contra uma GPU específica.

A adição mais prática de 2026 é a quantização nativa. Os modelos continuam crescendo, a inferência costuma ser limitada pela largura de banda de memória, então comprimir os pesos tanto faz caber mais modelo na memória quanto economiza largura de banda.¹ O movimento padrão: pegar pesos de meia precisão de 16 bits, reduzi-los para 4 bits e parear os valores quantizados com fatores de escala que os mapeiam de volta para a faixa no momento da computação.¹ O TensorOps agora lida com tipos de dados quantizados nativamente. A atualização do macOS e do iOS 26 acrescentou tipos inteiros de 4 e 8 bits; o macOS e o iOS 27 estendem isso para tipos de ponto flutuante de 4 e 8 bits e inteiros de 2 bits.¹ Você cria um tensor quantizado quase exatamente como um comum: preenche as propriedades do descritor, especifica um dataType quantizado e chama newTensorWithDescriptor no seu Metal device.¹

Os fatores de escala também ganham um lar bem organizado. No macOS e no iOS 27, um único MTLTensor pode carregar suas escalas ao lado dos dados quantizados como um plano de escala adicional, suportando o formato de fatores de escala por bloco FP8 E8M0, em que cada elemento de escala se aplica a um bloco de elementos de dados.¹ Você monta um descritor para o plano de escala, define seu dataType e os fatores de bloco e anexa um mapa de plano auxiliar ao descritor original do tensor; dados quantizados, escalas e metadados se empacotam em um único objeto de tensor.¹ Em um kernel, você declara o plano de escala (por exemplo, fp8_e8m0 com um tamanho de bloco de 32 por 1, de modo que cada 32 elementos de dados compartilhem uma escala), declara o tipo completo do tensor, configura um matmul2d_descriptor com os tamanhos de tile, cria uma operação matmul2d, passa os tensors quantizados, e o TensorOps cuida da dequantização para você.¹

Quando você precisa de um formato de quantização personalizado que a biblioteca não conhece, dequantize diretamente em um cooperative tensor e o passe para a operação matmul2d. Os cooperative tensors distribuem seu armazenamento pela memória privada das threads que participam do matmul, então os dados ficam nos registradores e você evita a ida e volta pela memória de threadgroup.¹

O exemplo de destaque na sessão 330 é o FlashAttention, o kernel de attention fundido no núcleo de todo transformer. A attention multiplica Q por K, calcula SoftMax sobre as linhas da matriz intermediária e então multiplica por V; o FlashAttention funde os três em um único kernel.¹ Você usa o escopo de operação execution_simdgroup para que cada SIMD group seja dono de linhas completas da matriz intermediária e possa calcular SoftMax sem trocar dados entre grupos, armazena a matriz intermediária em um cooperative tensor e calcula as reduções de linha com reduce_rows.¹ A melhoria de 2026 que mais importa: no macOS 26 você tinha de armazenar o cooperative tensor na memória de threadgroup antes do segundo matmul, mas agora você o alimenta diretamente via get_left_input_cooperative_tensor depois de uma verificação de layout is_compatible_as_left.¹ Se a verificação falhar, você recorre à ida e volta pela threadgroup; de um jeito ou de outro, o op.run é idêntico.¹

A Apple fechou o ciclo integrando esse kernel personalizado a um modelo real. O Core AI converte modelos PyTorch e suporta kernels Metal personalizados, então a equipe definiu o corpo do FlashAttention como uma string em Python, registrou um TorchMetalKernel, substituiu a attention padrão da Hugging Face por uma que chama o kernel e exportou um modelo de segmentação de imagem SAM 3 do PyTorch como um asset otimizado do Core AI, que segmentou corretamente um carro em uma imagem de teste.¹ Esse é o caminho de um kernel de GPU escrito à mão até um modelo pronto para entrega.

Neural rendering em tempo real

A segunda frente é a renderização. Muitas técnicas que historicamente usavam métodos analíticos, incluindo neural denoising, neural textures e tone mapping aprendido, agora podem rodar como machine learning em qualquer estágio do pipeline para melhorar qualidade, desempenho ou consumo de memória.² O Metal 4 oferece três níveis de controle, e o nível que você escolhe é uma troca deliberada.

Yulia, da Apple, percorre os três níveis de ML em um pipeline de renderização do Metal 4, do MetalFX às redes TensorOps rodando no neural accelerator do M5 e do A19 Pro (WWDC26, sessão 359).

No nível mais alto, o MetalFX oferece um denoiser e upscaler neural pronto para uso como uma caixa-preta totalmente integrada, projetado para as exigências de baixa latência de uma viewport ao vivo.² Em um path tracer, o seu orçamento de frame pode permitir uma amostra por pixel para manter a interatividade, e uma amostra é ruidosa. O MetalFX pega esse frame ruidoso mais entradas auxiliares (diffuse albedo, depth e algumas outras) e produz uma imagem limpa, quase final, usando técnicas espaciais e temporais.² O Redshift Live da Maxon, um path tracer em tempo real no Cinema 4D, o adota, e a Apple destilou a integração em três boas práticas: mantenha suas entradas auxiliares livres de ruído (o diffuse albedo é o sinal de denoising mais forte), armazene aquilo que o espectador realmente vê (primary surface replacement para espelhos, albedo mesclado por Fresnel para vidro) e acerte seus motion vectors (o MetalFX espera motion vectors sem jitter, ou as bordas tremulam).²

O nível intermediário é o ML command encoder do Metal 4, que roda um modelo pré-treinado diretamente no seu command buffer, sem troca de contexto.² O exemplo trabalhado pela Apple é o tone mapping neural. A cadeia de pós-processamento de um renderizador (tone mapping, color grade, emulação de filme) cresce arbitrariamente complexa, e uma rede neural consegue aprender a transformação inteira. Você treina uma rede como a HDRNet (uma arquitetura de 2017 de Gharbi e colegas) no PyTorch, a exporta para um MTLPackage, a carrega com um function descriptor e um machine learning pipeline descriptor e então a dispara com uma argument table.² O tone mapper neural então substitui toda a cadeia de pós-processamento em múltiplos estágios por uma única avaliação neural, codificada no mesmo command buffer ao lado do path tracer e do MetalFX, executando no mesmo frame.²

O nível mais profundo é o TensorOps dentro de um shader, a mesma biblioteca da sessão 330, mas usada para construir redes minúsculas de alguns milhares de parâmetros ou menos, treinadas em uma única cena e sem a intenção de generalizar.² Como a rede cabe inline entre suas instruções de ALU e de amostragem de textura, ela viabiliza o treinamento online: um modelo que se adapta a cada frame às condições mutáveis do mundo. O exemplo da Apple é uma sky probe para image-based lighting, em que um ciclo dinâmico de dia e noite faz um sinal de iluminação pré-computado ficar desatualizado. A solução é um MLP totalmente conectado, uma rede 3-4-4-3 que recebe uma direção como três floats e retorna a iluminação como uma cor, avaliada para frente no shader e treinada online com uma passagem de backpropagation a cada frame.² Usando o escopo de execução de SIMD-group, todas as threads participantes trabalham na mesma multiplicação de matrizes e ganham cooperative tensors cujo armazenamento se espalha pelas threads, então você faz matmul2d por cada camada, aplica as ativações no local e lê a saída ali mesmo no shader sem uma ida e volta à memória principal. Esse é o mesmo caminho do neural accelerator da sessão 330, agora alimentando um pixel.²

Medindo tudo isso: ferramentas de desempenho

Rodar ML na GPU significa disputar os mesmos ciclos, a mesma largura de banda e o mesmo orçamento térmico de que sua renderização precisa, então a medição deixa de ser opcional. A sessão 388 trata de sessões longas de jogo, mas as ferramentas se aplicam a qualquer carga de trabalho Metal, ML incluído, porque uma queda na taxa de quadros durante uma passagem de tone mapping neural se parece exatamente com qualquer outro travamento de GPU até que você consiga ver o que o app estava fazendo.³

Ruiwei, da Apple, sobre o sistema que registra métricas de desempenho do Metal em segundo plano o tempo todo, de modo que você possa olhar horas para trás e coletar um trace depois que a sessão termina (WWDC26, sessão 388).

A mudança principal no iOS e no macOS 27: o sistema sempre registra métricas de desempenho e de recursos do Metal em segundo plano, armazenando dados agregados e dados opcionais por frame (CPU, GPU, FPS, memória) por dias.³ Você coleta depois do fato. No macOS, metalperftrace collect --last 5h extrai um trace das últimas cinco horas; no iOS, uma configuração única adiciona um botão de Performance Trace à Central de Controle, que processa um trace retroativo sob demanda.³ Você analisa com metalperftrace overview, e --json emite uma saída estruturada que você pode alimentar a um script de regressão ou entregar a um agente de IA para triagem; o Instruments plota tudo em uma linha do tempo e sinaliza com cores as estatísticas que destoam.³

A peça que torna um gráfico bruto de FPS acionável é a StateReporting API, disponível em Swift e Objective-C.³ Você define domínios, cada um uma máquina de estados finita para uma área de funcionalidade ortogonal, e reporta transições com um rótulo, além de metadados estáveis opcionais e metadados voláteis por estado.³ Para um app pesado em ML, você poderia rodar um domínio que rastreia qual passagem neural está ativa, de modo que, quando o tempo de frame disparar, você possa pedir ao metalperftrace para agregar o FPS de um rótulo de estado específico e ver diretamente que, digamos, a passagem de tone mapping é o custo.³ A ressalva da Apple: mantenha as transições na cadência das ações do usuário ou mais lentas, porque o sistema limita o reporte de alta frequência e você perde dados.³ Depois da entrega, o MetricKit no iOS e no macOS 27 expõe a informação de taxa de quadros do Metal detalhada pelos seus estados de StateReporting, entregue como relatórios diários dos dispositivos.³

MLX: o caminho de alto nível permanece

Nem todo desenvolvedor de ML quer escrever kernels de GPU, e a Apple não empurrou todo mundo para baixo. O MLX Swift continua sendo a camada expressiva para computação numérica e de arrays no Apple silicon, e a sessão 328 é um argumento claro para ficar nela quando você puder.⁴

David Koski, da Apple, sobre onde o MLX Swift se encaixa entre Accelerate, BNNS, Metal Performance Shaders e Swift Numerics (WWDC26, sessão 328).

O MLX usa arrays n-dimensionais como sua abstração central, como o NumPy, então a maior parte do código NumPy se traduz com mudanças mínimas, e o código se lê como a matemática que você está implementando.⁴ Duas propriedades sustentam o framework: a avaliação preguiçosa, em que as operações constroem um grafo de computação que só roda quando você chama eval ou lê um valor, e as transformações de função que a avaliação preguiçosa torna possíveis, incluindo grad para diferenciação automática.⁴ Por padrão, a GPU executa o trabalho, e o enquadramento da Apple é que um ganho de 10x sobre um loop escalar de CPU é certamente possível, a depender do algoritmo.⁴ A sessão 328 defende isso com três exemplos: o conjunto de Mandelbrot como um loop de duas linhas sobre uma grade inteira de números complexos, um solucionador de distribuição de calor em que uma única chamada conv2d aplica o stencil de Jacobi por toda a grade e um ajuste de curva em que grad deriva o gradiente exato sem derivadas escritas à mão.⁴ O MLX entrega o kit completo além disso e é open source sob licença MIT, com front-ends em Swift, Python, C++ e C compartilhando os mesmos conceitos, então você pode prototipar em Python e entregar em Swift.⁴

Como isso se relaciona com Core AI, Core ML e MLX

As quatro sessões descrevem uma mesma pilha em altitudes diferentes, e o modelo mental certo é uma escada.

• Core AI e Core ML são a camada de implantação. Você converte um modelo treinado e o executa, e a Apple cuida da aceleração. O suporte do Core AI a kernels Metal personalizados é a ponte: o kernel de FlashAttention da sessão 330 se pluga em um modelo Core AI, então uma otimização no nível do Metal alcança uma implantação de alto nível sem reescrita.¹
• O MLX é a camada de computação de arrays e de pesquisa, onde você escreve Swift com formato de matemática, ganha autodiff e execução na GPU de graça e roda ou faz fine-tuning dos seus próprios modelos. É a camada por onde a maior parte do trabalho de ML deveria começar.⁴
• Metal Performance Shaders e TensorOps são a camada de kernel. Você desce aqui quando precisa de uma operação personalizada, quando está construindo um framework como o próprio MLX ou quando a rede precisa rodar inline em um shader. A camada de kernel expõe o neural accelerator de forma mais direta.¹

O substrato de hardware une as camadas. O neural accelerator vive no GPU shader core, e o Metal é como você alcança a GPU, então cada camada acima acaba cavalgando o mesmo silício sobre a arquitetura de memória unificada e baseada em tiles da Apple. Escolher uma camada é o mesmo julgamento da decisão entre MLX e Foundation Models: só desça quando você puder nomear a capacidade que a camada acima não dá, porque cada degrau para baixo troca conveniência por controle.

Perguntas frequentes

O que é o neural accelerator do M5?

O neural accelerator é um novo bloco de hardware na família de chips M5, localizado diretamente dentro de cada GPU shader core, ao lado dos demais pipelines da GPU.¹ A Apple o projetou para acelerar trabalho denso e limitado por computação, como o estágio de prefill de um LLM, e a biblioteca TensorOps o usa automaticamente quando ele está presente.¹ A Apple também mencionou o neural accelerator na GPU do A19 Pro na sessão de neural rendering.²

Quais tipos de dados quantizados os Metal tensors suportam?

A atualização do macOS e do iOS 26 acrescentou tipos inteiros de 4 e 8 bits.¹ No macOS e no iOS 27, o TensorOps estende o suporte a tipos de ponto flutuante de 4 e 8 bits e tipos inteiros de 2 bits, além de fatores de escala por bloco FP8 E8M0 carregados no plano de escala de um tensor.¹ A Apple observa que esses tipos menores trazem requisitos adicionais de alinhamento, então consulte a documentação do Metal antes de adotá-los.¹

Quais são os três níveis de neural rendering no Metal 4?

O MetalFX é o nível mais alto, um denoiser e upscaler neural de caixa-preta pronto para uso.² O ML command encoder do Metal 4 é o nível intermediário, rodando um modelo pré-treinado exportado para um MTLPackage diretamente no seu command buffer.² O TensorOps é o nível mais profundo, permitindo que você construa redes minúsculas dentro de um shader, incluindo treinamento online que adapta um modelo a cada frame.²

Quando devo usar o MLX em vez de escrever kernels Metal?

Use o MLX Swift quando seu objetivo for código numérico ou de arrays expressivo com bom desempenho, em que o código deve se ler como a matemática e você quer autodiff e execução na GPU por padrão.⁴ Desça para o TensorOps e os kernels Metal quando precisar de uma operação personalizada que o MLX ou o Core AI não oferecem, quando estiver contribuindo para um framework de ML ou quando a rede precisar rodar inline em um shader.¹

Como meço o desempenho de ML na GPU em 2026?

No iOS e no macOS 27, o sistema sempre registra métricas de desempenho do Metal em segundo plano, então você coleta um trace retroativo depois do fato com metalperftrace collect --last <duration> no macOS ou com o botão Performance Trace da Central de Controle no iOS.³ Analise com metalperftrace overview (com --json para scripting) ou com o Instruments, e adicione a StateReporting API para rotular o que seu app estava fazendo, de modo que você possa atribuir as lentidões a uma passagem específica.³

O cluster do Apple Ecosystem continua: MLX no Apple Silicon para o caminho do framework de arrays, Apple Silicon TBDR para o substrato de GPU sob tudo isso, Core AI para rodar modelos no dispositivo e inferência no dispositivo com Core ML para a pilha de ML mais ampla. O hub da série é a Apple Ecosystem Series, e, para construir recursos agênticos sobre essa base, veja o guia de iOS Agent Development.

Referências