diff --git a/.github/workflows/Build.yml b/.github/workflows/Build.yml
index 8292e19..a6fa3cb 100644
--- a/.github/workflows/Build.yml
+++ b/.github/workflows/Build.yml
@@ -56,7 +56,7 @@ jobs:
     # cxx ........... defines C++ compiler; passed to CMake configuration step (as `CXX` environment variable)
     # ver ........... defines optional suffix to package name when installing compiler with apt, and whenever compiler version is important for build process
     #                 cc: gcc, cxx: g++, ver: null --becomes--> sudo apt install gcc g++
-    #                 cc: gcc, cxx: g++, ver: -10  --becomes--> sudo apt install gcc-10 g++-10
+    #                 cc: gcc, cxx: g++, ver: 10   --becomes--> sudo apt install gcc-10 g++-10
     # arch .......... defines if building 32bit or 64bit application; used in multiple places to prepare build environment
     #                 also used as job name suffix (" x32" or " x64")
     # generator ..... passed to CMake configuration step (as `-G` switch)
@@ -67,75 +67,134 @@ jobs:
     #
     - { name: Linux GCC,      os: ubuntu-22.04, cc: gcc,   cxx: g++,     ver: null, arch: 32, generator: "Unix Makefiles",        can-fail: false, artifact: Build/fallout2-ce,             artifact-os: linux }
     # { name: Linux GCC,      os: ubuntu-22.04, cc: gcc,   cxx: g++,     ver: null, arch: 64, generator: "Unix Makefiles",        can-fail: true,  artifact: Build/fallout2-ce,             artifact-os: linux }
-    - { name: Linux GCC 10,   os: ubuntu-22.04, cc: gcc,   cxx: g++,     ver: -10,  arch: 32, generator: "Unix Makefiles",        can-fail: false, artifact: NO,                            artifact-os: linux }
-    # { name: Linux GCC 10,   os: ubuntu-22.04, cc: gcc,   cxx: g++,     ver: -10,  arch: 64, generator: "Unix Makefiles",        can-fail: true,  artifact: NO,                            artifact-os: linux }
-    - { name: Linux CLang,    os: ubuntu-22.04, cc: clang, cxx: clang++, ver: null, arch: 32, generator: "Unix Makefiles",        can-fail: false, artifact: NO,                            artifact-os: linux }
+    - { name: Linux GCC 10,   os: ubuntu-22.04, cc: gcc,   cxx: g++,     ver: 10,   arch: 32, generator: "Unix Makefiles",        can-fail: false, artifact: NO,                            artifact-os: linux }
+    # { name: Linux GCC 10,   os: ubuntu-22.04, cc: gcc,   cxx: g++,     ver: 10,   arch: 64, generator: "Unix Makefiles",        can-fail: true,  artifact: NO,                            artifact-os: linux }
+    # { name: MacOS 11 CLang, os: macOS-11,     cc: clang, cxx: clang++, ver: null, arch: 64, generator: "Unix Makefiles",        can-fail: true,  artifact: NO,                            artifact-os: mac }
+    # { name: MacOS 12 CLang, os: macOS-12,     cc: clang, cxx: clang++, ver: null, arch: 64, generator: "Unix Makefiles",        can-fail: true,  artifact: NO,                            artifact-os: mac }
     - { name: Windows VS2019, os: windows-2019, cc: cl,    cxx: cl,      ver: null, arch: 32, generator: "Visual Studio 16 2019", can-fail: false, artifact: NO,                            artifact-os: windows }
     # { name: Windows VS2019, os: windows-2019, cc: cl,    cxx: cl,      ver: null, arch: 64, generator: "Visual Studio 16 2019", can-fail: true,  artifact: NO,                            artifact-os: windows }
     - { name: Windows VS2022, os: windows-2022, cc: cl,    cxx, cl,      ver: null, arch: 32, generator: "Visual Studio 17 2022", can-fail: false, artifact: Build/Release/fallout2-ce.exe, artifact-os: windows }
     # { name: Windows VS2022, os: windows-2022, cc: cl,    cxx, cl,      ver: null, arch: 64, generator: "Visual Studio 17 2022", can-fail: true,  artifact: Build/Release/fallout2-ce.exe, artifact-os: windows }
 
   steps:
-
-  - name: Install
-    if:   runner.os == 'Linux'
+  - name: Configure
     run:  |
