<!--
{
  "documentType" : "article",
  "framework" : "Metal",
  "identifier" : "/documentation/Metal/finding-multiple-gpus-on-an-intel-based-mac",
  "metadataVersion" : "0.1.0",
  "role" : "article",
  "title" : "Finding multiple GPUs on an Intel-based Mac"
}
-->

# Finding multiple GPUs on an Intel-based Mac

Locate, identify, and choose suitable GPUs for your app.

## Discussion

Your app can use multiple GPUs on an Intel-based Mac, including any built-in and external GPUs. Start by getting a list of all the system’s available GPUs, and then submit workloads to those appropriate for your app’s tasks.

> Note:
> Mac computers with Apple silicon have a single, high-performance, and energy-efficient GPU.

### Get a list of GPU devices

Your app can get an array of [`MTLDevice`](/documentation/Metal/MTLDevice) instances, each of which represents an available GPU, by calling the [`MTLCopyAllDevices()`](/documentation/Metal/MTLCopyAllDevices()) function.

```swift
let devices = MTLCopyAllDevices()
```

However, that function provides a list of GPUs that are available at that moment in time. To get the current list and register for device update notifications, provide a handler to Metal by calling the [`MTLCopyAllDevicesWithObserver`](/documentation/Metal/MTLCopyAllDevicesWithObserver) function.

```swift
let (devices, observer) = MTLCopyAllDevicesWithObserver() { (device, notification) in
    self.device(device, issued: notification)
}
```

Metal calls your handler to tell your app when the system adds or removes an [`MTLDevice`](/documentation/Metal/MTLDevice) from the system.

> Note:
> Metal calls your app’s handler when a device may change its state in the future, such as when a person makes a safe disconnect request. For more information, see <doc://com.apple.metal/documentation/Metal/handling-external-gpu-additions-and-removals>.

Your app can deregister its observer when it no longer needs GPU device updates from the system by calling the [`MTLRemoveDeviceObserver(_:)`](/documentation/Metal/MTLRemoveDeviceObserver(_:)) function.

```swift
MTLRemoveDeviceObserver(observer)
```

### Identify each GPU by type

Each GPU on a Mac computer’s system can be one of three types: integrated, discrete, or external. You can identify each [`MTLDevice`](/documentation/Metal/MTLDevice) instance’s type by inspecting its [`isLowPower`](/documentation/Metal/MTLDevice/isLowPower) and [`isRemovable`](/documentation/Metal/MTLDevice/isRemovable) properties.

|GPU Type  |``doc://com.apple.metal/documentation/Metal/MTLDevice/isLowPower``|``doc://com.apple.metal/documentation/Metal/MTLDevice/isRemovable``|
|----------|------------------------------------------------------------------|-------------------------------------------------------------------|
|Integrated|<doc://com.apple.documentation/documentation/Swift/true>          |<doc://com.apple.documentation/documentation/Swift/false>          |
|Discrete  |<doc://com.apple.documentation/documentation/Swift/false>         |<doc://com.apple.documentation/documentation/Swift/false>          |
|External  |<doc://com.apple.documentation/documentation/Swift/false>         |<doc://com.apple.documentation/documentation/Swift/true>           |

For example, you can use these properties to build a list of devices for each GPU type.

```swift
var externalGPUs = [MTLDevice]()
var discreteGPUs = [MTLDevice]()
var integratedGPUs = [MTLDevice]()

for device in devices {
    if device.isRemovable { externalGPUs.append(device) } else
    if device.isLowPower { integratedGPUs.append(device) } else {
        discreteGPUs.append(device)
    }
}
```

Some external or discrete GPUs can also be *headless*, which means they aren’t connected to a display. Your app can identify whether a GPU is headless by checking a device instance’s [`isHeadless`](/documentation/Metal/MTLDevice/isHeadless) property.

```swift
if device.isHeadless {
    // This GPU device isn't connected to any displays.
    ...
}
```

### Select the GPUs suitable for your workloads

Each GPU type has its advantages for certain tasks or workloads that you can consider for a system with multiple GPUs.

|GPU type  |Power consumption|Memory bandwidth|
|----------|-----------------|----------------|
|Integrated|Low              |High            |
|Discrete  |Medium           |High            |
|External  |High             |Low             |

In general, start with an integrated GPU (if the system has one) to conserve power and extend the device’s battery life. If your app needs additional graphics or compute processing, consider moving some workloads to a discrete GPU, if the system has one.

> Tip:
> Your app could let a person choose which GPU your app uses for its workloads, especially if they attach an external GPU to their system.

External GPUs typically have significant processing power but lower bandwidth compared to internal GPUs, which makes them a good choice for tasks that don’t require much memory bandwidth for each frame, including the following:

- Rendering high-complexity graphics scenes
- Rendering high-resolution graphics content
- Processing compute workloads in tandem with rendering graphics
- Processing compute workloads that use a high arithmetic-logic unit (ALU) complexity

For more information about GPU memory bandwidth, see [Adjusting for GPU memory bandwidth tradeoffs](/documentation/Metal/adjusting-for-gpu-memory-bandwidth-tradeoffs).

> Note:
> A headless GPU is more suitable for compute processing than rendering graphics for a display because the GPU isn’t connected to a display.

---

Copyright &copy; 2026 Apple Inc. All rights reserved. | [Terms of Use](https://www.apple.com/legal/internet-services/terms/site.html) | [Privacy Policy](https://www.apple.com/privacy/privacy-policy)