fix: prefer the high-performance GPU on dual-GPU Macs

GPUI's Metal renderer sorted devices for low power and therefore always picked the Intel integrated GPU on Intel Macs with a discrete AMD GPU, even though the app declares NSSupportsAutomaticGraphicsSwitching=false. The UI was rendered and composited on the iGPU.

Carry a GPUI patch that selects the high-performance device by default, with CAP_GPU_PREFERENCE=low|integrated|battery and system|auto overrides. Apply the same preference to the Windows DXGI adapter and to Cap's wgpu devices (including camera blur) so the renderer, preview and encoders agree.

Add NSSupportsAutomaticGraphicsSwitching=false to the GPUI Info.plist, the change originally proposed for the Tauri app in #1759.

Author: AasishDairelSahayaGrinspan

apps/desktop-gpui/Info.plist

@@ -29,5 +29,7 @@
 	<string>Cap captures your screen as part of recording your Caps</string>
 	<key>NSCameraUseContinuityCameraDeviceType</key>
 	<true/>
+	<key>NSSupportsAutomaticGraphicsSwitching</key>
+	<false/>
 </dict>
 </plist>

apps/desktop-gpui/README.md

@@ -20,6 +20,10 @@ cargo run
 `RUST_LOG=cap_gpui=debug cargo run` for logs — note the filter is `cap_gpui`
 (the binary), not `cap_desktop_gpui` (the package).
 
+On dual-GPU Macs the renderer and every `cap-rendering` wgpu device pick the
+high-performance GPU. `CAP_GPU_PREFERENCE=low` (or `integrated`/`battery`)
+selects the integrated GPU instead, and `system` lets the platform choose.
+
 The first build takes about 11 minutes and 6.4 GB of `target/`: gpui pulls its
 own revisions of the wgpu and font stacks. After that, an edit rebuilds only
 the app crate, at `opt-level = 0` and incrementally, in about 22s with plain
@@ -797,8 +801,9 @@ sampling UV, the legacy page flips the canvas with `scaleX(-1)`; neither app
 ever mirrors the recorded camera track).
 
 Background blur runs live on preview frames through `src/camera_blur.rs`: a
-dedicated `camera-blur` thread owns its own wgpu device (requested the way the
-Tauri preview requests one — LowPower, downlevel limits) and runs the exact
+dedicated `camera-blur` thread owns its own wgpu device (requested through
+`cap_rendering::gpu_power_preference` like every other renderer and encoder —
+high-performance by default, downlevel limits) and runs the exact
 `cap_camera_effects::BlurProcessor` the recording's project config points the
 editor at, with the Tauri preview's 640×360 input cap and 150ms inference
 interval. The converter downscales to the cap inside the same hardware

apps/desktop-gpui/patches/zed-gpu-preference.patch

