diff --git a/scripts/buildsystems/vcpkg.cmake b/scripts/buildsystems/vcpkg.cmake
index 94bc5d4b9de2bc..eddd25c0fa332f 100644
--- a/scripts/buildsystems/vcpkg.cmake
+++ b/scripts/buildsystems/vcpkg.cmake
@@ -591,8 +591,6 @@ endif()
 
 cmake_policy(POP)
 
-# Any policies applied to the below macros and functions appear to leak into consumers
-
 function(add_executable)
     z_vcpkg_function_arguments(ARGS)
     _add_executable(${ARGS})
@@ -889,10 +887,15 @@ if(NOT Z_VCPKG_CMAKE_IN_TRY_COMPILE)
     list(APPEND CMAKE_TRY_COMPILE_PLATFORM_VARIABLES
         VCPKG_TARGET_TRIPLET
         VCPKG_TARGET_ARCHITECTURE
-        VCPKG_APPLOCAL_DEPS
+        VCPKG_HOST_TRIPLET
+        VCPKG_INSTALLED_DIR
+        VCPKG_PREFER_SYSTEM_LIBS
+        # VCPKG_APPLOCAL_DEPS # This should be off within try_compile!
         VCPKG_CHAINLOAD_TOOLCHAIN_FILE
         Z_VCPKG_ROOT_DIR
     )
+else()
+    set(VCPKG_APPLOCAL_DEPS OFF)
 endif()
 
 if(Z_VCPKG_HAS_FATAL_ERROR)
diff --git a/scripts/test_ports/try-compile/CMakeLists.txt b/scripts/test_ports/try-compile/CMakeLists.txt
new file mode 100644
index 00000000000000..1d1d93a33ae5a7
--- /dev/null
+++ b/scripts/test_ports/try-compile/CMakeLists.txt
@@ -0,0 +1,9 @@
+cmake_minimum_required(VERSION 3.25)
+
+project(try-compile-test LANGUAGES C CXX)
+
+try_compile(result PROJECT test-try-compile SOURCE_DIR  "${CMAKE_CURRENT_SOURCE_DIR}/try")
+
+if(NOT result)
+  message(FATAL_ERROR "Compiler flags are not passed consistently to try_compile!")
+endif()
\ No newline at end of file
diff --git a/scripts/test_ports/try-compile/portfile.cmake b/scripts/test_ports/try-compile/portfile.cmake
new file mode 100644
index 00000000000000..b7c364e9abe7ac
--- /dev/null
+++ b/scripts/test_ports/try-compile/portfile.cmake
@@ -0,0 +1,9 @@
+
+string(APPEND VCPKG_C_FLAGS " -DVCPKG_LET_ME_PASS")
+string(APPEND VCPKG_CXX_FLAGS " -DVCPKG_LET_ME_PASS")
+
+vcpkg_cmake_configure(
+    SOURCE_PATH "${CMAKE_CURRENT_LIST_DIR}"
+)
+
+set(VCPKG_POLICY_EMPTY_PACKAGE enabled)
\ No newline at end of file
diff --git a/scripts/test_ports/try-compile/try/CMakeLists.txt b/scripts/test_ports/try-compile/try/CMakeLists.txt
new file mode 100644
index 00000000000000..d5f1696f35c6e3
--- /dev/null
+++ b/scripts/test_ports/try-compile/try/CMakeLists.txt
@@ -0,0 +1,6 @@
+cmake_minimum_required(VERSION 3.25)
+
+project(try-compile-project LANGUAGES C CXX)
+
+add_library(result "${CMAKE_CURRENT_SOURCE_DIR}/try-compile.c")
+
diff --git a/scripts/test_ports/try-compile/try/try-compile.c b/scripts/test_ports/try-compile/try/try-compile.c
new file mode 100644
index 00000000000000..d3d67128e86e5a
--- /dev/null
+++ b/scripts/test_ports/try-compile/try/try-compile.c
@@ -0,0 +1,5 @@
+
+
+#if !defined(VCPKG_LET_ME_PASS)
+  #error "You shall not pass without forwarding compiler flags to try_compile!"
+#endif
\ No newline at end of file
diff --git a/scripts/test_ports/try-compile/vcpkg.json b/scripts/test_ports/try-compile/vcpkg.json
new file mode 100644
index 00000000000000..8ccd705cdc0e31
--- /dev/null
+++ b/scripts/test_ports/try-compile/vcpkg.json
@@ -0,0 +1,12 @@
+{
+  "name": "try-compile",
+  "version": "1",
+  "description": "Test if try compile correctly passes on compiler flags",
+  "license": "MIT",
+  "dependencies": [
+    {
+      "name": "vcpkg-cmake",
+      "host": true
+    }
+  ]
+}
diff --git a/scripts/toolchains/android.cmake b/scripts/toolchains/android.cmake
index c8243ff1fadc6b..d675d06a73fa07 100644
--- a/scripts/toolchains/android.cmake
+++ b/scripts/toolchains/android.cmake
@@ -33,23 +33,41 @@ include("${ANDROID_NDK_HOME}/build/cmake/android.toolchain.cmake")
 
 if(NOT _VCPKG_ANDROID_TOOLCHAIN)
     set(_VCPKG_ANDROID_TOOLCHAIN 1)
-    get_property( _CMAKE_IN_TRY_COMPILE GLOBAL PROPERTY IN_TRY_COMPILE )
-    if(NOT _CMAKE_IN_TRY_COMPILE)
-        string(APPEND CMAKE_C_FLAGS " -fPIC ${VCPKG_C_FLAGS} ")
-        string(APPEND CMAKE_CXX_FLAGS " -fPIC ${VCPKG_CXX_FLAGS} ")
-        string(APPEND CMAKE_C_FLAGS_DEBUG " ${VCPKG_C_FLAGS_DEBUG} ")
-        string(APPEND CMAKE_CXX_FLAGS_DEBUG " ${VCPKG_CXX_FLAGS_DEBUG} ")
-        string(APPEND CMAKE_C_FLAGS_RELEASE " ${VCPKG_C_FLAGS_RELEASE} ")
-        string(APPEND CMAKE_CXX_FLAGS_RELEASE " ${VCPKG_CXX_FLAGS_RELEASE} ")
-
-        string(APPEND CMAKE_MODULE_LINKER_FLAGS " ${VCPKG_LINKER_FLAGS} ")
-        string(APPEND CMAKE_SHARED_LINKER_FLAGS " ${VCPKG_LINKER_FLAGS} ")
-        string(APPEND CMAKE_EXE_LINKER_FLAGS " ${VCPKG_LINKER_FLAGS} ")
-        string(APPEND CMAKE_MODULE_LINKER_FLAGS_DEBUG " ${VCPKG_LINKER_FLAGS_DEBUG} ")
-        string(APPEND CMAKE_SHARED_LINKER_FLAGS_DEBUG " ${VCPKG_LINKER_FLAGS_DEBUG} ")
-        string(APPEND CMAKE_EXE_LINKER_FLAGS_DEBUG " ${VCPKG_LINKER_FLAGS_DEBUG} ")
-        string(APPEND CMAKE_MODULE_LINKER_FLAGS_RELEASE " ${VCPKG_LINKER_FLAGS_RELEASE} ")
-        string(APPEND CMAKE_SHARED_LINKER_FLAGS_RELEASE " ${VCPKG_LINKER_FLAGS_RELEASE} ")
-        string(APPEND CMAKE_EXE_LINKER_FLAGS_RELEASE " ${VCPKG_LINKER_FLAGS_RELEASE} ")
+
+    if(POLICY CMP0056)
+        cmake_policy(SET CMP0056 NEW)
+    endif()
+    if(POLICY CMP0066)
+        cmake_policy(SET CMP0066 NEW)
+    endif()
+    if(POLICY CMP0067)
+        cmake_policy(SET CMP0067 NEW)
     endif()
