[v0.1.16] 2026-03-12

- Updated helios-core to v1.3.67

## Context
- Added primitive texture management methods: `getPrimitiveTextureFile()`, `setPrimitiveTextureFile()`, `getPrimitiveTextureSize()`, `getPrimitiveTextureUV()`, `primitiveTextureHasTransparencyChannel()`, `getPrimitiveSolidFraction()`, `overridePrimitiveTextureColor()`, `usePrimitiveTextureColor()`, `isPrimitiveTextureColorOverridden()`
- Primitive getters now accept a list of UUIDs for efficient batch queries returning NumPy arrays (e.g., `getPrimitiveNormal([uuid1, uuid2])` returns an ndarray of shape (N, 3))
- Added `getAll*` convenience methods that query all primitives in the context (e.g., `getAllPrimitiveNormals()`)
- Extended `PrimitiveInfo` with `texture_file`, `texture_uv`, and `solid_fraction` fields
- Added timeseries data management: `addTimeseriesData()`, `setCurrentTimeseriesPoint()`, `queryTimeseriesData()`, `queryTimeseriesDate()`, `queryTimeseriesTime()`, `getTimeseriesLength()`, `doesTimeseriesVariableExist()`, `listTimeseriesVariables()`, `loadTabularTimeseriesData()`

## Radiation Model
- Added EXR image export methods: `writeCameraImageDataEXR()`, `writeDepthImageData()`, `writeDepthImageDataEXR()`, `writeNormDepthImage()`
- Added `getBackendName()` and `probeAnyGPUBackend()` for runtime GPU backend detection
- Updated error messages to reflect runtime backend auto-detection (OptiX 8 -> OptiX 6 -> Vulkan)

## Validation
- Added `isinstance()`-based type validation to PlantArchitecture and RadiationModel methods per argument type validation policy
- Added `validate_position_like()`, `validate_direction_like()`, and `validate_size_like()` validators for flexible parameter types

Author: bnbailey-psl

.github/workflows/build-wheels.yml

@@ -199,8 +199,8 @@ jobs:
         run: python -m cibuildwheel --output-dir wheelhouse
         timeout-minutes: 60  # Increased for LiDAR tests which are comprehensive
         env:
-          # Build for Python 3.9+ on all platforms
-          CIBW_BUILD: cp39-* cp310-* cp311-* cp312-* cp313-*
+          # Build for Python 3.10+ on all platforms
+          CIBW_BUILD: cp310-* cp311-* cp312-* cp313-* cp314-*
 
           # Fail fast on build errors instead of continuing to next Python version
           CIBW_BUILD_VERBOSITY: 1
@@ -272,7 +272,7 @@ jobs:
             yum install -y zlib-devel mesa-libGL-devel mesa-libEGL-devel libX11-devel libXrandr-devel mesa-libGLU-devel libXinerama-devel libXcursor-devel libXi-devel libXxf86vm-devel &&
             export PKG_CONFIG_PATH="/usr/lib64/pkgconfig:/usr/lib/pkgconfig:${PKG_CONFIG_PATH}" &&
             export CMAKE_PREFIX_PATH="/usr:${CMAKE_PREFIX_PATH}" &&
-            /opt/python/cp39-cp39/bin/python build_scripts/prepare_wheel.py --buildmode release --verbose --clean
+            /opt/python/cp310-cp310/bin/python build_scripts/prepare_wheel.py --buildmode release --verbose --clean
           # Per-ABI: do not rebuild; only stage/copy already built artifacts
           CIBW_BEFORE_BUILD_LINUX: >
             if [ -f /opt/rh/devtoolset-10/enable ]; then
@@ -290,7 +290,7 @@ jobs:
             export PKG_CONFIG_PATH="/usr/lib64/pkgconfig:/usr/lib/pkgconfig:${PKG_CONFIG_PATH}" &&
             export CMAKE_PREFIX_PATH="/usr:${CMAKE_PREFIX_PATH}" &&
             echo "Reusing native build; packaging only." &&
-            /opt/python/cp39-cp39/bin/python build_scripts/prepare_wheel.py --buildmode release --verbose
+            /opt/python/cp310-cp310/bin/python build_scripts/prepare_wheel.py --buildmode release --verbose
 
           # Manylinux-specific environment for zlib compatibility and OpenGL discovery
           # Use documented $PATH expansion to append devtoolset without overriding cibuildwheel's Python
