Attention: Here be dragons

This is the latest (unstable) version of this documentation, which may document features not available in or compatible with released stable versions of Godot.

Checking the stable version of the documentation...

Compilando para Windows

Ver também

Esta página descreve como compilar os binários do editor e do modelo de exportação do Windows a partir do código-fonte. Se você deseja exportar seu projeto para o Windows, leia Exportando para Windows.

Requisitos

Para compilar no Windows, o seguinte é necessário:

• Um compilador C++. Use uma das seguintes opções:

  • Visual Studio Community, versão 2019 ou posterior. O Visual Studio 2022 é recomendado. Durante a instalação, certifique-se de selecionar C++ na lista de fluxos de trabalho e selecione os seguintes componentes individuais:

    Visual Studio 2019Visual Studio 2022Visual Studio 2026

    • MSVC v142 - VS 2019 C++ {arch} build tools (Latest) para as arquiteturas de destino.

    • Windows 11 SDK (10.0.22621.0) (versão exata).

    Se você já instalou o Visual Studio sem suporte a C++ para a arquitetura de destino, ou sem o SDK do Windows, execute o instalador novamente; ele deve apresentar um botão Modify. Suporta x86_64, x86_32 e arm64.

  • MinGW-w64 com GCC pode ser usado como alternativa ao Visual Studio. Certifique-se de instalá-lo/configurá-lo para usar o modelo de thread posix. Importante: Ao usar o MinGW para compilar o ramo master, você precisa do GCC 12 ou posterior. Suporta apenas x86_64 e x86_32.

  • MinGW-LLVM com clang pode ser usado como alternativa ao Visual Studio e MinGW-w64. Importante: Ao usar o MinGW para compilar o ramo master, você precisa do clang 14 ou posterior. Suporta x86_64, x86_32 e arm64.

• Python 3.9+. Certifique-se de ativar a opção de adicionar o Python ao PATH no instalador.

• Sistema de compilação SCons 4.4+. O uso da versão mais recente é recomendado, especialmente para o suporte adequado de lançamentos recentes do Visual Studio.

• Dependências do Direct3D 12 (pode ser pulado com a opção do SCons d3d12=no se o suporte ao Direct3D 12 não for desejado).

Nota

Se você tem o Scoop instalado, pode facilmente instalar o MinGW e outras dependências usando o seguinte comando:

scoop install python mingw

O Scons ainda precisará ser instalado via pip

Nota

Se você tem o MSYS2 instalado, pode facilmente instalar o MinGW e outras dependências usando o seguinte comando:

pacman -S mingw-w64-x86_64-gcc mingw-w64-i686-gcc make python-pip

For each MSYS2 MinGW subsystem, you should then run pip3 install scons in its shell.

Ver também

Para obter o código-fonte do Godot para compilação, consulte Adquirindo o código fonte.

Para uma visão geral do uso do SCons no Godot, veja Introdução ao sistema de compilação.

Configurando SCons

Para instalar o SCons, abra o prompt de comando e execute o seguinte comando:

python -m pip install scons

Se você receber a mensagem Defaulting to user installation because normal site-packages is not writeable, pode ser necessário executar esse comando novamente usando permissões elevadas. Abra um novo prompt de comando como Administrador e execute o comando novamente para garantir que o SCons esteja disponível no PATH.

To verificar se você instalou o Python e o SCons corretamente, você pode digitar python --version e scons --version em um prompt de comando (cmd.exe).

Se os comandos acima não funcionarem, certifique-se de adicionar o Python à sua variável de ambiente PATH após instalá-lo e verifique novamente. Você pode fazer isso executando o instalador do Python novamente e ativando a opção de adicionar o Python ao PATH.

Se o SCons não conseguir detectar sua instalação do Visual Studio, pode ser que a sua versão do SCons seja muito antiga. Atualize-a para a versão mais recente com python -m pip install --upgrade scons.

Download do código-fonte do Godot

Consulte Adquirindo o código fonte para instruções detalhadas.

O tutorial assumirá de agora em diante que você colocou o código-fonte em C:\\godot.

Aviso

Para evitar lentidões causadas pela verificação contínua de vírus durante a compilação, adicione a pasta de origem do Godot à lista de exceções do seu software antivírus.

Para o Windows Defender, pressione a tecla Windows, digite "Segurança do Windows" e pressione Enter. Clique em Proteção contra vírus e ameaças no painel esquerdo. Em Configurações de proteção contra vírus e ameaças, clique em Gerenciar configurações e role para baixo até Exclusões. Clique em Adicionar ou remover exclusões e adicione a pasta de origem do Godot.

