dotnet · ApparentlyPlus · Sep 11, 2026 · Sep 15, 2026 · Sep 24, 2026
diff --git a/docs/workflow/building/coreclr/README.md b/docs/workflow/building/coreclr/README.md
@@ -121,6 +121,20 @@ To use *Ninja* instead of *Make* on non-Windows:
 
 You can also pass some extra compiler/linker flags to the CoreCLR build. Set the `EXTRA_CFLAGS`, `EXTRA_CXXFLAGS`, and `EXTRA_LDFLAGS` as you see fit for this purpose. The build script will consume them and then set the environment variables that will ultimately affect your build (i.e. those same ones without the `EXTRA_` prefix). Don't set the final ones directly yourself, as that is known to lead to potential failures in configure-time tests.
 
+### CMake Arguments
+
+On Unix, the top-level `build.sh` accepts a shell-quoted command fragment with `--cmakeargs`. Quote values containing spaces inside that fragment. Multiple options, including repeated `--cmakeargs` fragments, reach CMake in their original order:
+
+```bash
+./build.sh clr --cmakeargs "-DFIRST=1 -DSECOND=2" --cmakeargs "-DCMAKE_C_FLAGS='-O2 -g'"
+```
+
+When invoking `src/coreclr/build-runtime.sh`, `src/native/corehost/build.sh`, or `src/native/libs/build-native.sh` directly, each `-cmakeargs` accepts one literal argument. Alternatively, put `--` after all build-script options and follow it with CMake arguments using normal shell quoting. Arguments after `--` retain their order and override earlier definitions:
+
+```bash
+./src/coreclr/build-runtime.sh -component jit -- -DFIRST=1 -DFIRST=2 "-DCMAKE_C_FLAGS=-O2 -g"
+```
+
 ### Native ARM64 Building on Windows
 
 Currently, the runtime repo supports building CoreCLR directly on Windows ARM64 without the need to cross-compile, albeit it is still in an experimental phase. To do this, you need to install the ARM64 build tools and Windows SDK for Visual Studio, in addition to all the requirements outlined in the [Windows Requirements doc](/docs/workflow/requirements/windows-requirements.md).

diff --git a/eng/build.sh b/eng/build.sh
@@ -622,8 +622,10 @@ initDistroRid "$os" "$arch" "$crossBuild"
 # The later changes are ignored when using the cache.
 export DOTNETSDK_ALLOW_TARGETING_PACK_CACHING=0
 
-# URL-encode space (%20) to avoid quoting issues until the msbuild call in /eng/common/tools.sh.
-# In *proj files (XML docs), URL-encoded string are rendered in their decoded form.
+# Preserve the command fragment through MSBuild's command-line property parsing.
+cmakeargs="${cmakeargs//%/%25}"
+cmakeargs="${cmakeargs//\"/%22}"
+cmakeargs="${cmakeargs//;/%3B}"
 cmakeargs="${cmakeargs// /%20}"
 arguments+=("/p:TargetArchitecture=$arch" "/p:BuildArchitecture=$hostArch")
 arguments+=("/p:CMakeArgs=\"$cmakeargs\"" ${extraargs[@]+"${extraargs[@]}"})

