Pular para o conteúdo
SEGUNDA-FEIRA, NOVEMBRO 16, 2026NOTÍCIAS DE TECNOLOGIA INDEPENDENTES, ANÁLISES & GUIAS PRÁTICOS
SOBRE
ÚLTIMAS /

Agent Skills e servidores MCP explicados: como instalar, atualizar e corrigir no OpenCode, Claude Code, Codex e outros agentes de IA

LEIA O GUIA
AGENTES DE IAGM / 981

Apple Container 1.0 e a onda de ferramentas de desenvolvedor de 2026: máquinas de contêiner, Docker Sandboxes, Podman 6 e os grandes lançamentos do ano

O Apple container 1.0 roda cada contêiner Linux na própria VM no Mac. Guia de configuração, guia rápido de Docker, comparações e os lançamentos dev de 2026.

Apple Container 1.0 and the 2026 developer tool wave: featured card comparing one shared Linux VM with one VM per container

O Apple container 1.0 é a coisa mais interessante que a Apple lançou para desenvolvedores em anos, e a maioria das pessoas fora do meio dos contêineres não percebeu. Lançado em 9 de junho de 2026, na semana da WWDC, ele roda cada contêiner Linux na própria máquina virtual leve no seu Mac, fala imagens OCI padrão e traz uma ideia nova chamada máquinas de contêiner: ambientes Linux persistentes que compartilham seu nome de usuário e seu diretório home, mais ou menos como o WSL faz no Windows. Cinco meses e oito versões depois, ele está na versão 1.5.0, com um plugin de Kubernetes, uma versão com correções de segurança e um arquivo de skill oficial para agentes de codificação com IA no repositório.

Ele não chegou sozinho. 2026 tem sido um ano excepcionalmente denso para ferramentas de desenvolvedor. O Docker se reconstruiu em torno de sandboxes de microVM para agentes de IA. O Podman 6 arrancou uma década de redes legadas. O macOS 27 abandonou o Intel, e o Homebrew marcou uma data para seguir o mesmo caminho. O Python 3.15 tornou o UTF-8 o padrão, o TypeScript 7 reescreveu seu compilador em Go, o Bun se reescreveu em Rust com uma IA fazendo a maior parte da digitação, e o PostgreSQL 19 fez algo que quase ninguém faz mais: adiou o lançamento de propósito, para acertar as coisas.

Este guia cobre as duas metades dessa história. A primeira metade é um mergulho prático na ferramenta de contêineres da Apple: o que ela é, como funciona, o que mudou entre a 1.0 e a 1.5, como instalar e usar passo a passo, como traduzir seus hábitos com Docker, como ela se compara ao Docker Desktop, ao OrbStack, ao Podman e ao Lima, e onde ela se encaixa se você roda modelos de IA ou agentes de IA em um Mac. A segunda metade é um radar de lançamentos das outras novidades de 2026 no mesmo espírito, o que cada uma muda e o que você deve realmente fazer a respeito.

Todo número de versão, data e preço abaixo foi conferido nas notas de versão, na documentação oficial e nas páginas dos fabricantes em 12 de novembro de 2026. As ferramentas de desenvolvedor andam rápido: uma versão que é atual hoje pode estar duas versões atrás quando você ler isto, então os números voláteis aparecem datados onde surgem.

Divulgação: Este artigo não contém links de afiliado e nenhum conteúdo patrocinado. Minha empresa, Graham Miranda UG (haftungsbeschränkt), oferece hospedagem e serviços de TI e não ganha nada com nenhuma ferramenta, assinatura ou empresa mencionada aqui. Nenhuma empresa mencionada aqui revisou ou aprovou este artigo.


