Ensuring endianness in moderngl buffers

Question

I'm trying to learn moderngl for Python and I want to know if there is a way to make certain that when I read/write to a buffer (uniform or shader storage), the endianness agrees between guest and host devices. I have the following minimal program:

import moderngl as gl
import struct
context = gl.create_context(require=430, standalone=True)

comp = context.compute_shader('''
#version 430

layout (local_size_x=2) in;

layout (std140, binding=0) buffer mem {
    ivec4 vfs[];
};

void main() {
    uvec3 id = gl_GlobalInvocationID;
    vfs[id.x] = ivec4(id.x, gl_LocalInvocationID.x, gl_WorkGroupID.x, 0);
}
''')
output = context.buffer(None, reserve=4*4*8)
output.bind_to_storage_buffer(0)
comp.run(8)
buf = output.read()
buf = struct.unpack('32i', (buf)) # Unpacks using the default of native endianness
print(buf)

When I run this, as I would expect, I see the output:

(0, 0, 0, 0, 1, 1, 0, 0, 2, 0, 1, 0, 3, 1, 1, 0, 4, 0, 2, 0, 5, 1, 2, 0, 6, 0, 3, 0, 7, 1, 3, 0)

But will that always be the case when run on another machine or with another graphics card? Would it be possible that on some machines, this program will have the byte-reversals of each element in the output arrray? If so, is there a cross-system method to ensure the endianness is correct other than running some kind of test shader at the start of the program to detect endianness and correct for it if it is incorrect?

This may be the same for OpenGL in general; I do not know if there are any utilities specific to moderngl, or missing from it, to achieve this.

Answer 1

Vulkan has an explicit requirement that the host and device share the same endian byte-ordering. OpenGL does not explicitly have such a requirement, but the implicit definition of how OpenGL processes interpret bytes that it reads from/writes to memory effectively requires this.

So there is nothing to check.