diff --git a/eng/native/build-commons.sh b/eng/native/build-commons.sh
@@ -49,16 +49,17 @@ check_prereqs()
 build_native()
 {
     if [[ ! -e "$__RepoRootDir/artifacts/obj/_version.c" ]]; then
-        eval "$__RepoRootDir/eng/native/version/copy_version_files.sh"
+        "$__RepoRootDir/eng/native/version/copy_version_files.sh"
     fi
 
     targetOS="$1"
     hostArch="$2"
     cmakeDir="$3"
     intermediatesDir="$4"
     target="$5"
-    cmakeArgs="$6"
-    message="$7"
+    message="$6"
+    shift 6
+    cmakeArgs=("$@")
 
     # When sccache is enabled, use it as the compiler launcher.
     # On macOS, CMake wraps PCH includes with -Xarch_<arch> which sccache
@@ -69,7 +70,7 @@ build_native()
         if [[ "$targetOS" == osx || "$targetOS" == maccatalyst ]]; then
             __sccacheLauncher="$__RepoRootDir/eng/native/sccache-xarch-wrapper.sh"
         fi
-        cmakeArgs="-DCMAKE_C_COMPILER_LAUNCHER=$__sccacheLauncher -DCMAKE_CXX_COMPILER_LAUNCHER=$__sccacheLauncher $cmakeArgs"
+        cmakeArgs=("-DCMAKE_C_COMPILER_LAUNCHER=$__sccacheLauncher" "-DCMAKE_CXX_COMPILER_LAUNCHER=$__sccacheLauncher" "${cmakeArgs[@]}")
     fi
 
     # All set to commence the build
@@ -91,24 +92,24 @@ build_native()
 
     if [[ "$targetOS" == osx || "$targetOS" == maccatalyst ]]; then
         if [[ "$hostArch" == x64 ]]; then
-            cmakeArgs="-DCMAKE_OSX_ARCHITECTURES=\"x86_64\" $cmakeArgs"
+            cmakeArgs=(-DCMAKE_OSX_ARCHITECTURES=x86_64 "${cmakeArgs[@]}")
         elif [[ "$hostArch" == arm64 ]]; then
-            cmakeArgs="-DCMAKE_OSX_ARCHITECTURES=\"arm64\" $cmakeArgs"
+            cmakeArgs=(-DCMAKE_OSX_ARCHITECTURES=arm64 "${cmakeArgs[@]}")
         else
             echo "Error: Unknown OSX architecture $hostArch."
             exit 1
         fi
     fi
 
     if [[ "$targetOS" == maccatalyst ]]; then
-        cmakeArgs="-C $__RepoRootDir/eng/native/tryrun_ios_tvos.cmake $cmakeArgs"
+        cmakeArgs=(-C "$__RepoRootDir/eng/native/tryrun_ios_tvos.cmake" "${cmakeArgs[@]}")
 
         # Intentionally do not set CMAKE_OSX_DEPLOYMENT_TARGET for maccatalyst here:
         # - CMake interprets CMAKE_OSX_DEPLOYMENT_TARGET as a macOS minimum version
         #   instead of MacCatalyst, causing newer clang to reject it as invalid.
         # - The effective Catalyst minimum version is enforced via the
         #   -target *-apple-ios<version>-macabi flag in eng/native/configurecompiler.cmake
-        cmakeArgs="-DCMAKE_SYSTEM_NAME=Darwin -DCMAKE_OSX_SYSROOT=macosx -DCMAKE_SYSTEM_VARIANT=maccatalyst $cmakeArgs"
+        cmakeArgs=(-DCMAKE_SYSTEM_NAME=Darwin -DCMAKE_OSX_SYSROOT=macosx -DCMAKE_SYSTEM_VARIANT=maccatalyst "${cmakeArgs[@]}")
     fi
 
     if [[ "$targetOS" == android || "$targetOS" == linux-bionic ]]; then
@@ -119,72 +120,72 @@ build_native()
             exit 1
         fi
 
-        cmakeArgs="-DANDROID_BUILD=1 -C $__RepoRootDir/eng/native/tryrun.cmake $cmakeArgs"
-        cmakeArgs="-DCMAKE_TOOLCHAIN_FILE=$ANDROID_NDK_ROOT/build/cmake/android.toolchain.cmake -DANDROID_PLATFORM=android-${ANDROID_API_LEVEL} -DANDROID_NATIVE_API_LEVEL=${ANDROID_API_LEVEL} $cmakeArgs"
+        cmakeArgs=(-DANDROID_BUILD=1 -C "$__RepoRootDir/eng/native/tryrun.cmake" "${cmakeArgs[@]}")
+        cmakeArgs=("-DCMAKE_TOOLCHAIN_FILE=$ANDROID_NDK_ROOT/build/cmake/android.toolchain.cmake" "-DANDROID_PLATFORM=android-${ANDROID_API_LEVEL}" "-DANDROID_NATIVE_API_LEVEL=${ANDROID_API_LEVEL}" "${cmakeArgs[@]}")
 
         # Don't try to set CC/CXX in init-compiler.sh - it's handled in android.toolchain.cmake already
         __Compiler="default"
 
         if [[ "$hostArch" == x64 ]]; then
-            cmakeArgs="-DANDROID_ABI=x86_64 $cmakeArgs"
+            cmakeArgs=(-DANDROID_ABI=x86_64 "${cmakeArgs[@]}")
         elif [[ "$hostArch" == x86 ]]; then
-            cmakeArgs="-DANDROID_ABI=x86 $cmakeArgs"
+            cmakeArgs=(-DANDROID_ABI=x86 "${cmakeArgs[@]}")
         elif [[ "$hostArch" == arm64 ]]; then
-            cmakeArgs="-DANDROID_ABI=arm64-v8a $cmakeArgs"
+            cmakeArgs=(-DANDROID_ABI=arm64-v8a "${cmakeArgs[@]}")
         elif [[ "$hostArch" == arm ]]; then
-            cmakeArgs="-DANDROID_ABI=armeabi-v7a $cmakeArgs"
+            cmakeArgs=(-DANDROID_ABI=armeabi-v7a "${cmakeArgs[@]}")
         else
             echo "Error: Unknown Android architecture $hostArch."
             exit 1
         fi
     elif [[ "$targetOS" == iossimulator ]]; then
-        cmakeArgs="-C $__RepoRootDir/eng/native/tryrun_ios_tvos.cmake $cmakeArgs"
+        cmakeArgs=(-C "$__RepoRootDir/eng/native/tryrun_ios_tvos.cmake" "${cmakeArgs[@]}")
 
         # set default iOS simulator deployment target
         # keep in sync with SetOSTargetMinVersions in the root Directory.Build.props
-        cmakeArgs="-DCMAKE_SYSTEM_NAME=iOS -DCMAKE_OSX_SYSROOT=iphonesimulator -DCMAKE_OSX_DEPLOYMENT_TARGET=13.0 $cmakeArgs"
+        cmakeArgs=(-DCMAKE_SYSTEM_NAME=iOS -DCMAKE_OSX_SYSROOT=iphonesimulator -DCMAKE_OSX_DEPLOYMENT_TARGET=13.0 "${cmakeArgs[@]}")
         if [[ "$__TargetArch" == x64 ]]; then
-            cmakeArgs="-DCMAKE_OSX_ARCHITECTURES=\"x86_64\" $cmakeArgs"
+            cmakeArgs=(-DCMAKE_OSX_ARCHITECTURES=x86_64 "${cmakeArgs[@]}")
         elif [[ "$__TargetArch" == arm64 ]]; then
-            cmakeArgs="-DCMAKE_OSX_ARCHITECTURES=\"arm64\" $cmakeArgs"
+            cmakeArgs=(-DCMAKE_OSX_ARCHITECTURES=arm64 "${cmakeArgs[@]}")
         else
             echo "Error: Unknown iOS Simulator architecture $__TargetArch."
             exit 1
         fi
     elif [[ "$targetOS" == ios ]]; then
-        cmakeArgs="-C $__RepoRootDir/eng/native/tryrun_ios_tvos.cmake $cmakeArgs"
+        cmakeArgs=(-C "$__RepoRootDir/eng/native/tryrun_ios_tvos.cmake" "${cmakeArgs[@]}")
 
         # set default iOS device deployment target
         # keep in sync with SetOSTargetMinVersions in the root Directory.Build.props
-        cmakeArgs="-DCMAKE_SYSTEM_NAME=iOS -DCMAKE_OSX_SYSROOT=iphoneos -DCMAKE_OSX_DEPLOYMENT_TARGET=13.0 $cmakeArgs"
+        cmakeArgs=(-DCMAKE_SYSTEM_NAME=iOS -DCMAKE_OSX_SYSROOT=iphoneos -DCMAKE_OSX_DEPLOYMENT_TARGET=13.0 "${cmakeArgs[@]}")
         if [[ "$__TargetArch" == arm64 ]]; then
-            cmakeArgs="-DCMAKE_OSX_ARCHITECTURES=\"arm64\" $cmakeArgs"
+            cmakeArgs=(-DCMAKE_OSX_ARCHITECTURES=arm64 "${cmakeArgs[@]}")
         else
             echo "Error: Unknown iOS architecture $__TargetArch."
             exit 1
         fi
     elif [[ "$targetOS" == tvossimulator ]]; then
-        cmakeArgs="-C $__RepoRootDir/eng/native/tryrun_ios_tvos.cmake $cmakeArgs"
+        cmakeArgs=(-C "$__RepoRootDir/eng/native/tryrun_ios_tvos.cmake" "${cmakeArgs[@]}")
 
         # set default tvOS simulator deployment target
         # keep in sync with SetOSTargetMinVersions in the root Directory.Build.props
-        cmakeArgs="-DCMAKE_SYSTEM_NAME=tvOS -DCMAKE_OSX_SYSROOT=appletvsimulator -DCMAKE_OSX_DEPLOYMENT_TARGET=13.0 $cmakeArgs"
+        cmakeArgs=(-DCMAKE_SYSTEM_NAME=tvOS -DCMAKE_OSX_SYSROOT=appletvsimulator -DCMAKE_OSX_DEPLOYMENT_TARGET=13.0 "${cmakeArgs[@]}")
         if [[ "$__TargetArch" == x64 ]]; then
-            cmakeArgs="-DCMAKE_OSX_ARCHITECTURES=\"x86_64\" $cmakeArgs"
+            cmakeArgs=(-DCMAKE_OSX_ARCHITECTURES=x86_64 "${cmakeArgs[@]}")
         elif [[ "$__TargetArch" == arm64 ]]; then
-            cmakeArgs="-DCMAKE_OSX_ARCHITECTURES=\"arm64\" $cmakeArgs"
+            cmakeArgs=(-DCMAKE_OSX_ARCHITECTURES=arm64 "${cmakeArgs[@]}")
         else
             echo "Error: Unknown tvOS Simulator architecture $__TargetArch."
             exit 1
         fi
     elif [[ "$targetOS" == tvos ]]; then
-        cmakeArgs="-C $__RepoRootDir/eng/native/tryrun_ios_tvos.cmake $cmakeArgs"
+        cmakeArgs=(-C "$__RepoRootDir/eng/native/tryrun_ios_tvos.cmake" "${cmakeArgs[@]}")
 
         # set default tvOS device deployment target
         # keep in sync with SetOSTargetMinVersions in the root Directory.Build.props
-        cmakeArgs="-DCMAKE_SYSTEM_NAME=tvOS -DCMAKE_OSX_SYSROOT=appletvos -DCMAKE_OSX_DEPLOYMENT_TARGET=13.0 $cmakeArgs"
+        cmakeArgs=(-DCMAKE_SYSTEM_NAME=tvOS -DCMAKE_OSX_SYSROOT=appletvos -DCMAKE_OSX_DEPLOYMENT_TARGET=13.0 "${cmakeArgs[@]}")
         if [[ "$__TargetArch" == arm64 ]]; then
-            cmakeArgs="-DCMAKE_OSX_ARCHITECTURES=\"arm64\" $cmakeArgs"
+            cmakeArgs=(-DCMAKE_OSX_ARCHITECTURES=arm64 "${cmakeArgs[@]}")
         else
             echo "Error: Unknown tvOS architecture $__TargetArch."
             exit 1
@@ -204,9 +205,8 @@ build_native()
             scan_build=scan-build
         fi
 
-        nextCommand="\"$__RepoRootDir/eng/native/gen-buildsys.sh\" \"$cmakeDir\" \"$intermediatesDir\" $hostArch $targetOS $__Compiler $__BuildType \"$generator\" $scan_build $cmakeArgs"
-        echo "Invoking $nextCommand"
-        eval $nextCommand
+        echo "Invoking \"$__RepoRootDir/eng/native/gen-buildsys.sh\" \"$cmakeDir\" \"$intermediatesDir\" $hostArch $targetOS $__Compiler $__BuildType \"$generator\" $scan_build ${cmakeArgs[*]}"
+        "$__RepoRootDir/eng/native/gen-buildsys.sh" "$cmakeDir" "$intermediatesDir" "$hostArch" "$targetOS" "$__Compiler" "$__BuildType" "$generator" $scan_build ${cmakeArgs[@]+"${cmakeArgs[@]}"}
 
         local exit_code="$?"
         if [[ "$exit_code" != 0  ]]; then
@@ -281,7 +281,8 @@ usage()
     echo "-ci: indicates if this is a CI build."
     echo "-clang: optional argument to build using clang in PATH (default)."
     echo "-clangx.y: optional argument to build using clang version x.y."
-    echo "-cmakeargs: user-settable additional arguments passed to CMake."
+    echo "-cmakeargs: one literal argument passed to CMake; may be repeated."
+    echo "--: pass all remaining arguments to CMake in the given order."
     echo "-configureonly: do not perform any builds; just configure the build."
     echo "-cross: optional argument to signify cross compilation,"
     echo "        will use ROOTFS_DIR environment variable if set."
@@ -335,6 +336,12 @@ while :; do
         break
     fi
 
+    if [[ "$1" == "--" ]]; then
+        shift
+        __CMakeArgs=(${__CMakeArgs[@]+"${__CMakeArgs[@]}"} "$@")
+        break
+    fi
+
     lowerI="$(echo "${1/--/-}" | tr "[:upper:]" "[:lower:]")"
     case "$lowerI" in
         -\?|-h|-help)