Compilando

Selecionando um compilador

O SCons encontrará e usará automaticamente uma instalação existente do Visual Studio. Se você não tiver o Visual Studio instalado, ele tentará usar o MinGW. Se você já tem o Visual Studio instalado e deseja usar o MinGW-w64, passe use_mingw=yes para a linha de comando do SCons. Note que as compilações MSVC não podem ser realizadas a partir dos shells MSYS2 ou MinGW. Use o cmd.exe ou o PowerShell. Se você estiver usando o MinGW-LLVM, passe tanto use_mingw=yes quanto use_llvm=yes para la linha de comando do SCons.

Dica

Durante o desenvolvimento, usar o compilador do Visual Studio geralmente é uma ideia melhor, pois ele vincula o binário do Godot muito mais rápido do que o MinGW. No entanto, o MinGW pode produzir binários mais otimizados usando a otimização em tempo de vinculação (veja abaixo), tornando-o uma escolha melhor para uso em produção. Este é particularmente o caso da VM do GDScript, que se comporta muito melhor com o MinGW em comparação com o MSVC. Portanto, é recomendável usar o MinGW para produzir compilações que você distribuirá aos jogadores.

Todos os binários oficiais do Godot são compilados em contêineres personalizados usando MinGW.

Executando SCons

Depois de abrir um prompt de comando, mude para o diretório raiz do código-fonte da engine (usando cd) e digite:

C:\godot> scons platform=windows

Nota

Ao compilar com vários threads de CPU, os SCons podem avisar sobre a falta do pywin32. Você pode ignorar este alerta com segurança.

Dica

Se você está compilando o Godot para fazer alterações ou contribuir para a engine, você pode querer usar as opções do SCons dev_build=yes ou dev_mode=yes. Veja Aliases de desenvolvimento e produção para mais informações.

Se tudo correr bem, o executável binário resultante será colocado em C:\\godot\\bin\\ com o nome godot.windows.editor.x86_32.exe ou godot.windows.editor.x86_64.exe. Por padrão, o SCons compilará um binário correspondente à arquitetura da sua CPU, mas isso pode ser substituído usando arch=x86_64, arch=x86_32 ou arch=arm64.

Este arquivo executável contém toda a engine e roda sem dependências. Executá-lo abrirá o Gerenciador de Projetos.

Dica

Se você está compilando o Godot para uso em produção, pode tornar o executável final menor e mais rápido adicionando a opção do SCons production=yes. Isso ativa otimizações adicionais do compilador e otimização em tempo de vinculação (LTO).

A LTO leva algum tempo para ser executada e requer até 30 GB de RAM disponível durante a compilação (dependendo da toolchain). Se você estiver ficando sem memória com a opção acima, use production=yes lto=none ou production=yes lto=thin (apenas LLVM) para uma forma leve, mas menos eficaz de LTO.

Nota

Se você deseja usar configurações de editor separadas para suas próprias compilações do Godot e lançamentos oficiais, pode ativar o Modo autocontido criando um arquivo chamado ._sc_ ou _sc_ na pasta bin/.

Instalando os requisitos do Direct3D 12

Por padrão, as compilações do Godot para Windows contêm suporte para a API gráfica Direct3D 12. A compilação com suporte ao Direct3D 12 requer a instalação de dependências adicionais. Se desejar pular esta etapa, você pode usar a opção do SCons d3d12=no; o suporte ao Vulkan e OpenGL permanecerá disponível se você fizer isso.

Você pode instalar as dependências necessárias executando python misc/scripts/install_d3d12_sdk_windows.py no repositório de origem do Godot. Após executar este script, compile o Godot como de costume. Isso usará os caminhos padrão para as várias dependências, que correspondem aos usados no script.

Você pode encontrar as etapas detalhadas abaixo se desejar configurar as dependências manualmente, mas o script acima cuida de tudo para você (incluindo os componentes opcionais PIX e Agility SDK).

• Biblioteca godot-nir-static. Compilamos as bibliotecas Mesa que você precisará em uma biblioteca estática. Baixe-a em qualquer lugar, descompacte-a e lembre-se do caminho para a pasta descompactada, você precisará dela abaixo.

Nota

Você pode, opcionalmente, compilar as bibliotecas godot-nir-static você mesmo com as seguintes etapas:

1. Instale o pacote Python mako que é necessário para gerar alguns arquivos.

2. Clone o diretório godot-nir-static e navegue até ele.

3. Execute o seguinte:

git submodule update --init
./update_mesa.sh
scons