@@ -701,15 +701,15 @@ jobs:
       matrix:
         include:
           - os: ubuntu-22.04
-            python-version: '3.9'
+            python-version: '3.10'
           - os: ubuntu-22.04
-            python-version: '3.13'
+            python-version: '3.14'
           - os: windows-2022
-            python-version: '3.9'
+            python-version: '3.10'
           - os: windows-2022
-            python-version: '3.13'
+            python-version: '3.14'
           - os: macos-14
-            python-version: '3.13'
+            python-version: '3.14'
 
     steps:
       - name: Checkout PyHelios for tests
@@ -1299,8 +1299,18 @@ jobs:
           merge-multiple: true
           path: wheelhouse
 
+      - name: List wheel sizes
+        run: |
+          echo "=== Wheel sizes (PyPI limit: 100MB default) ==="
+          ls -lhS wheelhouse/
+          echo ""
+          echo "=== Wheels exceeding 100MB ==="
+          find wheelhouse/ -name "*.whl" -size +100M -exec ls -lh {} \; || echo "None found"
+
       - name: Publish to PyPI
         uses: pypa/gh-action-pypi-publish@release/v1
         with:
           packages-dir: wheelhouse/
           verify-metadata: false  # Skip metadata verification due to dynamic versioning
+          skip-existing: true  # Allow re-runs without failing on already-uploaded wheels
+          verbose: true  # Show full PyPI error details on upload failure

README.md

@@ -25,6 +25,8 @@ See the Helios C++ documentation for a more in-depth description of Helios: http
 
 ### Installation
 
+**Requirements:** Python 3.10 or later (pre-built wheels available for Python 3.10–3.14)
+
 **Easy Install (Recommended):**
 ```bash
 pip install pyhelios3d
@@ -50,7 +52,7 @@ If you need to customize plugins or build from source:
 
 **Prerequisites:**
 - Visual Studio 2019+ or Build Tools for Visual Studio
-- Python 3.7+
+- Python 3.10+
 
 ```bash
 # Clone repository
@@ -68,7 +70,7 @@ pip install -e .
 
 **Prerequisites:**
 - Xcode command line tools
-- Python 3.7+
+- Python 3.10+
 
 ```bash
 # Install Xcode command line tools
@@ -91,7 +93,7 @@ pip install -e .
 **Prerequisites:**
 - Build essentials
 - CMake
-- Python 3.7+
+- Python 3.10+
 
 ```bash
 # Clone repository
@@ -121,9 +123,11 @@ PyHelios plugins have three types of GPU support:
 **CPU-Only Plugins** (no GPU needed):
 - All other plugins (PlantArchitecture, Photosynthesis, SolarPosition, etc.)
 