+    if(POLICY CMP0137)
+        cmake_policy(SET CMP0137 NEW)
+    endif()
+    list(APPEND CMAKE_TRY_COMPILE_PLATFORM_VARIABLES
+        VCPKG_CRT_LINKAGE VCPKG_TARGET_ARCHITECTURE
+        VCPKG_C_FLAGS VCPKG_CXX_FLAGS
+        VCPKG_C_FLAGS_DEBUG VCPKG_CXX_FLAGS_DEBUG
+        VCPKG_C_FLAGS_RELEASE VCPKG_CXX_FLAGS_RELEASE
+        VCPKG_LINKER_FLAGS VCPKG_LINKER_FLAGS_RELEASE VCPKG_LINKER_FLAGS_DEBUG
+    )
+
+    string(APPEND CMAKE_C_FLAGS " -fPIC ${VCPKG_C_FLAGS} ")
+    string(APPEND CMAKE_CXX_FLAGS " -fPIC ${VCPKG_CXX_FLAGS} ")
+    string(APPEND CMAKE_C_FLAGS_DEBUG " ${VCPKG_C_FLAGS_DEBUG} ")
+    string(APPEND CMAKE_CXX_FLAGS_DEBUG " ${VCPKG_CXX_FLAGS_DEBUG} ")
+    string(APPEND CMAKE_C_FLAGS_RELEASE " ${VCPKG_C_FLAGS_RELEASE} ")
+    string(APPEND CMAKE_CXX_FLAGS_RELEASE " ${VCPKG_CXX_FLAGS_RELEASE} ")
+
+    string(APPEND CMAKE_MODULE_LINKER_FLAGS " ${VCPKG_LINKER_FLAGS} ")
+    string(APPEND CMAKE_SHARED_LINKER_FLAGS " ${VCPKG_LINKER_FLAGS} ")
+    string(APPEND CMAKE_EXE_LINKER_FLAGS " ${VCPKG_LINKER_FLAGS} ")
+    string(APPEND CMAKE_MODULE_LINKER_FLAGS_DEBUG " ${VCPKG_LINKER_FLAGS_DEBUG} ")
+    string(APPEND CMAKE_SHARED_LINKER_FLAGS_DEBUG " ${VCPKG_LINKER_FLAGS_DEBUG} ")
+    string(APPEND CMAKE_EXE_LINKER_FLAGS_DEBUG " ${VCPKG_LINKER_FLAGS_DEBUG} ")
+    string(APPEND CMAKE_MODULE_LINKER_FLAGS_RELEASE " ${VCPKG_LINKER_FLAGS_RELEASE} ")
+    string(APPEND CMAKE_SHARED_LINKER_FLAGS_RELEASE " ${VCPKG_LINKER_FLAGS_RELEASE} ")
+    string(APPEND CMAKE_EXE_LINKER_FLAGS_RELEASE " ${VCPKG_LINKER_FLAGS_RELEASE} ")
 endif()
diff --git a/scripts/toolchains/freebsd.cmake b/scripts/toolchains/freebsd.cmake
index 22cb5eefdb7409..5ae16c619841df 100644
--- a/scripts/toolchains/freebsd.cmake
+++ b/scripts/toolchains/freebsd.cmake
@@ -1,24 +1,42 @@
 if(NOT _VCPKG_FREEBSD_TOOLCHAIN)
-set(_VCPKG_FREEBSD_TOOLCHAIN 1)
-if(CMAKE_HOST_SYSTEM_NAME STREQUAL "FreeBSD")
-    set(CMAKE_CROSSCOMPILING OFF CACHE BOOL "")
-endif()
-set(CMAKE_SYSTEM_NAME FreeBSD CACHE STRING "")
+    set(_VCPKG_FREEBSD_TOOLCHAIN 1)
+    if(CMAKE_HOST_SYSTEM_NAME STREQUAL "FreeBSD")
+        set(CMAKE_CROSSCOMPILING OFF CACHE BOOL "")
+    endif()
+    set(CMAKE_SYSTEM_NAME FreeBSD CACHE STRING "")
 
-if(NOT DEFINED CMAKE_SYSTEM_PROCESSOR)
-    if(VCPKG_TARGET_ARCHITECTURE STREQUAL "x64")
-       set(CMAKE_SYSTEM_PROCESSOR x86_64 CACHE STRING "")
-    elseif(VCPKG_TARGET_ARCHITECTURE STREQUAL "x86")
-       set(CMAKE_SYSTEM_PROCESSOR x86 CACHE STRING "")
-    elseif(VCPKG_TARGET_ARCHITECTURE STREQUAL "arm64")
-       set(CMAKE_SYSTEM_PROCESSOR arm64 CACHE STRING "")
-    else()
-       set(CMAKE_SYSTEM_PROCESSOR "${CMAKE_HOST_SYSTEM_PROCESSOR}" CACHE STRING "")
+    if(NOT DEFINED CMAKE_SYSTEM_PROCESSOR)
+        if(VCPKG_TARGET_ARCHITECTURE STREQUAL "x64")
+           set(CMAKE_SYSTEM_PROCESSOR x86_64 CACHE STRING "")
+        elseif(VCPKG_TARGET_ARCHITECTURE STREQUAL "x86")
+           set(CMAKE_SYSTEM_PROCESSOR x86 CACHE STRING "")
+        elseif(VCPKG_TARGET_ARCHITECTURE STREQUAL "arm64")
+           set(CMAKE_SYSTEM_PROCESSOR arm64 CACHE STRING "")
+        else()
+           set(CMAKE_SYSTEM_PROCESSOR "${CMAKE_HOST_SYSTEM_PROCESSOR}" CACHE STRING "")
+        endif()
     endif()
-endif()
 
-get_property( _CMAKE_IN_TRY_COMPILE GLOBAL PROPERTY IN_TRY_COMPILE )
-if(NOT _CMAKE_IN_TRY_COMPILE)
+    if(POLICY CMP0056)
+        cmake_policy(SET CMP0056 NEW)
+    endif()
+    if(POLICY CMP0066)
+        cmake_policy(SET CMP0066 NEW)
+    endif()
+    if(POLICY CMP0067)
+        cmake_policy(SET CMP0067 NEW)
+    endif()
+    if(POLICY CMP0137)
+        cmake_policy(SET CMP0137 NEW)
+    endif()
+    list(APPEND CMAKE_TRY_COMPILE_PLATFORM_VARIABLES
+        VCPKG_CRT_LINKAGE VCPKG_TARGET_ARCHITECTURE
+        VCPKG_C_FLAGS VCPKG_CXX_FLAGS
+        VCPKG_C_FLAGS_DEBUG VCPKG_CXX_FLAGS_DEBUG
+        VCPKG_C_FLAGS_RELEASE VCPKG_CXX_FLAGS_RELEASE
+        VCPKG_LINKER_FLAGS VCPKG_LINKER_FLAGS_RELEASE VCPKG_LINKER_FLAGS_DEBUG
+    )
+
     string(APPEND CMAKE_C_FLAGS_INIT " -fPIC ${VCPKG_C_FLAGS} ")
     string(APPEND CMAKE_CXX_FLAGS_INIT " -fPIC ${VCPKG_CXX_FLAGS} ")
     string(APPEND CMAKE_C_FLAGS_DEBUG_INIT " ${VCPKG_C_FLAGS_DEBUG} ")
@@ -36,4 +54,3 @@ if(NOT _CMAKE_IN_TRY_COMPILE)
     string(APPEND CMAKE_SHARED_LINKER_FLAGS_RELEASE_INIT " ${VCPKG_LINKER_FLAGS_RELEASE} ")
     string(APPEND CMAKE_EXE_LINKER_FLAGS_RELEASE_INIT " ${VCPKG_LINKER_FLAGS_RELEASE} ")
 endif()
-endif()
diff --git a/scripts/toolchains/ios.cmake b/scripts/toolchains/ios.cmake
index d9c3f8a312092e..024d2428f61862 100644
--- a/scripts/toolchains/ios.cmake
+++ b/scripts/toolchains/ios.cmake
@@ -1,6 +1,26 @@
 if(NOT _VCPKG_IOS_TOOLCHAIN)
     set(_VCPKG_IOS_TOOLCHAIN 1)
 
+    if(POLICY CMP0056)
+        cmake_policy(SET CMP0056 NEW)
+    endif()
+    if(POLICY CMP0066)
+        cmake_policy(SET CMP0066 NEW)
+    endif()
+    if(POLICY CMP0067)
+        cmake_policy(SET CMP0067 NEW)
+    endif()
+    if(POLICY CMP0137)
+        cmake_policy(SET CMP0137 NEW)
+    endif()
+    list(APPEND CMAKE_TRY_COMPILE_PLATFORM_VARIABLES
+        VCPKG_CRT_LINKAGE VCPKG_TARGET_ARCHITECTURE
+        VCPKG_C_FLAGS VCPKG_CXX_FLAGS
+        VCPKG_C_FLAGS_DEBUG VCPKG_CXX_FLAGS_DEBUG
+        VCPKG_C_FLAGS_RELEASE VCPKG_CXX_FLAGS_RELEASE
+        VCPKG_LINKER_FLAGS VCPKG_LINKER_FLAGS_RELEASE VCPKG_LINKER_FLAGS_DEBUG
+    )
+
     # Set the CMAKE_SYSTEM_NAME for try_compile calls.
     set(CMAKE_SYSTEM_NAME iOS CACHE STRING "")
 
@@ -41,23 +61,20 @@ if(NOT _VCPKG_IOS_TOOLCHAIN)
         set(CMAKE_OSX_SYSROOT ${_vcpkg_ios_sysroot} CACHE STRING "iOS sysroot")
     endif()
 
