Vulkan — o que é, API multiplataforma e renderização

O que é Vulkan?

Vulkan é uma API de baixo nível e multiplataforma para trabalhar com unidades de processamento gráfico, lançada pela primeira vez pela Khronos Group em 2016. Vulkan sucedeu o OpenGL, oferecendo sobrecarga de CPU significativamente menor, desempenho previsível e capacidade de geração multithread de comandos.

Ao contrário do OpenGL, onde o driver realiza validação e sincronização na CPU, o Vulkan coloca o gerenciamento de recursos nas mãos do desenvolvedor. Alocação de memória, sincronização através de semáforos e barreiras, criação de pipelines — tudo isso é controlado explicitamente. Essa abordagem proporciona até 50% de melhoria de desempenho em cenários com limitação de CPU.

Vulkan é suportado no Windows, Linux, Android, iOS (via MoltenVK), macOS (MoltenVK), Nintendo Switch e consoles. De acordo com a Khronos Group (2026), a API funciona em dispositivos com GPUs da NVIDIA, AMD, Intel, Qualcomm (Adreno), ARM (Mali) e Apple (através da camada Metal). O Vulkan 1.4 (2026) adicionou suporte para Mesh Shaders e Video Encode API.

História do Vulkan

Originalmente, o Vulkan foi desenvolvido sob o codinome “glNext” — o sucessor do OpenGL. O Vulkan 1.0 (2016) forneceu uma API básica com gerenciamento explícito de memória, shaders SPIR-V e filas multithread. O Vulkan 1.1 (2018) adicionou Subgroup Operations e suporte para tipos de 16 bits. O Vulkan 1.2 (2020) introduziu Buffer Device Address e Timeline Semaphores.

O Vulkan 1.3 (2022) padronizou Dynamic Rendering e Graphics Pipeline Library. Vulkan 1.4 (2026) tornou obrigatório o suporte a Mesh Shaders e adicionou Video Encode/Decode API para codificação por hardware de H.264/HEVC/AV1. De acordo com a Khronos (2026), o Vulkan 1.4 é suportado em todas as novas GPUs NVIDIA RTX 50xx, AMD RX 9000 e Intel Arc B-series.

Arquitetura do Vulkan: dispositivo e filas

A arquitetura do Vulkan é construída sobre uma camada de abstração de hardware (camada HW). A aplicação interage com um dispositivo físico (VkPhysicalDevice) através de um dispositivo lógico (VkDevice). Os comandos são enviados para filas (VkQueue), cada uma pertencente a uma família de filas específica (graphics, compute, transfer).

VkInstance, VkDevice e VkQueue

VkInstance é o objeto raiz do Vulkan, que armazena informações sobre camadas de validação e extensões. VkPhysicalDevice representa a GPU física e permite consultar suas propriedades, heaps de memória e famílias de filas. VkDevice é um dispositivo lógico com filas e extensões solicitadas explicitamente.

// Criação de um dispositivo lógico 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);

A função vkCreateDevice cria um dispositivo lógico com as filas especificadas. VkQueue é um identificador de fila para enviar comandos. Uma única fila pode ser usada para gráficos, computação e cópia se os flags correspondentes forem suportados pela família de filas. A prioridade da fila (0.0–1.0) afeta a ordem de execução sob contenção.

VkMemory e VkBuffer — gerenciamento de memória

No Vulkan, a memória é alocada explicitamente através de VkDeviceMemory. O desenvolvedor consulta os tipos de memória (HOST_VISIBLE, DEVICE_LOCAL) do dispositivo físico e aloca blocos. Buffers (VkBuffer) e texturas (VkImage) não têm memória própria — eles são vinculados a blocos alocados via vkBindBufferMemory.

