build(posix): wire Windows SITL builds

Add MinGW-w64 toolchain support, Windows-specific POSIX target wiring, and compiler flag handling for MSVC and MinGW.

The build now copies px4-* command executables instead of relying on symlinks, places dynamic modules where tests expect them, forwards ExternalProject toolchain state, and adds a CI cross-build for px4_sitl_default.

Signed-off-by: Nuno Marques <n.marques21@hotmail.com>

.github/workflows/compile_windows.yml

@@ -0,0 +1,70 @@
+name: Windows SITL cross-build
+
+# Cross-compile px4_sitl_default for Windows x86_64 via MinGW-w64. This is
+# the regression gate for the platforms/posix Windows shim layer and
+# toolchain. The toolchain is resolved by bare name through
+# CMAKE_MODULE_PATH (extended by cmake/kconfig.cmake to include
+# platforms/posix/cmake).
+
+on:
+  push:
+    branches:
+      - 'main'
+      - 'stable'
+      - 'beta'
+      - 'release/**'
+    paths-ignore:
+      - 'docs/**'
+  pull_request:
+    branches:
+      - '**'
+    paths-ignore:
+      - 'docs/**'
+
+concurrency:
+  group: ${{ github.workflow }}-${{ github.ref }}
+  cancel-in-progress: true
+
+jobs:
+  build:
+    name: Windows SITL (MinGW)
+    runs-on: ubuntu-24.04
+    env:
+      CMAKE_ARGS: -DCMAKE_TOOLCHAIN_FILE=Toolchain-mingw-w64-x86_64
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          submodules: recursive
+          fetch-depth: 0
+
+      - name: Install MinGW-w64 + PX4 base deps
+        run: |
+          sudo apt-get update
+          # The *-posix variants of gcc/g++ ship winpthreads which PX4
+          # needs for std::thread and pthread_*.
+          sudo apt-get install -y --no-install-recommends \
+              mingw-w64 \
+              g++-mingw-w64-x86-64-posix \
+              gcc-mingw-w64-x86-64-posix \
+              cmake ninja-build ccache \
+              python3 python3-pip python3-jinja2 python3-yaml \
+              python3-toml python3-numpy python3-packaging \
+              python3-jsonschema python3-future
+
+      - name: Setup ccache
+        uses: hendrikmuhs/ccache-action@v1.2
+        with:
+          key: ccache-windows-sitl
+          max-size: 500M
+
+      - name: Cross-build px4.exe
+        run: make px4_sitl_default
+
+      - name: Upload px4.exe artifact
+        if: success()
+        uses: actions/upload-artifact@v4
+        with:
+          name: px4-sitl-windows-x86_64
+          path: build/px4_sitl_default/bin/px4.exe
+          if-no-files-found: error
+          retention-days: 14

CMakeLists.txt

@@ -173,13 +173,14 @@ set(config_module_list)
 set(config_kernel_list)
 
 # Find Python
-find_package(PythonInterp 3)
+find_package(Python3 3 COMPONENTS Interpreter)
 # We have a custom error message to tell users how to install python3.
-if(NOT PYTHONINTERP_FOUND)
+if(NOT Python3_Interpreter_FOUND)
 	message(FATAL_ERROR "Python 3 not found. Please install Python 3:\n"
 		"    Ubuntu: sudo apt install python3 python3-dev python3-pip\n"
 		"    macOS: brew install python")
 endif()
+set(PYTHON_EXECUTABLE ${Python3_EXECUTABLE})
 
 option(PYTHON_COVERAGE "Python code coverage" OFF)
 if(PYTHON_COVERAGE)
@@ -262,24 +263,45 @@ if(NOT CMAKE_BUILD_TYPE)
 	set(CMAKE_BUILD_TYPE ${PX4_BUILD_TYPE} CACHE STRING "Build type" FORCE)
 endif()
 
-if(CONFIG_BOARD_SUPPORT_FORTIFIED_TOOLCHAIN)
+if(MSVC)
-	set(PX4_DEBUG_OPT_LEVEL -Og)
+	if(CONFIG_BOARD_SUPPORT_FORTIFIED_TOOLCHAIN)
-	message(STATUS "fortified toolchain support enabled: PX4_DEBUG_OPT_LEVEL=${PX4_DEBUG_OPT_LEVEL}")
+		set(PX4_DEBUG_OPT_LEVEL /Od)
-else()
+		message(STATUS "fortified toolchain support enabled: PX4_DEBUG_OPT_LEVEL=${PX4_DEBUG_OPT_LEVEL}")
-	set(PX4_DEBUG_OPT_LEVEL -O0)
-endif()
-
-if((CMAKE_BUILD_TYPE STREQUAL "Debug") OR (CMAKE_BUILD_TYPE STREQUAL "Coverage"))
-	set(MAX_CUSTOM_OPT_LEVEL ${PX4_DEBUG_OPT_LEVEL})
-elseif(CMAKE_BUILD_TYPE MATCHES "Sanitizer")
-	set(MAX_CUSTOM_OPT_LEVEL -O1)
-elseif(CMAKE_BUILD_TYPE MATCHES "Release")
-	set(MAX_CUSTOM_OPT_LEVEL -O3)
-else()
-	if(px4_constrained_flash_build)
-		set(MAX_CUSTOM_OPT_LEVEL -Os)
 	else()