-    get_property( _CMAKE_IN_TRY_COMPILE GLOBAL PROPERTY IN_TRY_COMPILE )
-    if(NOT _CMAKE_IN_TRY_COMPILE)
-        string(APPEND CMAKE_C_FLAGS_INIT " -fPIC ${VCPKG_C_FLAGS} ")
-        string(APPEND CMAKE_CXX_FLAGS_INIT " -fPIC ${VCPKG_CXX_FLAGS} ")
-        string(APPEND CMAKE_C_FLAGS_DEBUG_INIT " ${VCPKG_C_FLAGS_DEBUG} ")
-        string(APPEND CMAKE_CXX_FLAGS_DEBUG_INIT " ${VCPKG_CXX_FLAGS_DEBUG} ")
-        string(APPEND CMAKE_C_FLAGS_RELEASE_INIT " ${VCPKG_C_FLAGS_RELEASE} ")
-        string(APPEND CMAKE_CXX_FLAGS_RELEASE_INIT " ${VCPKG_CXX_FLAGS_RELEASE} ")
-
-        string(APPEND CMAKE_MODULE_LINKER_FLAGS_INIT " ${VCPKG_LINKER_FLAGS} ")
-        string(APPEND CMAKE_SHARED_LINKER_FLAGS_INIT " ${VCPKG_LINKER_FLAGS} ")
-        string(APPEND CMAKE_EXE_LINKER_FLAGS_INIT " ${VCPKG_LINKER_FLAGS} ")
-        string(APPEND CMAKE_MODULE_LINKER_FLAGS_DEBUG_INIT " ${VCPKG_LINKER_FLAGS_DEBUG} ")
-        string(APPEND CMAKE_SHARED_LINKER_FLAGS_DEBUG_INIT " ${VCPKG_LINKER_FLAGS_DEBUG} ")
-        string(APPEND CMAKE_EXE_LINKER_FLAGS_DEBUG_INIT " ${VCPKG_LINKER_FLAGS_DEBUG} ")
-        string(APPEND CMAKE_MODULE_LINKER_FLAGS_RELEASE_INIT " ${VCPKG_LINKER_FLAGS_RELEASE} ")
-        string(APPEND CMAKE_SHARED_LINKER_FLAGS_RELEASE_INIT " ${VCPKG_LINKER_FLAGS_RELEASE} ")
-        string(APPEND CMAKE_EXE_LINKER_FLAGS_RELEASE_INIT " ${VCPKG_LINKER_FLAGS_RELEASE} ")
-    endif()
+    string(APPEND CMAKE_C_FLAGS_INIT " -fPIC ${VCPKG_C_FLAGS} ")
+    string(APPEND CMAKE_CXX_FLAGS_INIT " -fPIC ${VCPKG_CXX_FLAGS} ")
+    string(APPEND CMAKE_C_FLAGS_DEBUG_INIT " ${VCPKG_C_FLAGS_DEBUG} ")
+    string(APPEND CMAKE_CXX_FLAGS_DEBUG_INIT " ${VCPKG_CXX_FLAGS_DEBUG} ")
+    string(APPEND CMAKE_C_FLAGS_RELEASE_INIT " ${VCPKG_C_FLAGS_RELEASE} ")
+    string(APPEND CMAKE_CXX_FLAGS_RELEASE_INIT " ${VCPKG_CXX_FLAGS_RELEASE} ")
+
+    string(APPEND CMAKE_MODULE_LINKER_FLAGS_INIT " ${VCPKG_LINKER_FLAGS} ")
+    string(APPEND CMAKE_SHARED_LINKER_FLAGS_INIT " ${VCPKG_LINKER_FLAGS} ")
+    string(APPEND CMAKE_EXE_LINKER_FLAGS_INIT " ${VCPKG_LINKER_FLAGS} ")
+    string(APPEND CMAKE_MODULE_LINKER_FLAGS_DEBUG_INIT " ${VCPKG_LINKER_FLAGS_DEBUG} ")
+    string(APPEND CMAKE_SHARED_LINKER_FLAGS_DEBUG_INIT " ${VCPKG_LINKER_FLAGS_DEBUG} ")
+    string(APPEND CMAKE_EXE_LINKER_FLAGS_DEBUG_INIT " ${VCPKG_LINKER_FLAGS_DEBUG} ")
+    string(APPEND CMAKE_MODULE_LINKER_FLAGS_RELEASE_INIT " ${VCPKG_LINKER_FLAGS_RELEASE} ")
+    string(APPEND CMAKE_SHARED_LINKER_FLAGS_RELEASE_INIT " ${VCPKG_LINKER_FLAGS_RELEASE} ")
+    string(APPEND CMAKE_EXE_LINKER_FLAGS_RELEASE_INIT " ${VCPKG_LINKER_FLAGS_RELEASE} ")
 endif()
diff --git a/scripts/toolchains/linux.cmake b/scripts/toolchains/linux.cmake
index 960c8a290dd77d..84608334261d55 100644
--- a/scripts/toolchains/linux.cmake
+++ b/scripts/toolchains/linux.cmake
@@ -1,56 +1,75 @@
 if(NOT _VCPKG_LINUX_TOOLCHAIN)
-set(_VCPKG_LINUX_TOOLCHAIN 1)
-if(CMAKE_HOST_SYSTEM_NAME STREQUAL "Linux")
-    set(CMAKE_CROSSCOMPILING OFF CACHE BOOL "")
-endif()
-set(CMAKE_SYSTEM_NAME Linux CACHE STRING "")
-if(VCPKG_TARGET_ARCHITECTURE STREQUAL "x64")
-   set(CMAKE_SYSTEM_PROCESSOR x86_64 CACHE STRING "")
-elseif(VCPKG_TARGET_ARCHITECTURE STREQUAL "x86")
-   set(CMAKE_SYSTEM_PROCESSOR x86 CACHE STRING "")
-   string(APPEND VCPKG_C_FLAGS " -m32")
-   string(APPEND VCPKG_CXX_FLAGS " -m32")
-   string(APPEND VCPKG_LINKER_FLAGS " -m32")
-elseif(VCPKG_TARGET_ARCHITECTURE STREQUAL "arm")
-    set(CMAKE_SYSTEM_PROCESSOR armv7l CACHE STRING "")
-    if(CMAKE_HOST_SYSTEM_NAME STREQUAL "Linux" AND NOT CMAKE_HOST_SYSTEM_PROCESSOR STREQUAL "armv7l")
+    set(_VCPKG_LINUX_TOOLCHAIN 1)
 
-        if(NOT DEFINED CMAKE_CXX_COMPILER)
-            set(CMAKE_CXX_COMPILER "arm-linux-gnueabihf-g++")
-        endif()
-        if(NOT DEFINED CMAKE_C_COMPILER)
-            set(CMAKE_C_COMPILER "arm-linux-gnueabihf-gcc")
-        endif()
-        if(NOT DEFINED CMAKE_ASM_COMPILER)
-            set(CMAKE_ASM_COMPILER "arm-linux-gnueabihf-gcc")
-        endif()
-        if(NOT DEFINED CMAKE_ASM-ATT_COMPILER)
-            set(CMAKE_ASM-ATT_COMPILER "arm-linux-gnueabihf-as")
-        endif()
-        message(STATUS "Cross compiling arm on host ${CMAKE_HOST_SYSTEM_PROCESSOR}, use cross compiler: ${CMAKE_CXX_COMPILER}/${CMAKE_C_COMPILER}")
+    if(POLICY CMP0056)
+        cmake_policy(SET CMP0056 NEW)
+    endif()
+    if(POLICY CMP0066)
+        cmake_policy(SET CMP0066 NEW)
+    endif()
+    if(POLICY CMP0067)
+        cmake_policy(SET CMP0067 NEW)
+    endif()
+    if(POLICY CMP0137)
+        cmake_policy(SET CMP0137 NEW)
     endif()
-elseif(VCPKG_TARGET_ARCHITECTURE STREQUAL "arm64")
-    set(CMAKE_SYSTEM_PROCESSOR aarch64 CACHE STRING "")
-    if(CMAKE_HOST_SYSTEM_NAME STREQUAL "Linux" AND NOT CMAKE_HOST_SYSTEM_PROCESSOR STREQUAL "aarch64")
+    list(APPEND CMAKE_TRY_COMPILE_PLATFORM_VARIABLES
+        VCPKG_CRT_LINKAGE VCPKG_TARGET_ARCHITECTURE
+        VCPKG_C_FLAGS VCPKG_CXX_FLAGS
+        VCPKG_C_FLAGS_DEBUG VCPKG_CXX_FLAGS_DEBUG
+        VCPKG_C_FLAGS_RELEASE VCPKG_CXX_FLAGS_RELEASE
+        VCPKG_LINKER_FLAGS VCPKG_LINKER_FLAGS_RELEASE VCPKG_LINKER_FLAGS_DEBUG
+    )
 
