Metal — wat is het, grafische API en shaders

Wat is Metal?

Metal is een laag-niveau API voor het werken met de grafische processor (GPU), geïntroduceerd door Apple in 2014 samen met iOS 8 en OS X Yosemite. Metal is gemaakt als vervanging voor OpenGL en OpenCL met als doel de CPU-overhead te verminderen en directere toegang tot de GPU-hardware op Apple-apparaten te bieden.

In tegenstelling tot OpenGL, waar de driver meerdere controles en transformaties op de CPU uitvoert, gebruikt Metal een model van expliciet resourcebeheer. De ontwikkelaar controleert geheugentoewijzing, synchronisatie en het verzenden van GPU-opdrachten, wat een prestatieverbetering tot 50% oplevert vergeleken met OpenGL ES op dezelfde hardware.

Metal ondersteunt alle Apple-chips, van A7 (2013) tot M4 Ultra (2025). De API wordt voortdurend ontwikkeld: Metal 3 (2022) voegde ondersteuning toe voor mesh-shaders en ray tracing, Metal 3.1 (2023) — snelle resource-sharing tussen CPU en GPU, en Metal 4 (2025) — hardwareversnelling van neurale netwerken op de GPU met ondersteuning voor FP8 en INT4.

Geschiedenis van Metal

De eerste versie van Metal (2014) bood een basis-API voor grafische rendering op iOS. Metal 2 (2017) voegde compute shaders en Metal Performance Shaders toe. Metal 3 (2022) introduceerde MetalFX Upscaling — eigen upscaling-technologie voor games, concurrent van NVIDIA DLSS en AMD FSR. MetalFX biedt een prestatieverbetering tot 2x op Mac met M2.

Metal 4 (2025) richtte zich op machine learning en ray tracing. Volgens Apple (2025) bereikt Metal 4 op de M4 Ultra tot 80 TFLOPS in rekentaken bij FP16 en ondersteunt hardwarematige AV1-decodering. Metal wordt nu ook ondersteund op Apple Vision Pro via de compositor-service voor het renderen van immersieve content.

Metal-architectuur: apparaat en bronnen

Metal-architectuur is gebouwd rond het concept van expliciet beheer: de ontwikkelaar maakt MTLDevice (apparaat), MTLBuffer (databuffers), MTLTexture (texturen) en MTLCommandQueue (opdrachtrij) objecten. In tegenstelling tot OpenGL, waar de status in de context wordt opgeslagen, gebruikt Metal statusobjecten (state objects) die vooraf worden gecompileerd.

MTLDevice — ingangspunt van de API

MTLDevice vertegenwoordigt een fysieke of virtuele GPU. Alle Metal-bronnen worden via dit object gemaakt: buffers, texturen, shaderbibliotheken, pipelines. In systemen met meerdere GPU’s (Mac Pro) kan een specifiek apparaat worden gekozen. De methode supportsFamily: controleert de ondersteuning van functies: ray tracing, mesh-shaders, MetalFX.

import Metal
 
// GPU-apparaat verkrijgen
guard let device = MTLCreateSystemDefaultDevice() else {
    fatalError("Metal wordt niet ondersteund")
}
 
// Mogelijkheden controleren
let supportsRayTracing = device.supportsFamily(.metal3)
let gpuName = device.name // „Apple M4 Pro”
let maxBufferSize = device.maxBufferLength

De eigenschap maxBufferLength bepaalt de maximale buffergrootte die het apparaat ondersteunt. Op Apple Silicon met Unified Memory is de limiet tot 128 GB (op M4 Ultra). Dit maakt het mogelijk om met grote datasets te werken voor ML en wetenschappelijke berekeningen zonder buffergesegmenteerd. Het apparaat beheert ook het geheugen via MTLHeap.

MTLBuffer en MTLTexture — gegevens voor de GPU

MTLBuffer — een aaneengesloten geheugengebied dat toegankelijk is voor de GPU. Buffers worden gebruikt voor vertexgegevens, matrices, uniform-variabelen. Modi: shared (CPU + GPU-toegang in uniform geheugen), private (alleen GPU, sneller), managed (voor discrete GPU’s, met synchronisatie). Op Apple Silicon wordt shared aanbevolen voor eenvoud.

MTLTexture — een multidimensionale pixelarray voor texturen en rendering targets. 1D-, 2D-, 3D-, cube- en array-texturen worden ondersteund. Formaten: RGBA8Unorm, BGRA8Unorm, RGBA16Float, R32Float, ASTC (compressie), diepte (depth32Float) en stencil. Texture Usage-vlaggen geven aan hoe de textuur zal worden gebruikt: rendering, shader-lezen, kopiëren.

