Enum GpuPreference 

pub enum GpuPreference {
    Auto,
    LowPower,
    HighPerformance,
    Device(GpuId),
    Custom(Arc<dyn Fn(&[GpuAdapterInfo]) -> Option<usize> + Send + Sync>),
}

Which GPU an application prefers the renderer to run on.

The device is process-wide and chosen once, before the first window (decision 0008), so this is stated on the application rather than per window. The default is LowPower: on a hybrid laptop the panel is wired to the integrated GPU, so rendering on the discrete one keeps it powered for the window’s lifetime and crosses PCIe on every frame.

Variants

Auto

Today’s ranking: the compositor’s hint, then device type (discrete, integrated, other, virtual, CPU), then backend.

LowPower

Prefer the integrated adapter. The default.

HighPerformance

Prefer the discrete adapter.

Device(GpuId)

A named adapter, matched by its permanent part and, when it carries one, its session handle. One that is not present falls back to [Auto].

Custom(Arc<dyn Fn(&[GpuAdapterInfo]) -> Option<usize> + Send + Sync>)

A predicate that picks one adapter from the enumerated list.

The closure receives every adapter the platform reports and returns the index of the one it wants, or None when none will do. It chooses a GPU; it does not rank them.

use std::sync::Arc;
use gpui_platform::{GpuAdapterInfo, GpuDeviceType, GpuPreference};

let preference = GpuPreference::Custom(Arc::new(|gpus: &[GpuAdapterInfo]| {
    // A producer that must share a dma-buf with the renderer names its GPU first, and
    // otherwise takes the integrated one — where the panel is wired on a hybrid laptop.
    gpus.iter()
        .position(|gpu| gpu.device_id() == Some(0x1346))
        .or_else(|| {
            gpus.iter()
                .position(|gpu| gpu.device_type == GpuDeviceType::Integrated)
        })
}));

The adapter named is tried first. If the display cannot be configured on it, the remaining adapters follow in Auto’s order — this is a preference, not a pin. An application that must know what it got reads GpuAdapterInfo back through the app’s active-GPU accessor.

None, or an index outside the list, fails the window with an error naming the shortfall: the application saw the same list, so the two disagreeing is a bug worth surfacing rather than silently drawing on a GPU the application did not choose.

Trait Implementations

impl Clone for GpuPreference

fn clone(&self) -> GpuPreference

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for GpuPreference

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

Formats the value using the given formatter.

impl Default for GpuPreference

fn default() -> GpuPreference

Returns the “default value” for a type.