Making the Right Choice between WebGPU vs Vulkan

For developers requiring an efficient interface with modern GPU hardware, WebGPU is advisable, particularly for browser-based applications. It outperforms Vulkan by minimizing JavaScript calls and managing computational resources optimally. However, for diverse device targeting and seamless integration of ray tracing, Vulkan remains the preferable choice.

Key Differences Between WebGPU and Vulkan

• WebGPU, still at development stages, is a contemporary API, aimed to address WebGL limitations. Vulkan is a mature, cross-platform industry-standard graphics API.
• WebGPU manages computational resources optimally, reducing the overhead of making too many JavaScript calls. Vulkan provides fine-grained control over scheduling, synchronization, and memory allocation.
• WebGPU brings advancements of modern APIs like Direct3D 12, Metal, Vulkan to the web, offering new browser-based programming potentialities. Vulkan is device diverse, offering frequent extensions and improvements.
• WebGPU is developed collaboratively by tech giants including Apple, Google, Mozilla, Microsoft, and Intel. Vulkan permits contributions via Khronos, suggesting improvements or contributing to open-source projects.

What Is WebGPU and Who’s It For?

WebGPU is an advanced API designed for graphics and machine workloads. It has emerged to address the limitations of WebGL, a browser-based GPU API from 2011, and brings the functionalities of contemporary GPUs to the web. It’s intended for developers and organizations seeking superior real-time data processing and visually remarkable web elements.

Developed collaboratively by Apple, Google, Mozilla, Microsoft, and Intel since 2017, WebGPU is built on Vulkan. It’s currently available on Chrome 113 on ChromeOS, macOS, and Windows, while other platforms are still in the pipeline.

Pros of WebGPU

• Addresses WebGL limitations
• Efficient GPU hardware interface
• Optimal computational resource management
• Reduces overhead of excessive JavaScript calls
• Offering flexible programming model
• Enables porting classes of algorithms on GPU

Cons of WebGPU

• Still in early stages of development
• Currently disabled by default
• Future platform availability remains unclear

What Is Vulkan and Who’s It For?

Vulkan is a cross-platform industry-standard graphics API, providing developers with a platform to target a diverse range of devices. It has frequent extensions and additions, and is continually improving. Vulkan is for developers who demand control over scheduling, synchronization, and memory allocation in graphics programming.

The Vulkan ecosystem also boasts potentially pivotal utilities, such as Vulkan Portability and Vulkan SC 1.0 specification which cater to safety-critical systems, streamlining graphics and compute needs. Additionally, it’s the first graphics API with a formal memory model.

Pros of Vulkan

• Cross-platform nature
• Frequent extensions and improvements
• Effective control over critical aspects of graphics programming
• Potential in combating platform fragmentation
• First graphics API with formal memory model

Cons of Vulkan

• No guarantees for deployment timelines and device support
• Issues with complex 3D models

Code Examples for WebGPU & Vulkan

WebGPU 3D Torus

This code explains how you can generate a 3D Torus using the WebGPU API. This example requires a modern web browser that supports the WebGPU experimental feature.

    // Create canvas and get WebGPU context
let canvas = document.createElement('canvas');
let context = canvas.getContext('gpupresent');

// Create a GPU device
let adapter = await navigator.gpu.requestAdapter();
let device = await adapter.requestDevice();

// Create a GPU buffer
let buffer = device.createBuffer({
    size: VERTEX_SIZE * NUM_VERTICES,
    usage: GPUBufferUsage.VERTEX,
    mappedAtCreation: true
});

// Generate a 3D Torus
let vertices = new Float32Array(NUM_VERTICES * VERTEX_PER_QUAD);
for(let i = 0; i < NUM_VERTICES; i++) {
    let quadPos = i % VERTEX_PER_QUAD;
    let pos = [quadPos & 2, quadPos & 1];
    vertices.set(pos, i * VERTEX_SIZE / 4);
}

// Unmap buffer and create a vertex buffer layout
buffer.unmap();
let vertexBuffers = [{arrayStride: VERTEX_SIZE, attributes: [{offset: 0, format: 'float32x4', shaderLocation: 0}]}];
    

Vulkan Triangle Rendering

This example illustrates a basic Vulkan program that can render a simple triangle. Ensure that you have Vulkan SDK set up on your environment and understand the basic concepts of Vulkan API, such as Command buffer, Swap chains, and Pipelines.

// Include Vulkan
#include <vulkan/vulkan.h>

// Create an instance
VkApplicationInfo appInfo = {};
appInfo.pApplicationName = "Hello Triangle";
appInfo.applicationVersion = VK_MAKE_VERSION(1, 0, 0);
appInfo.pEngineName = "No Engine";
appInfo.engineVersion = VK_MAKE_VERSION(1, 0, 0);
appInfo.apiVersion = VK_API_VERSION_1_0;

VkInstanceCreateInfo createInfo = {};
createInfo.sType = VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO;
createInfo.pApplicationInfo = &appInfo;

uint32_t glfwExtensionCount = 0;
const char** glfwExtensions;

glfwExtensions = glfwGetRequiredInstanceExtensions(&glfwExtensionCount);

createInfo.enabledExtensionCount = glfwExtensionCount;
createInfo.ppEnabledExtensionNames = glfwExtensions;

createInfo.enabledLayerCount = 0;

if (vkCreateInstance(&createInfo, nullptr, &instance) != VK_SUCCESS) {
    throw std::runtime_error("failed to create instance!");
}

WebGPU vs Vulkan: The Showdown Verdict

The battlefield of graphics API sees two giants, WebGPU and Vulkan, confronting each other. Depending on your usage and needs, one can outshine the other. Here’s our verdict for different audience segments.

Developers Seeking to Harness Modern Hardware Functionalities

If you desire to harness the features of modern GPU hardware, WebGPU is your companion. Developed collaboratively by tech behemoths, it reflects the modern GPU hardware functionalities, and provides a flexible programming model with its compute shaders. WebGPU also comes with in-progress ports in popular JavaScript WebGL libraries, making it a potential go-to choice for developers.

AR/VR Creators who Need High Flexibility and Control

For those seeking complete control over memory allocation, scheduling and synchronization, Vulkan stands unparalleled. Its continual evolution grants developers incredible flexibility and capacity for improvement. Along with fully accelerated H.264 and H.265 decode, it is a resource for AR/VR creators needing high flexibility and control.

Game Makers Aiming for High Performance

The arena of high-performance gaming sees WebGPU as a promising contender. It was built on Vulkan, and consistently outperforms with more balanced CPU/GPU usage compared to WebGL. It also allows game makers to port a range of algorithms on the GPU, enabling brilliant visual effects that were unfathomable in the WebGL era.

In the graphics API face-off, it’s a close call. For modern, efficient interfacing with GPU hardware, WebGPU wins. But when it comes to broad device support and control, Vulkan can’t be beat. It all boils down to your intended application.