Up to date

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

Compiler pour macOS

Note

Cette page décrit comment compiler les binaires de l'éditeur macOS et les modèles d'exportation à partir du code source. Si vous souhaitez plutôt exporter votre projet vers macOS, lisez Exportation de macOS.

Pré-requis

Pour la compilation sous macOS, les éléments suivants sont nécessaires :

  • Python 3.6+.

  • SCons 3.0+ système de construction(build).

  • Xcode (ou les outils en ligne de commande plus légers pour Xcode).

  • Vulkan SDK for MoltenVK (macOS doesn't support Vulkan out of the box).

Note

If you have Homebrew installed, you can easily install SCons using the following command:

brew install scons

L'installation de Homebrew permet également de récupérer automatiquement les outils de ligne de commande pour Xcode si vous ne les avez pas déjà.

Similarly, if you have MacPorts installed, you can easily install SCons using the following command:

sudo port install scons

Voir aussi

Pour récupérer le code source de Godot pour le compiler, voir Obtenir la source.

Pour un aperçu général de l'utilisation de SCons pour Godot, voir Introduction au buildsystem.

Compilation

Démarrez un terminal et allez au répertoire racine du code source du moteur.

Pour compiler pour les Macs équipés Intel (x86-64), utilisez :

scons platform=macos arch=x86_64

Pour compiler pour les Macs équipés Apple Silicon (ARM64), utilisez :

scons platform=macos arch=arm64

Pour prendre en charge les deux architectures dans un seul binaire "Universal 2", exécutez les deux commandes ci-dessus et utilisez ensuite lipo pour les regrouper :

lipo -create bin/godot.macos.editor.x86_64 bin/godot.macos.editor.arm64 -output bin/godot.macos.editor.universal

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.

Note

Si vous souhaitez utiliser des paramètres d'édition séparés pour vos propres constructions Godot et vos versions officielles, vous pouvez activer Mode autonome en créant un fichier appelé ._sc_ ou _sc_ dans le dossier bin/.

To create an .app bundle like in the official builds, you need to use the template located in misc/dist/macos_tools.app. Typically, for an optimized editor binary built with dev_build=yes:

cp -r misc/dist/macos_tools.app ./Godot.app
mkdir -p Godot.app/Contents/MacOS
cp bin/godot.macos.editor.universal Godot.app/Contents/MacOS/Godot
chmod +x Godot.app/Contents/MacOS/Godot
codesign --force --timestamp --options=runtime --entitlements misc/dist/macos/editor.entitlements -s - Godot.app

Note

If you are building the master branch, you also need to include support for the MoltenVK Vulkan portability library. By default, it will be linked statically from your installation of the Vulkan SDK for macOS. You can also choose to link it dynamically by passing use_volk=yes and including the dynamic library in your .app bundle:

mkdir -p Godot.app/Contents/Frameworks
cp <Vulkan SDK path>/macOS/lib/libMoltenVK.dylib Godot.app/Contents/Frameworks/libMoltenVK.dylib

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=macos target=editor

And then use the --headless command line argument:

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

Pour compiler un build de débogage serveur qui peut être utilisé avec les outils de débogage à distance, utilisez : :

scons platform=macos target=template_debug

Pour compiler un build serveur release qui est optimisé pour faire fonctionner des serveurs de jeu dédiés, utilisez :

scons platform=macos target=template_release production=yes

Création de modèles d'exportation

To build macOS export templates, you have to compile using the targets without the editor: target=template_release (release template) and target=template_debug.

Les modèles officiels sont des binaires universels qui prennent en charge les architectures Intel x86_64 et ARM64. Vous pouvez également créer des modèles d'exportation qui ne prennent en charge qu'une seule de ces deux architectures en omettant l'étape lipo ci-dessous.

  • Pour Intel x86_64 :

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

  • Pour ARM64 (Apple M1) :

    scons platform=macos target=template_release arch=arm64
scons platform=macos target=template_debug arch=arm64

Pour prendre en charge les deux architectures dans un seul binaire "Universal 2", exécutez les deux commandes ci-dessus et utilisez ensuite lipo pour les regrouper :

lipo -create bin/godot.macos.opt.x86_64 bin/godot.macos.opt.arm64 -output bin/godot.macos.opt.universal
lipo -create bin/godot.macos.opt.debug.x86_64 bin/godot.macos.opt.debug.arm64 -output bin/godot.macos.opt.debug.universal

To create an .app bundle like in the official builds, you need to use the template located in misc/dist/macos_template.app. The release and debug builds should be placed in macos_template.app/Contents/MacOS with the names godot_macos_release.64 and godot_macos_debug.64 respectively. You can do so with the following commands (assuming a universal build, otherwise replace the .universal extension with the one of your arch-specific binaries):

cp -r misc/dist/macos_template.app .
mkdir -p macos_template.app/Contents/MacOS
cp bin/godot.macos.opt.universal macos_template.app/Contents/MacOS/godot_macos_release.64
cp bin/godot.macos.opt.debug.universal macos_template.app/Contents/MacOS/godot_macos_debug.64
chmod +x macos_template.app/Contents/MacOS/godot_macos*

Note

If you are building the master branch, you also need to include support for the MoltenVK Vulkan portability library. By default, it will be linked statically from your installation of the Vulkan SDK for macOS. You can also choose to link it dynamically by passing use_volk=yes and including the dynamic library in your .app bundle:

mkdir -p macos_template.app/Contents/Frameworks
cp <Vulkan SDK path>/macOS/libs/libMoltenVK.dylib macos_template.app/Contents/Frameworks/libMoltenVK.dylib

You can then zip the macos_template.app folder to reproduce the macos.zip template from the official Godot distribution:

zip -q -9 -r macos.zip macos_template.app

Utiliser Pyston pour un développement plus rapide

You can use Pyston to run SCons. Pyston is a JIT-enabled implementation of the Python language (which SCons is written in). Its "full" version is currently only compatible with Linux, but Pyston-lite is also compatible with macOS (both x86 and ARM). Pyston can speed up incremental builds significantly, often by a factor between 1.5× and 2×. Pyston can be combined with alternative linkers such as LLD or Mold to get even faster builds.

To install Pyston-lite, run python -m pip install pyston_lite_autoload then run SCons as usual. This will automatically load a subset of Pyston's optimizations in any Python program you run. However, this won't bring as much of a performance improvement compared to installing "full" Pyston (which currently can't be done on macOS).

Compilation croisée pour macOS à partir de Linux

Il est possible de compiler pour macOS dans un environnement Linux (et peut-être aussi dans Windows en utilisant le sous-système Windows pour Linux). Pour cela, vous devrez installer OSXCross pour pouvoir utiliser macOS comme cible. Tout d'abord, suivez les instructions pour l'installer :

Clonez le dépôt OSXCross quelque part sur votre machine (ou téléchargez un fichier ZIP et extrayez-le quelque part), par exemple :

git clone --depth=1 https://github.com/tpoechtrager/osxcross.git "$HOME/osxcross"

  1. Suivez les instructions pour empaqueter le SDK : https://github.com/tpoechtrager/osxcross#packaging-the-sdk

  2. Suivez les instructions pour installer OSXCross : https://github.com/tpoechtrager/osxcross#installation

Ensuite, vous devrez définir OSXCROSS_ROOT comme le chemin vers l'installation d'OSXCross (le même endroit où vous avez cloné le dépôt/extrait le zip), par exemple :

export OSXCROSS_ROOT="$HOME/osxcross"

Vous pouvez maintenant compiler avec SCons comme vous le feriez normalement :

scons platform=macos

Si vous avez une version du SDK OSXCross différente de celle attendue par le système de construction(build) SCons, vous pouvez en spécifier une personnalisée avec l'argument osxcross_sdk :

scons platform=macos osxcross_sdk=darwin15