Vulkan — qu'est-ce que c'est, API multiplateforme et rendu

Qu'est-ce que Vulkan ?

Vulkan est une API bas niveau et multiplateforme pour travailler avec les unités de traitement graphique, publiée pour la première fois par Khronos Group en 2016. Vulkan a succédé à OpenGL, offrant une surcharge CPU considérablement réduite, des performances prévisibles et la possibilité de génération multithread de commandes.

Contrairement à OpenGL, où le pilote effectue la validation et la synchronisation sur le CPU, Vulkan confie la gestion des ressources au développeur. Allocation mémoire, synchronisation via sémaphores et barrières, création de pipelines — tout cela est contrôlé explicitement. Cette approche offre jusqu'à 50% d'amélioration des performances dans les scénarios limités par le CPU.

Vulkan est pris en charge sur Windows, Linux, Android, iOS (via MoltenVK), macOS (MoltenVK), Nintendo Switch et les consoles. Selon Khronos Group (2026), l'API fonctionne sur des appareils avec GPU de NVIDIA, AMD, Intel, Qualcomm (Adreno), ARM (Mali) et Apple (via la couche Metal). Vulkan 1.4 (2026) a ajouté la prise en charge des Mesh Shaders et de Video Encode API.

Histoire de Vulkan

À l'origine, Vulkan a été développé sous le nom de code « glNext » — le successeur d'OpenGL. Vulkan 1.0 (2016) a fourni une API de base avec gestion explicite de la mémoire, shaders SPIR-V et files d'attente multithread. Vulkan 1.1 (2018) a ajouté Subgroup Operations et la prise en charge des types 16 bits. Vulkan 1.2 (2020) a introduit Buffer Device Address et Timeline Semaphores.

Vulkan 1.3 (2022) a standardisé Dynamic Rendering et Graphics Pipeline Library. Vulkan 1.4 (2026) a rendu obligatoire la prise en charge des Mesh Shaders et a ajouté Video Encode/Decode API pour l'encodage matériel H.264/HEVC/AV1. Selon Khronos (2026), Vulkan 1.4 est pris en charge sur tous les nouveaux GPU NVIDIA RTX 50xx, AMD RX 9000 et Intel Arc B-series.

Architecture de Vulkan : périphérique et files d'attente

L'architecture de Vulkan est construite sur une couche d'abstraction matérielle (couche HW). L'application interagit avec un périphérique physique (VkPhysicalDevice) via un périphérique logique (VkDevice). Les commandes sont envoyées aux files d'attente (VkQueue), chacune appartenant à une famille de files d'attente spécifique (graphics, compute, transfer).

VkInstance, VkDevice et VkQueue

VkInstance est l'objet racine de Vulkan, stockant des informations sur les couches de validation et les extensions. VkPhysicalDevice représente le GPU physique et permet d'interroger ses propriétés, ses tas mémoire et ses familles de files d'attente. VkDevice est un périphérique logique avec des files d'attente et des extensions demandées explicitement.

// Création d'un périphérique logique Vulkan
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);

La fonction vkCreateDevice crée un périphérique logique avec les files d'attente spécifiées. VkQueue est un handle de file d'attente pour envoyer des commandes. Une seule file d'attente peut être utilisée pour les graphismes, le calcul et la copie si les indicateurs correspondants sont pris en charge par la famille de files d'attente. La priorité de la file d'attente (0.0–1.0) affecte l'ordre d'exécution en cas de concurrence.

VkMemory et VkBuffer — gestion de la mémoire

Dans Vulkan, la mémoire est allouée explicitement via VkDeviceMemory. Le développeur interroge les types de mémoire (HOST_VISIBLE, DEVICE_LOCAL) auprès du périphérique physique et alloue des blocs. Les tampons (VkBuffer) et les textures (VkImage) n'ont pas leur propre mémoire — ils sont liés aux blocs alloués via vkBindBufferMemory.

Vulkan Memory Allocator (VMA) est une bibliothèque d'AMD qui simplifie la gestion de la mémoire. VMA regroupe automatiquement les petites allocations en gros blocs, gère la défragmentation et sélectionne le type de mémoire approprié. Selon AMD (2025), VMA réduit le nombre d'allocations mémoire de 50 à 100 fois par rapport à la gestion manuelle.

