This canvas is running a real fragment shader locally in your browser. Millions of calculations are happening every second to calculate the color of every individual pixel based purely on screen coordinates and time.
Early GPUs used a “fixed-function” pipeline: you could configure lighting and texturing, but you could not truly program how things were drawn. That changed in the early 2000s, when GPUs became programmable and shaders arrived; small programs that run on the GPU and decide how geometry and pixels are transformed and colored. Today they power essentially every visual effect you see, and they are written in shading languages such as HLSL, GLSL, and (historically) Cg.
The two shaders you meet first are the vertex shader and the fragment (pixel) shader.
The crucial detail is parallelism: the GPU runs these programs across thousands of vertices and millions of pixels, every single frame. That is why GPUs are so fast at graphics, and why shaders are written to be small and massively parallel.
You write shaders in HLSL, but your players run on many different graphics APIs: 0Direct3D, OpenGL/GLES, Metal, Vulkan, and each wants a different format. Unity’s shader compiler bridges that gap in stages:
So a single HLSL shader can fan out into several API-specific outputs before it ever reaches a player’s device.
Here is where it explodes. Shaders use keywords to toggle features on and off, such as fog, lightmaps, instancing, and shadows. Unity compiles one variant for every combination of those keyword sets, which means the total is the product of all the option sets, not the sum. A handful of features quickly becomes thousands, even millions, of variants. And at player build time, Unity compiles all the not-yet-compiled variants so they ship inside the game — even ones the editor never happened to use. Multiply variants by target platforms and shader compilation becomes one of the largest, most dreaded stages of a build: the classic graphics bottleneck.
Shader compilation is embarrassingly parallel, thousands of independent compile jobs, which is exactly what Incredibuild is built to crush.
On Incredibuild’s game development acceleration platform, shaders are a named target: it distributes massive shader blocks across your network to eliminate the graphics bottleneck. Cache misses are offloaded to hundreds of idle CPUs across your network or cloud, and the shared Build Cache means an unchanged shader variant is compiled once and reused by everyone on the team and every CI run, instead of being recompiled from scratch.
As with the rest of Incredibuild, it slots into your existing Unreal, Unity, or custom pipeline with no code or script changes. The shader stage simply stops being the thing everyone waits on.
Whether your pixels are powered by HLSL, GLSL, Metal, or SPIR-V, the Unity shader compiler still has to grind through every variant — and Incredibuild is how you make that grind disappear.
Incredibuild empowers your teams to be productive and focus on innovating.
