Kohi Game Engine Forum

Bindless Rendering Overview

Bindless rendering is a GPU resource model where shaders access buffers and textures directly through GPU-resident handles instead of being restricted by per-draw descriptor bindings. Traditional APIs require resources to be explicitly bound to slots before a draw call. Bindless removes that slot-based indirection and allows shaders to index into large arrays of resources using opaque GPU pointers or descriptor indices.

Classic binding model:

• You bind N textures and M buffers to fixed slots.
• Each draw call is constrained to those bound resources.
• Changing materials typically means rebinding descriptor sets or root signatures.

Bindless approach:

• All resources live in large descriptor arrays (or are exposed via GPU virtual addresses).
• Shaders receive an index or handle per draw/instance/material.
• The shader fetches the resource dynamically.
• The CPU no longer rebinding descriptors per draw.

Conceptual difference

Traditional:
Bind(Texture0);
Draw();
Bind(Texture1);
Draw();

Bindless:
material.textureIndex = 42;
DrawIndirect();

Shader:
Texture2D textures[]; // large descriptor array
color = textures[material.textureIndex].Sample(...);

Key Properties

• Descriptor arrays are very large (often unbounded in Vulkan with descriptor indexing).
• Resources are not rebound per draw.
• Shaders select resources dynamically.
• GPU-driven rendering pairs naturally with this model.

API Support

Vulkan:

• VK_EXT_descriptor_indexing
• Runtime descriptor arrays
• Non-uniform indexing
• Descriptor buffers (VK_EXT_descriptor_buffer)

DirectX 12:

• Descriptor heaps
• Root descriptors
• Shader-visible descriptor tables

OpenGL:

• ARB_bindless_texture
• 64-bit GPU texture handles

Why It Matters

• Reduces CPU overhead – no descriptor rebinding per material change; massive improvement in draw-call heavy scenes.
• Enables GPU-driven rendering – indirect draws or mesh shaders allow GPU selection of materials/resources without CPU intervention.
• Simplifies material systems – materials become data (indices into global tables) instead of state transitions.
• Scales to large content sets – thousands of textures/materials can exist simultaneously without rebinding churn.

Common Architecture Pattern

• Global descriptor heap / descriptor set with:
• All textures
• All structured buffers
• All material buffers
• Each material stores indices into these arrays.
• Draw commands reference a material index.
• Shader fetches material data → fetches texture indices → samples.

Example Material Buffer
struct Material
{
uint albedoIndex;
uint normalIndex;
uint metallicRoughnessIndex;
};

Shader flow
Material m = Materials[materialIndex];
Texture2D albedo = Textures[m.albedoIndex];

No CPU descriptor updates per draw.

Tradeoffs

• Requires modern hardware.
• Non-uniform indexing must be handled correctly.
• Descriptor management becomes global and long-lived.
• Debugging can be more complex.
• Memory pressure increases if not carefully managed.

Performance Characteristics

Bindless improves CPU scalability more than raw GPU speed. The GPU cost is similar unless the previous model caused pipeline stalls or descriptor heap switches. The real gains appear in:

• Large scenes with many materials
• GPU-driven indirect rendering
• Forward+ / clustered lighting
• Meshlet / mesh shader pipelines

Excellent article, and thanks for submitting this! You might want to convert the markdown to bb markup instead, though.

Thanks Travis, fixed that up.

Much better! Thanks for taking the time to do this.

I really hope more and more support comes for bindless rendering. It's such an efficient technique, but with obvious hardware limitations

Yeah, that's really the reason I haven't attempted use of it. Support is just meh atm. A shame, really.