VkCommandPool et VkCommandBuffer

VkCommandPool gère la mémoire pour les tampons de commandes. Les tampons (VkCommandBuffer) sont enregistrés sur le CPU et envoyés au GPU via vkQueueSubmit. Vulkan prend en charge les tampons primaires et secondaires : les primaires sont envoyés directement, les secondaires peuvent être appelés à partir des primaires pour la construction multithread de commandes.

L'enregistrement des commandes commence par vkBeginCommandBuffer et se termine par vkEndCommandBuffer. Entre les deux, des commandes de rendu sont enregistrées : vkCmdDraw, vkCmdDispatch, vkCmdCopyBuffer et vkCmdPipelineBarrier pour la synchronisation. Un nouveau tampon de commandes est créé pour chaque image avec mise en commun via la réinitialisation du pool.

Rendu avec Vulkan : pipeline et commandes

Le rendu dans Vulkan est organisé via des pipelines (VkPipeline). Contrairement à OpenGL, où l'état du pipeline est modifié globalement, Vulkan utilise VkPipeline — un pipeline précompilé qui inclut toutes les étapes : entrée des sommets, shaders, rastérisation, depth-stencil et blending.

VkPipeline — pipeline de rendu

VkGraphicsPipelineCreateInfo décrit le pipeline complet : shaders de sommets et de fragments, topologie (triangle list, triangle strip), rastériseur (fill mode, cull mode), multi-échantillonnage, tests depth-stencil, blending et paramètres du viewport. Le pipeline est créé une fois et réutilisé — un changement d'état nécessite un nouveau pipeline ou un état dynamique.

// Configuration du pipeline graphique
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);

L'état dynamique (VK_DYNAMIC_STATE_VIEWPORT, VK_DYNAMIC_STATE_SCISSOR) permet de modifier certains paramètres sans créer un nouveau pipeline. Vulkan 1.4 a rendu obligatoire la prise en charge de Dynamic State 3 (VK_EXT_extended_dynamic_state_3) pour gérer les constantes de blending, le depth bias et la topologie à la volée, réduisant ainsi le nombre de pipelines dans un projet.

Render Pass et Dynamic Rendering

VkRenderPass décrit la structure des passes de rendu : quelles pièces jointes sont utilisées, comment elles sont effacées et chargées. Dynamic Rendering (VK_KHR_dynamic_rendering, obligatoire depuis Vulkan 1.4) simplifie le processus : la passe de rendu est créée à la volée dans le tampon de commandes via vkCmdBeginRendering, sans objet VkRenderPass préalable.

Selon Khronos (2026), Dynamic Rendering réduit le code d'initialisation de Vulkan de 30–40% et diminue le nombre de permutations de pipeline. Pour les techniques de rendu différé complexes (Deferred Shading), il est toujours pratique d'utiliser VkRenderPass classique avec plusieurs sous-passes pour le G-buffer et l'éclairage.

Shaders dans Vulkan : SPIR-V et GLSL

SPIR-V est un format binaire universel de shaders dans Vulkan, développé par Khronos. Les shaders peuvent être écrits en GLSL, HLSL ou langage Zink et compilés en SPIR-V via glslangValidator, dxc ou Google Shaderc. Vulkan n'accepte pas les shaders en code source — seulement du SPIR-V binaire.

GLSL dans Vulkan

GLSL pour Vulkan diffère du GLSL standard d'OpenGL. Des blocs (layout) sont utilisés avec des numéros de set et de binding explicites, plutôt que des variables intégrées. Les attributs de sommets sont spécifiés via location, les uniforms via des uniform blocks ou des tampons. Push constants (jusqu'à 128 octets) sont disponibles pour un transfert rapide de données sans tampons.

// Shader de sommets 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;
}

Les qualificateurs layout(set = N, binding = M) sont une différence clé entre Vulkan GLSL et OpenGL. Set correspond à un ensemble de descripteurs (VkDescriptorSet), binding correspond à une ressource spécifique (tampon, texture, sampler). La séparation en ensembles permet de changer efficacement les ensembles de ressources entre les appels de dessin sans lier des ressources individuelles.

