Vulkan — wat is het, cross-platform API en rendering

Wat is Vulkan?

Vulkan — is een laag niveau, cross-platform API voor het werken met grafische processors, voor het eerst uitgebracht door Khronos Group in 2016. Vulkan verving OpenGL en biedt aanzienlijk lagere CPU-overhead, voorspelbare prestaties en de mogelijkheid van multi-threaded commandogeneratie.

In tegenstelling tot OpenGL, waar de driver controles en synchronisatie op de CPU uitvoert, legt Vulkan resourcebeheer bij de ontwikkelaar. Geheugentoewijzing, synchronisatie via semaforen en barriers, het creëren van pipelines — alles wordt expliciet gecontroleerd. Deze aanpak geeft een prestatieverbetering tot 50% in CPU-bound scenario's.

Vulkan wordt ondersteund op Windows, Linux, Android, iOS (via MoltenVK), macOS (MoltenVK), Nintendo Switch en consoles. Volgens Khronos Group (2026) werkt de API op apparaten met GPU's van NVIDIA, AMD, Intel, Qualcomm (Adreno), ARM (Mali) en Apple (via de Metal-laag). Vulkan 1.4 (2026) voegde ondersteuning toe voor Mesh Shaders en Video Encode API.

Geschiedenis van Vulkan

Aanvankelijk werd Vulkan ontwikkeld onder de codenaam „glNext” — de opvolger van OpenGL. Vulkan 1.0 (2016) bood een basis API met expliciet geheugenbeheer, SPIR-V shaders en multi-threaded wachtrijen. Vulkan 1.1 (2018) voegde Subgroup Operations en ondersteuning voor 16-bit types toe. Vulkan 1.2 (2020) introduceerde Buffer Device Address en Timeline Semaphores.

Vulkan 1.3 (2022) standaardiseerde Dynamic Rendering en Graphics Pipeline Library. Vulkan 1.4 (2026) maakte ondersteuning voor Mesh Shaders verplicht en voegde Video Encode/Decode API toe voor hardwarecodering van H.264/HEVC/AV1. Volgens Khronos (2026) wordt Vulkan 1.4 ondersteund op alle nieuwe GPU's NVIDIA RTX 50xx, AMD RX 9000 en Intel Arc B-serie.

Vulkan architectuur: apparaat en wachtrijen

Vulkan architectuur is gebouwd op een hardware abstractielaag (HW layer). De applicatie communiceert met het fysieke apparaat (VkPhysicalDevice) via een logisch apparaat (VkDevice). Commando's worden naar wachtrijen (VkQueue) gestuurd, die elk tot een bepaalde wachtrijfamilie behoren (graphics, compute, transfer).

VkInstance, VkDevice en VkQueue

VkInstance — het rootobject van Vulkan, dat informatie opslaat over validatielagen en extensies. VkPhysicalDevice vertegenwoordigt de fysieke GPU en maakt het mogelijk de eigenschappen, memory heaps en queue families op te vragen. VkDevice — een logisch apparaat met expliciet aangevraagde wachtrijen en extensies.

// Creatie van logisch Vulkan-apparaat
VkDeviceCreateInfo devInfo {};
devInfo.sType = VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO;
devInfo.queueCreateInfoCount = 1;
 
float queuePriority = 1.0f;
VkDeviceQueueCreateInfo queueInfo {};
queueInfo.sType = VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO;
queueInfo.queueFamilyIndex = 0;
queueInfo.queueCount = 1;
queueInfo.pQueuePriorities = &queuePriority;
devInfo.pQueueCreateInfos = &queueInfo;
 
VkDevice device;
vkCreateDevice(physicalDevice, &devInfo,
    nullptr, &device);
 
VkQueue queue;
vkGetDeviceQueue(device, 0, 0, &queue);

De functie vkCreateDevice maakt een logisch apparaat met opgegeven wachtrijen. VkQueue — een descriptor van een wachtrij voor het verzenden van commando's. Eén wachtrij kan worden gebruikt voor graphics, berekeningen en kopiëren, als de bijbehorende vlaggen worden ondersteund door de wachtrijfamilie. De wachtrijprioriteit (0.0–1.0) beïnvloedt de uitvoervolgorde bij concurrentie.

VkMemory en VkBuffer — geheugenbeheer

In Vulkan wordt geheugen expliciet toegewezen via VkDeviceMemory. De ontwikkelaar vraagt bij het fysieke apparaat memory types (HOST_VISIBLE, DEVICE_LOCAL) aan en wijst blokken toe. Buffers (VkBuffer) en textures (VkImage) hebben geen eigen geheugen — ze worden aan toegewezen blokken gekoppeld via vkBindBufferMemory.