-        if(NOT DEFINED CMAKE_CXX_COMPILER)
-            set(CMAKE_CXX_COMPILER "aarch64-linux-gnu-g++")
-        endif()
-        if(NOT DEFINED CMAKE_C_COMPILER)
-            set(CMAKE_C_COMPILER "aarch64-linux-gnu-gcc")
-        endif()
-        if(NOT DEFINED CMAKE_ASM_COMPILER)
-            set(CMAKE_ASM_COMPILER "aarch64-linux-gnu-gcc")
+    if(CMAKE_HOST_SYSTEM_NAME STREQUAL "Linux")
+        set(CMAKE_CROSSCOMPILING OFF CACHE BOOL "")
+    endif()
+    set(CMAKE_SYSTEM_NAME Linux CACHE STRING "")
+    if(VCPKG_TARGET_ARCHITECTURE STREQUAL "x64")
+       set(CMAKE_SYSTEM_PROCESSOR x86_64 CACHE STRING "")
+    elseif(VCPKG_TARGET_ARCHITECTURE STREQUAL "x86")
+       set(CMAKE_SYSTEM_PROCESSOR x86 CACHE STRING "")
+       string(APPEND VCPKG_C_FLAGS " -m32")
+       string(APPEND VCPKG_CXX_FLAGS " -m32")
+       string(APPEND VCPKG_LINKER_FLAGS " -m32")
+    elseif(VCPKG_TARGET_ARCHITECTURE STREQUAL "arm")
+        set(CMAKE_SYSTEM_PROCESSOR armv7l CACHE STRING "")
+        if(CMAKE_HOST_SYSTEM_NAME STREQUAL "Linux" AND NOT CMAKE_HOST_SYSTEM_PROCESSOR STREQUAL "armv7l")
+
+            if(NOT DEFINED CMAKE_CXX_COMPILER)
+                set(CMAKE_CXX_COMPILER "arm-linux-gnueabihf-g++")
+            endif()
+            if(NOT DEFINED CMAKE_C_COMPILER)
+                set(CMAKE_C_COMPILER "arm-linux-gnueabihf-gcc")
+            endif()
+            if(NOT DEFINED CMAKE_ASM_COMPILER)
+                set(CMAKE_ASM_COMPILER "arm-linux-gnueabihf-gcc")
+            endif()
+            if(NOT DEFINED CMAKE_ASM-ATT_COMPILER)
+                set(CMAKE_ASM-ATT_COMPILER "arm-linux-gnueabihf-as")
+            endif()
+            message(STATUS "Cross compiling arm on host ${CMAKE_HOST_SYSTEM_PROCESSOR}, use cross compiler: ${CMAKE_CXX_COMPILER}/${CMAKE_C_COMPILER}")
         endif()
-        if(NOT DEFINED CMAKE_ASM-ATT_COMPILER)
-            set(CMAKE_ASM-ATT_COMPILER "aarch64-linux-gnu-as")
+    elseif(VCPKG_TARGET_ARCHITECTURE STREQUAL "arm64")
+        set(CMAKE_SYSTEM_PROCESSOR aarch64 CACHE STRING "")
+        if(CMAKE_HOST_SYSTEM_NAME STREQUAL "Linux" AND NOT CMAKE_HOST_SYSTEM_PROCESSOR STREQUAL "aarch64")
+
+            if(NOT DEFINED CMAKE_CXX_COMPILER)
+                set(CMAKE_CXX_COMPILER "aarch64-linux-gnu-g++")
+            endif()
+            if(NOT DEFINED CMAKE_C_COMPILER)
+                set(CMAKE_C_COMPILER "aarch64-linux-gnu-gcc")
+            endif()
+            if(NOT DEFINED CMAKE_ASM_COMPILER)
+                set(CMAKE_ASM_COMPILER "aarch64-linux-gnu-gcc")
+            endif()
+            if(NOT DEFINED CMAKE_ASM-ATT_COMPILER)
+                set(CMAKE_ASM-ATT_COMPILER "aarch64-linux-gnu-as")
+            endif()
+            message(STATUS "Cross compiling arm64 on host ${CMAKE_HOST_SYSTEM_PROCESSOR}, use cross compiler: ${CMAKE_CXX_COMPILER}/${CMAKE_C_COMPILER}")
         endif()
-        message(STATUS "Cross compiling arm64 on host ${CMAKE_HOST_SYSTEM_PROCESSOR}, use cross compiler: ${CMAKE_CXX_COMPILER}/${CMAKE_C_COMPILER}")
     endif()
-endif()
 
-get_property( _CMAKE_IN_TRY_COMPILE GLOBAL PROPERTY IN_TRY_COMPILE )
-if(NOT _CMAKE_IN_TRY_COMPILE)
     string(APPEND CMAKE_C_FLAGS_INIT " -fPIC ${VCPKG_C_FLAGS} ")
     string(APPEND CMAKE_CXX_FLAGS_INIT " -fPIC ${VCPKG_CXX_FLAGS} ")
     string(APPEND CMAKE_C_FLAGS_DEBUG_INIT " ${VCPKG_C_FLAGS_DEBUG} ")
@@ -74,4 +93,3 @@ if(NOT _CMAKE_IN_TRY_COMPILE)
     string(APPEND CMAKE_EXE_LINKER_FLAGS_RELEASE_INIT " ${VCPKG_LINKER_FLAGS_RELEASE} ")
     string(APPEND CMAKE_ASM_FLAGS_INIT " ${VCPKG_C_FLAGS} ")
 endif()
-endif()
diff --git a/scripts/toolchains/mingw.cmake b/scripts/toolchains/mingw.cmake
index eead4b1f04c754..c0782a1e9047ac 100644
--- a/scripts/toolchains/mingw.cmake
+++ b/scripts/toolchains/mingw.cmake
@@ -1,35 +1,54 @@
 if(NOT _VCPKG_MINGW_TOOLCHAIN)
-set(_VCPKG_MINGW_TOOLCHAIN 1)
-if(CMAKE_HOST_SYSTEM_NAME STREQUAL "Windows")
-    set(CMAKE_CROSSCOMPILING OFF CACHE BOOL "")
-endif()
+    set(_VCPKG_MINGW_TOOLCHAIN 1)
 
-# Need to override MinGW from VCPKG_CMAKE_SYSTEM_NAME
-set(CMAKE_SYSTEM_NAME Windows CACHE STRING "" FORCE)
-
-if(VCPKG_TARGET_ARCHITECTURE STREQUAL "x86")
-   set(CMAKE_SYSTEM_PROCESSOR i686 CACHE STRING "")
-elseif(VCPKG_TARGET_ARCHITECTURE STREQUAL "x64")
-   set(CMAKE_SYSTEM_PROCESSOR x86_64 CACHE STRING "")
-elseif(VCPKG_TARGET_ARCHITECTURE STREQUAL "arm")
-   set(CMAKE_SYSTEM_PROCESSOR armv7 CACHE STRING "")
-elseif(VCPKG_TARGET_ARCHITECTURE STREQUAL "arm64")
-   set(CMAKE_SYSTEM_PROCESSOR aarch64 CACHE STRING "")
-endif()
+    if(POLICY CMP0056)
+        cmake_policy(SET CMP0056 NEW)
+    endif()
+    if(POLICY CMP0066)
+        cmake_policy(SET CMP0066 NEW)
+    endif()
+    if(POLICY CMP0067)
+        cmake_policy(SET CMP0067 NEW)
+    endif()
+    if(POLICY CMP0137)
+        cmake_policy(SET CMP0137 NEW)
+    endif()
+    list(APPEND CMAKE_TRY_COMPILE_PLATFORM_VARIABLES
+        VCPKG_CRT_LINKAGE VCPKG_TARGET_ARCHITECTURE 
+        VCPKG_C_FLAGS VCPKG_CXX_FLAGS
+        VCPKG_C_FLAGS_DEBUG VCPKG_CXX_FLAGS_DEBUG
+        VCPKG_C_FLAGS_RELEASE VCPKG_CXX_FLAGS_RELEASE
+        VCPKG_LINKER_FLAGS VCPKG_LINKER_FLAGS_RELEASE VCPKG_LINKER_FLAGS_DEBUG
+    )
 
-foreach(lang C CXX)
-  set(CMAKE_${lang}_COMPILER_TARGET "${CMAKE_SYSTEM_PROCESSOR}-windows-gnu" CACHE STRING "")
-endforeach()
+    if(CMAKE_HOST_SYSTEM_NAME STREQUAL "Windows")
+        set(CMAKE_CROSSCOMPILING OFF CACHE BOOL "")
+    endif()
 
-find_program(CMAKE_C_COMPILER "${CMAKE_SYSTEM_PROCESSOR}-w64-mingw32-gcc")
-find_program(CMAKE_CXX_COMPILER "${CMAKE_SYSTEM_PROCESSOR}-w64-mingw32-g++")
-find_program(CMAKE_RC_COMPILER "${CMAKE_SYSTEM_PROCESSOR}-w64-mingw32-windres")
-if(NOT CMAKE_RC_COMPILER)
-    find_program(CMAKE_RC_COMPILER "windres")
-endif()
+    # Need to override MinGW from VCPKG_CMAKE_SYSTEM_NAME
+    set(CMAKE_SYSTEM_NAME Windows CACHE STRING "" FORCE)
+
+    if(VCPKG_TARGET_ARCHITECTURE STREQUAL "x86")
+       set(CMAKE_SYSTEM_PROCESSOR i686 CACHE STRING "")
+    elseif(VCPKG_TARGET_ARCHITECTURE STREQUAL "x64")
+       set(CMAKE_SYSTEM_PROCESSOR x86_64 CACHE STRING "")
+    elseif(VCPKG_TARGET_ARCHITECTURE STREQUAL "arm")
+       set(CMAKE_SYSTEM_PROCESSOR armv7 CACHE STRING "")
+    elseif(VCPKG_TARGET_ARCHITECTURE STREQUAL "arm64")
+       set(CMAKE_SYSTEM_PROCESSOR aarch64 CACHE STRING "")
+    endif()
+
+    foreach(lang C CXX)
+      set(CMAKE_${lang}_COMPILER_TARGET "${CMAKE_SYSTEM_PROCESSOR}-windows-gnu" CACHE STRING "")
+    endforeach()
+
+    find_program(CMAKE_C_COMPILER "${CMAKE_SYSTEM_PROCESSOR}-w64-mingw32-gcc")
+    find_program(CMAKE_CXX_COMPILER "${CMAKE_SYSTEM_PROCESSOR}-w64-mingw32-g++")
+    find_program(CMAKE_RC_COMPILER "${CMAKE_SYSTEM_PROCESSOR}-w64-mingw32-windres")
+    if(NOT CMAKE_RC_COMPILER)
+        find_program(CMAKE_RC_COMPILER "windres")
+    endif()
 
