Vulkan — qué es, API multiplataforma y renderizado

¿Qué es Vulkan?

Vulkan es una API de bajo nivel y multiplataforma para trabajar con unidades de procesamiento gráfico, lanzada por primera vez por Khronos Group en 2016. Vulkan sucedió a OpenGL, ofreciendo una sobrecarga de CPU significativamente menor, rendimiento predecible y la capacidad de generación multiproceso de comandos.

A diferencia de OpenGL, donde el controlador realiza validación y sincronización en la CPU, Vulkan delega la gestión de recursos al desarrollador. Asignación de memoria, sincronización mediante semáforos y barreras, creación de pipelines — todo esto se controla explícitamente. Este enfoque proporciona hasta un 50% de mejora de rendimiento en escenarios con limitación de CPU.

Vulkan es compatible con Windows, Linux, Android, iOS (a través de MoltenVK), macOS (MoltenVK), Nintendo Switch y consolas. Según Khronos Group (2026), la API funciona en dispositivos con GPU de NVIDIA, AMD, Intel, Qualcomm (Adreno), ARM (Mali) y Apple (a través de la capa Metal). Vulkan 1.4 (2026) añadió soporte para Mesh Shaders y Video Encode API.

Historia de Vulkan

Originalmente, Vulkan se desarrolló bajo el nombre clave “glNext” — el sucesor de OpenGL. Vulkan 1.0 (2016) proporcionó una API básica con gestión explícita de memoria, shaders SPIR-V y colas multiproceso. Vulkan 1.1 (2018) añadió Subgroup Operations y soporte para tipos de 16 bits. Vulkan 1.2 (2020) introdujo Buffer Device Address y Timeline Semaphores.

Vulkan 1.3 (2022) estandarizó Dynamic Rendering y Graphics Pipeline Library. Vulkan 1.4 (2026) hizo obligatorio el soporte de Mesh Shaders y añadió Video Encode/Decode API para codificación por hardware de H.264/HEVC/AV1. Según Khronos (2026), Vulkan 1.4 es compatible con todas las GPU nuevas NVIDIA RTX 50xx, AMD RX 9000 e Intel Arc B-series.

Arquitectura de Vulkan: dispositivo y colas

La arquitectura de Vulkan se basa en una capa de abstracción de hardware (capa HW). La aplicación interactúa con un dispositivo físico (VkPhysicalDevice) a través de un dispositivo lógico (VkDevice). Los comandos se envían a colas (VkQueue), cada una perteneciente a una familia de colas específica (graphics, compute, transfer).

VkInstance, VkDevice y VkQueue

VkInstance es el objeto raíz de Vulkan que almacena información sobre capas de validación y extensiones. VkPhysicalDevice representa la GPU física y permite consultar sus propiedades, montones de memoria y familias de colas. VkDevice es un dispositivo lógico con colas y extensiones solicitadas explícitamente.

// Creación de un dispositivo lógico de 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 función vkCreateDevice crea un dispositivo lógico con las colas especificadas. VkQueue es un identificador de cola para enviar comandos. Una sola cola se puede usar para gráficos, cómputo y copia si los flags correspondientes son compatibles con la familia de colas. La prioridad de la cola (0.0–1.0) afecta el orden de ejecución bajo contención.

VkMemory y VkBuffer — gestión de memoria

En Vulkan, la memoria se asigna explícitamente a través de VkDeviceMemory. El desarrollador consulta los tipos de memoria (HOST_VISIBLE, DEVICE_LOCAL) del dispositivo físico y asigna bloques. Los búferes (VkBuffer) y las texturas (VkImage) no tienen memoria propia — se vinculan a bloques asignados mediante vkBindBufferMemory.

Vulkan Memory Allocator (VMA) es una biblioteca de AMD que simplifica la gestión de memoria. VMA agrupa automáticamente asignaciones pequeñas en bloques grandes, gestiona la desfragmentación y selecciona el tipo de memoria adecuado. Según AMD (2025), VMA reduce el número de asignaciones de memoria entre 50 y 100 veces en comparación con la gestión manual.

