🔝 Retour au Sommaire

1.4.3 Installation sur macOS et BSD

Introduction : Les plateformes Unix alternatives

macOS : L'Unix d'Apple

macOS représente un cas unique dans l'écosystème FreePascal/Lazarus :

Base Unix : Darwin kernel basé sur BSD
Interface propriétaire : Cocoa/AppKit pour les applications natives
Architectures multiples : Intel (x86_64) et Apple Silicon (ARM64/M1/M2/M3)
Restrictions : Gatekeeper, notarisation, sandboxing
Outils développeur : Xcode et Command Line Tools requis

BSD : Les Unix libres

Les systèmes BSD (Berkeley Software Distribution) offrent :

FreeBSD : Le plus populaire, excellent support serveur
OpenBSD : Focus sur la sécurité
NetBSD : Portabilité maximale
DragonFly BSD : Performance et innovation

Ces systèmes partagent des caractéristiques communes :

Philosophie Unix pure : "Faire une chose et la faire bien"
Système complet : Kernel + userland développés ensemble
Ports/Packages : Systèmes de gestion sophistiqués
Documentation excellente : Man pages détaillées

Partie 1 : Installation sur macOS

Prérequis macOS

Versions supportées

Version macOS	Nom	Support Lazarus	Architecture	Notes
14.x	Sonoma	✅ Excellent	Intel/ARM	Dernière version
13.x	Ventura	✅ Excellent	Intel/ARM	Recommandé
12.x	Monterey	✅ Très bon	Intel/ARM	Stable
11.x	Big Sur	✅ Bon	Intel/ARM	Premier ARM
10.15	Catalina	⚠️ Limité	Intel	64-bit uniquement
10.14	Mojave	⚠️ Ancien	Intel	Dernière 32-bit

Vérification du système

Ouvrez Terminal (Applications → Utilitaires → Terminal) :

# Version macOS
sw_vers

# Architecture processeur
uname -m
# arm64 = Apple Silicon (M1/M2/M3)
# x86_64 = Intel

# Espace disque disponible
df -h

# Mémoire
sysctl hw.memsize | awk '{print $2/1073741824 " GB"}'

Installation de Xcode Command Line Tools

Indispensable pour compiler sur macOS :

# Méthode 1 : Installation directe
xcode-select --install

# Une fenêtre apparaît, cliquez "Installer"
# Téléchargement ~500MB, installation ~2GB

# Méthode 2 : Via Xcode complet (App Store)
# Télécharger Xcode depuis l'App Store (plusieurs GB)
# Puis installer les Command Line Tools depuis Xcode

# Vérifier l'installation
xcode-select -p
# Devrait afficher : /Library/Developer/CommandLineTools
# ou : /Applications/Xcode.app/Contents/Developer

# Accepter la licence
sudo xcodebuild -license accept

Méthode 1 : Installation avec l'installateur DMG

Téléchargement

Visitez https://www.lazarus-ide.org
Choisissez la version pour votre architecture :
- Intel Mac : lazarus-3.0.0-x86_64-macosx.dmg
- Apple Silicon : lazarus-3.0.0-aarch64-macosx.dmg
- Universal : Fonctionne sur les deux (plus gros)

Installation depuis le DMG

# 1. Monter le DMG (ou double-clic dans Finder)
hdiutil attach lazarus-3.0.0-x86_64-macosx.dmg

# 2. Copier vers Applications
cp -R /Volumes/lazarus/Lazarus.app /Applications/

