Implemented static linking configuration to make the DLL self-contained.

Tests should be passing on Linux and MacOS. It's hopeful this will fix the Windows issues.

Author: bnbailey-psl

.github/workflows/pytest-windows.yml

@@ -29,6 +29,8 @@ jobs:
         python -m pip install --upgrade pip
         
     - name: Build native libraries
+      env:
+        CMAKE_RC_COMPILER: ""
       run: |
         python build_scripts/build_helios.py --buildmode release --plugins visualizer,weberpenntree --verbose
         

build_scripts/build_helios.py

@@ -506,15 +506,30 @@ def run_cmake_configure(self, additional_args: Optional[List[str]] = None) -> No
             cmake_cmd.extend(additional_args)
 
         # Add PyHelios-specific options
-        cmake_cmd.extend([
-            '-DBUILD_SHARED_LIBS=ON',  # Build as shared library
-        ])
+        if self.platform_name == 'Windows':
+            # On Windows, disable shared libs for dependencies but enable for PyHelios
+            cmake_cmd.extend([
+                '-DBUILD_SHARED_LIBS=OFF',  # Static dependencies to avoid DLL hell
+                '-DCMAKE_MSVC_RUNTIME_LIBRARY=MultiThreaded',  # Static MSVC runtime
+                '-DZLIB_ROOT=',  # Use bundled zlib
+                '-DPNG_BUILD_ZLIB=ON',  # Build PNG with bundled zlib
+                '-DPNG_SHARED=OFF',  # Static libpng
+                '-DJPEG_BUILD_SHARED=OFF',  # Static libjpeg
+            ])
+        else:
+            cmake_cmd.extend([
+                '-DBUILD_SHARED_LIBS=ON',  # Build as shared library on Unix
+            ])
 
         # Windows-specific workaround for zlib resource compilation issue
         if self.platform_name == 'Windows':
             # The RC compiler fails on win32/zlib1.rc due to C syntax in included headers
             # Patch zlib CMakeLists.txt to disable the problematic shared library target
             self._patch_zlib_cmake_for_windows()
+            
+            # Disable resource compilation entirely if CMAKE_RC_COMPILER is not set
+            if not os.environ.get('CMAKE_RC_COMPILER'):
+                cmake_cmd.extend(['-DCMAKE_RC_COMPILER='])  # Empty RC compiler disables resource compilation
 
         print(f"Running CMake configure: {' '.join(cmake_cmd)}")
 
@@ -589,6 +604,67 @@ def find_built_library(self) -> Path:
 
         raise HeliosBuildError(f"Built library {lib_name} not found in build directory")
 