Vulkan Memory Allocator (VMA) — een bibliotheek van AMD die geheugenbeheer vereenvoudigt. VMA groepeert automatisch kleine toewijzingen in grote blokken, beheert defragmentatie en selecteert het juiste memory type. Volgens AMD (2025) vermindert VMA het aantal geheugentoewijzingen met 50–100 keer in vergelijking met handmatig beheer.

VkCommandPool en VkCommandBuffer

VkCommandPool beheert het geheugen voor commandobuffers. Buffers (VkCommandBuffer) worden op de CPU geschreven en via vkQueueSubmit naar de GPU gestuurd. Vulkan ondersteunt primary en secondary buffers: primary worden direct verzonden, secondary kunnen vanuit primary worden aangeroepen voor multi-threaded commandoconstructie.

Het schrijven van commando's begint met vkBeginCommandBuffer en eindigt met vkEndCommandBuffer. Daartussen worden rendercommando's geschreven: vkCmdDraw, vkCmdDispatch, vkCmdCopyBuffer en vkCmdPipelineBarrier voor synchronisatie. Voor elk frame wordt een nieuwe commandobuffer gemaakt met pool reset.

Rendering via Vulkan: pipeline en commando's

Rendering in Vulkan is georganiseerd via pipelines (VkPipeline). In tegenstelling tot OpenGL, waar de pipelinestatus globaal verandert, gebruikt Vulkan VkPipeline — een vooraf gecompileerde pipeline die alle stadia omvat: vertexinvoer, shaders, rasterization, depth-stencil en blending.

VkPipeline — renderpipeline

VkGraphicsPipelineCreateInfo beschrijft de volledige pipeline: vertex- en fragmentshaders, topologie (triangle list, triangle strip), rasterizer (fill mode, cull mode), multisampling, depth-stencil tests, blending en viewport-instellingen. De pipeline wordt eenmalig aangemaakt en hergebruikt — statuswijziging vereist een nieuwe pipeline of dynamic state.

// Configuratie van grafische pipeline
VkGraphicsPipelineCreateInfo pipelineInfo {};
pipelineInfo.sType =
    VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO;
pipelineInfo.stageCount = 2;
pipelineInfo.pStages = shaderStages;
pipelineInfo.pVertexInputState =&;
    vertexInputState;
pipelineInfo.pRasterizationState =&;
    rasterState;
 
VkPipeline graphicsPipeline;
vkCreateGraphicsPipelines(device,
    VK_NULL_HANDLE, 1, &pipelineInfo,
    nullptr, &graphicsPipeline);

Dynamic State (VK_DYNAMIC_STATE_VIEWPORT, VK_DYNAMIC_STATE_SCISSOR) maakt het mogelijk bepaalde parameters te wijzigen zonder een nieuwe pipeline aan te maken. Vulkan 1.4 maakte ondersteuning voor Dynamic State 3 (VK_EXT_extended_dynamic_state_3) verplicht voor het beheren van blend constants, depth bias en topologie tijdens runtime, wat het aantal pipelines in het project vermindert.

Render Pass en Dynamic Rendering

VkRenderPass beschrijft de structuur van renderpassen: welke attachments worden gebruikt, hoe ze worden gewist en geladen. Dynamic Rendering (VK_KHR_dynamic_rendering, verplicht vanaf Vulkan 1.4) vereenvoudigt het proces: de render pass wordt tijdens runtime in de commandobuffer aangemaakt via vkCmdBeginRendering, zonder een voorafgaand VkRenderPass-object.

Volgens Khronos (2026) vermindert Dynamic Rendering de hoeveelheid initialisatiecode van Vulkan met 30–40% en verlaagt het aantal pipeline permutations. Voor complexe uitgestelde renderingstechnieken (Deferred Shading) is het nog steeds handig om klassieke VkRenderPass te gebruiken met meerdere subpasses voor G-buffer en belichting.

Shaders in Vulkan: SPIR-V en GLSL

SPIR-V — een universeel binair shaderformaat in Vulkan, ontwikkeld door Khronos. Shaders kunnen worden geschreven in GLSL, HLSL of de taal Zink en worden gecompileerd naar SPIR-V via glslangValidator, dxc of Google Shaderc. Vulkan accepteert geen shaders in broncode — alleen binair SPIR-V.

GLSL in Vulkan

GLSL voor Vulkan verschilt van standaard OpenGL GLSL. Er worden blokken (layout) gebruikt met expliciete vermelding van set- en bindingnummers, in plaats van ingebouwde variabelen. Vertexattributen worden via location gespecificeerd, uniforms via uniform blocks of buffers. Push constants (tot 128 bytes) zijn beschikbaar voor snelle gegevensoverdracht zonder buffers.

// Vertex shader Vulkan/GLSL
#version 460
 
layout(location = 0) in vec3 inPosition;
layout(location = 1) in vec3 inNormal;
 