@@ -0,0 +1,81 @@
+diff --git a/crates/gpui_macos/src/metal_renderer.rs b/crates/gpui_macos/src/metal_renderer.rs
+--- a/crates/gpui_macos/src/metal_renderer.rs
++++ b/crates/gpui_macos/src/metal_renderer.rs
+@@ -246,14 +246,32 @@
+     }
+ 
+     fn create_device() -> Result<metal::Device> {
+-        // Prefer low‐power integrated GPUs on Intel Mac. On Apple
+-        // Silicon, there is only ever one GPU, so this is equivalent to
+-        // `metal::Device::system_default()`.
+-        if let Some(d) = metal::Device::all()
+-            .into_iter()
+-            .min_by_key(|d| (d.is_removable(), !d.is_low_power()))
+-        {
+-            Ok(d)
++        let preference = std::env::var("CAP_GPU_PREFERENCE")
++            .unwrap_or_default()
++            .to_ascii_lowercase();
++        if matches!(preference.as_str(), "system" | "auto") {
++            if let Some(device) = metal::Device::system_default() {
++                log::info!("selected system Metal device: {}", device.name());
++                return Ok(device);
++            }
++        }
++        let prefer_low_power = matches!(preference.as_str(), "low" | "integrated" | "battery");
++        if let Some(device) = metal::Device::all().into_iter().min_by_key(|device| {
++            (
++                device.is_removable(),
++                if prefer_low_power {
++                    !device.is_low_power()
++                } else {
++                    device.is_low_power()
++                },
++            )
++        }) {
++            log::info!(
++                "selected Metal device: {} (low_power={})",
++                device.name(),
++                device.is_low_power()
++            );
++            Ok(device)
+         } else {
+             // For some reason `all()` can return an empty list, see https://github.com/zed-industries/zed/issues/37689
+             // In that case, we fall back to the system default device.
+diff --git a/crates/gpui_windows/src/directx_devices.rs b/crates/gpui_windows/src/directx_devices.rs
+--- a/crates/gpui_windows/src/directx_devices.rs
++++ b/crates/gpui_windows/src/directx_devices.rs
+@@ -15,11 +15,11 @@
+         },
+         Dxgi::{
+             CreateDXGIFactory2, DXGI_CREATE_FACTORY_DEBUG, DXGI_CREATE_FACTORY_FLAGS,
+-            IDXGIAdapter1, IDXGIFactory6,
++            DXGI_GPU_PREFERENCE_HIGH_PERFORMANCE, DXGI_GPU_PREFERENCE_MINIMUM_POWER,
++            DXGI_GPU_PREFERENCE_UNSPECIFIED, IDXGIAdapter1, IDXGIFactory6,
+         },
+     },
+ };
+-use windows::core::Interface;
+ 
+ pub(crate) fn try_to_recover_from_device_lost<T>(mut f: impl FnMut() -> Result<T>) -> Result<T> {
+     (0..5)
+@@ -112,8 +112,18 @@
+     ID3D11DeviceContext,
+     D3D_FEATURE_LEVEL,
+ )> {
++    let gpu_preference = match std::env::var("CAP_GPU_PREFERENCE")
++        .unwrap_or_default()
++        .to_ascii_lowercase()
++        .as_str()
++    {
++        "low" | "integrated" | "battery" => DXGI_GPU_PREFERENCE_MINIMUM_POWER,
++        "system" | "auto" => DXGI_GPU_PREFERENCE_UNSPECIFIED,
++        _ => DXGI_GPU_PREFERENCE_HIGH_PERFORMANCE,
++    };
+     for adapter_index in 0.. {
+-        let adapter: IDXGIAdapter1 = unsafe { dxgi_factory.EnumAdapters(adapter_index)?.cast()? };
++        let adapter: IDXGIAdapter1 =
++            unsafe { dxgi_factory.EnumAdapterByGpuPreference(adapter_index, gpu_preference)? };
+         if let Ok(desc) = unsafe { adapter.GetDesc1() } {
+             let gpu_name = String::from_utf16_lossy(&desc.Description)
+                 .trim_matches(char::from(0))

apps/desktop-gpui/src/camera_blur.rs

@@ -176,8 +176,8 @@ pub fn run(jobs: flume::Receiver<BlurJob>, results: flume::Sender<BlurOutput>) {
 /// One device + queue for the app's blur lifetime, latched like Tauri's
 /// `blur_processor_init_attempted`: a failed bring-up is not retried on every
 /// toggle. The Tauri preview keeps its device for the window's lifetime
-/// (`camera.rs:573-583`, `LowPower`, downlevel limits); only the ONNX/blur
-/// resources are per-enable.
+/// (`camera.rs:573-583`, downlevel limits); only the ONNX/blur resources are
+/// per-enable.
 fn shared_device(runtime: &tokio::runtime::Runtime) -> Option<(wgpu::Device, wgpu::Queue)> {
     static DEVICE: OnceLock<Option<(wgpu::Device, wgpu::Queue)>> = OnceLock::new();
     DEVICE
@@ -186,7 +186,7 @@ fn shared_device(runtime: &tokio::runtime::Runtime) -> Option<(wgpu::Device, wgp
                 let instance = cap_rendering::create_wgpu_instance_sync();
                 let adapter = instance
                     .request_adapter(&wgpu::RequestAdapterOptions {
-                        power_preference: wgpu::PowerPreference::LowPower,
+                        power_preference: cap_rendering::gpu_power_preference(),
                         force_fallback_adapter: cap_rendering::force_software_wgpu_adapter(),
                         compatible_surface: None,
                     })

apps/desktop-gpui/src/camera_blur_portable.rs

@@ -64,7 +64,7 @@ impl PortableCameraBlur {
             let instance = cap_rendering::create_wgpu_instance_sync();
             let adapter = instance
                 .request_adapter(&wgpu::RequestAdapterOptions {
-                    power_preference: wgpu::PowerPreference::LowPower,
+                    power_preference: cap_rendering::gpu_power_preference(),
                     force_fallback_adapter: cap_rendering::force_software_wgpu_adapter(),
                     compatible_surface: None,
                 })

crates/rendering/src/lib.rs

@@ -218,6 +218,21 @@ pub fn force_software_wgpu_adapter() -> bool {
         })
 }
 
+fn parse_gpu_power_preference(value: &str) -> wgpu::PowerPreference {
+    match value.to_ascii_lowercase().as_str() {
+        "low" | "integrated" | "battery" => wgpu::PowerPreference::LowPower,
+        "system" | "auto" => wgpu::PowerPreference::None,
+        _ => wgpu::PowerPreference::HighPerformance,
+    }
+}
+
+/// `CAP_GPU_PREFERENCE` selects the physical GPU when more than one is present.
+/// `low` picks the integrated GPU, `system` lets the platform choose, and the
+/// default picks the high-performance (usually discrete) GPU.
+pub fn gpu_power_preference() -> wgpu::PowerPreference {
+    parse_gpu_power_preference(&std::env::var("CAP_GPU_PREFERENCE").unwrap_or_default())
+}
+
 pub fn create_wgpu_instance_sync() -> wgpu::Instance {
     #[cfg(not(target_os = "windows"))]
     let instance = wgpu::Instance::new(&wgpu::InstanceDescriptor::default());
@@ -287,7 +302,7 @@ pub async fn probe_software_adapter() -> Option<(bool, String)> {
     } else {
         instance
             .request_adapter(&wgpu::RequestAdapterOptions {
-                power_preference: wgpu::PowerPreference::HighPerformance,
+                power_preference: gpu_power_preference(),
                 force_fallback_adapter: false,
                 compatible_surface: None,
             })
@@ -2499,7 +2514,7 @@ pub async fn create_shared_device() -> Result<SharedWgpuDevice, RenderingError>
     } else {
         instance
             .request_adapter(&wgpu::RequestAdapterOptions {
-                power_preference: wgpu::PowerPreference::HighPerformance,
+                power_preference: gpu_power_preference(),
                 force_fallback_adapter: false,
                 compatible_surface: None,
             })
@@ -5207,6 +5222,40 @@ impl ProjectUniforms {
 mod tests {
     use super::*;
 
+    #[test]
+    fn gpu_power_preference_defaults_to_high_performance() {
+        assert_eq!(
+            parse_gpu_power_preference(""),
+            wgpu::PowerPreference::HighPerformance
+        );
+        assert_eq!(
+            parse_gpu_power_preference("high"),
+            wgpu::PowerPreference::HighPerformance
+        );
+        assert_eq!(
+            parse_gpu_power_preference("discrete"),
+            wgpu::PowerPreference::HighPerformance
+        );
+    }
+
+    #[test]
+    fn gpu_power_preference_honors_overrides() {
+        for value in ["low", "integrated", "battery", "LOW"] {
+            assert_eq!(
+                parse_gpu_power_preference(value),
+                wgpu::PowerPreference::LowPower,
+                "{value}"
+            );
+        }
+        for value in ["system", "auto", "System"] {
+            assert_eq!(
+                parse_gpu_power_preference(value),
+                wgpu::PowerPreference::None,
+                "{value}"
+            );
+        }
+    }
+
     #[test]
     fn camera_blur_output_rejects_missing_pending_and_failed_masks() {
         use cap_camera_effects::{BlurFailure, BlurMaskStatus, BlurMode, BlurOutputStatus};

scripts/prepare-gpui-dependency.sh

@@ -8,6 +8,7 @@ patch_paths=(
 	"apps/desktop-gpui/patches/zed-windows.patch"
 	"apps/desktop-gpui/patches/zed-linux.patch"
 	"apps/desktop-gpui/patches/zed-idle-frames.patch"
+	"apps/desktop-gpui/patches/zed-gpu-preference.patch"
 )
 patch_files=("${patch_paths[@]/#/$repo_root/}")
 base_revision="5d1f83d9f27a19bec1fb241dc33b42238af9cf8d"

scripts/prepare-gpui-dependency.test.mjs

@@ -122,6 +122,7 @@ test("dependency verification handles overlapping patches without changing the c
 	writeFileSync(path.join(upstream, "renderer.rs"), "base\n");
 	writeFileSync(path.join(upstream, "windows.rs"), "base\n");
 	writeFileSync(path.join(upstream, "frames.rs"), "base\n");
+	writeFileSync(path.join(upstream, "gpu.rs"), "base\n");
 	commit();
 	const base = git(upstream, "rev-parse", "HEAD").trim();
 	const patch = (name) => {
@@ -142,6 +143,8 @@ test("dependency verification handles overlapping patches without changing the c
 	patch("zed-linux.patch");
 	writeFileSync(path.join(upstream, "frames.rs"), "paced frames\n");
 	patch("zed-idle-frames.patch");
+	writeFileSync(path.join(upstream, "gpu.rs"), "high performance GPU\n");
+	patch("zed-gpu-preference.patch");
 	const script = path.join(cap, "scripts/prepare-gpui-dependency.sh");
 	writeFileSync(
 		script,
@@ -165,6 +168,10 @@ test("dependency verification handles overlapping patches without changing the c
 			readFileSync(path.join(zed, "frames.rs"), "utf8"),
 			"paced frames\n",
 		);
+		assert.equal(
+			readFileSync(path.join(zed, "gpu.rs"), "utf8"),
+			"high performance GPU\n",
+		);
 	});
 
 	writeFileSync(path.join(zed, "unrelated.txt"), "preserve staged work\n");