@@ -389,7 +396,7 @@ while :; do
 
         cmakeargs|-cmakeargs)
             if [[ -n "$2" ]]; then
-                __CMakeArgs="$2 $__CMakeArgs"
+                __CMakeArgs=("$2" ${__CMakeArgs[@]+"${__CMakeArgs[@]}"})
                 shift
             else
                 echo "ERROR: 'cmakeargs' requires a non-empty option argument"
@@ -416,17 +423,17 @@ while :; do
             ;;
 
         keepnativesymbols|-keepnativesymbols)
-            __CMakeArgs="$__CMakeArgs -DCLR_CMAKE_KEEP_NATIVE_SYMBOLS=true"
+            __CMakeArgs=(${__CMakeArgs[@]+"${__CMakeArgs[@]}"} -DCLR_CMAKE_KEEP_NATIVE_SYMBOLS=true)
             ;;
 
         -fsanitize)
-            __CMakeArgs="$__CMakeArgs -DCLR_CMAKE_ENABLE_SANITIZERS=$2"
+            __CMakeArgs=(${__CMakeArgs[@]+"${__CMakeArgs[@]}"} "-DCLR_CMAKE_ENABLE_SANITIZERS=$2")
             EnableNativeSanitizers=$2
             shift
             ;;
         -fsanitize=*)
             sanitizers="${lowerI/#-fsanitize=/}" # -fsanitize=address => address
