From 58a04947c4204533f15fa086173991ae9663fc6a Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?R=C3=A9mi=20Verschelde?= <remi@godotengine.org>
Date: Fri, 26 Aug 2022 15:39:52 +0200
Subject: [PATCH] .NET 6: Remove all Mono build code, install .NET SDK 6.0

---
 Dockerfile.android                          | 16 +-----
 Dockerfile.base                             |  8 ++-
 Dockerfile.ios                              | 31 -----------
 Dockerfile.javascript                       | 32 ++---------
 Dockerfile.linux                            | 23 ++------
 Dockerfile.mono                             | 24 ---------
 Dockerfile.mono-glue                        | 10 ----
 Dockerfile.osx                              | 22 ++------
 Dockerfile.windows                          | 21 ++------
 README.md                                   | 49 ++++++++---------
 build.sh                                    | 59 ++++++---------------
 files/patches/mono-btls-cmake-wrapper.patch | 13 -----
 upload.sh                                   |  1 -
 13 files changed, 59 insertions(+), 250 deletions(-)
 delete mode 100644 Dockerfile.mono
 delete mode 100644 Dockerfile.mono-glue
 delete mode 100644 files/patches/mono-btls-cmake-wrapper.patch

diff --git a/Dockerfile.android b/Dockerfile.android
index ec80ce2..32402e3 100644
--- a/Dockerfile.android
+++ b/Dockerfile.android
@@ -1,14 +1,11 @@
 ARG img_version
-FROM godot-mono:${img_version}
-
-ARG mono_version
+FROM godot-fedora:${img_version}
 
 ENV ANDROID_SDK_ROOT=/root/sdk
 ENV ANDROID_NDK_VERSION=23.2.8568313
 ENV ANDROID_NDK_ROOT=${ANDROID_SDK_ROOT}/ndk/${ANDROID_NDK_VERSION}
 
-RUN if [ -z "${mono_version}" ]; then echo -e "\n\nargument mono-version is mandatory!\n\n"; exit 1; fi && \
-    dnf -y install --setopt=install_weak_deps=False \
+RUN dnf -y install --setopt=install_weak_deps=False \
       java-11-openjdk-devel ncurses-compat-libs && \
     mkdir -p sdk && cd sdk && \
     export CMDLINETOOLS=commandlinetools-linux-8512546_latest.zip && \
@@ -18,13 +15,4 @@ RUN if [ -z "${mono_version}" ]; then echo -e "\n\nargument mono-version is mand
     yes | cmdline-tools/bin/sdkmanager --sdk_root="${ANDROID_SDK_ROOT}" --licenses && \
     cmdline-tools/bin/sdkmanager --sdk_root="${ANDROID_SDK_ROOT}" "ndk;${ANDROID_NDK_VERSION}" 'cmdline-tools;latest' 'build-tools;32.0.0' 'platforms;android-32' 'cmake;3.18.1'
 
-RUN cp -a /root/files/${mono_version} /root && \
-    export MONO_SOURCE_ROOT=/root/${mono_version} && \
-    cd /root/${mono_version}/godot-mono-builds && \
-    python3 android.py configure -j --target=all-targets && \
-    python3 android.py make -j --target=all-targets && \
-    python3 bcl.py make -j --product=android && \
-    cd /root && \
-    rm -rf /root/${mono_version}
-
 CMD /bin/bash
diff --git a/Dockerfile.base b/Dockerfile.base
index fe4a8b7..7b23b7a 100644
--- a/Dockerfile.base
+++ b/Dockerfile.base
@@ -2,8 +2,12 @@ FROM fedora:36
 
 WORKDIR /root
 
+ENV DOTNET_NOLOGO=1
+ENV DOTNET_CLI_TELEMETRY_OPTOUT=1
+
 RUN dnf -y install --setopt=install_weak_deps=False \
-      bash bzip2 curl file findutils git make nano patch pkgconfig python3-pip unzip which xz && \
-    pip install scons==4.3.0
+      bash bzip2 curl file findutils git make nano patch pkgconfig python3-pip unzip which xz \
+      dotnet-sdk-6.0 && \
+    pip install scons==4.4.0
 
 CMD /bin/bash
diff --git a/Dockerfile.ios b/Dockerfile.ios
index ead7aac..8d56dc1 100644
--- a/Dockerfile.ios
+++ b/Dockerfile.ios
@@ -1,8 +1,6 @@
 ARG img_version
 FROM godot-osx:${img_version}
 