-get_property( _CMAKE_IN_TRY_COMPILE GLOBAL PROPERTY IN_TRY_COMPILE )
-if(NOT _CMAKE_IN_TRY_COMPILE)
     string(APPEND CMAKE_C_FLAGS_INIT " ${VCPKG_C_FLAGS} ")
     string(APPEND CMAKE_CXX_FLAGS_INIT " ${VCPKG_CXX_FLAGS} ")
     string(APPEND CMAKE_C_FLAGS_DEBUG_INIT " ${VCPKG_C_FLAGS_DEBUG} ")
@@ -52,4 +71,4 @@ if(NOT _CMAKE_IN_TRY_COMPILE)
     string(APPEND CMAKE_SHARED_LINKER_FLAGS_RELEASE_INIT " ${VCPKG_LINKER_FLAGS_RELEASE} ")
     string(APPEND CMAKE_EXE_LINKER_FLAGS_RELEASE_INIT " ${VCPKG_LINKER_FLAGS_RELEASE} ")
 endif()
-endif()
+
diff --git a/scripts/toolchains/openbsd.cmake b/scripts/toolchains/openbsd.cmake
index 8046628a1e59c8..f500babe9444a6 100644
--- a/scripts/toolchains/openbsd.cmake
+++ b/scripts/toolchains/openbsd.cmake
@@ -1,32 +1,50 @@
 if(NOT _VCPKG_OPENBSD_TOOLCHAIN)
-set(_VCPKG_OPENBSD_TOOLCHAIN 1)
+    set(_VCPKG_OPENBSD_TOOLCHAIN 1)
 
-if(CMAKE_HOST_SYSTEM_NAME STREQUAL "OpenBSD")
-    set(CMAKE_CROSSCOMPILING OFF CACHE BOOL "")
-endif()
-set(CMAKE_SYSTEM_NAME OpenBSD CACHE STRING "")
+    if(POLICY CMP0056)
+        cmake_policy(SET CMP0056 NEW)
+    endif()
+    if(POLICY CMP0066)
+        cmake_policy(SET CMP0066 NEW)
+    endif()
+    if(POLICY CMP0067)
+        cmake_policy(SET CMP0067 NEW)
+    endif()
+    if(POLICY CMP0137)
+        cmake_policy(SET CMP0137 NEW)
+    endif()
+    list(APPEND CMAKE_TRY_COMPILE_PLATFORM_VARIABLES
+        VCPKG_CRT_LINKAGE VCPKG_TARGET_ARCHITECTURE
+        VCPKG_C_FLAGS VCPKG_CXX_FLAGS
+        VCPKG_C_FLAGS_DEBUG VCPKG_CXX_FLAGS_DEBUG
+        VCPKG_C_FLAGS_RELEASE VCPKG_CXX_FLAGS_RELEASE
+        VCPKG_LINKER_FLAGS VCPKG_LINKER_FLAGS_RELEASE VCPKG_LINKER_FLAGS_DEBUG
+    )
 
-if(NOT DEFINED CMAKE_SYSTEM_PROCESSOR)
-    if(VCPKG_TARGET_ARCHITECTURE STREQUAL "x64")
-       set(CMAKE_SYSTEM_PROCESSOR x86_64 CACHE STRING "")
-    elseif(VCPKG_TARGET_ARCHITECTURE STREQUAL "x86")
-       set(CMAKE_SYSTEM_PROCESSOR x86 CACHE STRING "")
-    elseif(VCPKG_TARGET_ARCHITECTURE STREQUAL "arm64")
-       set(CMAKE_SYSTEM_PROCESSOR arm64 CACHE STRING "")
-    else()
-       set(CMAKE_SYSTEM_PROCESSOR "${CMAKE_HOST_SYSTEM_PROCESSOR}" CACHE STRING "")
-    endif()
-endif()
+    if(CMAKE_HOST_SYSTEM_NAME STREQUAL "OpenBSD")
+        set(CMAKE_CROSSCOMPILING OFF CACHE BOOL "")
+    endif()
+    set(CMAKE_SYSTEM_NAME OpenBSD CACHE STRING "")
 
-if(NOT DEFINED CMAKE_CXX_COMPILER)
-    set(CMAKE_CXX_COMPILER "/usr/bin/clang++")
-endif()
-if(NOT DEFINED CMAKE_C_COMPILER)
-    set(CMAKE_C_COMPILER "/usr/bin/clang")
-endif()
+    if(NOT DEFINED CMAKE_SYSTEM_PROCESSOR)
+        if(VCPKG_TARGET_ARCHITECTURE STREQUAL "x64")
+           set(CMAKE_SYSTEM_PROCESSOR x86_64 CACHE STRING "")
+        elseif(VCPKG_TARGET_ARCHITECTURE STREQUAL "x86")
+           set(CMAKE_SYSTEM_PROCESSOR x86 CACHE STRING "")
+        elseif(VCPKG_TARGET_ARCHITECTURE STREQUAL "arm64")
+           set(CMAKE_SYSTEM_PROCESSOR arm64 CACHE STRING "")
+        else()
+           set(CMAKE_SYSTEM_PROCESSOR "${CMAKE_HOST_SYSTEM_PROCESSOR}" CACHE STRING "")
+        endif()
+    endif()
+
+    if(NOT DEFINED CMAKE_CXX_COMPILER)
+        set(CMAKE_CXX_COMPILER "/usr/bin/clang++")
+    endif()
+    if(NOT DEFINED CMAKE_C_COMPILER)
+        set(CMAKE_C_COMPILER "/usr/bin/clang")
+    endif()
 
-get_property( _CMAKE_IN_TRY_COMPILE GLOBAL PROPERTY IN_TRY_COMPILE )
-if(NOT _CMAKE_IN_TRY_COMPILE)
     string(APPEND CMAKE_C_FLAGS_INIT " -fPIC ${VCPKG_C_FLAGS} ")
     string(APPEND CMAKE_CXX_FLAGS_INIT " -fPIC ${VCPKG_CXX_FLAGS} ")
     string(APPEND CMAKE_C_FLAGS_DEBUG_INIT " ${VCPKG_C_FLAGS_DEBUG} ")
@@ -43,5 +61,4 @@ if(NOT _CMAKE_IN_TRY_COMPILE)
     string(APPEND CMAKE_MODULE_LINKER_FLAGS_RELEASE_INIT " ${VCPKG_LINKER_FLAGS_RELEASE} ")
     string(APPEND CMAKE_SHARED_LINKER_FLAGS_RELEASE_INIT " ${VCPKG_LINKER_FLAGS_RELEASE} ")
     string(APPEND CMAKE_EXE_LINKER_FLAGS_RELEASE_INIT " ${VCPKG_LINKER_FLAGS_RELEASE} ")
-endif(NOT _CMAKE_IN_TRY_COMPILE)
 endif(NOT _VCPKG_OPENBSD_TOOLCHAIN)
diff --git a/scripts/toolchains/osx.cmake b/scripts/toolchains/osx.cmake
index 4066d3924ff69a..2989588b15d070 100644
--- a/scripts/toolchains/osx.cmake
+++ b/scripts/toolchains/osx.cmake
@@ -1,41 +1,59 @@
 if(NOT _VCPKG_OSX_TOOLCHAIN)
-set(_VCPKG_OSX_TOOLCHAIN 1)
+    set(_VCPKG_OSX_TOOLCHAIN 1)
 
-set(CMAKE_SYSTEM_NAME Darwin CACHE STRING "")
+    if(POLICY CMP0056)
+        cmake_policy(SET CMP0056 NEW)
+    endif()
+    if(POLICY CMP0066)
+        cmake_policy(SET CMP0066 NEW)
+    endif()
+    if(POLICY CMP0067)
+        cmake_policy(SET CMP0067 NEW)
+    endif()
+    if(POLICY CMP0137)
+        cmake_policy(SET CMP0137 NEW)
+    endif()
+    list(APPEND CMAKE_TRY_COMPILE_PLATFORM_VARIABLES
+        VCPKG_CRT_LINKAGE VCPKG_TARGET_ARCHITECTURE
+        VCPKG_C_FLAGS VCPKG_CXX_FLAGS
+        VCPKG_C_FLAGS_DEBUG VCPKG_CXX_FLAGS_DEBUG
+        VCPKG_C_FLAGS_RELEASE VCPKG_CXX_FLAGS_RELEASE
+        VCPKG_LINKER_FLAGS VCPKG_LINKER_FLAGS_RELEASE VCPKG_LINKER_FLAGS_DEBUG
+    )
 
-set(CMAKE_MACOSX_RPATH ON CACHE BOOL "")
+    set(CMAKE_SYSTEM_NAME Darwin CACHE STRING "")
 