VkCommandPool y VkCommandBuffer

VkCommandPool gestiona la memoria para los búferes de comandos. Los búferes (VkCommandBuffer) se registran en la CPU y se envían a la GPU mediante vkQueueSubmit. Vulkan admite búferes primarios y secundarios: los primarios se envían directamente, los secundarios se pueden llamar desde primarios para la construcción multiproceso de comandos.

El registro de comandos comienza con vkBeginCommandBuffer y termina con vkEndCommandBuffer. Entre ellos se registran comandos de renderizado: vkCmdDraw, vkCmdDispatch, vkCmdCopyBuffer y vkCmdPipelineBarrier para sincronización. Se crea un nuevo búfer de comandos para cada fotograma con agrupación mediante pool reset.

Renderizado con Vulkan: pipeline y comandos

El renderizado en Vulkan se organiza a través de pipelines (VkPipeline). A diferencia de OpenGL, donde el estado del pipeline se cambia globalmente, Vulkan usa VkPipeline — un pipeline precompilado que incluye todas las etapas: entrada de vértices, shaders, rasterización, depth-stencil y blending.

VkPipeline — pipeline de renderizado

VkGraphicsPipelineCreateInfo describe el pipeline completo: shaders de vértices y fragmentos, topología (triangle list, triangle strip), rasterizador (fill mode, cull mode), multisampling, pruebas depth-stencil, blending y configuración de viewport. El pipeline se crea una vez y se reutiliza — cambiar el estado requiere un nuevo pipeline o estado dinámico.

// Configuración del pipeline gráfico
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) permite cambiar ciertos parámetros sin crear un nuevo pipeline. Vulkan 1.4 hizo obligatorio el soporte para Dynamic State 3 (VK_EXT_extended_dynamic_state_3) para gestionar blend constants, depth bias y topología sobre la marcha, reduciendo el número de pipelines en un proyecto.

Render Pass y Dynamic Rendering

VkRenderPass describe la estructura de los pases de renderizado: qué attachments se usan, cómo se limpian y cargan. Dynamic Rendering (VK_KHR_dynamic_rendering, obligatorio desde Vulkan 1.4) simplifica el proceso: el render pass se crea sobre la marcha en el búfer de comandos mediante vkCmdBeginRendering, sin un objeto VkRenderPass previo.

Según Khronos (2026), Dynamic Rendering reduce el código de inicialización de Vulkan en un 30–40% y disminuye el número de permutaciones de pipeline. Para técnicas de renderizado diferido complejas (Deferred Shading), sigue siendo conveniente usar VkRenderPass clásico con varios subpasses para G-buffer e iluminación.

Shaders en Vulkan: SPIR-V y GLSL

SPIR-V es un formato binario universal de shaders en Vulkan, desarrollado por Khronos. Los shaders se pueden escribir en GLSL, HLSL o lenguaje Zink y compilarse a SPIR-V mediante glslangValidator, dxc o Google Shaderc. Vulkan no acepta shaders en código fuente — solo SPIR-V binario.

GLSL en Vulkan

GLSL para Vulkan difiere del GLSL estándar de OpenGL. Se utilizan bloques (layout) con indicación explícita de números de set y binding, en lugar de variables integradas. Los atributos de vértices se especifican mediante location, los uniforms mediante uniform blocks o búferes. Push constants (hasta 128 bytes) están disponibles para transferencia rápida de datos sin búferes.

// Shader de vértices 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;
}

Los calificadores layout(set = N, binding = M) son una diferencia clave entre Vulkan GLSL y OpenGL. Set corresponde a un descriptor set (VkDescriptorSet), binding corresponde a un recurso específico (búfer, textura, sampler). La separación en sets permite cambiar eficientemente conjuntos de recursos entre draw calls sin vincular recursos individuales.