-ARG mono_version
-
 ENV IOS_SDK=15.4
 
 RUN dnf -y install --setopt=install_weak_deps=False \
@@ -39,33 +37,4 @@ ENV OSXCROSS_IOS=not_nothing
 ENV IOSCROSS_ROOT=/root/ioscross
 ENV PATH="/root/ioscross/arm64/bin:/root/ioscross/arm64_sim/bin:/root/ioscross/x86_64_sim/bin:${PATH}"
 
-RUN if [ -z "${mono_version}" ]; then echo -e "\n\nargument mono-version is mandatory!\n\n"; exit 1; fi && \
-    cp -a /root/files/${mono_version} /root && \
-    cd /root/${mono_version} && \
-    cd godot-mono-builds && \
-    export MONO_SOURCE_ROOT=/root/${mono_version} && \
-    python3 ios.py configure -j --target=arm64 --ios-version-min 10.0 --osx-toolchain ${OSXCROSS_ROOT} \
-      --ios-toolchain ${IOSCROSS_ROOT}/arm64 --ios-sdk ${IOSCROSS_ROOT}/arm64/SDK/iPhoneOS${IOS_SDK}.sdk && \
-    python3 ios.py make -j --target=arm64 && \
-    #python3 ios.py configure -j --target=arm64-sim --ios-version-min 10.0 --osx-toolchain ${OSXCROSS_ROOT} \
-    #  --ios-toolchain ${IOSCROSS_ROOT}/arm64_sim --ios-sdk ${IOSCROSS_ROOT}/arm64_sim/SDK/iPhoneOS${IOS_SDK}.sdk && \
-    #python3 ios.py make -j --target=arm64-sim && \
-    python3 ios.py configure -j --target=x86_64 --ios-version-min 10.0 --osx-toolchain ${OSXCROSS_ROOT} \
-      --ios-toolchain ${IOSCROSS_ROOT}/x86_64_sim --ios-sdk ${IOSCROSS_ROOT}/x86_64_sim/SDK/iPhoneOS${IOS_SDK}.sdk && \
-    python3 ios.py make -j --target=x86_64 && \
-    python3 bcl.py make -j --product=ios && \
-    # TODO: Enable once godot-mono-builds supports osxcross for the cross-compiler.
-    # It requires having a build of libclang with support for iOS arm64 + changes to the build scripts.
-    #python3 ios.py configure -j --target=cross-arm64 --ios-toolchain ${IOSCROSS_ROOT}/arm64 --ios-sdk ${IOSCROSS_ROOT}/arm64/SDK/iPhoneOS${IOS_SDK}.sdk --osx-toolchain ${OSXCROSS_ROOT} && \
-    #python3 ios.py make -j --target=cross-arm64 && \
-    cd /root && \
-    rm -rf /root/${mono_version}
-
-# Until we can build the cross-compiler, we include a pre-made build in the container.
-RUN mkdir -p /root/aot-compilers/iphone-arm64 && \
-    curl -LO https://github.com/godotengine/godot-mono-builds/releases/download/release-fcf205c/ios-cross-arm64.zip && \
-    dnf -y install --setopt=install_weak_deps=False p7zip && \
-    7za e ios-cross-arm64.zip ios-cross-arm64-release/bin/aarch64-apple-darwin-mono-sgen -o/root/aot-compilers/iphone-arm64 && \
-    rm ios-cross-arm64.zip
-
 CMD /bin/bash
diff --git a/Dockerfile.javascript b/Dockerfile.javascript
index a4b1678..9565d1e 100644
--- a/Dockerfile.javascript
+++ b/Dockerfile.javascript
@@ -1,32 +1,10 @@
 ARG img_version
-FROM godot-mono:${img_version}
+FROM godot-fedora:${img_version}
 
-ARG mono_version
+ENV EMSCRIPTEN_VERSION=3.1.20
 