Vulkan Memory Allocator (VMA) é uma biblioteca da AMD que simplifica o gerenciamento de memória. A VMA agrupa automaticamente pequenas alocações em blocos grandes, gerencia a desfragmentação e seleciona o tipo de memória adequado. De acordo com a AMD (2025), a VMA reduz o número de alocações de memória em 50 a 100 vezes em comparação com o gerenciamento manual.

VkCommandPool e VkCommandBuffer

VkCommandPool gerencia a memória para buffers de comando. Os buffers (VkCommandBuffer) são gravados na CPU e enviados para a GPU via vkQueueSubmit. O Vulkan suporta buffers primários e secundários: os primários são enviados diretamente, os secundários podem ser chamados a partir dos primários para construção multithread de comandos.

A gravação de comandos começa com vkBeginCommandBuffer e termina com vkEndCommandBuffer. Entre eles, são gravados comandos de renderização: vkCmdDraw, vkCmdDispatch, vkCmdCopyBuffer e vkCmdPipelineBarrier para sincronização. Um novo buffer de comando é criado para cada quadro com pooling via reset de pool.

Renderização com Vulkan: pipeline e comandos

A renderização no Vulkan é organizada através de pipelines (VkPipeline). Ao contrário do OpenGL, onde o estado do pipeline é alterado globalmente, o Vulkan usa VkPipeline — um pipeline pré-compilado que inclui todas as etapas: entrada de vértices, shaders, rasterização, depth-stencil e blending.

VkPipeline — pipeline de renderização

VkGraphicsPipelineCreateInfo descreve o pipeline completo: shaders de vértices e fragmentos, topologia (triangle list, triangle strip), rasterizador (fill mode, cull mode), multisampling, testes depth-stencil, blending e configurações de viewport. O pipeline é criado uma vez e reutilizado — alterar o estado requer um novo pipeline ou estado dinâmico.

// Configuração do 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);

O Dynamic State (VK_DYNAMIC_STATE_VIEWPORT, VK_DYNAMIC_STATE_SCISSOR) permite alterar certos parâmetros sem criar um novo pipeline. O Vulkan 1.4 tornou obrigatório o suporte para Dynamic State 3 (VK_EXT_extended_dynamic_state_3) para gerenciar blend constants, depth bias e topologia em tempo real, reduzindo o número de pipelines em um projeto.

Render Pass e Dynamic Rendering

VkRenderPass descreve a estrutura dos passes de renderização: quais attachments são usados, como são limpos e carregados. O Dynamic Rendering (VK_KHR_dynamic_rendering, obrigatório desde Vulkan 1.4) simplifica o processo: o render pass é criado em tempo real no buffer de comando via vkCmdBeginRendering, sem um objeto VkRenderPass prévio.

De acordo com a Khronos (2026), o Dynamic Rendering reduz o código de inicialização do Vulkan em 30–40% e diminui o número de permutações de pipeline. Para técnicas de renderização adiada complexas (Deferred Shading), ainda é conveniente usar VkRenderPass clássico com vários subpasses para G-buffer e iluminação.

Shaders no Vulkan: SPIR-V e GLSL

SPIR-V é um formato binário universal de shaders no Vulkan, desenvolvido pela Khronos. Os shaders podem ser escritos em GLSL, HLSL ou linguagem Zink e compilados para SPIR-V via glslangValidator, dxc ou Google Shaderc. O Vulkan não aceita shaders em código fonte — apenas SPIR-V binário.

GLSL no Vulkan

GLSL para Vulkan difere do GLSL padrão do OpenGL. São usados blocos (layout) com indicação explícita de números de set e binding, em vez de variáveis embutidas. Os atributos de vértices são especificados através de location, os uniforms através de uniform blocks ou buffers. Push constants (até 128 bytes) estão disponíveis para transferência rápida de dados sem buffers.

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

Os qualificadores layout(set = N, binding = M) são uma diferença chave entre Vulkan GLSL e OpenGL. Set corresponde a um conjunto de descritores (VkDescriptorSet), binding corresponde a um recurso específico (buffer, textura, sampler). A separação em sets permite alternar eficientemente conjuntos de recursos entre draw calls sem vincular recursos individuais.