-            __CMakeArgs="$__CMakeArgs -DCLR_CMAKE_ENABLE_SANITIZERS=$sanitizers"
+            __CMakeArgs=(${__CMakeArgs[@]+"${__CMakeArgs[@]}"} "-DCLR_CMAKE_ENABLE_SANITIZERS=$sanitizers")
             EnableNativeSanitizers=$sanitizers
             ;;
 
@@ -597,7 +604,7 @@ elif [[ "$__TargetOS" == android ]]; then
     # nothing to do here
     true
 else
-    __CMakeArgs="-DFEATURE_DISTRO_AGNOSTIC_SSL=$__PortableBuild $__CMakeArgs"
+    __CMakeArgs=("-DFEATURE_DISTRO_AGNOSTIC_SSL=$__PortableBuild" ${__CMakeArgs[@]+"${__CMakeArgs[@]}"})
 fi
 
 # Configure environment if we are doing a cross compile.

diff --git a/src/coreclr/build-runtime.sh b/src/coreclr/build-runtime.sh
@@ -100,7 +100,7 @@ __SourceDir="$__ProjectDir/src"
 __StaticAnalyzer=0
 __UnprocessedBuildArgs=
 __VerboseBuild=0
-__CMakeArgs=""
+__CMakeArgs=()
 __RequestedBuildComponents=""
 __SubDir=""
 
