RenderingDevice cheat sheet

01The seven steps

# 1  device
var rd := RenderingServer.create_local_rendering_device()

# 2  shader:  .glsl file -> SPIR-V -> RID
var shader_file: RDShaderFile = load("res://my_shader.glsl")
var shader := rd.shader_create_from_spirv(shader_file.get_spirv())

# 3  memory:  bytes in, RID out
var bytes := PackedFloat32Array([...]).to_byte_array()
var buffer := rd.storage_buffer_create(bytes.size(), bytes)

# 4  binding:  must mirror layout(set = 0, binding = 0) in the shader
var u := RDUniform.new()
u.uniform_type = RenderingDevice.UNIFORM_TYPE_STORAGE_BUFFER
u.binding = 0
u.add_id(buffer)
var uniform_set := rd.uniform_set_create([u], shader, 0)   # last arg = set index

# 5  pipeline:  create once, reuse forever
var pipeline := rd.compute_pipeline_create(shader)

# 6  record + dispatch:  counts are WORKGROUPS, not invocations
var list := rd.compute_list_begin()
rd.compute_list_bind_compute_pipeline(list, pipeline)
rd.compute_list_bind_uniform_set(list, uniform_set, 0)
rd.compute_list_dispatch(list, x_groups, y_groups, z_groups)
rd.compute_list_end()

# 7  execute and (only if you must) read back
rd.submit()
rd.sync()                                # blocks the CPU — avoid in the frame loop
var out := rd.buffer_get_data(buffer).to_float32_array()

# cleanup: RIDs are not reference-counted
rd.free_rid(uniform_set); rd.free_rid(pipeline)
rd.free_rid(buffer);      rd.free_rid(shader)

Several of these methods take extra optional arguments (buffer offsets, specialization constants, texture views) that change between 4.x point releases. When in doubt, check the class reference for your exact Godot version rather than trusting a tutorial.

02The shader skeleton

#[compute]                                // mandatory, line 1, Godot-specific
#version 450

layout(local_size_x = 64, local_size_y = 1, local_size_z = 1) in;

layout(set = 0, binding = 0, std430) restrict buffer DataBuffer {
    float data[];                        // runtime-sized: must be the last member
} buf;

void main() {
    uint id = gl_GlobalInvocationID.x;
    if (id >= buf.data.length()) { return; }   // always
    buf.data[id] *= 2.0;
}

03Dispatch arithmetic

Local size should be a multiple of the hardware bundle width — 32 on NVIDIA, 64 on AMD — so 64 total invocations per group is the safe floor (NVIDIA CUDA C++ Best Practices Guide). Note that 8 × 8 = 64 and 4 × 4 × 4 = 64: the multiple applies to the product, not to each axis.

04Why it printed zeros

05Byte-contract checklist