MTLLibrary en shadercompilatie

MTLLibrary — een verzameling gecompileerde GPU-functies (shaders). De bibliotheek kan worden gemaakt van MSL-broncode (Metal Shading Language) tijdens runtime of vooraf worden gecompileerd en in het bundel (.metallib) worden opgenomen. Voorcompilatie wordt aanbevolen om vertragingen in de initialisatiefase te elimineren.

MTLFunction vertegenwoordigt een specifieke shaderfunctie. Vertex-shaders, fragment-shaders, compute-shaders (kernel) en mesh-shaders worden via de bibliotheek gemaakt. Functies worden op de GPU gecachet en hergebruikt tussen frames. Shader-argumenten worden gespecificeerd via buffers en textuurslots met indexbinding.

Rendering via Metal: commandobuffers

Rendering in Metal is georganiseerd via asynchrone opdrachtrijen. De ontwikkelaar maakt een MTLCommandBuffer, codeert er rendering- of compute-opdrachten in en verzendt deze naar MTLCommandQueue. De GPU voert de opdrachten sequentieel uit, terwijl de CPU zijn werk kan voortzetten. Synchronisatie gebeurt via semaforen of completionHandler.

MTLCommandQueue en MTLCommandBuffer

MTLCommandQueue — een opdrachtrij gemaakt van MTLDevice. Een applicatie kan meerdere rijen hebben voor graphics, computing en kopiëren. Elke rij garandeert sequentiële uitvoering van opdrachten. MTLCommandBuffer — een container voor een portie GPU-werk. Na het coderen wordt deze gecommit en uitgevoerd op de GPU.

// Hoofdrenderinglus
let commandQueue = device.makeCommandQueue()!
 
guard let commandBuffer = commandQueue.makeCommandBuffer()
else { return }
 
guard let descriptor = currentDrawable.texture.makeRenderPassDescriptor(
    attachment: 0
) else { return }
 
let encoder = commandBuffer.makeRenderCommandEncoder(
    descriptor: descriptor
)!
encoder.setRenderPipelineState(pipelineState)
encoder.drawPrimitives(type: .triangle,
    vertexStart: 0, vertexCount: 36)
encoder.endEncoding()
 
commandBuffer.present(currentDrawable)
commandBuffer.commit()

De methode drawPrimitives voert het tekenen van geometrie uit. De parameter vertexCount geeft het aantal vertices aan. Voor elk frame wordt een nieuwe command buffer gemaakt. Present synchroniseert het tekenen met de VSync van het scherm. Metal beheert automatisch de synchronisatie met het display via CAMetalLayer.

Render Pipeline Status

MTLRenderPipelineState — gecompileerde status van de rendering-pipeline, inclusief vertex- en fragment-shaders, depth-stencil-configuratie, blending en uitvoerpixelformaat. Het maken van een pipeline state is een dure operatie, daarom worden objecten gecachet en hergebruikt. Voor verschillende shadercombinaties worden verschillende pipeline states gemaakt.

Metal 3.1 introduceerde snelle rendering via Immutable Samplers, die op de GPU worden gecachet voor het versnellen van texture sampling. Metal ondersteunt tot 31 texturen per shaderslot in Apple Silicon-omgevingen. Op oudere apparaten met A13 en lager is de limiet verlaagd naar 16 slots. Het wordt aanbevolen om texturen te combineren in Texture Atlases om het aantal samples te verminderen.

Metal Shading Language en shaders

Metal Shading Language (MSL) — een programmeertaal voor shaders gebaseerd op C++14 met extensies voor GPU-berekeningen. MSL ondersteunt sjablonen (templates), functie-overloading, naamruimten en adresrekenkunde. Shaders worden gecompileerd naar binaire GPU-code via de Apple LLVM-backend.

Vertex- en fragment-shaders

Vertex shader verwerkt elk vertex: transformeert coördinaten van wereldruimte naar schermruimte, berekent normalen en geeft gegevens door aan de fragment-shader. Fragment shader berekent de kleur van elke pixel: past texturen, belichting en post-processing-effecten toe.

// Metal vertex shader
#include <metal_stdlib>
using namespace metal;
 
struct VertexIn {
    float3 position [[attribute(0)]];
    float3 normal   [[attribute(1)]];
};
 
struct VertexOut {
    float4 position [[position]];
    float3 worldNormal;
};
 
vertex VertexOut vertexMain(
    VertexIn in [[stage_in]],
    constant float4x4 &mvp [[buffer(0)]]
) {
    VertexOut out;
    out.position = mvp * float4(in.position, 1.0);
    out.worldNormal = in.normal;
    return out;
}