-ENV EMSCRIPTEN_CLASSICAL=3.1.14
-ENV EMSCRIPTEN_MONO=1.39.9
-
-RUN if [ -z "${mono_version}" ]; then printf "\n\nArgument mono_version is mandatory!\n\n"; exit 1; fi && \
-    # We need to downgrade to autoconf 2.69 from F35 as autoconf 2.71 from F36 breaks `--host wasm32`.
-    dnf -y install --setopt=install_weak_deps=False \
-      https://kojipkgs.fedoraproject.org//packages/autoconf/2.69/37.fc35/noarch/autoconf-2.69-37.fc35.noarch.rpm \
-      https://kojipkgs.fedoraproject.org//packages/automake/1.16.2/5.fc35/noarch/automake-1.16.2-5.fc35.noarch.rpm && \
-    git clone --branch ${EMSCRIPTEN_CLASSICAL} --progress https://github.com/emscripten-core/emsdk emsdk_${EMSCRIPTEN_CLASSICAL} && \
-    cp -r emsdk_${EMSCRIPTEN_CLASSICAL} emsdk_${EMSCRIPTEN_MONO} && \
-    emsdk_${EMSCRIPTEN_CLASSICAL}/emsdk install ${EMSCRIPTEN_CLASSICAL} && \
-    emsdk_${EMSCRIPTEN_CLASSICAL}/emsdk activate ${EMSCRIPTEN_CLASSICAL} && \
-    emsdk_${EMSCRIPTEN_MONO}/emsdk install ${EMSCRIPTEN_MONO} && \
-    emsdk_${EMSCRIPTEN_MONO}/emsdk activate ${EMSCRIPTEN_MONO} && \
-    source /root/emsdk_${EMSCRIPTEN_MONO}/emsdk_env.sh && \
-    cp -a /root/files/${mono_version} /root && \
-    cd /root/${mono_version} && \
-    export MONO_SOURCE_ROOT=/root/${mono_version} && \
-    cd /root/${mono_version}/godot-mono-builds && \
-    python3 patch_emscripten.py && \
-    python3 wasm.py configure -j --target=runtime && \
-    python3 wasm.py make -j --target=runtime && \
-    python3 bcl.py make -j --product wasm && \
-    cd /root && \
-    rm -rf /root/${mono_version}
+RUN git clone --branch ${EMSCRIPTEN_VERSION} --progress https://github.com/emscripten-core/emsdk && \
+    emsdk/emsdk install ${EMSCRIPTEN_VERSION} && \
+    emsdk/emsdk activate ${EMSCRIPTEN_VERSION}
 
 CMD /bin/bash
diff --git a/Dockerfile.linux b/Dockerfile.linux
index dc24990..f089660 100644
--- a/Dockerfile.linux
+++ b/Dockerfile.linux
@@ -1,15 +1,12 @@
 ARG img_version
-FROM godot-mono:${img_version}
-
-ARG mono_version
+FROM godot-fedora:${img_version}
 
 ENV GODOT_SDK_LINUX_X86_64=/root/x86_64-godot-linux-gnu_sdk-buildroot
 ENV GODOT_SDK_LINUX_X86=/root/i686-godot-linux-gnu_sdk-buildroot
 ENV GODOT_SDK_LINUX_ARMHF=/root/arm-godot-linux-gnueabihf_sdk-buildroot
 ENV BASE_PATH=${PATH}
 
-RUN if [ -z "${mono_version}" ]; then echo -e "\n\nargument mono-version is mandatory!\n\n"; exit 1; fi && \
-    dnf -y install --setopt=install_weak_deps=False \
+RUN dnf -y install --setopt=install_weak_deps=False \
       libxcrypt-compat yasm && \
     curl -LO https://downloads.tuxfamily.org/godotengine/toolchains/linux/2021-02-11/x86_64-godot-linux-gnu_sdk-buildroot.tar.bz2 && \
     tar xf x86_64-godot-linux-gnu_sdk-buildroot.tar.bz2 && \
@@ -30,20 +27,6 @@ RUN if [ -z "${mono_version}" ]; then echo -e "\n\nargument mono-version is mand
     rm -f i686-godot-linux-gnu_sdk-buildroot.tar.bz2 && \
     cd i686-godot-linux-gnu_sdk-buildroot && \
     ./relocate-sdk.sh && \
