GLSL aka Open GL - Blender Contributor Custom Shader Development Basics.

(Wiki)[https://en.wikipedia.org/wiki/OpenGLShadingLanguage] OpenGL Shaders in Blender: A Developer’s Guide to GLSL, BSL, and the GPU Module Blender is an unusually interesting graphics codebase to study because it sits at the intersection of traditional OpenGL rendering, modern Vulkan development, Apple's Metal API, offline rendering, real-time rendering, compute workloads, UI rendering, and an enormous production shader library. For a developer interested in contributing to Blender, learning GLSL is therefore only the first layer. The deeper goal is understanding how Blender represents GPU programs independently of the graphics API that eventually executes them. Modern Blender does not want most rendering code tightly coupled to OpenGL. Instead, Blender's GPU module provides an abstraction over OpenGL, Vulkan, and Metal, while Blender's shader infrastructure allows much of the same shader source to be translated or adapted for those backends. This means that a Blender contributor should think: Write a Blender GPU shader that can execute on OpenGL, Vulkan, and Metal. rather than: Write an OpenGL-only shader. That distinction defines modern Blender shader development. --- 1. GLSL Fundamentals Still Matter GLSL—OpenGL Shading Language—is a C-like language designed for massively parallel GPU programs. Its core concepts include vectors, matrices, GPU-oriented functions such as dot, cross, mix, and clamp, and communication through shader inputs, outputs, uniforms, and GPU resources. The traditional graphics pipeline can be simplified as: The three shader categories most relevant when starting Blender GPU work are: | Shader stage | Main responsibility | | --------------- | ------------------------------------------------------------------------- | | Vertex shader | Transform vertices and produce data for later stages | | Fragment shader | Calculate output values for rasterized fragments | | Compute shader | Execute general parallel GPU workloads outside the rasterization pipeline | These correspond directly to the traditional GLSL model. But Blender layers a substantial architecture around them. --- 2. Blender's GPU Abstraction Layer At the center of Blender's graphics architecture is the GPU module. The GPU module provides APIs for drawing geometry and executing computational work without forcing higher-level Blender systems to directly manipulate OpenGL, Vulkan, or Metal objects. Conceptually, an ordinary draw operation involves objects such as: Blender's official GPU documentation describes objects including GPUBatch, GPUVertBuf, GPUIndexBuf, GPUShader, GPUFramebuffer, and GPUTexture as components of this abstraction. This architecture lets systems including EEVEE, Workbench, viewport overlays, editors, Grease Pencil, and Blender's UI use common GPU infrastructure. A contributor working on rendering should therefore understand both sides of the system: The shader is only one component of the rendering operation. --- 3. Blender Is No Longer an OpenGL-Only Shader Codebase Historically Blender shaders were GLSL programs targeting OpenGL. That architecture changed as Blender added Metal and Vulkan support. Current Blender developer documentation explains that the project retained GLSL-like syntax while building infrastructure capable of translating or adapting shader code to different backend languages. Blender is also developing BSL—Blender Shading Language—to make the shader system easier to validate, share with C++, and translate between GPU backends. The conceptual compilation pipeline is approximately: This has profound consequences for contributors. Perfectly valid desktop OpenGL GLSL is not automatically acceptable Blender shader code. A shader may compile successfully using an NVIDIA OpenGL driver but fail when translated or compiled for Vulkan or Metal. Portability is therefore part of shader correctness. --- 4. Blender Shading Language Blender's current shader development direction is increasingly represented by Blender Shading Language, or BSL. BSL is not intended to become another giant general-purpose GPU compiler. Instead, Blender describes it as a shader language derived from its GLSL heritage while adopting C++-compatible constructs and compile-time translation. The goals include making shader code easier to share with host-side code, removing opaque implicit transformations, and statically validating more shader behavior. This is why current Blender source may look subtly different from GLSL tutorials found elsewhere. For example, ordinary GLSL frequently uses: Modern Blender shader code increasingly uses Blender-style types: Blender's GLSL style guide explicitly directs contributors toward the HLSL/MSL/Blender-style vector and matrix naming convention such as float2 rather than vec2. The mathematics is unchanged. What changes is the source representation and the restrictions required for reliable cross compilation. --- 5. GPUShaderCreateInfo: One of the Most Important Concepts to Learn A shader…