@@ -154,10 +154,10 @@ export MSBUILDDEBUGPATH
 check_prereqs
 
 # Build the coreclr (native) components.
-__CMakeArgs="-DCLR_CMAKE_PGO_INSTRUMENT=$__PgoInstrument -DCLR_CMAKE_OPTDATA_PATH=$__PgoOptDataPath -DCLR_CMAKE_PGO_OPTIMIZE=$__PgoOptimize -DCLI_CMAKE_FALLBACK_OS=\"$__HostFallbackOS\" $__CMakeArgs"
+__CMakeArgs=("-DCLR_CMAKE_PGO_INSTRUMENT=$__PgoInstrument" "-DCLR_CMAKE_OPTDATA_PATH=$__PgoOptDataPath" "-DCLR_CMAKE_PGO_OPTIMIZE=$__PgoOptimize" "-DCLI_CMAKE_FALLBACK_OS=$__HostFallbackOS" ${__CMakeArgs[@]+"${__CMakeArgs[@]}"})
 
 if [[ "$__SkipConfigure" == 0 && "$__CodeCoverage" == 1 ]]; then
-    __CMakeArgs="-DCLR_CMAKE_ENABLE_CODE_COVERAGE=1 $__CMakeArgs"
+    __CMakeArgs=(-DCLR_CMAKE_ENABLE_CODE_COVERAGE=1 ${__CMakeArgs[@]+"${__CMakeArgs[@]}"})
 fi
 
 __CMakeTarget=""