-**For GPU Acceleration** (optional), ensure you have:
-- Vulkan SDK installed (supports NVIDIA, AMD, Intel, Apple Silicon GPUs)
-- OR for NVIDIA-optimized path: CUDA Toolkit (version 11.8 or 12.x) + OptiX
+**For GPU Acceleration** (optional), ensure you have at least one:
+- Vulkan loader library (macOS/Linux only; no extra packages on Windows)
+- OR for NVIDIA-optimized path: CUDA 12.0+ with driver >= 560 (OptiX 8.1) or CUDA 9.0+ with driver < 560 (OptiX 6.5)
+
+The radiation plugin auto-detects the best available backend at runtime (OptiX 8 -> OptiX 6 -> Vulkan).
 
 **Verification:**
 ```bash

build_scripts/build_helios.py

@@ -780,13 +780,8 @@ def run_cmake_configure(self, additional_args: Optional[List[str]] = None) -> No
                 '-DBUILD_SHARED_LIBS=ON',  # Build as shared library on Unix
             ])
 
-        # Windows-specific workaround for zlib resource compilation issue
+        # Windows-specific: disable resource compilation if CMAKE_RC_COMPILER is not set
         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
 
@@ -1477,8 +1472,8 @@ def copy_radiation_shader_files(self) -> None:
                     "The radiation plugin requires GPU backend shader files.\n"
                     "Shader files (SPIR-V for Vulkan, PTX for OptiX) should be generated during CMake build.\n\n"
                     "To fix this issue:\n"
-                    "1. Ensure Vulkan SDK is installed (primary cross-platform backend)\n"
-                    "2. Or ensure CUDA toolkit + OptiX are installed (NVIDIA-only backend)\n"
+                    "1. Ensure Vulkan loader is installed (macOS/Linux; bundled on Windows)\n"
+                    "2. Or ensure CUDA toolkit is installed (NVIDIA GPU backend)\n"
                     "3. Check CMake configuration enables at least one GPU backend\n"
                     "4. Run build with --clean to rebuild from scratch\n\n"
                     f"Expected shader directory: {shader_source_dir}\n"
@@ -1572,70 +1567,6 @@ def build(self, cmake_args: Optional[List[str]] = None) -> Path:
         print(f"Built with plugins: {final_plugins}")
         return output_library
 
-    def _patch_zlib_cmake_for_windows(self) -> None:
-        """
-        Patch zlib's CMakeLists.txt on Windows to disable the shared library target
-        that causes resource compilation errors with win32/zlib1.rc.
-        """
-        zlib_cmake_path = self.helios_root / "core" / "lib" / "zlib" / "CMakeLists.txt"
-        
-        if not zlib_cmake_path.exists():
-            print("Warning: zlib CMakeLists.txt not found, skipping patch")
-            return
-            
-        print("Patching zlib CMakeLists.txt to disable shared library on Windows...")
-        
-        try:
-            # Read the original file
-            with open(zlib_cmake_path, 'r') as f:
-                content = f.read()
-            
-            # Check if already patched (to avoid double-patching)
-            if "# PYHELIOS PATCH: Disabled shared library" in content:
-                print("zlib CMakeLists.txt already patched")
-                return
-        except Exception as e:
-            print(f"Warning: Failed to read zlib CMakeLists.txt: {e}")
-            return
-            
-        # Patch: comment out the shared library creation and related lines
-        patches = [
-            # Comment out the shared library creation
-            ("add_library(zlib SHARED", "# PYHELIOS PATCH: Disabled shared library\n# add_library(zlib SHARED"),
-            # Comment out the include directories for shared lib
-            ("target_include_directories(zlib PUBLIC", "# target_include_directories(zlib PUBLIC"),
-            # Comment out all properties for shared lib
-            ("set_target_properties(zlib PROPERTIES DEFINE_SYMBOL ZLIB_DLL)", "# set_target_properties(zlib PROPERTIES DEFINE_SYMBOL ZLIB_DLL)"),
-            ("set_target_properties(zlib PROPERTIES SOVERSION 1)", "# set_target_properties(zlib PROPERTIES SOVERSION 1)"),
-            ("    set_target_properties(zlib PROPERTIES VERSION ${ZLIB_FULL_VERSION})", "    # set_target_properties(zlib PROPERTIES VERSION ${ZLIB_FULL_VERSION})"),
-            ("   set_target_properties(zlib zlibstatic PROPERTIES OUTPUT_NAME z)", "   set_target_properties(zlibstatic PROPERTIES OUTPUT_NAME z)"),
-            ("     set_target_properties(zlib PROPERTIES LINK_FLAGS", "     # set_target_properties(zlib PROPERTIES LINK_FLAGS"),
-            ("    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:
-            if old in content:
-                content = content.replace(old, new)
-                print(f"  Patched: {old[:50]}...")
-        
-        # Write the patched file back
-        try:
-            with open(zlib_cmake_path, 'w') as f:
-                f.write(content)
-            print("zlib CMakeLists.txt patched successfully")
-        except Exception as e:
-            print(f"Warning: Failed to write patched zlib CMakeLists.txt: {e}")
-            raise HeliosBuildError(f"Could not patch zlib CMakeLists.txt: {e}")
-
-
 def get_default_plugins() -> List[str]:
     """
     Get the default set of plugins (only the currently integrated plugins).

docs/CHANGELOG.md

@@ -1,5 +1,25 @@
 # Changelog
 
+# [v0.1.16] 2026-03-12
+
+- Updated helios-core to v1.3.67
+
+## Context
+- Added primitive texture management methods: `getPrimitiveTextureFile()`, `setPrimitiveTextureFile()`, `getPrimitiveTextureSize()`, `getPrimitiveTextureUV()`, `primitiveTextureHasTransparencyChannel()`, `getPrimitiveSolidFraction()`, `overridePrimitiveTextureColor()`, `usePrimitiveTextureColor()`, `isPrimitiveTextureColorOverridden()`
+- Primitive getters now accept a list of UUIDs for efficient batch queries returning NumPy arrays (e.g., `getPrimitiveNormal([uuid1, uuid2])` returns an ndarray of shape (N, 3))
+- Added `getAll*` convenience methods that query all primitives in the context (e.g., `getAllPrimitiveNormals()`)
+- Extended `PrimitiveInfo` with `texture_file`, `texture_uv`, and `solid_fraction` fields
+- Added timeseries data management: `addTimeseriesData()`, `setCurrentTimeseriesPoint()`, `queryTimeseriesData()`, `queryTimeseriesDate()`, `queryTimeseriesTime()`, `getTimeseriesLength()`, `doesTimeseriesVariableExist()`, `listTimeseriesVariables()`, `loadTabularTimeseriesData()`
+
+## Radiation Model
+- Added EXR image export methods: `writeCameraImageDataEXR()`, `writeDepthImageData()`, `writeDepthImageDataEXR()`, `writeNormDepthImage()`
+- Added `getBackendName()` and `probeAnyGPUBackend()` for runtime GPU backend detection
+- Updated error messages to reflect runtime backend auto-detection (OptiX 8 -> OptiX 6 -> Vulkan)
+
+## Validation
+- Added `isinstance()`-based type validation to PlantArchitecture and RadiationModel methods per argument type validation policy
+- Added `validate_position_like()`, `validate_direction_like()`, and `validate_size_like()` validators for flexible parameter types
+
 # [v0.1.15] 2026-03-06
 
 - Updated helios-core to v1.3.65

docs/cross_platform.md

@@ -2,6 +2,15 @@
 
 PyHelios is designed to work seamlessly across Windows, macOS, and Linux. This guide covers platform-specific considerations and features.
 
+## Python Version Support
+
+PyHelios requires **Python 3.10 or later**. Pre-built wheels are available for Python 3.10–3.14.
+
+| Python Version | Status |
+|----------------|--------|
+| 3.10 – 3.14 | Supported (pre-built wheels available) |
+| 3.9 and earlier | Not supported |
+
 ## Platform Support Matrix
 
 | Feature | Windows | macOS | Linux | Notes |

docs/plugin_radiation.md

@@ -12,26 +12,42 @@ The radiation plugin supports two GPU backends. At least one must be available:
 
 ### Vulkan Backend (All Platforms)
 
-Supports NVIDIA, AMD, Intel, and Apple Silicon GPUs via Vulkan compute shaders with software BVH traversal.
+Supports NVIDIA, AMD, Intel, and Apple Silicon GPUs via Vulkan compute shaders with software BVH traversal. Vulkan headers and the glslang shader compiler are bundled with Helios, so no external Vulkan SDK installation is required on Windows.
 
 | Requirement | macOS | Linux | Windows |
 |-------------|-------|-------|---------|
 | **GPU** | Any with Vulkan support | Any with Vulkan support | Any with Vulkan support |
-| **Vulkan SDK** | Via MoltenVK (bundled with macOS) | <a href="https://vulkan.lunarg.com/sdk/home">Vulkan SDK</a> | <a href="https://vulkan.lunarg.com/sdk/home">Vulkan SDK</a> |
+| **Dependencies** | `brew install vulkan-loader molten-vk` | `sudo apt-get install libvulkan-dev` | None (all bundled) |
 
 ### OptiX Backend (NVIDIA Only)
 
-Provides optimized ray tracing on NVIDIA GPUs using hardware RT cores.
+Provides optimized ray tracing on NVIDIA GPUs using hardware RT cores. Two OptiX versions are supported:
 
-| Requirement | macOS | Linux | Windows |
-|-------------|-------|-------|---------|
-| **GPU** | Not supported | CUDA-capable (compute capability 3.5+) | CUDA-capable (compute capability 3.5+) |
-| **CUDA Runtime** | Not supported | Version 9.0+ | Version 9.0+ |
-| **OptiX Runtime** | Not supported | Bundled with PyHelios | Bundled with PyHelios |
+| Backend | Driver Requirement | CUDA | Notes |
+|---------|-------------------|------|-------|
+| **OptiX 8.1** | NVIDIA driver >= 560 | CUDA 12.0+ | Default for modern drivers |
+| **OptiX 6.5** | NVIDIA driver < 560 | CUDA 9.0+ | Legacy driver support |
 
 ### Backend Selection
 
-Backend selection is automatic based on available hardware. Use the CMake option `FORCE_VULKAN_BACKEND=ON` to force the Vulkan backend for testing.
+Backend selection is **automatic at runtime** via GPU hardware probing. When the radiation model starts, it probes compiled-in backends in priority order (OptiX 8 -> OptiX 6 -> Vulkan) and selects the first one that is compatible with the current hardware. If no compatible GPU is found, a clear diagnostic error is raised.
+
+You can query the active backend at runtime:
+
+```python
+with RadiationModel(context) as radiation:
+    print(f"Active backend: {radiation.getBackendName()}")
+    # e.g., "OptiX 8.1", "OptiX 6.5", "Vulkan Compute"
+```
+
+You can also probe GPU availability without creating a full radiation model:
+
+```python
+if RadiationModel.probeAnyGPUBackend():
+    print("GPU backend available")
+else:
+    print("No compatible GPU backend found")
+```
 
 **For CUDA/OptiX setup**, see the comprehensive \ref CUDASetup "CUDA Setup Guide", which covers:
 - Choosing the correct CUDA toolkit version: \ref ChoosingCUDA
@@ -1059,6 +1075,48 @@ radiation.writeCameraImageData(
     imagefile_base="raw_data",
     image_path="./data"
 )
+
+# Camera image data in EXR format (lossless float precision, v1.3.66+)
+radiation.writeCameraImageDataEXR(
+    camera="overhead_camera",
+    band="PAR",                    # Single band
+    imagefile_base="raw_float_data",
+    image_path="./data"
+)
+
+# Multi-band EXR (all bands as separate channels in one file)
+radiation.writeCameraImageDataEXR(
+    camera="overhead_camera",
+    band=["Red", "Green", "Blue"],  # Multiple bands
+    imagefile_base="rgb_float_data",
+    image_path="./data"
+)
+```
+
+### Depth Image Export
+
+```python
+# Depth image as ASCII text file
+radiation.writeDepthImageData(
+    camera_label="overhead_camera",
+    imagefile_base="depth_data",
+    image_path="./data"
+)
+
+# Depth image as EXR file (lossless float precision, v1.3.66+)
+radiation.writeDepthImageDataEXR(
+    camera_label="overhead_camera",
+    imagefile_base="depth_float",
+    image_path="./data"
+)
+
+# Normalized depth image (grayscale JPEG for visualization)
+radiation.writeNormDepthImage(
+    camera_label="overhead_camera",
+    imagefile_base="depth_visual",
+    max_depth=50.0,  # Maximum depth for normalization
+    image_path="./data"
+)
 ```
 
 ### Object Detection Training Data