-if(NOT DEFINED CMAKE_SYSTEM_PROCESSOR)
-    if(VCPKG_TARGET_ARCHITECTURE STREQUAL "x64")
-       set(CMAKE_SYSTEM_PROCESSOR x86_64 CACHE STRING "")
-    elseif(VCPKG_TARGET_ARCHITECTURE STREQUAL "x86")
-       set(CMAKE_SYSTEM_PROCESSOR x86 CACHE STRING "")
-    elseif(VCPKG_TARGET_ARCHITECTURE STREQUAL "arm64")
-       set(CMAKE_SYSTEM_PROCESSOR arm64 CACHE STRING "")
-    else()
-       set(CMAKE_SYSTEM_PROCESSOR "${CMAKE_HOST_SYSTEM_PROCESSOR}" CACHE STRING "")
-    endif()
-endif()
+    set(CMAKE_MACOSX_RPATH ON CACHE BOOL "")
 
-if(DEFINED VCPKG_CMAKE_SYSTEM_VERSION)
-    set(CMAKE_SYSTEM_VERSION "${VCPKG_CMAKE_SYSTEM_VERSION}" CACHE STRING "" FORCE)
-endif()
+    if(NOT DEFINED CMAKE_SYSTEM_PROCESSOR)
+        if(VCPKG_TARGET_ARCHITECTURE STREQUAL "x64")
+           set(CMAKE_SYSTEM_PROCESSOR x86_64 CACHE STRING "")
+        elseif(VCPKG_TARGET_ARCHITECTURE STREQUAL "x86")
+           set(CMAKE_SYSTEM_PROCESSOR x86 CACHE STRING "")
+        elseif(VCPKG_TARGET_ARCHITECTURE STREQUAL "arm64")
+           set(CMAKE_SYSTEM_PROCESSOR arm64 CACHE STRING "")
+        else()
+           set(CMAKE_SYSTEM_PROCESSOR "${CMAKE_HOST_SYSTEM_PROCESSOR}" CACHE STRING "")
+        endif()
+    endif()
 
-if(CMAKE_HOST_SYSTEM_NAME STREQUAL "Darwin")
-    if(CMAKE_SYSTEM_PROCESSOR STREQUAL CMAKE_HOST_SYSTEM_PROCESSOR)
-        set(CMAKE_CROSSCOMPILING OFF CACHE STRING "")
-    elseif(CMAKE_HOST_SYSTEM_PROCESSOR STREQUAL "ARM64")
-        # arm64 macOS can run x64 binaries
-        set(CMAKE_CROSSCOMPILING OFF CACHE STRING "")
+    if(DEFINED VCPKG_CMAKE_SYSTEM_VERSION)
+        set(CMAKE_SYSTEM_VERSION "${VCPKG_CMAKE_SYSTEM_VERSION}" CACHE STRING "" FORCE)
     endif()
 
-    if(NOT DEFINED CMAKE_SYSTEM_VERSION)
-        set(CMAKE_SYSTEM_VERSION "${CMAKE_HOST_SYSTEM_VERSION}" CACHE STRING "")
+    if(CMAKE_HOST_SYSTEM_NAME STREQUAL "Darwin")
+        if(CMAKE_SYSTEM_PROCESSOR STREQUAL CMAKE_HOST_SYSTEM_PROCESSOR)
+            set(CMAKE_CROSSCOMPILING OFF CACHE STRING "")
+        elseif(CMAKE_HOST_SYSTEM_PROCESSOR STREQUAL "ARM64")
+            # arm64 macOS can run x64 binaries
+            set(CMAKE_CROSSCOMPILING OFF CACHE STRING "")
+        endif()
+
+        if(NOT DEFINED CMAKE_SYSTEM_VERSION)
+            set(CMAKE_SYSTEM_VERSION "${CMAKE_HOST_SYSTEM_VERSION}" CACHE STRING "")
+        endif()
     endif()
-endif()
 
-get_property( _CMAKE_IN_TRY_COMPILE GLOBAL PROPERTY IN_TRY_COMPILE )
-if(NOT _CMAKE_IN_TRY_COMPILE)
     string(APPEND CMAKE_C_FLAGS_INIT " -fPIC ${VCPKG_C_FLAGS} ")
     string(APPEND CMAKE_CXX_FLAGS_INIT " -fPIC ${VCPKG_CXX_FLAGS} ")
     string(APPEND CMAKE_C_FLAGS_DEBUG_INIT " ${VCPKG_C_FLAGS_DEBUG} ")
@@ -53,4 +71,3 @@ if(NOT _CMAKE_IN_TRY_COMPILE)
     string(APPEND CMAKE_SHARED_LINKER_FLAGS_RELEASE_INIT " ${VCPKG_LINKER_FLAGS_RELEASE} ")
     string(APPEND CMAKE_EXE_LINKER_FLAGS_RELEASE_INIT " ${VCPKG_LINKER_FLAGS_RELEASE} ")
 endif()
-endif()
diff --git a/scripts/toolchains/uwp.cmake b/scripts/toolchains/uwp.cmake
index 9da60228764fad..7ef343d0488910 100644
--- a/scripts/toolchains/uwp.cmake
+++ b/scripts/toolchains/uwp.cmake
@@ -1,32 +1,50 @@
 if(NOT _VCPKG_WINDOWS_TOOLCHAIN)
-set(_VCPKG_WINDOWS_TOOLCHAIN 1)
-set(CMAKE_MSVC_RUNTIME_LIBRARY "MultiThreaded$<$<CONFIG:Debug>:Debug>$<$<STREQUAL:${VCPKG_CRT_LINKAGE},dynamic>:DLL>" CACHE STRING "")
-set(CMAKE_MSVC_DEBUG_INFORMATION_FORMAT "")
-
-set(CMAKE_SYSTEM_NAME WindowsStore CACHE STRING "")
-
-if(VCPKG_TARGET_ARCHITECTURE STREQUAL "x86")
-    set(CMAKE_SYSTEM_PROCESSOR x86 CACHE STRING "")
-elseif(VCPKG_TARGET_ARCHITECTURE STREQUAL "x64")
-    set(CMAKE_SYSTEM_PROCESSOR AMD64 CACHE STRING "")
-elseif(VCPKG_TARGET_ARCHITECTURE STREQUAL "arm")
-    set(CMAKE_SYSTEM_PROCESSOR ARM CACHE STRING "")
-elseif(VCPKG_TARGET_ARCHITECTURE STREQUAL "arm64")
-    set(CMAKE_SYSTEM_PROCESSOR ARM64 CACHE STRING "")
-endif()
+    set(_VCPKG_WINDOWS_TOOLCHAIN 1)
+    set(CMAKE_MSVC_RUNTIME_LIBRARY "MultiThreaded$<$<CONFIG:Debug>:Debug>$<$<STREQUAL:${VCPKG_CRT_LINKAGE},dynamic>:DLL>" CACHE STRING "")
+    set(CMAKE_MSVC_DEBUG_INFORMATION_FORMAT "")
 
-if(DEFINED VCPKG_CMAKE_SYSTEM_VERSION)
-    set(CMAKE_SYSTEM_VERSION "${VCPKG_CMAKE_SYSTEM_VERSION}" CACHE STRING "" FORCE)
-endif()
+    if(POLICY CMP0056)
+        cmake_policy(SET CMP0056 NEW)
+    endif()
+    if(POLICY CMP0066)
+        cmake_policy(SET CMP0066 NEW)
+    endif()
+    if(POLICY CMP0067)
+        cmake_policy(SET CMP0067 NEW)
+    endif()
+    if(POLICY CMP0137)
+        cmake_policy(SET CMP0137 NEW)
+    endif()
+    list(APPEND CMAKE_TRY_COMPILE_PLATFORM_VARIABLES
+        VCPKG_CRT_LINKAGE VCPKG_TARGET_ARCHITECTURE VCPKG_SET_CHARSET_FLAG
+        VCPKG_C_FLAGS VCPKG_CXX_FLAGS
+        VCPKG_C_FLAGS_DEBUG VCPKG_CXX_FLAGS_DEBUG
+        VCPKG_C_FLAGS_RELEASE VCPKG_CXX_FLAGS_RELEASE
+        VCPKG_LINKER_FLAGS VCPKG_LINKER_FLAGS_RELEASE VCPKG_LINKER_FLAGS_DEBUG
+        VCPKG_PLATFORM_TOOLSET
+    )
+
+    set(CMAKE_SYSTEM_NAME WindowsStore CACHE STRING "")
+
+    if(VCPKG_TARGET_ARCHITECTURE STREQUAL "x86")
+        set(CMAKE_SYSTEM_PROCESSOR x86 CACHE STRING "")
+    elseif(VCPKG_TARGET_ARCHITECTURE STREQUAL "x64")
+        set(CMAKE_SYSTEM_PROCESSOR AMD64 CACHE STRING "")
+    elseif(VCPKG_TARGET_ARCHITECTURE STREQUAL "arm")
+        set(CMAKE_SYSTEM_PROCESSOR ARM CACHE STRING "")
+    elseif(VCPKG_TARGET_ARCHITECTURE STREQUAL "arm64")
+        set(CMAKE_SYSTEM_PROCESSOR ARM64 CACHE STRING "")
+    endif()
 