Se você estiver compilando com o MinGW-w64, adicione use_mingw=yes ao comando scons, você também pode especificar a arquitetura de compilação usando arch={architecture}. Se você estiver compilando com o MinGW-LLVM, adicione tanto use_mingw=yes quanto use_llvm=yes ao comando scons.

Se você estiver compilando com o MinGW e os binários não estiverem localizados no PATH, adicione mingw_prefix=\"/path/to/mingw\" ao comando scons.

A biblioteca estática Mesa deve ser compilada usando o mesmo compilador e o mesmo CRT (se você estiver compilando com o MinGW) que você está usando para compilar o Godot.

Opcionalmente, você pode compilar com o seguinte para recursos adicionais:

• O PIX é um aplicativo de ajuste de desempenho e depuração para aplicativos Direct3D12. Se você compilar o suporte para ele, poderá obter informações muito mais detalhadas através do PIX que o ajudarão a otimizar seu jogo e solucionar bugs gráficos. Para usá-lo, baixe o pacote WinPixEventRuntime. Você será levado a uma página de pacote NuGet onde pode clicar em "Download package" para obtê-lo. Uma vez baixado, altere a extensão do arquivo para .zip e descompacte o arquivo em algum caminho.

• O Agility SDK pode ser usado para fornecer acesso aos recursos mais recentes do Direct3D 12 sem depender de atualizações de driver. Para usá-lo, baixe o pacote Agility SDK mais recente. Você será levado a uma página de pacote NuGet onde pode clicar em "Download package" para obtê-lo. Uma vez baixado, altere a extensão do arquivo para .zip e descompacte o arquivo em algum caminho.

Nota

Se você usa uma versão de visualização do Agility SDK, lembre-se de ativar o modo de desenvolvedor no Windows; caso contrário, ele não será usado.

Nota

Se você deseja usar um PIX com compilação MinGW, navegue até o diretório de tempo de execução do PIX e use os seguintes comandos para gerar a biblioteca de importação:

# For x86-64:
gendef ./bin/x64/WinPixEventRuntime.dll
dlltool --machine i386:x86-64 --no-leading-underscore -d WinPixEventRuntime.def -D WinPixEventRuntime.dll -l ./bin/x64/libWinPixEventRuntime.a

# For ARM64:
gendef ./bin/ARM64/WinPixEventRuntime.dll
dlltool --machine arm64 --no-leading-underscore -d WinPixEventRuntime.def -D WinPixEventRuntime.dll -l ./bin/ARM64/libWinPixEventRuntime.a

Ao compilar o Godot, você precisará dizer ao SCons onde procurar as bibliotecas adicionais:

C:\godot> scons platform=windows mesa_libs=<...>

Ou, com todas as opções ativadas:

C:\godot> scons platform=windows mesa_libs=<...> agility_sdk_path=<...> pix_path=<...>

Nota

O suporte ao PIX é desativado por padrão, mesmo se você o tiver instalado. Para ativá-lo, passe use_pix=yes para o SCons.

Nota

Para as DLLs do Agility SDK, você deve escolher explicitamente o tipo de fluxo de trabalho. Arquitetura única é o padrão (DLLs copiadas para bin/). Se você passar agility_sdk_multi_arch=yes para o SCons, optará por multi-arquitetura. As DLLs serão copiadas para os subdiretórios apropriados bin/<arch>/ e, em tempo de execução, a correta será carregada.

Compilando com suporte ao AccessKit

O AccessKit fornece suporte para leitores de tela.

A compilação com o AccessKit requer a instalação de dependências adicionais. Se desejar pular esta etapa, você pode usar a opção do SCons accesskit=no.

Você pode instalar as dependências necessárias executando python misc/scripts/install_accesskit.py no repositório de origem do Godot. Após executar este script, compile o Godot como de costume.

Nota

Você pode, opcionalmente, compilar as bibliotecas AccessKit você mesmo com as seguintes etapas:

1. Clone o diretório godot-accesskit-c-static e navegue até ele.

2. Execute o seguinte comando:

cd accesskit-c
cmake -S . -B build -DCMAKE_BUILD_TYPE=Release
cmake --build build
cmake --install build

A biblioteca estática AccessKit deve ser compilada usando o mesmo compilador e o mesmo CRT (se você estiver compilando com o MinGW) que você está usando para compilar o Godot.

Para compilar o Godot com uma compilação personalizada do AccessKit, adicione accesskit_sdk_path={path} para dizer ao SCons onde procurar as bibliotecas AccessKit:

scons platform=windows accesskit_sdk_path=<...>

