Vulkan — vad är det, plattformsoberoende API och rendering

Vad är Vulkan?

Vulkan — är ett lågnivå, plattformsoberoende API för arbete med grafikprocessorer, första gången utgivet av Khronos Group 2016. Vulkan ersatte OpenGL och erbjuder betydligt lägre CPU-overhead, förutsägbar prestanda och möjlighet till flertrådad kommandogenerering.

Till skillnad från OpenGL, där drivrutinen utför kontroller och synkronisering på CPU:n, överför Vulkan resurshanteringen till utvecklaren. Minnesallokering, synkronisering via semaforer och barriärer, skapande av pipelines — allt kontrolleras explicit. Detta tillvägagångssätt ger en prestandaökning på upp till 50% i CPU-bound-scenarier.

Vulkan stöds på Windows, Linux, Android, iOS (via MoltenVK), macOS (MoltenVK), Nintendo Switch och konsoler. Enligt Khronos Group (2026) fungerar API:t på enheter med GPU från NVIDIA, AMD, Intel, Qualcomm (Adreno), ARM (Mali) och Apple (via Metal-lagret). Vulkan 1.4 (2026) lade till stöd för Mesh Shaders och Video Encode API.

Historik om Vulkan

Ursprungligen utvecklades Vulkan under kodnamnet “glNext” — efterföljaren till OpenGL. Vulkan 1.0 (2016) gav ett grundläggande API med explicit minneshantering, SPIR-V-shaders och flertrådade köer. Vulkan 1.1 (2018) lade till Subgroup Operations och stöd för 16-bitars typer. Vulkan 1.2 (2020) introducerade Buffer Device Address och Timeline Semaphores.

Vulkan 1.3 (2022) standardiserade Dynamic Rendering och Graphics Pipeline Library. Vulkan 1.4 (2026) gjorde stöd för Mesh Shaders obligatoriskt och lade till Video Encode/Decode API för hårdvarukodning av H.264/HEVC/AV1. Enligt Khronos (2026) stöds Vulkan 1.4 på alla nya GPU:er NVIDIA RTX 50xx, AMD RX 9000 och Intel Arc B-serien.

Vulkan-arkitektur: enhet och köer

Vulkan-arkitekturen är byggd på ett hårdvaruabstraktionslager (HW layer). Applikationen interagerar med den fysiska enheten (VkPhysicalDevice) via en logisk enhet (VkDevice). Kommandon skickas till köer (VkQueue), som var och en tillhör en specifik köfamilj (graphics, compute, transfer).

VkInstance, VkDevice och VkQueue

VkInstance — Vulkan-rotobjektet som lagrar information om valideringslager och tillägg. VkPhysicalDevice representerar den fysiska GPU:n och möjliggör förfrågan om dess egenskaper, memory heaps och queue families. VkDevice — en logisk enhet med explicit efterfrågade köer och tillägg.

// Skapa logisk Vulkan-enhet
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);

Funktionen vkCreateDevice skapar en logisk enhet med angivna köer. VkQueue — en deskriptor för en kö för att skicka kommandon. En kö kan användas för grafik, beräkningar och kopiering, om motsvarande flaggor stöds av köfamiljen. Köprioritet (0.0–1.0) påverkar exekveringsordningen vid konkurrens.

VkMemory och VkBuffer — minneshantering

I Vulkan allokeras minne explicit via VkDeviceMemory. Utvecklaren begär memory types (HOST_VISIBLE, DEVICE_LOCAL) från den fysiska enheten och allokerar block. Buffertar (VkBuffer) och texturer (VkImage) har inget eget minne — de binds till allokerade block via vkBindBufferMemory.

Vulkan Memory Allocator (VMA) — ett bibliotek från AMD som förenklar minneshantering. VMA grupperar automatiskt små allokeringar i stora block, hanterar defragmentering och väljer lämplig memory type. Enligt AMD (2025) minskar VMA antalet minnesallokeringar 50–100 gånger jämfört med manuell hantering.

VkCommandPool och VkCommandBuffer

VkCommandPool hanterar minnet för kommandobuffertar. Buffertar (VkCommandBuffer) skrivs på CPU:n och skickas till GPU:n via vkQueueSubmit. Vulkan stöder primära och sekundära buffertar: primära skickas direkt, sekundära kan anropas från primära för flertrådad kommandokonstruktion.

Skrivning av kommandon börjar med vkBeginCommandBuffer och slutar med vkEndCommandBuffer. Mellan dem skrivs renderingskommandon: vkCmdDraw, vkCmdDispatch, vkCmdCopyBuffer och vkCmdPipelineBarrier för synkronisering. För varje bildruta skapas en ny kommandobuffert med pool reset.

Rendering via Vulkan: pipeline och kommandon

Rendering i Vulkan organiseras via pipelines (VkPipeline). Till skillnad från OpenGL, där pipelinestatus ändras globalt, använder Vulkan VkPipeline — en förkompilerad pipeline som omfattar alla steg: vertexinmatning, shaders, rasterisering, depth-stencil och blending.

VkPipeline — renderingspipeline

VkGraphicsPipelineCreateInfo beskriver hela pipeline: vertex- och fragmentshaders, topologi (triangle list, triangle strip), rasteriserare (fill mode, cull mode), multisampling, depth-stencil-tester, blending och viewport-inställningar. Pipeline skapas en gång och återanvänds — statusändring kräver en ny pipeline eller dynamic state.

// Konfiguration av grafisk 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) gör det möjligt att ändra vissa parametrar utan att skapa en ny pipeline. Vulkan 1.4 gjorde stöd för Dynamic State 3 (VK_EXT_extended_dynamic_state_3) obligatoriskt för hantering av blend constants, depth bias och topologi i farten, vilket minskar antalet pipelines i projektet.