+    def _check_windows_dll_dependencies(self, dll_path: Path) -> Dict[str, bool]:
+        """
+        Check Windows DLL dependencies using dumpbin if available.
+        
+        Args:
+            dll_path: Path to the DLL to check
+            
+        Returns:
+            Dictionary of dependency name -> found status
+        """
+        dependencies = {}
+        
+        try:
+            # Try using dumpbin to check dependencies
+            result = subprocess.run(
+                ['dumpbin', '/dependents', str(dll_path)], 
+                capture_output=True, text=True, timeout=30
+            )
+            
+            if result.returncode == 0:
+                lines = result.stdout.split('\n')
+                in_dependencies = False
+                
+                for line in lines:
+                    line = line.strip()
+                    if 'Image has the following dependencies:' in line:
+                        in_dependencies = True
+                        continue
+                    elif in_dependencies and line:
+                        if line.endswith('.dll'):
+                            dep_name = line.lower()
+                            # Check if this is a system DLL that should be available
+                            system_dlls = {
+                                'kernel32.dll', 'user32.dll', 'gdi32.dll', 'advapi32.dll',
+                                'msvcrt.dll', 'vcruntime140.dll', 'msvcp140.dll', 'ucrtbase.dll'
+                            }
+                            
+                            if dep_name in system_dlls:
+                                dependencies[dep_name] = True  # Assume system DLLs are available
+                            else:
+                                # Check if the DLL exists in system paths
+                                try:
+                                    result_check = subprocess.run(
+                                        ['where', dep_name], capture_output=True
+                                    )
+                                    dependencies[dep_name] = result_check.returncode == 0
+                                except:
+                                    dependencies[dep_name] = False
+                        elif line.startswith('Summary'):
+                            break
+                            
+            print(f"DLL dependencies for {dll_path.name}:")
+            for dep, found in dependencies.items():
+                status = "✓" if found else "✗"
+                print(f"  {status} {dep}")
+                
+        except (subprocess.TimeoutExpired, FileNotFoundError, subprocess.CalledProcessError):
+            print(f"Could not check DLL dependencies (dumpbin not available)")
+            
+        return dependencies
+
     def _validate_library_loadable(self, library_path: Path) -> None:
         """
         Validate that the library can be loaded by ctypes.
@@ -606,7 +682,16 @@ def _validate_library_loadable(self, library_path: Path) -> None:
         try:
             import ctypes
 
+            # Check dependencies before attempting to load (Windows only)
             if self.platform_name == 'Windows':
+                print(f"Checking Windows DLL dependencies for: {library_path.name}")
+                dependencies = self._check_windows_dll_dependencies(library_path)
+                missing_deps = [dep for dep, found in dependencies.items() if not found]
+                
+                if missing_deps:
+                    print(f"WARNING: Missing dependencies detected: {missing_deps}")
+                    print("This may cause ctypes loading to fail")
+                
                 # Test Windows DLL loading
                 test_lib = ctypes.WinDLL(str(library_path))
             else:
@@ -618,22 +703,42 @@ def _validate_library_loadable(self, library_path: Path) -> None:
 
         except Exception as e:
             # FAIL-FAST: Library cannot be loaded by ctypes
-            error_msg = (
-                f"CRITICAL: Built library cannot be loaded by ctypes: {library_path}\n"
-                f"Load error: {e}\n\n"
-                f"This is a fatal build error. PyHelios requires libraries that can be loaded by ctypes.\n\n"
-                f"Possible causes:\n"
-                f"1. Static library (.a) was created instead of shared library (.dylib/.so/.dll)\n"
-                f"2. Missing dependencies or incorrect linking\n"
-                f"3. Architecture mismatch (x86 vs ARM64)\n"
-                f"4. Corrupted library file\n\n"
-                f"Solutions:\n"
-                f"1. Ensure CMake builds shared libraries: -DBUILD_SHARED_LIBS=ON\n"
-                f"2. Check that all dependencies are available\n"
-                f"3. Rebuild with correct architecture flags\n"
-                f"4. Verify library dependencies with 'otool -L' (macOS) or 'ldd' (Linux)\n\n"
-                f"This build cannot proceed with an unusable library."
-            )
+            if self.platform_name == 'Windows':
+                # Windows-specific error handling and dependency checking
+                error_msg = (
+                    f"CRITICAL: Built Windows DLL cannot be loaded by ctypes: {library_path}\n"
+                    f"Load error: {e}\n\n"
+                    f"This indicates missing DLL dependencies. Common causes:\n\n"
+                    f"1. Visual C++ Runtime Libraries missing\n"
+                    f"2. Static linking not configured properly\n"
+                    f"3. Third-party dependencies (zlib, libpng, etc.) not embedded\n"
+                    f"4. Architecture mismatch (x86 vs x64)\n\n"
+                    f"Windows-specific solutions:\n"
+                    f"1. Install Visual C++ Redistributable (vcredist)\n"
+                    f"2. Use static linking: -DCMAKE_MSVC_RUNTIME_LIBRARY=MultiThreaded\n"
+                    f"3. Ensure -DBUILD_SHARED_LIBS=OFF for dependencies\n"
+                    f"4. Check DLL dependencies with 'dumpbin /dependents {library_path.name}'\n"
+                    f"5. Verify architecture matches Python (x86 vs x64)\n\n"
+                    f"The built DLL has missing dependencies and cannot be used."
+                )
+            else:
+                # Unix error handling
+                error_msg = (
+                    f"CRITICAL: Built library cannot be loaded by ctypes: {library_path}\n"
+                    f"Load error: {e}\n\n"
+                    f"This is a fatal build error. PyHelios requires libraries that can be loaded by ctypes.\n\n"
+                    f"Possible causes:\n"
+                    f"1. Static library (.a) was created instead of shared library (.dylib/.so/.dll)\n"
+                    f"2. Missing dependencies or incorrect linking\n"
+                    f"3. Architecture mismatch (x86 vs ARM64)\n"
+                    f"4. Corrupted library file\n\n"
+                    f"Solutions:\n"
+                    f"1. Ensure CMake builds shared libraries: -DBUILD_SHARED_LIBS=ON\n"
+                    f"2. Check that all dependencies are available\n"
+                    f"3. Rebuild with correct architecture flags\n"
+                    f"4. Verify library dependencies with 'otool -L' (macOS) or 'ldd' (Linux)\n\n"
+                    f"This build cannot proceed with an unusable library."
+                )
             raise HeliosBuildError(error_msg)
 
     def copy_to_output(self, library_path: Path) -> Path:
@@ -1269,6 +1374,12 @@ def _patch_zlib_cmake_for_windows(self) -> None:
             ("    set_target_properties(zlib PROPERTIES SUFFIX \"1.dll\")", "    # set_target_properties(zlib PROPERTIES SUFFIX \"1.dll\")"),
             # Update install targets to exclude zlib shared library
             ("    install(TARGETS zlib zlibstatic", "    install(TARGETS zlibstatic"),
+            # Add static runtime linking for zlib
+            ("add_library(zlibstatic STATIC ${ZLIB_SRCS} ${ZLIB_PUBLIC_HDRS} ${ZLIB_PRIVATE_HDRS})", 
+             "add_library(zlibstatic STATIC ${ZLIB_SRCS} ${ZLIB_PUBLIC_HDRS} ${ZLIB_PRIVATE_HDRS})\n# PYHELIOS PATCH: Use static MSVC runtime\nif(MSVC)\n    set_target_properties(zlibstatic PROPERTIES MSVC_RUNTIME_LIBRARY \"MultiThreaded$<$<CONFIG:Debug>:Debug>\")\nendif()"),
+            # Disable problematic resource compilation
+            ("if(NOT MINGW)\n    set(ZLIB_DLL_SRCS\n        win32/zlib1.rc # If present will override custom build rule below.\n    )\nendif()",
+             "# PYHELIOS PATCH: Disable resource compilation to avoid RC errors\n# if(NOT MINGW)\n#     set(ZLIB_DLL_SRCS\n#         win32/zlib1.rc # If present will override custom build rule below.\n#     )\n# endif()"),
         ]
 
         for old, new in patches:

pyhelios_build/CMakeLists.txt

@@ -77,10 +77,28 @@ endif()
 if(WIN32)
     # Define DLL export macro for Windows
     target_compile_definitions(pyhelios_shared PRIVATE BUILDING_PYHELIOS_DLL)
+    
+    # Ensure static linking of Visual Studio runtime and system libraries
     set_target_properties(pyhelios_shared PROPERTIES
         LIBRARY_OUTPUT_DIRECTORY "${CMAKE_BINARY_DIR}/lib"
         RUNTIME_OUTPUT_DIRECTORY "${CMAKE_BINARY_DIR}/lib"
         OUTPUT_NAME "libhelios"
+        MSVC_RUNTIME_LIBRARY "MultiThreaded$<$<CONFIG:Debug>:Debug>"
+    )
+    
+    # Static link system libraries to avoid missing DLL dependencies
+    target_link_libraries(pyhelios_shared PRIVATE
+        kernel32 user32 gdi32 winspool shell32 ole32 oleaut32 uuid comdlg32 advapi32
+    )
+    
+    # Force static linking for all targets on Windows to avoid DLL dependencies
+    set_property(TARGET pyhelios_shared PROPERTY MSVC_RUNTIME_LIBRARY "MultiThreaded$<$<CONFIG:Debug>:Debug>")
+    
+    # Ensure all dependencies are found and linked statically
+    # This prevents "module not found" errors with missing DLLs
+    target_link_options(pyhelios_shared PRIVATE
+        "/NODEFAULTLIB:msvcrt.lib"
+        "/NODEFAULTLIB:msvcrtd.lib"
     )
 elseif(APPLE)
     set_target_properties(pyhelios_shared PROPERTIES