Compilando com suporte ao WinRT

O WinRT fornece suporte para OneCore TTS (acessando vozes do Windows 10+), monitoramento de informações de cores HDR e seletor de emojis.

Se você estiver compilando com o MinGW, a compilação com o WinRT requer a instalação de dependências adicionais. Se desejar pular esta etapa, você pode usar a opção do SCons winrt=no.

Você pode instalar las dependências necessárias executando python misc/scripts/install_winrt.py no repositório de origem do Godot. Após executar este script, compile o Godot como de costume.

Nota

Você pode opcionalmente construir os cabeçalhos WinRT por conta própria com os seguintes passos:

1. Clone o diretório winrt-mingw e navegue até ele.

2. Execute o seguinte comando:

cmake -Bbuild -DCMAKE_BUILD_TYPE=Release -DCPPWINRT_BUILD_VERSION=2.0.250303.1 -DBUILD_TESTING=OFF cppwinrt/
echo "" > build/app.manifest.rc
cmake --build build
./build/cppwinrt.exe -input windows-rs/crates/libs/bindgen/default/ -output include/

Para compilar o Godot com uma compilação personalizada do WinRT, adicione winrt_path={path} para dizer ao SCons onde procurar os cabeçalhos WinRT:

scons platform=windows winrt_path=<...>

Compilando com suporte ao ANGLE

O ANGLE fornece uma camada de tradução do OpenGL ES 3.x para o Direct3D 11 e pode ser usado para melhorar o suporte ao renderizador de Compatibilidade em algumas GPUs mais antigas com drivers OpenGL desatualizados e no Windows para ARM.

A compilação com o ANGLE requer a instalação de dependências adicionais. Se desejar pular esta etapa, você pode usar a opção do SCons angle=no.

Você pode instalar as dependências necessárias executando python misc/scripts/install_angle.py no repositório de origem do Godot. Após executar este script, compile o Godot como de costume.

Nota

Você pode, opcionalmente, compilar as bibliotecas godot-angle-static você mesmo com as seguintes etapas:

1. Clone o diretório godot-angle-static e navegue até ele.

2. Execute o seguinte comando:

git submodule update --init
./update_angle.sh
scons

Se você estiver compilando com o MinGW, adicione use_mingw=yes ao comando, você também pode especificar a arquitetura de compilação usando arch={architecture}. Se você estiver compilando com o MinGW-LLVM, adicione tanto use_mingw=yes quanto use_llvm=yes ao comando scons.

Se você estiver compilando com o MinGW e os binários não estiverem localizados no PATH, adicione mingw_prefix=\"/path/to/mingw\" ao comando scons.

A biblioteca estática ANGLE deve ser compilada usando o mesmo compilador e o mesmo CRT (se você estiver compilando com o MinGW) que você está usando para compilar o Godot.

Para compilar o Godot com uma compilação personalizada do ANGLE, adicione angle_libs={path} para dizer ao SCons onde procurar as bibliotecas ANGLE:

scons platform=windows angle_libs=<...>

Desenvolvimento no Visual Studio

O uso de uma IDE não é necessário para compilar o Godot, já que o SCons cuida de tudo. Mas se você pretende fazer o desenvolvimento da engine ou depuração do código C++ da engine, pode estar interessado em configurar um editor de código ou uma IDE.

Editores baseados em pastas não exigem nenhuma configuração específica para começar a trabalhar com a base de código do Godot. Para editar projetos com o Visual Studio, eles precisam ser configurados como uma solução.

Você pode criar uma solução do Visual Studio via SCons executando o SCons com o parâmetro vsproj=yes, assim:

scons platform=windows vsproj=yes

Você poderá abrir a origem do Godot em uma solução do Visual Studio agora e poderá compilar o Godot usando o botão Build do Visual Studio.

Ver também

Veja Visual Studio para mais detalhes.

Solução de problemas

Se você receber uma falha de compilação ao usar o MSVC, certifique-se de aplicar as atualizações mais recentes. Você pode fazer isso iniciando a IDE do Visual Studio e usando Continue without code, depois Help > Check for Updates na barra de menu no topo. Instale todas as atualizações e tente compilar novamente.

Compilação cruzada para Windows a partir de outros sistemas operacionais

Se você é um usuário de Linux ou macOS, precisa instalar o MinGW-w64, que normalmente vem em variantes de 32 e 64 bits, ou o MinGW-LLVM, que vem como um único arquivo para todas as arquiteturas de destino. Os nomes dos pacotes podem diferir com base na sua distribuição, aqui estão alguns conhecidos:

Arch Linux	pacman -S mingw-w64
Debian / Ubuntu	apt install mingw-w64
Fedora	dnf install mingw64-gcc-c++ mingw64-winpthreads-static \ mingw32-gcc-c++ mingw32-winpthreads-static
macOS	brew install mingw-w64
Mageia	urpmi mingw64-gcc-c++ mingw64-winpthreads-static \ mingw32-gcc-c++ mingw32-winpthreads-static

Antes de tentar a compilação, o SCons verificará os seguintes binários na sua variável de ambiente PATH:

# for MinGW-w64
i686-w64-mingw32-gcc
x86_64-w64-mingw32-gcc

# for MinGW-LLVM
aarch64-w64-mingw32-clang
i686-w64-mingw32-clang
x86_64-w64-mingw32-clang

Se os binários não estiverem localizados no PATH (por exemplo, /usr/bin), você pode definir a seguinte variável de ambiente para dar uma dica ao sistema de compilação:

export MINGW_PREFIX="/path/to/mingw"

Onde /path/to/mingw é o caminho que contém o diretório bin onde i686-w64-mingw32-gcc e x86_64-w64-mingw32-gcc estão localizados (por exemplo, /opt/mingw-w64 se os binários estiverem localizados em /opt/mingw-w64/bin).

Para se certificar de que está fazendo as coisas corretamente, a execução do seguinte no shell deve resultar em um compilador funcionando (a saída da versão pode diferir com base no seu sistema):

${MINGW_PREFIX}/bin/x86_64-w64-mingw32-gcc --version
# x86_64-w64-mingw32-gcc (GCC) 13.2.0

Nota

Se você estiver compilando com o MinGW-LLVM, adicione use_llvm=yes ao comando scons.

Nota

Ao compilar de forma cruzada para o Windows usando o MinGW-w64, tenha em mente que apenas as arquiteturas x86_64 e x86_32 são suportadas. O MinGW-LLVM também suporta arm64. Certifique-se de especificar a opção arch= correta ao invocar o SCons se estiver compilando a partir de uma arquitetura diferente.

Solução de problemas

A compilação cruzada a partir de algumas versões do Ubuntu pode levar a este bug, devido a uma configuração padrão que carece de suporte para threading POSIX.

Você pode alterar essa configuração seguindo estas instruções, para 64 bits:

sudo update-alternatives --config x86_64-w64-mingw32-gcc
<choose x86_64-w64-mingw32-gcc-posix from the list>
sudo update-alternatives --config x86_64-w64-mingw32-g++
<choose x86_64-w64-mingw32-g++-posix from the list>

E para 32 bits:

sudo update-alternatives --config i686-w64-mingw32-gcc
<choose i686-w64-mingw32-gcc-posix from the list>
sudo update-alternatives --config i686-w64-mingw32-g++
<choose i686-w64-mingw32-g++-posix from the list>

Criando modelos de exportação do Windows

Os modelos de exportação do Windows são criados compilando o Godot sem o editor, com as seguintes flags:

C:\godot> scons platform=windows target=template_debug arch=x86_32
C:\godot> scons platform=windows target=template_release arch=x86_32
C:\godot> scons platform=windows target=template_debug arch=x86_64
C:\godot> scons platform=windows target=template_release arch=x86_64
C:\godot> scons platform=windows target=template_debug arch=arm64
C:\godot> scons platform=windows target=template_release arch=arm64

Se você planeja substituir os modelos de exportação padrão, copie-os para o seguinte local, substituindo <version> pelo identificador da versão (como 4.2.1.stable ou 4.3.dev):

%APPDATA%\Godot\export_templates\<version>\

Com os seguintes nomes:

windows_debug_x86_32_console.exe
windows_debug_x86_32.exe
windows_debug_x86_64_console.exe
windows_debug_x86_64.exe
windows_debug_arm64_console.exe
windows_debug_arm64.exe
windows_release_x86_32_console.exe
windows_release_x86_32.exe
windows_release_x86_64_console.exe
windows_release_x86_64.exe
windows_release_arm64_console.exe
windows_release_arm64.exe

No entanto, se você estiver usando módulos personalizados ou código de engine personalizado, pode preferir configurar seus binários como modelos de exportação personalizados no menu de exportação do projeto. Você deve ter as Advanced Options ativadas para definir isso.

Você não precisa copiá-los neste caso, basta referenciar os arquivos resultantes no diretório bin\\ da sua pasta de origem do Godot, para que na próxima vez que você compilar, os modelos personalizados sejam referenciados automaticamente.