Resumo rápido — Apple Container 1.0 e os lançamentos para desenvolvedores de 2026 em dez pontos

  • O Apple container 1.0 foi lançado em 9 de junho de 2026. Ele roda cada contêiner Linux na própria VM leve, usando o pacote Conteinerização Swift de código aberto da Apple. Ele baixa e envia imagens OCI padrão e tem licença Apache-2.0. Ele precisa de um Mac com Apple silicon e tem suporte no macOS 26. A versão atual é a 1.5.0 (29 de setembro).
  • As máquinas de contêiner são o destaque principal. Um único comando entrega a você um ambiente Linux persistente que inicializa o sistema init da imagem e mapeia seu nome de usuário e seu diretório home do Mac para dentro do Linux, então você edita no macOS e compila dentro do Linux sem nenhuma etapa de cópia. É o mais perto que o Mac já chegou do WSL.
  • Desde a 1.0, a Apple adicionou um experimental plugin k8s de contêiner que cria clusters Kubernetes locais, exportação de contêiner, encaminhamento SSH para builds, uma versão de segurança que corrigiu seis avisos, e um skill de agente oficial que ensina agentes de codificação com IA a usar a ferramenta em vez do Docker.
  • O que ele ainda não consegue fazer: não há Compose, nem --restart política de reinício, nem interface gráfica, nem acesso à GPU para contêineres Linux, os nomes de contêiner só resolvem na rede padrão, e a memória liberada dentro de um contêiner não é devolvida ao macOS. Para pilhas com vários serviços, o Docker Desktop e o OrbStack continuam sendo os melhores para o uso diário.
  • O ano do Docker foi sobre agentes de IA. As Hardened Images passaram a ser gratuitas e de código aberto (dezembro de 2025), Docker Sandboxes dão a cada agente de codificação sua própria microVM (janeiro), Cloud Sandboxes as movem para a nuvem do Docker (setembro), e o Model Runner roda LLMs locais na GPU do host, porque contêineres em um Mac não enxergam o Metal.
  • Podman 6 (junho) removeu cgroups v1, CNI, slirp4netns, BoltDB e o suporte a Macs Intel, e tornou o libkrun o padrão no macOS, que também é o único caminho convencional para inferência em GPU quase nativa dentro de um contêiner no Mac. OrbStack 2.2 adicionou passthrough de USB; Lima 2.x se transformou em um sandbox para agentes de IA.
  • A plataforma mudou debaixo dos pés de todo mundo. macOS 27 Golden Gate (14 de setembro) roda apenas em Apple silicon; Xcode 27 exige macOS Tahoe 26.6 e traz o Swift 6.4 com planejamento de agentes integrado; Homebrew 7 moveu os Macs Intel para o Tier 3 e para de rodar neles em 1º de setembro de 2027; Linux 7.0 e Ubuntu 26.04 LTS chegaram em abril.
  • Linguagens e runtimes: Python 3.15 (imports preguiçosos, UTF-8 por padrão, um JIT mais rápido), TypeScript 7 (compilador reescrito em Go, builds 8–12× mais rápidos), Node.js 26 LTS (Temporal ativado por padrão), Go 1.27 (métodos genéricos, JSON v2), .NET 11 (tipos union do C# 15), Vite 8 (Rolldown) e Bun 1.4 (reescrito de Zig para Rust).
  • Seis padrões explicam essa onda: a máquina virtual virou a nova fronteira do contêiner; a Intel está saindo da cadeia de ferramentas do Mac; ferramentas estão sendo reescritas em linguagens nativas em busca de velocidade; a IA agora é ao mesmo tempo construtora e caçadora de bugs; os padrões de segurança ficaram mais rígidos; e os trens de lançamento estão desacelerando para dar suporte às versões por mais tempo.
  • O que fazer agora: se você está em Apple silicon e macOS 26 ou posterior, teste uma máquina de contêiner esta semana; mantenha o Docker Desktop ou o OrbStack para stacks do Compose; coloque seus agentes de codificação com IA em um sandbox; teste Python 3.15, TypeScript 7 e Node 26 em um branch antes de trocar; e planeje a aposentadoria de qualquer Mac com Intel antes de setembro de 2027.

O radar de lançamentos para desenvolvedores de 2026 em resumo

Versão Lançado em O que mudou Para quem importa
Apple container 1.0 → 1.5 9 jun → 29 set 2026 Uma VM por contêiner Linux, máquinas de contêiner, Kubernetes local Desenvolvedores Mac em Apple silicon
Docker Sandboxes / Cloud Sandboxes 30 jan / 24 set 2026 Uma microVM descartável para cada agente de codificação com IA Quem roda agentes de codificação sem supervisão
Docker Hardened Images, grátis 17 dez 2025 Mais de 1.000 imagens mínimas e assinadas sob Apache 2.0 Quem publica imagens de contêiner
Podman 6.0 final de jun 2026 cgroups v1, CNI e slirp4netns removidos; libkrun como padrão no macOS Usuários de Podman, ambientes Fedora e RHEL
OrbStack 2.1–2.2 abr–out 2026 Máquinas isoladas, passthrough de USB, som Desenvolvedores Mac que querem velocidade e uma GUI
Lima 2.0–2.2 nov 2025–jul 2026 Sandbox de agentes de IA, convidados macOS e Windows Usuários de Lima e Colima, criadores de agentes
macOS 27 Golden Gate 14 set 2026 Somente Apple silicon; o último Rosetta 2 completo Todo desenvolvedor Mac
Xcode 27 + Swift 6.4 14 set 2026 Planos de agente, Device Hub; exige Tahoe 26.6+ Desenvolvedores da plataforma Apple
Swift 6.3 24 mar 2026 SDK oficial do Android, @c Interop com C Equipes Swift multiplataforma
Linux 7.0 12 abr 2026 Rust não é mais experimental; XFS com autorrecuperação Servidores e hosts de contêiner
Ubuntu 26.04 LTS 23 abr 2026 sudo-rs, coreutils em Rust, CUDA no repositório Servidores, runners de CI, usuários de WSL
Homebrew 6.0 e 7.0 11 jun / 13 set 2026 Confiança em taps, brew vulns, BrewUI, Intel para o Tier 3 Todo usuário de linha de comando no Mac
Python 3.15 9 out 2026 Importações tardias, UTF-8 como padrão, JIT mais rápido desenvolvedores Python
TypeScript 7.0 8 jul 2026 Compilador em Go, compilações completas 8–12× mais rápidas Equipes de JavaScript e TypeScript
Node.js 26 LTS “Lithium” LTS 28 out 2026 Temporal ativado por padrão; última major semestral Backends Node.js
Go 1.27 19 ago 2026 Métodos genéricos, JSON v2, TLS pós-quântico Serviços Go
.NET 11 10–12 nov 2026 tipos union do C# 15; .NET 8 e 9 fora de suporte Empresas que usam .NET
Bun 1.4 Ago. de 2026 Reescrito de Zig para Rust, em grande parte por agentes de IA Usuários do Bun e céticos da codificação com IA
Vite 8 12 de mar. de 2026 Rolldown substitui o esbuild e o Rollup Equipes de front-end
Kubernetes 1.36 / 1.37 22 de abr. / 26 de ago. de 2026 Namespaces de usuário em GA; 67 aprimoramentos na 1.37 Equipes de plataforma
PostgreSQL 19 RC1 em 15 de out.; GA previsto para 19 de nov. de 2026 Adiado, com 53 recursos revertidos por questão de qualidade Responsáveis por bancos de dados
Zed 1.0 fim de abril de 2026 O editor feito em Rust chega à 1.0 em três plataformas Quem troca de editor

As datas referem-se às primeiras versões estáveis, salvo indicação em contrário. As versões mudam rápido: Apple container, OrbStack, Zed e Python lançaram versões pontuais desde então. Cada figura é creditada onde aparece.


Índice


Parte 1 — O que é o Apple Container 1.0 e por que ele é diferente

Contêineres são um recurso do Linux. Um contêiner é apenas um conjunto de processos Linux comuns, isolados de todo o resto por recursos do kernel chamados namespaces e cgroups, e iniciados a partir de uma imagem que guarda seus arquivos. O macOS não é Linux, então toda ferramenta que roda contêineres Linux em um Mac precisa rodar uma máquina virtual Linux em algum lugar. A pergunta interessante é quantas.

Uma VM para tudo, ou uma VM por contêiner

Docker Desktop, OrbStack, Podman’s machine e Colima todas seguem a abordagem clássica: elas iniciam uma máquina virtual Linux e rodam todos os seus contêineres dentro dela, lado a lado no mesmo kernel Linux. Isso é eficiente, é rápido iniciar um contêiner depois que a VM já está rodando, e é assim que os contêineres funcionam também em um servidor Linux. O problema é que o isolamento entre contêineres é tão forte quanto esse kernel compartilhado, e que a VM precisa conseguir enxergar todas as pastas que qualquer contêiner possa vir a precisar, porque é com a VM que o seu Mac compartilha arquivos.

Apple container inverte isso. Ele usa o pacote de código aberto da Apple Conteinerização pacote para iniciar uma VM leve separada para cada contêiner. A documentação da Apple lista três motivos:

  • Segurança. Cada contêiner ganha o isolamento de uma máquina virtual completa, com um conjunto mínimo de utilitários e bibliotecas essenciais dentro, o que reduz a superfície de ataque.
  • Privacidade. Você monta na VM daquele contêiner apenas os dados de que ele precisa. Com uma VM compartilhada, a VM precisa conseguir alcançar tudo o que qualquer contêiner possa vir a usar.
  • Desempenho. A Apple diz que essas VMs precisam de menos memória do que VMs completas e inicializam em tempos comparáveis aos de contêineres em uma VM compartilhada. Na WWDC26, ela descreveu as VMs leves como tendo tempos de inicialização abaixo de um segundo.

Todo o resto é padrão. O Apple container consome e produz imagens OCI, então ele baixa do Docker Hub, do registro de contêineres do GitHub ou de qualquer outro registro, compila a partir de Dockerfiles comuns e envia imagens que rodam em qualquer outro lugar.

Apple container 1.0 executa uma VM Linux leve por contêiner; Docker Desktop, OrbStack e Podman compartilham uma única VM Linux
As mesmas imagens OCI, um limite de isolamento diferente: com o Apple container, cada contêiner ganha seu próprio kernel e sua própria VM.

O que realmente roda no seu Mac

O Apple container é construído com as mesmas peças do macOS que a Apple usa em todo o resto, e isso é parte do motivo de ele parecer nativo:

  • O Virtualization framework executa as VMs Linux e seus dispositivos virtuais.
  • O vmnet framework fornece a rede virtual. Cada contêiner ganha seu próprio endereço IP (por padrão em 192.168.64.0/24), acessível a partir do seu Mac e, no macOS 26, a partir de outros contêineres.
  • XPC conecta a ferramenta de linha de comando aos seus serviços em segundo plano, launchd gerencia esses serviços, Keychain guarda suas senhas de registro, e o sistema unificado de logs coleta os logs.
  • Quando você executa container system start, um agente de inicialização chamado container-apiserver inicia, junto com auxiliares para imagens, a rede, as máquinas de contêiner e os clusters Kubernetes. Cada contêiner que você cria ganha seu próprio container-runtime-linux auxiliar.
  • O kernel Linux dentro de cada VM vem do Kata Containers projeto por padrão. O primeiro container system start oferece baixá-lo.

Por que o modelo de uma VM por contêiner importa agora

Durante anos, uma VM por contêiner soou como exagero para o notebook de um desenvolvedor. Duas coisas mudaram isso. Primeiro, o Apple silicon tornou as VMs leves baratas o suficiente para iniciar em menos de um segundo. Segundo, os desenvolvedores começaram a deixar agentes de codificação com IA executarem comandos e códigos que não leram. Mitch Ashley, do The Futurum Group, colocou a questão em termos de onde fica o limite de segurança: ele sai dos namespaces do kernel compartilhado e vai para o hipervisor, que é uma forma mais defensável de executar cargas de trabalho não confiáveis. Se um processo comprometido escapa de um contêiner em uma VM compartilhada, ele fica na VM junto com todos os seus outros contêineres. Se escapa de um contêiner Apple, fica em uma VM sem mais nada dentro.

As contrapartidas

Nada é de graça, e o design por contêiner tem custos reais:

  • Inicializações a frio. O Cloud Native Now citou benchmarks independentes nos quais o Docker Desktop iniciava contêineres cerca de quatro vezes mais rápido, enquanto o Apple container apresentava cerca de 33% mais vazão de memória. Trate os dois como indicativos: é um único conjunto de testes, o artigo não informou quem os executou, e ambas as ferramentas lançaram várias versões desde então.
  • I/O de arquivos pequenos. Como cada contêiner tem seu próprio sistema de arquivos, cargas de trabalho que mexem em dezenas de milhares de arquivos pequenos, como um grande npm install, podem parecer mais lentas do que em uma ferramenta madura de VM compartilhada.
  • A memória não é devolvida. O framework Virtualization só oferece suporte parcial ao memory ballooning. A VM de um contêiner cresce conforme o aplicativo usa memória, mas a memória liberada dentro do Linux não é devolvida ao macOS. A própria documentação da Apple sugere reiniciar de vez em quando os contêineres que consomem muita memória.
  • Somente macOS 26, somente Apple silicon. A Apple diz que a ferramenta é suportada no macOS 26 e que os mantenedores normalmente não corrigem problemas que não conseguem reproduzir ali. Ela até funciona no macOS 15, mas lá os contêineres não conseguem se comunicar entre si e você fica com apenas uma rede. Macs Intel não são suportados de jeito nenhum.

Parte 2 — Da 1.0 à 1.5: oito versões em menos de quatro meses

A Apple apresentou o container e o Containerization no WWDC25, em junho de 2025, e os publicou como código aberto. Veio então um ano de versões 0.x, cada uma com uma mudança que quebrava compatibilidade de vez em quando. A versão 1.0.0 chegou em 9 de junho de 2026, e a Apple manteve um ritmo constante desde então:

Versão Data Mudanças principais
1.0.0 9 jun 2026 container machine; container cp; --stop-signal e --shm-size; configuração movida para um arquivo TOML; saída JSON/YAML/TOML mais limpa; correção para endereços IP vazados
1.1.0 6 de jul. de 2026 Virtualização aninhada para container machines; montagens de socket Unix para contêineres não-root
1.2.0–1.2.2 29 de jul.–8 de ago. de 2026 Experimental plugin k8s de contêiner plugin para Kubernetes local; exportação de contêiner; build --ssh; caminhos somente leitura e mascarados; várias correções de endurecimento
1.3.0 24 de ago. de 2026 Kernel padrão do Kata atualizado para 3.32.0; operações de imagem usam HTTPS por padrão
1.3.1 29 de ago. de 2026 Versão de segurança corrigindo seis avisos no Containerization; o skill de agente oficial adicionado ao repositório
1.4.1 9 set 2026 container clean; container system status informa host, caminhos e recursos (a 1.4.0 nunca foi lançada)
1.5.0 29 de setembro de 2026 Correção para perda de acesso à rede após mudanças de DNS; CNI personalizado para clusters Kubernetes; k8s start removido por enquanto

Última versão em 12 de novembro de 2026: 1.5.0. A Apple observa que seus números de versão são versões de produto, não versões semânticas.

Histórico de lançamentos do Apple container, da apresentação na WWDC25 ao 1.0 em 9 de junho de 2026 e ao 1.5.0 em 29 de setembro de 2026
Do anúncio até a 1.0 passou-se um ano. Da 1.0 até a 1.5, menos de quatro meses.

O que a 1.0 quebrou, e por que você deve se importar se atualizou a partir da 0.x

A versão 1.0 foi o momento em que a Apple arrumou a casa, e três mudanças podem morder quem tem scripts:

  • A configuração passou para um arquivo TOML em ~/.config/container/config.toml. Os antigos container system property get e set subcomandos não existem mais.
  • A saída estruturada mudou. Se você faz parse do JSON de container ls ou inspect em scripts, verifique-as contra a 1.x.
  • A API de segundo plano abandonou a compatibilidade com clientes 0.x. Qualquer ferramenta de terceiros criada contra a API XPC 0.x precisa de atualização.

Desde a 1.0, a Apple diz que a interface de linha de comando em geral preserva a compatibilidade retroativa dentro de uma versão principal, com uma exceção que importa: recursos marcados experimental, como o subcomando do Kubernetes, podem mudar sem aviso.

A versão de segurança

Versão 1.3.1 corrigiu seis avisos no pacote Containerization. Em palavras simples: um ID de contêiner que não era verificado podia deixar a criação de contêiner apagar arquivos fora da própria pasta; digests de imagem não validados permitiam path traversal no armazenamento local de imagens; carregar um layout de imagem podia seguir um symlink e ler arquivos do seu Mac; o cliente de registry seguia um redirecionamento de autenticação sem verificar o host (CVE-2026-65388); e duas camadas de imagem malformadas podiam derrubar o descompactador. Nenhum desses é exótico. São exatamente o tipo de bug que você esperaria em uma ferramenta jovem que lida com imagens não confiáveis, e são um bom argumento para se manter atualizado. As versões 1.2 já tinham adicionado verificações de integridade para downloads de kernel e validação de IDs de contêiner e nomes de plugins, e a 1.5.0 corrigiu um problema de segurança no tratamento de kubeconfig do plugin do Kubernetes.

A Apple entrega uma skill para seu agente de codificação com IA

O detalhe mais 2026 de todo o projeto é um arquivo chamado skills/container/SKILL.md, adicionado na 1.3.1. É uma skill de agente: um conjunto de instruções que agentes de codificação com IA como Claude Code e Codex podem carregar quando a tarefa envolve contêineres. Ela diz ao agente que container substitui Docker, Lima, Colima e Podman em um Mac, dá a ele um mapa de comandos de Docker para container e o avisa sobre as armadilhas em que um modelo cairia: os grupos de comandos são no singular (container image ls, não container images), container build precisa de -t ou você fica com uma imagem nomeada por um UUID aleatório, não há Compose e não há --restart, e os nomes de contêiner só resolvem na rede padrão.

É um arquivo pequeno, mas diz algo sobre como a Apple espera que a ferramenta seja usada: cada vez menos por um desenvolvedor digitando comandos e cada vez mais por um agente digitando em nome dele. O guia rápido da Parte 5 usa o mesmo mapeamento.

O que vem a seguir

O branch principal do projeto já está renomeando o plugin k8s de contêiner subcomando experimental para container cluster e adicionando uma --shared-image-store opção que permite que os nós do cluster usem suas imagens locais sem um registry. A própria documentação da Apple avisa que, com o compartilhamento ativado, qualquer coisa com root em um nó pode ler todas as imagens do seu armazenamento local, incluindo imagens privadas que você baixou com suas credenciais de registry. Se você escreve scripts para o plugin Kubernetes hoje, espere que o nome mude em uma versão futura.


Parte 3 — Máquinas de contêiner: a resposta da Apple ao WSL

Um contêiner normal é modelado a partir de um aplicativo: um processo, geralmente de curta duração, descartado quando para. Uma container machine é modelada a partir de um ambiente Linux. A Apple o apresentou na 1.0 e lhe deu uma sessão própria na WWDC26, que o descreveu como rápido e leve como um contêiner, e persistente como uma máquina virtual.

O que uma máquina de contêiner oferece

  • Ela inicializa o sistema init da imagem, então serviços de longa duração funcionam. Em uma imagem com systemd, systemctl start postgresql faz o que você espera.
  • Seu nome de usuário e seu diretório home do Mac são mapeados para dentro. Dentro da máquina você é seu próprio usuário, não root, com sudosem senha, e a pasta home do seu Mac é montada no mesmo caminho. Seus repositórios e dotfiles existem dos dois lados ao mesmo tempo.
  • Seu diretório de trabalho acompanha você. Execute um comando a partir de uma pasta de projeto no seu Mac e ele roda na mesma pasta dentro do Linux.
  • Ela persiste. Pacotes que você instala, serviços que você configura e arquivos fora do seu diretório home sobrevivem a um stop e start.
  • Ela é construída a partir de imagens OCI comuns, inclusive as que você mesmo constrói com container build.

Na prática, isso significa que você edita no Xcode, no Zed ou no VS Code no macOS, e compila, executa e testa dentro do Linux, sem nenhuma etapa de cópia no meio. A demo da Apple na WWDC compilou um servidor web em Swift dentro de uma máquina, editou-o no Xcode no Mac e o carregou no Safari.

Como funcionam as máquinas do Apple container: seu usuário do Mac e sua pasta home mapeados em uma VM Linux persistente com sistema de init próprio
Uma máquina de contêiner é uma VM Linux persistente que pensa fazer parte do seu Mac: mesmo usuário, mesma pasta home, mesmo diretório de trabalho.

Os comandos

# Create a machine from an image and make it the default
container machine create alpine:latest --name dev
container machine set-default dev

# Run a single command, or open a shell (boots the machine if it's stopped)
container machine run uname -a
container machine run whoami        # your Mac username, not root
container machine run               # interactive shell

# Manage it
container machine ls
container machine inspect dev
container machine set -n dev cpus=4 memory=8G   # applies after the next stop/start
container machine stop dev
container machine rm dev            # deletes the machine AND its storage

Todo container machine comando também atende pelo alias curto m, então container m ls funciona. A memória padrão é metade da memória do seu Mac, o que é generoso; em uma máquina de 16 GB, defina um limite.

Traga sua própria imagem de máquina

Qualquer imagem Linux que contenha /sbin/init funciona. A documentação da Apple inclui um Dockerfile que transforma o Ubuntu 24.04 em uma systemd máquina completa com SSH e ferramentas comuns; a versão curta é assim:

FROM ubuntu:24.04
ENV container container
RUN apt-get update && \
    apt-get install -y dbus systemd openssh-server iproute2 curl sudo && \
    apt-get clean && rm -rf /var/lib/apt/lists/*
RUN systemctl set-default multi-user.target
container build -t local/ubuntu-machine:latest .
container machine create local/ubuntu-machine:latest --name ubuntu

O exemplo completo da Apple também mascara algumas systemd unidades que não fazem sentido em uma VM e redefine o ID da máquina; copie da documentação em vez daqui se você quiser systemd que ela inicie sem problemas. Na primeira inicialização, a ferramenta executa um script de configuração que cria seu usuário. Você pode substituí-lo pelo seu próprio script em /etc/machine/create-user.sh.

Virtualização aninhada

Desde a 1.1, uma máquina de contêiner pode rodar máquinas virtuais próprias, o que é útil para testar ferramentas baseadas em KVM ou para executar configurações de Kubernetes dentro de uma VM. Você precisa de um M3 ou mais recente Mac, macOS 15 ou mais recente, e de um kernel Linux compilado com suporte a KVM, porque o kernel padrão não o inclui. Você então cria a máquina com --virtualization --kernel /path/to/vmlinux-kvm e verifica se há /dev/kvm dentro dela.

As limitações que você precisa conhecer antes de se mudar

  • A máquina tem a própria rede. Os servidores dentro dela precisam escutar na interface externa da máquina, não apenas em localhost, e você os acessa pelo endereço IP da máquina, que o container machine list mostra.
  • Excluir uma máquina exclui o disco dela. Tudo que estiver fora da sua pasta home montada se perde depois de container machine rm.
  • É um ambiente de conveniência, não um sandbox. A documentação da Apple é explícita: uma máquina monta toda a sua pasta home em leitura e gravação no mesmo caminho, roda com todas as capacidades do Linux e sem os habituais /proc e /sys caminhos mascarados, e dá ao seu usuário acesso sem senha a sudo. O root dentro da máquina pode, portanto, gravar em qualquer lugar da sua pasta home com as suas permissões do macOS. É exatamente o que você quer para o seu próprio trabalho e exatamente o que você não quer para um agente de IA. Para um agente, crie uma máquina com --home-mount none (ou altere uma existente com container machine set -n dev home-mount=none, depois reinicie-a) e clone o projeto dentro dela, ou dispense as máquinas e use diretamente um container run com apenas a pasta do projeto montada. A Parte 8 volta a este assunto.
  • É Linux em Apple silicon, então binários somente x86 precisam do Rosetta (container run --rosetta existe para contêineres) ou de uma compilação arm64.

Quem deve usar uma

Se você desenvolve software de servidor que roda em Linux, testa em mais de uma distribuição ou executa serviços como PostgreSQL, Redis ou uma fila de mensagens para desenvolvimento local, as máquinas de contêiner substituem boa parte daquilo para que as pessoas usavam Lima, Multipass, UTM ou um VPS remoto. Crie uma máquina por distribuição-alvo (alpine, ubuntu, debian), mantenha a mesma pasta home em todas elas e teste seu código nas três sem sair do seu Mac.


Parte 4 — Como instalar e usar o Apple Container: passo a passo

Este é o caminho mais curto do zero até uma instalação funcionando, com os comandos da própria documentação da Apple para a versão 1.5.0. Tudo roda no Terminal.

Como instalar o Apple container passo a passo: verifique seu Mac, instale o pacote, inicie os serviços, execute e faça o build
A instalação inteira em uma página. Os passos 1 e 4 são os que costumam confundir.

Passo 1 — Verifique seu Mac

Você precisa de Apple silicon e, para funcionalidade completa, macOS 26 Tahoe ou mais recente. Ele também roda no macOS 27 Golden Gate.

uname -m               # must print arm64
sw_vers -productVersion  # 26.x or 27.x for full support

No macOS 15 Sequoia a ferramenta roda, mas os contêineres não conseguem se alcançar e você só tem uma rede. Em um Mac com Intel ela não roda de jeito nenhum; pule para a Parte 6 para ver as alternativas.

Passo 2 — Baixe o instalador assinado

Abra o página de releases do Apple container e baixe o pacote de instalação assinado (.pkg) anexado à versão mais recente, 1.5.0 no momento em que escrevo. A documentação da Apple descreve apenas este pacote como forma de instalação, então é esse que você deve usar.

Passo 3 — Instale

Dê um duplo clique no pacote, siga o instalador e digite sua senha de administrador quando for pedido. Ele instala tudo em /usr/local, incluindo dois scripts auxiliares que você vai precisar depois: update-container.sh e uninstall-container.sh.

Passo 4 — Inicie os serviços e instale um kernel

container system start

A primeira inicialização pergunta se você quer baixar o kernel Linux recomendado do projeto Kata Containers. Responda y. Depois verifique se está tudo no ar:

container system status    # host, paths and resources since 1.4.1
container system version
container ls -a            # an empty list means it's working

container system start inicia um launch agent, então você precisa rodar de novo depois de reiniciar. Se um comando falhar mais tarde com “Plugins indisponíveis. Inicie os serviços do sistema de contêineres e tente novamente”, confira primeiro a grafia do seu comando: a própria skill de agente da Apple avisa que um subcomando digitado errado gera exatamente essa mensagem, e só é um problema real de serviço se container system status também disser que o serviço está parado.

Passo 5 — Rode seus primeiros contêineres

container run --rm alpine echo hello      # baixa a imagem alpine, roda na própria VM e a remove
container run -it --rm ubuntu:24.04 bash  # um shell interativo; digite exit para sair

Por padrão, as imagens vêm do Docker Hub, então nomes curtos como alpine e postgres:16 funcionam como funcionam no Docker.

Passo 6 — Crie e rode sua própria imagem

Crie uma pasta com este Dockerfile (é o mesmo pequeno servidor web que o tutorial da Apple usa):

FROM docker.io/python:alpine
WORKDIR /content
RUN echo '<h1>Hello from Apple container</h1>' > index.html
CMD ["python3", "-m", "http.server", "80", "--bind", "0.0.0.0"]

Crie a imagem, rode e abra:

container build -t web-test .                       # sempre passe -t
container run -d --name web -p 8080:80 web-test     # em segundo plano, porta 8080 no seu Mac
open http://localhost:8080

Duas diferenças em relação ao Docker vale a pena conhecer de imediato. Primeiro, sempre marque suas builds: sem -t, a imagem recebe um UUID recém-gerado como nome. Segundo, cada contêiner tem seu próprio endereço IP. container ls mostra isso, e você pode abrir http://<that-ip> sem publicar nenhuma porta; -p só é necessário quando você quer o conhecido localhost:8080 ou quando um aplicativo do macOS espera uma porta local.

Passo 7 — Dê nomes amigáveis aos contêineres (opcional)

O Apple container tem um serviço DNS embutido. Defina um domínio local uma vez e cada contêiner fica acessível como <name>.<domain>:

mkdir -p ~/.config/container
printf '[dns]\ndomain = "test"\n' >> ~/.config/container/config.toml   # edite a tabela [dns] se o arquivo já tiver uma
container system stop && container system start
sudo container system dns create test
open http://web.test

Os nomes só são resolvidos para contêineres na default rede e sempre com o domínio: web.test funciona, mas um web não. Contêineres em uma rede que você criou com container network create não conseguem se resolver por nome de jeito nenhum no momento (registrado como issue #1809); use essas redes para isolamento e conecte por IP.

Passo 8 — Mantenha os dados e defina limites

# Monte a pasta atual via bind-mount
container run -it --rm -v "$PWD":/app -w /app node:22 bash

# Um volume nomeado para um banco de dados, com limites de CPU e memória
container volume create pgdata
container run -d --name db --cpus 2 --memory 2g \
  -e POSTGRES_PASSWORD=change-me \
  -v pgdata:/var/lib/postgresql/data \
  postgres:16

Defina --memory em qualquer coisa de longa duração. Como a memória liberada dentro da VM de um contêiner não é devolvida ao macOS, um contêiner sem limite que um dia chegou ao pico continua com essa memória até você reiniciá-lo.

Passo 9 — Alcance um serviço rodando no seu Mac

Contêineres não podem usar localhost para alcançar seu Mac, porque dentro da VM localhost é o contêiner. Para alcançar, digamos, o Ollama ou um servidor de desenvolvimento no seu Mac, crie um domínio de host uma vez:

sudo container system dns create host.container.internal --localhost 203.0.113.113
container run -it --rm alpine/curl curl http://host.container.internal:11434/api/tags

A documentação da Apple lista dois poréns: criar esse domínio desativa o iCloud Private Relay, e a regra de filtro de pacotes por trás dele é removida quando você reinicia, então pode ser preciso recriá-la. Qualquer endereço das faixas da documentação (192.0.2.0/24, 198.51.100.0/24, 203.0.113.0/24) é uma escolha segura.

Passo 10 — Experimente uma máquina de contêiner

container machine create alpine:latest --name dev --set-default
container machine run          # um shell no Linux, como você, na sua pasta atual

A Parte 3 tem os detalhes, incluindo as ressalvas de segurança antes de você deixar um agente entrar.

Passo 11 — Rode Kubernetes local (experimental)

brew install kubectl                   # se você ainda não tem
container k8s create                   # cria um cluster chamado k8s-dev
kubectl get nodes                      # o cluster já está em ~/.kube/config
container build -t my-app:latest .
container k8s load-image my-app:latest # use imagePullPolicy: Never no seu pod spec
container k8s delete                   # quando terminar

Os clusters usam a kindest/node:v1.35.5 imagem por padrão e recebe um quarto das CPUs e da memória do seu Mac (no mínimo 2 CPUs e 2 GB). Na 1.5.0, um cluster cujo nó parou não pode ser reiniciado; exclua e recrie. E lembre-se de que este subcomando é experimental e está sendo renomeado para container cluster na branch main.

Etapa 12 — Atualizar, limpar ou desinstalar

container stats --no-stream          # CPU, memória, rede e disco em tempo real por contêiner
container logs -f web                # acompanha a saída de um contêiner
container system df                  # uso de disco
container prune && container image prune && container volume prune && container network prune

container system stop && /usr/local/bin/update-container.sh && container system start   # atualizar
/usr/local/bin/uninstall-container.sh -k   # desinstalar, manter seus dados
/usr/local/bin/uninstall-container.sh -d   # desinstalar e apagar seus dados

Solução de problemas

Sintoma Causa provável Solução
“Os plugins não estão disponíveis. Inicie os serviços do sistema de contêineres e tente de novo” Um subcomando digitado errado (por exemplo, container images), ou os serviços realmente estão parados Conferir container --help para descobrir o nome certo; execute container system start somente se container system status disser que está parado
Sua imagem recém-compilada tem um nome aleatório Você compilou sem -t container image ls, então recompile com -t name:tag
Os contêineres não conseguem se alcançar pelo nome Os nomes só resolvem na rede padrão, com o domínio Uso name.test, ou conecte pelo IP de container inspect
Os contêineres não conseguem se alcançar de jeito nenhum Você está no macOS 15 Atualize para o macOS 26 ou posterior
O uso de memória só aumenta Ballooning parcial de memória no framework Virtualization Defina --memory; reinicie o contêiner para devolver a memória
exec format error Uma imagem só x86 em Apple silicon Use uma imagem arm64 ou multiarch, ou tente --rosetta
A rede para de funcionar após uma mudança de VPN ou DNS Um bug corrigido na 1.5.0 Atualize com update-container.sh
Um contêiner não consegue alcançar um servidor de desenvolvimento no seu Mac localhost dentro de um contêiner é o próprio contêiner Crie uma --localhost domínio host (Etapa 9)

Parte 5 — Apple Container vs Docker: o guia rápido de migração

Para a maioria das pessoas, a questão Apple container vs Docker se resume a hábitos, e a maior parte do que você digita todo dia se traduz um para um. O comando grupos são singulares (imagem, volume, rede, registro, máquina, sistema), que é a primeira coisa que confunde a memória muscular de quem vem do Docker, e algumas coisas simplesmente não existem. Esta tabela cobre os comandos que importam; a documentação da Apple tem o mapeamento completo.

O que você quer Docker Apple container
Listar contêineres em execução / todos os contêineres docker ps / docker ps -a container ls / container ls -a
Executar em segundo plano com uma porta docker run -d -p 8080:80 --name web img container run -d -p 8080:80 --name web img
Abrir um shell dentro docker exec -it web sh container exec -it web sh
Acompanhar os logs docker logs -f web container logs -f web
Parar e remover docker stop web / docker rm web container stop web / container delete web (ou rm)
Construir uma imagem docker build -t app . container build -t app .
Listar, baixar, enviar e remover imagens docker images, pull, push, rmi container image ls, image pull, image push, image rm
Fazer login em um registro docker login container registry login
Copiar arquivos para dentro ou para fora docker cp container cp
Uso de recursos docker stats container stats
Informações do sistema / uso de disco docker info / docker system df container system status / container system df
Limpar tudo docker system prune quatro comandos: container prune, image prune, volume prune, network prune
Volumes e redes docker volume … / docker network … container volume … / container network …
Aplicativo multicontêiner docker compose up Sem equivalente: use um script shell (abaixo)
Reiniciar um contêiner docker restart web container stop web && container start web
Política de reinício --restart unless-stopped Nenhum: use o launchd no Mac, ou um sistema init dentro de uma máquina de contêiner
Salvar um contêiner alterado como imagem docker commit Nenhum: compile a partir de um Dockerfile
Observar eventos, renomear, pausar, anexar docker events, renomear, pause, anexar Nenhum (exec -it substitui anexar)

E algumas coisas que só o container da Apple faz:

  • container machine para ambientes Linux persistentes (Parte 3).
  • container run --ssh encaminha o agente SSH do seu Mac para dentro do contêiner e mantém o socket funcionando mesmo depois do logout.
  • container run --publish-socket host_path:container_path publica um socket Unix no seu Mac em vez de uma porta TCP.
  • container run --rosetta executa binários Linux x86-64 por meio do Rosetta.
  • container run --virtualization expõe a virtualização ao contêiner para uso aninhado (M3 ou posterior).
  • container system kernel gerencia o kernel Linux que seus contêineres inicializam.
Guia rápido de comandos do Docker para o Apple container: ps, run, exec, logs, build, images, login, prune e o que não tem equivalente
A maioria dos comandos traduz um para um. Compose, políticas de reinício e commit são os três que você vai sentir falta.

Substituir um arquivo Compose por um script

Não existe container compose, e a Apple não deu prazo: a Cloud Native Now contou mais de 150 respostas na discussão sobre Compose do projeto até julho. Até então, um pequeno arquivo Compose vira um script shell. Veja uma pilha típica de dois serviços:

services:
  cache:
    image: redis:7
  api:
    image: my-api:latest
    ports: ["3000:3000"]
    environment:
      REDIS_URL: redis://cache:6379
    depends_on: [cache]

Com o test domínio DNS do Passo 7 configurado, o equivalente é:

#!/usr/bin/env bash
set -euo pipefail

# Ambos os contêineres ficam na rede padrão, onde a resolução de nomes funciona
container run -d --name cache redis:7

# depends_on se torna uma verificação explícita de prontidão
until container exec cache redis-cli ping >/dev/null 2>&1; do sleep 1; done

# O nome precisa incluir o domínio: cache.test, não cache
container run -d --name api -p 3000:3000 \
  -e REDIS_URL=redis://cache.test:6379 \
  my-api:latest

Três regras de tradução cobrem a maioria dos arquivos: todo nome de serviço se torna name.domain na sua configuração (cache.test), depends_on se torna um loop de verificação de prontidão (o que é mais correto do que a ordenação apenas por início do Compose, de qualquer forma), e build: se torna um container build -t … linha antes do execute. Derrube com container stop api cache && container delete api cache.

Para qualquer coisa maior que três ou quatro serviços, esse script fica cansativo rápido, e essa é a razão honesta pela qual a maioria das equipes com stacks pesadas em Compose deveria manter o Docker Desktop ou o OrbStack por enquanto.

Deixe seu agente de codificação fazer a tradução

Se você usa um agente de codificação com IA, o repositório da Apple já contém as instruções de que ele precisa. A skill em skills/container/ no release 1.5.0, com seu arquivo de referência sobre migração do Docker, mapeia os comandos, lista o que não existe e explica as regras de DNS acima. Copie essa pasta para o diretório de skills do seu agente e peça ao agente para converter seu arquivo Compose; depois leia o que ele escreveu antes de executar.


Parte 6 — Apple Container vs Docker Desktop, OrbStack, Podman e Lima

O Apple container não tenta ser o Docker Desktop, e a Apple não o apresentou como substituto. Ele disputa outro trabalho: rodar cargas de trabalho Linux em um Mac com o isolamento mais forte e o mínimo de software extra. Se você está comparando alternativas ao Docker Desktop para o seu Mac, veja como o cenário estava em 12 de novembro de 2026.

Apple container 1.5 Docker Desktop OrbStack 2.2 Podman 6 Lima 2.2 / Colima
Arquitetura Uma VM leve por contêiner Uma VM Linux compartilhada Uma VM Linux leve compartilhada Uma VM de máquina Podman (libkrun por padrão no Mac) Uma VM por instância Lima; o Colima roda Docker ou containerd dentro de uma
Isolamento entre contêineres Hypervisor Namespaces do kernel na VM compartilhada Namespaces do kernel; “máquinas isoladas” desde a 2.1 Namespaces do kernel na VM da máquina Por instância
Compose Não Sim Sim (compatível com Docker) Sim (podman compose, ou Docker Compose contra a API dele) Via Docker dentro da VM (Colima)
GUI Não Sim Sim Podman Desktop Não
Kubernetes local Experimental plugin k8s de contêiner Integrado Integrado (1.34) Via Podman Desktop (kind, minikube) Opções baseadas em k3s
GPU para contêineres Linux Não Sem passthrough de Metal; o Model Runner executa os modelos no host Não anunciado Sim, via libkrun (Vulkan e remoting de API do llama.cpp) Driver krunkit experimental
Destaque de 2026 Máquinas de contêiner, Kubernetes local, skill de agente Sandboxes para agentes de IA, Model Runner, Hardened Images gratuitos Máquinas isoladas, passthrough de USB, som Grande limpeza; libkrun como padrão; Macs Intel abandonados Sandbox de agentes de IA; convidados macOS e Windows
Preço Gratuito, Apache-2.0 Grátis para uso pessoal; planos pagos a partir de US$ 11 por usuário por mês (Pro, mensal) Grátis para uso pessoal; Pro US$ 8 por usuário por mês Gratuito, Apache-2.0 Gratuito, código aberto
Melhor para Contêineres únicos, ambientes de desenvolvimento Linux, isolamento máximo Equipes, stacks do Compose, controles corporativos Um driver diário rápido e refinado para uso individual Paridade com Linux, contêineres rootless, inferência por GPU VMs programáveis, runners de CI, sandboxes de agentes

Os preços são de tabela em 12 de novembro de 2026 e mudam; o plano Business do Docker custa US$ 24 por usuário por mês. O licenciamento do Docker há muito tempo exige um plano pago para uso comercial acima de um limite de tamanho da empresa (250 funcionários ou US$ 10 milhões de receita anual desde 2021); confira os termos atuais antes de contar com isso.

Apple container vs Docker Desktop, OrbStack, Podman 6 e Lima: isolamento, Compose, GUI, Kubernetes, GPU e preço
Não há um único vencedor: a ferramenta certa depende de você precisar de Compose, interface gráfica, acesso à GPU ou o isolamento mais forte.

Docker Desktop: o veterano que virou plataforma de agentes de IA

A Docker passou 2026 se reposicionando em torno de agentes de IA, e três de suas jogadas importam aqui. Em dezembro de 2025, ela tornou o Docker Hardened Images gratuitos e de código aberto sob Apache 2.0: mais de mil imagens mínimas com listas de materiais assinadas, que você pode usar com qualquer ferramenta, inclusive a da Apple. Em 30 de janeiro de 2026, lançou Docker Sandboxes, que dão a cada agente de codificação com IA sua própria microVM (mais na Parte 8). E em fevereiro adicionou um backend vLLM para Apple silicon a Docker Model Runner, que executa modelos de linguagem diretamente na GPU do Mac em vez de em um contêiner, pelo motivo que a Parte 7 explica.

O que o Docker Desktop ainda tem e ninguém iguala é todo o ecossistema: Compose, uma interface gráfica madura, Kubernetes, extensões, gestão corporativa e a memória muscular de todo desenvolvedor que você vier a contratar. Se o ambiente local da sua equipe é um arquivo Compose com oito serviços, é aí que você deve ficar por enquanto.

OrbStack: o rápido

O OrbStack construiu sua reputação em velocidade e baixo uso de memória, e suas versões de 2026 adicionaram recursos em vez de reinventá-lo: a versão 2.1 (abril) trouxe uma interface no estilo do macOS 26 e máquinas isoladas, máquinas Linux que veem apenas as pastas que você compartilha com elas e podem ser bloqueadas de acessar seu Mac; 2.2 (junho) adicionou passthrough de USB e som, para que webcams, microcontroladores e dispositivos de áudio funcionem dentro do Linux; e as versões de outubro corrigiram problemas no macOS 27 e passaram para o Linux 7.2. É gratuito para uso pessoal e custa US$ 8 por usuário por mês para uso comercial. Para um desenvolvedor individual que quer compatibilidade com Docker e Compose sem o Docker Desktop, continua sendo a recomendação padrão.

Podman 6: a grande limpeza

Podman 6.0, lançado no final de junho, é a versão mais disruptiva desta lista, e de propósito. Abandona o suporte a cgroups v1, substitui a rede CNI por Netavark, troca o slirp4netns por pasta na rede rootless, exige nftables em vez de iptables e migra seu antigo banco de dados BoltDB para SQLite. O isolamento de rede agora vem ativado por padrão. No Mac, o provedor de máquina padrão agora é libkrun, e Macs com Intel não têm mais suporte; no Windows, o Windows 10 é descartado. No Linux, --gpus agora suporta GPUs AMD além das NVIDIA.

Faça a atualização com cuidado: as máquinas Podman no Linux existentes precisam ser recriadas, e tudo o que dependia da pilha de rede antiga precisa ser testado. O ganho é uma ferramenta muito mais simples e nativa do Linux e, no Mac, é a única com uma história de verdade para contêineres acelerados por GPU.

Lima e Colima: o kit de ferramentas por baixo

Lima é o gerenciador de VMs de código aberto sobre o qual muitas outras ferramentas se apoiam, e se tornou um projeto em incubação na CNCF em novembro de 2025. Sua série 2.x mergulhou de cabeça em IA: Lima 2.0 adicionou um driver krunkit experimental com suporte a GPU e ferramentas MCP para que agentes de IA possam usar uma VM Lima como sandbox; 2.1 (março) adicionou convidados macOS experimentais e um limactl shell --sync modo criado para impedir que agentes de IA danifiquem arquivos no seu Mac; 2.2 (julho) adicionou convidados Windows experimentais. Colima, que envolve o Lima para entregar um runtime Docker ou containerd com um único comando, continua sendo o caminho gratuito mais leve para uma configuração compatível com Docker em um Mac.

Qual deles você deve usar?

  • Você vive em arquivos Compose, ou sua empresa padronizou o Docker: Docker Desktop.
  • Você quer a configuração compatível com Docker mais rápida e leve para você mesmo: OrbStack (ou Colima, se tiver de ser gratuito e de código aberto).
  • Você quer contêineres Linux acelerados por GPU, contêineres sem root ou paridade com servidores Fedora e RHEL: Podman 6.
  • Você quer o isolamento mais forte, nenhum daemon extra e ambientes de desenvolvimento Linux que pareçam parte do macOS: Apple container, com as container machines.
  • Você executa agentes de codificação com IA sem supervisão: um sandbox feito para isso (Parte 8), qualquer que seja o runtime que você use por baixo.

Nada impede você de combiná-los. O Apple container não toca no socket do Docker nem na VM do Docker, então você pode manter o Docker Desktop ou o OrbStack para a sua stack do Compose e usar container machines para todo o resto.


Parte 7 — Contêineres e IA local no Mac: para onde vai a GPU?

Se você roda modelos de linguagem localmente, esta é a parte que mais importa, e é justamente a que a maioria dos guias de contêiner pula: Contêineres Linux em um Mac não conseguem usar a GPU como os aplicativos nativos usam. A Docker diz isso com todas as letras na documentação do Model Runner: não existe passthrough de GPU Metal para contêineres. O framework de Virtualização da Apple não entrega Metal a convidados Linux, e o Apple container não acrescenta isso. Um modelo rodando dentro de um Apple container roda na CPU, o que, para um modelo de 7 bilhões de parâmetros, é a diferença entre fluente e doloroso.

Existem quatro maneiras sensatas de lidar com isso:

  1. Rode o modelo nativamente e coloque todo o resto em contêineres. Ollama, LM Studio, MLX e llama.cpp usam o Metal diretamente no macOS. Rode-os ali, coloque sua aplicação, seu banco de dados e suas ferramentas em contêineres e deixe os contêineres chamarem o modelo por HTTP. Com o Apple container, esse é o Passo 9 da Parte 4: crie um host.container.internal domínio e aponte seu aplicativo para http://host.container.internal:11434 para o Ollama.
  2. Deixe o Docker fazer a mesma coisa por você. O Docker Model Runner executa modelos no host, fora de qualquer contêiner, usando llama.cpp, MLX ou, desde fevereiro, um backend vLLM para Apple silicon (Docker Desktop 4.62 ou posterior). Ele expõe APIs compatíveis com OpenAI e com Anthropic, e você gerencia os modelos com docker model pull como imagens.
  3. Use o Podman com libkrun se o modelo precisar viver em um contêiner. O libkrun dá ao seu convidado Linux uma GPU virtual. Os engenheiros da Red Hat chegaram primeiro a cerca de 75–80% da velocidade nativa do llama.cpp via Vulkan e depois criaram o “API remoting”, que encaminha as chamadas de GPU do llama.cpp do contêiner para o Metal no host. Nos testes deles em um MacBook Pro M4 Pro, o processamento de prompt rodou na velocidade nativa, e a geração de tokens atingiu pelo menos cerca de 95% do nativo. É a única rota mainstream para inferência em GPU dentro de um contêiner em um Mac, e o RamaLama empacota tudo. A Red Hat observa que ele não foi projetado para uso multiusuário.
  4. Experimente o driver krunkit do Lima, que é construído sobre a mesma tecnologia libkrun e oferece aceleração de GPU como opção experimental.
Onde a IA local roda em um Mac: apps nativos com Metal, Docker Model Runner, Podman com libkrun e contêineres somente com CPU
Se o modelo roda em um contêiner Linux comum, ele roda na CPU. Mantenha a inferência nativa ou use uma ferramenta que encaminhe o trabalho da GPU para o Metal.

A receita prática para a maioria das pessoas: rode o Ollama ou o LM Studio nativamente, coloque tudo em volta em contêineres e trate os contêineres como o lugar do seu código e dos seus serviços, não dos seus pesos. Se você está escolhendo hardware para isso, meu guia de MacBooks para LLMs locais cobre quanta memória cada tamanho de modelo precisa, e o guia de IA local com M5 Pro de 64 GB se aprofunda em uma configuração.


Parte 8 — A era do sandbox: por que toda ferramenta de contêiner virou uma ferramenta de agentes de IA

Veja as notas de lançamento de 2026 de todas as ferramentas da Parte 6 e o mesmo tema continua aparecendo: isolar agentes de IA. Não é coincidência. Agentes de codificação agora rodam por horas, instalam pacotes, executam código que eles mesmos escreveram e leem arquivos que não lhes foram indicados. A pergunta deixou de ser “o agente consegue escrever código bom?” e passou a ser “no que ele pode mexer enquanto faz isso?” Em 2026, a resposta com que todos os fornecedores convergiram foi um sandbox de agente de IA: um ambiente descartável com kernel próprio, apenas os arquivos que a tarefa precisa e, idealmente, limites sobre para onde ele pode enviar dados.

Cinco formas de dar ao agente seu próprio ambiente

  • Docker Sandboxes (30 de janeiro de 2026) dão a cada agente uma microVM descartável com apenas a pasta do seu projeto montada e seu próprio motor Docker dentro, sem acesso ao daemon Docker do seu host. No lançamento, eles suportavam Claude Code, Codex CLI, Copilot CLI, Gemini CLI e Kiro no macOS e no Windows. O sbx ferramenta de linha de comando permite escolher uma política de rede (Open, Balanced ou Locked Down), permitir destinos específicos e gerenciar segredos com sbx secret. A versão 0.53.0 foi lançada em 11 de novembro.
  • Docker Cloud Sandboxes (24 de setembro de 2026) rodam os mesmos sandboxes na nuvem da Docker com o mesmo isolamento e as mesmas políticas, para que um agente possa continuar trabalhando a noite toda com seu laptop fechado. Eles escalam de 1 a 16 vCPUs e, segundo a Docker, iniciam em poucas centenas de milissegundos.
  • Apple container dá a todo contêiner uma fronteira de VM por design. Um container run com apenas o seu projeto montado é um ambiente de agente razoável; uma container machine, como a Parte 3 explicou, não é, a menos que você desative a montagem do home.
  • Lima 2.x traz ferramentas MCP que permitem a um agente executar comandos dentro de uma VM do Lima, e um --sync modo shell criado para impedir que agentes danifiquem arquivos no host.
  • OrbStack 2.1 adicionou máquinas isoladas, que veem apenas as pastas que você escolhe compartilhar e, desde a 2.1.2, podem ser bloqueadas de alcançar seu Mac e suas outras máquinas.
Sandboxes de agentes de IA em um Mac em 2026: Docker Sandboxes, Apple container, Lima e OrbStack comparados por isolamento e acesso
Toda grande ferramenta de contêiner para Mac lançou uma resposta para a mesma pergunta neste ano: no que o agente pode mexer?

Um ambiente de agente mínimo com o Apple container

Se você quiser experimentar com a ferramenta deste artigo, isto dá ao agente uma VM própria, a pasta do seu projeto e nada mais do seu Mac:

cd ~/code/my-project
container run -it --rm --name agent-box \
  --cpus 4 --memory 8g \
  -v "$PWD":/work -w /work \
  node:22 bash
# dentro: instale a CLI do seu agente, faça login e execute na /work

O que isto protege e o que não protege, honestamente:

  • Protege o resto dos arquivos do seu Mac, suas chaves SSH (desde que você não adicione --ssh), seu Keychain e seus outros contêineres.
  • Não protege a própria pasta do projeto, que o agente ainda pode alterar ou excluir, então faça commit antes de começar. Também não restringe o tráfego de rede de saída: o Apple container não tem política de egress, então um agente enganado por uma página web ou README malicioso ainda pode enviar dados para fora. As políticas de rede do Docker Sandboxes são a melhor escolha se isso te preocupa.
  • As credenciais que você cola ficam dentro do ambiente. Use um token com escopo para o agente, não sua conta principal.

O teste de realidade da segurança

Sandboxes reduzem o raio de alcance; não tornam um agente comprometido inofensivo. A própria versão 1.3.1 da Apple corrigiu seis avisos no código que descompacta imagens, e a safra de 2026 de ferramentas de IA expostas transformadas em mineradores de cripto é um bom lembrete do que acontece quando o isolamento é pensado depois: em abril, a Censys documentou mais de mil servidores ComfyUI deixados abertos na internet sendo alvo de ataques, como eu abordei em Vale a pena minerar cripto em 2026?. Mantenha as ferramentas de sandbox atualizadas, dê credenciais com escopo limitado aos agentes, revise o que eles fazem commit e nunca exponha a interface de controle de um agente à internet. Se você está escolhendo um agente, minha comparação de harnesses de codificação com IA mostra quais deles já vêm com sandbox integrado.


Parte 9 — A camada de plataforma: macOS 27, Xcode 27, Swift, Linux 7.0, Ubuntu 26.04 e Homebrew

O Apple container foi o lançamento mais interessante do ano para desenvolvedores de Mac, mas não foi o único que mudou a forma como você trabalha. O resto deste guia é o radar de lançamentos: as novidades de 2026 que mais importam para quem faz software, agrupadas por camada, com o que mudou e o que fazer em cada caso.

Linha do tempo de lançamentos de ferramentas para desenvolvedores em 2026: Apple container, Docker, Podman, macOS 27, Python 3.15, TypeScript 7 e mais
Treze meses, três frentes. Abril e junho foram os meses mais movimentados desta lista; setembro trouxe o macOS 27 e o Xcode 27.

macOS 27 Golden Gate: somente Apple silicon

A Apple anunciou o macOS 27 Golden Gate na WWDC26 em 8 de junho e o lançou em 14 de setembro de 2026. Para os desenvolvedores, o destaque não é a Siri, que agora roda no Gemini do Google, nem os apps abrindo mais rápido que a Apple anuncia; é a lista do que sumiu:

  • Os Macs Intel estão fora. O Golden Gate roda apenas em Apple silicon. O macOS 26 Tahoe é a última versão para Macs Intel, que ficam nele pelo resto da janela de atualizações de segurança.
  • O Rosetta 2 está com os dias contados. Na atualização, o Rosetta é removido e reinstalado sob demanda na primeira vez que um app só para x86 é aberto. O Golden Gate é amplamente descrito como o último macOS com suporte completo ao Rosetta 2, então ferramentas exclusivas para x86 no seu fluxo de trabalho precisam de um plano de substituição.
  • Os runtimes de script antigos continuam sumindo. Uma instalação limpa não tem Python 2 nem PHP; python3 é o 3.9.6 que vem com as Command Line Tools e não muda. Use Homebrew, uv ou pyenv para trabalho sério com Python, e Homebrew para PHP.
  • Não existe downgrade. Se algo quebrar, o caminho limpo de volta é uma restauração do Time Machine. Faça backup antes e espere se você depende de um cliente VPN, driver ou extensão de kernel que ainda não esteja certificado para o 27.

Um alerta específico se você programa em Python: as notas de lançamento da python.org para o 3.15 avisam que o IDLE e outros apps tkinter podem travar ao abrir diálogos no macOS 27.0, e sugerem esperar por uma correção antes de atualizar se você depende deles.

Xcode 27 e Swift 6.4: agentes com um plano

Xcode 27 saiu em 14 de setembro com Swift 6.4. Ele exige macOS Tahoe 26.6 ou posterior em Apple silicon, então também é o fim da linha para o Xcode em Intel. As mudanças que importam:

  • A codificação com agentes amadureceu. Os agentes agora podem planejar antes de agir: o plano é um documento Markdown editável que você aprova antes de o agente mudar qualquer coisa. O Gemini do Google entrou na lista de modelos compatíveis, e as integrações com provedores externos são opcionais, porque enviam seu código para servidores de terceiros.
  • O Device Hub substitui o app Simulator, trazendo simuladores e dispositivos reais para uma única janela. xcrun simctl continua funcionando, então a automação de simulador por script sobrevive.
  • Alguns projetos não vão compilar sem mudanças. O clássico ld64 linker sumiu (a -ld64 flag agora faz a linkagem falhar), algumas quebras no código Swift afetam @State inicializadores e init acessadores, e para alvos do macOS 27 ARCHS_STANDARD não inclui mais o x86_64, silenciosamente.

Swift 6.3, lançado em 24 de março, merece menção própria: tornou o Swift SDK for Android oficial, então você pode compilar código Android nativo em Swift e chamá-lo a partir de Kotlin ou Java, adicionou um @c atributo que expõe funções Swift ao C, e pré-visualizou o novo sistema Swift Build dentro do Swift Package Manager. Combinado com as máquinas de contêiner, agora é realista escrever Swift do lado do servidor em um Mac, compilar e testar no Linux real ao lado e compartilhar código com um aplicativo Android.

Linux 7.0: um número redondo com mudanças reais

Linus Torvalds lançou Linux 7.0 em 12 de abril de 2026. O salto de versão a partir da 6.19 foi um reinício de numeração, não um sinal de reviravolta, mas o lançamento trouxe marcos reais: O suporte a Rust perdeu o rótulo “experimental”, o XFS ganhou autorrecuperação autônoma, módulos do kernel podem ser assinados com o algoritmo pós-quântico ML-DSA , enquanto a assinatura de módulos com SHA-1 foi removida, e o zram agora pode gravar páginas comprimidas de volta ao armazenamento sem descomprimi-las antes. Em outubro, o OrbStack já distribuía um kernel 7.2 dentro da sua VM.

Ubuntu 26.04 LTS “Resolute Raccoon”

A Canonical lançou Ubuntu 26.04 LTS em 23 de abril de 2026, construído sobre o Linux 7.0. É o lançamento que colocou o Rust no coração de uma distribuição mainstream: sudo-rs e os utilitários Rust da uutils coreutils substituem o clássico sudo e as ferramentas de linha de comando essenciais. A criptografia de disco completo com suporte a TPM agora está disponível no instalador, o Livepatch cobre servidores Arm64 pela primeira vez, e o CUDA da NVIDIA está nos próprios repositórios do Ubuntu pela primeira vez, junto com o ROCm da AMD. Para contêineres, isso significa ubuntu:26.04 é a imagem base de onde novos projetos devem partir; para usuários de Windows, o Ubuntu no WSL ganhou cloud-init e integração com o Ubuntu Pro. Se você está montando um novo servidor neste inverno, a maior parte do meu checklist de endurecimento de servidor Debian 12 também se aplica ao 26.04.

Homebrew 6.0 e 7.0: duas versões principais em um verão

O Homebrew lançou duas versões principais com três meses de diferença e, juntas, mudaram seus padrões mais do que qualquer lançamento em anos:

  • Homebrew 6.0 (11 de junho) passou a exigir que você confie explicitamente em taps de terceiros antes que o código deles rode (os taps oficiais continuam confiáveis), tornou o modo “ask” o padrão para desenvolvedores, de modo que brew install e brew upgrade mostram o que vai mudar antes de mudar, trouxe um sandbox Bubblewrap para o Linux e adicionou brew exec, que executa um pacote sem instalá-lo permanentemente, de forma muito parecida com o npx.
  • Homebrew 7.0 (13 de setembro) integrado brew vulns, que verifica seus pacotes instalados no banco de dados de vulnerabilidades OSV.dev, lançou BrewUI, o aplicativo gráfico oficial do Homebrew (brew install homebrew-app, macOS Tahoe 26 ou mais recente), mudou o sandbox do Linux para Landlock e acelerou as instalações com mais trabalho paralelo.
  • O cronograma do Intel agora está definido. Golden Gate, Tahoe e Sequoia são Nível 1 no Apple silicon. Os Macs Intel passaram para o Nível 3, sem novos bottles, e o Homebrew deixa de funcionar em Intel em 1º de setembro de 2027; ele sugere o MacPorts para quem tiver que ficar. O macOS 10.15 e versões anteriores não são mais suportados de forma alguma, e o Sonoma 14 caiu para o Nível 3.

Dois comandos que vale a pena executar hoje: brew vulns --severity=high para ver o que está exposto, e brew tap para revisar em quais taps de terceiros você vem confiando o tempo todo.


Parte 10 — Linguagens e runtimes: Python 3.15, TypeScript 7, Node.js 26, Go 1.27, .NET 11, Bun e Vite

Python 3.15: inicia mais rápido, executa mais rápido

Python 3.15.0 chegou em 9 de outubro de 2026 (a versão atual é 3.15.2). Os principais recursos:

  • Importações lazy explícitas (PEP 810). Você pode marcar uma importação como lazy, para que o módulo carregue só quando for usado pela primeira vez. Para ferramentas de linha de comando e funções serverless que importam bibliotecas pesadas que quase nunca usam, o tempo de inicialização cai de forma perceptível.
  • UTF-8 é a codificação padrão (PEP 686). open() sem um encoding argumento agora significa UTF-8 em todo lugar. É principalmente uma correção para o Windows, mas verifique qualquer código que dependia do antigo padrão dependente de locale.
  • Novos built-ins: frozendict (PEP 814), um dicionário imutável, e sentinel (PEP 661), uma forma adequada de criar valores marcadores únicos.
  • Desempacotamento em comprehensions (PEP 798), um novo profiler estatístico chamado Tachyon (PEP 799) com um novo profiling pacote, ponteiros de frame ativados por padrão para melhor profiling, e várias melhorias de tipagem.
  • Um JIT experimental mais rápido: cerca de 7–8% mais rápido que o interpretador padrão no Linux x86-64 e 11–12% mais rápido que o interpretador com tail-calling em Macs Apple silicon, segundo as medições de média geométrica da equipe principal’s.
  • O free-threading se aproxima do normal. O instalador oficial do macOS agora instala o suporte a free-threading por padrão, e o novo trabalho com ABI estável facilita o suporte das extensões C a essa build sem o global interpreter lock.

As imagens de contêiner são python:3.15. Teste primeiro em um branch: imports preguiçosos e a mudança de codificação são as duas coisas mais propensas a surpreender código existente.

TypeScript 7.0: o compilador, reescrito em Go

A Microsoft lançou TypeScript 7.0 em 8 de julho de 2026, após um release candidate em junho. É o port nativo do compilador e do serviço de linguagem para Go, conhecido durante o desenvolvimento como Project Corsa, e a Microsoft diz que ele normalmente deixa builds completos de 8 a 12 vezes mais rápidos, ajudado por multithreading de verdade. Como a equipe portou a estrutura e a lógica do código existente em vez de redesenhá-lo, os dois compiladores produzem resultados consistentes.

Você instala do jeito de sempre (npm install -D typescript), e o pacote agora inclui o binário nativo tsc. Para ferramentas que ainda precisam da API JavaScript antiga, a Microsoft publica @typescript/typescript6, que fornece um tsc6 comando e a API 6.0 lado a lado com a 7.0. A Microsoft agora planeja releases de recursos a cada três ou quatro meses. Se seu editor parece mais rápido neste outono, é por isso.

Node.js 26 LTS: o Temporal chega e o trem de releases desacelera

Node.js 26 saiu em maio e se tornou LTS em 28 de outubro de 2026 como versão 26.13.0, codinome “Lithium”, com suporte até o fim de abril de 2029. Ele habilita a Temporal API por padrão, o substituto tão aguardado do notoriamente desajeitado Data objeto do JavaScript, e traz o motor V8 14.6 e o Undici 8, o cliente HTTP por trás do fetch().

O Node 26 também é o fim de uma era. É o último grande lançamento no antigo esquema de duas vezes por ano. A partir do Node.js 27, haverá um grande lançamento por ano, todas as versões passarão a ser LTS, e cada linha terá 30 meses de LTS dentro dos 36 meses de suporte total. A fase alfa do Node 27 começou em outubro de 2026, seu primeiro lançamento está previsto para abril de 2027 e ele terá suporte até abril de 2030.

Go 1.27: métodos genéricos, finalmente

Go 1.27 saiu em 19 de agosto de 2026. Agora os métodos podem ter seus próprios parâmetros de tipo, um dos recursos mais pedidos desde que os genéricos chegaram no Go 1.18 (métodos de interface ainda não podem). encoding/json agora roda sobre a mais rápida implementação v2 por baixo, com novos encoding/json/v2 e jsontext pacotes; a desserialização é significativamente mais rápida, embora algumas mensagens de erro soem diferentes. Há suporte SIMD experimental e portátil por trás de GOEXPERIMENT=simd, e os pacotes de criptografia ganharam ML-DSA assinaturas pós-quânticas e ML-KEM-1024 para troca de chaves no TLS 1.3. Uma nota de plataforma: o Go 1.27 exige macOS 13 Ventura ou posterior.

.NET 11: tipos união, e duas versões sem suporte

A Microsoft lançou .NET 11 na .NET Conf 2026 (10–12 de novembro). É uma versão de prazo padrão com 24 meses de suporte. O grande destaque para quem desenvolve são os tipos união do C# 15, que permitem que um valor seja exatamente um entre vários tipos declarados, com o compilador verificando que as expressões switch tratam todos os casos. O .NET MAUI agora roda no CoreCLR runtime por padrão, usando código pré-compilado mais um interpretador nas plataformas Apple, onde a compilação JIT não é permitida, e o dotnet comando em si inicia mais rápido graças a um host Native AOT.

A parte urgente não é o próprio .NET 11: O .NET 8 e o .NET 9 chegaram ao fim do suporte em 10 de novembro de 2026. O que ainda estiver rodando neles precisa migrar para o .NET 10 (suporte de longo prazo) ou para o .NET 11.

Bun 1.4: reescrito em Rust, em grande parte por IA

O lançamento mais debatido do ano é Bun 1.4, publicado em agosto. Bun, o runtime JavaScript que a Anthropic adquiriu em dezembro de 2025, foi portado de Zig para Rust Zig para Rust. Segundo o relato do InfoQ, a base de código original tinha cerca de 535.000 linhas de Zig; o porte levou cerca de quatro meses em vez do ano que uma pequena equipe humana precisaria; e o trabalho foi feito em grande parte por uma versão de pré-lançamento do Claude Fable 5 da Anthropic, orquestrada como cerca de 50 fluxos de trabalho com um agente implementador, dois agentes revisores adversariais e um agente corrigidor, rodando até 64 instâncias em paralelo. Fazer a suíte de testes passar custou cerca de US$ 165.000 no uso da API.

Os resultados têm dois lados. O porte mecânico introduziu 19 regressões sutis. Também resolveu 128 bugs de longa data, e em um teste de 2.000 builds consecutivos, o uso de memória se estabilizou em 609 MB em vez de subir além de 6,7 GB como antes. O criador do Zig, Andrew Kelley, criticou o projeto por entregar código que nenhum humano havia revisado por completo. Goste ou não, o Bun 1.4 agora é o caso de referência de reescrita de infraestrutura por IA em escala, e a discussão sobre o que “revisado” significa para código escrito por IA está longe de resolvida.

Vite 8: um bundler em vez de dois

Vite 8, lançada em 12 de março de 2026, substituiu o par de bundlers que o Vite sempre usou, esbuild no desenvolvimento e Rollup em produção, por um único bundler baseado em Rust, Rolldown, mais o conjunto de ferramentas do compilador Oxc. Em benchmarks, o Rolldown é de 10 a 30 vezes mais rápido que o Rollup, e os primeiros adotantes relataram grandes ganhos no mundo real: o build de produção da Linear caiu de 46 segundos para 6. O Vite agora exige Node.js 20.19+ ou 22.12+, é distribuído apenas como ESM e fica cerca de 15 MB maior para instalar; uma camada de compatibilidade converte automaticamente a maioria das configurações existentes.


Parte 11 — Infraestrutura e editores: Kubernetes, PostgreSQL 19 e Zed 1.0

Kubernetes 1.36 e 1.37

O Kubernetes manteve seu ritmo de três lançamentos por ano. A versão 1.36 “Haru” (22 de abril de 2026) trouxe 70 melhorias, 18 delas promovidas a estável, e a mais importante foi namespaces de usuário, que mapeiam o usuário root de um contêiner para um usuário sem privilégios no host. A autorização refinada para a API do kubelet e as métricas de pressure stall (PSI) também passaram a estável, e os ExternalIPs de Service foram descontinuados. A versão 1.37 “Garhwal” (26 de agosto de 2026) veio em seguida com 67 melhorias: 16 estáveis, 23 em beta e 27 em alfa.

Para usuários de Mac, um detalhe prático: o plugin Kubernetes do Apple container usa a kindest/node:v1.35.5 imagem por padrão, então fica uma ou duas versões atrás. Passe --node-image com uma imagem de nó kind mais recente quando precisar testar com o Kubernetes atual.

PostgreSQL 19: o lançamento que esperou

O PostgreSQL lança uma versão principal todo outono como um relógio. Este ano, não. Durante o ciclo beta da versão 19, o projeto reverteu 53 commits, incluindo recursos de destaque como consultas a grafos de propriedades em SQL (SQL/PGQ), MERGE/SPLIT PARTITION, UPDATE/DELETE … FOR PORTION OF e GROUP BY ALL, que retornava resultados errados em alguns casos. A maioria deve voltar na versão 20. Uma análise de setembro no blog de engenharia da Snowflake apontou uma causa interessante: a detecção de bugs assistida por IA estava revelando problemas de fase final que antes teriam sido lançados. O primeiro release candidate saiu em 15 de outubro, e a disponibilidade geral está prevista para 19 de novembro de 2026, a menos que outro candidato seja necessário.

É o oposto do instinto de “lançar e corrigir depois”, e para um banco de dados essa é a decisão certa. Fique no PostgreSQL 18 em produção até o 19 ter pelo menos sua primeira versão menor.

Zed 1.0: um novo editor chega à versão estável

Zed, o editor construído em Rust e acelerado por GPU da equipe por trás do Atom, atingiu 1.0 no fim de abril de 2026, depois de cerca de cinco anos de desenvolvimento. Roda no macOS (12 ou posterior), Windows e Linux, e seus recursos de IA incluem suporte a agentes de codificação externos por meio do Agent Client Protocol aberto. Ele anda rápido: a versão atual em 12 de novembro é a 1.28.1.


Parte 12 — Seis padrões por trás da onda de lançamentos de 2026

Vistos um a um, esses são apenas notas de versão. Vistos em conjunto, eles mostram para onde as ferramentas de desenvolvimento estão indo.

1. A máquina virtual é o novo contêiner

O Apple container dá a cada contêiner sua própria VM. O Docker Sandboxes e o Cloud Sandboxes dão a cada agente uma microVM. Lima, OrbStack e Podman passaram o ano inteiro adicionando recursos de isolamento no nível de VM. A causa é a mesma em todo lugar: agentes de IA executam código que ninguém leu, e a fronteira de namespaces do kernel que era suficiente para seus próprios serviços confiáveis não é um lugar confortável para deter um serviço não confiável. O Apple silicon tornou as VMs leves baratas o bastante para fazer disso o padrão.

2. A Intel está saindo do conjunto de ferramentas do Mac

macOS 27, Xcode 27 e Apple container rodam apenas em Apple silicon. O Podman 6 abandonou os Macs Intel. O Homebrew moveu a Intel para o Tier 3 e marcou uma data, 1º de setembro de 2027, depois da qual ele deixa de rodar lá de vez. O Golden Gate é o último macOS com Rosetta 2 completa. Se você ou sua empresa ainda desenvolvem em Macs Intel, 2027 é o ano em que isso se torna inviável.

Fim do suporte a Macs Intel nas ferramentas de desenvolvedor: macOS 27, Xcode 27, Podman 6 e Homebrew, que termina em 1º de setembro de 2027
A saída dos Macs Intel, ferramenta por ferramenta. O corte do Homebrew em 1º de setembro de 2027 é a data para colocar no seu calendário.

3. Reescreva em uma linguagem mais rápida

O compilador do TypeScript passou de JavaScript para Go e ficou de 8 a 12 vezes mais rápido. O Vite trocou dois empacotadores por um escrito em Rust. O Bun passou de Zig para Rust. O Ubuntu substituiu sudo e os utilitários principais por versões em Rust, o Rust perdeu o rótulo de experimental no kernel do Linux, e o Zed provou que um editor nativo pode competir com os baseados em Electron. A velocidade é metade do motivo; a segurança de memória é a outra.

4. A IA agora é tanto quem constrói quanto quem encontra bugs

Uma IA fez a maior parte da digitação na reescrita do Bun. A detecção de bugs assistida por IA ajudou a adiar o PostgreSQL 19. A Apple distribui uma skill para que agentes de codificação consigam operar sua ferramenta de contêineres, o Xcode 27 tem agentes que planejam antes de escrever, e a Docker reorganizou sua linha de produtos em torno de isolá-los em sandboxes. As ferramentas assumem cada vez mais que há um agente, e não uma pessoa, do outro lado da linha de comando, e isso está mudando o que significam “boa documentação” e “bons padrões”. (Para o lado do fluxo de trabalho dessa mudança, veja meu guia de vibe coding.)

5. Seguro por padrão, finalmente

O Homebrew agora exige que você confie em taps de terceiros e verifica vulnerabilidades conhecidas. A Docker liberou suas imagens reforçadas. O Podman ativou o isolamento de rede por padrão. O Apple container agora usa HTTPS por padrão para registries e corrigiu seis avisos em uma única versão. O Linux 7.0 e o Go 1.27 adotaram assinaturas pós-quânticas, e o Ubuntu trocou ferramentas por versões seguras em memória. Nada disso é glamouroso, e tudo isso reduz o número de maneiras pelas quais uma dependência ruim ou um agente confuso pode te prejudicar.

6. Trens mais lentos, suporte mais longo

O Node.js está migrando para uma versão principal por ano, com LTS em todas as versões. As versões de prazo padrão do .NET agora têm 24 meses de suporte. O PostgreSQL escolheu a qualidade em vez da sua janela de lançamento habitual. Depois de anos de ciclos de lançamento cada vez mais rápidos, as plataformas sobre as quais as pessoas constroem negócios estão desacelerando de propósito, enquanto as ferramentas por cima, do TypeScript ao Zed e ao Apple container, continuam lançando a cada poucas semanas.


Parte 13 — Seu plano de atualização para novembro de 2026

Aqui está o que eu faria, de acordo com o tipo de desenvolvedor que você é.

Plano de atualização para desenvolvedores em novembro de 2026 por função, de usuários de Mac e Docker a donos de Python, TypeScript e Macs Intel
Uma linha por tipo de desenvolvedor. Comece pela linha que descreve você e depois passe os olhos nas demais.

Desenvolvedores de Mac em Apple silicon. Faça um backup do Time Machine, depois migre para o macOS 26.6 ou 27 e o Xcode 27 quando suas ferramentas críticas derem suporte a eles. Instale o Apple container 1.5 e crie uma máquina de contêineres para seus builds Linux. Execute brew update && brew upgrade, depois brew vulns e brew tap.

Equipes no Docker Desktop. Fique onde está para o desenvolvimento baseado em Compose. Migre as imagens base para o Docker Hardened Images onde fizer sentido, experimente o Docker Sandboxes para trabalho com agentes e confira se o número de assentos ainda corresponde aos termos de licença da Docker.

Quem executa agentes de codificação com IA. Dê a cada agente um sandbox: Docker Sandboxes, um Apple container simples com apenas o projeto montado, ou uma VM do Lima. Nunca dê a um agente sua pasta home inteira, seu agente SSH ou um token sem escopo. Faça commit antes de cada execução longa.

Desenvolvedores Python. Teste a 3.15 em um branch. Fique de olho no padrão UTF-8 e em qualquer código que possa quebrar com importações preguiçosas, experimente a build free-threaded se você tiver código limitado por CPU, e mantenha o IDLE longe do macOS 27.0 até a correção do tkinter sair.

Desenvolvedores de JavaScript e TypeScript. Mova novos serviços de produção para o Node 26 LTS. Experimente o TypeScript 7 com @typescript/typescript6 como sua rede de segurança para ferramentas que precisam da API antiga, e atualize para o Vite 8 se seus builds estiverem lentos.

Desenvolvedores de Go e .NET. Atualize para o Go 1.27, lembrando que ele precisa do macOS 13 ou posterior. Migre agora qualquer coisa que ainda esteja no .NET 8 ou 9 para o .NET 10 LTS ou o .NET 11: eles já estão sem suporte.

Donos de servidores Linux. Use Ubuntu 26.04 LTS para novos servidores, ative os namespaces de usuário onde sua versão do Kubernetes os suportar e fique no PostgreSQL 18 até o 19 receber uma versão de correção.

Donos de Mac Intel. O Tahoe é seu último macOS, e o Homebrew deixa de rodar em Intel em 1º de setembro de 2027. Planeje uma substituição no orçamento de 2027 ou leve seu trabalho de desenvolvimento para uma máquina Linux ou um ambiente de nuvem. Se você está avaliando as novas telas do MacBook Pro para essa substituição, eu expliquei por que escolhi mini-LED em vez de OLED, e comparei o MacBook Pro M1 com o M5 Pro de 16 polegadas em detalhes.


Perguntas frequentes

O que é o Apple container 1.0?

O Apple container é a ferramenta de linha de comando de código aberto da Apple para criar, executar, compilar e publicar contêineres Linux em um Mac. A versão 1.0 foi lançada em 9 de junho de 2026. Ele roda cada contêiner em sua própria máquina virtual leve usando o pacote Containerization em Swift da Apple, funciona com imagens OCI padrão de qualquer registry e ganhou as máquinas de contêiner: ambientes Linux persistentes que compartilham seu nome de usuário e sua pasta home do Mac. A versão atual é a 1.5.0.

O Apple container substitui o Docker Desktop?

Ainda não para a maioria das equipes. O Apple container executa as mesmas imagens e cobre comandos do dia a dia como run, build, exec, logs e push, mas não tem Compose, não tem políticas de reinício, não tem interface gráfica e não dá acesso à GPU para contêineres. O Docker Desktop e o OrbStack continuam melhores para pilhas Compose com vários serviços. O Apple container é mais indicado para contêineres únicos, ambientes de desenvolvimento Linux e cargas em que o isolamento no nível da VM importa.

O que são máquinas de contêiner?

As máquinas de contêiner, novidade no Apple container 1.0, são ambientes Linux persistentes criados a partir de imagens OCI comuns. Cada uma roda em sua própria VM leve, inicializa o init system da imagem e mapeia seu nome de usuário, sua pasta home e o diretório atual do Mac para dentro do Linux, então você edita no macOS e compila dentro do Linux sem etapa de cópia. Elas são criadas com container machine create e são o mais próximo que o Mac tem do WSL do Windows.

O Apple container funciona em Macs Intel ou no macOS 15?

Ele não roda em Macs Intel de jeito nenhum; precisa de Apple silicon. A Apple oferece suporte a ele no macOS 26 Tahoe, e ele também roda no macOS 27 Golden Gate. Ele roda no macOS 15 Sequoia, mas com limitações reais: os contêineres não conseguem se comunicar pela rede entre si, só uma rede fica disponível, e os mantenedores da Apple em geral não corrigem problemas que não conseguem reproduzir no macOS 26.

O Apple container é gratuito?

Sim. O Apple container e o pacote Containerization são de código aberto sob a licença Apache 2.0, sem assinatura, licença por assento ou conta. Você baixa o pacote instalador assinado da página de releases do projeto no GitHub. As imagens continuam vindo de registries como o Docker Hub, cujos próprios limites de requisições e termos se aplicam quando você faz pull delas.

O Apple container oferece suporte ao Docker Compose?

Não. Não existe um container compose comando, e a Apple não deu prazo, embora a discussão sobre Compose no projeto seja uma das mais movimentadas. Um arquivo Compose pequeno pode ser reescrito como um shell script que inicia cada contêiner na rede padrão, usa name.domain hostnames como db.test e substitui depends_on por um loop de prontidão. Stacks Compose maiores ficam melhor no Docker Desktop ou no OrbStack.

Posso usar minhas imagens Docker com o Apple container?

Sim. O Apple container consome e produz imagens OCI padrão, então imagens do Docker Hub, do registry de contêineres do GitHub ou de um registry privado rodam sem alteração, e as imagens que você compila com container build a partir de um Dockerfile comum rodam em qualquer outro lugar. Use imagens arm64 ou multiarquitetura quando possível; imagens só x86 precisam do --rosetta do P2Pool.

Contêineres em um Mac podem usar a GPU para IA local?

Não no Apple container nem em um contêiner Docker padrão: contêineres Linux em um Mac não têm passthrough de GPU Metal, então os modelos dentro deles rodam na CPU. Rode o modelo nativamente com Ollama, LM Studio ou MLX e chame-o a partir dos seus contêineres, ou deixe o Docker Model Runner rodá-lo no host. O Podman com libkrun é a exceção, encaminhando o trabalho de GPU do llama.cpp para o Metal em velocidade quase nativa nos testes da Red Hat.

O Apple container é mais seguro que o Docker?

Seu design oferece isolamento mais forte entre contêineres. Cada contêiner Apple roda em sua própria VM, então um processo que escapa do contêiner cai em uma VM sem mais nada dentro, enquanto no Docker Desktop todos os contêineres compartilham uma única VM Linux e um único kernel. Isso não o torna livre de bugs: a versão 1.3.1 corrigiu seis avisos de segurança no tratamento de imagens. Mantenha-o atualizado e lembre que as máquinas de contêiner trocam isolamento por conveniência de propósito.

Como instalo o Apple container?

Confira se seu Mac tem Apple silicon e macOS 26 ou mais recente, baixe o instalador assinado .pkg da página de releases do Apple container no GitHub, execute-o com sua senha de administrador e depois rode container system start e aceite o kernel Linux recomendado. Teste com container run --rm alpine echo hello. Atualize depois com /usr/local/bin/update-container.sh, depois de parar os serviços com container system stop.

O que são os Docker Sandboxes?

O Docker Sandboxes, lançado em 30 de janeiro de 2026, executa agentes de codificação com IA como Claude Code, Codex CLI, Copilot CLI e Gemini CLI dentro de microVMs descartáveis. Cada sandbox monta só a pasta do seu projeto, tem seu próprio motor Docker sem acesso ao do seu host e pode impor políticas de rede por meio do sbx ferramenta. Os Docker Cloud Sandboxes, lançados em 24 de setembro de 2026, rodam os mesmos sandboxes na nuvem da Docker.

O que mudou para desenvolvedores no macOS 27 Golden Gate?

O macOS 27 Golden Gate, lançado em 14 de setembro de 2026, roda apenas em Apple silicon, o que faz do macOS 26 Tahoe a última versão para Macs Intel. Ele é descrito como o último macOS com Rosetta 2 completo, uma instalação limpa não traz Python 2 nem PHP, e o Xcode 27, que vem com Swift 6.4 e planejamento por agentes, exige macOS Tahoe 26.6 ou mais recente. Não há downgrade no local, então faça backup antes de atualizar.

Devo atualizar para o Python 3.15?

Teste primeiro, depois atualize. O Python 3.15, lançado em 9 de outubro de 2026, adiciona imports lazy explícitos, frozendict e sentinel novos built-ins, um JIT experimental mais rápido e UTF-8 como codificação padrão. A mudança de codificação e os imports lazy são os que mais provavelmente afetam código existente, então rode sua suíte de testes em um branch. No macOS 27.0, o python.org avisa que o IDLE e outros aplicativos tkinter podem travar ao abrir diálogos.

O TypeScript 7 é uma atualização que quebra compatibilidade?

Em grande parte não para os resultados da checagem de tipos, que a Microsoft manteve consistentes ao portar a lógica do compilador existente para Go, mas ferramentas que usam a API JavaScript do compilador podem precisar de tempo para acompanhar. O TypeScript 7.0, lançado em 8 de julho de 2026, normalmente deixa builds completos de 8 a 12 vezes mais rápidos. O @typescript/typescript6 pacote da Microsoft fornece um tsc6 comando e a API 6.0 lado a lado, para ferramentas que precisam dos dois.

Quando o Homebrew deixa de oferecer suporte a Macs Intel?

O Homebrew 7.0, lançado em 13 de setembro de 2026, moveu os Macs Intel para o Tier 3, o que significa que não há mais bottles pré-compilados, e o Homebrew deixa de rodar em Macs Intel depois de 1º de setembro de 2027. Ele sugere o MacPorts para quem precisa continuar no Intel. Em Apple silicon, macOS 15 Sequoia, 26 Tahoe e 27 Golden Gate são plataformas Tier 1 com suporte completo.

Por que o PostgreSQL 19 foi adiado?

O projeto escolheu qualidade em vez da data habitual de lançamento no outono. Durante o ciclo beta, reverteu 53 commits, incluindo consultas de grafo de propriedades em SQL, merge e split de partições, FOR PORTION OF e GROUP BY ALL, a maioria deles prevista para a versão 20, e a detecção de bugs assistida por IA revelou problemas tardios. O primeiro release candidate chegou em 15 de outubro de 2026, e a disponibilidade geral está planejada para 19 de novembro de 2026.

A conclusão

O Apple container 1.0 é o sinal mais claro em anos de que a Apple leva a sério o desenvolvimento Linux no Mac. Uma VM por contêiner é um design genuinamente diferente do Docker Desktop, e o certo para um mundo em que agentes de IA executam código que ninguém leu. As máquinas de contêiner transformam um Mac em uma estação de trabalho Linux confortável, sem precisar de um gerenciador de VM separado. O ritmo desde junho, oito versões, um plugin de Kubernetes, uma versão de segurança e uma skill para agentes, sugere que a Apple pretende continuar.

Também é jovem. Sem Compose, sem políticas de reinício, sem GUI e sem GPU, a maioria das equipes com stacks de vários serviços deve manter o Docker Desktop ou o OrbStack por enquanto, e tratar o Apple container como a ferramenta para contêineres únicos, ambientes Linux e trabalhos que exigem isolamento. Isso não é uma crítica; é o que a versão 1.x é.

Ao redor dele, 2026 reformulou o resto da stack: a saída da Intel do toolchain do Mac agora tem datas definidas, as ferramentas centrais ficaram mais rápidas ao serem reescritas em Go e Rust, os padrões de segurança ficaram mais rígidos, e a IA passou de escrever seu código para reescrever seu runtime e encontrar os bugs no seu banco de dados. Os desenvolvedores que vão sentir isso menos são os que se movem com deliberação: fazem backup, testam em uma branch, isolam os agentes em sandbox e aposentam os Macs Intel antes que o Homebrew o faça por eles.


Usa Apple container, OrbStack ou Podman no seu Mac? Gostaria de saber o que você roda, o que quebrou e o que você mediu. Correções e contraprovas são bem-vindas: este artigo é atualizado conforme essas ferramentas lançam novas versões.

Divulgação: Este artigo não contém links de afiliados nem conteúdo patrocinado. Minha empresa, Graham Miranda UG (haftungsbeschränkt), presta serviços de hospedagem e TI e não ganha nada com nenhuma ferramenta ou empresa mencionada. Nenhuma empresa mencionada aqui revisou ou aprovou este artigo.

Última atualização: 12 de novembro de 2026.

pt_BRPortuguês do Brasil