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 Linux, *BSD

Ver também

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

Requisitos

Para compilar no Linux ou outras variantes do Unix, o seguinte é necessário:

  • GCC 9+ ou Clang 6+.

  • Python 3.9+.

  • Sistema de build SCons 4.4+.

  • pkg-config (usado para detectar as bibliotecas de desenvolvimento listadas abaixo).

  • Bibliotecas de desenvolvimento:

    • X11, Xcursor, Xinerama, Xi e XRandR.

    • Wayland e wayland-scanner.

    • Mesa.

    • ALSA.

    • PulseAudio.

  • Opcional - libudev (compile com udev=yes).

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.

Comandos de uma linha específicos por distribuição

apk add \
  scons \
  pkgconf \
  gcc \
  g++ \
  libx11-dev \
  libxcursor-dev \
  libxinerama-dev \
  libxi-dev \
  libxrandr-dev \
  mesa-dev \
  eudev-dev \
  alsa-lib-dev \
  pulseaudio-dev

Compilando

Inicie um terminal, vá para o diretório raiz do código-fonte da engine e digite:

scons platform=linuxbsd

Nota

Antes do Godot 4.0, o alvo Linux/*BSD era chamado de x11 em vez de linuxbsd. Se você deseja compilar o Godot 3.x, certifique-se de usar o ramo 3.x desta documentação.

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 no subdiretório "bin". Este arquivo executável contém toda a engine e roda sem dependências. Executá-lo abrirá o Gerenciador de Projetos.

Nota

Se você deseja compilar usando o Clang em vez do GCC, use este comando:

scons platform=linuxbsd use_llvm=yes

O uso do Clang parece ser um requisito para o OpenBSD, caso contrário, as fontes não seriam compiladas. Para dispositivos com arquitetura RISC-V, use o compilador Clang em vez do compilador GCC.

Nota

A compilação em algumas plataformas, como o OpenBSD, pode exigir mais memória do que o disponível por padrão. Para aumentar o limite de memória no OpenBSD dentro do máximo para o usuário atual, execute ulimit -d {nova quantidade em kB}.

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 rodar e requer cerca de 7 GB de RAM disponível durante a compilação. Se você estiver ficando sem memória com a opção acima, use production=yes lto=none ou production=yes lto=thin 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/.

Compilando com suporte ao AccessKit

O AccessKit fornece suporte para leitores de tela.

Por padrão, o Godot é compilado com o AccessKit vinculado dinamicamente. Você pode usá-lo colocando o accesskit.so ao lado do executável.

Nota

Você também pode usar o AccessKit vinculado dinamicamente com os modelos de exportação; renomeie o SO para accesskit.{architecture}.so e coloque-os ao lado os executáveis do modelo de exportação, e as bibliotecas serão copiadas automaticamente durante o processo de exportação.

Para compilar o Godot com o AccessKit vinculado estaticamente:

  • Baixe as bibliotecas estáticas pré-compiladas da biblioteca godot-accesskit-c-static e descompacte-as.

  • Ao compilar o Godot, adicione accesskit_sdk_path={path} para dizer ao SCons onde procurar as bibliotecas do AccessKit:

    scons platform=linuxbsd accesskit_sdk_path=<...>

Nota

Você pode, opcionalmente, compilar as bibliotecas godot-angle-static 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 do AccessKit deve ser compilada usando o mesmo compilador que você está usando para compilar o Godot.

Executando um build headless/servidor

Para rodar no modo headless (sem interface), que fornece funcionalidade de editor para exportar projetos de forma automatizada, use a compilação normal:

scons platform=linuxbsd target=editor

E então, use o argumento de linha de comando --headless:

./bin/godot.linuxbsd.editor.x86_64 --headless

Para compilar uma build de servidor de depuração que pode ser usada com ferramentas de depuração remota, use:

scons platform=linuxbsd target=template_debug

Para compilar uma build de servidor que é otimizada para rodar servidores de jogos dedicados, use:

scons platform=linuxbsd target=template_release production=yes

Construindo modelos de exportação

Aviso

Os binários do Linux geralmente não rodam em distribuições que são mais antigas do que a distribuição na qual foram compilados. Se você deseja distribuir binários que funcionem na maioria das distribuições, deve compilá-los em uma distribuição antiga, como o Ubuntu 20.04. Você pode usar uma máquina virtual ou um contêiner para configurar um ambiente de compilação adequado.

Para compilar modelos de exportação para Linux ou *BSD, execute o sistema de compilação com os seguintes parâmetros:

  • (32 bits)

scons platform=linuxbsd target=template_release arch=x86_32
scons platform=linuxbsd target=template_debug arch=x86_32

  • (64 bits)

scons platform=linuxbsd target=template_release arch=x86_64
scons platform=linuxbsd target=template_debug arch=x86_64

Note que a compilação cruzada para os bits opostos (64/32) em relação à sua plataforma host nem sempre é simples e pode precisar de um ambiente chroot.

Para criar modelos de exportação padrão, os arquivos resultantes na pasta bin/ devem ser copiados para:

$HOME/.local/share/godot/export_templates/<version>/

e nomeados desta forma (mesmo para o *BSD, que é visto como "Linux/X11" pelo Godot):

linux_debug.arm32
linux_debug.arm64
linux_debug.x86_32
linux_debug.x86_64
linux_release.arm32
linux_release.arm64
linux_release.x86_32
linux_release.x86_64

No entanto, se você estiver escrevendo seus próprios módulos personalizados ou código C++ 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.

../../../_images/lintemplates.webp

Você nem precisa copiá-los, pode apenas 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.

Compilação cruzada para dispositivos RISC-V

Para compilar o Godot de forma cruzada para dispositivos RISC-V, precisamos configurar os seguintes itens:

  • riscv-gnu-toolchain. Embora não instalemos isso para usar diretamente, ele nos fornece um sysroot, bem como arquivos de cabeçalho e bibliotecas que precisaremos. Existem muitas versões para escolher, no entanto, quanto mais antiga a toolchain, mais compatíveis serão os nossos binários finais. Em caso de dúvida, use esta versão e baixe o riscv64-glibc-ubuntu-20.04-gcc-nightly-2023.07.07-nightly.tar.gz. Extraia-o em algum lugar e lembre-se do seu caminho.

  • mold. Este vinculador (linker) rápido é o único que vincula corretamente o binário resultante. Baixe-o, extraia-o e certifique-se de adicionar a pasta bin dele ao seu PATH. Execute mold --help | grep support para verificar se a sua versão do Mold suporta RISC-V. Se você não vir RISC-V, seu Mold pode precisar ser atualizado.

Para facilitar a referência à nossa toolchain, podemos definir uma variável de ambiente assim:

export RISCV_TOOLCHAIN_PATH="path to toolchain here"

Dessa forma, não teremos que definir manualmente o local do diretório toda vez que quisermos referenciá-lo.

Com toda a configuração acima concluída, agora estamos prontos para compilar o Godot.

Vá para a raiz do código-fonte e execute o seguinte comando de build:

PATH="$RISCV_TOOLCHAIN_PATH/bin:$PATH" \
scons arch=rv64 use_llvm=yes linker=mold lto=none target=editor \
    ccflags="--sysroot=$RISCV_TOOLCHAIN_PATH/sysroot --gcc-toolchain=$RISCV_TOOLCHAIN_PATH -target riscv64-unknown-linux-gnu" \
    linkflags="--sysroot=$RISCV_TOOLCHAIN_PATH/sysroot --gcc-toolchain=$RISCV_TOOLCHAIN_PATH -target riscv64-unknown-linux-gnu"

Nota

O GCC para RISC-V possui bugs com suas operações atômicas que o impedem de compilar o Godot corretamente. É por isso que o Clang é usado no lugar. Certifique-se de que ele pode compilar para RISC-V. Você pode verificar executando o comando clang -print-targets, certificando-se de ver riscv64 na lista de alvos.

Aviso

O código acima inclui a adição de $RISCV_TOOLCHAIN_PATH/bin ao PATH, mas apenas para o seguinte comando scons. Como o riscv-gnu-toolchain usa seu próprio Clang localizado na pasta bin, adicionar $RISCV_TOOLCHAIN_PATH/bin à variável de ambiente PATH do seu usuário pode impedir você de acessar outra versão do Clang, caso haja uma instalada. Por esse motivo, não é recomendado tornar a adição da pasta bin permanente. Você também pode omitir a linha PATH=\"$RISCV_TOOLCHAIN_PATH/bin:$PATH\" se quiser usar o scons com uma versão do Clang instalada por conta própria, mas isso pode gerar problemas de compatibilidade com o riscv-gnu-toolchain.

O comando é semelhante em natureza, mas com algumas mudanças importantes. ccflags e linkflags anexam flags adicionais à compilação. --sysroot aponta para uma pasta que simula um sistema Linux, contendo todos os cabeçalhos, bibliotecas e arquivos .so que o Clang usará. --gcc-toolchain diz ao Clang onde a toolchain completa está, e -target riscv64-unknown-linux-gnu indica ao Clang a arquitetura de destino e o SO para o qual queremos compilar.

Se tudo correu bem, você deve ver agora um diretório bin e, dentro dele, um binário semelhante ao seguinte:

godot.linuxbsd.editor.rv64.llvm

Agora você pode copiar esse executável para o seu dispositivo RISC-V favorito e depois iniciá-lo lá clicando duas vezes, o que deve abrir o gerenciador de projetos.

Se você decidir mais tarde compilar os modelos de exportação, copie o comando de compilação acima, mas altere o valor de target para template_debug para uma build de depuração, ou template_release para uma build de lançamento.

Usando Clang e LLD para um desenvolvimento mais rápido

Você também pode usar o Clang e o LLD para compilar o Godot. Isso tem duas vantagens em comparação com a configuração padrão do GCC + GNU ld:

  • O LLD vincula o Godot significativamente mais rápido em comparação com o GNU ld ou gold. Isso leva a tempos de iteração mais rápidos.

  • O Clang tende a fornecer mensagens de erro mais úteis em comparação com o GCC.

Para isso, instale o Clang e o pacote lld usando o gerenciador de pacotes da sua distribuição e, em seguida, utilize o seguinte comando do SCons:

scons platform=linuxbsd use_llvm=yes linker=lld

Após a conclusão da compilação, um novo binário com o sufixo .llvm será criado na pasta bin/.

Ainda é recomendado usar o GCC para compilações de produção, pois é o compilador usado para as compilações oficiais e é testado de forma mais rigorosa.

Se este erro ocorrer:

/usr/bin/ld: cannot find -l:libatomic.a: No such file or directory

Existem duas soluções:

  • No seu comando SCons, adicione o parâmetro use_static_cpp=no.

  • Siga estas instruções para configurar, compilar e instalar o libatomic_ops. Em seguida, copie /usr/lib/libatomic_ops.a para /usr/lib/libatomic.a, ou crie um link simbólico (soft link) para o libatomic_ops com o comando ln -s /usr/lib/libatomic_ops.a /usr/lib/libatomic.a. O link simbólico garante que o libatomic_ops mais recente seja usado sem a necessidade de copiá-lo toda vez que for atualizado.

Usando o mold para um desenvolvimento mais rápido

Para uma vinculação ainda mais rápida em comparação com o LLD, você pode usar o mold. O mold pode ser usado tanto com o GCC quanto com o Clang.

sudo apt-get update
sudo apt-get install -y mold

Uma vez instalado o mold, use o seguinte comando SCons ao compilar o Godot:

scons platform=linuxbsd linker=mold

Usando bibliotecas do sistema para um desenvolvimento mais rápido

O Godot inclui o código-fonte de várias bibliotecas de terceiros. Você pode optar por usar as versões do sistema das bibliotecas de terceiros no lugar. Isso torna o binário do Godot mais rápido de vincular, já que as bibliotecas de terceiros são vinculadas dinamicamente. Portanto, elas não precisam ser vinculadas estaticamente toda vez que você compila a engine (mesmo em pequenas mudanças incrementais).

No entanto, nem todas as distribuições Linux possuem pacotes para bibliotecas de terceiros disponíveis (o elas podem não estar atualizadas).

Mudar para as bibliotecas do sistema pode reduzir os tempos de vinculação em vários segundos em CPUs lentas, mas requer testes manuais dependendo da sua distribuição Linux. Além disso, você pode não conseguir usar as bibliotecas do sistema para tudo devido a bugs nos pacotes de biblioteca do sistema (ou no sistema de compilação, já que esse recurso é menos testado).

Para compilar o Godot com as bibliotecas do sistema, instale estas dependências além daquelas listadas no Comandos de uma linha específicos por distribuição:

sudo apt-get update
sudo apt-get install -y \
  libembree-dev \
  libenet-dev \
  libfreetype-dev \
  libpng-dev \
  zlib1g-dev \
  libgraphite2-dev \
  libharfbuzz-dev \
  libogg-dev \
  libtheora-dev \
  libvorbis-dev \
  libwebp-dev \
  libmbedtls-dev \
  libminiupnpc-dev \
  libpcre2-dev \
  libsdl3-dev \
  libzstd-dev \
  libsquish-dev \
  libicu-dev

Depois de instalar todos os pacotes necessários, use o seguinte comando para compilar o Godot:

scons platform=linuxbsd builtin_embree=no builtin_enet=no builtin_freetype=no builtin_graphite=no builtin_harfbuzz=no builtin_libogg=no builtin_libpng=no builtin_libtheora=no builtin_libvorbis=no builtin_libwebp=no builtin_mbedtls=no builtin_miniupnpc=no builtin_pcre2=no builtin_sdl=no builtin_zlib=no builtin_zstd=no

On Debian stable, you will need to remove builtin_embree=no as the system-provided Embree version is too old to work with Godot's latest master branch (which requires Embree 4).

Você pode visualizar uma lista de todas as bibliotecas integradas que possuem alternativas de sistema executando scons -h e procurando por opções que começam com builtin_.

Aviso

Ao usar as bibliotecas do sistema, o binário resultante não é mais portátil entre distribuições Linux. Não use essa abordagem para criar binários que pretenda distribuir a outros, a menos que esteja criando um pacote para uma distribuição Linux específica.