lsurf 1.0.0__py3-none-any.whl

lsurf/gui/views/config_editor.py

@@ -0,0 +1,3199 @@
+# The Clear BSD License
+#
+# Copyright (c) 2026 Tobias Heibges
+# All rights reserved.
+#
+# Redistribution and use in source and binary forms, with or without
+# modification, are permitted (subject to the limitations in the disclaimer
+# below) provided that the following conditions are met:
+#
+#      * Redistributions of source code must retain the above copyright notice,
+#      this list of conditions and the following disclaimer.
+#
+#      * 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.
+#
+#      * Neither the name of the copyright holder nor the names of its
+#      contributors may be used to endorse or promote products derived from this
+#      software without specific prior written permission.
+#
+# NO EXPRESS OR IMPLIED LICENSES TO ANY PARTY'S PATENT RIGHTS ARE GRANTED BY
+# THIS LICENSE. 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 HOLDER 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.
+
+"""Config editor panel - create and edit simulation configurations in real-time.
+
+Provides a GUI for editing surfaces, sources, and simulation parameters
+with live preview in the 3D viewport.
+"""
+
+from pathlib import Path
+from typing import TYPE_CHECKING, Any, Callable
+
+import numpy as np
+
+import dearpygui.dearpygui as dpg
+
+if TYPE_CHECKING:
+    from ..core.scene import Scene
+    from .results import ResultsPanel
+
+
+class ConfigEditorPanel:
+    """Configuration editor with real-time preview."""
+
+    # Available surface roles
+    SURFACE_ROLES = ["optical", "absorber"]
+
+    # Class-level caches for discovered options (populated once)
+    _discovered_materials: list[str] | None = None
+    _discovered_sources: list[str] | None = None
+    _discovered_surfaces: list[str] | None = None
+    _discovered_atmospheres: list[str] | None = None
+
+    @classmethod
+    def get_available_materials(cls) -> list[str]:
+        """Dynamically discover available materials from lsurf.materials."""
+        if cls._discovered_materials is not None:
+            return cls._discovered_materials
+
+        materials = []
+        try:
+            import lsurf.materials as mat
+
+            # Add predefined material instances (like VACUUM, AIR_STP, etc.)
+            for name in dir(mat):
+                obj = getattr(mat, name)
+                if hasattr(obj, "__class__") and "Material" in type(obj).__name__:
+                    if not name.startswith("_"):
+                        # Convert to lowercase, handle underscores
+                        clean_name = name.lower()
+                        materials.append(clean_name)
+
+            # Add atmosphere models (like STANDARD_ATMOSPHERE, ExponentialAtmosphere)
+            for name in dir(mat):
+                if "Atmosphere" in name and not name.startswith("_"):
+                    obj = getattr(mat, name)
+                    if hasattr(obj, "__class__"):
+                        clean_name = cls._camel_to_snake(name)
+                        materials.append(clean_name)
+
+        except ImportError:
+            # Fallback if lsurf not available
+            materials = ["vacuum", "air", "water", "glass"]
+
+        # Add custom option for user-defined materials
+        if "custom" not in materials:
+            materials.append("custom")
+
+        cls._discovered_materials = sorted(set(materials))
+        return cls._discovered_materials
+
+    @classmethod
+    def get_available_sources(cls) -> list[str]:
+        """Dynamically discover available source types from lsurf.sources."""
+        if cls._discovered_sources is not None:
+            return cls._discovered_sources
+
+        sources = []
+        try:
+            import inspect
+            import lsurf.sources as src
+
+            for name in dir(src):
+                obj = getattr(src, name)
+                # Check if it's a class with generate method (source class)
+                if (
+                    inspect.isclass(obj)
+                    and hasattr(obj, "generate")
+                    and name
+                    not in ("RaySource", "CustomRaySource", "ParallelBeamFromPositions")
+                    and not name.startswith("_")
+                ):
+                    # Convert CamelCase to snake_case and simplify
+                    snake_name = cls._camel_to_snake(name)
+                    # Remove common suffixes for cleaner names
+                    snake_name = snake_name.replace("_source", "").replace("_beam", "")
+                    sources.append(snake_name)
+
+        except ImportError:
+            sources = ["point", "collimated", "diverging", "gaussian"]
+
+        cls._discovered_sources = sources
+        return cls._discovered_sources
+
+    @classmethod
+    def get_available_surfaces(cls) -> list[str]:
+        """Dynamically discover available surface types from lsurf.surfaces."""
+        if cls._discovered_surfaces is not None:
+            return cls._discovered_surfaces
+
+        surfaces = []
+        try:
+            import inspect
+            import lsurf.surfaces as surf
+
+            for name in dir(surf):
+                obj = getattr(surf, name)
+                # Check if it's a concrete surface class
+                if (
+                    inspect.isclass(obj)
+                    and hasattr(obj, "intersect")
+                    and name not in ("Surface", "GPUSurface")
+                    and not name.startswith("_")
+                ):
+                    # Convert CamelCase to snake_case, remove 'Surface' suffix
+                    clean_name = name.replace("Surface", "")
+                    snake_name = cls._camel_to_snake(clean_name)
+                    if snake_name:
+                        surfaces.append(snake_name)
+
+        except ImportError:
+            surfaces = ["plane", "sphere", "bounded_plane"]
+
+        cls._discovered_surfaces = surfaces
+        return cls._discovered_surfaces
+
+    @classmethod
+    def get_available_atmospheres(cls) -> list[str]:
+        """Dynamically discover available atmosphere models from lsurf.materials."""
+        if cls._discovered_atmospheres is not None:
+            return cls._discovered_atmospheres
+
+        atmospheres = []
+        try:
+            import inspect
+            import lsurf.materials as mat
+
+            for name in dir(mat):
+                obj = getattr(mat, name)
+                if "Atmosphere" in name and not name.startswith("_"):
+                    if inspect.isclass(obj):
+                        snake_name = cls._camel_to_snake(name)
+                        atmospheres.append(snake_name)
+                    elif hasattr(obj, "__class__"):
+                        # Instance like STANDARD_ATMOSPHERE
+                        atmospheres.append(name.lower())
+
+        except ImportError:
+            atmospheres = ["exponential_atmosphere", "standard_atmosphere"]
+
+        cls._discovered_atmospheres = sorted(set(atmospheres))
+        return cls._discovered_atmospheres
+
+    # Class-level cache for material types
+    _discovered_material_types: list[str] | None = None
+
+    @classmethod
+    def get_available_material_types(cls) -> list[str]:
+        """Dynamically discover available material types from lsurf.materials."""
+        if cls._discovered_material_types is not None:
+            return cls._discovered_material_types
+
+        material_types = []
+        try:
+            import inspect
+            import lsurf.materials as mat
+
+            # Known material classes to look for
+            for name in dir(mat):
+                obj = getattr(mat, name)
+                if inspect.isclass(obj) and not name.startswith("_"):
+                    # Check if it has refractive_index or is a material-like class
+                    if (
+                        hasattr(obj, "__init__")
+                        and name not in ("MaterialField",)
+                        and (
+                            "Material" in name
+                            or "Atmosphere" in name
+                            or "Model" in name
+                        )
+                    ):
+                        snake_name = cls._camel_to_snake(name)
+                        material_types.append(snake_name)
+
+        except ImportError:
+            material_types = ["homogeneous_material", "exponential_atmosphere"]
+
+        cls._discovered_material_types = sorted(set(material_types))
+        return cls._discovered_material_types
+
+    @classmethod
+    def get_material_defaults(cls, material_type: str) -> dict[str, Any]:
+        """Get default parameters for a material type by introspecting its constructor."""
+        try:
+            import inspect
+            import lsurf.materials as mat
+
+            # Convert snake_case to CamelCase class name
+            class_name = cls._snake_to_camel(material_type)
+
+            if hasattr(mat, class_name):
+                material_class = getattr(mat, class_name)
+                sig = inspect.signature(material_class.__init__)
+                defaults = {}
+
+                for param_name, param in sig.parameters.items():
+                    if param_name in ("self", "kernel", "propagator"):
+                        continue
+                    if param.default != inspect.Parameter.empty:
+                        val = param.default
+                        # Convert tuples to lists for UI
+                        if isinstance(val, tuple):
+                            val = list(val)
+                        defaults[param_name] = val
+                    else:
+                        # Provide sensible defaults based on parameter name
+                        if param_name == "name":
+                            defaults[param_name] = material_type
+                        elif param_name == "refractive_index":
+                            defaults[param_name] = 1.0
+                        elif "n_sea_level" in param_name:
+                            defaults[param_name] = 1.000293
+                        elif "scale_height" in param_name:
+                            defaults[param_name] = 8500.0
+                        elif "earth_radius" in param_name:
+                            defaults[param_name] = 6371000.0
+                        elif "earth_center" in param_name:
+                            defaults[param_name] = [0.0, 0.0, 0.0]
+                        elif "center" in param_name:
+                            defaults[param_name] = [0.0, 0.0, 0.0]
+                        elif "coef" in param_name:
+                            defaults[param_name] = 0.0
+                        elif "altitude_range" in param_name:
+                            defaults[param_name] = [0.0, 200000.0]
+
+                return defaults
+
+        except Exception as e:
+            print(f"Error getting material defaults for {material_type}: {e}")
+
+        # Fallback defaults
+        fallbacks = {
+            "homogeneous_material": {
+                "name": "custom",
+                "refractive_index": 1.5,
+                "absorption_coef": 0.0,
+            },
+            "exponential_atmosphere": {
+                "name": "atmosphere",
+                "n_sea_level": 1.000293,
+                "scale_height": 8500.0,
+                "earth_radius": 6371000.0,
+                "earth_center": [0.0, 0.0, 0.0],
+            },
+            "duct_atmosphere": {
+                "name": "duct",
+                "n_sea_level": 1.000293,
+                "scale_height": 8500.0,
+                "earth_radius": 6371000.0,
+                "duct_center": 0.0,
+                "duct_width": 100.0,
+                "duct_intensity": 0.0,
+            },
+        }
+        return fallbacks.get(
+            material_type, {"name": material_type, "refractive_index": 1.0}
+        )
+
+    @classmethod
+    def get_surface_defaults(cls, surface_type: str) -> dict[str, Any]:
+        """Get default parameters for a surface type by introspecting its constructor."""
+        try:
+            import inspect
+            import lsurf.surfaces as surf
+
+            # Handle gpu_ prefix specially - strip it and prepend GPU to class name
+            if surface_type.startswith("gpu_"):
+                base_type = surface_type[4:]  # Remove "gpu_" prefix
+                class_name = "GPU" + cls._snake_to_camel(base_type) + "Surface"
+                gpu_class_name = class_name
+                non_gpu_class_name = cls._snake_to_camel(base_type) + "Surface"
+            else:
+                class_name = cls._snake_to_camel(surface_type) + "Surface"
+                gpu_class_name = "GPU" + class_name
+                non_gpu_class_name = class_name
+
+            # Check if this is a wave surface (needs 2D direction, prefer GPU version)
+            is_wave_surface = "wave" in surface_type.lower()
+
+            # For wave surfaces, prefer GPU version (has individual params)
+            if is_wave_surface:
+                candidates = [gpu_class_name, non_gpu_class_name]
+            else:
+                candidates = [class_name, gpu_class_name]
+
+            surface_class = None
+            for candidate in candidates:
+                if hasattr(surf, candidate):
+                    surface_class = getattr(surf, candidate)
+                    break
+
+            if surface_class is not None:
+                sig = inspect.signature(surface_class.__init__)
+                defaults = {}
+
+                # Check if class uses wave_params (composite parameter)
+                uses_wave_params = "wave_params" in sig.parameters
+
+                # If using wave_params, add individual wave parameters as defaults
+                if uses_wave_params:
+                    defaults["amplitude"] = 1.0
+                    defaults["wavelength"] = 10.0
+                    defaults["direction"] = [1.0, 0.0]
+                    defaults["phase"] = 0.0
+                    defaults["steepness"] = 0.0
+
+                for param_name, param in sig.parameters.items():
+                    if param_name in ("self", "wave_params"):
+                        continue
+                    if param.default != inspect.Parameter.empty:
+                        defaults[param_name] = param.default
+                    else:
+                        # Provide sensible defaults for common parameter types
+                        if (
+                            "point" in param_name
+                            or "center" in param_name
+                            or "position" in param_name
+                        ):
+                            if "earth" in param_name:
+                                defaults[param_name] = [0.0, 0.0, -6.371e6]
+                            else:
+                                defaults[param_name] = [0.0, 0.0, 0.0]
+                        elif "normal" in param_name:
+                            defaults[param_name] = [0.0, 0.0, 1.0]
+                        elif param_name == "direction":
+                            # Wave surfaces use 2D direction, others use 3D
+                            if is_wave_surface:
+                                defaults[param_name] = [1.0, 0.0]
+                            else:
+                                defaults[param_name] = [0.0, 0.0, 1.0]
+                        elif "radius" in param_name:
+                            if "earth" in param_name:
+                                defaults[param_name] = 6.371e6
+                            else:
+                                defaults[param_name] = 5.0
+                        elif "width" in param_name or "height" in param_name:
+                            defaults[param_name] = 10.0
+                        elif "amplitude" in param_name:
+                            defaults[param_name] = 1.0
+                        elif "wavelength" in param_name:
+                            defaults[param_name] = 10.0
+                        elif param_name == "reference_z":
+                            defaults[param_name] = 0.0
+
+                return defaults
+
+        except Exception as e:
+            print(f"Error getting defaults for {surface_type}: {e}")
+
+        # Fallback defaults for common types
+        fallbacks = {
+            "plane": {"point": [0, 0, 0], "normal": [0, 0, 1]},
+            "bounded_plane": {
+                "point": [0, 0, 0],
+                "normal": [0, 0, 1],
+                "width": 10,
+                "height": 10,
+            },
+            "sphere": {"center": [0, 0, 0], "radius": 5},
+            "annular_plane": {
+                "center": [0, 0, 0],
+                "normal": [0, 0, 1],
+                "inner_radius": 1,
+                "outer_radius": 5,
+            },
+            "gerstner_wave": {
+                "amplitude": 1.0,
+                "wavelength": 10.0,
+                "direction": [1.0, 0.0],
+                "reference_z": 0.0,
+                "phase": 0.0,
+                "steepness": 0.0,
+            },
+            "curved_wave": {
+                "amplitude": 1.0,
+                "wavelength": 10.0,
+                "direction": [1.0, 0.0],
+                "earth_center": [0, 0, -6.371e6],
+                "earth_radius": 6.371e6,
+            },
+            "gpu_gerstner_wave": {
+                "amplitude": 1.0,
+                "wavelength": 10.0,
+                "direction": [1.0, 0.0],
+                "reference_z": 0.0,
+                "phase": 0.0,
+            },
+            "gpu_curved_wave": {
+                "amplitude": 1.0,
+                "wavelength": 10.0,
+                "direction": [1.0, 0.0],
+                "earth_center": [0, 0, -6.371e6],
+                "earth_radius": 6.371e6,
+            },
+        }
+        return fallbacks.get(surface_type, {})
+
+    @classmethod
+    def get_source_defaults(cls, source_type: str) -> dict[str, Any]:
+        """Get default parameters for a source type by introspecting its constructor."""
+        try:
+            import inspect
+            import lsurf.sources as src
+
+            # Convert snake_case to CamelCase class name
+            # Handle special cases for naming
+            if source_type == "point":
+                class_name = "PointSource"
+            elif source_type == "collimated":
+                class_name = "CollimatedBeam"
+            elif source_type == "diverging":
+                class_name = "DivergingBeam"
+            elif source_type == "uniform_diverging":
+                class_name = "UniformDivergingBeam"
+            elif source_type == "gaussian":
+                class_name = "GaussianBeam"
+            else:
+                # Try to construct class name
+                class_name = cls._snake_to_camel(source_type)
+                if not class_name.endswith(("Source", "Beam")):
+                    class_name += "Source"
+
+            if hasattr(src, class_name):
+                source_class = getattr(src, class_name)
+                sig = inspect.signature(source_class.__init__)
+                defaults = {}
+
+                for param_name, param in sig.parameters.items():
+                    if param_name == "self":
+                        continue
+                    if param.default != inspect.Parameter.empty:
+                        defaults[param_name] = param.default
+                    else:
+                        # Provide sensible defaults for common parameter types
+                        if param_name in (
+                            "position",
+                            "origin",
+                            "center",
+                            "waist_position",
+                        ):
+                            defaults[param_name] = [0.0, 0.0, 10.0]
+                        elif param_name in ("direction", "mean_direction"):
+                            defaults[param_name] = [0.0, 0.0, -1.0]
+                        elif param_name == "num_rays":
+                            defaults[param_name] = 10000
+                        elif param_name == "wavelength":
+                            defaults[param_name] = 532e-9
+                        elif param_name == "power":
+                            defaults[param_name] = 1.0
+                        elif "radius" in param_name:
+                            defaults[param_name] = 1.0
+                        elif "angle" in param_name:
+                            defaults[param_name] = 10.0  # degrees
+
+                return defaults
+
+        except Exception:
+            pass
+
+        # Fallback defaults
+        fallbacks = {
+            "point": {"position": [0, 0, 10]},
+            "collimated": {"direction": [0, 0, -1], "radius": 1.0},
+            "diverging": {"direction": [0, 0, -1], "divergence_angle": 10.0},
+            "uniform_diverging": {"direction": [0, 0, -1], "divergence_angle": 10.0},
+            "gaussian": {"direction": [0, 0, -1], "waist_radius": 0.001},
+        }
+        return fallbacks.get(source_type, {})
+
+    @staticmethod
+    def _snake_to_camel(name: str) -> str:
+        """Convert snake_case to CamelCase."""
+        return "".join(word.capitalize() for word in name.split("_"))
+
+    @staticmethod
+    def _camel_to_snake(name: str) -> str:
+        """Convert CamelCase to snake_case."""
+        import re
+
+        # Insert underscore before uppercase letters and convert to lowercase
+        s1 = re.sub("(.)([A-Z][a-z]+)", r"\1_\2", name)
+        return re.sub("([a-z0-9])([A-Z])", r"\1_\2", s1).lower()
+
+    def __init__(
+        self,
+        scene: "Scene",
+        on_config_change: Callable[[], None] | None = None,
+        on_simulate: Callable[[], None] | None = None,
+        results_panel: "ResultsPanel | None" = None,
+        visualization_panel: Any | None = None,
+    ) -> None:
+        self.scene = scene
+        self.on_config_change = on_config_change
+        self.on_simulate = on_simulate
+        self.results_panel = results_panel
+        self.visualization_panel = visualization_panel
+        self._window_tag: int | None = None
+        self._last_export_debug: str = ""
+
+        # Current configuration state
+        # Surfaces now store medium config inline (no separate media dict needed)
+        self._surfaces: list[dict[str, Any]] = []
+        self._detectors: list[dict[str, Any]] = []
+        self._source_config: dict[str, Any] = {
+            "type": "point",
+            "position": [0.0, 0.0, 10.0],
+            "num_rays": 10000,
+            "wavelength": 532e-9,
+            "power": 1.0,
+        }
+        self._sim_config: dict[str, Any] = {
+            "max_bounces": 10,
+            "step_size": 100.0,
+            "use_gpu": True,
+            "bounding_center": [0.0, 0.0, 0.0],
+            "bounding_radius": 100.0,
+            "output_directory": "./results",
+            "output_prefix": "simulation",
+            "output_format": "hdf5",
+            "track_refracted_rays": True,
+        }
+
+        # Track UI element tags for updates
+        self._surface_container: int | None = None
+        self._detector_container: int | None = None
+
+    def create(self, parent: int | str) -> int:
+        """Create the config editor panel.
+
+        Args:
+            parent: Parent container tag
+
+        Returns:
+            The window tag
+        """
+        with dpg.child_window(
+            parent=parent,
+            tag="config_editor_window",
+            width=-1,
+            height=-1,
+        ) as self._window_tag:
+            # Create green theme for simulate button
+            with dpg.theme() as simulate_theme:
+                with dpg.theme_component(dpg.mvButton):
+                    dpg.add_theme_color(dpg.mvThemeCol_Button, (40, 120, 40, 255))
+                    dpg.add_theme_color(
+                        dpg.mvThemeCol_ButtonHovered, (50, 150, 50, 255)
+                    )
+                    dpg.add_theme_color(dpg.mvThemeCol_ButtonActive, (60, 180, 60, 255))
+
+            # Toolbar
+            with dpg.group(horizontal=True):
+                dpg.add_button(
+                    label="New Config",
+                    callback=self._on_new_config,
+                )
+                dpg.add_button(
+                    label="Load Config",
+                    callback=self._on_load_config,
+                )
+                dpg.add_button(
+                    label="Apply",
+                    callback=self._on_apply,
+                )
+                dpg.add_button(
+                    label="Reload Scene",
+                    callback=self._on_reload_scene,
+                )
+                dpg.add_button(
+                    label="Export YAML",
+                    callback=self._on_export_yaml,
+                )
+                dpg.add_spacer(width=10)
+                simulate_btn = dpg.add_button(
+                    label="Simulate",
+                    callback=self._on_simulate,
+                    tag="simulate_btn",
+                )
+                dpg.bind_item_theme(simulate_btn, simulate_theme)
+
+                dpg.add_spacer(width=10)
+                dpg.add_text("", tag="simulate_status", color=(128, 128, 128))
+
+            dpg.add_separator()
+
+            # Second row of toolbar - Check Geometry button
+            with dpg.group(horizontal=True):
+                dpg.add_button(
+                    label="Check Geometry",
+                    callback=self._on_check_geometry,
+                )
+
+            dpg.add_separator()
+
+            # Tabbed sections - ordered logically:
+            # 1. Surfaces (with inline media configuration)
+            # 2. Detectors
+            # 3. Source
+            # 4. Simulation
+            with dpg.tab_bar():
+                # Surfaces tab - define surface geometry and assign media
+                with dpg.tab(label="Surfaces"):
+                    with dpg.group():
+                        dpg.add_text(
+                            "Define surface geometry and optical properties",
+                            color=(150, 150, 150),
+                        )
+                        dpg.add_text(
+                            "Configure front/back media directly on each surface",
+                            color=(120, 120, 120),
+                        )
+                        dpg.add_spacer(height=5)
+                        dpg.add_button(
+                            label="+ Add Surface",
+                            callback=self._on_add_surface,
+                            width=-1,
+                        )
+                        dpg.add_separator()
+                        with dpg.child_window(
+                            height=-1,  # Fill available space, scrollable
+                            tag="surfaces_container",
+                        ) as self._surface_container:
+                            self._rebuild_surfaces_ui()
+
+                # Detectors tab
+                with dpg.tab(label="Detectors"):
+                    with dpg.group():
+                        dpg.add_text(
+                            "Define detector surfaces to capture rays",
+                            color=(150, 150, 150),
+                        )
+                        dpg.add_spacer(height=5)
+                        dpg.add_button(
+                            label="+ Add Detector",
+                            callback=self._on_add_detector,
+                            width=-1,
+                        )
+                        dpg.add_separator()
+                        with dpg.child_window(
+                            height=-1,  # Fill available space, scrollable
+                            tag="detectors_container",
+                        ) as self._detector_container:
+                            self._rebuild_detectors_ui()
+
+                # Source tab
+                with dpg.tab(label="Source"):
+                    with dpg.child_window(height=-1, tag="source_container"):
+                        self._create_source_ui()
+
+                # Simulation tab
+                with dpg.tab(label="Simulation"):
+                    with dpg.child_window(height=-1, tag="simulation_container"):
+                        self._create_simulation_ui()
+
+        return self._window_tag
+
+    def _create_source_ui(self) -> None:
+        """Create the source configuration UI."""
+        dpg.add_text("Source Configuration", color=(180, 180, 180))
+        dpg.add_separator()
+
+        # Source type selector
+        dpg.add_text("Type:")
+        dpg.add_combo(
+            items=self.get_available_sources(),
+            default_value=self._source_config["type"],
+            callback=self._on_source_type_change,
+            tag="source_type_combo",
+            width=-1,
+        )
+
+        dpg.add_spacer(height=10)
+
+        # Common parameters - Position with label on left
+        with dpg.group(horizontal=True):
+            dpg.add_text("Position X:", color=(180, 180, 180))
+            dpg.add_input_float(
+                default_value=self._source_config["position"][0],
+                callback=lambda s, a: self._on_source_param_change("position", 0, a),
+                width=-1,
+                tag="source_pos_x",
+            )
+        with dpg.group(horizontal=True):
+            dpg.add_text("Position Y:", color=(180, 180, 180))
+            dpg.add_input_float(
+                default_value=self._source_config["position"][1],
+                callback=lambda s, a: self._on_source_param_change("position", 1, a),
+                width=-1,
+                tag="source_pos_y",
+            )
+        with dpg.group(horizontal=True):
+            dpg.add_text("Position Z:", color=(180, 180, 180))
+            dpg.add_input_float(
+                default_value=self._source_config["position"][2],
+                callback=lambda s, a: self._on_source_param_change("position", 2, a),
+                width=-1,
+                tag="source_pos_z",
+            )
+
+        dpg.add_spacer(height=5)
+        with dpg.group(horizontal=True):
+            dpg.add_text("Number of Rays:", color=(180, 180, 180))
+            dpg.add_input_int(
+                default_value=self._source_config["num_rays"],
+                callback=lambda s, a: self._on_source_param_change("num_rays", None, a),
+                width=-1,
+                min_value=100,
+                max_value=10000000,
+                tag="source_num_rays",
+            )
+
+        with dpg.group(horizontal=True):
+            dpg.add_text("Wavelength (nm):", color=(180, 180, 180))
+            dpg.add_input_float(
+                default_value=self._source_config["wavelength"] * 1e9,
+                callback=lambda s, a: self._on_source_param_change(
+                    "wavelength", None, a * 1e-9
+                ),
+                width=-1,
+                min_value=100,
+                max_value=2000,
+                tag="source_wavelength",
+            )
+
+        with dpg.group(horizontal=True):
+            dpg.add_text("Power (W):", color=(180, 180, 180))
+            dpg.add_input_float(
+                default_value=self._source_config["power"],
+                callback=lambda s, a: self._on_source_param_change("power", None, a),
+                width=-1,
+                min_value=0.0,
+                tag="source_power",
+            )
+
+        # Type-specific parameters container
+        dpg.add_separator()
+        with dpg.group(tag="source_type_params"):
+            self._update_source_type_params()
+
+    def _update_source_type_params(self) -> None:
+        """Update source type-specific parameter UI dynamically from discovered defaults."""
+        if not dpg.does_item_exist("source_type_params"):
+            return
+
+        dpg.delete_item("source_type_params", children_only=True)
+
+        source_type = self._source_config["type"]
+
+        # Get defaults dynamically
+        defaults = self.get_source_defaults(source_type)
+
+        # Skip common params already shown in the main UI
+        skip_params = {
+            "num_rays",
+            "wavelength",
+            "power",
+            "position",
+            "origin",
+            "center",
+            "waist_position",
+        }
+
+        for param_name, default_val in defaults.items():
+            if param_name in skip_params:
+                continue
+
+            # Create human-readable label
+            label = param_name.replace("_", " ").title()
+
+            # Handle different parameter types
+            if isinstance(default_val, (list, tuple)) and len(default_val) == 3:
+                # 3D vector parameter (direction, etc.) - label on left
+                vec_labels = ["X", "Y", "Z"]
+                for i in range(3):
+                    with dpg.group(horizontal=True, parent="source_type_params"):
+                        dpg.add_text(f"{label} {vec_labels[i]}:", color=(180, 180, 180))
+                        dpg.add_input_float(
+                            default_value=self._source_config.get(
+                                param_name, list(default_val)
+                            )[i],
+                            callback=lambda s, a, idx=i, pn=param_name: self._on_source_param_change(
+                                pn, idx, a
+                            ),
+                            width=-1,
+                        )
+
+            elif isinstance(default_val, (list, tuple)) and len(default_val) == 2:
+                # 2D vector parameter - label on left
+                vec_labels = ["X", "Y"]
+                for i in range(2):
+                    with dpg.group(horizontal=True, parent="source_type_params"):
+                        dpg.add_text(f"{label} {vec_labels[i]}:", color=(180, 180, 180))
+                        dpg.add_input_float(
+                            default_value=self._source_config.get(
+                                param_name, list(default_val)
+                            )[i],
+                            callback=lambda s, a, idx=i, pn=param_name: self._on_source_param_change(
+                                pn, idx, a
+                            ),
+                            width=-1,
+                        )
+
+            elif isinstance(default_val, str):
+                # String parameter (like profile: "uniform" or "gaussian")
+                # Try to discover possible values
+                possible_values = self._get_param_choices(
+                    source_type, param_name, default_val
+                )
+                dpg.add_text(f"{label}:", parent="source_type_params")
+                dpg.add_combo(
+                    items=possible_values,
+                    default_value=self._source_config.get(param_name, default_val),
+                    callback=lambda s, a, pn=param_name: self._on_source_param_change(
+                        pn, None, a
+                    ),
+                    width=-1,
+                    parent="source_type_params",
+                )
+
+            elif isinstance(default_val, bool):
+                # Boolean parameter
+                dpg.add_checkbox(
+                    label=label,
+                    default_value=self._source_config.get(param_name, default_val),
+                    callback=lambda s, a, pn=param_name: self._on_source_param_change(
+                        pn, None, a
+                    ),
+                    parent="source_type_params",
+                )
+
+            elif isinstance(default_val, int):
+                # Integer parameter
+                dpg.add_text(f"{label}:", parent="source_type_params")
+                dpg.add_input_int(
+                    default_value=self._source_config.get(param_name, default_val),
+                    callback=lambda s, a, pn=param_name: self._on_source_param_change(
+                        pn, None, a
+                    ),
+                    width=-1,
+                    parent="source_type_params",
+                )
+
+            elif isinstance(default_val, float):
+                # Float parameter
+                dpg.add_text(f"{label}:", parent="source_type_params")
+                dpg.add_input_float(
+                    default_value=self._source_config.get(param_name, default_val),
+                    callback=lambda s, a, pn=param_name: self._on_source_param_change(
+                        pn, None, a
+                    ),
+                    width=-1,
+                    parent="source_type_params",
+                )
+
+    def _get_param_choices(
+        self, source_type: str, param_name: str, default_val: str
+    ) -> list[str]:
+        """Get possible choices for a string parameter by inspecting type hints or docstrings."""
+        # Known choices for common parameters
+        known_choices = {
+            "profile": ["uniform", "gaussian"],
+        }
+
+        if param_name in known_choices:
+            return known_choices[param_name]
+
+        # Default: return just the default value
+        return [default_val]
+
+    def _create_simulation_ui(self) -> None:
+        """Create the simulation configuration UI."""
+        dpg.add_text("Simulation Parameters", color=(180, 180, 180))
+        dpg.add_separator()
+
+        dpg.add_text("Max Bounces:")
+        dpg.add_input_int(
+            default_value=self._sim_config["max_bounces"],
+            callback=lambda s, a: self._on_sim_param_change("max_bounces", a),
+            width=-1,
+            min_value=1,
+            max_value=100,
+        )
+
+        dpg.add_text("Step Size (m):")
+        dpg.add_input_float(
+            default_value=self._sim_config["step_size"],
+            callback=lambda s, a: self._on_sim_param_change("step_size", a),
+            width=-1,
+            min_value=0.1,
+        )
+
+        dpg.add_text("Bounding Radius (m):")
+        dpg.add_input_float(
+            default_value=self._sim_config["bounding_radius"],
+            callback=lambda s, a: self._on_sim_param_change("bounding_radius", a),
+            width=-1,
+            min_value=1.0,
+        )
+
+        dpg.add_spacer(height=5)
+        dpg.add_checkbox(
+            label="Use GPU",
+            default_value=self._sim_config["use_gpu"],
+            callback=lambda s, a: self._on_sim_param_change("use_gpu", a),
+        )
+        dpg.add_checkbox(
+            label="Track Refracted Rays",
+            default_value=self._sim_config["track_refracted_rays"],
+            callback=lambda s, a: self._on_sim_param_change("track_refracted_rays", a),
+        )
+        with dpg.tooltip(dpg.last_item()):
+            dpg.add_text(
+                "When enabled, rays that refract through surfaces\ncontinue propagating. Disable for reflection-only\nsimulations (e.g., ocean surface reflection)."
+            )
+
+        dpg.add_spacer(height=10)
+        dpg.add_text("Output Settings", color=(180, 180, 180))
+        dpg.add_separator()
+
+        dpg.add_text("Output Directory:")
+        with dpg.group(horizontal=True):
+            dpg.add_input_text(
+                default_value=self._sim_config["output_directory"],
+                callback=lambda s, a: self._on_sim_param_change("output_directory", a),
+                width=-60,
+                tag="output_dir_input",
+            )
+            dpg.add_button(
+                label="...",
+                callback=self._on_browse_output_dir,
+                width=50,
+            )
+
+        dpg.add_text("Output Prefix:")
+        dpg.add_input_text(
+            default_value=self._sim_config["output_prefix"],
+            callback=lambda s, a: self._on_sim_param_change("output_prefix", a),
+            width=-1,
+        )
+
+        dpg.add_text("Output Format:")
+        dpg.add_combo(
+            items=["hdf5", "numpy", "csv"],
+            default_value=self._sim_config["output_format"],
+            callback=lambda s, a: self._on_sim_param_change("output_format", a),
+            width=-1,
+        )
+
+    def _on_browse_output_dir(self) -> None:
+        """Handle browse button for output directory."""
+
+        def callback(sender, app_data):
+            if app_data.get("file_path_name"):
+                dir_path = app_data["file_path_name"]
+                self._sim_config["output_directory"] = dir_path
+                if dpg.does_item_exist("output_dir_input"):
+                    dpg.set_value("output_dir_input", dir_path)
+
+        with dpg.file_dialog(
+            callback=callback,
+            width=800,
+            height=500,
+            modal=True,
+            show=True,
+            directory_selector=True,
+        ):
+            pass
+
+    def _rebuild_surfaces_ui(self) -> None:
+        """Rebuild the surfaces list UI."""
+        if not dpg.does_item_exist("surfaces_container"):
+            return
+
+        dpg.delete_item("surfaces_container", children_only=True)
+
+        if not self._surfaces:
+            dpg.add_text(
+                "No surfaces. Click '+ Add Surface' to create one.",
+                color=(128, 128, 128),
+                parent="surfaces_container",
+            )
+            return
+
+        for i, surface in enumerate(self._surfaces):
+            self._create_surface_editor(i, surface, "surfaces_container")
+
+    def _rebuild_detectors_ui(self) -> None:
+        """Rebuild the detectors list UI."""
+        if not dpg.does_item_exist("detectors_container"):
+            return
+
+        dpg.delete_item("detectors_container", children_only=True)
+
+        if not self._detectors:
+            dpg.add_text(
+                "No detectors. Click '+ Add Detector' to create one.",
+                color=(128, 128, 128),
+                parent="detectors_container",
+            )
+            return
+
+        for i, detector in enumerate(self._detectors):
+            self._create_detector_editor(i, detector, "detectors_container")
+
+    def _create_surface_editor(
+        self, index: int, surface: dict[str, Any], parent: int | str
+    ) -> None:
+        """Create editor UI for a single surface."""
+        with dpg.collapsing_header(
+            label=f"{surface.get('name', f'Surface {index}')} ({surface['type']})",
+            default_open=True,
+            parent=parent,
+        ):
+            # Name
+            dpg.add_text("Name:")
+            dpg.add_input_text(
+                default_value=surface.get("name", f"surface_{index}"),
+                callback=self._on_surface_name_change,
+                user_data=index,
+                width=-1,
+            )
+
+            # Role selector
+            dpg.add_text("Role:")
+            dpg.add_combo(
+                items=self.SURFACE_ROLES,
+                default_value=surface.get("role", "optical"),
+                callback=self._on_surface_role_change,
+                user_data=index,
+                width=-1,
+            )
+
+            # Type selector
+            dpg.add_text("Geometry:")
+            dpg.add_combo(
+                items=self.get_available_surfaces(),
+                default_value=surface["type"],
+                callback=self._on_surface_type_combo_change,
+                user_data=index,
+                width=-1,
+            )
+
+            # Material selectors (only for optical surfaces)
+            if surface.get("role", "optical") == "optical":
+                dpg.add_separator()
+
+                # Help text for media matching
+                dpg.add_text(
+                    "Tip: Back medium should match front medium of next surface",
+                    color=(120, 120, 120),
+                )
+
+                # Get current medium configs (convert string to dict if needed)
+                front_medium = surface.get("front_medium", {"type": "vacuum"})
+                if isinstance(front_medium, str):
+                    front_medium = self._get_default_medium_config(front_medium)
+                back_medium = surface.get("back_medium", {"type": "vacuum"})
+                if isinstance(back_medium, str):
+                    back_medium = self._get_default_medium_config(back_medium)
+
+                # Front Medium: dropdown + Customize button
+                dpg.add_text("Front Medium:")
+                with dpg.group(horizontal=True):
+                    dpg.add_combo(
+                        items=self.get_available_materials(),
+                        default_value=front_medium.get("type", "vacuum"),
+                        callback=self._on_surface_front_medium_type_change,
+                        user_data=index,
+                        width=-100,
+                    )
+                    dpg.add_button(
+                        label="Customize",
+                        callback=self._on_customize_front_medium_btn,
+                        user_data=index,
+                        width=90,
+                    )
+
+                # Back Medium: dropdown + Customize button
+                dpg.add_text("Back Medium:")
+                with dpg.group(horizontal=True):
+                    dpg.add_combo(
+                        items=self.get_available_materials(),
+                        default_value=back_medium.get("type", "vacuum"),
+                        callback=self._on_surface_back_medium_type_change,
+                        user_data=index,
+                        width=-100,
+                    )
+                    dpg.add_button(
+                        label="Customize",
+                        callback=self._on_customize_back_medium_btn,
+                        user_data=index,
+                        width=90,
+                    )
+
+            dpg.add_separator()
+
+            # Type-specific parameters
+            self._create_surface_type_params(index, surface)
+
+            # Remove button
+            dpg.add_button(
+                label="Remove",
+                callback=self._on_remove_surface_btn,
+                user_data=index,
+                width=-1,
+            )
+
+            dpg.add_separator()
+
+    def _on_surface_role_change(self, sender, app_data, user_data) -> None:
+        """Handle surface role change."""
+        if 0 <= user_data < len(self._surfaces):
+            self._surfaces[user_data]["role"] = app_data
+            self._rebuild_surfaces_ui()
+            self._build_and_load_config()
+
+    def _on_surface_name_change(self, sender, app_data, user_data) -> None:
+        """Handle surface name change."""
+        self._on_surface_change(user_data, "name", app_data)
+
+    def _on_surface_type_combo_change(self, sender, app_data, user_data) -> None:
+        """Handle surface type combo change."""
+        self._on_surface_type_change(user_data, app_data)
+
+    def _on_remove_surface_btn(self, sender, app_data, user_data) -> None:
+        """Handle remove surface button."""
+        self._on_remove_surface(user_data)
+
+    def _create_surface_type_params(self, index: int, surface: dict[str, Any]) -> None:
+        """Create type-specific parameter inputs for a surface dynamically."""
+        surface_type = surface["type"]
+
+        # Get the surface class and introspect its parameters
+        self._create_dynamic_params(index, surface, surface_type, is_surface=True)
+
+    def _create_dynamic_params(
+        self,
+        index: int,
+        config: dict[str, Any],
+        type_name: str,
+        is_surface: bool = True,
+    ) -> None:
+        """Dynamically create UI for all parameters of a surface/detector type."""
+        import inspect
+        import lsurf.surfaces as surf
+
+        # Handle gpu_ prefix specially - strip it and prepend GPU to class name
+        if type_name.startswith("gpu_"):
+            base_type = type_name[4:]  # Remove "gpu_" prefix
+            class_name = "GPU" + self._snake_to_camel(base_type) + "Surface"
+            gpu_class_name = class_name
+            non_gpu_class_name = self._snake_to_camel(base_type) + "Surface"
+        else:
+            class_name = self._snake_to_camel(type_name) + "Surface"
+            gpu_class_name = "GPU" + class_name
+            non_gpu_class_name = class_name
+
+        # Check if this is a wave surface (uses 2D direction, prefer GPU version)
+        is_wave = "wave" in type_name.lower()
+
+        # Try to find the class - prefer GPU version for wave surfaces
+        # (GPU versions have individual amplitude/wavelength/direction params)
+        surface_class = None
+        if is_wave:
+            candidates = [gpu_class_name, non_gpu_class_name]
+        else:
+            candidates = [class_name, gpu_class_name]
+
+        for candidate in candidates:
+            if hasattr(surf, candidate):
+                surface_class = getattr(surf, candidate)
+                break
+
+        if surface_class is None:
+            # Fallback to defaults-based generation
+            self._create_params_from_defaults(index, config, type_name, is_surface)
+            return
+
+        # Get constructor signature
+        try:
+            sig = inspect.signature(surface_class.__init__)
+        except Exception:
+            self._create_params_from_defaults(index, config, type_name, is_surface)
+            return
+
+        # Parameters to skip (handled elsewhere or internal)
+        skip_params = {"self", "name", "role", "material_front", "material_back"}
+
+        # Check if this class uses wave_params (composite parameter)
+        # If so, expand it into individual amplitude/wavelength/direction/phase/steepness fields
+        uses_wave_params = "wave_params" in sig.parameters
+
+        if uses_wave_params:
+            # Add individual wave parameter UI elements
+            self._create_wave_params_ui(index, config, is_surface)
+            skip_params.add("wave_params")
+
+        # Process each parameter
+        for param_name, param in sig.parameters.items():
+            if param_name in skip_params:
+                continue
+
+            # Get default value
+            if param.default != inspect.Parameter.empty:
+                default_val = param.default
+            else:
+                # Provide sensible defaults based on parameter name
+                default_val = self._get_param_default(param_name, is_wave)
+
+            # Get current value from config or use default
+            current_val = config.get(param_name, default_val)
+
+            # Create appropriate UI element based on type
+            label = param_name.replace("_", " ").title()
+
+            if isinstance(current_val, (list, tuple)):
+                if len(current_val) == 3:
+                    self._add_vector_input(
+                        index, config, param_name, label, list(current_val), is_surface
+                    )
+                elif len(current_val) == 2:
+                    self._add_vector_input_2d(
+                        index, config, param_name, label, list(current_val), is_surface
+                    )
+            elif isinstance(current_val, bool):
+                if is_surface:
+                    callback = self._make_surface_scalar_callback(index, param_name)
+                else:
+                    callback = self._make_detector_scalar_callback(index, param_name)
+                with dpg.group(horizontal=True):
+                    dpg.add_text(f"{label}:", color=(180, 180, 180))
+                    dpg.add_checkbox(
+                        default_value=current_val,
+                        callback=callback,
+                    )
+            elif isinstance(current_val, int) and not isinstance(current_val, bool):
+                if is_surface:
+                    callback = self._make_surface_scalar_callback(index, param_name)
+                else:
+                    callback = self._make_detector_scalar_callback(index, param_name)
+                with dpg.group(horizontal=True):
+                    dpg.add_text(f"{label}:", color=(180, 180, 180))
+                    dpg.add_input_int(
+                        default_value=int(current_val),
+                        callback=callback,
+                        width=-1,
+                    )
+            elif isinstance(current_val, (int, float)):
+                if is_surface:
+                    callback = self._make_surface_scalar_callback(index, param_name)
+                else:
+                    callback = self._make_detector_scalar_callback(index, param_name)
+                # Choose format based on magnitude
+                if abs(current_val) > 10000 or (
+                    current_val != 0 and abs(current_val) < 0.01
+                ):
+                    fmt = "%.4g"
+                else:
+                    fmt = "%.4f"
+                with dpg.group(horizontal=True):
+                    dpg.add_text(f"{label}:", color=(180, 180, 180))
+                    dpg.add_input_float(
+                        default_value=float(current_val),
+                        callback=callback,
+                        width=-1,
+                        format=fmt,
+                    )
+
+    def _create_wave_params_ui(
+        self, index: int, config: dict[str, Any], is_surface: bool = True
+    ) -> None:
+        """Create UI for wave surface parameters (amplitude, wavelength, direction, etc.)."""
+        # Wave parameter defaults
+        wave_fields = [
+            ("amplitude", 1.0, "Amplitude (m)"),
+            ("wavelength", 10.0, "Wavelength (m)"),
+            ("phase", 0.0, "Phase (rad)"),
+            ("steepness", 0.0, "Steepness"),
+        ]
+
+        for param_name, default_val, label in wave_fields:
+            current_val = config.get(param_name, default_val)
+            if is_surface:
+                callback = self._make_surface_scalar_callback(index, param_name)
+            else:
+                callback = self._make_detector_scalar_callback(index, param_name)
+
+            with dpg.group(horizontal=True):
+                dpg.add_text(f"{label}:", color=(180, 180, 180))
+                dpg.add_input_float(
+                    default_value=float(current_val),
+                    callback=callback,
+                    width=-1,
+                    format="%.4g",
+                )
+
+        # Direction is a 2D vector for wave surfaces
+        direction_default = [1.0, 0.0]
+        current_direction = config.get("direction", direction_default)
+        self._add_vector_input_2d(
+            index, config, "direction", "Direction", list(current_direction), is_surface
+        )
+
+    def _get_param_default(self, param_name: str, is_wave: bool = False) -> Any:
+        """Get a sensible default value for a parameter based on its name."""
+        name_lower = param_name.lower()
+
+        if "point" in name_lower or "center" in name_lower or "position" in name_lower:
+            if "earth" in name_lower:
+                return [0.0, 0.0, -6.371e6]
+            return [0.0, 0.0, 0.0]
+        elif "normal" in name_lower:
+            return [0.0, 0.0, 1.0]
+        elif param_name == "direction":
+            return [1.0, 0.0] if is_wave else [0.0, 0.0, 1.0]
+        elif "radius" in name_lower:
+            if "earth" in name_lower:
+                return 6.371e6
+            elif "inner" in name_lower:
+                return 1.0
+            elif "outer" in name_lower:
+                return 5.0
+            return 5.0
+        elif "width" in name_lower or "height" in name_lower:
+            return 10.0
+        elif "amplitude" in name_lower:
+            return 1.0
+        elif "wavelength" in name_lower:
+            return 10.0
+        elif "reference_z" in name_lower:
+            return 0.0
+        elif "altitude" in name_lower:
+            return 100000.0
+        elif "phase" in name_lower:
+            return 0.0
+        elif "time" in name_lower:
+            return 0.0
+        elif "num" in name_lower or "count" in name_lower:
+            return 4
+        else:
+            return 0.0
+
+    def _create_params_from_defaults(
+        self, index: int, config: dict[str, Any], type_name: str, is_surface: bool
+    ) -> None:
+        """Create UI from get_surface_defaults fallback."""
+        defaults = self.get_surface_defaults(type_name)
+        for param_name, default_val in defaults.items():
+            if param_name in ("name", "role", "material_front", "material_back"):
+                continue
+
+            current_val = config.get(param_name, default_val)
+            label = param_name.replace("_", " ").title()
+
+            if isinstance(current_val, (list, tuple)) and len(current_val) == 3:
+                self._add_vector_input(
+                    index, config, param_name, label, list(current_val), is_surface
+                )
+            elif isinstance(current_val, (list, tuple)) and len(current_val) == 2:
+                self._add_vector_input_2d(
+                    index, config, param_name, label, list(current_val), is_surface
+                )
+            elif isinstance(current_val, (int, float)):
+                if is_surface:
+                    callback = self._make_surface_scalar_callback(index, param_name)
+                else:
+                    callback = self._make_detector_scalar_callback(index, param_name)
+                with dpg.group(horizontal=True):
+                    dpg.add_text(f"{label}:", color=(180, 180, 180))
+                    dpg.add_input_float(
+                        default_value=float(current_val),
+                        callback=callback,
+                        width=-1,
+                        format="%.4g",
+                    )
+
+    def _add_vector_input(
+        self,
+        index: int,
+        config: dict,
+        param: str,
+        label: str,
+        default: list,
+        is_surface: bool = True,
+    ) -> None:
+        """Add a labeled X/Y/Z vector input group (label on left, input on right)."""
+        labels = ["X", "Y", "Z"]
+        for j in range(3):
+            if is_surface:
+                callback = self._make_surface_vec_callback(index, param, j)
+            else:
+                callback = self._make_detector_vec_callback(index, param, j)
+            with dpg.group(horizontal=True):
+                dpg.add_text(f"{label} {labels[j]}:", color=(180, 180, 180))
+                dpg.add_input_float(
+                    default_value=config.get(param, default)[j],
+                    callback=callback,
+                    width=-1,
+                    format="%.4g",
+                )
+
+    def _add_vector_input_2d(
+        self,
+        index: int,
+        config: dict,
+        param: str,
+        label: str,
+        default: list,
+        is_surface: bool = True,
+    ) -> None:
+        """Add a labeled X/Y 2D vector input group (label on left, input on right)."""
+        labels = ["X", "Y"]
+        for j in range(2):
+            if is_surface:
+                callback = self._make_surface_vec_callback(index, param, j)
+            else:
+                callback = self._make_detector_vec_callback(index, param, j)
+            with dpg.group(horizontal=True):
+                dpg.add_text(f"{label} {labels[j]}:", color=(180, 180, 180))
+                dpg.add_input_float(
+                    default_value=config.get(param, default)[j],
+                    callback=callback,
+                    width=-1,
+                    format="%.4g",
+                )
+
+    def _make_surface_vec_callback(self, index: int, param: str, component: int):
+        """Create a callback for surface vector parameter changes."""
+
+        def callback(sender, app_data, user_data=None):
+            self._on_surface_vec_change(index, param, component, app_data)
+
+        return callback
+
+    def _make_surface_scalar_callback(self, index: int, param: str):
+        """Create a callback for surface scalar parameter changes."""
+
+        def callback(sender, app_data, user_data=None):
+            self._on_surface_change(index, param, app_data)
+
+        return callback
+
+    def _create_detector_editor(
+        self, index: int, detector: dict[str, Any], parent: int | str
+    ) -> None:
+        """Create editor UI for a single detector."""
+        with dpg.collapsing_header(
+            label=f"{detector.get('name', f'Detector {index}')} ({detector['type']})",
+            default_open=True,
+            parent=parent,
+        ):
+            dpg.add_text("Name:")
+            dpg.add_input_text(
+                default_value=detector.get("name", f"detector_{index}"),
+                callback=self._on_detector_name_change,
+                user_data=index,
+                width=-1,
+            )
+
+            dpg.add_text("Type:")
+            dpg.add_combo(
+                items=self.get_available_surfaces(),
+                default_value=detector["type"],
+                callback=self._on_detector_type_combo_change,
+                user_data=index,
+                width=-1,
+            )
+
+            # Type-specific params - dynamically generated
+            det_type = detector["type"]
+            self._create_dynamic_params(index, detector, det_type, is_surface=False)
+
+            dpg.add_button(
+                label="Remove",
+                callback=self._on_remove_detector_btn,
+                user_data=index,
+                width=-1,
+            )
+
+            dpg.add_separator()
+
+    def _on_detector_name_change(self, sender, app_data, user_data) -> None:
+        """Handle detector name change."""
+        self._on_detector_change(user_data, "name", app_data)
+
+    def _on_detector_type_combo_change(self, sender, app_data, user_data) -> None:
+        """Handle detector type combo change."""
+        self._on_detector_type_change(user_data, app_data)
+
+    def _on_remove_detector_btn(self, sender, app_data, user_data) -> None:
+        """Handle remove detector button."""
+        self._on_remove_detector(user_data)
+
+    def _make_detector_vec_callback(self, index: int, param: str, component: int):
+        """Create a callback for detector vector parameter changes."""
+
+        def callback(sender, app_data, user_data=None):
+            self._on_detector_vec_change(index, param, component, app_data)
+
+        return callback
+
+    def _make_detector_scalar_callback(self, index: int, param: str):
+        """Create a callback for detector scalar parameter changes."""
+
+        def callback(sender, app_data, user_data=None):
+            self._on_detector_change(index, param, app_data)
+
+        return callback
+
+    # === Event Handlers ===
+
+    def _on_new_config(self) -> None:
+        """Create a new empty configuration."""
+        self._surfaces = []
+        self._detectors = []
+        self._source_config = {
+            "type": "point",
+            "position": [0.0, 0.0, 10.0],
+            "num_rays": 10000,
+            "wavelength": 532e-9,
+            "power": 1.0,
+        }
+        self._rebuild_surfaces_ui()
+        self._rebuild_detectors_ui()
+        self.scene.clear()
+
+    def _on_load_config(self) -> None:
+        """Open file dialog to load a configuration file."""
+
+        def callback(sender, app_data):
+            if app_data.get("file_path_name"):
+                self.load_from_file(app_data["file_path_name"])
+
+        with dpg.file_dialog(
+            callback=callback,
+            width=800,
+            height=500,
+            modal=True,
+            show=True,
+        ):
+            dpg.add_file_extension(".yaml", color=(0, 255, 0))
+            dpg.add_file_extension(".yml", color=(0, 255, 0))
+            dpg.add_file_extension(".toml", color=(0, 200, 255))
+
+    def load_from_file(self, file_path: str | Path) -> bool:
+        """Load configuration from a YAML or TOML file into the editor.
+
+        Args:
+            file_path: Path to the configuration file
+
+        Returns:
+            True if loaded successfully
+        """
+        file_path = Path(file_path)
+        if not file_path.exists():
+            print(f"Config file not found: {file_path}")
+            return False
+
+        try:
+            # Load the raw config data
+            if file_path.suffix in (".yaml", ".yml"):
+                import yaml
+
+                with open(file_path) as f:
+                    data = yaml.safe_load(f)
+            elif file_path.suffix == ".toml":
+                import tomllib
+
+                with open(file_path, "rb") as f:
+                    data = tomllib.load(f)
+            else:
+                print(f"Unsupported file format: {file_path.suffix}")
+                return False
+
+            print(f"[GUI] Loaded config from: {file_path}")
+            print(
+                f"[GUI] Found {len(data.get('surfaces', []))} surfaces, {len(data.get('detectors', []))} detectors"
+            )
+
+            # Parse and populate the editor state
+            self._load_config_data(data)
+            return True
+
+        except Exception as e:
+            import traceback
+
+            print(f"Error loading config: {e}")
+            traceback.print_exc()
+            return False
+
+    def _load_config_data(self, data: dict) -> None:
+        """Populate editor state from parsed config data."""
+        # Clear existing state
+        self._surfaces = []
+        self._detectors = []
+
+        # Load media (for reference)
+        media_data = data.get("media", {})
+
+        # Load surfaces
+        for i, surf_data in enumerate(data.get("surfaces", [])):
+            surface_config = self._parse_surface_config(surf_data, media_data, i)
+            if surface_config:
+                self._surfaces.append(surface_config)
+
+        # Load detectors
+        for i, det_data in enumerate(data.get("detectors", [])):
+            detector_config = self._parse_detector_config(det_data, i)
+            if detector_config:
+                self._detectors.append(detector_config)
+
+        # Load source
+        source_data = data.get("source", {})
+        if source_data:
+            self._source_config = self._parse_source_config(source_data)
+
+        # Load simulation config
+        sim_data = data.get("simulation", {})
+        output_data = data.get("output", {})
+        self._sim_config = {
+            "max_bounces": sim_data.get("max_bounces", 10),
+            "step_size": sim_data.get("step_size", 100.0),
+            "use_gpu": sim_data.get("use_gpu", True),
+            "bounding_center": sim_data.get("bounding_center", [0.0, 0.0, 0.0]),
+            "bounding_radius": sim_data.get("bounding_radius", 100.0),
+            "track_refracted_rays": sim_data.get("track_refracted_rays", True),
+            "output_directory": output_data.get("directory", "./results"),
+            "output_prefix": output_data.get("prefix", "simulation"),
+            "output_format": output_data.get("format", "hdf5"),
+        }
+
+        print(
+            f"[GUI] Parsed {len(self._surfaces)} surfaces, {len(self._detectors)} detectors"
+        )
+        for i, s in enumerate(self._surfaces):
+            print(
+                f"[GUI]   Surface {i}: {s.get('name', 'unnamed')} ({s.get('type', '?')})"
+            )
+        for i, d in enumerate(self._detectors):
+            print(
+                f"[GUI]   Detector {i}: {d.get('name', 'unnamed')} ({d.get('type', '?')})"
+            )
+
+        # Rebuild UI
+        self._rebuild_surfaces_ui()
+        self._rebuild_detectors_ui()
+
+        # Apply to scene for preview
+        self._build_and_load_config()
+
+    def _parse_surface_config(
+        self, surf_data: dict, media_data: dict, index: int = 0
+    ) -> dict | None:
+        """Parse a surface configuration from loaded data."""
+        surface_type = surf_data.get("type", "plane")
+
+        config = {
+            "type": surface_type,
+            "name": surf_data.get("name", f"surface_{index}"),
+            "role": surf_data.get("role", "optical"),
+        }
+
+        # Handle front_medium - can be string or dict
+        front_medium = surf_data.get("front_medium", surf_data.get("front", "vacuum"))
+        if isinstance(front_medium, str):
+            config["front_medium"] = self._get_default_medium_config(front_medium)
+        elif isinstance(front_medium, dict):
+            config["front_medium"] = front_medium
+        else:
+            config["front_medium"] = {"type": "vacuum"}
+
+        # Handle back_medium - can be string or dict
+        back_medium = surf_data.get("back_medium", surf_data.get("back", "vacuum"))
+        if isinstance(back_medium, str):
+            config["back_medium"] = self._get_default_medium_config(back_medium)
+        elif isinstance(back_medium, dict):
+            config["back_medium"] = back_medium
+        else:
+            config["back_medium"] = {"type": "vacuum"}
+
+        # Handle CLI config format which uses nested "params" dict
+        params = surf_data.get("params", {})
+
+        # Copy parameters from params dict first (CLI format)
+        for key, value in params.items():
+            if isinstance(value, tuple):
+                value = list(value)
+            config[key] = value
+
+        # Copy all other parameters from the source data (flat format)
+        # This ensures we don't miss any surface-specific parameters
+        skip_keys = {
+            "type",
+            "name",
+            "role",
+            "front",
+            "back",
+            "front_medium",
+            "back_medium",
+            "params",
+        }
+        for key, value in surf_data.items():
+            if key not in skip_keys:
+                # Convert to list if it's a tuple for UI compatibility
+                if isinstance(value, tuple):
+                    value = list(value)
+                config[key] = value
+
+        # Normalize center -> point for surface types that use "point"
+        # (bounded_plane uses "point" but some YAMLs use "center")
+        if (
+            surface_type in ("bounded_plane", "plane")
+            and "center" in config
+            and "point" not in config
+        ):
+            config["point"] = config.pop("center")
+
+        return config
+
+    def _parse_detector_config(self, det_data: dict, index: int = 0) -> dict | None:
+        """Parse a detector configuration from loaded data."""
+        detector_type = det_data.get("type", "bounded_plane")
+
+        # Map CLI detector types to surface types
+        type_mapping = {
+            "planar": "bounded_plane",
+            "spherical": "sphere",
+        }
+        surface_type = type_mapping.get(detector_type, detector_type)
+
+        config = {
+            "type": surface_type,
+            "name": det_data.get("name", f"detector_{index}"),
+        }
+
+        # Handle CLI config format which uses nested "params" dict
+        params = det_data.get("params", {})
+
+        # Copy parameters from params dict first (CLI format)
+        for key, value in params.items():
+            if isinstance(value, tuple):
+                value = list(value)
+            config[key] = value
+
+        # Copy all other parameters from the source data (flat format)
+        skip_keys = {"type", "name", "params"}
+        for key, value in det_data.items():
+            if key not in skip_keys:
+                # Convert to list if it's a tuple for UI compatibility
+                if isinstance(value, tuple):
+                    value = list(value)
+                config[key] = value
+
+        # Normalize center -> point for detector types that use "point"
+        # (bounded_plane uses "point" but some YAMLs use "center")
+        if (
+            surface_type in ("bounded_plane", "plane")
+            and "center" in config
+            and "point" not in config
+        ):
+            config["point"] = config.pop("center")
+
+        return config
+
+    def _parse_source_config(self, source_data: dict) -> dict:
+        """Parse a source configuration from loaded data."""
+        source_type = source_data.get("type", "point")
+
+        # Map CLI source types to our internal types
+        type_mapping = {
+            "collimated_beam": "collimated",
+            "diverging_beam": "diverging",
+            "gaussian_beam": "gaussian",
+        }
+        internal_type = type_mapping.get(source_type, source_type)
+
+        # Handle CLI config format which uses nested "params" dict
+        params = source_data.get("params", {})
+
+        config = {
+            "type": internal_type,
+            "num_rays": params.get("num_rays", source_data.get("num_rays", 10000)),
+            "wavelength": params.get(
+                "wavelength", source_data.get("wavelength", 532e-9)
+            ),
+            "power": params.get("power", source_data.get("power", 1.0)),
+        }
+
+        # Copy parameters from params dict first (CLI format)
+        skip_keys = {"type", "num_rays", "wavelength", "power", "params"}
+        for key, value in params.items():
+            if key not in skip_keys:
+                if isinstance(value, tuple):
+                    value = list(value)
+                config[key] = value
+
+        # Copy all other parameters from the source data (flat format)
+        for key, value in source_data.items():
+            if key not in skip_keys:
+                # Convert to list if it's a tuple for UI compatibility
+                if isinstance(value, tuple):
+                    value = list(value)
+                config[key] = value
+
+        # Normalize position field - the UI uses "position" as the common field
+        # but different sources use different names (origin, center, etc.)
+        if "position" not in config:
+            for pos_key in ("origin", "center", "waist_position"):
+                if pos_key in config:
+                    config["position"] = config[pos_key]
+                    break
+            else:
+                config["position"] = [0.0, 0.0, 10.0]
+
+        # Handle beam_radius -> radius mapping
+        if "beam_radius" in config and "radius" not in config:
+            config["radius"] = config["beam_radius"]
+
+        return config
+
+    def _on_apply(self) -> None:
+        """Apply the current configuration to the scene."""
+        self._build_and_load_config()
+
+    def _on_reload_scene(self) -> None:
+        """Reload the scene: clear results and rebuild all geometry from config."""
+        from ..core.scene import ObjectType
+
+        # Clear simulation results from scene
+        to_remove = [
+            name
+            for name, obj in self.scene.objects.items()
+            if obj.obj_type in (ObjectType.RAY_PATHS, ObjectType.DETECTIONS)
+        ]
+        for name in to_remove:
+            self.scene.remove_object(name)
+
+        self.scene.result = None
+
+        # Rebuild and reload geometry and source
+        self._build_and_load_config()
+
+        print("[GUI] Scene reloaded")
+
+    def _update_simulate_status(
+        self, message: str, color: tuple = (128, 128, 128)
+    ) -> None:
+        """Update the simulation status text."""
+        if dpg.does_item_exist("simulate_status"):
+            dpg.set_value("simulate_status", message)
+            dpg.configure_item("simulate_status", color=color)
+        # Force a frame render to show the update immediately
+        dpg.render_dearpygui_frame()
+
+    def _on_simulate(self) -> None:
+        """Run the simulation by exporting to YAML and calling the CLI."""
+        import subprocess
+        import tempfile
+        import os
+        from pathlib import Path
+
+        # Show running status
+        self._update_simulate_status("Running simulation...", (100, 200, 255))
+
+        # Disable simulate button during run
+        if dpg.does_item_exist("simulate_btn"):
+            dpg.configure_item("simulate_btn", enabled=False)
+
+        # First apply the current config to update the 3D view
+        self._build_and_load_config()
+
+        # Get output settings
+        output_dir = (
+            Path(self._sim_config.get("output_directory", "./results"))
+            .expanduser()
+            .resolve()
+        )
+        output_prefix = self._sim_config.get("output_prefix", "simulation")
+        output_format = self._sim_config.get("output_format", "hdf5")
+
+        # Ensure output directory exists
+        output_dir.mkdir(parents=True, exist_ok=True)
+
+        # Export to temp YAML file
+        with tempfile.NamedTemporaryFile(mode="w", suffix=".yaml", delete=False) as f:
+            temp_path = f.name
+
+        stdout = ""
+        stderr = ""
+        return_code = 0
+
+        try:
+            self._export_to_yaml(temp_path)
+            print(f"[GUI] Exported config to {temp_path}")
+
+            # Run the CLI with output directory (no --no-save)
+            cmd = ["lsurf", "run", temp_path, "--output-dir", str(output_dir)]
+            print(f"[GUI] Running: {' '.join(cmd)}")
+
+            result = subprocess.run(
+                cmd,
+                capture_output=True,
+                text=True,
+                timeout=300,  # 5 minute timeout
+            )
+
+            stdout = result.stdout or ""
+            stderr = result.stderr or ""
+            return_code = result.returncode
+
+            # Print output to console as well
+            if stdout:
+                print(stdout)
+            if stderr:
+                print(f"[STDERR] {stderr}")
+
+            if return_code != 0:
+                print(f"[GUI] CLI exited with code {return_code}")
+            else:
+                # Try to load results for visualization
+                self._load_results_for_visualization(
+                    output_dir, output_prefix, output_format
+                )
+
+        except subprocess.TimeoutExpired:
+            stderr = "Simulation timed out after 5 minutes"
+            return_code = -1
+            print(f"[GUI] {stderr}")
+        except Exception as e:
+            stderr = f"Error running simulation: {e}"
+            return_code = -1
+            print(f"[GUI] {stderr}")
+        finally:
+            # Clean up temp file
+            try:
+                os.unlink(temp_path)
+            except Exception:
+                pass
+
+        # Display results in the results panel
+        if self.results_panel:
+            # Append debug info to stdout
+            debug_info = getattr(self, "_last_export_debug", "")
+            if debug_info:
+                stdout = stdout + "\n\n=== Exported Config ===\n" + debug_info
+            # Add output location info
+            stdout = stdout + f"\n\nResults saved to: {output_dir}"
+            self.results_panel.display_cli_output(stdout, stderr, return_code)
+
+        # Update status and re-enable button
+        if dpg.does_item_exist("simulate_btn"):
+            dpg.configure_item("simulate_btn", enabled=True)
+
+        if return_code == 0:
+            self._update_simulate_status("Simulation complete", (100, 255, 100))
+        else:
+            self._update_simulate_status("Simulation failed", (255, 100, 100))
+
+        # Note: We intentionally do NOT call on_simulate() here because
+        # we're using the CLI for simulation instead of the internal runner.
+        # Calling it would run the old simulation and overwrite our results.
+
+    def _load_results_for_visualization(
+        self, output_dir, output_prefix: str, output_format: str
+    ) -> None:
+        """Load simulation results from output files for visualization."""
+        import numpy as np
+
+        try:
+            from lsurf.detectors.results import DetectorResult
+
+            # The CLI saves in a custom format, not the DetectorResult format
+            # So we need to load manually and construct a DetectorResult
+
+            detected_file = None
+            positions = None
+            directions = None
+            intensities = None
+            times = None
+            wavelengths = None
+
+            # Try HDF5 format first
+            h5_file = output_dir / f"{output_prefix}_detected.h5"
+            if h5_file.exists():
+                try:
+                    import h5py
+
+                    with h5py.File(h5_file, "r") as f:
+                        positions = f["positions"][...]
+                        if "directions" in f:
+                            directions = f["directions"][...]
+                        if "intensities" in f:
+                            intensities = f["intensities"][...]
+                        if "times" in f:
+                            times = f["times"][...]
+                        if "wavelengths" in f:
+                            wavelengths = f["wavelengths"][...]
+                    detected_file = h5_file
+                except Exception as e:
+                    print(f"[GUI] Failed to load HDF5: {e}")
+
+            # Try numpy format
+            if positions is None:
+                npz_file = output_dir / f"{output_prefix}_detected.npz"
+                if npz_file.exists():
+                    data = np.load(npz_file)
+                    positions = data.get("positions")
+                    directions = data.get("directions")
+                    intensities = data.get("intensities")
+                    times = data.get("times")
+                    wavelengths = data.get("wavelengths")
+                    detected_file = npz_file
+
+            if positions is None or len(positions) == 0:
+                print(f"[GUI] No detected rays found in {output_dir}")
+                return
+
+            # Fill in defaults for missing data
+            num_rays = len(positions)
+            if directions is None or len(directions) == 0:
+                directions = np.zeros((num_rays, 3), dtype=np.float32)
+            if intensities is None or len(intensities) == 0:
+                intensities = np.ones(num_rays, dtype=np.float32)
+            if times is None or len(times) == 0:
+                times = np.zeros(num_rays, dtype=np.float32)
+            if wavelengths is None or len(wavelengths) == 0:
+                wavelengths = np.full(
+                    num_rays, 532e-9, dtype=np.float32
+                )  # Default green
+
+            # Create DetectorResult
+            detected = DetectorResult(
+                positions=positions.astype(np.float32),
+                directions=directions.astype(np.float32),
+                times=times.astype(np.float32),
+                intensities=intensities.astype(np.float32),
+                wavelengths=wavelengths.astype(np.float32),
+                detector_name="cli_results",
+            )
+
+            print(
+                f"[GUI] Loaded {detected.num_rays} detected rays from {detected_file}"
+            )
+            if self.visualization_panel:
+                self.visualization_panel.set_detected(detected)
+
+        except Exception as e:
+            print(f"[GUI] Failed to load results for visualization: {e}")
+            import traceback
+
+            traceback.print_exc()
+
+    def _on_export_yaml(self) -> None:
+        """Export configuration to YAML file."""
+
+        def callback(sender, app_data):
+            if app_data.get("file_path_name"):
+                self._export_to_yaml(app_data["file_path_name"])
+
+        with dpg.file_dialog(
+            callback=callback,
+            width=800,
+            height=500,
+            modal=True,
+            show=True,
+            default_filename="simulation.yaml",
+        ):
+            dpg.add_file_extension(".yaml")
+            dpg.add_file_extension(".yml")
+
+    def _on_add_surface(self) -> None:
+        """Add a new surface."""
+        # Offset each new surface so they don't overlap
+        index = len(self._surfaces)
+        z_offset = index * 5.0  # Stack surfaces 5 units apart in Z
+
+        self._surfaces.append(
+            {
+                "type": "bounded_plane",
+                "name": f"surface_{index}",
+                "role": "optical",
+                "front_medium": {"type": "vacuum", "refractive_index": 1.0},
+                "back_medium": {"type": "vacuum", "refractive_index": 1.0},
+                "point": [0.0, 0.0, z_offset],
+                "normal": [0.0, 0.0, 1.0],
+                "width": 10.0,
+                "height": 10.0,
+            }
+        )
+        self._rebuild_surfaces_ui()
+        self._build_and_load_config()
+
+    def _on_remove_surface(self, index: int) -> None:
+        """Remove a surface."""
+        if 0 <= index < len(self._surfaces):
+            del self._surfaces[index]
+            self._rebuild_surfaces_ui()
+            self._build_and_load_config()
+
+    def _on_surface_change(self, index: int, param: str, value: Any) -> None:
+        """Handle surface parameter change."""
+        if 0 <= index < len(self._surfaces):
+            self._surfaces[index][param] = value
+            self._build_and_load_config()
+
+    def _on_surface_vec_change(
+        self, index: int, param: str, component: int, value: float
+    ) -> None:
+        """Handle surface vector parameter change."""
+        if 0 <= index < len(self._surfaces):
+            if param not in self._surfaces[index]:
+                self._surfaces[index][param] = [0.0, 0.0, 0.0]
+            self._surfaces[index][param][component] = value
+            self._build_and_load_config()
+
+    def _on_surface_type_change(self, index: int, new_type: str) -> None:
+        """Handle surface type change."""
+        if 0 <= index < len(self._surfaces):
+            old = self._surfaces[index]
+            # Preserve common settings including medium configs
+            front_medium = old.get("front_medium", {"type": "vacuum"})
+            back_medium = old.get("back_medium", {"type": "vacuum"})
+            # Ensure they're dicts
+            if isinstance(front_medium, str):
+                front_medium = self._get_default_medium_config(front_medium)
+            if isinstance(back_medium, str):
+                back_medium = self._get_default_medium_config(back_medium)
+
+            self._surfaces[index] = {
+                "type": new_type,
+                "name": old.get("name", f"surface_{index}"),
+                "role": old.get("role", "optical"),
+                "front_medium": front_medium,
+                "back_medium": back_medium,
+            }
+            # Get defaults for new type dynamically
+            defaults = self.get_surface_defaults(new_type)
+            self._surfaces[index].update(defaults)
+
+            self._rebuild_surfaces_ui()
+            self._build_and_load_config()
+
+    def _on_add_detector(self) -> None:
+        """Add a new detector."""
+        # Offset each new detector so they don't overlap
+        index = len(self._detectors)
+        z_offset = 20.0 + index * 5.0  # Stack detectors 5 units apart starting at z=20
+
+        self._detectors.append(
+            {
+                "type": "plane",
+                "name": f"detector_{index}",
+                "point": [0.0, 0.0, z_offset],
+                "normal": [0.0, 0.0, -1.0],
+            }
+        )
+        self._rebuild_detectors_ui()
+        self._build_and_load_config()
+
+    def _on_remove_detector(self, index: int) -> None:
+        """Remove a detector."""
+        if 0 <= index < len(self._detectors):
+            del self._detectors[index]
+            self._rebuild_detectors_ui()
+            self._build_and_load_config()
+
+    def _on_detector_change(self, index: int, param: str, value: Any) -> None:
+        """Handle detector parameter change."""
+        if 0 <= index < len(self._detectors):
+            self._detectors[index][param] = value
+            self._build_and_load_config()
+
+    def _on_detector_vec_change(
+        self, index: int, param: str, component: int, value: float
+    ) -> None:
+        """Handle detector vector parameter change."""
+        if 0 <= index < len(self._detectors):
+            if param not in self._detectors[index]:
+                self._detectors[index][param] = [0.0, 0.0, 0.0]
+            self._detectors[index][param][component] = value
+            self._build_and_load_config()
+
+    def _on_detector_type_change(self, index: int, new_type: str) -> None:
+        """Handle detector type change."""
+        if 0 <= index < len(self._detectors):
+            old = self._detectors[index]
+            self._detectors[index] = {
+                "type": new_type,
+                "name": old.get("name", f"detector_{index}"),
+            }
+            # Get defaults for new type dynamically
+            defaults = self.get_surface_defaults(new_type)
+            self._detectors[index].update(defaults)
+
+            self._rebuild_detectors_ui()
+            self._build_and_load_config()
+
+    def _on_source_type_change(self, sender, value) -> None:
+        """Handle source type change."""
+        self._source_config["type"] = value
+        # Set defaults for new type dynamically
+        defaults = self.get_source_defaults(value)
+        for key, default_val in defaults.items():
+            self._source_config.setdefault(key, default_val)
+
+        self._update_source_type_params()
+        self._build_and_load_config()
+
+    def _on_source_param_change(
+        self, param: str, component: int | None, value: Any
+    ) -> None:
+        """Handle source parameter change."""
+        if component is not None:
+            if param not in self._source_config:
+                self._source_config[param] = [0.0, 0.0, 0.0]
+            self._source_config[param][component] = value
+        else:
+            self._source_config[param] = value
+        self._build_and_load_config()
+
+    def _on_sim_param_change(self, param: str, value: Any) -> None:
+        """Handle simulation parameter change."""
+        self._sim_config[param] = value
+
+    # === Medium Customization Methods ===
+
+    def _get_medium_params(self, medium_type: str) -> dict[str, Any]:
+        """Get editable parameters for a medium type by introspection."""
+        import inspect
+        import lsurf.materials as mat
+
+        params = {}
+
+        # Map simple type names to class names
+        type_to_class = {
+            "vacuum": "HomogeneousMaterial",
+            "air": "HomogeneousMaterial",
+            "water": "HomogeneousMaterial",
+            "glass": "HomogeneousMaterial",
+            "homogeneous_material": "HomogeneousMaterial",
+            "exponential_atmosphere": "ExponentialAtmosphere",
+            "duct_atmosphere": "DuctAtmosphere",
+        }
+
+        class_name = type_to_class.get(medium_type, self._snake_to_camel(medium_type))
+
+        if not hasattr(mat, class_name):
+            # Fallback for simple materials
+            return {"refractive_index": 1.0}
+
+        material_class = getattr(mat, class_name)
+
+        try:
+            sig = inspect.signature(material_class.__init__)
+            for param_name, param in sig.parameters.items():
+                if param_name in ("self", "kernel", "propagator", "name"):
+                    continue
+
+                # Get default value
+                if param.default != inspect.Parameter.empty:
+                    default_val = param.default
+                elif param_name == "refractive_index":
+                    default_val = 1.0
+                elif "n_sea_level" in param_name:
+                    default_val = 1.000293
+                elif "scale_height" in param_name:
+                    default_val = 8500.0
+                elif "earth_radius" in param_name:
+                    default_val = 6371000.0
+                elif "earth_center" in param_name or "center" in param_name:
+                    default_val = [0.0, 0.0, 0.0]
+                elif "coef" in param_name:
+                    default_val = 0.0
+                elif "altitude_range" in param_name:
+                    default_val = [0.0, 200000.0]
+                else:
+                    default_val = 0.0
+
+                # Convert tuples to lists for UI
+                if isinstance(default_val, tuple):
+                    default_val = list(default_val)
+
+                params[param_name] = default_val
+
+        except Exception:
+            params = {"refractive_index": 1.0}
+
+        return params
+
+    def _get_default_medium_config(self, medium_type: str) -> dict[str, Any]:
+        """Get a default medium config dict for a given type."""
+        # Predefined defaults
+        predefined = {
+            "vacuum": {"type": "vacuum", "refractive_index": 1.0},
+            "air": {"type": "air", "refractive_index": 1.000293},
+            "water": {"type": "water", "refractive_index": 1.333},
+            "glass": {"type": "glass", "refractive_index": 1.5},
+        }
+
+        if medium_type in predefined:
+            return predefined[medium_type].copy()
+
+        # For other types, get params via introspection
+        config = {"type": medium_type}
+        config.update(self._get_medium_params(medium_type))
+        return config
+
+    def _on_customize_medium(
+        self, surface_index: int, side: str, medium_config: dict[str, Any]
+    ) -> None:
+        """Open a popup to customize medium parameters.
+
+        Args:
+            surface_index: Index of the surface
+            side: "front" or "back"
+            medium_config: Current medium configuration dict
+        """
+        medium_type = medium_config.get("type", "vacuum")
+        title = f"Customize {side.title()} Medium ({medium_type})"
+
+        # Get parameters for this medium type
+        params = self._get_medium_params(medium_type)
+
+        # Create unique popup tag
+        popup_tag = f"medium_popup_{surface_index}_{side}"
+
+        # Delete existing popup if any
+        if dpg.does_item_exist(popup_tag):
+            dpg.delete_item(popup_tag)
+
+        # Store temp values for editing
+        temp_values = {}
+        for param_name, default_val in params.items():
+            temp_values[param_name] = medium_config.get(param_name, default_val)
+
+        def on_ok():
+            # Apply temp values to the surface config
+            if 0 <= surface_index < len(self._surfaces):
+                medium_key = f"{side}_medium"
+                new_config = {"type": medium_type}
+                new_config.update(temp_values)
+                self._surfaces[surface_index][medium_key] = new_config
+                self._build_and_load_config()
+            dpg.delete_item(popup_tag)
+
+        def on_cancel():
+            dpg.delete_item(popup_tag)
+
+        def make_scalar_callback(param_name: str):
+            def callback(sender, value):
+                temp_values[param_name] = value
+
+            return callback
+
+        def make_vec_callback(param_name: str, component: int):
+            def callback(sender, value):
+                if param_name not in temp_values:
+                    temp_values[param_name] = [0.0, 0.0, 0.0]
+                temp_values[param_name][component] = value
+
+            return callback
+
+        with dpg.window(
+            label=title,
+            modal=True,
+            tag=popup_tag,
+            width=400,
+            height=300,
+            pos=[200, 150],
+            no_resize=True,
+        ):
+            # Create parameter inputs
+            for param_name, default_val in params.items():
+                current_val = temp_values.get(param_name, default_val)
+                label = param_name.replace("_", " ").title()
+
+                if isinstance(current_val, list) and len(current_val) == 3:
+                    # 3D vector
+                    vec_labels = ["X", "Y", "Z"]
+                    for j in range(3):
+                        with dpg.group(horizontal=True):
+                            dpg.add_text(
+                                f"{label} {vec_labels[j]}:", color=(180, 180, 180)
+                            )
+                            dpg.add_input_float(
+                                default_value=current_val[j],
+                                callback=make_vec_callback(param_name, j),
+                                width=-1,
+                                format="%.6g",
+                            )
+                elif isinstance(current_val, list) and len(current_val) == 2:
+                    # 2D vector (range)
+                    vec_labels = ["Min", "Max"]
+                    for j in range(2):
+                        with dpg.group(horizontal=True):
+                            dpg.add_text(
+                                f"{label} {vec_labels[j]}:", color=(180, 180, 180)
+                            )
+                            dpg.add_input_float(
+                                default_value=current_val[j],
+                                callback=make_vec_callback(param_name, j),
+                                width=-1,
+                                format="%.6g",
+                            )
+                elif isinstance(current_val, bool):
+                    with dpg.group(horizontal=True):
+                        dpg.add_text(f"{label}:", color=(180, 180, 180))
+                        dpg.add_checkbox(
+                            default_value=current_val,
+                            callback=make_scalar_callback(param_name),
+                        )
+                elif isinstance(current_val, int) and not isinstance(current_val, bool):
+                    with dpg.group(horizontal=True):
+                        dpg.add_text(f"{label}:", color=(180, 180, 180))
+                        dpg.add_input_int(
+                            default_value=current_val,
+                            callback=make_scalar_callback(param_name),
+                            width=-1,
+                        )
+                elif isinstance(current_val, (int, float)):
+                    fmt = (
+                        "%.6g"
+                        if abs(current_val) > 10000
+                        or (current_val != 0 and abs(current_val) < 0.001)
+                        else "%.6f"
+                    )
+                    with dpg.group(horizontal=True):
+                        dpg.add_text(f"{label}:", color=(180, 180, 180))
+                        dpg.add_input_float(
+                            default_value=float(current_val),
+                            callback=make_scalar_callback(param_name),
+                            width=-1,
+                            format=fmt,
+                        )
+
+            dpg.add_separator()
+
+            # OK/Cancel buttons
+            with dpg.group(horizontal=True):
+                dpg.add_button(label="OK", callback=on_ok, width=100)
+                dpg.add_spacer(width=10)
+                dpg.add_button(label="Cancel", callback=on_cancel, width=100)
+
+    def _on_surface_front_medium_type_change(self, sender, app_data, user_data) -> None:
+        """Handle surface front medium type dropdown change."""
+        surface_index = user_data
+        if 0 <= surface_index < len(self._surfaces):
+            new_type = app_data
+            # Create new medium config with defaults for this type
+            new_config = self._get_default_medium_config(new_type)
+            self._surfaces[surface_index]["front_medium"] = new_config
+            self._build_and_load_config()
+
+    def _on_surface_back_medium_type_change(self, sender, app_data, user_data) -> None:
+        """Handle surface back medium type dropdown change."""
+        surface_index = user_data
+        if 0 <= surface_index < len(self._surfaces):
+            new_type = app_data
+            # Create new medium config with defaults for this type
+            new_config = self._get_default_medium_config(new_type)
+            self._surfaces[surface_index]["back_medium"] = new_config
+            self._build_and_load_config()
+
+    def _on_customize_front_medium_btn(self, sender, app_data, user_data) -> None:
+        """Handle customize front medium button click."""
+        surface_index = user_data
+        if 0 <= surface_index < len(self._surfaces):
+            medium_config = self._surfaces[surface_index].get(
+                "front_medium", {"type": "vacuum"}
+            )
+            # Ensure it's a dict
+            if isinstance(medium_config, str):
+                medium_config = self._get_default_medium_config(medium_config)
+            self._on_customize_medium(surface_index, "front", medium_config)
+
+    def _on_customize_back_medium_btn(self, sender, app_data, user_data) -> None:
+        """Handle customize back medium button click."""
+        surface_index = user_data
+        if 0 <= surface_index < len(self._surfaces):
+            medium_config = self._surfaces[surface_index].get(
+                "back_medium", {"type": "vacuum"}
+            )
+            # Ensure it's a dict
+            if isinstance(medium_config, str):
+                medium_config = self._get_default_medium_config(medium_config)
+            self._on_customize_medium(surface_index, "back", medium_config)
+
+    # === Geometry Validation ===
+
+    def _on_check_geometry(self) -> None:
+        """Validate geometry and show warnings."""
+        warnings = []
+
+        # Check all optical surfaces have media
+        for i, surf in enumerate(self._surfaces):
+            if surf.get("role") == "optical":
+                front = surf.get("front_medium")
+                back = surf.get("back_medium")
+
+                if not front:
+                    warnings.append(
+                        f"Surface '{surf.get('name', f'surface_{i}')}' missing front medium"
+                    )
+                if not back:
+                    warnings.append(
+                        f"Surface '{surf.get('name', f'surface_{i}')}' missing back medium"
+                    )
+
+        # Create popup to show results
+        popup_tag = "check_geometry_popup"
+        if dpg.does_item_exist(popup_tag):
+            dpg.delete_item(popup_tag)
+
+        def on_close():
+            dpg.delete_item(popup_tag)
+
+        with dpg.window(
+            label="Geometry Check",
+            modal=True,
+            tag=popup_tag,
+            width=400,
+            height=200,
+            pos=[200, 150],
+            no_resize=True,
+        ):
+            if warnings:
+                dpg.add_text("Warnings:", color=(255, 200, 100))
+                dpg.add_separator()
+                for warning in warnings:
+                    dpg.add_text(f"  \u26a0 {warning}", color=(255, 200, 100))
+            else:
+                dpg.add_text("\u2713 Geometry OK", color=(100, 255, 100))
+                dpg.add_separator()
+                dpg.add_text(
+                    f"  {len(self._surfaces)} surface(s) configured",
+                    color=(150, 150, 150),
+                )
+                dpg.add_text(
+                    f"  {len(self._detectors)} detector(s) configured",
+                    color=(150, 150, 150),
+                )
+
+            dpg.add_separator()
+            dpg.add_button(label="Close", callback=on_close, width=-1)
+
+    # === Build and Export ===
+
+    def _build_and_load_config(self) -> None:
+        """Build geometry and source from current config and load into scene."""
+        try:
+            geometry = self._build_geometry()
+            if geometry:
+                print(
+                    f"[GUI] Built geometry with {len(geometry.surfaces)} surfaces, {len(geometry.detectors)} detectors"
+                )
+                self.scene.load_geometry(geometry)
+            else:
+                print("[GUI] No geometry built (no surfaces/detectors)")
+
+            source = self._build_source()
+            if source:
+                print(f"[GUI] Built source: {type(source).__name__}")
+                self.scene.load_source(source)
+            else:
+                print("[GUI] No source built")
+
+            if self.on_config_change:
+                self.on_config_change()
+
+        except Exception as e:
+            import traceback
+
+            print(f"Error building config: {e}")
+            traceback.print_exc()
+
+    def _build_geometry(self):
+        """Build a Geometry object from current config."""
+        from lsurf.geometry import GeometryBuilder
+        from lsurf.materials import AIR_STP, BK7_GLASS, VACUUM, WATER
+        from lsurf.surfaces import SurfaceRole
+
+        builder = GeometryBuilder()
+
+        # Register predefined materials for simple type names
+        predefined_materials = {
+            "vacuum": VACUUM,
+            "air": AIR_STP,
+            "air_stp": AIR_STP,
+            "water": WATER,
+            "glass": BK7_GLASS,
+            "bk7_glass": BK7_GLASS,
+            "bk7": BK7_GLASS,
+        }
+
+        for name, material in predefined_materials.items():
+            builder.register_medium(name, material)
+
+        # Always use vacuum as background
+        builder.set_background("vacuum")
+
+        # Add surfaces - build materials inline from surface configs
+        medium_counter = 0
+        for surf_config in self._surfaces:
+            role_str = surf_config.get("role", "optical")
+            if role_str == "optical":
+                role = SurfaceRole.OPTICAL
+            else:
+                role = SurfaceRole.ABSORBER
+
+            surface = self._create_surface(surf_config, role)
+            if surface:
+                # Get front/back medium configs (could be string or dict)
+                front_config = surf_config.get("front_medium", {"type": "vacuum"})
+                back_config = surf_config.get("back_medium", {"type": "vacuum"})
+
+                # Convert string to dict if needed
+                if isinstance(front_config, str):
+                    front_config = {"type": front_config}
+                if isinstance(back_config, str):
+                    back_config = {"type": back_config}
+
+                # Build and register materials with unique names
+                front_name = self._register_inline_medium(
+                    builder, front_config, predefined_materials, medium_counter
+                )
+                medium_counter += 1
+                back_name = self._register_inline_medium(
+                    builder, back_config, predefined_materials, medium_counter
+                )
+                medium_counter += 1
+
+                builder.add_surface(surface, front_name, back_name)
+
+        # Add detectors
+        for det_config in self._detectors:
+            detector = self._create_surface(det_config, SurfaceRole.DETECTOR)
+            if detector:
+                builder.add_detector(detector)
+
+        return builder.build()
+
+    def _register_inline_medium(
+        self, builder, medium_config: dict, predefined: dict, counter: int
+    ) -> str:
+        """Register a medium from inline config and return its name.
+
+        For simple predefined types with no customizations, returns the predefined name.
+        For customized materials, builds and registers them with a unique name.
+        """
+        medium_type = medium_config.get("type", "vacuum")
+
+        # Check if this is a simple predefined type with no customizations
+        if medium_type in predefined:
+            # Check if there are any non-default custom parameters
+            default_config = self._get_default_medium_config(medium_type)
+            has_customization = False
+            for key, value in medium_config.items():
+                if key == "type":
+                    continue
+                if key in default_config and default_config[key] != value:
+                    has_customization = True
+                    break
+
+            if not has_customization:
+                return medium_type
+
+        # Build custom material
+        material = self._build_material(medium_config)
+        if material:
+            # Register with unique name
+            unique_name = f"_inline_medium_{counter}"
+            builder.register_medium(unique_name, material)
+            return unique_name
+
+        # Fallback to vacuum
+        return "vacuum"
+
+    def _create_surface(self, config: dict, role):
+        """Create a surface from config dict dynamically."""
+        import inspect
+        import lsurf.surfaces as surf
+
+        surface_type = config["type"]
+        name = config.get("name", "unnamed")
+
+        # Handle gpu_ prefix specially - strip it and prepend GPU to class name
+        if surface_type.startswith("gpu_"):
+            base_type = surface_type[4:]  # Remove "gpu_" prefix
+            class_name = "GPU" + self._snake_to_camel(base_type) + "Surface"
+            gpu_class_name = class_name  # Already GPU
+            non_gpu_class_name = self._snake_to_camel(base_type) + "Surface"
+        else:
+            class_name = self._snake_to_camel(surface_type) + "Surface"
+            gpu_class_name = "GPU" + class_name
+            non_gpu_class_name = class_name
+
+        # Check if this is a wave surface
+        is_wave = "wave" in surface_type.lower()
+
+        # For wave surfaces, prefer GPU version (has individual params instead of wave_params)
+        if is_wave:
+            candidates = [gpu_class_name, non_gpu_class_name]
+        else:
+            candidates = [class_name, gpu_class_name]
+
+        # Try to find the class
+        surface_class = None
+        for candidate in candidates:
+            if hasattr(surf, candidate):
+                surface_class = getattr(surf, candidate)
+                break
+
+        if surface_class is None:
+            print(f"[GUI] Unknown surface type: {surface_type} (tried {candidates})")
+            return None
+
+        try:
+            print(f"[GUI] Creating {surface_class.__name__} with config: {config}")
+            # Get constructor signature
+            sig = inspect.signature(surface_class.__init__)
+
+            # Build kwargs from config, matching parameter names
+            kwargs = {"role": role, "name": name}
+
+            # Check if this class expects wave_params instead of individual parameters
+            uses_wave_params = "wave_params" in sig.parameters
+
+            if uses_wave_params:
+                # Build wave_params from individual config values
+                wave_params = self._build_wave_params(config)
+                if wave_params:
+                    kwargs["wave_params"] = wave_params
+
+            for param_name, param in sig.parameters.items():
+                if param_name in ("self", "role", "name", "wave_params"):
+                    continue
+
+                # Check if we have this parameter in config
+                if param_name in config:
+                    value = config[param_name]
+                    # Convert lists to tuples for vector params
+                    if isinstance(value, list):
+                        value = tuple(value)
+                    kwargs[param_name] = value
+                elif param.default == inspect.Parameter.empty:
+                    # Required parameter not in config - try common mappings
+                    if param_name == "point" and "center" in config:
+                        kwargs[param_name] = tuple(config["center"])
+                    elif param_name == "center" and "point" in config:
+                        kwargs[param_name] = tuple(config["point"])
+
+            return surface_class(**kwargs)
+
+        except Exception as e:
+            import traceback
+
+            print(f"Error creating surface {surface_type}: {e}")
+            traceback.print_exc()
+            return None
+
+    def _build_wave_params(self, config: dict):
+        """Build a list of GerstnerWaveParams objects from config values.
+
+        Non-GPU wave surfaces expect a list of wave params for multiple wave components.
+        The GUI edits a single wave, so we return a list with one element.
+        """
+        try:
+            from lsurf.surfaces import GerstnerWaveParams
+
+            amplitude = config.get("amplitude", 1.0)
+            wavelength = config.get("wavelength", 10.0)
+            direction = config.get("direction", [1.0, 0.0])
+            phase = config.get("phase", 0.0)
+            steepness = config.get("steepness", 0.0)
+
+            if isinstance(direction, list):
+                direction = tuple(direction)
+
+            wave_param = GerstnerWaveParams(
+                amplitude=amplitude,
+                wavelength=wavelength,
+                direction=direction,
+                phase=phase,
+                steepness=steepness,
+            )
+            # Return as list since non-GPU wave surfaces expect list[GerstnerWaveParams]
+            return [wave_param]
+        except Exception as e:
+            print(f"Error building wave params: {e}")
+            return None
+
+    def _build_material(self, config: dict):
+        """Build a material object from config dict dynamically."""
+        import inspect
+        import lsurf.materials as mat
+
+        material_type = config.get("type", "homogeneous_material")
+
+        # Convert snake_case to CamelCase class name
+        class_name = self._snake_to_camel(material_type)
+
+        if not hasattr(mat, class_name):
+            print(f"[GUI] Unknown material type: {material_type} (tried {class_name})")
+            # Fallback to HomogeneousMaterial
+            from lsurf.materials import HomogeneousMaterial
+
+            return HomogeneousMaterial(
+                name=config.get("name", "custom"),
+                refractive_index=config.get("refractive_index", 1.0),
+            )
+
+        material_class = getattr(mat, class_name)
+
+        try:
+            print(f"[GUI] Creating {class_name} with config: {config}")
+            sig = inspect.signature(material_class.__init__)
+
+            # Build kwargs from config
+            kwargs = {}
+
+            for param_name, param in sig.parameters.items():
+                if param_name in ("self", "kernel", "propagator"):
+                    continue
+
+                if param_name in config:
+                    value = config[param_name]
+                    # Convert lists to tuples for vector params
+                    if isinstance(value, list):
+                        value = tuple(value)
+                    kwargs[param_name] = value
+                elif param.default == inspect.Parameter.empty:
+                    # Required parameter - try to provide sensible default
+                    if param_name == "name":
+                        kwargs[param_name] = config.get("name", material_type)
+                    elif param_name == "refractive_index":
+                        kwargs[param_name] = 1.0
+
+            return material_class(**kwargs)
+
+        except Exception as e:
+            import traceback
+
+            print(f"Error creating material {material_type}: {e}")
+            traceback.print_exc()
+            return None
+
+    def _build_source(self):
+        """Build a RaySource from current config dynamically."""
+        import inspect
+        import lsurf.sources as src
+
+        source_type = self._source_config["type"]
+
+        # Map source type names to class names
+        class_name_map = {
+            "point": "PointSource",
+            "collimated": "CollimatedBeam",
+            "diverging": "DivergingBeam",
+            "uniform_diverging": "UniformDivergingBeam",
+            "gaussian": "GaussianBeam",
+        }
+
+        # Get class name
+        if source_type in class_name_map:
+            class_name = class_name_map[source_type]
+        else:
+            # Try to construct class name
+            class_name = self._snake_to_camel(source_type)
+            if not class_name.endswith(("Source", "Beam")):
+                class_name += "Source"
+
+        if not hasattr(src, class_name):
+            print(f"Unknown source type: {source_type}")
+            return None
+
+        source_class = getattr(src, class_name)
+
+        try:
+            # Get constructor signature
+            sig = inspect.signature(source_class.__init__)
+
+            # Build kwargs from config, matching parameter names
+            kwargs = {}
+
+            # Common parameters
+            kwargs["num_rays"] = self._source_config.get("num_rays", 10000)
+            kwargs["wavelength"] = self._source_config.get("wavelength", 532e-9)
+            kwargs["power"] = self._source_config.get("power", 1.0)
+
+            for param_name, param in sig.parameters.items():
+                if param_name in ("self", "num_rays", "wavelength", "power"):
+                    continue
+
+                # Map common UI field "position" to various parameter names
+                if param_name in ("position", "origin", "center", "waist_position"):
+                    value = self._source_config.get("position", [0, 0, 10])
+                    kwargs[param_name] = tuple(value)
+                elif param_name in ("direction", "mean_direction"):
+                    value = self._source_config.get("direction", [0, 0, -1])
+                    kwargs[param_name] = tuple(value)
+                elif param_name == "divergence_angle":
+                    # Convert degrees to radians
+                    value = self._source_config.get("divergence_angle", 10.0)
+                    kwargs[param_name] = np.radians(value)
+                elif param_name in self._source_config:
+                    value = self._source_config[param_name]
+                    if isinstance(value, list):
+                        value = tuple(value)
+                    kwargs[param_name] = value
+                elif param.default != inspect.Parameter.empty:
+                    # Use default from signature
+                    pass  # Will use class default
+                else:
+                    # Required parameter not found - try to provide sensible default
+                    if "radius" in param_name:
+                        kwargs[param_name] = 1.0
+
+            return source_class(**kwargs)
+
+        except Exception as e:
+            print(f"Error creating source {source_type}: {e}")
+            return None
+
+    def _export_to_yaml(self, filepath: str) -> None:
+        """Export current configuration to YAML file (CLI-compatible format)."""
+        import yaml
+
+        # Map GUI source types to CLI source types
+        source_type_map = {
+            "point": "point",
+            "collimated": "collimated_beam",
+            "diverging": "diverging_beam",
+            "uniform_diverging": "diverging_beam",
+            "gaussian": "gaussian_beam",
+        }
+
+        # Map GUI detector types to CLI detector types
+        detector_type_map = {
+            "plane": "planar",
+            "bounded_plane": "planar",
+            "sphere": "spherical",
+        }
+
+        def normalize_medium_type(medium_type: str) -> str:
+            """Normalize GUI medium type to CLI-compatible type."""
+            # Strip numeric suffixes like _0, _1, etc.
+            import re
+
+            base_type = re.sub(r"_\d+$", "", medium_type)
+
+            # Map to CLI types
+            type_map = {
+                "air_stp": "air",
+                "air": "air",
+                "vacuum": "vacuum",
+                "water": "water",
+                "glass": "glass",
+                "bk7_glass": "glass",
+                "bk7": "glass",
+                "homogeneous": "homogeneous",
+                "exponential_atmosphere": "exponential_atmosphere",
+                "duct_atmosphere": "duct_atmosphere",
+            }
+
+            # Try exact match first
+            if base_type in type_map:
+                return type_map[base_type]
+
+            # Try prefix matching for variants
+            for key, value in type_map.items():
+                if base_type.startswith(key):
+                    return value
+
+            # Default: return as-is (may fail CLI validation)
+            return base_type
+
+        # Separate simulation config from output config
+        sim_config_for_export = {
+            k: v
+            for k, v in self._sim_config.items()
+            if k not in ("output_directory", "output_prefix", "output_format")
+        }
+
+        config = {
+            "media": {
+                "vacuum": {
+                    "type": "vacuum"
+                },  # Always include vacuum as it's the background
+            },
+            "background": "vacuum",
+            "surfaces": [],
+            "detectors": [],
+            "source": {},
+            "simulation": sim_config_for_export,
+            "output": {
+                "directory": self._sim_config.get("output_directory", "./results"),
+                "prefix": self._sim_config.get("output_prefix", "simulation"),
+                "format": self._sim_config.get("output_format", "hdf5"),
+                "save_statistics": True,
+            },
+        }
+
+        # Collect unique media and add to media section
+        media_counter = 0
+        media_name_map = {}  # Map from (type, params_hash) to media name
+
+        def get_or_create_medium_name(medium_config: dict | str) -> str:
+            """Get or create a unique medium name for this config."""
+            nonlocal media_counter
+
+            if isinstance(medium_config, str):
+                medium_type = medium_config
+                params = {}
+            else:
+                medium_type = medium_config.get("type", "vacuum")
+                # Filter out params that should use CLI defaults
+                skip_params = {
+                    "type",
+                    "refractive_index",
+                }  # Let CLI use correct defaults
+                params = {
+                    k: v for k, v in medium_config.items() if k not in skip_params
+                }
+
+            # Map to CLI-compatible type
+            cli_type = normalize_medium_type(medium_type)
+
+            # For simple predefined types, always use the type name (let CLI use defaults)
+            if cli_type in ("vacuum", "air", "water", "glass"):
+                if cli_type not in config["media"]:
+                    config["media"][cli_type] = {"type": cli_type}
+                return cli_type
+
+            # Create a key for this medium config
+            params_key = str(sorted(params.items()))
+            cache_key = (cli_type, params_key)
+
+            if cache_key in media_name_map:
+                return media_name_map[cache_key]
+
+            # Create new medium entry
+            media_name = f"{cli_type}_{media_counter}"
+            media_counter += 1
+            config["media"][media_name] = {"type": cli_type, "params": params}
+            media_name_map[cache_key] = media_name
+            return media_name
+
+        # Add surfaces (CLI expects params in nested dict)
+        for surf in self._surfaces:
+            # Get medium names (strings for CLI)
+            front_medium = surf.get("front_medium", {"type": "vacuum"})
+            back_medium = surf.get("back_medium", {"type": "vacuum"})
+            front_name = get_or_create_medium_name(front_medium)
+            back_name = get_or_create_medium_name(back_medium)
+
+            # Collect surface params (everything except type/name/role/media)
+            skip_keys = {"type", "name", "role", "front_medium", "back_medium"}
+            params = {k: v for k, v in surf.items() if k not in skip_keys}
+
+            surf_config = {
+                "name": surf.get("name", "surface"),
+                "type": surf["type"],
+                "role": surf.get("role", "optical"),
+                "front_medium": front_name,
+                "back_medium": back_name,
+                "params": params,
+            }
+            config["surfaces"].append(surf_config)
+
+        # Add detectors (CLI uses different type names and param names)
+        for det in self._detectors:
+            det_type = det["type"]
+            cli_type = detector_type_map.get(det_type, "planar")
+
+            # Build detector params with correct CLI names
+            if cli_type == "planar":
+                params = {
+                    "center": det.get("point", det.get("center", [0, 0, 0])),
+                    "normal": det.get("normal", [0, 0, 1]),
+                    "width": det.get("width", 10.0),
+                    "height": det.get("height", 10.0),
+                }
+            elif cli_type == "spherical":
+                params = {
+                    "center": det.get("center", [0, 0, 0]),
+                    "radius": det.get("radius", 1.0),
+                }
+            else:
+                skip_keys = {"type", "name"}
+                params = {k: v for k, v in det.items() if k not in skip_keys}
+
+            det_config = {
+                "name": det.get("name", "detector"),
+                "type": cli_type,
+                "params": params,
+            }
+            config["detectors"].append(det_config)
+
+        # Add source (CLI uses different type names and nested params)
+        source_type = self._source_config["type"]
+        cli_source_type = source_type_map.get(source_type, source_type)
+
+        source_params = {
+            "num_rays": self._source_config.get("num_rays", 10000),
+            "wavelength": self._source_config.get("wavelength", 532e-9),
+            "power": self._source_config.get("power", 1.0),
+        }
+
+        if source_type == "point":
+            source_params["position"] = self._source_config.get("position", [0, 0, 10])
+        elif source_type == "collimated":
+            source_params["center"] = self._source_config.get("position", [0, 0, 10])
+            source_params["direction"] = self._source_config.get(
+                "direction", [0, 0, -1]
+            )
+            source_params["beam_radius"] = self._source_config.get("radius", 1.0)
+        elif source_type == "gaussian":
+            source_params["waist_position"] = self._source_config.get(
+                "position", [0, 0, 10]
+            )
+            source_params["direction"] = self._source_config.get(
+                "direction", [0, 0, -1]
+            )
+            source_params["waist_radius"] = self._source_config.get(
+                "waist_radius", 0.001
+            )
+        elif source_type in ("diverging", "uniform_diverging"):
+            source_params["origin"] = self._source_config.get("position", [0, 0, 10])
+            source_params["mean_direction"] = self._source_config.get(
+                "direction", [0, 0, -1]
+            )
+            # Convert degrees to radians for CLI (sources expect radians)
+            divergence_deg = self._source_config.get("divergence_angle", 10.0)
+            source_params["divergence_angle"] = float(np.radians(divergence_deg))
+
+        config["source"] = {
+            "type": cli_source_type,
+            "params": source_params,
+        }
+
+        with open(filepath, "w") as f:
+            yaml.dump(config, f, default_flow_style=False, sort_keys=False)
+
+        # Also save a copy to a known location for debugging
+        debug_path = "/tmp/lsurf_gui_last_export.yaml"
+        with open(debug_path, "w") as f:
+            yaml.dump(config, f, default_flow_style=False, sort_keys=False)
+
+        self._last_export_debug = f"Config saved to: {debug_path}"