diff --git a/python/mujoco/bindings_test.py b/python/mujoco/bindings_test.py
index 8e983ece..3a93f0af 100644
--- a/python/mujoco/bindings_test.py
+++ b/python/mujoco/bindings_test.py
@@ -948,7 +948,7 @@ Euler integrator, semi-implicit in velocity.
   def test_can_raise_error(self):
     self.data.pstack = self.data.nstack
     with self.assertRaisesRegex(mujoco.FatalError,
-                                r'\Amj_stackAllocBytes: stack overflow'):
+                                r'\Amj_stackAllocByte: stack overflow'):
       mujoco.mj_forward(self.model, self.data)
 
   def test_mjcb_time(self):
diff --git a/src/engine/engine_collision_driver.c b/src/engine/engine_collision_driver.c
index bdd680a6..23ad7c73 100644
--- a/src/engine/engine_collision_driver.c
+++ b/src/engine/engine_collision_driver.c
@@ -208,7 +208,7 @@ int mj_collideOBB(const mjtNum aabb1[6], const mjtNum aabb2[6],
 }
 
 static mjCollisionTree* mj_stackAllocTree(mjData* d, int max_stack) {
-  return (mjCollisionTree*)mj_stackAllocBytes(d, max_stack * sizeof(mjCollisionTree*));
+  return (mjCollisionTree*)mj_stackAllocByte(d, max_stack * sizeof(mjCollisionTree*));
 }
 
 // binary search between two body trees
@@ -750,8 +750,8 @@ int mj_broadphase(const mjModel* m, mjData* d, int* pair, int maxpair) {
   }
 
   // allocate sort buffer
-  sortbuf = (mjtBroadphase*)mj_stackAllocBytes(d, 2 * bufcnt * sizeof(mjtBroadphase));
-  activebuf = (mjtBroadphase*)mj_stackAllocBytes(d, 2 *bufcnt * sizeof(mjtBroadphase));
+  sortbuf = (mjtBroadphase*)mj_stackAllocByte(d, 2 * bufcnt * sizeof(mjtBroadphase));
+  activebuf = (mjtBroadphase*)mj_stackAllocByte(d, 2 *bufcnt * sizeof(mjtBroadphase));
 
   // init sortbuf with axis0
   int k = 0;
diff --git a/src/engine/engine_collision_sdf.c b/src/engine/engine_collision_sdf.c
index d97a716c..9e3f5729 100644
--- a/src/engine/engine_collision_sdf.c
+++ b/src/engine/engine_collision_sdf.c
@@ -456,7 +456,7 @@ static void collideBVH(const mjModel* m, mjData* d, int g,
     int node;
   };
   typedef struct CollideTreeArgs_ CollideTreeArgs;
-  CollideTreeArgs* stack = (CollideTreeArgs*)mj_stackAllocBytes(
+  CollideTreeArgs* stack = (CollideTreeArgs*) mj_stackAllocByte(
       d, max_stack * sizeof(CollideTreeArgs));
 
   int nstack = 0;
diff --git a/src/engine/engine_io.c b/src/engine/engine_io.c
index 8ce41761..7588ed91 100644
--- a/src/engine/engine_io.c
+++ b/src/engine/engine_io.c
@@ -1188,7 +1188,7 @@ void* mj_arenaAlloc(mjData* d, int bytes, int alignment) {
 
 
 // allocate size bytes on the mjData stack
-void* mj_stackAllocBytes(mjData* d, size_t size) {
+void* mj_stackAllocByte(mjData* d, size_t size) {
   // return NULL if empty
   if (!size) {
     return NULL;
@@ -1268,11 +1268,11 @@ void* mj_stackAllocBytes(mjData* d, size_t size) {
 }
 
 mjtNum* mj_stackAlloc(mjData* d, int size) {
-  return (mjtNum*)mj_stackAllocBytes(d, size * sizeof(mjtNum));
+  return (mjtNum*)mj_stackAllocByte(d, size * sizeof(mjtNum));
 }
 
 int* mj_stackAllocInt(mjData* d, int size) {
-  return (int*)mj_stackAllocBytes(d, size * sizeof(int));
+  return (int*)mj_stackAllocByte(d, size * sizeof(int));
 }
 
 
diff --git a/src/engine/engine_io.h b/src/engine/engine_io.h
index 3ac30c35..5de5c594 100644
--- a/src/engine/engine_io.h
+++ b/src/engine/engine_io.h
@@ -109,7 +109,7 @@ MJAPI mjtNum* mj_stackAlloc(mjData* d, int size);
 MJAPI int* mj_stackAllocInt(mjData* d, int size);
 
 // mjData stack allocate for a specific size of bytes
-MJAPI void* mj_stackAllocBytes(mjData* d, size_t size);
+MJAPI void* mj_stackAllocByte(mjData* d, size_t size);
 
 // de-allocate data
 MJAPI void mj_deleteData(mjData* d);
diff --git a/src/engine/engine_util_container.c b/src/engine/engine_util_container.c
index 69778969..af339a44 100644
--- a/src/engine/engine_util_container.c
+++ b/src/engine/engine_util_container.c
@@ -22,7 +22,7 @@
 
 // stack allocate and initialize new mjArrayList
 mjArrayList* mju_arrayListCreate(mjData* d, size_t element_size, size_t initial_capacity) {
-  mjArrayList* array_list = (mjArrayList*) mj_stackAllocBytes(d, sizeof(mjArrayList));
+  mjArrayList* array_list = (mjArrayList*) mj_stackAllocByte(d, sizeof(mjArrayList));
   initial_capacity = mjMAX(1, initial_capacity);
   array_list->d = d;
   array_list->element_size = element_size;
@@ -31,7 +31,7 @@ mjArrayList* mju_arrayListCreate(mjData* d, size_t element_size, size_t initial_
   array_list->next_segment = NULL;
 
   // allocate array list buffer
-  array_list->buffer = (void*) mj_stackAllocBytes(d, element_size * initial_capacity);
+  array_list->buffer = (void*) mj_stackAllocByte(d, element_size * initial_capacity);
   return array_list;
 }