Vulkan — was ist das, plattformübergreifende API und Rendering

Was ist Vulkan?

Vulkan ist eine Low-Level, plattformübergreifende API für die Arbeit mit Grafikprozessoren, die erstmals 2016 von der Khronos Group veröffentlicht wurde. Vulkan löste OpenGL ab und bietet deutlich geringeren CPU-Overhead, vorhersagbare Leistung und die Möglichkeit zur mehrthreadigen Befehlsgenerierung.

Im Gegensatz zu OpenGL, wo der Treiber Validierung und Synchronisation auf der CPU durchführt, überlässt Vulkan dem Entwickler die Ressourcenverwaltung. Speicherzuweisung, Synchronisation durch Semaphore und Barriers, Pipeline-Erstellung — all dies wird explizit gesteuert. Dieser Ansatz bringt bis zu 50% Leistungssteigerung in CPU-lastigen Szenarien.

Vulkan wird auf Windows, Linux, Android, iOS (über MoltenVK), macOS (MoltenVK), Nintendo Switch und Konsolen unterstützt. Laut Khronos Group (2026) läuft die API auf Geräten mit GPUs von NVIDIA, AMD, Intel, Qualcomm (Adreno), ARM (Mali) und Apple (über die Metal-Schicht). Vulkan 1.4 (2026) fügte Unterstützung für Mesh Shaders und die Video Encode API hinzu.

Geschichte von Vulkan

Ursprünglich wurde Vulkan unter dem Codenamen “glNext” entwickelt — dem Nachfolger von OpenGL. Vulkan 1.0 (2016) bot eine grundlegende API mit expliziter Speicherverwaltung, SPIR-V-Shadern und mehrthreadigen Warteschlangen. Vulkan 1.1 (2018) fügte Subgroup Operations und Unterstützung für 16-Bit-Typen hinzu. Vulkan 1.2 (2020) führte Buffer Device Address und Timeline Semaphores ein.

Vulkan 1.3 (2022) standardisierte Dynamic Rendering und die Graphics Pipeline Library. Vulkan 1.4 (2026) machte die Unterstützung von Mesh Shaders verbindlich und fügte die Video Encode/Decode API für hardwaregestützte Kodierung von H.264/HEVC/AV1 hinzu. Laut Khronos (2026) wird Vulkan 1.4 auf allen neuen NVIDIA RTX 50xx-, AMD RX 9000- und Intel Arc B-Serie-GPUs unterstützt.

Vulkan-Architektur: Gerät und Warteschlangen

Die Vulkan-Architektur basiert auf einer Hardware-Abstraktionsschicht (HW-Schicht). Die Anwendung interagiert über ein logisches Gerät (VkDevice) mit einem physischen Gerät (VkPhysicalDevice). Befehle werden an Warteschlangen (VkQueue) gesendet, die jeweils zu einer bestimmten Warteschlangenfamilie (graphics, compute, transfer) gehören.

VkInstance, VkDevice und VkQueue

VkInstance ist das Wurzelobjekt von Vulkan und speichert Informationen über Validierungsschichten und Erweiterungen. VkPhysicalDevice repräsentiert die physische GPU und ermöglicht die Abfrage ihrer Eigenschaften, Speicherbereiche und Warteschlangenfamilien. VkDevice ist ein logisches Gerät mit explizit angeforderten Warteschlangen und Erweiterungen.

// Erstellen eines logischen Vulkan-Geräts
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);

Die Funktion vkCreateDevice erstellt ein logisches Gerät mit den angegebenen Warteschlangen. VkQueue ist ein Warteschlangen-Handle zum Senden von Befehlen. Eine einzelne Warteschlange kann für Grafik, Compute und Kopie verwendet werden, wenn die entsprechenden Flags von der Warteschlangenfamilie unterstützt werden. Die Warteschlangenpriorität (0.0–1.0) beeinflusst die Ausführungsreihenfolge bei Konkurrenz.

VkMemory und VkBuffer — Speicherverwaltung

In Vulkan wird Speicher explizit über VkDeviceMemory zugewiesen. Der Entwickler fragt Speichertypen (HOST_VISIBLE, DEVICE_LOCAL) vom physischen Gerät ab und weist Blöcke zu. Puffer (VkBuffer) und Texturen (VkImage) haben keinen eigenen Speicher — sie werden über vkBindBufferMemory an zugewiesene Blöcke gebunden.