Descripteurs et ensembles de descripteurs

VkDescriptorSet est un groupe de ressources (tampons, textures, samplers) liées aux shaders. La disposition des descripteurs décrit les types de ressources et leurs numéros de binding. Les ensembles de descripteurs sont mis à jour via vkUpdateDescriptorSets et réutilisés entre les appels de dessin. Vulkan 1.4 prend en charge VK_EXT_descriptor_buffer pour l'accès direct aux descripteurs depuis le GPU.

Push Constants sont un mécanisme de transfert rapide de petits volumes de données (jusqu'à 128 octets) vers les shaders sans créer de descripteurs. Les push constants sont définies via vkCmdPushConstants dans le tampon de commandes. Selon Khronos (2025), l'utilisation de push constants au lieu d'uniform buffers réduit la surcharge CPU de 10–15% à des taux d'appels de dessin supérieurs à 10 000 par image.

Vulkan sur différentes plateformes

Vulkan est la seule API qui fonctionne sur toutes les principales plateformes : Windows (via le pilote ICD officiel), Linux (RADV, AMDVLK, NVIDIA), Android (Vulkan 1.3+, obligatoire depuis Android 10), et sur les appareils Apple via MoltenVK — une couche de traduction de Vulkan vers Metal.

Vulkan sur Android

Sur Android, Vulkan est obligatoire pour Android 10 et versions ultérieures. Google recommande Vulkan pour les nouveaux projets, en particulier les jeux hautes performances et les applications AR via ARCore. Qualcomm Adreno et ARM Mali offrent une prise en charge complète de Vulkan 1.3 avec ray tracing matériel sur Adreno 8xx et Mali-G720.

Selon Google (2026), 98% des appareils Android avec Android 10+ prennent en charge Vulkan. Pour la rétrocompatibilité, ANGLE (Almost Native Graphics Layer Engine) est disponible, qui traduit OpenGL ES en Vulkan. Cela permet d'exécuter d'anciennes applications OpenGL sur un pilote Vulkan avec jusqu'à 20% d'amélioration des performances.

Sur Android, Vulkan a une priorité élevée pour l'efficacité énergétique : les applications Vulkan consomment 25–40% d'énergie en moins par rapport à OpenGL ES sous la même charge graphique sur les appareils avec Adreno 7xx+. Cela fait de Vulkan l'API préférée pour les jeux sur appareils mobiles.

Vulkan sur Apple via MoltenVK

MoltenVK est une implémentation de Vulkan sur Metal, développée par LunarG et Valve. MoltenVK traduit les appels de l'API Vulkan en Metal, prenant en charge Vulkan 1.2 sur iOS et macOS. Les performances de MoltenVK sont proches du Metal natif : la surcharge de traduction est de 5–15% selon le scénario.

Selon LunarG (2025), MoltenVK est utilisé dans CrossOver (Wine pour Mac) pour exécuter des jeux Windows sur macOS. Dota 2, Civilization VI et Baldur's Gate 3 sur macOS fonctionnent via MoltenVK avec des performances de 30–60 FPS sur M3/M4. MoltenVK prend en charge l'upscaling MetalFX pour améliorer les performances.

Vulkan Ray Tracing

VK_KHR_ray_tracing est une extension pour le ray tracing matériel dans Vulkan, obligatoire depuis Vulkan 1.4. Prise en charge sur les GPU avec cœurs RT : NVIDIA RTX 20xx/30xx/40xx/50xx, AMD RX 6000+/9000, Intel Arc A/B. Vulkan RT fournit VkAccelerationStructure, VkRayTracingPipeline et Shader Binding Table.

Vulkan Ray Tracing prend en charge les réflexions, les ombres, l'occlusion ambiante et l'éclairage global en temps réel. Selon Khronos (2026), sur la NVIDIA RTX 5090, Vulkan Ray Tracing atteint jusqu'à 100 Giga rays/s dans des scènes de qualité de référence. Pour les plateformes portables, Vulkan RT évolue via la réduction du flou et le débruitage temporel.