-set(CMAKE_CROSSCOMPILING ON CACHE STRING "")
+    if(DEFINED VCPKG_CMAKE_SYSTEM_VERSION)
+        set(CMAKE_SYSTEM_VERSION "${VCPKG_CMAKE_SYSTEM_VERSION}" CACHE STRING "" FORCE)
+    endif()
 
-if(NOT DEFINED CMAKE_SYSTEM_VERSION)
-    set(CMAKE_SYSTEM_VERSION "${CMAKE_HOST_SYSTEM_VERSION}" CACHE STRING "")
-endif()
+    set(CMAKE_CROSSCOMPILING ON CACHE STRING "")
 
-get_property( _CMAKE_IN_TRY_COMPILE GLOBAL PROPERTY IN_TRY_COMPILE )
-if(NOT _CMAKE_IN_TRY_COMPILE)
+    if(NOT DEFINED CMAKE_SYSTEM_VERSION)
+        set(CMAKE_SYSTEM_VERSION "${CMAKE_HOST_SYSTEM_VERSION}" CACHE STRING "")
+    endif()
 
     if(NOT (DEFINED VCPKG_MSVC_CXX_WINRT_EXTENSIONS))
         set(VCPKG_MSVC_CXX_WINRT_EXTENSIONS ON)
@@ -43,17 +61,16 @@ if(NOT _CMAKE_IN_TRY_COMPILE)
     set(CHARSET_FLAG "/utf-8")
     if (NOT VCPKG_SET_CHARSET_FLAG OR VCPKG_PLATFORM_TOOLSET MATCHES "v120")
         # VS 2013 does not support /utf-8
-        set(CHARSET_FLAG)
+        set(CHARSET_FLAG "")
     endif()
 
     set(MP_BUILD_FLAG "")
     if(NOT (CMAKE_CXX_COMPILER MATCHES "clang-cl.exe"))
-        set(MP_BUILD_FLAG "/MP")
+        set(MP_BUILD_FLAG "/MP ")
     endif()
 
     set(_vcpkg_cpp_flags "/DWIN32 /D_WINDOWS /D_UNICODE /DUNICODE /DWINAPI_FAMILY=WINAPI_FAMILY_APP /D__WRL_NO_DEFAULT_LIB__" ) # VS adds /D "_WINDLL" for DLLs;
-    set(_vcpkg_common_flags "/nologo /Z7 ${MP_BUILD_FLAG} /GS /Gd /Gm- /W3 /WX- /Zc:wchar_t /Zc:inline /Zc:forScope /fp:precise /Oy- /EHsc")
-
+    set(_vcpkg_common_flags "/nologo /Z7 ${MP_BUILD_FLAG}/GS /Gd /Gm- /W3 /WX- /Zc:wchar_t /Zc:inline /Zc:forScope /fp:precise /Oy- /EHsc")
     #/ZW:nostdlib -> ZW is added by CMake # VS also normally adds /sdl but not cmake MSBUILD
     set(_vcpkg_winmd_flag "")
     if(VCPKG_MSVC_CXX_WINRT_EXTENSIONS)
@@ -68,6 +85,7 @@ if(NOT _CMAKE_IN_TRY_COMPILE)
     set(CMAKE_RC_FLAGS "-c65001 ${_vcpkg_cpp_flags}" CACHE STRING "")
 
     unset(CHARSET_FLAG)
+    unset(MP_BUILD_FLAG)
     unset(_vcpkg_cpp_flags)
     unset(_vcpkg_common_flags)
     unset(_vcpkg_winmd_flag)
@@ -81,15 +99,15 @@ if(NOT _CMAKE_IN_TRY_COMPILE)
     string(APPEND CMAKE_STATIC_LINKER_FLAGS_RELEASE_INIT " /nologo ") # VS adds /LTCG
 
     if(VCPKG_MSVC_CXX_WINRT_EXTENSIONS)
-        set(additional_dll_flags "/WINMD:NO")
+        set(additional_dll_flags "/WINMD:NO ")
         if(CMAKE_GENERATOR MATCHES "Ninja")
-            set(additional_exe_flags "/WINMD") # VS Generator chokes on this in the compiler detection
+            set(additional_exe_flags "/WINMD ") # VS Generator chokes on this in the compiler detection
         endif()
     endif()
-    string(APPEND CMAKE_MODULE_LINKER_FLAGS " /MANIFEST:NO /NXCOMPAT /DYNAMICBASE /DEBUG ${additional_dll_flags} /APPCONTAINER /SUBSYSTEM:CONSOLE /MANIFESTUAC:NO ${VCPKG_LINKER_FLAGS}")
-    string(APPEND CMAKE_SHARED_LINKER_FLAGS " /MANIFEST:NO /NXCOMPAT /DYNAMICBASE /DEBUG ${additional_dll_flags} /APPCONTAINER /SUBSYSTEM:CONSOLE /MANIFESTUAC:NO ${VCPKG_LINKER_FLAGS}")
+    string(APPEND CMAKE_MODULE_LINKER_FLAGS " /MANIFEST:NO /NXCOMPAT /DYNAMICBASE /DEBUG ${additional_dll_flags}/APPCONTAINER /SUBSYSTEM:CONSOLE /MANIFESTUAC:NO ${VCPKG_LINKER_FLAGS}")
+    string(APPEND CMAKE_SHARED_LINKER_FLAGS " /MANIFEST:NO /NXCOMPAT /DYNAMICBASE /DEBUG ${additional_dll_flags}/APPCONTAINER /SUBSYSTEM:CONSOLE /MANIFESTUAC:NO ${VCPKG_LINKER_FLAGS}")
     # VS adds /DEBUG:FULL /TLBID:1.    WindowsApp.lib is in CMAKE_C|CXX_STANDARD_LIBRARIES
-    string(APPEND CMAKE_EXE_LINKER_FLAGS " /MANIFEST:NO /NXCOMPAT /DYNAMICBASE /DEBUG ${additional_exe_flags} /APPCONTAINER /MANIFESTUAC:NO ${VCPKG_LINKER_FLAGS}")
+    string(APPEND CMAKE_EXE_LINKER_FLAGS " /MANIFEST:NO /NXCOMPAT /DYNAMICBASE /DEBUG ${additional_exe_flags}/APPCONTAINER /MANIFESTUAC:NO ${VCPKG_LINKER_FLAGS}")
 
     set(CMAKE_MODULE_LINKER_FLAGS_RELEASE "/DEBUG /INCREMENTAL:NO /OPT:REF /OPT:ICF ${VCPKG_LINKER_FLAGS_RELEASE}" CACHE STRING "") # VS uses /LTCG:incremental
     set(CMAKE_SHARED_LINKER_FLAGS_RELEASE "/DEBUG /INCREMENTAL:NO /OPT:REF /OPT:ICF ${VCPKG_LINKER_FLAGS_RELEASE}" CACHE STRING "") # VS uses /LTCG:incremental
@@ -99,4 +117,3 @@ if(NOT _CMAKE_IN_TRY_COMPILE)
     string(APPEND CMAKE_SHARED_LINKER_FLAGS_DEBUG_INIT " /nologo ")
     string(APPEND CMAKE_EXE_LINKER_FLAGS_DEBUG_INIT " /nologo ${VCPKG_LINKER_FLAGS} ${VCPKG_LINKER_FLAGS_DEBUG} ")
 endif()
-endif()
diff --git a/scripts/toolchains/windows.cmake b/scripts/toolchains/windows.cmake
index 559d5c55154516..7b90f2ce3e8c3c 100644
--- a/scripts/toolchains/windows.cmake
+++ b/scripts/toolchains/windows.cmake
@@ -1,42 +1,60 @@
 if(NOT _VCPKG_WINDOWS_TOOLCHAIN)
-set(_VCPKG_WINDOWS_TOOLCHAIN 1)
-set(CMAKE_MSVC_RUNTIME_LIBRARY "MultiThreaded$<$<CONFIG:Debug>:Debug>$<$<STREQUAL:${VCPKG_CRT_LINKAGE},dynamic>:DLL>" CACHE STRING "")
-set(CMAKE_MSVC_DEBUG_INFORMATION_FORMAT "")
+    set(_VCPKG_WINDOWS_TOOLCHAIN 1)
+    set(CMAKE_MSVC_RUNTIME_LIBRARY "MultiThreaded$<$<CONFIG:Debug>:Debug>$<$<STREQUAL:${VCPKG_CRT_LINKAGE},dynamic>:DLL>" CACHE STRING "")
+    set(CMAKE_MSVC_DEBUG_INFORMATION_FORMAT "")
 