-    rm -f bin/{aclocal*,auto*,libtool*,m4} && \
-    cp -a /root/files/${mono_version} /root && \
-    export MONO_SOURCE_ROOT=/root/${mono_version} && \
-    cd /root/${mono_version}/godot-mono-builds && \
-    export PATH=${GODOT_SDK_LINUX_X86_64}/bin:${BASE_PATH} && \
-    python3 linux.py configure -j --target=x86_64 && \
-    python3 linux.py make -j --target=x86_64 && \
-    export PATH=${GODOT_SDK_LINUX_X86}/bin:${BASE_PATH} && \
-    python3 linux.py configure -j --target=x86 && \
-    python3 linux.py make -j --target=x86 && \
-    export PATH=${GODOT_SDK_LINUX_X86_64}/bin:${BASE_PATH} && \
-    python3 bcl.py make -j --product=desktop && \
-    python3 linux.py copy-bcl --target=x86_64 --target=x86 && \
-    cd /root && \
-    rm -rf /root/${mono_version}
+    rm -f bin/{aclocal*,auto*,libtool*,m4}
 
 CMD /bin/bash
diff --git a/Dockerfile.mono b/Dockerfile.mono
deleted file mode 100644
index 10a635d..0000000
--- a/Dockerfile.mono
+++ /dev/null
@@ -1,24 +0,0 @@
-ARG img_version
-FROM godot-fedora:${img_version}
-
-ARG mono_version
-
-RUN if [ -z "${mono_version}" ]; then echo -e "\n\nargument mono-version is mandatory!\n\n"; exit 1; fi && \
-    dnf -y install --setopt=install_weak_deps=False \
-      autoconf automake cmake gcc gcc-c++ gettext libtool perl python-unversioned-command && \
-    cp -a /root/files/${mono_version} /root && \
-    cd /root/${mono_version} && \
-    NOCONFIGURE=1 ./autogen.sh && \
-    ./configure --prefix=/usr --sysconfdir=/etc --localstatedir=/var/lib/mono --disable-boehm --host=x86_64-linux-gnu && \
-    make -j && \
-    make install && \
-    cd /root && \
-    rm -rf /root/${mono_version} && \
-    cert-sync /etc/pki/tls/certs/ca-bundle.crt && \
-    rpm -ivh --nodeps \
-      https://download.mono-project.com/repo/centos8-preview/m/msbuild/msbuild-16.10.1+xamarinxplat.2021.05.26.14.00-0.xamarin.7.epel8.noarch.rpm \
-      https://download.mono-project.com/repo/centos8-preview/m/msbuild/msbuild-sdkresolver-16.10.1+xamarinxplat.2021.05.26.14.00-0.xamarin.7.epel8.noarch.rpm \
-      https://download.mono-project.com/repo/centos8-preview/m/msbuild-libhostfxr/msbuild-libhostfxr-3.0.0.2019.04.16.02.13-0.xamarin.4.epel8.x86_64.rpm \
-      https://download.mono-project.com/repo/centos8-preview/n/nuget/nuget-5.6.0.6489.bin-0.xamarin.1.epel8.noarch.rpm
-
-CMD /bin/bash
diff --git a/Dockerfile.mono-glue b/Dockerfile.mono-glue
deleted file mode 100644
index 1c90882..0000000
--- a/Dockerfile.mono-glue
+++ /dev/null
@@ -1,10 +0,0 @@
-ARG img_version
-FROM godot-mono:${img_version}
-
-ARG mono_version
-
-RUN dnf -y install --setopt=install_weak_deps=False \
-      xorg-x11-server-Xvfb libX11-devel libXcursor-devel libXrandr-devel libXinerama-devel libXi-devel \
-      alsa-lib-devel pulseaudio-libs-devel libudev-devel mesa-libGL-devel mesa-libGLU-devel mesa-dri-drivers
-
-CMD /bin/bash
diff --git a/Dockerfile.osx b/Dockerfile.osx
index 63fd9d5..9b3ef82 100644
--- a/Dockerfile.osx
+++ b/Dockerfile.osx
@@ -1,11 +1,8 @@
 ARG img_version
-FROM godot-mono:${img_version}
+FROM godot-fedora:${img_version}
 
-ARG mono_version
-
-RUN if [ -z "${mono_version}" ]; then echo -e "\n\nargument mono-version is mandatory!\n\n"; exit 1; fi && \
-    dnf -y install --setopt=install_weak_deps=False \
-      automake autoconf bzip2-devel cmake libicu-devel libtool libxml2-devel openssl-devel yasm && \
+RUN dnf -y install --setopt=install_weak_deps=False \
+      automake autoconf bzip2-devel cmake gcc gcc-c++ libicu-devel libtool libxml2-devel openssl-devel yasm && \
     git clone --progress https://github.com/tpoechtrager/osxcross.git && \
     cd /root/osxcross && \
     git checkout 17bb5e2d0a46533c1dd525cf4e9a80d88bd9f00e && \
