Up to date

This page is up to date for Godot 4.3. If you still find outdated information, please open an issue.

Compiling for Linux, *BSD

Ver también

Esta página describe cómo compilar los binarios del editor y las plantillas de exportación para Linux desde el código fuente. Si lo que buscas es exportar tu proyecto a Linux, consulta Exportando para Linux.

Requerimientos

Para compilar en Linux u otras variantes de Unix, se requiere lo siguiente:

• GCC 9+ or Clang 6+.

• Python 3.6+.

• SCons 3.1.2+ build system.

• pkg-config (used to detect the development libraries listed below).

• Librerías de desarrollo:

  • X11, Xcursor, Xinerama, Xi and XRandR.

  • Wayland y wayland-scanner.

  • Mesa.

  • ALSA.

  • PulseAudio.

• Opcional - libudev (compilar con udev=yes).

Ver también

Para obtener el código fuente de Godot para compilarlo, consulta la sección Consiguiendo el código fuente.

Para obtener una visión general del uso de SCons para Godot, consulta la sección Introducción al sistema de compilación.

Líneas de comandos específicas para cada distribución

Alpine LinuxArch LinuxDebian/UbuntuFedoraFreeBSDGentooMageiaNetBSDOpenBSDopenSUSESolus

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

Inicia una terminal, ve al directorio raíz del código fuente del motor y escribe:

scons platform=linuxbsd

Nota