@@ -170,12 +170,12 @@ if [[ -z "$__CMakeTarget" ]]; then
 fi
 
 if [[ "$__TargetArch" != "$__HostArch" ]]; then
-    __CMakeArgs="-DCLR_CMAKE_TARGET_ARCH=$__TargetArch $__CMakeArgs"
+    __CMakeArgs=("-DCLR_CMAKE_TARGET_ARCH=$__TargetArch" ${__CMakeArgs[@]+"${__CMakeArgs[@]}"})
 fi
 
-eval "$__RepoRootDir/eng/native/version/copy_version_files.sh"
+"$__RepoRootDir/eng/native/version/copy_version_files.sh"
 
-build_native "$__HostOS" "$__HostArch" "$__ProjectRoot" "$__IntermediatesDir" "$__CMakeTarget" "$__CMakeArgs" "CoreCLR component"
+build_native "$__HostOS" "$__HostArch" "$__ProjectRoot" "$__IntermediatesDir" "$__CMakeTarget" "CoreCLR component" ${__CMakeArgs[@]+"${__CMakeArgs[@]}"}
 
 # Build complete
 

diff --git a/src/coreclr/runtime.proj b/src/coreclr/runtime.proj
@@ -22,8 +22,7 @@
           DependsOnTargets="$(BuildRuntimeDependsOnTargets)"
           BeforeTargets="Build">
     <ItemGroup>
-      <_CMakeArgs Include="$(CMakeArgs)" />
-      <_CoreClrBuildArg Include="@(_CMakeArgs->'-cmakeargs &quot;%(Identity)&quot;')" />
+      <_CoreClrBuildArg Condition="$([MSBuild]::IsOsPlatform(Windows))" Include="-cmakeargs &quot;$(CMakeArgs)&quot;" />
       <_CoreClrBuildArg Condition="'$(TargetArchitecture)' != ''" Include="-$(TargetArchitecture)" />
       <_CoreClrBuildArg Include="-$(Configuration.ToLower())" />
       <_CoreClrBuildArg Include="$(CppCompilerAndLinker)" />
@@ -53,7 +52,7 @@
       <_CoreClrBuildArg Include="-targetrid $(TargetRid)" />
       <_CoreClrBuildArg Include="-cmakeargs &quot;-DCLR_DOTNET_RID=$(PortableTargetRid)&quot;" />
       <_CoreClrBuildArg Condition="'$(BuildSubdirectory)' != ''" Include="-subdir $(BuildSubdirectory)" />