Descritores e conjuntos de descritores

VkDescriptorSet é um grupo de recursos (buffers, texturas, samplers) vinculados a shaders. O layout de descritores descreve os tipos de recursos e seus números de binding. Os conjuntos de descritores são atualizados via vkUpdateDescriptorSets e reutilizados entre draw calls. O Vulkan 1.4 suporta VK_EXT_descriptor_buffer para acesso direto a descritores da GPU.

Push Constants é um mecanismo para transferência rápida de pequenos volumes de dados (até 128 bytes) para shaders sem criar descritores. As push constants são definidas via vkCmdPushConstants no buffer de comando. De acordo com a Khronos (2025), usar push constants em vez de uniform buffers reduz a sobrecarga da CPU em 10–15% em taxas de draw calls superiores a 10 mil por quadro.

Vulkan em diferentes plataformas

Vulkan é a única API que funciona em todas as principais plataformas: Windows (via driver ICD oficial), Linux (RADV, AMDVLK, NVIDIA), Android (Vulkan 1.3+, obrigatório desde Android 10), e em dispositivos Apple através de MoltenVK — uma camada de tradução de Vulkan para Metal.

Vulkan no Android

No Android, o Vulkan é obrigatório para Android 10 e versões posteriores. O Google recomenda o Vulkan para novos projetos, especialmente jogos de alto desempenho e aplicações AR através do ARCore. O Qualcomm Adreno e o ARM Mali fornecem suporte completo ao Vulkan 1.3 com tracing de raios por hardware no Adreno 8xx e Mali-G720.

De acordo com o Google (2026), 98% dos dispositivos Android com Android 10+ suportam Vulkan. Para compatibilidade reversa, o ANGLE (Almost Native Graphics Layer Engine) está disponível, que traduz OpenGL ES para Vulkan. Isso permite executar aplicações OpenGL antigas em um driver Vulkan com até 20% de melhoria de desempenho.

No Android, o Vulkan tem alta prioridade para eficiência energética: as aplicações Vulkan consomem 25–40% menos energia em comparação com OpenGL ES sob a mesma carga gráfica em dispositivos com Adreno 7xx+. Isso torna o Vulkan a API preferida para jogos em dispositivos móveis.

Vulkan na Apple via MoltenVK

MoltenVK é uma implementação do Vulkan sobre Metal, desenvolvida pela LunarG e Valve. O MoltenVK traduz chamadas da API Vulkan para Metal, suportando Vulkan 1.2 no iOS e macOS. O desempenho do MoltenVK é próximo ao Metal nativo: a sobrecarga de tradução é de 5–15% dependendo do cenário.

De acordo com a LunarG (2025), o MoltenVK é usado no CrossOver (Wine para Mac) para executar jogos Windows no macOS. Dota 2, Civilization VI e Baldur's Gate 3 no macOS funcionam através do MoltenVK com desempenho de 30–60 FPS em M3/M4. O MoltenVK suporta MetalFX upscaling para melhoria de desempenho.

Vulkan Ray Tracing

VK_KHR_ray_tracing é uma extensão para tracing de raios por hardware no Vulkan, obrigatória desde Vulkan 1.4. Suportada em GPUs com núcleos RT: NVIDIA RTX 20xx/30xx/40xx/50xx, AMD RX 6000+/9000, Intel Arc A/B. O Vulkan RT fornece VkAccelerationStructure, VkRayTracingPipeline e Shader Binding Table.

O Vulkan Ray Tracing suporta reflexos, sombras, oclusão ambiental e iluminação global em tempo real. De acordo com a Khronos (2026), na NVIDIA RTX 5090, o Vulkan Ray Tracing atinge até 100 Giga rays/s em cenas de qualidade de referência. Para plataformas portáteis, o Vulkan RT escala através de redução de blur e denoising temporal.