-          :
-          # Extra setup is needed to install 32bit packages on 64bit host
-          if [[ ${{ matrix.cfg.arch }} -eq 32 ]]; then
-             arch=i386
-             sudo dpkg --add-architecture $arch
-             echo [apt] added architecture $arch
-          else
-             arch=amd64
+          : Here be dragons :
+          #set -x
+          arch=${{ matrix.cfg.arch }}
+          ver="${{ matrix.cfg.ver }}"
+          cc="${{ matrix.cfg.cc }}"
+          cxx="${{ matrix.cfg.cxx }}"
+
+          # Variables exported for other steps:
+          #
+          #  GHA_PM .................. packages manager executable (might include `sudo`); if not exported, `Install` step is skipped
+          #  GHA_PM_COMPILER ......... compiler package(s), including version (if set in matrix)
+          #  GHA_PM_COMPILER_EXTRA ... extra compiler packages
+          #  GHA_PM_LIBS ............. required libraries packages
+          #  GHA_CC .................. C compiler executable, including version (if set in matrix)
+          #  GHA_CXX ................. C++ compiler executable, including version (if set in matrix)
+          #  GHA_PLATFORM ............ CMake -A ... switch, for configure step
+          #  GHA_TOOLCHAIN ........... CMake -DCMAKE_TOOLCHAIN_FILE=... switch, for configure step
+
+          # Compiler executables names
+          [[ "$ver" != "" ]] && verCMAKE="-$ver"
+          echo GHA_CC="$cc$verCMAKE" >> $GITHUB_ENV
+          echo GHA_CXX="$cxx$verCMAKE" >> $GITHUB_ENV
+
+          if   [[ $arch -ne 32 ]] && [[ $arch -ne 64 ]]; then
+               echo "[ERROR] matrix.cfg.arch must be set to 32 or 64"
+               exit 1
+          elif [[ "$ver" != "" ]] && ! [[ "$ver" =~ [0-9]+ ]]; then
+               echo "[ERROR] matrix.cfg.ver must be null or number"
+               exit 1
+          elif [[ $RUNNER_OS == "Linux" ]]; then
+               [[ "$ver" != "" ]] && verPM="-$ver"
+
+               echo GHA_PM="sudo apt" >> $GITHUB_ENV
+               apt="amd64"
+
+               if [[ "$cc" == "clang" ]] && [[ "$cxx" == "clang++" ]]; then
+                  echo GHA_PM_COMPILER="$cc$verPM" >> $GITHUB_ENV
+               else
+                  echo GHA_PM_COMPILER="$cc$verPM $cxx$verPM" >> $GITHUB_ENV
+               fi
+
+               # Handle building 32bit executable on 64bit host
+               if [[ $arch -eq 32 ]]; then
+                  apt="i386"
+                  sudo dpkg --add-architecture $apt
+
+                  # Extra packages
+                  echo GHA_PM_COMPILER_EXTRA="gcc${verPM}-multilib g++${verPM}-multilib" >> $GITHUB_ENV
+
+                  # Toolchain file; without proper 32@64 toolchain setup CMake can't find OpenGL libraries
+                  echo GHA_TOOLCHAIN="-DCMAKE_TOOLCHAIN_FILE=CMake/Toolchain/Linux32.cmake" >> $GITHUB_ENV
+               fi
+
+               echo GHA_PM_LIBS="libsdl2-dev:$apt zlib1g-dev:$apt" >> $GITHUB_ENV
+          elif [[ $RUNNER_OS == "macOS" ]]; then
+               [[ "$ver" != "" ]] && verPM="@$ver"
+               echo GHA_PM="brew" >> $GITHUB_ENV
+
+               if [[ "$cc" == "gcc" ]] && [[ "$cxx" == "g++" ]]; then
+                  echo GHA_PM_COMPILER="$cc$verPM" >> $GITHUB_ENV
+               elif [[ "$cc" == "clang" ]] && [[ "$cxx" == "clang++" ]]; then
+                  echo GHA_PM_COMPILER="llvm$verPM" >> $GITHUB_ENV
+               fi
+
+               echo GHA_PM_LIBS="sdl2" >> $GITHUB_ENV
+          elif [[ $RUNNER_OS == "Windows" ]]; then
+               # VisualStudio; '-A' switch is used to compile 32bit targets on 64bit hosts
+               if [[ "${{ matrix.cfg.generator }}" =~ ^Visual ]]; then
+                  if [[ $arch  -eq 32 ]]; then
+                     echo GHA_PLATFORM="-A Win32" >> $GITHUB_ENV
+                  else
+                     echo GHA_PLATFORM="-A x64" >> $GITHUB_ENV
+                  fi
+               fi
           fi
 