[[attribute(N)]] attributen komen overeen met de vertex-formaten gespecificeerd in MTLVertexDescriptor. Buffer [buffer(0)] geeft de MVP-matrix door als uniform-variabele. De vertex-positie moet worden gemarkeerd met [[position]] voor doorgeven aan de rasterizer. Alle MSL-vectortypen — float2, float3, float4 — worden gemapt op hardware GPU-registers.

Compute Shaders (Compute Kernels)

Compute shader (kernel) — een GPU-functie die buiten de grafische pipeline wordt uitgevoerd. Kernel-functies worden gemarkeerd met de kwalificatie kernel en uitgevoerd in threads, georganiseerd in threadgroups. Compute shaders worden gebruikt voor beeldverwerking, fysicasimulatie, ML en post-processing.

// Compute kernel voor vervaging van afbeelding
kernel void blurKernel(
    texture2d<half> input  [[texture(0)]],
    texture2d<half> output [[texture(1)]],
    constant float &radius  [[buffer(0)]],
    uint2 gid [[thread_position_in_grid]]
) {
    if (gid.x >= input.get_width() ||
        gid.y >= input.get_height()) { return; }
    half4 color = input.read(gid);
    output.write(color, gid);
}

De parameter gid [[thread_position_in_grid]] bevat de unieke thread-index. Texture2D specialiseert zich op basis van het pixeltype: half (FP16), float (FP32). Compute kernels kunnen worden gestart met een gridgrootte van meer dan 1 miljard threads op M4 Ultra. Maximale threadgroup-grootte is 1024 threads op Apple Silicon GPU.

Prestaties en Metal Performance Shaders

Metal Performance Shaders (MPS) — een bibliotheek met geoptimaliseerde GPU-functies van Apple. MPS omvat convolutionele neurale netwerken (MPSNNConvolution), matrixvermenigvuldigingen (MPSMatrixMultiplication), sorteren (MPSParallelSort) en beeldverwerking (MPSImageGaussianBlur). Alle functies zijn geoptimaliseerd voor specifieke Apple GPU’s.

MetalFX Upscaling

MetalFX — upscaling- en anti-aliasing-technologie, concurrent van NVIDIA DLSS en AMD FSR. MetalFX biedt twee modi: Spatial (ruimtelijke upscaling via FSR 2-algoritme) en Temporal (temporele upscaling met motion vectors). Temporal MetalFX biedt kwaliteit dicht bij native 4K vanuit rendering op 1440p.

Volgens Apple (2025) biedt MetalFX Temporal op M4 Max een prestatieverbetering tot 3x in games met behoud van kwaliteit die visueel niet te onderscheiden is van native resolutie. MetalFX werkt op elke GPU die Metal 3 ondersteunt, zonder speciale tensor kernen. Integratie van MetalFX in een project vergt ongeveer 50 regels code.

Ray Tracing in Metal

Ray Tracing in Metal 3 wordt ondersteund op M3-, M4- en A17 Pro-chips met hardwareversnellingsblokken (Ray Tracing Accelerators). Metal biedt MTLAccelerationStructure voor het bouwen van BVH en MTLIntersectionFunction voor straalintersectie in shaders. Gigantische scènes met miljoenen driehoeken worden in milliseconden naar BVH gecompileerd.

Volgens Apple (2025) voert hardware ray tracing op de M4 Ultra tot 40 miljard straalintersecties per seconde uit (Giga rays/s). Dit is 4 keer sneller dan software ray tracing op de M1 Ultra. Metal RT ondersteunt intersection queries, dynamische geometrieën en Motion Blur voor realistische animaties. Reflecties en schaduwen met ray tracing werken in realtime op 60 FPS.

Unified Memory en Zero-Copy

Unified Memory — de Apple Silicon-architectuur waarbij CPU en GPU hetzelfde fysieke geheugen gebruiken. Metal op Apple Silicon vereist geen kopiëren van gegevens tussen CPU en GPU: MTLBuffer in shared-modus is toegankelijk voor beide processors zonder kopiëren. Dit elimineert de belangrijkste bottleneck van traditionele GPU’s (PCIe-transfers).

Zero-Copy in Metal stelt de CPU in staat gegevens naar de buffer te schrijven en de GPU deze zonder vertraging te lezen. Volgens Apple (2025) levert dit een prestatieverbetering op van 30–50% vergeleken met discrete GPU’s op games en ML-taken. Voor discrete GPU’s (Mac Pro met Radeon) ondersteunt Metal de managed-modus met automatische synchronisatie via memory barriers.