-      <_CoreClrBuildArg Include="-cmakeargs &quot;-DCLR_DOTNET_HOST_PATH='$(DOTNET_HOST_PATH)'&quot;" />
+      <_CoreClrBuildArg Include="-cmakeargs &quot;-DCLR_DOTNET_HOST_PATH=$(DOTNET_HOST_PATH)&quot;" />
       <_CoreClrBuildArg Condition="'$(HasCdacBuildTool)' == 'true'" Include="-cmakeargs &quot;-DCDAC_BUILD_TOOL_BINARY_PATH=$(RuntimeBinDir)cdac-build-tool\cdac-build-tool.dll&quot;" />
       <_CoreClrBuildArg Condition="'$(FeatureXplatEventSource)' == 'false'" Include="-cmakeargs &quot;-DFEATURE_EVENTSOURCE_XPLAT=0&quot;" />
       <_CoreClrBuildArg Condition="'$(FeatureInterpreter)' == 'true'" Include="-cmakeargs &quot;-DFEATURE_INTERPRETER=1&quot;" />
@@ -116,6 +115,7 @@
       <_CoreClrBuildScript Condition="$([MSBuild]::IsOsPlatform(Windows))">build-runtime.cmd</_CoreClrBuildScript>
       <_CoreClrBuildScript Condition="!$([MSBuild]::IsOsPlatform(Windows))">build-runtime.sh</_CoreClrBuildScript>
       <_CoreClrBuildCommand>&quot;$(MSBuildThisFileDirectory)$(_CoreClrBuildScript)&quot; @(_CoreClrBuildArg, ' ') @(NativeCMakeArg, ' ')</_CoreClrBuildCommand>
+      <_CoreClrBuildCommand Condition="!$([MSBuild]::IsOsPlatform(Windows))">$(_CoreClrBuildCommand) -- $(CMakeArgs)</_CoreClrBuildCommand>
     </PropertyGroup>
 
     <!-- Use IgnoreStandardErrorWarningFormat because Arcade sets WarnAsError and we want to avoid upgrading compiler warnings to errors in release branches -->

diff --git a/src/native/corehost/build.sh b/src/native/corehost/build.sh
@@ -14,7 +14,7 @@ __RepoRootDir="$(cd "$__scriptpath"/../../..; pwd -P)"
 __TargetArch=x64
 __TargetOS=linux
 __BuildType=Debug
-__CMakeArgs=""
+__CMakeArgs=()
 __Compiler=clang
 __CrossBuild=0
 __PortableBuild=1
@@ -59,10 +59,10 @@ __IntermediatesDir="$__RootBinDir/obj/$__TargetRid.$__BuildType"
 
 export __BinDir __IntermediatesDir __RuntimeFlavor
 
-__CMakeArgs="-DCLI_CMAKE_FALLBACK_OS=\"$__HostFallbackOS\" -DCLI_CMAKE_COMMIT_HASH=\"$__commit_hash\" $__CMakeArgs"
+__CMakeArgs=("-DCLI_CMAKE_FALLBACK_OS=$__HostFallbackOS" "-DCLI_CMAKE_COMMIT_HASH=$__commit_hash" ${__CMakeArgs[@]+"${__CMakeArgs[@]}"})
 
 if [[ "$__TargetOS" != osx ]]; then
-    __CMakeArgs="-DFEATURE_DISTRO_AGNOSTIC_SSL=$__PortableBuild $__CMakeArgs"
+    __CMakeArgs=("-DFEATURE_DISTRO_AGNOSTIC_SSL=$__PortableBuild" ${__CMakeArgs[@]+"${__CMakeArgs[@]}"})
 fi
 
 # Specify path to be set for CMAKE_INSTALL_PREFIX.
@@ -77,4 +77,4 @@ setup_dirs
 check_prereqs
 
 # Build the installer native components.
-build_native "$__TargetOS" "$__TargetArch" "$__scriptpath" "$__IntermediatesDir" "install" "$__CMakeArgs" "installer component"
+build_native "$__TargetOS" "$__TargetArch" "$__scriptpath" "$__IntermediatesDir" "install" "installer component" ${__CMakeArgs[@]+"${__CMakeArgs[@]}"}