@@ -1314,15 +1372,24 @@ except RuntimeError as e:
 from pyhelios import RadiationModel
 from pyhelios.exceptions import HeliosGPUInitializationError
 
+# Check GPU availability before creating RadiationModel
+if not RadiationModel.probeAnyGPUBackend():
+    print("No compatible GPU backend found")
+    print("Supported backends: OptiX 8 (NVIDIA driver >= 560), OptiX 6 (NVIDIA driver < 560), Vulkan")
+
 try:
     radiation = RadiationModel(context)
-    
+    print(f"Using backend: {radiation.getBackendName()}")
+
 except Exception as e:
     print(f"RadiationModel initialization failed: {e}")
-    
-    # Check if GPU is available
+
+    # Runtime backend probing provides clear diagnostic messages
     if "Vulkan" in str(e):
-        print("Vulkan backend error - check Vulkan SDK installation and GPU drivers")
+        print("Vulkan backend error - check GPU drivers")
+        print("  macOS: brew install vulkan-loader molten-vk")
+        print("  Linux: sudo apt-get install libvulkan-dev")
+        print("  Windows: No additional packages needed")
     elif "OptiX" in str(e):
         print("OptiX backend error - check CUDA/OptiX installation and NVIDIA drivers")
     elif "GPU" in str(e):