-		set(MAX_CUSTOM_OPT_LEVEL -O2)
+		set(PX4_DEBUG_OPT_LEVEL /Od)
+	endif()
+
+	if((CMAKE_BUILD_TYPE STREQUAL "Debug") OR (CMAKE_BUILD_TYPE STREQUAL "Coverage"))
+		set(MAX_CUSTOM_OPT_LEVEL ${PX4_DEBUG_OPT_LEVEL})
+	elseif(CMAKE_BUILD_TYPE MATCHES "Release")
+		set(MAX_CUSTOM_OPT_LEVEL /O2)
+	else()
+		if(px4_constrained_flash_build)
+			set(MAX_CUSTOM_OPT_LEVEL /O1)
+		else()
+			set(MAX_CUSTOM_OPT_LEVEL /O2)
+		endif()
+	endif()
+else()
+	if(CONFIG_BOARD_SUPPORT_FORTIFIED_TOOLCHAIN)
+		set(PX4_DEBUG_OPT_LEVEL -Og)
+		message(STATUS "fortified toolchain support enabled: PX4_DEBUG_OPT_LEVEL=${PX4_DEBUG_OPT_LEVEL}")
+	else()
+		set(PX4_DEBUG_OPT_LEVEL -O0)
+	endif()
+
+	if((CMAKE_BUILD_TYPE STREQUAL "Debug") OR (CMAKE_BUILD_TYPE STREQUAL "Coverage"))
+		set(MAX_CUSTOM_OPT_LEVEL ${PX4_DEBUG_OPT_LEVEL})
+	elseif(CMAKE_BUILD_TYPE MATCHES "Sanitizer")
+		set(MAX_CUSTOM_OPT_LEVEL -O1)
+	elseif(CMAKE_BUILD_TYPE MATCHES "Release")
+		set(MAX_CUSTOM_OPT_LEVEL -O3)
+	else()
+		if(px4_constrained_flash_build)
+			set(MAX_CUSTOM_OPT_LEVEL -Os)
+		else()
+			set(MAX_CUSTOM_OPT_LEVEL -O2)
+		endif()
 	endif()
 endif()
 

cmake/px4_add_common_flags.cmake

@@ -42,55 +42,75 @@
 #
 function(px4_add_common_flags)
 
-	add_compile_options(
+	if ("${CMAKE_CXX_COMPILER_ID}" STREQUAL "MSVC")
-		-g # always build debug symbols
+		add_compile_options(
-
+			/MP
-		# optimization options
+			/Zi
-		-fdata-sections
+			/EHsc
-		-ffunction-sections
+			/bigobj
-		-fomit-frame-pointer
+			/permissive-
-		-fmerge-all-constants
+			/utf-8
-
+			/FIvisibility.h
-		#-funsafe-math-optimizations # Enables -fno-signed-zeros, -fno-trapping-math, -fassociative-math and -freciprocal-math
+			/W3
-		-fno-signed-zeros	# Allow optimizations for floating-point arithmetic that ignore the signedness of zero
-		-fno-trapping-math	# Compile code assuming that floating-point operations cannot generate user-visible traps
-		#-fassociative-math	# Allow re-association of operands in series of floating-point operations
-		-freciprocal-math	# Allow the reciprocal of a value to be used instead of dividing by the value if this enables optimizations
-
-		-fno-math-errno		# Do not set errno after calling math functions that are executed with a single instruction, e.g., sqrt
-
-		-fno-strict-aliasing
-
-		# visibility
-		-fvisibility=hidden
-		-include visibility.h
-
-		# Warnings
-		-Wall
-		-Wextra
-		-Werror
-
-		-Warray-bounds
-		-Wcast-align
-		-Wdisabled-optimization
-		-Wdouble-promotion
-		-Wfatal-errors
-		-Wfloat-equal
-		-Wformat-security
-		-Winit-self
-		-Wlogical-op
-		-Wpointer-arith
-		-Wshadow
-		-Wuninitialized
-		-Wunknown-pragmas
-		-Wunused-variable
-
-		# disabled warnings
-		-Wno-missing-field-initializers
-		-Wno-missing-include-dirs # TODO: fix and enable
-		-Wno-unused-parameter
 
+			/wd4005 # macro redefinition in Windows/POSIX compatibility headers
+			/wd4068 # unknown pragma from GCC-oriented third-party code
+			/wd4244 # narrowing conversion warnings are pervasive in PX4 SITL
+			/wd4267 # size_t to int narrowing in POSIX-style APIs
+			/wd4305 # truncation from double to float constants
+			/wd4996 # POSIX/CRT compatibility names are intentional
 		)
+	else()
+		add_compile_options(
+			-g # always build debug symbols
+
+			# optimization options
+			-fdata-sections
+			-ffunction-sections
+			-fomit-frame-pointer
+			-fmerge-all-constants
+
+			#-funsafe-math-optimizations # Enables -fno-signed-zeros, -fno-trapping-math, -fassociative-math and -freciprocal-math
+			-fno-signed-zeros	# Allow optimizations for floating-point arithmetic that ignore the signedness of zero
+			-fno-trapping-math	# Compile code assuming that floating-point operations cannot generate user-visible traps
+			#-fassociative-math	# Allow re-association of operands in series of floating-point operations
+			-freciprocal-math	# Allow the reciprocal of a value to be used instead of dividing by the value if this enables optimizations
+
+			-fno-math-errno		# Do not set errno after calling math functions that are executed with a single instruction, e.g., sqrt
+
+			-fno-strict-aliasing
+
+			# visibility
+			-fvisibility=hidden
+			-include visibility.h
+
+			# Warnings
+			-Wall
+			-Wextra
+			-Werror
+
+			-Warray-bounds
+			-Wcast-align
+			-Wdisabled-optimization
+			-Wdouble-promotion
+			-Wfatal-errors
+			-Wfloat-equal
+			-Wformat-security
+			-Winit-self
+			-Wlogical-op
+			-Wpointer-arith
+			-Wshadow
+			-Wuninitialized
+			-Wunknown-pragmas
+			-Wunused-variable
+
+			# disabled warnings
+			-Wno-missing-field-initializers
+			-Wno-missing-include-dirs # TODO: fix and enable
+			-Wno-unused-parameter
+
+			)
+	endif()
 
 	# compiler specific flags
 	if (("${CMAKE_CXX_COMPILER_ID}" MATCHES "Clang") OR ("${CMAKE_CXX_COMPILER_ID}" MATCHES "AppleClang"))
@@ -136,18 +156,18 @@ function(px4_add_common_flags)
 
 	elseif ("${CMAKE_CXX_COMPILER_ID}" STREQUAL "Intel")
 		message(FATAL_ERROR "Intel compiler not yet supported")
-	elseif ("${CMAKE_CXX_COMPILER_ID}" STREQUAL "MSVC")
-		message(FATAL_ERROR "MS compiler not yet supported")
 	endif()
 
 	# C only flags
 	set(c_flags)
-	list(APPEND c_flags
+	if (NOT ("${CMAKE_CXX_COMPILER_ID}" STREQUAL "MSVC"))
-		-fno-common
+		list(APPEND c_flags
+			-fno-common
 
-		-Wnested-externs
+			-Wnested-externs
-		-Wstrict-prototypes
+			-Wstrict-prototypes
-	)
+		)
+	endif()
 	foreach(flag ${c_flags})
 		add_compile_options($<$<COMPILE_LANGUAGE:C>:${flag}>)
 	endforeach()
@@ -155,14 +175,20 @@ function(px4_add_common_flags)
 
 	# CXX only flags
 	set(cxx_flags)
-	list(APPEND cxx_flags
+	if ("${CMAKE_CXX_COMPILER_ID}" STREQUAL "MSVC")
-		-Wreorder
+		list(APPEND cxx_flags
+			/Zc:__cplusplus
+		)
+	else()
+		list(APPEND cxx_flags
+			-Wreorder
 
-		# disabled warnings
+			# disabled warnings
-		-Wno-overloaded-virtual # TODO: fix and remove
+			-Wno-overloaded-virtual # TODO: fix and remove
-	)
+		)
+	endif()
 
-	if((NOT BUILD_TESTING) AND (NOT PX4_CONFIG MATCHES "px4_sitl"))
+	if((NOT BUILD_TESTING) AND (NOT PX4_CONFIG MATCHES "px4_sitl") AND (NOT ("${CMAKE_CXX_COMPILER_ID}" STREQUAL "MSVC")))
 		list(APPEND cxx_flags
 			-fno-rtti
 		)

cmake/px4_add_module.cmake

@@ -140,7 +140,19 @@ function(px4_add_module)
 		set_target_properties(${MODULE} PROPERTIES
 			PREFIX ""
 			SUFFIX ".px4mod"
+			# Co-locate the .px4mod with CMakeLists.txt on all platforms.
+			# CMake places SHARED libraries in the project-wide
+			# LIBRARY_OUTPUT_DIRECTORY on Linux, but on Windows it treats
+			# DLLs as RUNTIME artefacts and puts them at the top of the
+			# binary tree — diverging from the ctest test discovery
+			# layout (sitl_tests.cmake runs the dyn test with
+			# WORKING_DIRECTORY=${CMAKE_CURRENT_BINARY_DIR}).
+			LIBRARY_OUTPUT_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}
+			RUNTIME_OUTPUT_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}
 			)