Antes de Godot 4.0, el destino Linux/*BSD se llamaba x11 en lugar de linuxbsd. Si desea compilar Godot 3.x, asegúrese de utilizar la rama 3.x de esta documentación.

Truco

If you are compiling Godot to make changes or contribute to the engine, you may want to use the SCons options dev_build=yes or dev_mode=yes. See Development and production aliases for more info.

If all goes well, the resulting binary executable will be placed in the "bin" subdirectory. This executable file contains the whole engine and runs without any dependencies. Executing it will bring up the Project Manager.

Nota

Si deseas compilar utilizando Clang en lugar de GCC, usa este comando:

scons platform=linuxbsd use_llvm=yes

El uso de Clang parece ser un requisito para OpenBSD, de lo contrario, las fuentes no se compilarían correctamente. Para dispositivos con arquitectura RISC-V, utilice el compilador Clang en lugar del compilador GCC.

Truco

If you are compiling Godot for production use, you can make the final executable smaller and faster by adding the SCons option production=yes. This enables additional compiler optimizations and link-time optimization.

LTO tarda un tiempo en ejecutarse y requiere aproximadamente 7 GB de RAM disponible durante la compilación. Si se está quedando sin memoria con la opción anterior, utilice production=yes lto=none o production=yes lto=thin para utilizar una forma liviana pero menos efectiva de LTO.

Nota

Si deseas utilizar configuraciones de editor separadas para tus propias compilaciones de Godot y las versiones oficiales, puedes habilitar Modo autónomo creando un archivo llamado ._sc_ o _sc_ en la carpeta bin/.

Running a headless/server build

To run in headless mode which provides editor functionality to export projects in an automated manner, use the normal build:

scons platform=linuxbsd target=editor

Y luego use el argumento de línea de comando --headless:

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

Para compilar una versión servidor con depuración que se puede utilizar con herramientas de depuración remota, utiliza:

scons platform=linuxbsd target=template_debug

Para compilar una versión servidor que está optimizada para ejecutar servidores de juegos dedicados, utiliza:

scons platform=linuxbsd target=template_release production=yes

Construyendo plantillas de exportación

Advertencia

Las binarias de Linux generalmente no se ejecutarán en distribuciones más antiguas que la distribución en la que fueron compiladas. Si deseas distribuir binarios que funcionen en la mayoría de las distribuciones, debes compilarlos en una distribución antigua como Ubuntu 16.04. Puedes utilizar una máquina virtual o un contenedor para configurar un entorno de compilación adecuado.

To build Linux or *BSD export templates, run the build system with the following parameters:

• (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

Ten en cuenta que la compilación cruzada para bits opuestos (64/32) a los de tu plataforma de host no siempre es sencilla y puede requerir un entorno chroot.

Para crear plantillas de exportación estándar, los archivos resultantes en la carpeta bin/ deben copiarse a:

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

y nombrados de la siguiente manera (incluso para *BSD que es reconocido como "Linux/X11" por 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

Sin embargo, si estás escribiendo tus propios módulos personalizados o código C++ personalizado, es posible que desees configurar tus binarios como plantillas de exportación personalizadas aquí:

Ni siquiera necesitas copiarlos, simplemente puedes hacer referencia a los archivos resultantes en el directorio bin/ de la carpeta de origen de Godot, de esta manera, la próxima vez que construyas, automáticamente tendrás las plantillas personalizadas referenciadas.

Cross-compiling for RISC-V devices

To cross-compile Godot for RISC-V devices, we need to setup the following items:

• riscv-gnu-toolchain. While we are not going to use this directly, it provides us with a sysroot, as well as header and libraries files that we will need. There are many versions to choose from, however, the older the toolchain, the more compatible our final binaries will be. If in doubt, use this version, and download riscv64-glibc-ubuntu-18.04-nightly-2021.12.22-nightly.tar.gz. Extract it somewhere and remember its path.

• Clang. RISC-V GCC has bugs with its atomic operations which prevent it from compiling Godot correctly. Any version of Clang from 16.0.0 upwards will suffice. Download it from the package manager of your distro, and make sure that it can compile to RISC-V. You can verify by executing this command clang -print-targets, make sure you see riscv64 on the list of targets.

• mold. This fast linker, is the only one that correctly links the resulting binary. Download it, extract it, and make sure to add its bin folder to your PATH. Run mold --help | grep support to check if your version of Mold supports RISC-V. If you don't see RISC-V, your Mold may need to be updated.

To make referencing our toolchain easier, we can set an environment variable like this:

export RISCV_TOOLCHAIN_PATH="path to toolchain here"

This way, we won't have to manually set the directory location each time we want to reference it.

With all the above setup, we are now ready to build Godot.

Go to the root of the source code, and execute the following build command:

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"

The command is similar in nature, but with some key changes. ccflags and linkflags append additional flags to the build. --sysroot points to a folder simulating a Linux system, it contains all the headers, libraries, and .so files Clang will use. --gcc-toolchain tells Clang where the complete toolchain is, and -target riscv64-unknown-linux-gnu indicates to Clang the target architecture, and OS we want to build for.

If all went well, you should now see a bin directory, and within it, a binary similar to the following:

godot.linuxbsd.editor.rv64.llvm

You can now copy this executable to your favorite RISC-V device, then launch it there by double-clicking, which should bring up the project manager.

If you later decide to compile the export templates, copy the above build command but change the value of target to template_debug for a debug build, or template_release for a release build.

Utilizando Clang y LLD para un desarrollo más rápido

También puedes usar Clang y LLD para compilar Godot. Esto tiene dos ventajas en comparación con la configuración predeterminada de GCC + GNU ld:

• LLD enlaza Godot significativamente más rápido en comparación con GNU ld o gold. Esto lleva a tiempos de iteración más rápidos.

• Clang tiende a proporcionar mensajes de error más útiles en comparación con GCC.

Para hacerlo, instala Clang y el paquete lld desde el administrador de paquetes de tu distribución y luego utiliza el siguiente comando de SCons:

scons platform=linuxbsd use_llvm=yes linker=lld

Después de que se complete la compilación, se creará un nuevo archivo binario con el sufijo .llvm en la carpeta bin/.

Todavía se recomienda usar GCC para las compilaciones de producción, ya que se pueden compilar utilizando la optimización en tiempo de enlace, lo que hace que los archivos binarios resultantes sean más pequeños y rápidos.

Si ocurre este error:

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

There are two solutions:

• En el comando SCons, agregue el parámetro use_static_cpp=no.

• Sigue estas instrucciones para configurar, compilar e instalar libatomic_ops. Luego, copia /usr/lib/libatomic_ops.a a /usr/lib/libatomic.a, o crea un enlace simbólico a libatomic_ops con el comando ln -s /usr/lib/libatomic_ops.a /usr/lib/libatomic.a. El enlace simbólico puede garantizar que se use la última versión de libatomic_ops sin la necesidad de copiarla cada vez que se actualice.

Using mold for faster development

Para una vinculación aún más rápida en comparación con LLD, puede usar mold. mold se puede usar con GCC o Clang.

A partir de enero de 2023, mold no está disponible en los repositorios de distribución de Linux, por lo que tendrás que instalar sus binarios manualmente.

• Descarga binarios de mold desde su página de lanzamientos.

• Extraiga el archivo .tar.gz, luego mueva la carpeta extraída a una ubicación como .local/share/mold.

• Agregue $HOME/.local/share/mold/bin a la variable de entorno PATH del usuario. Por ejemplo, puede agregar la siguiente línea al final de su archivo $HOME/.bash_profile:

PATH="$HOME/.local/share/mold/bin:$PATH"

• Abra una nueva terminal (o ejecute source "$HOME/.bash_profile"), luego use el siguiente comando SCons al compilar Godot:

  scons platform=linuxbsd linker=mold
  

Using system libraries for faster development

Godot incluye el código fuente de varias bibliotecas de terceros. También puede optar por utilizar versiones en su sistema de estas bibliotecas. Esto hace que el binario de Godot sea más rápido de vincular, ya que las bibliotecas de terceros están vinculadas dinámicamente. Por lo tanto, no es necesario vincularlas estáticamente cada vez que crea el motor (incluso en pequeños cambios incrementales).

Sin embargo, no todas las distribuciones de Linux tienen paquetes para bibliotecas de terceros disponibles (o pueden no estar actualizados).

Pasar a las bibliotecas del sistema puede reducir los tiempos de vinculación por varios segundos en CPU lentas, pero requiere pruebas manuales según la distribución de Linux. Además, es posible que no pueda usar bibliotecas del sistema para todo debido a errores en los paquetes de bibliotecas del sistema (o en el sistema de compilación, ya que esta función está menos probada).

To compile Godot with system libraries, install these dependencies on top of the ones listed in the Líneas de comandos específicas para cada distribución:

Debian/UbuntuFedora

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 \
  libzstd-dev \
  libsquish-dev \
  libicu-dev

Después de instalar todos los paquetes necesarios, utilice el siguiente comando para compilar 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_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).

Puede ver una lista de todas las bibliotecas integradas que tienen alternativas del sistema ejecutando scons -h y luego buscando opciones que comiencen con builtin_.

Advertencia

Al utilizar bibliotecas del sistema, la biblioteca resultante ya no es portable entre distribuciones de Linux. No utilice este enfoque para crear archivos binarios que desee distribuir a otros, a menos que esté creando un paquete solo para esa distribución de Linux.