Conheça a CLI do Unity : gerencie o Unity a partir do seu terminal.

TL;DR

• Já disponível : o Unity CLI é um binário Unity independente para gerenciar e interagir com editores, módulos, projetos e autenticação a partir do terminal. Sem necessidade de interface gráfica; instale via linha de comando.
• Projetado para automação: saída estruturada em JSON/TSV, códigos de saída claros, instalações não interativas e autenticação de conta de serviço para CI.
• Também disponível hoje : o pacote experimental com.unity.pipeline permite que a CLI controle um Editor em execução ou uma versão de desenvolvimento do Player por meio de uma API local. Você pode expor seus próprios comandos com um atributo [CliCommand] .
• O comando `unity command eval` executa código C# em tempo real dentro de um Editor ou Player em execução e retorna o resultado, sem a necessidade de recompilação em nível de projeto ou recarregamento de domínio.
• Em conjunto, permitem que agentes de IA operem o Unity: observem um projeto em andamento, atuem sobre ele e verifiquem o resultado.

Cada vez mais, o desenvolvimento acontece no terminal: em scripts, em CI e, cada vez mais, nas mãos de agentes de IA. Hoje, a Unity te encontra lá. A CLI do Unity traz o Unity para o terminal em todos os níveis: instale e gerencie editores com um único binário, controle um editor em execução a partir de um script e até mesmo execute código C# diretamente no seu projeto, sem precisar recompilar. É um único comando Unity rápido, e cada camada vai além da anterior: a CLI gerencia o Unity, o pacote Pipeline o controla e o eval acessa seu interior. Tanto a CLI quanto o pacote Pipeline já estão disponíveis.

Antes de nos aprofundarmos no assunto, vejamos o que é possível quando essas funcionalidades se combinam:

O que é a CLI do Unity ?

A CLI é distribuída como um único arquivo binário independente. Não há dependências para instalar, e a instalação se adiciona ao seu PATH: basta executá-la como `unity` e atualizá-la no local com `unity upgrade` . Além de editores e projetos, ele também gerencia módulos e autenticação, portanto, uma máquina nova não precisa de mais nada.

Por ser um binário nativo, ele inicia rapidamente, enquanto o antigo caminho headless do Unity Hub ( -- --headless ) demorava consideravelmente mais. Essa diferença se acumula ao longo das dezenas de chamadas que um script ou agente faz por trabalho.

Comece a usar

Instale-o usando o gerenciador de pacotes da sua plataforma:

# macOS or Linux
curl -fsSL https://public-cdn.cloud.unity3d.com/hub/prod/cli/install.sh | UNITY_CLI_CHANNEL=beta bash

# Windows
$env:UNITY_CLI_CHANNEL='beta'; irm https://public-cdn.cloud.unity3d.com/hub/prod/cli/install.ps1 | iex