+		if(WIN32)
+			set_target_properties(${MODULE} PROPERTIES WINDOWS_EXPORT_ALL_SYMBOLS ON)
+		endif()
 		target_link_libraries(${MODULE} PRIVATE px4)
 		if(APPLE)
 			# Postpone resolving symbols until loading time, which is the default on most systems, but not Mac.

platforms/posix/CMakeLists.txt

@@ -26,10 +26,35 @@ add_definitions(-DPX4_SOURCE_DIR="${PX4_SOURCE_DIR}" -DPX4_BINARY_DIR="${PX4_BIN
 # PX4_INSTALL_PREFIX is set by cmake/package.cmake after this file is processed.
 # It is passed via target_compile_definitions on the px4 target from package.cmake.
 
-add_executable(px4
+if(WIN32)
+	include(cmake/windows.cmake)
+endif()
+
+set(_px4_main_sources
 	src/px4/common/main.cpp
 	apps.cpp
-	)
+)
+
+if(WIN32)
+	px4_posix_windows_append_sources(_px4_main_sources)
+else()
+	list(APPEND _px4_main_sources src/px4/common/shell_posix.cpp)
+endif()
+
+if(WIN32)
+	px4_posix_windows_configure_link_templates()
+endif()
+
+add_executable(px4 ${_px4_main_sources})
+
+set(_px4_posix_math_libraries)
+if(NOT MSVC)
+	list(APPEND _px4_posix_math_libraries m)
+endif()
+
+if(WIN32)
+	px4_posix_windows_configure_target(px4)
+endif()
 
 if (BUILD_TESTING)
 	# Build mavlink fuzz tests. These run other modules and thus cannot be a functional/unit test
@@ -44,7 +69,7 @@ if (BUILD_TESTING)
 	target_link_libraries(mavlink_fuzz_tests
 		PRIVATE
 			${module_libraries}
-			m
+			${_px4_posix_math_libraries}
 			parameters
 	)
 	target_compile_options(mavlink_fuzz_tests
@@ -65,20 +90,24 @@ endif()
 target_link_libraries(px4
 	PRIVATE
 		${module_libraries}
-		m
+		${_px4_posix_math_libraries}
 		parameters
 )
 
-if((NOT APPLE) AND (NOT ANDROID))
+if((NOT APPLE) AND (NOT ANDROID) AND (NOT WIN32))
 	target_link_libraries(px4 PRIVATE rt)
 endif()
 
-if(NOT ANDROID)
+if((NOT ANDROID) AND (NOT WIN32))
 	target_link_libraries(px4 PRIVATE pthread)
 endif()
 
 target_link_libraries(px4 PRIVATE uORB)
 
+if(WIN32)
+	px4_posix_windows_link_libraries(px4)
+endif()
+
 #=============================================================================
 # install
 #

platforms/posix/cmake/Toolchain-mingw-w64-x86_64.cmake

@@ -0,0 +1,88 @@
+############################################################################
+#
+# PX4 MinGW-w64 x86_64 cross toolchain.
+#
+# Used to cross-compile px4_sitl_default from a POSIX host to a native
+# Windows x86_64 executable via the MinGW-w64 GCC port. Pick the
+# *-posix* variant (winpthreads) so std::thread, pthread, and
+# std::mutex work.
+#
+# Usage (from PX4-Autopilot repo root):
+#   CMAKE_ARGS="-DCMAKE_TOOLCHAIN_FILE=Toolchain-mingw-w64-x86_64" \
+#       make px4_sitl_default
+#
+# The bare toolchain name is resolved through CMAKE_MODULE_PATH, which
+# cmake/kconfig.cmake extends with platforms/${PX4_PLATFORM}/cmake.
+############################################################################
+
+set(CMAKE_SYSTEM_NAME Windows)
+set(CMAKE_SYSTEM_PROCESSOR x86_64)
+
+set(TOOLCHAIN_PREFIX x86_64-w64-mingw32)
+
+find_program(MINGW_C_COMPILER NAMES ${TOOLCHAIN_PREFIX}-gcc-posix ${TOOLCHAIN_PREFIX}-gcc)
+find_program(MINGW_CXX_COMPILER NAMES ${TOOLCHAIN_PREFIX}-g++-posix ${TOOLCHAIN_PREFIX}-g++)
+find_program(MINGW_RC_COMPILER NAMES ${TOOLCHAIN_PREFIX}-windres)
+find_program(MINGW_AR          NAMES ${TOOLCHAIN_PREFIX}-ar)
+find_program(MINGW_RANLIB      NAMES ${TOOLCHAIN_PREFIX}-ranlib)
+
+if(NOT MINGW_C_COMPILER OR NOT MINGW_CXX_COMPILER)
+	message(FATAL_ERROR
+		"MinGW-w64 (${TOOLCHAIN_PREFIX}) not found. "
+		"Install with: apt-get install mingw-w64 g++-mingw-w64-x86-64-posix gcc-mingw-w64-x86-64-posix")
+endif()
+
+set(CMAKE_C_COMPILER   ${MINGW_C_COMPILER})
+set(CMAKE_CXX_COMPILER ${MINGW_CXX_COMPILER})
+set(CMAKE_RC_COMPILER  ${MINGW_RC_COMPILER})
+set(CMAKE_AR           ${MINGW_AR})
+set(CMAKE_RANLIB       ${MINGW_RANLIB})
+
+# Find headers/libs only in the target sysroot, but let us run host tools
+# (python, etc.) during the build (generators, kconfig, msg-gen).
+# PACKAGE uses BOTH so find_package() can locate packages installed by
+# nested ExternalProject builds (microcdr under the PX4 build tree) as
+# well as packages living in the MinGW sysroot.
+set(CMAKE_FIND_ROOT_PATH /usr/${TOOLCHAIN_PREFIX})
+set(CMAKE_FIND_ROOT_PATH_MODE_PROGRAM NEVER)
+set(CMAKE_FIND_ROOT_PATH_MODE_LIBRARY ONLY)
+set(CMAKE_FIND_ROOT_PATH_MODE_INCLUDE ONLY)
+set(CMAKE_FIND_ROOT_PATH_MODE_PACKAGE BOTH)
+
+# MinGW lacks many POSIX headers. Put our shim directory in the search
+# path ahead of the MinGW sysroot — do it here (rather than in the posix
+# platform layer only) so that nested ExternalProject builds
+# (Micro-XRCE-DDS-Client) using this toolchain also resolve <poll.h>,
+# <sys/statfs.h>, <netdb.h>, <net/if.h>, <time.h> _r wrappers, etc.
+get_filename_component(_px4_windows_shim_dir
+	"${CMAKE_CURRENT_LIST_DIR}/../include/windows_shim" ABSOLUTE)
+include_directories(BEFORE SYSTEM "${_px4_windows_shim_dir}")
+
+# Target Windows 10 (1803+) so AF_UNIX is available in WinSock2.
+add_compile_definitions(
+	_WIN32_WINNT=0x0A00       # Windows 10
+	WINVER=0x0A00
+	__PX4_WINDOWS             # PX4 platform selector
+	NOMINMAX                  # avoid <windows.h> min/max macros
+	WIN32_LEAN_AND_MEAN
+	_USE_MATH_DEFINES
+	__USE_MINGW_ANSI_STDIO=1  # make printf accept PRIu64 / %llu / %zu
+)
+
+# PX4 uses `#pragma pack(push, 1)` around structs with multi-bit bitfields
+# (e.g. sixteen 11-bit RC channel fields in src/lib/rc/crsf.cpp). MinGW
+# defaults to the MSVC bitfield ABI, which lays those out differently
+# from Linux GCC (each storage unit padded to the declared type's
+# alignment instead of packed bit-adjacent). Force the Itanium/SysV
+# layout so decoded wire formats match across platforms.
+add_compile_options(-mno-ms-bitfields)
+
+# Produce a statically linked .exe so the user does not need to ship
+# libgcc_s, libstdc++, and winpthread DLLs separately.
+set(CMAKE_EXE_LINKER_FLAGS_INIT    "-static -static-libgcc -static-libstdc++")
+set(CMAKE_SHARED_LINKER_FLAGS_INIT "-static-libgcc -static-libstdc++")
+
+# ctest runs the PE binary via wine through the CROSSCOMPILING_EMULATOR
+# property set on the px4 target (platforms/posix/CMakeLists.txt),
+# rather than CMAKE_CROSSCOMPILING_EMULATOR here, because the latter
+# does not reliably propagate across CMake reconfigures.

platforms/posix/cmake/px4_impl_os.cmake

@@ -210,11 +210,22 @@ function(px4_posix_generate_symlinks)
 
 		if (MAIN)
 			set(ln_name "${PREFIX}${MAIN}")
-			add_custom_command(TARGET ${TARGET}
+			if(WIN32 OR MINGW)
-				POST_BUILD
+				# Windows symlinks require admin; copy the exe instead so that
-				COMMAND ${CMAKE_COMMAND} -E create_symlink ${TARGET} ${ln_name}
+				# px4-<module>.exe can be invoked the same way as on POSIX.
-				WORKING_DIRECTORY "${CMAKE_RUNTIME_OUTPUT_DIRECTORY}"
+				add_custom_command(TARGET ${TARGET}
-			)
+					POST_BUILD
+					COMMAND ${CMAKE_COMMAND} -E copy
+						$<TARGET_FILE:${TARGET}>
+						${CMAKE_RUNTIME_OUTPUT_DIRECTORY}/${ln_name}.exe
+				)
+			else()
+				add_custom_command(TARGET ${TARGET}
+					POST_BUILD
+					COMMAND ${CMAKE_COMMAND} -E create_symlink ${TARGET} ${ln_name}
+					WORKING_DIRECTORY "${CMAKE_RUNTIME_OUTPUT_DIRECTORY}"
+				)
+			endif()
 		endif()
 	endforeach()
 endfunction()
@@ -231,16 +242,106 @@ endfunction()
 #
 function(px4_os_add_flags)
 
-	add_definitions(
+	add_definitions(-D__PX4_POSIX)
-		-D__PX4_POSIX
+
-		-Dnoreturn_function=__attribute__\(\(noreturn\)\)
+	if(MSVC)
-		)
+		add_definitions(-Dnoreturn_function=__declspec\(noreturn\))
+	else()
+		add_definitions(-Dnoreturn_function=__attribute__\(\(noreturn\)\))
+	endif()
 
 	include_directories(platforms/posix/include)
 
+	# When cross-compiling for Windows (MinGW) the shim headers have to
+	# sit *before* the MinGW sysroot in the search path so our termios.h,
+	# sys/mman.h, etc. are picked up instead of "no such file". -idirafter
+	# is not enough — sysroot headers win otherwise.
+	if(WIN32 OR MINGW)
+		include_directories(BEFORE platforms/posix/include/windows_shim)
+	endif()
+
 	if ("${PX4_BOARD}" MATCHES "sitl")
 
-		if(UNIX AND APPLE)
+		if(WIN32 OR MINGW)
+			add_definitions(
+				-D__PX4_WINDOWS
+				-D_GNU_SOURCE
+				-D_WIN32_WINNT=0x0A00
+				-DWINVER=0x0A00
+				-DNOMINMAX
+				-DWIN32_LEAN_AND_MEAN
+				-D_USE_MATH_DEFINES
+				)
+
+			if(MSVC)
+				add_definitions(
+					-D_CRT_SECURE_NO_WARNINGS
+					-D_CRT_NONSTDC_NO_DEPRECATE
+					-D_WINSOCK_DEPRECATED_NO_WARNINGS
+				)
+			else()
+				add_definitions(
+					# Strip __declspec(dllimport) from WinSock prototypes so PX4
+					# call sites resolve to the bare `bind`/`socket`/etc. symbol
+					# (a thunk emitted into the executable) rather than going
+					# through `__imp_<name>`. Required for the linker --wrap
+					# flags configured in platforms/posix/cmake/windows.cmake (which
+					# route those bare symbols through the errno-translating
+					# wrappers in src/px4/windows/posix/net/socket_wrap.cpp) to actually fire.
+					-DWINSOCK_API_LINKAGE=
+				)
+
+				# Relax a few warning classes that fire in every translation
+				# unit on MinGW and drown real diagnostics. Note: *do not* use
+				# -Wno-format here — PX4 globally enables -Wformat-security /
+				# -Wformat=1 and disabling the parent -Wformat makes those
+				# flags "ignored without -Wformat", which becomes an error
+				# under -Wfatal-errors.
+				add_compile_options(
+					-Wno-format-nonliteral
+					-Wno-format-truncation
+					-Wno-format-zero-length
+					-Wno-pedantic-ms-format
+					-Wno-cast-function-type
+					-Wno-unknown-pragmas
+					-Wno-attributes
+					-Wno-unused-variable
+					-Wno-unused-function
+					-Wno-unused-but-set-variable
+					-Wno-missing-field-initializers
+					-Wno-deprecated-declarations
+					# Even with __USE_MINGW_ANSI_STDIO=1, GCC's -Wformat still
+					# checks printf arguments against the ms_printf attribute
+					# that MinGW bakes into its stdio.h prototype. PX4 uses
+					# PRIu64/%llu/%zu heavily (via inttypes.h) — downgrade
+					# format mismatches from error to warning rather than
+					# mechanically rewriting thousands of call sites.
+					-Wno-error=format
+					-Wno-error=format-extra-args
+					# Cross-compile GCC flags uninitialized-use false positives
+					# where native GCC doesn't — downgrade, don't rewrite.
+					-Wno-error=uninitialized
+					-Wno-error=maybe-uninitialized
+					# WinSock typedefs SOCKET = unsigned long long; PX4 stores
+					# sockets in `int _fd` like everyone else. Downgrade the
+					# resulting narrowing warnings instead of rewriting every
+					# call site.
+					-Wno-error=narrowing
+					# MinGW LLP64: `unsigned long` is 32-bit but a pointer
+					# is 64-bit. A handful of PX4 call sites cast int->void*
+					# through `unsigned long`. Accept the warning rather
+					# than rewriting every cast with uintptr_t.
+					-Wno-error=int-to-pointer-cast
+					-Wno-error=pointer-to-int-cast
+					# Same LLP64 mismatch for C++'s stricter cast-from-pointer
+					# check. `(unsigned long)&p` truncates on Win64. Let the
+					# warning through without aborting the build.
+					$<$<COMPILE_LANGUAGE:CXX>:-fpermissive>
+					-Wno-error=shadow
+					)
+			endif()
+
+		elseif(UNIX AND APPLE)
 			add_definitions(-D__PX4_DARWIN)
 
 			# Silence Apple ld warning about duplicate static libs. CMake intentionally
@@ -262,7 +363,11 @@ function(px4_os_add_flags)
 
 	endif()
 
-	add_compile_options($<$<COMPILE_LANGUAGE:C>:-Wbad-function-cast>)
+	# -Wbad-function-cast is a C-only warning but it trips on the winsock
+	# socket() return type vs int on MinGW. Exclude it on Windows.
+	if(NOT (WIN32 OR MINGW))
+		add_compile_options($<$<COMPILE_LANGUAGE:C>:-Wbad-function-cast>)
+	endif()
 
 endfunction()
 

platforms/posix/cmake/sitl_tests.cmake

@@ -30,7 +30,7 @@ foreach(test_name ${tests})
 	configure_file(${PX4_SOURCE_DIR}/posix-configs/SITL/init/test/test_template.in ${PX4_SOURCE_DIR}/posix-configs/SITL/init/test/test_${test_name}_generated)
 
 	add_test(NAME ${test_name_prefix}
-		COMMAND $<TARGET_FILE:px4>
+		COMMAND px4
 			-s ${PX4_SOURCE_DIR}/posix-configs/SITL/init/test/test_${test_name}_generated
 			-t ${PX4_SOURCE_DIR}/test_data
 			${PX4_SOURCE_DIR}/ROMFS/px4fmu_test
@@ -57,7 +57,7 @@ foreach(test_name ${cmd_tests})
 	configure_file(${PX4_SOURCE_DIR}/posix-configs/SITL/init/test/test_cmd_template.in ${PX4_SOURCE_DIR}/posix-configs/SITL/init/test/test_${test_name}_generated)
 
 	add_test(NAME ${test_name_prefix}
-		COMMAND $<TARGET_FILE:px4>
+		COMMAND px4
 			-s ${PX4_SOURCE_DIR}/posix-configs/SITL/init/test/test_${test_name}_generated
 			-t ${PX4_SOURCE_DIR}/test_data
 			${PX4_SOURCE_DIR}/ROMFS/px4fmu_test
@@ -74,7 +74,7 @@ endforeach()
 
 # IMU filtering
 add_test(NAME sitl-imu_filtering
-	COMMAND $<TARGET_FILE:px4>
+	COMMAND px4
 		-s ${PX4_SOURCE_DIR}/posix-configs/SITL/init/test/test_imu_filtering
 		-t ${PX4_SOURCE_DIR}/test_data
 		${PX4_SOURCE_DIR}/ROMFS/px4fmu_test
@@ -89,7 +89,7 @@ sanitizer_fail_test_on_error(sitl-imu_filtering)
 
 # # Shutdown test
 # add_test(NAME sitl-shutdown
-# 	COMMAND $<TARGET_FILE:px4>
+# 	COMMAND px4
 # 		-s ${PX4_SOURCE_DIR}/posix-configs/SITL/init/test/test_shutdown
 # 		-t ${PX4_SOURCE_DIR}/test_data
 # 		${PX4_SOURCE_DIR}/ROMFS/px4fmu_test
@@ -104,7 +104,7 @@ sanitizer_fail_test_on_error(sitl-imu_filtering)
 
 # Dynamic module loading test
 add_test(NAME dyn
-	COMMAND $<TARGET_FILE:px4> -s "${PX4_SOURCE_DIR}/posix-configs/SITL/init/test/test_dyn_hello"
+	COMMAND px4 -s "${PX4_SOURCE_DIR}/posix-configs/SITL/init/test/test_dyn_hello"
 	WORKING_DIRECTORY ${PX4_BINARY_DIR}/src/examples/dyn_hello
 )
 set_tests_properties(dyn PROPERTIES PASS_REGULAR_EXPRESSION "1: PASSED")
@@ -122,7 +122,7 @@ foreach(cmd_name ${test_cmds})
 	configure_file(${PX4_SOURCE_DIR}/posix-configs/SITL/init/test/cmd_template.in ${PX4_SOURCE_DIR}/posix-configs/SITL/init/test/cmd_${cmd_name}_generated)
 
 	add_test(NAME posix_${cmd_name}
-		COMMAND $<TARGET_FILE:px4>
+		COMMAND px4
 			${PX4_SOURCE_DIR}/ROMFS/px4fmu_test
 			-s ${PX4_SOURCE_DIR}/posix-configs/SITL/init/test/cmd_${cmd_name}_generated
 			-t ${PX4_SOURCE_DIR}/test_data

platforms/posix/cmake/windows.cmake

@@ -0,0 +1,157 @@
+############################################################################
+#
+#   Copyright (c) 2026 PX4 Development Team. All rights reserved.
+#
+# Redistribution and use in source and binary forms, with or without
+# modification, are permitted provided that the following conditions
+# are met:
+#
+# 1. Redistributions of source code must retain the above copyright
+#    notice, this list of conditions and the following disclaimer.
+# 2. Redistributions in binary form must reproduce the above copyright
+#    notice, this list of conditions and the following disclaimer in
+#    the documentation and/or other materials provided with the
+#    distribution.
+# 3. Neither the name PX4 nor the names of its contributors may be
+#    used to endorse or promote products derived from this software
+#    without specific prior written permission.
+#
+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
+# FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
+# COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
+# INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
+# BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
+# OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
+# AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+# LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
+# ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+# POSSIBILITY OF SUCH DAMAGE.
+#
+############################################################################
+
+# Windows support here is a Win32 backend for the POSIX platform, not a
+# separate PX4 platform. Keep the backend source list and Win32 link policy
+# out of platforms/posix/CMakeLists.txt so the top-level POSIX build remains
+# about platform selection rather than Win32 implementation detail.
+
+set(PX4_POSIX_WINDOWS_ROOT "${PX4_SOURCE_DIR}/platforms/posix/src/px4/windows")
+set(PX4_POSIX_WINDOWS_PRIVATE_INCLUDE_DIR "${PX4_POSIX_WINDOWS_ROOT}/include")
+
+function(px4_posix_windows_append_sources out_var)
+	list(APPEND ${out_var}
+		${PX4_POSIX_WINDOWS_ROOT}/runtime/init.cpp
+
+		${PX4_POSIX_WINDOWS_ROOT}/posix/sys/errno_map.cpp
+		${PX4_POSIX_WINDOWS_ROOT}/posix/sys/ioctl.cpp
+		${PX4_POSIX_WINDOWS_ROOT}/posix/sys/sysconf.cpp
+		${PX4_POSIX_WINDOWS_ROOT}/posix/sys/termios.cpp
+
+		${PX4_POSIX_WINDOWS_ROOT}/posix/proc/env.cpp
+		${PX4_POSIX_WINDOWS_ROOT}/posix/proc/ids.cpp
+		${PX4_POSIX_WINDOWS_ROOT}/posix/proc/sched.cpp
+		${PX4_POSIX_WINDOWS_ROOT}/posix/proc/user.cpp
+
+		${PX4_POSIX_WINDOWS_ROOT}/posix/fs/flock.cpp
+		${PX4_POSIX_WINDOWS_ROOT}/posix/fs/mman.cpp
+
+		${PX4_POSIX_WINDOWS_ROOT}/posix/net/if_query.cpp
+		${PX4_POSIX_WINDOWS_ROOT}/posix/net/resolver.cpp
+		${PX4_POSIX_WINDOWS_ROOT}/posix/net/socket.cpp
+
+		${PX4_POSIX_WINDOWS_ROOT}/posix/lib/dlfcn.cpp
+
+		${PX4_POSIX_WINDOWS_ROOT}/shell/shell.cpp
+		${PX4_POSIX_WINDOWS_ROOT}/shell/embedded_backend_stub.cpp
+	)
+	if(MSVC)
+		list(APPEND ${out_var}
+			${PX4_POSIX_WINDOWS_ROOT}/posix/proc/pthread.cpp
+			${PX4_POSIX_WINDOWS_ROOT}/posix/sys/time.cpp
+			${PX4_POSIX_WINDOWS_ROOT}/posix/net/socket_msvc.cpp
+		)
+	else()
+		list(APPEND ${out_var}
+			${PX4_POSIX_WINDOWS_ROOT}/posix/net/socket_wrap.cpp
+		)
+	endif()
+	set(${out_var} "${${out_var}}" PARENT_SCOPE)
+endfunction()
+
+function(px4_posix_windows_configure_link_templates)
+	if(MSVC)
+		return()
+	endif()
+
+	# PX4 links many static archives with cross-archive symbol cycles
+	# (uORB <-> platform <-> modules, winsock referenced from both daemon
+	# server and uxrce_dds_client). GNU ld's default single-pass static
+	# archive resolution can leave unresolved WinSock import symbols.
+	# Wrap <LINK_LIBRARIES> in a group so ld rescans until convergence.
+	string(REPLACE "<LINK_LIBRARIES>" "-Wl,--start-group <LINK_LIBRARIES> -Wl,--end-group"
+		CMAKE_CXX_LINK_EXECUTABLE "${CMAKE_CXX_LINK_EXECUTABLE}")
+	string(REPLACE "<LINK_LIBRARIES>" "-Wl,--start-group <LINK_LIBRARIES> -Wl,--end-group"
+		CMAKE_C_LINK_EXECUTABLE "${CMAKE_C_LINK_EXECUTABLE}")
+
+	set(CMAKE_CXX_LINK_EXECUTABLE "${CMAKE_CXX_LINK_EXECUTABLE}" PARENT_SCOPE)
+	set(CMAKE_C_LINK_EXECUTABLE "${CMAKE_C_LINK_EXECUTABLE}" PARENT_SCOPE)
+endfunction()
+
+function(px4_posix_windows_configure_target target_name)
+	target_include_directories(${target_name}
+		PRIVATE
+			${PX4_POSIX_WINDOWS_PRIVATE_INCLUDE_DIR}
+	)
+
+	set_target_properties(${target_name} PROPERTIES ENABLE_EXPORTS ON)
+
+	if(MSVC)
+		set_target_properties(${target_name} PROPERTIES WINDOWS_EXPORT_ALL_SYMBOLS ON)
+		target_compile_options(${target_name} PRIVATE /bigobj)
+	else()
+		# Force an import library (`libpx4.dll.a`) to be generated alongside
+		# px4.exe so DYNAMIC `.px4mod` modules can link against it.
+		target_link_options(${target_name} PRIVATE -Wl,--export-all-symbols)
+
+		# Route bare WinSock calls through socket_wrap.cpp so WSAGetLastError()
+		# is translated into errno before PX4 logs strerror(errno).
+		target_link_options(${target_name} PRIVATE
+			-Wl,--wrap=socket
+			-Wl,--wrap=bind
+			-Wl,--wrap=listen
+			-Wl,--wrap=accept
+			-Wl,--wrap=connect
+			-Wl,--wrap=setsockopt
+			-Wl,--wrap=shutdown
+			-Wl,--wrap=recv
+			-Wl,--wrap=send
+			-Wl,--wrap=recvfrom
+			-Wl,--wrap=sendto
+			-Wl,--wrap=strerror
+		)
+	endif()
+
+	# Make ctest run `wine px4.exe ...` transparently.
+	find_program(_px4_wine NAMES wine wine64)
+	if(_px4_wine)
+		set_target_properties(${target_name} PROPERTIES CROSSCOMPILING_EMULATOR "${_px4_wine}")
+	endif()
+endfunction()
+
+function(px4_posix_windows_link_libraries target_name)
+	# Keep Win32 import libs at the end of the link line. This is ordering
+	# only: every PX4 static archive has already been scanned before these
+	# are used to resolve platform symbols.
+	target_link_libraries(${target_name}
+		PRIVATE
+			ws2_32
+			iphlpapi
+			dbghelp
+			psapi
+	)
+
+	if(NOT MSVC)
+		target_link_libraries(${target_name} PRIVATE winpthread)
+	endif()
+endfunction()

src/modules/uxrce_dds_client/CMakeLists.txt

@@ -43,7 +43,15 @@ else()
 
 	# If a toolchain file is given, explicitly define its path when building the Micro-XRCE-DDS-CLient
 	if(CMAKE_TOOLCHAIN_FILE MATCHES "cmake$")
-		set(microxrceddsclient_toolchain ${CMAKE_TOOLCHAIN_FILE})
+		# CMake accepts relative toolchain paths on the command line (resolved
+		# against the source dir) but ExternalProject runs in its own working
+		# directory, so we have to hand down an absolute path.
+		if(NOT IS_ABSOLUTE "${CMAKE_TOOLCHAIN_FILE}")
+			get_filename_component(microxrceddsclient_toolchain
+				"${CMAKE_TOOLCHAIN_FILE}" ABSOLUTE BASE_DIR "${PX4_SOURCE_DIR}")
+		else()
+			set(microxrceddsclient_toolchain ${CMAKE_TOOLCHAIN_FILE})
+		endif()
 	elseif(CMAKE_TOOLCHAIN_FILE)
 		set(microxrceddsclient_toolchain ${PX4_SOURCE_DIR}/platforms/${PX4_PLATFORM}/cmake/${CMAKE_TOOLCHAIN_FILE}.cmake)
 	endif()
@@ -75,6 +83,10 @@ else()
 			-DCMAKE_C_FLAGS:STRING=${c_flags_with_includes}
 			-DCMAKE_CXX_FLAGS:STRING=${cxx_flags_with_includes}
 			-DCMAKE_EXE_LINKER_FLAGS:STRING=${CMAKE_EXE_LINKER_FLAGS}
+			# Forward the generator + make program so nested superbuilds
+			# (microcdr, uclient) can configure themselves without a second
+			# round of auto-detection.
+			-DCMAKE_MAKE_PROGRAM:FILEPATH=${CMAKE_MAKE_PROGRAM}
 			-DUCLIENT_PIC:BOOL=OFF
 			-DUCLIENT_PROFILE_TCP:BOOL=OFF
 			-DUCLIENT_PROFILE_UDP:BOOL=ON
@@ -83,7 +95,10 @@ else()
 			-DUCLIENT_PROFILE_CUSTOM_TRANSPORT:BOOL=OFF
 			-DUCLIENT_PROFILE_MULTITHREAD:BOOL=OFF
 			-DUCLIENT_PROFILE_SHARED_MEMORY:BOOL=OFF
-			-DUCLIENT_PLATFORM_POSIX:BOOL=ON
+			# Pick the right transport platform: on Windows let the uclient
+			# CMakeLists auto-detect (UCLIENT_PLATFORM_WINDOWS) rather than
+			# forcing POSIX — its POSIX transport pulls in <poll.h>.
+			-DUCLIENT_PLATFORM_POSIX:BOOL=$<IF:$<OR:$<BOOL:${WIN32}>,$<BOOL:${MINGW}>>,OFF,ON>
 			-DUCLIENT_BUILD_MICROCDR:BOOL=ON
 			-DCMAKE_INSTALL_PREFIX:PATH=${CMAKE_CURRENT_BINARY_DIR}
 			-DCMAKE_PREFIX_PATH:PATH=${CMAKE_CURRENT_BINARY_DIR}

src/systemcmds/dyn/CMakeLists.txt

@@ -5,4 +5,9 @@ px4_add_module(
 		dyn.cpp
 	)
 
-target_link_libraries(systemcmds__dyn PUBLIC dl)
+if(NOT CMAKE_SYSTEM_NAME STREQUAL "Windows")
+	# Windows has no libdl — dlopen/dlsym are provided as inlines over
+	# LoadLibrary/GetProcAddress in the POSIX shim, so no extra link
+	# dependency is needed on that platform.
+	target_link_libraries(systemcmds__dyn PUBLIC dl)
+endif()