Hello everyone!

Following up from the previous post, today I’d like to briefly explore compute shaders — what they are, and how they can be used in game engine development.

What Is a Compute Shader?

A compute shader allows you to use the GPU for general-purpose computations, not just rendering graphics. This opens the door to leveraging the parallel processing power of GPUs for tasks like simulations, physics calculations, or custom logic.

In the previous post, I touched on different types of GPU buffers. Among them, the storage buffer is notable because it allows write access from within the shader — meaning you can output results from computations performed on the GPU.

Moreover, the results calculated in a compute shader can even be passed into the vertex shader, making it possible to use GPU-computed data for rendering directly.

Using a Compute Shader for a Simple Transformation

Let’s take a look at a basic example. Previously, I used a math function to rotate a rectangle on screen. Here's the code snippet that powered that transformation:

🔗 Code Gist:
https://gist.github.com/erenengine/386ff40b411010a119ad2c43d6ceab9f

📺 Related Demo Video:
https://youtu.be/kM3smoN8sXo

This time, I rewrote that same logic in a compute shader to perform the transformation.

🔧 Compute Shader Source:
https://github.com/erenengine/eren/blob/main/eren_vulkan_render_shared/examples/test_compute_shader/shaders/shader.comp

After adjusting some supporting code, everything compiled and ran as expected. The rectangle rotates just as before — only this time, the math was handled by a compute shader instead of the CPU or vertex stage.

Is This the Best Use Case?

To be fair, using a compute shader for a simple task like this is a bit of overkill. GPUs are optimized for massively parallel workloads, and in this example, I’m only running a single process, so there’s no real performance gain.

That said, compute shaders shine when dealing with scenarios such as:

• Massive character or crowd updates

• Large-scale particle systems

• Complex physics simulations

In those cases, offloading calculations to the GPU can make a huge difference.

Limitations in Web Environments

A quick note for those working with web-based graphics:

• In WebGPU, read_write storage buffers are not accessible in vertex shaders

• In WebGL, storage buffers are not supported at all

So on the web, using compute shaders for rendering purposes is tricky — they’re generally limited to background calculations only.

Wrapping Up

This was a simple hands-on experiment with compute shaders — more of a proof-of-concept than a performance-oriented implementation. Still, it's a helpful first step in understanding how compute shaders can fit into modern rendering workflows.

I’m planning to explore more advanced and performance-focused uses in future posts, so stay tuned!

Thanks for reading, and happy dev’ing out there! 😊