Vulkan Memory Allocator (VMA) ist eine Bibliothek von AMD, die die Speicherverwaltung vereinfacht. VMA gruppiert kleine Zuweisungen automatisch in große Blöcke, verwaltet die Defragmentierung und wählt den geeigneten Speichertyp aus. Laut AMD (2025) reduziert VMA die Anzahl der Speicherzuweisungen um das 50- bis 100-fache im Vergleich zur manuellen Verwaltung.

VkCommandPool und VkCommandBuffer

VkCommandPool verwaltet den Speicher für Befehlspuffer. Puffer (VkCommandBuffer) werden auf der CPU aufgezeichnet und über vkQueueSubmit an die GPU gesendet. Vulkan unterstützt primäre und sekundäre Puffer: primäre werden direkt gesendet, sekundäre können von primären für mehrthreadige Befehlskonstruktion aufgerufen werden.

Die Befehlsaufzeichnung beginnt mit vkBeginCommandBuffer und endet mit vkEndCommandBuffer. Dazwischen werden Rendering-Befehle aufgezeichnet: vkCmdDraw, vkCmdDispatch, vkCmdCopyBuffer und vkCmdPipelineBarrier zur Synchronisation. Für jeden Frame wird ein neuer Befehlspuffer mit Pooling über Pool-Reset erstellt.

Rendering mit Vulkan: Pipeline und Befehle

Rendering in Vulkan wird über Pipelines (VkPipeline) organisiert. Im Gegensatz zu OpenGL, wo der Pipeline-Zustand global geändert wird, verwendet Vulkan VkPipeline — eine vorcompilierte Pipeline, die alle Stufen umfasst: Vertex-Eingabe, Shader, Rasterisierung, Depth-Stencil und Blending.

VkPipeline — Rendering-Pipeline

VkGraphicsPipelineCreateInfo beschreibt die vollständige Pipeline: Vertex- und Fragment-Shader, Topologie (triangle list, triangle strip), Rasterizer (fill mode, cull mode), Multisampling, Depth-Stencil-Tests, Blending und Viewport-Einstellungen. Die Pipeline wird einmal erstellt und wiederverwendet — eine Zustandsänderung erfordert eine neue Pipeline oder dynamischen Zustand.

// Einrichten der Grafik-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) erlaubt das Ändern bestimmter Parameter ohne Erstellung einer neuen Pipeline. Vulkan 1.4 machte die Unterstützung von Dynamic State 3 (VK_EXT_extended_dynamic_state_3) zur Verwaltung von Blend-Konstanten, Depth Bias und Topologie im laufenden Betrieb verbindlich, was die Anzahl der Pipelines in einem Projekt reduziert.

Render Pass und Dynamic Rendering

VkRenderPass beschreibt die Struktur der Rendering-Durchgänge: welche Attachments verwendet werden, wie sie gelöscht und geladen werden. Dynamic Rendering (VK_KHR_dynamic_rendering, seit Vulkan 1.4 verbindlich) vereinfacht den Prozess: Der Render-Pass wird im Befehlspuffer über vkCmdBeginRendering im laufenden Betrieb erstellt, ohne ein vorheriges VkRenderPass-Objekt.

Laut Khronos (2026) reduziert Dynamic Rendering den Vulkan-Initialisierungscode um 30–40% und verringert die Anzahl der Pipeline-Permutationen. Für komplexe Deferred-Rendering-Techniken (Deferred Shading) ist weiterhin der klassische VkRenderPass mit mehreren Subpasses für G-Buffer und Beleuchtung praktisch.

Shader in Vulkan: SPIR-V und GLSL

SPIR-V ist ein universelles binäres Shader-Format in Vulkan, entwickelt von Khronos. Shader können in GLSL, HLSL oder der Zink-Sprache geschrieben und über glslangValidator, dxc oder Google Shaderc in SPIR-V kompiliert werden. Vulkan akzeptiert keine Shader im Quellcode — nur binäres SPIR-V.

GLSL in Vulkan

GLSL für Vulkan unterscheidet sich vom Standard-OpenGL-GLSL. Anstelle von Built-in-Variablen werden Blöcke (layout) mit expliziten Set- und Binding-Nummern verwendet. Vertex-Attribute werden über Location spezifiziert, Uniforms über Uniform-Blöcke oder Puffer. Push Constants (bis zu 128 Byte) stehen für schnelle Datenübertragung ohne Puffer zur Verfügung.

// Vulkan/GLSL Vertex-Shader
#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;
}

Die Qualifizierer layout(set = N, binding = M) sind ein wesentlicher Unterschied zwischen Vulkan GLSL und OpenGL. Set entspricht einem Deskriptor-Set (VkDescriptorSet), Binding entspricht einer bestimmten Ressource (Puffer, Textur, Sampler). Die Aufteilung in Sets ermöglicht effizientes Umschalten von Ressourcensätzen zwischen Draw Calls ohne Binden einzelner Ressourcen.