layout(binding = 0, set = 0)
uniform UniformBufferObject {
    mat4 modelViewProjection;
} ubo;
 
layout(location = 0) out vec3 outNormal;
 
void main() {
    gl_Position = ubo.modelViewProjection *
        vec4(inPosition, 1.0);
    outNormal = inNormal;
}

De kwalificatoren layout(set = N, binding = M) — het belangrijkste verschil tussen Vulkan GLSL en OpenGL. Set komt overeen met een descriptorengroep (VkDescriptorSet), binding met een specifieke resource (buffer, texture, sampler). De opdeling in sets maakt het mogelijk efficiënt resourcesets te wisselen tussen draw calls zonder individuele resources te binden.

Descriptoren en descriptorengroepen

VkDescriptorSet — een groep resources (buffers, textures, samplers) die aan shaders zijn gebonden. De descriptorlayout beschrijft de resourcetypes en hun bindingnummers. Descriptorengroepen worden bijgewerkt via vkUpdateDescriptorSets en hergebruikt tussen draw calls. Vulkan 1.4 ondersteunt VK_EXT_descriptor_buffer voor directe toegang tot descriptoren vanuit de GPU.

Push Constants — een mechanisme voor snelle overdracht van kleine hoeveelheden gegevens (tot 128 bytes) naar shaders zonder descriptoren te maken. Push Constants worden via vkCmdPushConstants in de commandobuffer gespecificeerd. Volgens Khronos (2025) vermindert het gebruik van push constants in plaats van uniform buffers de CPU-overhead met 10–15% bij een frequentie van draw calls van meer dan 10 duizend per frame.

Vulkan op verschillende platforms

Vulkan is de enige API die op alle belangrijke platforms werkt: Windows (via de officiële ICD driver), Linux (RADV, AMDVLK, NVIDIA), Android (Vulkan 1.3+, verplicht vanaf Android 10) en op Apple-apparaten via MoltenVK — de vertaallaag Vulkan → Metal.

Vulkan op Android

Op Android is Vulkan verplicht voor Android 10 en nieuwer. Google beveelt Vulkan aan voor nieuwe projecten, met name hoogwaardige games en AR-applicaties via ARCore. Qualcomm Adreno en ARM Mali bieden volledige ondersteuning voor Vulkan 1.3 met hardware ray tracing op Adreno 8xx en Mali-G720.

Volgens Google (2026) ondersteunt 98% van de Android-apparaten met Android 10+ Vulkan. Voor achterwaartse compatibiliteit is ANGLE (Almost Native Graphics Layer Engine) beschikbaar, die OpenGL ES naar Vulkan vertaalt. Dit maakt het mogelijk oude OpenGL-applicaties op de Vulkan-driver te draaien met een prestatieverbetering tot 20%.

Op Android heeft Vulkan hoge prioriteit voor energie-efficiëntie: Vulkan-applicaties verbruiken 25–40% minder energie in vergelijking met OpenGL ES bij dezelfde grafische belasting op apparaten met Adreno 7xx+. Dit maakt Vulkan de voorkeurs-API voor games op mobiele apparaten.

Vulkan op Apple via MoltenVK

MoltenVK — een implementatie van Vulkan bovenop Metal, ontwikkeld door LunarG en Valve. MoltenVK vertaalt Vulkan API-aanroepen naar Metal en ondersteunt Vulkan 1.2 op iOS en macOS. De prestaties van MoltenVK liggen dicht bij native Metal: de vertaaloverhead bedraagt 5–15% afhankelijk van het scenario.

Volgens LunarG (2025) wordt MoltenVK gebruikt in CrossOver (Wine voor Mac) om Windows-games op macOS te draaien. Dota 2, Civilization VI en Baldur’s Gate 3 op macOS werken via MoltenVK met 30–60 FPS op M3/M4. MoltenVK ondersteunt MetalFX upscaling voor prestatieverbetering.

Vulkan Ray Tracing

VK_KHR_ray_tracing — de extensie voor hardware ray tracing in Vulkan, verplicht vanaf Vulkan 1.4. Ondersteund op GPU's met RT-kernen: NVIDIA RTX 20xx/30xx/40xx/50xx, AMD RX 6000+/9000, Intel Arc A/B. Vulkan RT biedt VkAccelerationStructure, VkRayTracingPipeline en Shader Binding Table.

Vulkan Ray Tracing ondersteunt reflecties, schaduwen, ambient occlusion en globale belichting in realtime. Volgens Khronos (2026) voert Vulkan Ray Tracing op de NVIDIA RTX 5090 tot 100 Giga rays/s uit in referentiekwaliteitsscènes. Voor draagbare platforms wordt Vulkan RT geschaald via blur reduction en temporal denoising.