@@ -20,17 +17,4 @@ RUN if [ -z "${mono_version}" ]; then echo -e "\n\nargument mono-version is mand
 ENV OSXCROSS_ROOT=/root/osxcross
 ENV PATH="/root/osxcross/target/bin:${PATH}"
 
-RUN cp -a /root/files/${mono_version} /root && \
-    cd /root/${mono_version} && \
-    patch -p1 < /root/files/patches/mono-btls-cmake-wrapper.patch && \
-    export MONO_SOURCE_ROOT=/root/${mono_version} && \
-    export OSXCROSS_SDK=21.4 && \
-    cd /root/${mono_version}/godot-mono-builds && \
-    python3 osx.py configure -j --target=x86_64 --target=arm64 && \
-    python3 osx.py make -j --target=x86_64 --target=arm64 && \
-    python3 bcl.py make --product=desktop && \
-    python3 osx.py copy-bcl --target=x86_64 --target=arm64 && \
-    cd /root && \
-    rm -rf /root/${mono_version}
-
 CMD /bin/bash
diff --git a/Dockerfile.windows b/Dockerfile.windows
index 687bca5..e470e62 100644
--- a/Dockerfile.windows
+++ b/Dockerfile.windows
@@ -1,22 +1,7 @@
 ARG img_version
-FROM godot-mono:${img_version}
+FROM godot-fedora:${img_version}
 
-ARG mono_version
-
-RUN if [ -z "${mono_version}" ]; then echo -e "\n\nargument mono-version is mandatory!\n\n"; exit 1; fi && \
-    dnf -y install --setopt=install_weak_deps=False \
-      mingw32-gcc mingw32-gcc-c++ mingw32-winpthreads-static mingw64-gcc mingw64-gcc-c++ mingw64-winpthreads-static && \
-    cp -a /root/files/${mono_version} /root && \
-    export MONO_SOURCE_ROOT=/root/${mono_version} && \
-    cd /root/${mono_version}/godot-mono-builds && \
-    python3 windows.py configure -j --target=x86_64 --target=x86 --mxe-prefix=/usr && \
-    python3 windows.py make -j --target=x86_64 --target=x86 --mxe-prefix=/usr && \
-    # 'desktop' bcl needed to build 'desktop-win32', then we can remove it.
-    python3 bcl.py make -j --product=desktop && \
-    python3 bcl.py make -j --product=desktop-win32 && \
-    rm -rf /root/mono-installs/desktop-bcl && \
-    python3 windows.py copy-bcl --target=x86_64 --target=x86 && \
-    cd /root && \
-    rm -rf /root/${mono_version}
+RUN dnf -y install --setopt=install_weak_deps=False \
+      mingw32-gcc mingw32-gcc-c++ mingw32-winpthreads-static mingw64-gcc mingw64-gcc-c++ mingw64-winpthreads-static
 
 CMD /bin/bash
diff --git a/README.md b/README.md
index 056fcc1..943a9ce 100644
--- a/README.md
+++ b/README.md
@@ -35,29 +35,27 @@ tried we ran into performance issues).
 
 The `build.sh` script included is used to build the containers themselves.
 
-The first two arguments can take any value and are meant to convey what Godot branch
-you are building for (e.g. `3.x`) and what Linux distribution the `Dockerfile.base`
+The two arguments can take any value and are meant to convey what Godot branch
+you are building for (e.g. `4.x`) and what Linux distribution the `Dockerfile.base`
 is based on (e.g. `f36` for Fedora 36).
 
-The third argument is important and should be the name of a tagged Mono release from
-the upstream `2020-02` branch (e.g. `mono-6.12.0.182`).
-
 Run the command using:
 
-    ./build.sh 3.x f36 mono-6.12.0.182
+    ./build.sh 4.x f36
 
