Enable unwind panics & hardened GPU init

Author: richiemcilroy

Cargo.toml

@@ -96,7 +96,7 @@ manual_clamp = "deny"
 
 # Optimize for smaller binary size
 [profile.release]
-panic = "abort"   # Strip expensive panic clean-up logic
+panic = "unwind"
 codegen-units = 1 # Compile crates one after another so the compiler can optimize better
 lto = true        # Enables link to optimizations
 opt-level = "s"   # Optimize for binary size

apps/desktop/src-tauri/src/gpu_context.rs

@@ -47,61 +47,85 @@ pub struct SharedGpuContext {
 
 static GPU: OnceCell<Option<SharedGpuContext>> = OnceCell::const_new();
 
-pub async fn get_shared_gpu() -> Option<&'static SharedGpuContext> {
-    GPU.get_or_init(|| async {
-        let instance = wgpu::Instance::new(&wgpu::InstanceDescriptor::default());
+async fn init_gpu_inner() -> Option<SharedGpuContext> {
+    let instance = wgpu::Instance::new(&wgpu::InstanceDescriptor::default());
+
+    let hardware_adapter = instance
+        .request_adapter(&wgpu::RequestAdapterOptions {
+            power_preference: wgpu::PowerPreference::HighPerformance,
+            force_fallback_adapter: false,
+            compatible_surface: None,
+        })
+        .await
+        .ok();
 
-        let hardware_adapter = instance
+    let (adapter, is_software_adapter) = if let Some(adapter) = hardware_adapter {
+        tracing::info!(
+            adapter_name = adapter.get_info().name,
+            adapter_backend = ?adapter.get_info().backend,
+            "Using hardware GPU adapter for shared context"
+        );
+        (adapter, false)
+    } else {
+        tracing::warn!(
+            "No hardware GPU adapter found, attempting software fallback for shared context"
+        );
+        let software_adapter = instance
             .request_adapter(&wgpu::RequestAdapterOptions {
-                power_preference: wgpu::PowerPreference::HighPerformance,
-                force_fallback_adapter: false,
+                power_preference: wgpu::PowerPreference::LowPower,
+                force_fallback_adapter: true,
                 compatible_surface: None,
             })
             .await
-            .ok();
-
-        let (adapter, is_software_adapter) = if let Some(adapter) = hardware_adapter {
-            tracing::info!(
-                adapter_name = adapter.get_info().name,
-                adapter_backend = ?adapter.get_info().backend,
-                "Using hardware GPU adapter for shared context"
-            );
-            (adapter, false)
-        } else {
-            tracing::warn!("No hardware GPU adapter found, attempting software fallback for shared context");
-            let software_adapter = instance
-                .request_adapter(&wgpu::RequestAdapterOptions {
-                    power_preference: wgpu::PowerPreference::LowPower,
-                    force_fallback_adapter: true,
-                    compatible_surface: None,
-                })
-                .await
-                .ok()?;
-
-            tracing::info!(
-                adapter_name = software_adapter.get_info().name,
-                adapter_backend = ?software_adapter.get_info().backend,
-                "Using software adapter for shared context (CPU rendering - performance may be reduced)"
-            );
-            (software_adapter, true)
-        };
-
-        let (device, queue) = adapter
-            .request_device(&wgpu::DeviceDescriptor {
-                label: Some("cap-shared-gpu-device"),
-                required_features: wgpu::Features::empty(),
-                ..Default::default()
-            })
-            .await
             .ok()?;
 
-        Some(SharedGpuContext {
-            device: Arc::new(device),
-            queue: Arc::new(queue),
-            adapter: Arc::new(adapter),
-            instance: Arc::new(instance),
-            is_software_adapter,
+        tracing::info!(
+            adapter_name = software_adapter.get_info().name,
+            adapter_backend = ?software_adapter.get_info().backend,
+            "Using software adapter for shared context (CPU rendering - performance may be reduced)"
+        );
+        (software_adapter, true)
+    };
+
+    let (device, queue) = adapter
+        .request_device(&wgpu::DeviceDescriptor {
+            label: Some("cap-shared-gpu-device"),
+            required_features: wgpu::Features::empty(),
+            ..Default::default()
         })
+        .await
+        .ok()?;
+
+    Some(SharedGpuContext {
+        device: Arc::new(device),
+        queue: Arc::new(queue),
+        adapter: Arc::new(adapter),
+        instance: Arc::new(instance),
+        is_software_adapter,
+    })
+}
+
+pub async fn get_shared_gpu() -> Option<&'static SharedGpuContext> {
+    GPU.get_or_init(|| async {
+        let result = tokio::spawn(init_gpu_inner()).await;
+
+        match result {
+            Ok(ctx) => ctx,
+            Err(e) => {
+                if e.is_panic() {
+                    tracing::error!(
+                        "GPU initialization panicked (wgpu internal error). \
+                         The app will continue without GPU acceleration."
+                    );
+                } else {
+                    tracing::error!(
+                        error = %e,
+                        "GPU initialization task failed"
+                    );
+                }
+                None
+            }
+        }
     })
     .await
     .as_ref()