Render Pass och Dynamic Rendering

VkRenderPass beskriver strukturen för renderingspass: vilka attachments som används, hur de rensas och laddas. Dynamic Rendering (VK_KHR_dynamic_rendering, obligatoriskt från Vulkan 1.4) förenklar processen: render-pass skapas i farten i kommandobufferten via vkCmdBeginRendering, utan ett förutgående VkRenderPass-objekt.

Enligt Khronos (2026) minskar Dynamic Rendering mängden initialiseringskod för Vulkan med 30–40% och minskar antalet pipeline-permutationer. För komplexa tekniker med uppskjuten rendering (Deferred Shading) är det fortfarande bekvämt att använda klassisk VkRenderPass med flera subpasses för G-buffer och belysning.

Shaders i Vulkan: SPIR-V och GLSL

SPIR-V — ett universellt binärt shaderformat i Vulkan, utvecklat av Khronos. Shaders kan skrivas i GLSL, HLSL eller språket Zink och kompileras till SPIR-V via glslangValidator, dxc eller Google Shaderc. Vulkan accepterar inte shaders i källkod — endast binärt SPIR-V.

GLSL i Vulkan

GLSL för Vulkan skiljer sig från standard OpenGL GLSL. Block (layout) används med explicit angivande av set- och binding-nummer, istället för inbyggda variabler. Vertexattribut anges via location, uniforms via uniform blocks eller buffertar. Push constants (upp till 128 byte) är tillgängliga för snabb dataöverföring utan buffertar.

// 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;
}

Kvalificerarna layout(set = N, binding = M) — den viktigaste skillnaden mellan Vulkan GLSL och OpenGL. Set motsvarar en deskriptorsamling (VkDescriptorSet), binding — en specifik resurs (buffert, textur, samplare). Uppdelningen i set möjliggör effektiv växling av resursamlingar mellan draw calls utan att binda enskilda resurser.

Deskriptorer och deskriptorsamlingar

VkDescriptorSet — en grupp resurser (buffertar, texturer, samplare) bundna till shaders. Deskriptorlayouten beskriver resurstyperna och deras binding-nummer. Deskriptorsamlingar uppdateras via vkUpdateDescriptorSets och återanvänds mellan draw calls. Vulkan 1.4 stöder VK_EXT_descriptor_buffer för direkt åtkomst till deskriptorer från GPU:n.

Push Constants — en mekanism för snabb överföring av små datamängder (upp till 128 byte) till shaders utan att skapa deskriptorer. Push constants anges via vkCmdPushConstants i kommandobufferten. Enligt Khronos (2025) minskar användning av push constants istället för uniform buffers CPU-overhead med 10–15% vid en frekvens av draw calls över 10 tusen per bildruta.

Vulkan på olika plattformar

Vulkan är det enda API som fungerar på alla större plattformar: Windows (via officiell ICD-drivrutin), Linux (RADV, AMDVLK, NVIDIA), Android (Vulkan 1.3+, obligatoriskt från Android 10) och på Apple-enheter via MoltenVK — översättningslagret Vulkan → Metal.

Vulkan på Android

På Android är Vulkan obligatoriskt för Android 10 och nyare. Google rekommenderar Vulkan för nya projekt, särskilt högpresterande spel och AR-applikationer via ARCore. Qualcomm Adreno och ARM Mali ger fullt stöd för Vulkan 1.3 med hårdvarustrålföljning på Adreno 8xx och Mali-G720.

Enligt Google (2026) stöder 98% av Android-enheterna med Android 10+ Vulkan. För bakåtkompatibilitet finns ANGLE (Almost Native Graphics Layer Engine), som översätter OpenGL ES till Vulkan. Detta gör det möjligt att köra gamla OpenGL-applikationer på Vulkan-drivrutinen med en prestandaökning på upp till 20%.

På Android har Vulkan hög prioritet för energieffektivitet: Vulkan-applikationer förbrukar 25–40% mindre energi jämfört med OpenGL ES vid samma grafiska belastning på enheter med Adreno 7xx+. Detta gör Vulkan till det föredragna API:et för spel på mobila enheter.

Vulkan på Apple via MoltenVK

MoltenVK — en implementering av Vulkan ovanpå Metal, utvecklad av LunarG och Valve. MoltenVK översätter Vulkan API-anrop till Metal och stöder Vulkan 1.2 på iOS och macOS. Prestandan för MoltenVK är nära inbyggd Metal: översättningsoverheaden är 5–15% beroende på scenario.

Enligt LunarG (2025) används MoltenVK i CrossOver (Wine för Mac) för att köra Windows-spel på macOS. Dota 2, Civilization VI och Baldur’s Gate 3 på macOS körs via MoltenVK med 30–60 FPS på M3/M4. MoltenVK stöder MetalFX-uppskalning för prestandaförbättring.

Vulkan Ray Tracing

VK_KHR_ray_tracing — tillägget för hårdvarustrålföljning i Vulkan, obligatoriskt från Vulkan 1.4. Stöds på GPU:er med RT-kärnor: NVIDIA RTX 20xx/30xx/40xx/50xx, AMD RX 6000+/9000, Intel Arc A/B. Vulkan RT tillhandahåller VkAccelerationStructure, VkRayTracingPipeline och Shader Binding Table.

Vulkan Ray Tracing stöder reflektioner, skuggor, ambient occlusion och global belysning i realtid. Enligt Khronos (2026) utför Vulkan Ray Tracing på NVIDIA RTX 5090 upp till 100 Giga rays/s i referenskvalitetsscener. För bärbara plattformar skalas Vulkan RT via blur reduction och temporal denoising.