Descriptores y conjuntos de descriptores

VkDescriptorSet es un grupo de recursos (búferes, texturas, samplers) vinculados a shaders. El layout de descriptores describe los tipos de recursos y sus números de binding. Los descriptor sets se actualizan mediante vkUpdateDescriptorSets y se reutilizan entre draw calls. Vulkan 1.4 admite VK_EXT_descriptor_buffer para acceso directo a descriptores desde la GPU.

Push Constants es un mecanismo para la transferencia rápida de pequeños volúmenes de datos (hasta 128 bytes) a shaders sin crear descriptores. Las push constants se establecen mediante vkCmdPushConstants en el búfer de comandos. Según Khronos (2025), usar push constants en lugar de uniform buffers reduce la sobrecarga de CPU en un 10–15% con tasas de draw calls superiores a 10 mil por fotograma.

Vulkan en diferentes plataformas

Vulkan es la única API que funciona en todas las plataformas principales: Windows (a través del controlador ICD oficial), Linux (RADV, AMDVLK, NVIDIA), Android (Vulkan 1.3+, obligatorio desde Android 10), y en dispositivos Apple a través de MoltenVK — una capa de traducción de Vulkan a Metal.

Vulkan en Android

En Android, Vulkan es obligatorio para Android 10 y versiones posteriores. Google recomienda Vulkan para nuevos proyectos, especialmente juegos de alto rendimiento y aplicaciones AR a través de ARCore. Qualcomm Adreno y ARM Mali proporcionan soporte completo de Vulkan 1.3 con trazado de rayos por hardware en Adreno 8xx y Mali-G720.

Según Google (2026), el 98% de los dispositivos Android con Android 10+ son compatibles con Vulkan. Para compatibilidad hacia atrás, está disponible ANGLE (Almost Native Graphics Layer Engine), que traduce OpenGL ES a Vulkan. Esto permite ejecutar aplicaciones OpenGL antiguas en un controlador Vulkan con hasta un 20% de mejora de rendimiento.

En Android, Vulkan tiene alta prioridad para eficiencia energética: las aplicaciones Vulkan consumen 25–40% menos energía en comparación con OpenGL ES bajo la misma carga gráfica en dispositivos con Adreno 7xx+. Esto convierte a Vulkan en la API preferida para juegos móviles.

Vulkan en Apple mediante MoltenVK

MoltenVK es una implementación de Vulkan sobre Metal, desarrollada por LunarG y Valve. MoltenVK traduce las llamadas de la API de Vulkan a Metal, compatible con Vulkan 1.2 en iOS y macOS. El rendimiento de MoltenVK es cercano al Metal nativo: la sobrecarga de traducción es del 5–15% según el escenario.

Según LunarG (2025), MoltenVK se usa en CrossOver (Wine para Mac) para ejecutar juegos de Windows en macOS. Dota 2, Civilization VI y Baldur's Gate 3 en macOS funcionan a través de MoltenVK con rendimiento de 30–60 FPS en M3/M4. MoltenVK admite MetalFX upscaling para mejorar el rendimiento.

Vulkan Ray Tracing

VK_KHR_ray_tracing es una extensión para trazado de rayos por hardware en Vulkan, obligatoria desde Vulkan 1.4. Compatible con GPU con núcleos RT: NVIDIA RTX 20xx/30xx/40xx/50xx, AMD RX 6000+/9000, Intel Arc A/B. Vulkan RT proporciona VkAccelerationStructure, VkRayTracingPipeline y Shader Binding Table.

Vulkan Ray Tracing admite reflejos, sombras, oclusión ambiental e iluminación global en tiempo real. Según Khronos (2026), en NVIDIA RTX 5090, Vulkan Ray Tracing alcanza hasta 100 Giga rays/s en escenas de calidad de referencia. Para plataformas portátiles, Vulkan RT escala mediante reducción de desenfoque y denoising temporal.