Deskriptoren und Deskriptor-Sets

VkDescriptorSet ist eine Gruppe von Ressourcen (Puffer, Texturen, Sampler), die an Shader gebunden sind. Das Deskriptor-Layout beschreibt die Ressourcentypen und ihre Binding-Nummern. Deskriptor-Sets werden über vkUpdateDescriptorSets aktualisiert und zwischen Draw Calls wiederverwendet. Vulkan 1.4 unterstützt VK_EXT_descriptor_buffer für direkten Zugriff auf Deskriptoren von der GPU.

Push Constants sind ein Mechanismus zur schnellen Übertragung kleiner Datenmengen (bis zu 128 Byte) an Shader ohne Erstellung von Deskriptoren. Push Constants werden über vkCmdPushConstants im Befehlspuffer gesetzt. Laut Khronos (2025) reduziert die Verwendung von Push Constants anstelle von Uniform Buffers den CPU-Overhead um 10–15% bei Draw-Call-Raten von über 10.000 pro Frame.

Vulkan auf verschiedenen Plattformen

Vulkan ist die einzige API, die auf allen wichtigen Plattformen funktioniert: Windows (über offiziellen ICD-Treiber), Linux (RADV, AMDVLK, NVIDIA), Android (Vulkan 1.3+, verbindlich seit Android 10) und auf Apple-Geräten über MoltenVK — eine Übersetzungsschicht von Vulkan zu Metal.

Vulkan auf Android

Auf Android ist Vulkan für Android 10 und neuer verbindlich. Google empfiehlt Vulkan für neue Projekte, insbesondere für leistungsstarke Spiele und AR-Anwendungen über ARCore. Qualcomm Adreno und ARM Mali bieten vollständige Vulkan 1.3-Unterstützung mit hardwarebeschleunigtem Ray Tracing auf Adreno 8xx und Mali-G720.

Laut Google (2026) unterstützen 98% der Android-Geräte mit Android 10+ Vulkan. Für Abwärtskompatibilität steht ANGLE (Almost Native Graphics Layer Engine) zur Verfügung, das OpenGL ES in Vulkan übersetzt. Dadurch können ältere OpenGL-Anwendungen auf einem Vulkan-Treiber mit bis zu 20% Leistungssteigerung ausgeführt werden.

Unter Android hat Vulkan hohe Priorität für Energieeffizienz: Vulkan-Anwendungen verbrauchen auf Geräten mit Adreno 7xx+ bei gleicher Grafiklast 25–40% weniger Energie im Vergleich zu OpenGL ES. Dies macht Vulkan zur bevorzugten API für Spiele auf Mobilgeräten.

Vulkan auf Apple über MoltenVK

MoltenVK ist eine Vulkan-Implementierung auf Basis von Metal, entwickelt von LunarG und Valve. MoltenVK übersetzt Vulkan-API-Aufrufe in Metal und unterstützt Vulkan 1.2 unter iOS und macOS. Die Leistung von MoltenVK liegt nahe an nativem Metal: der Übersetzungs-Overhead beträgt je nach Szenario 5–15%.

Laut LunarG (2025) wird MoltenVK in CrossOver (Wine für Mac) verwendet, um Windows-Spiele unter macOS auszuführen. Dota 2, Civilization VI und Baldur's Gate 3 laufen unter macOS über MoltenVK mit 30–60 FPS auf M3/M4. MoltenVK unterstützt MetalFX-Upscaling zur Leistungssteigerung.

Vulkan Ray Tracing

VK_KHR_ray_tracing ist eine Erweiterung für hardwarebeschleunigtes Ray Tracing in Vulkan, verbindlich seit Vulkan 1.4. Unterstützt auf GPUs mit RT-Kernen: NVIDIA RTX 20xx/30xx/40xx/50xx, AMD RX 6000+/9000, Intel Arc A/B. Vulkan RT bietet VkAccelerationStructure, VkRayTracingPipeline und Shader Binding Table.

Vulkan Ray Tracing unterstützt Reflexionen, Schatten, Ambient Occlusion und globale Beleuchtung in Echtzeit. Laut Khronos (2026) erreicht Vulkan Ray Tracing auf der NVIDIA RTX 5090 bis zu 100 Giga rays/s in Referenzqualität-Szenen. Für portable Plattformen skaliert Vulkan RT durch Blur-Reduktion und temporales Denoising.