# 3. Copier FPC et sources (important!)
sudo cp -R /Volumes/lazarus/usr/local/* /usr/local/

# 4. Démonter le DMG
hdiutil detach /Volumes/lazarus

Première exécution et Gatekeeper

macOS bloquera probablement Lazarus au premier lancement :

# Méthode 1 : Via Finder
# Clic droit sur Lazarus.app → Ouvrir
# Cliquer "Ouvrir" dans la boîte de dialogue

# Méthode 2 : Terminal (supprime la quarantaine)
xattr -d com.apple.quarantine /Applications/Lazarus.app

# Méthode 3 : Autoriser globalement (non recommandé)
sudo spctl --master-disable

Méthode 2 : Installation via Homebrew

Installation de Homebrew

Si Homebrew n'est pas installé :

# Installation de Homebrew
/bin/bash -c "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/HEAD/install.sh)"

# Pour Apple Silicon, ajouter au PATH
echo 'eval "$(/opt/homebrew/bin/brew shellenv)"' >> ~/.zprofile  
eval "$(/opt/homebrew/bin/brew shellenv)"

# Pour Intel
echo 'eval "$(/usr/local/bin/brew shellenv)"' >> ~/.zprofile  
eval "$(/usr/local/bin/brew shellenv)"

# Vérifier
brew --version

Installation de Lazarus avec Homebrew

# Mise à jour de Homebrew
brew update

# Rechercher les formules disponibles
brew search lazarus  
brew search fpc

# Installation du compilateur FreePascal
brew install fpc

# Installation de Lazarus
brew install --cask lazarus

# Vérification
fpc -version  
lazarus --version

Gestion avec Homebrew

# Mise à jour
brew upgrade fpc  
brew upgrade --cask lazarus

# Informations
brew info fpc  
brew info --cask lazarus

# Désinstallation
brew uninstall fpc  
brew uninstall --cask lazarus

# Nettoyage
brew cleanup

Méthode 3 : Installation via MacPorts

Installation de MacPorts

Téléchargez MacPorts depuis https://www.macports.org
Choisissez le package pour votre version macOS
Installez le .pkg

Ou via Terminal :

# Après installation du .pkg
# Mettre à jour PATH
export PATH="/opt/local/bin:/opt/local/sbin:$PATH"  
echo 'export PATH="/opt/local/bin:/opt/local/sbin:$PATH"' >> ~/.zprofile

# Mise à jour de MacPorts
sudo port selfupdate

Installation avec MacPorts

# Rechercher les ports disponibles
port search lazarus  
port search fpc

# Installation
sudo port install fpc  
sudo port install lazarus

# Variantes disponibles
port variants lazarus

# Installation avec variantes
sudo port install lazarus +gtk2 +universal

# Vérification
port installed | grep -E "fpc|lazarus"

Méthode 4 : Compilation depuis les sources sur macOS

Préparation

# Créer structure de répertoires
mkdir -p ~/Development/FreePascal/{fpc,lazarus}  
cd ~/Development/FreePascal

# Installer les outils nécessaires
brew install svn git wget

# Pour GTK (optionnel, pour cross-platform)
brew install gtk+3 cairo pango

Compilation de FPC

# Obtenir FPC de démarrage
cd ~/Development/FreePascal  
wget https://sourceforge.net/projects/freepascal/files/Mac%20OS%20X/3.2.2/fpc-3.2.2.x86_64-macosx.dmg  
hdiutil attach fpc-3.2.2.x86_64-macosx.dmg  
sudo installer -pkg /Volumes/fpc-3.2.2/fpc-3.2.2.x86_64-macosx.pkg -target /

# Obtenir les sources
cd fpc  
svn checkout https://svn.freepascal.org/svn/fpc/trunk fpc-trunk

# Compiler
cd fpc-trunk  
make clean all FPC=/usr/local/bin/fpc

# Installer
sudo make install PREFIX=/usr/local

# Vérifier
/usr/local/bin/fpc -version

Compilation de Lazarus

cd ~/Development/FreePascal/lazarus

# Obtenir les sources
svn checkout https://svn.freepascal.org/svn/lazarus/trunk lazarus-trunk

cd lazarus-trunk

# Compiler pour Cocoa (natif macOS)
make clean all LCL_PLATFORM=cocoa

# Ou pour Carbon (legacy, 32-bit)
# make clean all LCL_PLATFORM=carbon

# Ou pour GTK2 (cross-platform)
# make clean all LCL_PLATFORM=gtk2

# Créer l'application bundle
make app

# Copier vers Applications
cp -R lazarus.app /Applications/Lazarus-Dev.app

Configuration spécifique macOS

Signature de code

Pour distribuer vos applications :

# Voir les identités de signature disponibles
security find-identity -v -p codesigning

# Signer votre application
codesign --force --sign "Developer ID Application: Your Name" YourApp.app

# Vérifier la signature
codesign --verify --verbose YourApp.app

# Pour la notarisation (requis pour distribution)
xcrun altool --notarize-app \
  --primary-bundle-id "com.yourcompany.yourapp" \
  --username "your@email.com" \
  --password "@keychain:AC_PASSWORD" \
  --file YourApp.dmg

Configuration des chemins

Ajoutez à ~/.zprofile ou ~/.bash_profile :

# FreePascal/Lazarus
export FPC_DIR="/usr/local/lib/fpc/3.2.2"  
export LAZARUS_DIR="/Applications/Lazarus.app/Contents/MacOS"  
export PATH="/usr/local/bin:$PATH"

# Alias utiles
alias lazarus="open -a Lazarus"  
alias fpc="/usr/local/bin/fpc"

Intégration avec Finder

Créez un service Automator pour ouvrir les fichiers .pas :

Ouvrir Automator
Nouveau → Service rapide
"Le service reçoit" → fichiers ou dossiers
Ajouter "Exécuter un script Shell"
Script :

open -a Lazarus "$@"

Sauvegarder comme "Ouvrir avec Lazarus"

Problèmes courants sur macOS

"Lazarus.app est endommagé"

# Supprimer les attributs de quarantaine
xattr -cr /Applications/Lazarus.app

# Ou désactiver temporairement Gatekeeper
sudo spctl --master-disable
# Lancer Lazarus
sudo spctl --master-enable

Problèmes avec les architectures

# Vérifier l'architecture d'un binaire
file /Applications/Lazarus.app/Contents/MacOS/lazarus

# Forcer Rosetta 2 pour Intel sur Apple Silicon
arch -x86_64 /Applications/Lazarus.app/Contents/MacOS/lazarus

# Compiler en Universal Binary
make all CPU_TARGET=x86_64  
make all CPU_TARGET=aarch64  
lipo -create lazarus-x86_64 lazarus-aarch64 -output lazarus-universal

Partie 2 : Installation sur BSD

FreeBSD

Installation via pkg (binaire)

# Mise à jour du système de paquets
sudo pkg update

# Recherche des paquets
pkg search lazarus  
pkg search fpc

# Installation
sudo pkg install lazarus fpc

# Installation avec dépendances GTK2
sudo pkg install lazarus-gtk2

# Installation avec Qt5
sudo pkg install lazarus-qt5

# Vérification
pkg info lazarus  
fpc -version

Installation via ports (source)

# Mise à jour des ports
sudo portsnap fetch update
# Ou avec Git (FreeBSD 13+)
sudo git -C /usr/ports pull

# Naviguer vers le port
cd /usr/ports/lang/fpc  
sudo make config  # Choisir les options  
sudo make install clean

cd /usr/ports/editors/lazarus  
sudo make config  
sudo make install clean

# Options de compilation personnalisées
sudo make WITH_GTK2=yes WITH_QT5=yes install clean

Configuration FreeBSD

# Ajouter à ~/.profile ou ~/.bashrc
export PATH="/usr/local/bin:$PATH"  
export FPC_DIR="/usr/local/lib/fpc/3.2.2"  
export LAZARUS_DIR="/usr/local/share/lazarus"

# Pour X11
export DISPLAY=:0.0

# Permissions pour ports série
sudo pw groupmod dialer -m $USER

OpenBSD

Installation via pkg_add

# Configuration du miroir
echo "https://cdn.openbsd.org/pub/OpenBSD" > /etc/installurl

# Installation
doas pkg_add lazarus  
doas pkg_add fpc

# Avec un miroir spécifique
doas pkg_add -D snap https://mirror.example.org/pub/OpenBSD/7.4/packages/amd64/lazarus-3.0.tgz

Configuration OpenBSD

# Limites système pour compilation
# Ajouter à /etc/login.conf dans la classe default:
# :datasize-cur=2048M:\
# :datasize-max=infinity:\
# :stacksize-cur=8M:

# Appliquer les changements
doas cap_mkdb /etc/login.conf

# Variables d'environnement
export PATH="/usr/local/bin:$PATH"  
export PKG_PATH="https://cdn.openbsd.org/pub/OpenBSD/$(uname -r)/packages/$(arch -s)"

NetBSD

Installation via pkgin

# Installation de pkgin si nécessaire
pkg_add pkgin

# Mise à jour
pkgin update

# Installation
pkgin install lazarus  
pkgin install fpc

# Recherche
pkgin search lazarus

Installation via pkgsrc

# Obtenir pkgsrc
cd /usr  
cvs -q -z3 -d anoncvs@anoncvs.NetBSD.org:/cvsroot checkout -P pkgsrc

# Compiler FPC
cd /usr/pkgsrc/lang/fpc  
make install clean

# Compiler Lazarus
cd /usr/pkgsrc/devel/lazarus  
make install clean

DragonFly BSD

Installation

# Via pkg
pkg update  
pkg install lazarus fpc

# Via dports
cd /usr/dports/lang/fpc  
make install clean

cd /usr/dports/editors/lazarus  
make install clean

Configuration commune Unix

Structure des répertoires

/usr/local/                    # BSD typique
├── bin/
│   ├── fpc                   # Compilateur
│   ├── lazarus               # IDE
│   └── lazbuild             # Build tool
├── lib/
│   └── fpc/                 # Bibliothèques FPC
├── share/
│   ├── lazarus/             # Fichiers Lazarus
│   └── fpcsrc/              # Sources FPC
└── etc/
    └── fpc.cfg              # Configuration FPC

~/.lazarus/                   # Configuration utilisateur
├── onlinepackagemanager/
├── environmentoptions.xml
└── packagefiles.xml

Scripts d'automatisation multi-BSD

Script d'installation universel

Créez install-lazarus-bsd.sh :

#!/bin/sh

# Détection du système BSD
detect_bsd() {
    if [ -f /etc/os-release ]; then
        . /etc/os-release
        echo $NAME
    elif [ "$(uname -s)" = "FreeBSD" ]; then
        echo "FreeBSD"
    elif [ "$(uname -s)" = "OpenBSD" ]; then
        echo "OpenBSD"
    elif [ "$(uname -s)" = "NetBSD" ]; then
        echo "NetBSD"
    elif [ "$(uname -s)" = "DragonFly" ]; then
        echo "DragonFly"
    else
        echo "Unknown"
    fi
}

BSD_TYPE=$(detect_bsd)  
echo "Detected: $BSD_TYPE"

case $BSD_TYPE in
    FreeBSD)
        sudo pkg update
        sudo pkg install -y lazarus fpc
        ;;
    OpenBSD)
        doas pkg_add lazarus fpc
        ;;
    NetBSD)
        pkgin -y install lazarus fpc
        ;;
    DragonFly)
        pkg update
        pkg install -y lazarus fpc
        ;;
    *)
        echo "Système non supporté"
        exit 1
        ;;
esac

echo "Installation terminée!"

Script de configuration post-installation

Créez configure-lazarus-bsd.sh :

#!/bin/sh

# Configuration commune BSD

# Créer les répertoires
mkdir -p ~/Projects/Lazarus  
mkdir -p ~/.lazarus

# Configuration PATH
echo 'export PATH="/usr/local/bin:$PATH"' >> ~/.profile  
echo 'export FPC_DIR="/usr/local/lib/fpc"' >> ~/.profile  
echo 'export LAZARUS_DIR="/usr/local/share/lazarus"' >> ~/.profile

# Alias
echo 'alias laz="lazarus"' >> ~/.profile  
echo 'alias lazbuild="/usr/local/bin/lazbuild"' >> ~/.profile

# Pour X11
if [ -n "$DISPLAY" ]; then
    echo 'export DISPLAY=:0.0' >> ~/.profile
fi

# Permissions groupes
case $(uname -s) in
    FreeBSD)
        sudo pw groupmod dialer -m $USER
        sudo pw groupmod operator -m $USER
        ;;
    OpenBSD)
        doas usermod -G dialer,operator $USER
        ;;
    NetBSD)
        sudo usermod -G dialer,operator $USER
        ;;
esac

echo "Configuration terminée. Reconnectez-vous pour appliquer."

Comparaison macOS vs BSD

Tableau comparatif

Aspect	macOS	FreeBSD	OpenBSD	NetBSD
Installation	DMG/Homebrew	pkg/ports	pkg_add	pkgin
Widgetset natif	Cocoa	GTK2/Qt5	GTK2	GTK2/Qt5
Architecture	x86_64/ARM64	x86_64/ARM	x86_64	Multi
Signature code	Obligatoire	Non	Non	Non
Sandboxing	Oui	jail	pledge	Non
Documentation	Moyenne	Excellente	Excellente	Bonne
Communauté FPC	Moyenne	Bonne	Petite	Petite
Performance	Excellente	Excellente	Très bonne	Bonne

Choix de plateforme

Choisir macOS si :

✅ Développement d'applications Mac natives
✅ Besoin de l'écosystème Apple
✅ Distribution sur App Store
✅ Support commercial requis

Choisir FreeBSD si :

✅ Serveurs et applications système
✅ Performance maximale
✅ ZFS et jails nécessaires
✅ Grande communauté BSD

Choisir OpenBSD si :

✅ Sécurité prioritaire absolue
✅ Applications critiques
✅ Simplicité et clarté du code
✅ Documentation exemplaire

Choisir NetBSD si :

✅ Portabilité maximale
✅ Systèmes embarqués
✅ Architectures exotiques
✅ Recherche et expérimentation

Développement cross-platform macOS/BSD

Code portable

program CrossPlatform;
{$mode objfpc}{$H+}

uses
  {$IFDEF UNIX}
    {$IFDEF DARWIN}
    CocoaAll,  // macOS specific
    {$ELSE}
    Unix,      // BSD/Linux
    {$ENDIF}
  {$ENDIF}
  SysUtils;

begin
  {$IFDEF DARWIN}
  WriteLn('Running on macOS');
  WriteLn('Compiled with FPC ', {$I %FPCVERSION%});
  {$ENDIF}

  {$IFDEF FREEBSD}
  WriteLn('Running on FreeBSD');
  {$ENDIF}

  {$IFDEF OPENBSD}
  WriteLn('Running on OpenBSD');
  {$ENDIF}

  {$IFDEF NETBSD}
  WriteLn('Running on NetBSD');
  {$ENDIF}
end.

Compilation conditionnelle

{$IFDEF UNIX}
  {$IFDEF DARWIN}
    // Code spécifique macOS
    {$linkframework Cocoa}
    {$linkframework Carbon}
  {$ELSE}
    // Code BSD/Linux
    {$IFDEF FREEBSD}
      // Spécifique FreeBSD
    {$ENDIF}
  {$ENDIF}
{$ENDIF}

Optimisation et performance

macOS : Optimisations spécifiques

# Compilation optimisée pour Apple Silicon
make all OPT="-O3 -Cg -XX" CPU_TARGET=aarch64

# Universal Binary
make all CPU_TARGET=x86_64 INSTALL_PREFIX=build-x86_64  
make all CPU_TARGET=aarch64 INSTALL_PREFIX=build-aarch64  
lipo -create build-x86_64/lazarus build-aarch64/lazarus -output lazarus-universal

# Optimisation avec Link Time Optimization
make all OPT="-O3 -Cg -XX -Xs -flto"

BSD : Optimisations système

# FreeBSD : Utiliser clang au lieu de gcc
make all CC=clang CXX=clang++

# OpenBSD : Optimisations sécurité
make all OPT="-O2 -fstack-protector-strong"

# NetBSD : Optimisation multithread
make all OPT="-O3 -pthread"

Dépannage

Problèmes courants macOS

"xcrun: error: invalid active developer path"

xcode-select --install  
sudo xcode-select --switch /Applications/Xcode.app

"Library not loaded: @rpath/..."

# Vérifier les chemins de bibliothèques
otool -L /Applications/Lazarus.app/Contents/MacOS/lazarus

# Corriger avec install_name_tool
install_name_tool -add_rpath /usr/local/lib /Applications/Lazarus.app/Contents/MacOS/lazarus

Problèmes courants BSD

"Cannot find unit interfaces"

# FreeBSD
export FPCDIR=/usr/local/lib/fpc/3.2.2  
export LAZARUSDIR=/usr/local/share/lazarus

# Recompiler la LCL
cd $LAZARUSDIR  
gmake clean all

Problèmes X11

# Vérifier X11
xhost +  
echo $DISPLAY

# FreeBSD : Installer X11
pkg install xorg

# Configuration
echo 'dbus_enable="YES"' >> /etc/rc.conf  
echo 'hald_enable="YES"' >> /etc/rc.conf

Conclusion

Points clés à retenir

macOS :

Nécessite Xcode Command Line Tools
Gatekeeper et signature peuvent compliquer
Excellente intégration native avec Cocoa
Support ARM64 (Apple Silicon) mature

BSD :

Installation simple via gestionnaires de paquets
Excellente documentation système
Performance et stabilité remarquables
Communauté plus petite mais experte

Ressources spécifiques