-The above will generate images using the tag '3.x-f36-mono-6.12.0.182'.
-You can then specify it in the `build.sh` of [godot-build-scripts]().
+The above will generate images using the tag '4.x-f36'.
+You can then specify it in the `build.sh` of
+[godot-build-scripts](https://github.com/godotengine/godot-build-scripts).
 
 ### Selecting which images to build
 
 If you don't need to build all versions or you want to try with a single target OS first,
 you can comment out the corresponding lines from the script:
 
-    $podman_build_mono -t godot-linux:${img_version} -f Dockerfile.linux . 2>&1 | tee logs/linux.log
-    $podman_build_mono -t godot-windows:${img_version} -f Dockerfile.windows . 2>&1 | tee logs/windows.log
-    $podman_build_mono -t godot-javascript:${img_version} -f Dockerfile.javascript . 2>&1 | tee logs/javascript.log
-    $podman_build_mono -t godot-android:${img_version} -f Dockerfile.android . 2>&1 | tee logs/android.log
+    $podman_build -t godot-linux:${img_version} -f Dockerfile.linux . 2>&1 | tee logs/linux.log
+    $podman_build -t godot-windows:${img_version} -f Dockerfile.windows . 2>&1 | tee logs/windows.log
+    $podman_build -t godot-javascript:${img_version} -f Dockerfile.javascript . 2>&1 | tee logs/javascript.log
+    $podman_build -t godot-android:${img_version} -f Dockerfile.android . 2>&1 | tee logs/android.log
     ...
 
 **Note:** The MSVC image (used for UWP builds) does not work currently.
@@ -68,31 +66,28 @@ you can comment out the corresponding lines from the script:
 These are the expected container image sizes, so you can plan your disk usage in advance:
 
     REPOSITORY                                       TAG                        SIZE
-    localhost/godot-fedora                           3.x-f36-mono-6.12.0.182    546 MB
-    localhost/godot-export                           3.x-f36-mono-6.12.0.182    1.03 GB
-    localhost/godot-mono                             3.x-f36-mono-6.12.0.182    1.41 GB
-    localhost/godot-mono-glue                        3.x-f36-mono-6.12.0.182    1.75 GB
-    localhost/godot-linux                            3.x-f36-mono-6.12.0.182    3.8 GB
-    localhost/godot-windows                          3.x-f36-mono-6.12.0.182    3.31 GB
-    localhost/godot-javascript                       3.x-f36-mono-6.12.0.182    3.87 GB
-    localhost/godot-android                          3.x-f36-mono-6.12.0.182    6.06 GB
-    localhost/godot-osx                              3.x-f36-mono-6.12.0.182    5.71 GB
-    localhost/godot-ios                              3.x-f36-mono-6.12.0.182    6.53 GB
+    localhost/godot-fedora                           4.x-f36                    1.06 GB
+    localhost/godot-export                           4.x-f36                    1.54 GB
+    localhost/godot-linux                            4.x-f36                    2.07 GB
+    localhost/godot-windows                          4.x-f36                    1.81 GB
+    localhost/godot-javascript                       4.x-f36                    2.2 GB
+    localhost/godot-android                          4.x-f36                    4.24 GB
+    localhost/godot-osx                              4.x-f36                    4.56 GB
+    localhost/godot-ios                              4.x-f36                    5.01 GB
 
 In addition to this, generating containers will also require some host disk space
-(up to 30 GB) for the downloaded Mono sources and dependencies (Xcode, MSVC).
+(around 20 GB) for the dependencies (Xcode, MSVC).
 
 
 ## Toolchains
 
-These are the toolchains currently in use for Godot 3.5 and later:
+These are the toolchains currently in use for Godot 4.0 and later:
 
 - Base image: Fedora 36
-- Mono version: 6.12.0.182
-- SCons: 4.3.0
+- SCons: 4.4.0
 - Linux: GCC 10.2.0 built against glibc 2.19, binutils 2.35.1, from our own [Linux SDK](https://github.com/godotengine/buildroot)
 - Windows: MinGW 9.0.0, GCC 11.2.0, binutils 2.37
-- HTML5: Emscripten 3.1.14 (standard builds), Emscripten 1.39.9 (Mono builds)
+- HTML5: Emscripten 3.1.20
 - Android: Android NDK 23.2.8568313, build-tools 32.0.0, platform android-32, CMake 3.18.1
 - macOS: Xcode 13.3.1 with LLVM Clang 13.0.1, MacOSX SDK 12.3
 - iOS: Xcode 13.3.1 with LLVM Clang 13.0.1, iPhoneOS SDK 15.4
diff --git a/build.sh b/build.sh
index a14b7c5..4de67e2 100755
--- a/build.sh
+++ b/build.sh
@@ -8,10 +8,10 @@ if [ -z $podman ]; then
   exit 1
 fi
 
-if [ -z "$1" -o -z "$2" -o -z "$3" ]; then
-  echo "Usage: $0 <godot branch> <base distro> <mono version>"
+if [ -z "$1" -o -z "$2" ]; then
+  echo "Usage: $0 <godot branch> <base distro>"
   echo
-  echo "Example: $0 3.x f35 mono-6.12.0.178"
+  echo "Example: $0 3.x f35"
   echo
   echo "godot branch:"
   echo "        Informational, tracks the Godot branch these containers are intended for."
@@ -19,28 +19,18 @@ if [ -z "$1" -o -z "$2" -o -z "$3" ]; then
   echo "base distro:"
   echo "        Informational, tracks the base Linux distro these containers are based on."
   echo
-  echo "mono version:"
-  echo "	Defines the Mono tag that will be cloned with Git to compile from source."
-  echo
-  echo "The resulting image version will be <godot branch>-<base distro>-<mono version>."
+  echo "The resulting image version will be <godot branch>-<base distro>."
   exit 1
 fi
 
 godot_branch=$1
 base_distro=$2
-mono_version=$3
-img_version=$godot_branch-$base_distro-$mono_version
+img_version=$godot_branch-$base_distro
 files_root=$(pwd)/files
-mono_root="${files_root}/${mono_version}"
 build_msvc=0
 
 # Confirm settings
 echo "Docker image tag: ${img_version}"
-echo "Mono branch: ${mono_version}"
-if [ -e ${mono_root} ]; then
-  mono_exists="(exists)"
-fi
-echo "Mono source folder: ${mono_root} ${mono_exists}"
 echo
 while true; do
   read -p "Is this correct? [y/n] " yn
@@ -53,35 +43,16 @@ done
 
 mkdir -p logs
 
-# Check out and patch Mono version
-if [ ! -e ${mono_root} ]; then
-  git clone -b ${mono_version} --single-branch --progress --depth 1 https://github.com/mono/mono ${mono_root}
-  pushd ${mono_root}
-  # Download all submodules, up to 6 at a time
-  git submodule update --init --recursive --recommend-shallow -j 6 --progress
-  # Set up godot-mono-builds in tree
-  git clone --progress https://github.com/godotengine/godot-mono-builds
-  pushd godot-mono-builds
-  git checkout 4bf530983a52d09f4f63aea032aee9be47931cbd
-  export MONO_SOURCE_ROOT=${mono_root}
-  python3 patch_mono.py
-  popd
-  popd
-fi
-
 # You can add --no-cache  as an option to podman_build below to rebuild all containers from scratch
-export podman_build="$podman build --build-arg img_version=${img_version}"
-export podman_build_mono="$podman_build --build-arg mono_version=${mono_version} -v ${files_root}:/root/files"
+export podman_build="$podman build --build-arg img_version=${img_version} -v ${files_root}:/root/files"
 
-$podman build -v ${files_root}:/root/files -t godot-fedora:${img_version} -f Dockerfile.base . 2>&1 | tee logs/base.log
+$podman build -t godot-fedora:${img_version} -f Dockerfile.base . 2>&1 | tee logs/base.log
 $podman_build -t godot-export:${img_version} -f Dockerfile.export . 2>&1 | tee logs/export.log
 
-$podman_build_mono -t godot-mono:${img_version} -f Dockerfile.mono . 2>&1 | tee logs/mono.log
-$podman_build_mono -t godot-mono-glue:${img_version} -f Dockerfile.mono-glue . 2>&1 | tee logs/mono-glue.log
-$podman_build_mono -t godot-linux:${img_version} -f Dockerfile.linux . 2>&1 | tee logs/linux.log
-$podman_build_mono -t godot-windows:${img_version} -f Dockerfile.windows . 2>&1 | tee logs/windows.log
-$podman_build_mono -t godot-javascript:${img_version} -f Dockerfile.javascript . 2>&1 | tee logs/javascript.log
-$podman_build_mono -t godot-android:${img_version} -f Dockerfile.android . 2>&1 | tee logs/android.log
+$podman_build -t godot-linux:${img_version} -f Dockerfile.linux . 2>&1 | tee logs/linux.log
+$podman_build -t godot-windows:${img_version} -f Dockerfile.windows . 2>&1 | tee logs/windows.log
+$podman_build -t godot-javascript:${img_version} -f Dockerfile.javascript . 2>&1 | tee logs/javascript.log
+$podman_build -t godot-android:${img_version} -f Dockerfile.android . 2>&1 | tee logs/android.log
 
 XCODE_SDK=13.3.1
 OSX_SDK=12.3
@@ -93,12 +64,12 @@ if [ ! -e files/MacOSX${OSX_SDK}.sdk.tar.xz ] || [ ! -e files/iPhoneOS${IOS_SDK}
   fi
 
   echo "Building OSX and iOS SDK packages. This will take a while"
-  $podman_build -t godot-xcode-packer:${img_version} -f Dockerfile.xcode -v ${files_root}:/root/files . 2>&1 | tee logs/xcode.log
+  $podman_build -t godot-xcode-packer:${img_version} -f Dockerfile.xcode . 2>&1 | tee logs/xcode.log
   $podman run -it --rm -v ${files_root}:/root/files -e XCODE_SDKV="${XCODE_SDK}" -e OSX_SDKV="${OSX_SDK}" -e IOS_SDKV="${IOS_SDK}" godot-xcode-packer:${img_version} 2>&1 | tee logs/xcode_packer.log
 fi
 
-$podman_build_mono -t godot-osx:${img_version} -f Dockerfile.osx . 2>&1 | tee logs/osx.log
-$podman_build_mono -t godot-ios:${img_version} -f Dockerfile.ios . 2>&1 | tee logs/ios.log
+$podman_build -t godot-osx:${img_version} -f Dockerfile.osx . 2>&1 | tee logs/osx.log
+$podman_build -t godot-ios:${img_version} -f Dockerfile.ios . 2>&1 | tee logs/ios.log
 
 if [ "${build_msvc}" != "0" ]; then
   if [ ! -e files/msvc2017.tar ]; then
@@ -113,5 +84,5 @@ if [ "${build_msvc}" != "0" ]; then
     exit 1
   fi
 
-  $podman_build -t godot-msvc:${img_version} -f Dockerfile.msvc -v ${files_root}:/root/files . 2>&1 | tee logs/msvc.log
+  $podman_build -t godot-msvc:${img_version} -f Dockerfile.msvc . 2>&1 | tee logs/msvc.log
 fi
diff --git a/files/patches/mono-btls-cmake-wrapper.patch b/files/patches/mono-btls-cmake-wrapper.patch
deleted file mode 100644
index 9b1a852..0000000
--- a/files/patches/mono-btls-cmake-wrapper.patch
+++ /dev/null
@@ -1,13 +0,0 @@
-diff --git a/mono/btls/Makefile.am b/mono/btls/Makefile.am
-index 9a385443..094b26f4 100644
---- a/mono/btls/Makefile.am
-+++ b/mono/btls/Makefile.am
-@@ -58,7 +58,7 @@ all-local: build-shared/libmono-btls-shared$(libsuffix)
- 
- build-shared/$(BUILDFILE):
- 	-mkdir -p build-shared
--	(cd build-shared && CC="$(CC)" CXX="$(CXX)" "$(CMAKE)" $(CMAKE_ARGS) $(BTLS_CMAKE_ARGS) -DBUILD_SHARED_LIBS=1 "$(abs_top_srcdir)/mono/btls")
-+	(cd build-shared && CC="$(CC)" CXX="$(CXX)" $(CMAKE) $(CMAKE_ARGS) $(BTLS_CMAKE_ARGS) -DBUILD_SHARED_LIBS=1 "$(abs_top_srcdir)/mono/btls")
- 
- if NINJA
- build-shared/libmono-btls-shared$(libsuffix): build-shared/$(BUILDFILE) $(MONO_BTLS_SOURCES_FILES)
diff --git a/upload.sh b/upload.sh
index 4ef1a05..5727c54 100755
--- a/upload.sh
+++ b/upload.sh
@@ -20,7 +20,6 @@ if [ -z "${registry}" ]; then
 fi
 
 $podman push godot-export:${img_version} ${registry}/godot/export
-$podman push godot-mono-glue:${img_version} ${registry}/godot/mono-glue
 $podman push godot-linux:${img_version} ${registry}/godot/linux
 $podman push godot-windows:${img_version} ${registry}/godot/windows
 $podman push godot-javascript:${img_version} ${registry}/godot/javascript