(Observação: Em breve haverá suporte para gerenciadores de pacotes padrão como brew, winget e apt. Consulte a documentação da CLI para obter a versão mais recente.

Explore as opções disponíveis:

unity --help

Instalar um editor com os módulos necessários é muito simples:

unity install 6000.2.10f1 -m android ios webgl

A partir daí, os comandos funcionam como você esperaria: `unity editors` para ver o que está instalado, `unity open` para iniciar um projeto com o editor correto selecionado e `unity auth login` para fazer login. Não tem certeza de quais IDs de módulo uma versão possui? O comando `unity modules list 6000.2.10f1` resolve isso para você.

Projetado para automação

A CLI foi criada para funcionar dentro de sistemas de automação, e não apenas como um shell interativo. Cada comando pode gerar uma saída estruturada que você pode direcionar diretamente para suas ferramentas:

unity editors --format json
unity editors --format tsv

Os erros são enviados para stderr , os resultados para stdout e os códigos de saída seguem um padrão simples ( 0 sucesso, 1 erro, 130 cancelado), de modo que as falhas são fáceis de detectar em um pipeline.

Para instalações não supervisionadas, ignore todos os avisos:

unity install 6000.2.10f1 -m android ios --accept-eula --yes

Em um agente de compilação sem interface gráfica, a autenticação é feita com uma conta de serviço por meio de variáveis ​​de ambiente. Sem navegador, sem etapas manuais. E o Unity Doctor diagnostica problemas de ambiente, credenciais e configuração.

Conversando com o editor

Gerenciar instalações é apenas metade da história. A CLI do Unity também pode controlar um Editor em execução .

Uma vez adicionado a um projeto, o com.unity.pipeline permite que um Editor em execução receba comandos da CLI diretamente da sua máquina. Ele funciona com o Unity 6.0 LTS e versões mais recentes, e transforma o Editor em um alvo de automação programável para scripts, tarefas de CI e ferramentas de agentes.

Adicioná-lo a um projeto é um comando único:

unity pipeline install

Você pode verificar quais dos seus projetos o têm instalado com o comando `unity pipeline list` . Com o pacote instalado, você pode executar comandos registrados em um Editor conectado (ou até mesmo em um ambiente de execução do Player) diretamente do terminal:

# List the commands a connected Editor exposes
unity command

# Run one of them
unity command <command-name>

Esses comandos não formam um conjunto fixo. Qualquer método estático em seu projeto se torna um método estático ao adicionar um atributo [CliCommand] , com [CliArg] em seus parâmetros:

using Unity.Pipeline.Commands;
using UnityEngine;

public static class MyPipelineCommands
{
    [CliCommand("greet", "Log a greeting and return its length")]
    public static int Greet(
        [CliArg("name", "Who to greet", Required = true)] string name)
    {
        Debug.Log($"Hello, {name}!");
        return name.Length;
    }
}

O pacote o descobre automaticamente, sem necessidade de registro. O comando `unity command greet --name World` é executado no Editor conectado e retorna o resultado.

O pacote Pipeline já está disponível. Atualmente está em fase experimental , portanto, espere que evolua. Ele permite automatizar tarefas que antes exigiam a intervenção humana no Editor: acionar importações, executar testes e criar ferramentas personalizadas.

Não se limita ao Editor. Inclua o componente de tempo de execução em uma versão de desenvolvimento e seu jogo em execução exporá o mesmo tipo de API. Use a CLI para acessar o player com o comando `unity command --runtime ` para obter logs em tempo real, consultar o status da execução ou recarregar o código em uma versão que já está em execução. É exclusivo para localhost e está desativado por padrão (para versões de desenvolvimento e controle de qualidade, nunca para produção), mas transforma um Player em execução em algo que um script, ambiente de teste ou agente de IA pode controlar em uma instância de tempo de execução real.

Execute scripts C# com eval.

Os comandos registrados abrangem as operações que você previu. O comando `unity command eval` abrange aquelas que você não previu. Ele avalia uma expressão C# arbitrária dentro de um Editor em execução e retorna o resultado: um ambiente REPL (Read-Eval-Print Loop) em tempo real para o seu projeto, a partir do terminal.

unity command eval "return Application.version;"
unity command eval "return UnityEditor.EditorApplication.isPlaying;"
unity command eval "var s = Application.dataPath; return s.Length;" --json
unity command eval_file "path/to/script.cs"

Ele é compilado com Roslyn e executado na thread principal do Editor, portanto, alcança qualquer mecanismo ou API de editor que seu projeto suporte, e a mesma flag --runtime o direciona para um Player em execução. Como esse poder é mútuo, a avaliação (eval) é protegida por um token de segurança. Sem comandos predefinidos, sem plugins, sem recompilação: se você consegue expressar uma pergunta em C#, você consegue perguntar a uma instância do Unity em execução.

A vantagem é a velocidade. O ciclo usual de alteração e verificação (editar, recompilar, reiniciar) leva, no máximo, alguns segundos; a função `eval` retorna respostas em milissegundos em uma instância que já está em execução. Ao longo das inúmeras chamadas que um script ou um agente faz em uma sessão, essa diferença se acumula, e é exatamente isso que proporciona a um agente de IA um ciclo de feedback preciso em vez de um lento.

Uma base para o desenvolvimento assistido por IA

Esses elementos (uma CLI programável, um editor programável e um REPL em tempo real) oferecem muito mais do que mera conveniência. São eles que tornam possível a demonstração no início deste post e transformam o Unity em um ambiente no qual um agente de IA pode realmente trabalhar.

Os assistentes de programação com IA são bons em escrever código e conteúdo. Historicamente, eles têm tido dificuldades com tudo relacionado a isso: gerenciar o projeto, identificar o que deu errado e tentar novamente. Um assistente pode gerar um script de jogo, mas não pode executar os testes para verificar se ele funciona. A CLI do Unity e a camada Pipeline resolvem essa lacuna.

Duas propriedades fazem a diferença. Primeiro, a CLI usa uma linguagem que os agentes entendem: JSON estruturado e um contrato de código de saída previsível significam que um modelo obtém resultados claros e analisáveis ​​em vez de texto extraído do console. As mesmas qualidades que o tornam confiável em CI o tornam confiável como uma ferramenta que um agente utiliza.

Em segundo lugar, o pacote Pipeline torna o Editor autodescritivo: execute o comando `unity` sem argumentos e um Editor conectado relatará as operações que ele expõe. Um agente descobre o que pode fazer em tempo de execução, em vez de depender de uma lista predefinida. E como os comandos são registrados com atributos simples, sua equipe pode expor operações específicas do projeto como ferramentas que podem ser chamadas pelo agente. Isso significa que cada comando registrado se relaciona naturalmente com o tipo de ferramenta que um agente já sabe como invocar.

Junte tudo isso e você terá um verdadeiro ciclo de feedback: um assistente pode abrir o projeto, aplicar uma alteração, executar os testes, entrar no modo de reprodução para verificar o comportamento, ler o resultado e decidir o que fazer em seguida, sem que um humano precise ficar transmitindo informações de um lado para o outro. Essa é a mudança de um assistente que sugere para um que pode verificar . É também uma solução natural para os padrões de agentes emergentes: cada comando registrado corresponde ao tipo de ferramenta que um modelo de chamada de função ou servidor MCP já sabe como invocar.

E não existe uma lista fixa do que um agente pode fazer. Como o eval acessa qualquer API que seu projeto possa chamar, a superfície de capacidade de um agente é a mesma do Unity: renderização, física, animação, banco de dados de ativos, o próprio Editor, além de tudo o que seu próprio código adicionar. Esse alcance é resultado de mais de uma década de trabalho com API , e um agente o obtém sem qualquer integração adicional.

Estamos no início disso, e os povos primitivos já estão aqui hoje. Se você estiver criando ferramentas com auxílio de IA para Unity, o pacote Pipeline é um bom ponto de partida.

Como isso se relaciona com as ofertas de IA da Unity

Se você utiliza os recursos de IA da Unity, como o conjunto de assistentes integrados ao editor, esta é a camada subjacente. A IA (Inteligência Artificial) do Unity é a parte que raciocina sobre o seu projeto e decide o que fazer. A CLI e o pacote Pipeline são a superfície de execução que concretiza essas decisões: rápidas, locais e com controle por token. A mesma interface está aberta a qualquer agente, seja ele a ferramenta própria da Unity roteando através do seu servidor MCP, um assistente de terceiros ou um script que você mesmo escreva. A IA da Unity é uma consumidora dela, não uma substituta.

Disponível agora

A CLI do Unity está aqui. Instale-o, execute `unity --help` e incorpore-o ao seu próximo script de compilação ou tarefa de CI, ou automatize-o com um agente. A documentação contém a referência completa dos comandos. Conte-nos o que você está construindo; seu feedback moldará os próximos passos.

Declaração de porto seguro: Este roteiro representa as intenções atuais da Unity para o desenvolvimento de nosso conjunto de produtos. Este conteúdo é fornecido apenas para fins informativos e não constitui um compromisso de disponibilizar qualquer recurso ou funcionalidade específica. As informações fornecidas estão sujeitas a alterações a qualquer momento, e a Unity não oferece garantias quanto ao conteúdo, cronograma ou natureza de quaisquer lançamentos futuros. O usuário não deve confiar neste roteiro para tomar decisões críticas para os negócios.