-          echo ::group::apt update
-          sudo apt update 2>&1
+  - name: Install
+    if:   env.GHA_PM != ''
+    run:  |
+          :
+          #set -x
+
+          echo ::group::Update package manager
+          $GHA_PM update 2>&1
           echo ::endgroup::
 
-          echo ::group::Compiler
-          sudo apt install ${{ matrix.cfg.cc }}${{ matrix.cfg.ver }}
-          echo ::endgroup::
-
-          # Extra packages are needed to compile 32bit targets on 64bit host
-          if [[ $arch -eq "i386" ]]; then
-             echo ::group::Multilib
-             sudo apt install gcc${{ matrix.cfg.ver }}-multilib g++${{ matrix.cfg.ver }}-multilib
+          if [[ ${{ matrix.cfg.arch }} -eq 32 ]] && ([[ "$ImageOS" == "ubuntu20" ]] || [[ "${{ matrix.cfg.os }}" == "ubuntu-20.04" ]]); then
+             echo ::group::Fix Ubuntu 20
+             $GHA_PM install --allow-downgrades libpcre2-8-0=10.34-7
              echo ::endgroup::
           fi
 
-          echo ::group::Libraries
-          sudo apt install libsdl2-dev:$arch zlib1g-dev:$arch
-          echo :endgroup::
+          if [[ "$GHA_PM_COMPILER" != "" ]] || [[ "$GHA_PM_COMPILER_EXTRA" ]]; then
+             echo ::group::Compiler
+             $GHA_PM install $GHA_PM_COMPILER $GHA_PM_COMPILER_EXTRA
+             echo ::endgroup::
+          fi
+
+          if [[ "$GHA_PM_LIBS" != "" ]]; then
+             echo ::group::Libraries
+             $GHA_PM install $GHA_PM_LIBS
+             echo :endgroup::
+          fi
 
   - name: Clone
     uses: actions/checkout@v3
 
+  # Using ${{ env.NAME }} here (instead of usual $NAME) to make full command line clearly displayed, without need to check step environment first
   - name: Prepare
-    run:  |
-          :
-          #[Linux] Toolchain file is used to compile 32bit targets on 64bit hosts
-          # NOTE: without proper 32@64 toolchain setup CMake can't find OpenGL libraries
-          if [[ "$RUNNER_OS" == "Linux" ]] && [[ ${{ matrix.cfg.arch }} -eq 32 ]]; then
-             toolchain="-DCMAKE_TOOLCHAIN_FILE=CMake/Toolchain/Linux32.cmake"
-          fi
-          #[VisualStudio] '-A' switch is used to compile 32bit targets on 64bit hosts
-          if [[ "${{ matrix.cfg.cc }}" == "cl" ]]; then
-             if [[ ${{ matrix.cfg.arch }} -eq 32 ]]; then
-                platform="-A Win32"
-             else
-                platform="-A x64"
-             fi
-          fi
-          cmake -B Build -G "${{ matrix.cfg.generator }}" $platform $toolchain 2>&1 
+    run:  cmake -B Build -G "${{ matrix.cfg.generator }}" ${{ env.GHA_PLATFORM }} ${{ env.GHA_TOOLCHAIN }} 2>&1
     env:
-     CC:  ${{ matrix.cfg.cc }}${{ matrix.cfg.ver }} 
-     CXX: ${{ matrix.cfg.cxx }}${{ matrix.cfg.ver }}
+     CC:  ${{ env.GHA_CC }}
+     CXX: ${{ env.GHA_CXX }}
 
   - name: Build
-    run:  |
-          cmake --build Build --config Release && echo BUILD_OK=1 >> $GITHUB_ENV
+    run:  cmake --build Build --config Release && echo BUILD_OK=1 >> $GITHUB_ENV
     continue-on-error: ${{ matrix.cfg.can-fail }}
 
   - name: Artifact prepare