-set(CMAKE_SYSTEM_NAME Windows CACHE STRING "")
-
-if(VCPKG_TARGET_ARCHITECTURE STREQUAL "x86")
-    set(CMAKE_SYSTEM_PROCESSOR x86 CACHE STRING "")
-elseif(VCPKG_TARGET_ARCHITECTURE STREQUAL "x64")
-    set(CMAKE_SYSTEM_PROCESSOR AMD64 CACHE STRING "")
-elseif(VCPKG_TARGET_ARCHITECTURE STREQUAL "arm")
-    set(CMAKE_SYSTEM_PROCESSOR ARM CACHE STRING "")
-elseif(VCPKG_TARGET_ARCHITECTURE STREQUAL "arm64")
-    set(CMAKE_SYSTEM_PROCESSOR ARM64 CACHE STRING "")
-endif()
+    if(POLICY CMP0056)
+        cmake_policy(SET CMP0056 NEW)
+    endif()
+    if(POLICY CMP0066)
+        cmake_policy(SET CMP0066 NEW)
+    endif()
+    if(POLICY CMP0067)
+        cmake_policy(SET CMP0067 NEW)
+    endif()
+    if(POLICY CMP0137)
+        cmake_policy(SET CMP0137 NEW)
+    endif()
+    list(APPEND CMAKE_TRY_COMPILE_PLATFORM_VARIABLES
+       VCPKG_CRT_LINKAGE VCPKG_TARGET_ARCHITECTURE VCPKG_SET_CHARSET_FLAG
+       VCPKG_C_FLAGS VCPKG_CXX_FLAGS
+       VCPKG_C_FLAGS_DEBUG VCPKG_CXX_FLAGS_DEBUG
+       VCPKG_C_FLAGS_RELEASE VCPKG_CXX_FLAGS_RELEASE
+       VCPKG_LINKER_FLAGS VCPKG_LINKER_FLAGS_RELEASE VCPKG_LINKER_FLAGS_DEBUG
+       VCPKG_PLATFORM_TOOLSET
+    )
 
-if(DEFINED VCPKG_CMAKE_SYSTEM_VERSION)
-    set(CMAKE_SYSTEM_VERSION "${VCPKG_CMAKE_SYSTEM_VERSION}" CACHE STRING "" FORCE)
-endif()
+    set(CMAKE_SYSTEM_NAME Windows CACHE STRING "")
 
-if(CMAKE_HOST_SYSTEM_NAME STREQUAL "Windows")
-    if(CMAKE_SYSTEM_PROCESSOR STREQUAL CMAKE_HOST_SYSTEM_PROCESSOR)
-        set(CMAKE_CROSSCOMPILING OFF CACHE STRING "")
-    elseif(CMAKE_SYSTEM_PROCESSOR STREQUAL "x86")
-        # any of the four platforms can run x86 binaries
-        set(CMAKE_CROSSCOMPILING OFF CACHE STRING "")
-    elseif(CMAKE_HOST_SYSTEM_PROCESSOR STREQUAL "ARM64")
-        # arm64 can run binaries of any of the four platforms after Windows 11
-        set(CMAKE_CROSSCOMPILING OFF CACHE STRING "")
+    if(VCPKG_TARGET_ARCHITECTURE STREQUAL "x86")
+        set(CMAKE_SYSTEM_PROCESSOR x86 CACHE STRING "")
+    elseif(VCPKG_TARGET_ARCHITECTURE STREQUAL "x64")
+        set(CMAKE_SYSTEM_PROCESSOR AMD64 CACHE STRING "")
+    elseif(VCPKG_TARGET_ARCHITECTURE STREQUAL "arm")
+        set(CMAKE_SYSTEM_PROCESSOR ARM CACHE STRING "")
+    elseif(VCPKG_TARGET_ARCHITECTURE STREQUAL "arm64")
+        set(CMAKE_SYSTEM_PROCESSOR ARM64 CACHE STRING "")
     endif()
 
-    if(NOT DEFINED CMAKE_SYSTEM_VERSION)
-        set(CMAKE_SYSTEM_VERSION "${CMAKE_HOST_SYSTEM_VERSION}" CACHE STRING "")
+    if(DEFINED VCPKG_CMAKE_SYSTEM_VERSION)
+        set(CMAKE_SYSTEM_VERSION "${VCPKG_CMAKE_SYSTEM_VERSION}" CACHE STRING "" FORCE)
     endif()
-endif()
 
-get_property( _CMAKE_IN_TRY_COMPILE GLOBAL PROPERTY IN_TRY_COMPILE )
-if(NOT _CMAKE_IN_TRY_COMPILE)
+    if(CMAKE_HOST_SYSTEM_NAME STREQUAL "Windows")
+        if(CMAKE_SYSTEM_PROCESSOR STREQUAL CMAKE_HOST_SYSTEM_PROCESSOR)
+            set(CMAKE_CROSSCOMPILING OFF CACHE STRING "")
+        elseif(CMAKE_SYSTEM_PROCESSOR STREQUAL "x86")
+            # any of the four platforms can run x86 binaries
+            set(CMAKE_CROSSCOMPILING OFF CACHE STRING "")
+        elseif(CMAKE_HOST_SYSTEM_PROCESSOR STREQUAL "ARM64")
+            # arm64 can run binaries of any of the four platforms after Windows 11
+            set(CMAKE_CROSSCOMPILING OFF CACHE STRING "")
+        endif()
+
+        if(NOT DEFINED CMAKE_SYSTEM_VERSION)
+            set(CMAKE_SYSTEM_VERSION "${CMAKE_HOST_SYSTEM_VERSION}" CACHE STRING "")
+        endif()
+    endif()
 
     if(VCPKG_CRT_LINKAGE STREQUAL "dynamic")
         set(VCPKG_CRT_LINK_FLAG_PREFIX "/MD")
@@ -49,16 +67,16 @@ if(NOT _CMAKE_IN_TRY_COMPILE)
     set(CHARSET_FLAG "/utf-8")
     if (NOT VCPKG_SET_CHARSET_FLAG OR VCPKG_PLATFORM_TOOLSET MATCHES "v120")
         # VS 2013 does not support /utf-8
-        set(CHARSET_FLAG)
+        set(CHARSET_FLAG "")
     endif()
 
     set(MP_BUILD_FLAG "")
     if(NOT (CMAKE_CXX_COMPILER MATCHES "clang-cl.exe"))
-        set(MP_BUILD_FLAG "/MP")
+        set(MP_BUILD_FLAG "/MP ")
     endif()
 
-    set(CMAKE_CXX_FLAGS " /nologo /DWIN32 /D_WINDOWS /W3 ${CHARSET_FLAG} /GR /EHsc ${MP_BUILD_FLAG} ${VCPKG_CXX_FLAGS}" CACHE STRING "")
-    set(CMAKE_C_FLAGS " /nologo /DWIN32 /D_WINDOWS /W3 ${CHARSET_FLAG} ${MP_BUILD_FLAG} ${VCPKG_C_FLAGS}" CACHE STRING "")
+    set(CMAKE_CXX_FLAGS " /nologo /DWIN32 /D_WINDOWS /W3 ${CHARSET_FLAG} /GR /EHsc ${MP_BUILD_FLAG}${VCPKG_CXX_FLAGS}" CACHE STRING "")
+    set(CMAKE_C_FLAGS " /nologo /DWIN32 /D_WINDOWS /W3 ${CHARSET_FLAG} ${MP_BUILD_FLAG}${VCPKG_C_FLAGS}" CACHE STRING "")
 
     if(VCPKG_TARGET_ARCHITECTURE STREQUAL "arm64ec")
         string(APPEND CMAKE_CXX_FLAGS " /arm64EC /D_AMD64_ /DAMD64 /D_ARM64EC_ /DARM64EC")
@@ -66,8 +84,6 @@ if(NOT _CMAKE_IN_TRY_COMPILE)
     endif()
     set(CMAKE_RC_FLAGS "-c65001 /DWIN32" CACHE STRING "")
 
-    unset(CHARSET_FLAG)
-
     set(CMAKE_CXX_FLAGS_DEBUG "/D_DEBUG ${VCPKG_CRT_LINK_FLAG_PREFIX}d /Z7 /Ob0 /Od /RTC1 ${VCPKG_CXX_FLAGS_DEBUG}" CACHE STRING "")
     set(CMAKE_C_FLAGS_DEBUG "/D_DEBUG ${VCPKG_CRT_LINK_FLAG_PREFIX}d /Z7 /Ob0 /Od /RTC1 ${VCPKG_C_FLAGS_DEBUG}" CACHE STRING "")
     set(CMAKE_CXX_FLAGS_RELEASE "${VCPKG_CRT_LINK_FLAG_PREFIX} /O2 /Oi /Gy /DNDEBUG /Z7 ${VCPKG_CXX_FLAGS_RELEASE}" CACHE STRING "")
@@ -82,5 +98,8 @@ if(NOT _CMAKE_IN_TRY_COMPILE)
     string(APPEND CMAKE_MODULE_LINKER_FLAGS_DEBUG_INIT " /nologo ${VCPKG_LINKER_FLAGS} ${VCPKG_LINKER_FLAGS_DEBUG} ")
     string(APPEND CMAKE_SHARED_LINKER_FLAGS_DEBUG_INIT " /nologo ${VCPKG_LINKER_FLAGS} ${VCPKG_LINKER_FLAGS_DEBUG} ")
     string(APPEND CMAKE_EXE_LINKER_FLAGS_DEBUG_INIT " /nologo ${VCPKG_LINKER_FLAGS} ${VCPKG_LINKER_FLAGS_DEBUG} ")
-endif()
+
+    unset(CHARSET_FLAG)
+    unset(MP_BUILD_FLAG)
+    unset(VCPKG_CRT_LINK_FLAG_PREFIX)
 endif()