diff --git a/.gitignore b/.gitignore
index 46828956d..710ce9521 100644
--- a/.gitignore
+++ b/.gitignore
@@ -83,3 +83,14 @@ xcode/*
 .vscode
 .build
 *.swp
+*.swp
+.tags
+.vimrc
+.lastsession.vim
+*.un~
+.cache/
+.ccls-cache/
+compile_commands.json
+.compile_commands.json
+.clang_complete
+.ccls-root
\ No newline at end of file
diff --git a/include/cglm/aabb2d.h b/include/cglm/aabb2d.h
index 03c6773da..4a9f98be7 100644
--- a/include/cglm/aabb2d.h
+++ b/include/cglm/aabb2d.h
@@ -35,7 +35,7 @@ glm_aabb2d_zero(vec2 aabb[2]) {
  */
 CGLM_INLINE
 void
-glm_aabb2d_copy(vec2 aabb[2], vec2 dest[2]) {
+glm_aabb2d_copy(CGLM_IN(vec2) aabb[2], vec2 dest[2]) {
   glm_vec2_copy(aabb[0], dest[0]);
   glm_vec2_copy(aabb[1], dest[1]);
 }
@@ -49,7 +49,7 @@ glm_aabb2d_copy(vec2 aabb[2], vec2 dest[2]) {
  */
 CGLM_INLINE
 void
-glm_aabb2d_transform(vec2 aabb[2], mat3 m, vec2 dest[2]) {
+glm_aabb2d_transform(CGLM_IN(vec2) aabb[2], CGLM_IN(mat3) m, vec2 dest[2]) {
   vec2 v[2], xa, xb, ya, yb;
 
   glm_vec2_scale(m[0], aabb[0][0], xa);
@@ -84,7 +84,7 @@ glm_aabb2d_transform(vec2 aabb[2], mat3 m, vec2 dest[2]) {
  */
 CGLM_INLINE
 void
-glm_aabb2d_merge(vec2 aabb1[2], vec2 aabb2[2], vec2 dest[2]) {
+glm_aabb2d_merge(CGLM_IN(vec2) aabb1[2], CGLM_IN(vec2) aabb2[2], vec2 dest[2]) {
   dest[0][0] = glm_min(aabb1[0][0], aabb2[0][0]);
   dest[0][1] = glm_min(aabb1[0][1], aabb2[0][1]);
 
@@ -105,7 +105,7 @@ glm_aabb2d_merge(vec2 aabb1[2], vec2 aabb2[2], vec2 dest[2]) {
  */
 CGLM_INLINE
 void
-glm_aabb2d_crop(vec2 aabb[2], vec2 cropAabb[2], vec2 dest[2]) {
+glm_aabb2d_crop(CGLM_IN(vec2) aabb[2], CGLM_IN(vec2) cropAabb[2], vec2 dest[2]) {
   dest[0][0] = glm_max(aabb[0][0], cropAabb[0][0]);
   dest[0][1] = glm_max(aabb[0][1], cropAabb[0][1]);
 
@@ -127,9 +127,9 @@ glm_aabb2d_crop(vec2 aabb[2], vec2 cropAabb[2], vec2 dest[2]) {
  */
 CGLM_INLINE
 void
-glm_aabb2d_crop_until(vec2 aabb[2],
-                      vec2 cropAabb[2],
-                      vec2 clampAabb[2],
+glm_aabb2d_crop_until(CGLM_IN(vec2) aabb[2],
+                      CGLM_IN(vec2) cropAabb[2],
+                      CGLM_IN(vec2) clampAabb[2],
                       vec2 dest[2]) {
   glm_aabb2d_crop(aabb, cropAabb, dest);
   glm_aabb2d_merge(clampAabb, dest, dest);
@@ -154,7 +154,7 @@ glm_aabb2d_invalidate(vec2 aabb[2]) {
  */
 CGLM_INLINE
 bool
-glm_aabb2d_isvalid(vec2 aabb[2]) {
+glm_aabb2d_isvalid(CGLM_IN(vec2) aabb[2]) {
   return glm_vec2_max(aabb[0]) != FLT_MAX
          && glm_vec2_min(aabb[1]) != -FLT_MAX;
 }
@@ -166,7 +166,7 @@ glm_aabb2d_isvalid(vec2 aabb[2]) {
  */
 CGLM_INLINE
 float
-glm_aabb2d_diag(vec2 aabb[2]) {
+glm_aabb2d_diag(CGLM_IN(vec2) aabb[2]) {
   return glm_vec2_distance(aabb[0], aabb[1]);
 }
 
@@ -178,8 +178,8 @@ glm_aabb2d_diag(vec2 aabb[2]) {
  */
 CGLM_INLINE
 void
-glm_aabb2d_sizev(vec2 aabb[2], vec2 dest) {
-  glm_vec2_sub(aabb[1], aabb[0], dest); 
+glm_aabb2d_sizev(CGLM_IN(vec2) aabb[2], vec2 dest) {
+  glm_vec2_sub(aabb[1], aabb[0], dest);
 }
 
 /*!
@@ -189,7 +189,7 @@ glm_aabb2d_sizev(vec2 aabb[2], vec2 dest) {
  */
 CGLM_INLINE
 float
-glm_aabb2d_radius(vec2 aabb[2]) {
+glm_aabb2d_radius(CGLM_IN(vec2) aabb[2]) {
   return glm_aabb2d_diag(aabb) * 0.5f;
 }
 
@@ -201,7 +201,7 @@ glm_aabb2d_radius(vec2 aabb[2]) {
  */
 CGLM_INLINE
 void
-glm_aabb2d_center(vec2 aabb[2], vec2 dest) {
+glm_aabb2d_center(CGLM_IN(vec2) aabb[2], vec2 dest) {
   glm_vec2_center(aabb[0], aabb[1], dest);
 }
 
@@ -213,7 +213,7 @@ glm_aabb2d_center(vec2 aabb[2], vec2 dest) {
  */
 CGLM_INLINE
 bool
-glm_aabb2d_aabb(vec2 aabb[2], vec2 other[2]) {
+glm_aabb2d_aabb(CGLM_IN(vec2) aabb[2], CGLM_IN(vec2) other[2]) {
   return (aabb[0][0] <= other[1][0] && aabb[1][0] >= other[0][0])
       && (aabb[0][1] <= other[1][1] && aabb[1][1] >= other[0][1]);
 }
@@ -228,7 +228,7 @@ glm_aabb2d_aabb(vec2 aabb[2], vec2 other[2]) {
  */
 CGLM_INLINE
 bool
-glm_aabb2d_circle(vec2 aabb[2], vec3 c) {
+glm_aabb2d_circle(CGLM_IN(vec2) aabb[2], const vec3 c) {
   float dmin;
   int   a, b;
 
@@ -249,7 +249,7 @@ glm_aabb2d_circle(vec2 aabb[2], vec3 c) {
  */
 CGLM_INLINE
 bool
-glm_aabb2d_point(vec2 aabb[2], vec2 point) {
+glm_aabb2d_point(CGLM_IN(vec2) aabb[2], CGLM_IN(vec2) point) {
   return (point[0] >= aabb[0][0] && point[0] <= aabb[1][0])
       && (point[1] >= aabb[0][1] && point[1] <= aabb[1][1]);
 }
@@ -262,7 +262,7 @@ glm_aabb2d_point(vec2 aabb[2], vec2 point) {
  */
 CGLM_INLINE
 bool
-glm_aabb2d_contains(vec2 aabb[2], vec2 other[2]) {
+glm_aabb2d_contains(CGLM_IN(vec2) aabb[2], CGLM_IN(vec2) other[2]) {
   return (aabb[0][0] <= other[0][0] && aabb[1][0] >= other[1][0])
       && (aabb[0][1] <= other[0][1] && aabb[1][1] >= other[1][1]);
 }
diff --git a/include/cglm/affine-mat.h b/include/cglm/affine-mat.h
index c22c0e07e..74fe26de5 100644
--- a/include/cglm/affine-mat.h
+++ b/include/cglm/affine-mat.h
@@ -7,8 +7,8 @@
 
 /*
  Functions:
-   CGLM_INLINE void glm_mul(mat4 m1, mat4 m2, mat4 dest);
-   CGLM_INLINE void glm_mul_rot(mat4 m1, mat4 m2, mat4 dest);
+   CGLM_INLINE void glm_mul(CGLM_IN(mat4) m1, CGLM_IN(mat4) m2, mat4 dest);
+   CGLM_INLINE void glm_mul_rot(CGLM_IN(mat4) m1, CGLM_IN(mat4) m2, mat4 dest);
    CGLM_INLINE void glm_inv_tr(mat4 mat);
  */
 
@@ -53,7 +53,7 @@
  */
 CGLM_INLINE
 void
-glm_mul(mat4 m1, mat4 m2, mat4 dest) {
+glm_mul(CGLM_IN(mat4) m1, CGLM_IN(mat4) m2, mat4 dest) {
 #if defined(__wasm__) && defined(__wasm_simd128__)
   glm_mul_wasm(m1, m2, dest);
 #elif defined(__AVX__)
@@ -113,7 +113,7 @@ glm_mul(mat4 m1, mat4 m2, mat4 dest) {
  */
 CGLM_INLINE
 void
-glm_mul_rot(mat4 m1, mat4 m2, mat4 dest) {
+glm_mul_rot(CGLM_IN(mat4) m1, CGLM_IN(mat4) m2, mat4 dest) {
 #if defined(__wasm__) && defined(__wasm_simd128__)
   glm_mul_rot_wasm(m1, m2, dest);
 #elif defined( __SSE__ ) || defined( __SSE2__ )
diff --git a/include/cglm/affine-post.h b/include/cglm/affine-post.h
index 3e297e61a..926142311 100644
--- a/include/cglm/affine-post.h
+++ b/include/cglm/affine-post.h
@@ -10,17 +10,17 @@
 
 /*
  Functions:
-   CGLM_INLINE void glm_translated_to(mat4 m, vec3 v, mat4 dest);
-   CGLM_INLINE void glm_translated(mat4 m, vec3 v);
+   CGLM_INLINE void glm_translated_to(CGLM_IN(mat4) m, const vec3 v, mat4 dest);
+   CGLM_INLINE void glm_translated(mat4 m, const vec3 v);
    CGLM_INLINE void glm_translated_x(mat4 m, float to);
    CGLM_INLINE void glm_translated_y(mat4 m, float to);
    CGLM_INLINE void glm_translated_z(mat4 m, float to);
-   CGLM_INLINE void glm_rotated_x(mat4 m, float angle, mat4 dest);
-   CGLM_INLINE void glm_rotated_y(mat4 m, float angle, mat4 dest);
-   CGLM_INLINE void glm_rotated_z(mat4 m, float angle, mat4 dest);
-   CGLM_INLINE void glm_rotated(mat4 m, float angle, vec3 axis);
-   CGLM_INLINE void glm_rotated_at(mat4 m, vec3 pivot, float angle, vec3 axis);
-   CGLM_INLINE void glm_spinned(mat4 m, float angle, vec3 axis);
+   CGLM_INLINE void glm_rotated_x(CGLM_IN(mat4) m, float angle, mat4 dest);
+   CGLM_INLINE void glm_rotated_y(CGLM_IN(mat4) m, float angle, mat4 dest);
+   CGLM_INLINE void glm_rotated_z(CGLM_IN(mat4) m, float angle, mat4 dest);
+   CGLM_INLINE void glm_rotated(mat4 m, float angle, const vec3 axis);
+   CGLM_INLINE void glm_rotated_at(mat4 m, vec3 pivot, float angle, const vec3 axis);
+   CGLM_INLINE void glm_spinned(mat4 m, float angle, const vec3 axis);
  */
 
 #include "common.h"
@@ -41,7 +41,7 @@
  */
 CGLM_INLINE
 void
-glm_translated(mat4 m, vec3 v) {
+glm_translated(mat4 m, const vec3 v) {
   glm_vec3_add(m[3], v, m[3]);
 }
 
@@ -59,7 +59,7 @@ glm_translated(mat4 m, vec3 v) {
  */
 CGLM_INLINE
 void
-glm_translated_to(mat4 m, vec3 v, mat4 dest) {
+glm_translated_to(CGLM_IN(mat4) m, const vec3 v, mat4 dest) {
   glm_mat4_copy(m, dest);
   glm_translated(dest, v);
 }
@@ -118,7 +118,7 @@ glm_translated_z(mat4 m, float z) {
  */
 CGLM_INLINE
 void
-glm_rotated_x(mat4 m, float angle, mat4 dest) {
+glm_rotated_x(CGLM_IN(mat4) m, float angle, mat4 dest) {
   CGLM_ALIGN_MAT mat4 t = GLM_MAT4_IDENTITY_INIT;
   float c, s;
 
@@ -145,7 +145,7 @@ glm_rotated_x(mat4 m, float angle, mat4 dest) {
  */
 CGLM_INLINE
 void
-glm_rotated_y(mat4 m, float angle, mat4 dest) {
+glm_rotated_y(CGLM_IN(mat4) m, float angle, mat4 dest) {
   CGLM_ALIGN_MAT mat4 t = GLM_MAT4_IDENTITY_INIT;
   float c, s;
 
@@ -172,7 +172,7 @@ glm_rotated_y(mat4 m, float angle, mat4 dest) {
  */
 CGLM_INLINE
 void
-glm_rotated_z(mat4 m, float angle, mat4 dest) {
+glm_rotated_z(CGLM_IN(mat4) m, float angle, mat4 dest) {
   CGLM_ALIGN_MAT mat4 t = GLM_MAT4_IDENTITY_INIT;
   float c, s;
 
@@ -198,7 +198,7 @@ glm_rotated_z(mat4 m, float angle, mat4 dest) {
  */
 CGLM_INLINE
 void
-glm_rotated(mat4 m, float angle, vec3 axis) {
+glm_rotated(mat4 m, float angle, const vec3 axis) {
   CGLM_ALIGN_MAT mat4 rot;
   glm_rotate_make(rot, angle, axis);
   glm_mul_rot(rot, m, m);
@@ -217,7 +217,7 @@ glm_rotated(mat4 m, float angle, vec3 axis) {
  */
 CGLM_INLINE
 void
-glm_rotated_at(mat4 m, vec3 pivot, float angle, vec3 axis) {
+glm_rotated_at(mat4 m, vec3 pivot, float angle, const vec3 axis) {
   CGLM_ALIGN(8) vec3 pivotInv;
 
   glm_vec3_negate_to(pivot, pivotInv);
@@ -238,7 +238,7 @@ glm_rotated_at(mat4 m, vec3 pivot, float angle, vec3 axis) {
  */
 CGLM_INLINE
 void
-glm_spinned(mat4 m, float angle, vec3 axis) {
+glm_spinned(mat4 m, float angle, const vec3 axis) {
   CGLM_ALIGN_MAT mat4 rot;
   glm_rotate_atm(rot, m[3], angle, axis);
   glm_mat4_mul(rot, m, m);
diff --git a/include/cglm/affine-pre.h b/include/cglm/affine-pre.h
index 2fa77f777..8c3ecfd20 100644
--- a/include/cglm/affine-pre.h
+++ b/include/cglm/affine-pre.h
@@ -10,18 +10,18 @@
 
 /*
  Functions:
-   CGLM_INLINE void glm_translate_to(mat4 m, vec3 v, mat4 dest);
-   CGLM_INLINE void glm_translate(mat4 m, vec3 v);
+   CGLM_INLINE void glm_translate_to(mat4 m, const vec3 v, mat4 dest);
+   CGLM_INLINE void glm_translate(mat4 m, const vec3 v);
    CGLM_INLINE void glm_translate_x(mat4 m, float to);
    CGLM_INLINE void glm_translate_y(mat4 m, float to);
    CGLM_INLINE void glm_translate_z(mat4 m, float to);
    CGLM_INLINE void glm_rotate_x(mat4 m, float angle, mat4 dest);
    CGLM_INLINE void glm_rotate_y(mat4 m, float angle, mat4 dest);
    CGLM_INLINE void glm_rotate_z(mat4 m, float angle, mat4 dest);
-   CGLM_INLINE void glm_rotate(mat4 m, float angle, vec3 axis);
-   CGLM_INLINE void glm_rotate_at(mat4 m, vec3 pivot, float angle, vec3 axis);
-   CGLM_INLINE void glm_rotate_atm(mat4 m, vec3 pivot, float angle, vec3 axis);
-   CGLM_INLINE void glm_spin(mat4 m, float angle, vec3 axis);
+   CGLM_INLINE void glm_rotate(mat4 m, float angle, const vec3 axis);
+   CGLM_INLINE void glm_rotate_at(mat4 m, const vec3 pivot, float angle, const vec3 axis);
+   CGLM_INLINE void glm_rotate_atm(mat4 m, const vec3 pivot, float angle, const vec3 axis);
+   CGLM_INLINE void glm_spin(mat4 m, float angle, const vec3 axis);
  */
 
 #include "common.h"
@@ -40,7 +40,7 @@
  */
 CGLM_INLINE
 void
-glm_translate(mat4 m, vec3 v) {
+glm_translate(mat4 m, const vec3 v) {
 #if defined(CGLM_SIMD)
   glmm_128 m0, m1, m2, m3;
 
@@ -72,7 +72,7 @@ glm_translate(mat4 m, vec3 v) {
  */
 CGLM_INLINE
 void
-glm_translate_to(mat4 m, vec3 v, mat4 dest) {
+glm_translate_to(CGLM_IN(mat4) m, const vec3 v, mat4 dest) {
   glm_mat4_copy(m, dest);
   glm_translate(dest, v);
 }
@@ -141,7 +141,7 @@ glm_translate_z(mat4 m, float z) {
  */
 CGLM_INLINE
 void
-glm_rotate_x(mat4 m, float angle, mat4 dest) {
+glm_rotate_x(CGLM_IN(mat4) m, float angle, mat4 dest) {
   CGLM_ALIGN_MAT mat4 t = GLM_MAT4_IDENTITY_INIT;
   float c, s;
 
@@ -166,7 +166,7 @@ glm_rotate_x(mat4 m, float angle, mat4 dest) {
  */
 CGLM_INLINE
 void
-glm_rotate_y(mat4 m, float angle, mat4 dest) {
+glm_rotate_y(CGLM_IN(mat4) m, float angle, mat4 dest) {
   CGLM_ALIGN_MAT mat4 t = GLM_MAT4_IDENTITY_INIT;
   float c, s;
 
@@ -191,7 +191,7 @@ glm_rotate_y(mat4 m, float angle, mat4 dest) {
  */
 CGLM_INLINE
 void
-glm_rotate_z(mat4 m, float angle, mat4 dest) {
+glm_rotate_z(CGLM_IN(mat4) m, float angle, mat4 dest) {
   CGLM_ALIGN_MAT mat4 t = GLM_MAT4_IDENTITY_INIT;
   float c, s;
 
@@ -207,7 +207,7 @@ glm_rotate_z(mat4 m, float angle, mat4 dest) {
 }
 
 /*!
- * @brief rotate existing transform matrix 
+ * @brief rotate existing transform matrix
  *        around given axis by angle at ORIGIN (0,0,0)
  *
  *   **❗️IMPORTANT ❗️**
@@ -233,7 +233,7 @@ glm_rotate_z(mat4 m, float angle, mat4 dest) {
  */
 CGLM_INLINE
 void
-glm_rotate(mat4 m, float angle, vec3 axis) {
+glm_rotate(mat4 m, float angle, const vec3 axis) {
   CGLM_ALIGN_MAT mat4 rot;
   glm_rotate_make(rot, angle, axis);
   glm_mul_rot(m, rot, m);
@@ -250,7 +250,7 @@ glm_rotate(mat4 m, float angle, vec3 axis) {
  */
 CGLM_INLINE
 void
-glm_rotate_at(mat4 m, vec3 pivot, float angle, vec3 axis) {
+glm_rotate_at(mat4 m, const vec3 pivot, float angle, const vec3 axis) {
   CGLM_ALIGN(8) vec3 pivotInv;
 
   glm_vec3_negate_to(pivot, pivotInv);
@@ -275,7 +275,7 @@ glm_rotate_at(mat4 m, vec3 pivot, float angle, vec3 axis) {
  */
 CGLM_INLINE
 void
-glm_rotate_atm(mat4 m, vec3 pivot, float angle, vec3 axis) {
+glm_rotate_atm(mat4 m, const vec3 pivot, float angle, const vec3 axis) {
   CGLM_ALIGN(8) vec3 pivotInv;
 
   glm_vec3_negate_to(pivot, pivotInv);
@@ -286,7 +286,7 @@ glm_rotate_atm(mat4 m, vec3 pivot, float angle, vec3 axis) {
 }
 
 /*!
- * @brief rotate existing transform matrix 
+ * @brief rotate existing transform matrix
  *        around given axis by angle around self (doesn't affected by position)
  *
  * @param[in, out]  m      affine transform
@@ -295,7 +295,7 @@ glm_rotate_atm(mat4 m, vec3 pivot, float angle, vec3 axis) {
  */
 CGLM_INLINE
 void
-glm_spin(mat4 m, float angle, vec3 axis) {
+glm_spin(mat4 m, float angle, const vec3 axis) {
   CGLM_ALIGN_MAT mat4 rot;
   glm_rotate_atm(rot, m[3], angle, axis);
   glm_mat4_mul(m, rot, m);
diff --git a/include/cglm/affine.h b/include/cglm/affine.h
index 2c608f798..4087a27f7 100644
--- a/include/cglm/affine.h
+++ b/include/cglm/affine.h
@@ -7,28 +7,28 @@
 
 /*
  Functions:
-   CGLM_INLINE void glm_translate_to(mat4 m, vec3 v, mat4 dest);
-   CGLM_INLINE void glm_translate(mat4 m, vec3 v);
-   CGLM_INLINE void glm_translate_x(mat4 m, float to);
-   CGLM_INLINE void glm_translate_y(mat4 m, float to);
-   CGLM_INLINE void glm_translate_z(mat4 m, float to);
-   CGLM_INLINE void glm_translate_make(mat4 m, vec3 v);
-   CGLM_INLINE void glm_scale_to(mat4 m, vec3 v, mat4 dest);
-   CGLM_INLINE void glm_scale_make(mat4 m, vec3 v);
-   CGLM_INLINE void glm_scale(mat4 m, vec3 v);
+   CGLM_INLINE void glm_translate_to(CGLM_IN(mat4) m, const vec3 v, mat4 dest);
+   CGLM_INLINE void glm_translate(CGLM_IN(mat4) m, const vec3 v);
+   CGLM_INLINE void glm_translate_x(CGLM_IN(mat4) m, float to);
+   CGLM_INLINE void glm_translate_y(CGLM_IN(mat4) m, float to);
+   CGLM_INLINE void glm_translate_z(CGLM_IN(mat4) m, float to);
+   CGLM_INLINE void glm_translate_make(mat4 m, const vec3 v);
+   CGLM_INLINE void glm_scale_to(CGLM_IN(mat4) m, const vec3 v, mat4 dest);
+   CGLM_INLINE void glm_scale_make(mat4 m, const vec3 v);
+   CGLM_INLINE void glm_scale(mat4 m, const vec3 v);
    CGLM_INLINE void glm_scale_uni(mat4 m, float s);
-   CGLM_INLINE void glm_rotate_x(mat4 m, float angle, mat4 dest);
-   CGLM_INLINE void glm_rotate_y(mat4 m, float angle, mat4 dest);
-   CGLM_INLINE void glm_rotate_z(mat4 m, float angle, mat4 dest);
-   CGLM_INLINE void glm_rotate_make(mat4 m, float angle, vec3 axis);
-   CGLM_INLINE void glm_rotate(mat4 m, float angle, vec3 axis);
-   CGLM_INLINE void glm_rotate_at(mat4 m, vec3 pivot, float angle, vec3 axis);
-   CGLM_INLINE void glm_rotate_atm(mat4 m, vec3 pivot, float angle, vec3 axis);
-   CGLM_INLINE void glm_spin(mat4 m, float angle, vec3 axis);
-   CGLM_INLINE void glm_decompose_scalev(mat4 m, vec3 s);
-   CGLM_INLINE bool glm_uniscaled(mat4 m);
-   CGLM_INLINE void glm_decompose_rs(mat4 m, mat4 r, vec3 s);
-   CGLM_INLINE void glm_decompose(mat4 m, vec4 t, mat4 r, vec3 s);
+   CGLM_INLINE void glm_rotate_x(CGLM_IN(mat4) m, float angle, mat4 dest);
+   CGLM_INLINE void glm_rotate_y(CGLM_IN(mat4) m, float angle, mat4 dest);
+   CGLM_INLINE void glm_rotate_z(CGLM_IN(mat4) m, float angle, mat4 dest);
+   CGLM_INLINE void glm_rotate_make(mat4 m, float angle, const vec3 axis);
+   CGLM_INLINE void glm_rotate(CGLM_IN(mat4) m, float angle, const vec3 axis);
+   CGLM_INLINE void glm_rotate_at(CGLM_IN(mat4) m, vec3 pivot, float angle, const vec3 axis);
+   CGLM_INLINE void glm_rotate_atm(CGLM_IN(mat4) m, vec3 pivot, float angle, const vec3 axis);
+   CGLM_INLINE void glm_spin(CGLM_IN(mat4) m, float angle, const vec3 axis);
+   CGLM_INLINE void glm_decompose_scalev(CGLM_IN(mat4) m, vec3 s);
+   CGLM_INLINE bool glm_uniscaled(CGLM_IN(mat4) m);
+   CGLM_INLINE void glm_decompose_rs(CGLM_IN(mat4) m, mat4 r, vec3 s);
+   CGLM_INLINE void glm_decompose(CGLM_IN(mat4) m, vec4 t, mat4 r, vec3 s);
  */
 
 #ifndef cglm_affine_h
@@ -49,7 +49,7 @@
  */
 CGLM_INLINE
 void
-glm_translate_make(mat4 m, vec3 v) {
+glm_translate_make(mat4 m, const vec3 v) {
   glm_mat4_identity(m);
   glm_vec3_copy(v, m[3]);
 }
@@ -64,7 +64,7 @@ glm_translate_make(mat4 m, vec3 v) {
  */
 CGLM_INLINE
 void
-glm_scale_to(mat4 m, vec3 v, mat4 dest) {
+glm_scale_to(CGLM_IN(mat4) m, const vec3 v, mat4 dest) {
   glm_vec4_scale(m[0], v[0], dest[0]);
   glm_vec4_scale(m[1], v[1], dest[1]);
   glm_vec4_scale(m[2], v[2], dest[2]);
@@ -80,7 +80,7 @@ glm_scale_to(mat4 m, vec3 v, mat4 dest) {
  */
 CGLM_INLINE
 void
-glm_scale_make(mat4 m, vec3 v) {
+glm_scale_make(mat4 m, const vec3 v) {
   glm_mat4_identity(m);
   m[0][0] = v[0];
   m[1][1] = v[1];
@@ -96,7 +96,7 @@ glm_scale_make(mat4 m, vec3 v) {
  */
 CGLM_INLINE
 void
-glm_scale(mat4 m, vec3 v) {
+glm_scale(mat4 m, const vec3 v) {
   glm_scale_to(m, v, m);
 }
 
@@ -110,7 +110,7 @@ glm_scale(mat4 m, vec3 v) {
 CGLM_INLINE
 void
 glm_scale_uni(mat4 m, float s) {
-  CGLM_ALIGN(8) vec3 v = { s, s, s };
+  CGLM_ALIGN(8) const vec3 v = { s, s, s };
   glm_scale_to(m, v, m);
 }
 
@@ -125,7 +125,7 @@ glm_scale_uni(mat4 m, float s) {
  */
 CGLM_INLINE
 void
-glm_rotate_make(mat4 m, float angle, vec3 axis) {
+glm_rotate_make(mat4 m, float angle, const vec3 axis) {
   CGLM_ALIGN(8) vec3 axisn, v, vs;
   float c;
 
@@ -155,7 +155,7 @@ glm_rotate_make(mat4 m, float angle, vec3 axis) {
  */
 CGLM_INLINE
 void
-glm_decompose_scalev(mat4 m, vec3 s) {
+glm_decompose_scalev(CGLM_IN(mat4) m, vec3 s) {
   s[0] = glm_vec3_norm(m[0]);
   s[1] = glm_vec3_norm(m[1]);
   s[2] = glm_vec3_norm(m[2]);
@@ -171,7 +171,7 @@ glm_decompose_scalev(mat4 m, vec3 s) {
  */
 CGLM_INLINE
 bool
-glm_uniscaled(mat4 m) {
+glm_uniscaled(CGLM_IN(mat4) m) {
   CGLM_ALIGN(8) vec3 s;
   glm_decompose_scalev(m, s);
   return glm_vec3_eq_all(s);
@@ -187,7 +187,7 @@ glm_uniscaled(mat4 m) {
  */
 CGLM_INLINE
 void
-glm_decompose_rs(mat4 m, mat4 r, vec3 s) {
+glm_decompose_rs(CGLM_IN(mat4) m, mat4 r, vec3 s) {
   CGLM_ALIGN(16) vec4 t = {0.0f, 0.0f, 0.0f, 1.0f};
   CGLM_ALIGN(8)  vec3 v;
 
@@ -227,7 +227,7 @@ glm_decompose_rs(mat4 m, mat4 r, vec3 s) {
  */
 CGLM_INLINE
 void
-glm_decompose(mat4 m, vec4 t, mat4 r, vec3 s) {
+glm_decompose(CGLM_IN(mat4) m, vec4 t, mat4 r, vec3 s) {
   glm_vec4_copy(m[3], t);
   glm_decompose_rs(m, r, s);
 }
diff --git a/include/cglm/affine2d-post.h b/include/cglm/affine2d-post.h
index c6605a897..763a06ad8 100644
--- a/include/cglm/affine2d-post.h
+++ b/include/cglm/affine2d-post.h
@@ -10,11 +10,11 @@
 
 /*
  Functions:
-   CGLM_INLINE void glm_translated2d(mat3 m, vec2 v);
+   CGLM_INLINE void glm_translated2d(mat3 m, const vec2 v);
    CGLM_INLINE void glm_translated2d_x(mat3 m, float to);
    CGLM_INLINE void glm_translated2d_y(mat3 m, float to);
    CGLM_INLINE void glm_rotated2d(mat3 m, float angle);
-   CGLM_INLINE void glm_scaled2d(mat3 m, vec2 v);
+   CGLM_INLINE void glm_scaled2d(mat3 m, const vec2 v);
    CGLM_INLINE void glm_scaled2d_uni(mat3 m, float s);
  */
 
@@ -31,7 +31,7 @@
  */
 CGLM_INLINE
 void
-glm_translated2d(mat3 m, vec2 v) {
+glm_translated2d(mat3 m, const vec2 v) {
   glm_vec2_add(m[2], v, m[2]);
 }
 
@@ -99,7 +99,7 @@ glm_rotated2d(mat3 m, float angle) {
  */
 CGLM_INLINE
 void
-glm_scaled2d(mat3 m, vec2 v) {
+glm_scaled2d(mat3 m, const vec2 v) {
   m[0][0] *= v[0];
   m[1][0] *= v[0];
   m[2][0] *= v[0];
diff --git a/include/cglm/affine2d.h b/include/cglm/affine2d.h
index 0dcf50a00..d75473608 100644
--- a/include/cglm/affine2d.h
+++ b/include/cglm/affine2d.h
@@ -7,14 +7,14 @@
 
 /*
  Functions:
-   CGLM_INLINE void glm_translate2d(mat3 m, vec2 v)
-   CGLM_INLINE void glm_translate2d_to(mat3 m, vec2 v, mat3 dest)
+   CGLM_INLINE void glm_translate2d(mat3 m, const vec2 v)
+   CGLM_INLINE void glm_translate2d_to(mat3 m, const vec2 v, mat3 dest)
    CGLM_INLINE void glm_translate2d_x(mat3 m, float x)
    CGLM_INLINE void glm_translate2d_y(mat3 m, float y)
-   CGLM_INLINE void glm_translate2d_make(mat3 m, vec2 v)
-   CGLM_INLINE void glm_scale2d_to(mat3 m, vec2 v, mat3 dest)
-   CGLM_INLINE void glm_scale2d_make(mat3 m, vec2 v)
-   CGLM_INLINE void glm_scale2d(mat3 m, vec2 v)
+   CGLM_INLINE void glm_translate2d_make(mat3 m, const vec2 v)
+   CGLM_INLINE void glm_scale2d_to(mat3 m, const vec2 v, mat3 dest)
+   CGLM_INLINE void glm_scale2d_make(mat3 m, const vec2 v)
+   CGLM_INLINE void glm_scale2d(mat3 m, const vec2 v)
    CGLM_INLINE void glm_scale2d_uni(mat3 m, float s)
    CGLM_INLINE void glm_rotate2d_make(mat3 m, float angle)
    CGLM_INLINE void glm_rotate2d(mat3 m, float angle)
@@ -38,7 +38,7 @@
  */
 CGLM_INLINE
 void
-glm_translate2d(mat3 m, vec2 v) {
+glm_translate2d(mat3 m, const vec2 v) {
   m[2][0] = m[0][0] * v[0] + m[1][0] * v[1] + m[2][0];
   m[2][1] = m[0][1] * v[0] + m[1][1] * v[1] + m[2][1];
   m[2][2] = m[0][2] * v[0] + m[1][2] * v[1] + m[2][2];
@@ -56,7 +56,7 @@ glm_translate2d(mat3 m, vec2 v) {
  */
 CGLM_INLINE
 void
-glm_translate2d_to(mat3 m, vec2 v, mat3 dest) {
+glm_translate2d_to(CGLM_IN(mat3) m, const vec2 v, mat3 dest) {
   glm_mat3_copy(m, dest);
   glm_translate2d(dest, v);
 }
@@ -97,7 +97,7 @@ glm_translate2d_y(mat3 m, float y) {
  */
 CGLM_INLINE
 void
-glm_translate2d_make(mat3 m, vec2 v) {
+glm_translate2d_make(mat3 m, const vec2 v) {
   glm_mat3_identity(m);
   m[2][0] = v[0];
   m[2][1] = v[1];
@@ -113,15 +113,15 @@ glm_translate2d_make(mat3 m, vec2 v) {
  */
 CGLM_INLINE
 void
-glm_scale2d_to(mat3 m, vec2 v, mat3 dest) {
+glm_scale2d_to(CGLM_IN(mat3) m, const vec2 v, mat3 dest) {
   dest[0][0] = m[0][0] * v[0];
   dest[0][1] = m[0][1] * v[0];
   dest[0][2] = m[0][2] * v[0];
-  
+
   dest[1][0] = m[1][0] * v[1];
   dest[1][1] = m[1][1] * v[1];
   dest[1][2] = m[1][2] * v[1];
-  
+
   dest[2][0] = m[2][0];
   dest[2][1] = m[2][1];
   dest[2][2] = m[2][2];
@@ -135,7 +135,7 @@ glm_scale2d_to(mat3 m, vec2 v, mat3 dest) {
  */
 CGLM_INLINE
 void
-glm_scale2d_make(mat3 m, vec2 v) {
+glm_scale2d_make(mat3 m, const vec2 v) {
   glm_mat3_identity(m);
   m[0][0] = v[0];
   m[1][1] = v[1];
@@ -150,7 +150,7 @@ glm_scale2d_make(mat3 m, vec2 v) {
  */
 CGLM_INLINE
 void
-glm_scale2d(mat3 m, vec2 v) {
+glm_scale2d(mat3 m, const vec2 v) {
   m[0][0] = m[0][0] * v[0];
   m[0][1] = m[0][1] * v[0];
   m[0][2] = m[0][2] * v[0];
@@ -192,7 +192,7 @@ glm_rotate2d_make(mat3 m, float angle) {
 
   s = sinf(angle);
   c = cosf(angle);
-  
+
   m[0][0] = c;
   m[0][1] = s;
   m[0][2] = 0;
@@ -200,7 +200,7 @@ glm_rotate2d_make(mat3 m, float angle) {
   m[1][0] = -s;
   m[1][1] = c;
   m[1][2] = 0;
-  
+
   m[2][0] = 0.0f;
   m[2][1] = 0.0f;
   m[2][2] = 1.0f;
@@ -223,7 +223,7 @@ glm_rotate2d(mat3 m, float angle) {
 
   s = sinf(angle);
   c = cosf(angle);
-  
+
   m[0][0] = m00 * c + m10 * s;
   m[0][1] = m01 * c + m11 * s;
   m[0][2] = m02 * c + m12 * s;
@@ -243,7 +243,7 @@ glm_rotate2d(mat3 m, float angle) {
  */
 CGLM_INLINE
 void
-glm_rotate2d_to(mat3 m, float angle, mat3 dest) {
+glm_rotate2d_to(CGLM_IN(mat3) m, float angle, mat3 dest) {
   float m00 = m[0][0],  m10 = m[1][0],
         m01 = m[0][1],  m11 = m[1][1],
         m02 = m[0][2],  m12 = m[1][2];
@@ -251,7 +251,7 @@ glm_rotate2d_to(mat3 m, float angle, mat3 dest) {
 
   s = sinf(angle);
   c = cosf(angle);
-  
+
   dest[0][0] = m00 * c + m10 * s;
   dest[0][1] = m01 * c + m11 * s;
   dest[0][2] = m02 * c + m12 * s;
@@ -259,7 +259,7 @@ glm_rotate2d_to(mat3 m, float angle, mat3 dest) {
   dest[1][0] = m00 * -s + m10 * c;
   dest[1][1] = m01 * -s + m11 * c;
   dest[1][2] = m02 * -s + m12 * c;
-  
+
   dest[2][0] = m[2][0];
   dest[2][1] = m[2][1];
   dest[2][2] = m[2][2];
diff --git a/include/cglm/box.h b/include/cglm/box.h
index a56909b34..250c61dc2 100644
--- a/include/cglm/box.h
+++ b/include/cglm/box.h
@@ -22,7 +22,7 @@
  */
 CGLM_INLINE
 void
-glm_aabb_transform(vec3 box[2], mat4 m, vec3 dest[2]) {
+glm_aabb_transform(CGLM_IN(vec3) box[2], CGLM_IN(mat4) m, vec3 dest[2]) {
   vec3 v[2], xa, xb, ya, yb, za, zb;
 
   glm_vec3_scale(m[0], box[0][0], xa);
@@ -62,7 +62,7 @@ glm_aabb_transform(vec3 box[2], mat4 m, vec3 dest[2]) {
  */
 CGLM_INLINE
 void
-glm_aabb_merge(vec3 box1[2], vec3 box2[2], vec3 dest[2]) {
+glm_aabb_merge(CGLM_IN(vec3) box1[2], CGLM_IN(vec3) box2[2], vec3 dest[2]) {
   dest[0][0] = glm_min(box1[0][0], box2[0][0]);
   dest[0][1] = glm_min(box1[0][1], box2[0][1]);
   dest[0][2] = glm_min(box1[0][2], box2[0][2]);
@@ -85,7 +85,7 @@ glm_aabb_merge(vec3 box1[2], vec3 box2[2], vec3 dest[2]) {
  */
 CGLM_INLINE
 void
-glm_aabb_crop(vec3 box[2], vec3 cropBox[2], vec3 dest[2]) {
+glm_aabb_crop(CGLM_IN(vec3) box[2], CGLM_IN(vec3) cropBox[2], vec3 dest[2]) {
   dest[0][0] = glm_max(box[0][0], cropBox[0][0]);
   dest[0][1] = glm_max(box[0][1], cropBox[0][1]);
   dest[0][2] = glm_max(box[0][2], cropBox[0][2]);
@@ -109,9 +109,9 @@ glm_aabb_crop(vec3 box[2], vec3 cropBox[2], vec3 dest[2]) {
  */
 CGLM_INLINE
 void
-glm_aabb_crop_until(vec3 box[2],
-                    vec3 cropBox[2],
-                    vec3 clampBox[2],
+glm_aabb_crop_until(CGLM_IN(vec3) box[2],
+                    CGLM_IN(vec3) cropBox[2],
+                    CGLM_IN(vec3) clampBox[2],
                     vec3 dest[2]) {
   glm_aabb_crop(box, cropBox, dest);
   glm_aabb_merge(clampBox, dest, dest);
@@ -133,8 +133,9 @@ glm_aabb_crop_until(vec3 box[2],
  */
 CGLM_INLINE
 bool
-glm_aabb_frustum(vec3 box[2], vec4 planes[6]) {
-  float *p, dp;
+glm_aabb_frustum(CGLM_IN(vec3) box[2], CGLM_IN(vec4) planes[6]) {
+  const float *p;
+  float dp;
   int    i;
 
   for (i = 0; i < 6; i++) {
@@ -169,7 +170,7 @@ glm_aabb_invalidate(vec3 box[2]) {
  */
 CGLM_INLINE
 bool
-glm_aabb_isvalid(vec3 box[2]) {
+glm_aabb_isvalid(CGLM_IN(vec3) box[2]) {
   return glm_vec3_max(box[0]) != FLT_MAX
          && glm_vec3_min(box[1]) != -FLT_MAX;
 }
@@ -181,7 +182,7 @@ glm_aabb_isvalid(vec3 box[2]) {
  */
 CGLM_INLINE
 float
-glm_aabb_size(vec3 box[2]) {
+glm_aabb_size(CGLM_IN(vec3) box[2]) {
   return glm_vec3_distance(box[0], box[1]);
 }
 
@@ -192,7 +193,7 @@ glm_aabb_size(vec3 box[2]) {
  */
 CGLM_INLINE
 float
-glm_aabb_radius(vec3 box[2]) {
+glm_aabb_radius(CGLM_IN(vec3) box[2]) {
   return glm_aabb_size(box) * 0.5f;
 }
 
@@ -204,7 +205,7 @@ glm_aabb_radius(vec3 box[2]) {
  */
 CGLM_INLINE
 void
-glm_aabb_center(vec3 box[2], vec3 dest) {
+glm_aabb_center(CGLM_IN(vec3) box[2], vec3 dest) {
   glm_vec3_center(box[0], box[1], dest);
 }
 
@@ -216,7 +217,7 @@ glm_aabb_center(vec3 box[2], vec3 dest) {
  */
 CGLM_INLINE
 bool
-glm_aabb_aabb(vec3 box[2], vec3 other[2]) {
+glm_aabb_aabb(CGLM_IN(vec3) box[2], CGLM_IN(vec3) other[2]) {
   return (box[0][0] <= other[1][0] && box[1][0] >= other[0][0])
       && (box[0][1] <= other[1][1] && box[1][1] >= other[0][1])
       && (box[0][2] <= other[1][2] && box[1][2] >= other[0][2]);
@@ -235,7 +236,7 @@ glm_aabb_aabb(vec3 box[2], vec3 other[2]) {
  */
 CGLM_INLINE
 bool
-glm_aabb_sphere(vec3 box[2], vec4 s) {
+glm_aabb_sphere(CGLM_IN(vec3) box[2], CGLM_IN(vec4) s) {
   float dmin;
   int   a, b, c;
 
@@ -258,7 +259,7 @@ glm_aabb_sphere(vec3 box[2], vec4 s) {
  */
 CGLM_INLINE
 bool
-glm_aabb_point(vec3 box[2], vec3 point) {
+glm_aabb_point(CGLM_IN(vec3) box[2], CGLM_IN(vec3) point) {
   return (point[0] >= box[0][0] && point[0] <= box[1][0])
       && (point[1] >= box[0][1] && point[1] <= box[1][1])
       && (point[2] >= box[0][2] && point[2] <= box[1][2]);
@@ -272,7 +273,7 @@ glm_aabb_point(vec3 box[2], vec3 point) {
  */
 CGLM_INLINE
 bool
-glm_aabb_contains(vec3 box[2], vec3 other[2]) {
+glm_aabb_contains(CGLM_IN(vec3) box[2], CGLM_IN(vec3) other[2]) {
   return (box[0][0] <= other[0][0] && box[1][0] >= other[1][0])
       && (box[0][1] <= other[0][1] && box[1][1] >= other[1][1])
       && (box[0][2] <= other[0][2] && box[1][2] >= other[1][2]);
diff --git a/include/cglm/cam.h b/include/cglm/cam.h
index 73677de2a..51031e5fc 100644
--- a/include/cglm/cam.h
+++ b/include/cglm/cam.h
@@ -15,9 +15,9 @@
                                float bottom, float top,
                                float nearZ,  float farZ,
                                mat4  dest)
-   CGLM_INLINE void  glm_ortho_aabb(vec3 box[2], mat4 dest)
-   CGLM_INLINE void  glm_ortho_aabb_p(vec3 box[2],  float padding, mat4 dest)
-   CGLM_INLINE void  glm_ortho_aabb_pz(vec3 box[2], float padding, mat4 dest)
+   CGLM_INLINE void  glm_ortho_aabb(CGLM_IN(vec3) box[2], mat4 dest)
+   CGLM_INLINE void  glm_ortho_aabb_p(CGLM_IN(vec3) box[2],  float padding, mat4 dest)
+   CGLM_INLINE void  glm_ortho_aabb_pz(CGLM_IN(vec3) box[2], float padding, mat4 dest)
    CGLM_INLINE void  glm_ortho_default(float aspect, mat4  dest)
    CGLM_INLINE void  glm_ortho_default_s(float aspect, float size, mat4 dest)
    CGLM_INLINE void  glm_perspective(float fovy,
@@ -32,22 +32,22 @@
    CGLM_INLINE void  glm_perspective_default(float aspect, mat4 dest)
    CGLM_INLINE void  glm_perspective_default_infinite(float aspect, mat4 dest)
    CGLM_INLINE void  glm_perspective_resize(float aspect, mat4 proj)
-   CGLM_INLINE void  glm_lookat(vec3 eye, vec3 center, vec3 up, mat4 dest)
-   CGLM_INLINE void  glm_look(vec3 eye, vec3 dir, vec3 up, mat4 dest)
-   CGLM_INLINE void  glm_look_anyup(vec3 eye, vec3 dir, mat4 dest)
+   CGLM_INLINE void  glm_lookat(CGLM_IN(vec3) eye, CGLM_IN(vec3) center, CGLM_IN(vec3) up, mat4 dest)
+   CGLM_INLINE void  glm_look(CGLM_IN(vec3) eye, CGLM_IN(vec3) dir, CGLM_IN(vec3) up, mat4 dest)
+   CGLM_INLINE void  glm_look_anyup(CGLM_IN(vec3) eye, CGLM_IN(vec3) dir, mat4 dest)
    CGLM_INLINE void  glm_persp_decomp(mat4   proj,
                                       float *nearZ, float *farZ,
                                       float *top,   float *bottom,
                                       float *left,  float *right)
-   CGLM_INLINE void  glm_persp_decompv(mat4 proj, float dest[6])
-   CGLM_INLINE void  glm_persp_decomp_x(mat4 proj, float *left, float *right)
-   CGLM_INLINE void  glm_persp_decomp_y(mat4 proj, float *top,  float *bottom)
-   CGLM_INLINE void  glm_persp_decomp_z(mat4 proj, float *nearv, float *farv)
-   CGLM_INLINE void  glm_persp_decomp_far(mat4 proj, float *farZ)
-   CGLM_INLINE void  glm_persp_decomp_near(mat4 proj, float *nearZ)
-   CGLM_INLINE float glm_persp_fovy(mat4 proj)
-   CGLM_INLINE float glm_persp_aspect(mat4 proj)
-   CGLM_INLINE void  glm_persp_sizes(mat4 proj, float fovy, vec4 dest)
+   CGLM_INLINE void  glm_persp_decompv(CGLM_IN(mat4) proj, float dest[6])
+   CGLM_INLINE void  glm_persp_decomp_x(CGLM_IN(mat4) proj, float *left, float *right)
+   CGLM_INLINE void  glm_persp_decomp_y(CGLM_IN(mat4) proj, float *top,  float *bottom)
+   CGLM_INLINE void  glm_persp_decomp_z(CGLM_IN(mat4) proj, float *nearv, float *farv)
+   CGLM_INLINE void  glm_persp_decomp_far(CGLM_IN(mat4) proj, float *farZ)
+   CGLM_INLINE void  glm_persp_decomp_near(CGLM_IN(mat4) proj, float *nearZ)
+   CGLM_INLINE float glm_persp_fovy(CGLM_IN(mat4) proj)
+   CGLM_INLINE float glm_persp_aspect(CGLM_IN(mat4) proj)
+   CGLM_INLINE void  glm_persp_sizes(CGLM_IN(mat4) proj, float fovy, vec4 dest)
  */
 
 #ifndef cglm_cam_h
@@ -157,7 +157,7 @@ glm_ortho(float left,    float right,
  */
 CGLM_INLINE
 void
-glm_ortho_aabb(vec3 box[2], mat4 dest) {
+glm_ortho_aabb(CGLM_IN(vec3) box[2], mat4 dest) {
 #if CGLM_CONFIG_CLIP_CONTROL == CGLM_CLIP_CONTROL_LH_ZO
   glm_ortho_aabb_lh_zo(box, dest);
 #elif CGLM_CONFIG_CLIP_CONTROL == CGLM_CLIP_CONTROL_LH_NO
@@ -180,7 +180,7 @@ glm_ortho_aabb(vec3 box[2], mat4 dest) {
  */
 CGLM_INLINE
 void
-glm_ortho_aabb_p(vec3 box[2], float padding, mat4 dest) {
+glm_ortho_aabb_p(CGLM_IN(vec3) box[2], float padding, mat4 dest) {
 #if CGLM_CONFIG_CLIP_CONTROL == CGLM_CLIP_CONTROL_LH_ZO
   glm_ortho_aabb_p_lh_zo(box, padding, dest);
 #elif CGLM_CONFIG_CLIP_CONTROL == CGLM_CLIP_CONTROL_LH_NO
@@ -203,7 +203,7 @@ glm_ortho_aabb_p(vec3 box[2], float padding, mat4 dest) {
  */
 CGLM_INLINE
 void
-glm_ortho_aabb_pz(vec3 box[2], float padding, mat4 dest) {
+glm_ortho_aabb_pz(CGLM_IN(vec3) box[2], float padding, mat4 dest) {
 #if CGLM_CONFIG_CLIP_CONTROL == CGLM_CLIP_CONTROL_LH_ZO
   glm_ortho_aabb_pz_lh_zo(box, padding, dest);
 #elif CGLM_CONFIG_CLIP_CONTROL == CGLM_CLIP_CONTROL_LH_NO
@@ -395,7 +395,7 @@ glm_perspective_resize(float aspect, mat4 proj) {
  */
 CGLM_INLINE
 void
-glm_lookat(vec3 eye, vec3 center, vec3 up, mat4 dest) {
+glm_lookat(CGLM_IN(vec3) eye, CGLM_IN(vec3) center, CGLM_IN(vec3) up, mat4 dest) {
 #if CGLM_CONFIG_CLIP_CONTROL & CGLM_CLIP_CONTROL_LH_BIT
   glm_lookat_lh(eye, center, up, dest);
 #elif CGLM_CONFIG_CLIP_CONTROL & CGLM_CLIP_CONTROL_RH_BIT
@@ -419,7 +419,7 @@ glm_lookat(vec3 eye, vec3 center, vec3 up, mat4 dest) {
  */
 CGLM_INLINE
 void
-glm_look(vec3 eye, vec3 dir, vec3 up, mat4 dest) {
+glm_look(CGLM_IN(vec3) eye, CGLM_IN(vec3) dir, CGLM_IN(vec3) up, mat4 dest) {
 #if CGLM_CONFIG_CLIP_CONTROL & CGLM_CLIP_CONTROL_LH_BIT
   glm_look_lh(eye, dir, up, dest);
 #elif CGLM_CONFIG_CLIP_CONTROL & CGLM_CLIP_CONTROL_RH_BIT
@@ -439,7 +439,7 @@ glm_look(vec3 eye, vec3 dir, vec3 up, mat4 dest) {
  */
 CGLM_INLINE
 void
-glm_look_anyup(vec3 eye, vec3 dir, mat4 dest) {
+glm_look_anyup(CGLM_IN(vec3) eye, CGLM_IN(vec3) dir, mat4 dest) {
 #if CGLM_CONFIG_CLIP_CONTROL & CGLM_CLIP_CONTROL_LH_BIT
   glm_look_anyup_lh(eye, dir, dest);
 #elif CGLM_CONFIG_CLIP_CONTROL & CGLM_CLIP_CONTROL_RH_BIT
@@ -460,7 +460,7 @@ glm_look_anyup(vec3 eye, vec3 dir, mat4 dest) {
  */
 CGLM_INLINE
 void
-glm_persp_decomp(mat4 proj,
+glm_persp_decomp(CGLM_IN(mat4) proj,
                  float * __restrict nearZ, float * __restrict farZ,
                  float * __restrict top,   float * __restrict bottom,
                  float * __restrict left,  float * __restrict right) {
@@ -484,7 +484,7 @@ glm_persp_decomp(mat4 proj,
  */
 CGLM_INLINE
 void
-glm_persp_decompv(mat4 proj, float dest[6]) {
+glm_persp_decompv(CGLM_IN(mat4) proj, float dest[6]) {
 #if CGLM_CONFIG_CLIP_CONTROL == CGLM_CLIP_CONTROL_LH_ZO
   glm_persp_decompv_lh_zo(proj, dest);
 #elif CGLM_CONFIG_CLIP_CONTROL == CGLM_CLIP_CONTROL_LH_NO
@@ -506,7 +506,7 @@ glm_persp_decompv(mat4 proj, float dest[6]) {
  */
 CGLM_INLINE
 void
-glm_persp_decomp_x(mat4 proj,
+glm_persp_decomp_x(CGLM_IN(mat4) proj,
                    float * __restrict left,
                    float * __restrict right) {
 #if CGLM_CONFIG_CLIP_CONTROL == CGLM_CLIP_CONTROL_LH_ZO
@@ -530,7 +530,7 @@ glm_persp_decomp_x(mat4 proj,
  */
 CGLM_INLINE
 void
-glm_persp_decomp_y(mat4 proj,
+glm_persp_decomp_y(CGLM_IN(mat4) proj,
                    float * __restrict top,
                    float * __restrict bottom) {
 #if CGLM_CONFIG_CLIP_CONTROL == CGLM_CLIP_CONTROL_LH_ZO
@@ -554,7 +554,7 @@ glm_persp_decomp_y(mat4 proj,
  */
 CGLM_INLINE
 void
-glm_persp_decomp_z(mat4 proj, float * __restrict nearZ, float * __restrict farZ) {
+glm_persp_decomp_z(CGLM_IN(mat4) proj, float * __restrict nearZ, float * __restrict farZ) {
 #if CGLM_CONFIG_CLIP_CONTROL == CGLM_CLIP_CONTROL_LH_ZO
   glm_persp_decomp_z_lh_zo(proj, nearZ, farZ);
 #elif CGLM_CONFIG_CLIP_CONTROL == CGLM_CLIP_CONTROL_LH_NO
@@ -574,7 +574,7 @@ glm_persp_decomp_z(mat4 proj, float * __restrict nearZ, float * __restrict farZ)
  */
 CGLM_INLINE
 void
-glm_persp_decomp_far(mat4 proj, float * __restrict farZ) {
+glm_persp_decomp_far(CGLM_IN(mat4) proj, float * __restrict farZ) {
 #if CGLM_CONFIG_CLIP_CONTROL == CGLM_CLIP_CONTROL_LH_ZO
   glm_persp_decomp_far_lh_zo(proj, farZ);
 #elif CGLM_CONFIG_CLIP_CONTROL == CGLM_CLIP_CONTROL_LH_NO
@@ -594,7 +594,7 @@ glm_persp_decomp_far(mat4 proj, float * __restrict farZ) {
  */
 CGLM_INLINE
 void
-glm_persp_decomp_near(mat4 proj, float * __restrict nearZ) {
+glm_persp_decomp_near(CGLM_IN(mat4) proj, float * __restrict nearZ) {
 #if CGLM_CONFIG_CLIP_CONTROL == CGLM_CLIP_CONTROL_LH_ZO
   glm_persp_decomp_near_lh_zo(proj, nearZ);
 #elif CGLM_CONFIG_CLIP_CONTROL == CGLM_CLIP_CONTROL_LH_NO
@@ -615,7 +615,7 @@ glm_persp_decomp_near(mat4 proj, float * __restrict nearZ) {
  */
 CGLM_INLINE
 void
-glm_persp_sizes(mat4 proj, float fovy, vec4 dest) {
+glm_persp_sizes(CGLM_IN(mat4) proj, float fovy, vec4 dest) {
 #if CGLM_CONFIG_CLIP_CONTROL == CGLM_CLIP_CONTROL_LH_ZO
   glm_persp_sizes_lh_zo(proj, fovy, dest);
 #elif CGLM_CONFIG_CLIP_CONTROL == CGLM_CLIP_CONTROL_LH_NO
diff --git a/include/cglm/clipspace/ortho_lh_no.h b/include/cglm/clipspace/ortho_lh_no.h
index 76c7a94e9..251befe9d 100644
--- a/include/cglm/clipspace/ortho_lh_no.h
+++ b/include/cglm/clipspace/ortho_lh_no.h
@@ -11,11 +11,11 @@
                                     float bottom,  float top,
                                     float nearZ, float farZ,
                                     mat4  dest)
-   CGLM_INLINE void glm_ortho_aabb_lh_no(vec3 box[2], mat4 dest)
-   CGLM_INLINE void glm_ortho_aabb_p_lh_no(vec3 box[2],
+   CGLM_INLINE void glm_ortho_aabb_lh_no(CGLM_IN(vec3) box[2], mat4 dest)
+   CGLM_INLINE void glm_ortho_aabb_p_lh_no(CGLM_IN(vec3) box[2],
                                            float padding,
                                            mat4 dest)
-   CGLM_INLINE void glm_ortho_aabb_pz_lh_no(vec3 box[2],
+   CGLM_INLINE void glm_ortho_aabb_pz_lh_no(CGLM_IN(vec3) box[2],
                                             float padding,
                                             mat4 dest)
    CGLM_INLINE void glm_ortho_default_lh_no(float aspect,
@@ -80,7 +80,7 @@ glm_ortho_lh_no(float left,    float right,
  */
 CGLM_INLINE
 void
-glm_ortho_aabb_lh_no(vec3 box[2], mat4 dest) {
+glm_ortho_aabb_lh_no(CGLM_IN(vec3) box[2], mat4 dest) {
   glm_ortho_lh_no(box[0][0],  box[1][0],
                   box[0][1],  box[1][1],
                  -box[1][2], -box[0][2],
@@ -100,7 +100,7 @@ glm_ortho_aabb_lh_no(vec3 box[2], mat4 dest) {
  */
 CGLM_INLINE
 void
-glm_ortho_aabb_p_lh_no(vec3 box[2], float padding, mat4 dest) {
+glm_ortho_aabb_p_lh_no(CGLM_IN(vec3) box[2], float padding, mat4 dest) {
   glm_ortho_lh_no(box[0][0] - padding,    box[1][0] + padding,
                   box[0][1] - padding,    box[1][1] + padding,
                 -(box[1][2] + padding), -(box[0][2] - padding),
@@ -120,7 +120,7 @@ glm_ortho_aabb_p_lh_no(vec3 box[2], float padding, mat4 dest) {
  */
 CGLM_INLINE
 void
-glm_ortho_aabb_pz_lh_no(vec3 box[2], float padding, mat4 dest) {
+glm_ortho_aabb_pz_lh_no(CGLM_IN(vec3) box[2], float padding, mat4 dest) {
   glm_ortho_lh_no(box[0][0],              box[1][0],
                   box[0][1],              box[1][1],
                 -(box[1][2] + padding), -(box[0][2] - padding),
diff --git a/include/cglm/clipspace/ortho_lh_zo.h b/include/cglm/clipspace/ortho_lh_zo.h
index e45530d4d..197fb1586 100644
--- a/include/cglm/clipspace/ortho_lh_zo.h
+++ b/include/cglm/clipspace/ortho_lh_zo.h
@@ -11,11 +11,11 @@
                                     float bottom,  float top,
                                     float nearZ, float farZ,
                                     mat4  dest)
-   CGLM_INLINE void glm_ortho_aabb_lh_zo(vec3 box[2], mat4 dest)
-   CGLM_INLINE void glm_ortho_aabb_p_lh_zo(vec3 box[2],
+   CGLM_INLINE void glm_ortho_aabb_lh_zo(CGLM_IN(vec3) box[2], mat4 dest)
+   CGLM_INLINE void glm_ortho_aabb_p_lh_zo(CGLM_IN(vec3) box[2],
                                            float padding,
                                            mat4 dest)
-   CGLM_INLINE void glm_ortho_aabb_pz_lh_zo(vec3 box[2],
+   CGLM_INLINE void glm_ortho_aabb_pz_lh_zo(CGLM_IN(vec3) box[2],
                                             float padding,
                                             mat4 dest)
    CGLM_INLINE void glm_ortho_default_lh_zo(float aspect,
@@ -78,7 +78,7 @@ glm_ortho_lh_zo(float left,    float right,
  */
 CGLM_INLINE
 void
-glm_ortho_aabb_lh_zo(vec3 box[2], mat4 dest) {
+glm_ortho_aabb_lh_zo(CGLM_IN(vec3) box[2], mat4 dest) {
   glm_ortho_lh_zo(box[0][0],  box[1][0],
                   box[0][1],  box[1][1],
                  -box[1][2], -box[0][2],
@@ -97,7 +97,7 @@ glm_ortho_aabb_lh_zo(vec3 box[2], mat4 dest) {
  */
 CGLM_INLINE
 void
-glm_ortho_aabb_p_lh_zo(vec3 box[2], float padding, mat4 dest) {
+glm_ortho_aabb_p_lh_zo(CGLM_IN(vec3) box[2], float padding, mat4 dest) {
   glm_ortho_lh_zo(box[0][0] - padding,    box[1][0] + padding,
                   box[0][1] - padding,    box[1][1] + padding,
                 -(box[1][2] + padding), -(box[0][2] - padding),
@@ -116,7 +116,7 @@ glm_ortho_aabb_p_lh_zo(vec3 box[2], float padding, mat4 dest) {
  */
 CGLM_INLINE
 void
-glm_ortho_aabb_pz_lh_zo(vec3 box[2], float padding, mat4 dest) {
+glm_ortho_aabb_pz_lh_zo(CGLM_IN(vec3) box[2], float padding, mat4 dest) {
   glm_ortho_lh_zo(box[0][0],              box[1][0],
                   box[0][1],              box[1][1],
                 -(box[1][2] + padding), -(box[0][2] - padding),
diff --git a/include/cglm/clipspace/ortho_rh_no.h b/include/cglm/clipspace/ortho_rh_no.h
index aa7a90607..c9c2530bf 100644
--- a/include/cglm/clipspace/ortho_rh_no.h
+++ b/include/cglm/clipspace/ortho_rh_no.h
@@ -11,11 +11,11 @@
                                     float bottom,  float top,
                                     float nearZ, float farZ,
                                     mat4  dest)
-   CGLM_INLINE void glm_ortho_aabb_rh_no(vec3 box[2], mat4 dest)
-   CGLM_INLINE void glm_ortho_aabb_p_rh_no(vec3 box[2],
+   CGLM_INLINE void glm_ortho_aabb_rh_no(CGLM_IN(vec3) box[2], mat4 dest)
+   CGLM_INLINE void glm_ortho_aabb_p_rh_no(CGLM_IN(vec3) box[2],
                                            float padding,
                                            mat4 dest)
-   CGLM_INLINE void glm_ortho_aabb_pz_rh_no(vec3 box[2],
+   CGLM_INLINE void glm_ortho_aabb_pz_rh_no(CGLM_IN(vec3) box[2],
                                             float padding,
                                             mat4 dest)
    CGLM_INLINE void glm_ortho_default_rh_no(float aspect,
@@ -80,7 +80,7 @@ glm_ortho_rh_no(float left,    float right,
  */
 CGLM_INLINE
 void
-glm_ortho_aabb_rh_no(vec3 box[2], mat4 dest) {
+glm_ortho_aabb_rh_no(CGLM_IN(vec3) box[2], mat4 dest) {
   glm_ortho_rh_no(box[0][0],  box[1][0],
                   box[0][1],  box[1][1],
                  -box[1][2], -box[0][2],
@@ -100,7 +100,7 @@ glm_ortho_aabb_rh_no(vec3 box[2], mat4 dest) {
  */
 CGLM_INLINE
 void
-glm_ortho_aabb_p_rh_no(vec3 box[2], float padding, mat4 dest) {
+glm_ortho_aabb_p_rh_no(CGLM_IN(vec3) box[2], float padding, mat4 dest) {
   glm_ortho_rh_no(box[0][0] - padding,    box[1][0] + padding,
                   box[0][1] - padding,    box[1][1] + padding,
                 -(box[1][2] + padding), -(box[0][2] - padding),
@@ -120,7 +120,7 @@ glm_ortho_aabb_p_rh_no(vec3 box[2], float padding, mat4 dest) {
  */
 CGLM_INLINE
 void
-glm_ortho_aabb_pz_rh_no(vec3 box[2], float padding, mat4 dest) {
+glm_ortho_aabb_pz_rh_no(CGLM_IN(vec3) box[2], float padding, mat4 dest) {
   glm_ortho_rh_no(box[0][0],              box[1][0],
                   box[0][1],              box[1][1],
                 -(box[1][2] + padding), -(box[0][2] - padding),
diff --git a/include/cglm/clipspace/ortho_rh_zo.h b/include/cglm/clipspace/ortho_rh_zo.h
index 7a0876c02..747dc06d3 100644
--- a/include/cglm/clipspace/ortho_rh_zo.h
+++ b/include/cglm/clipspace/ortho_rh_zo.h
@@ -11,11 +11,11 @@
                                     float bottom,  float top,
                                     float nearZ, float farZ,
                                     mat4  dest)
-   CGLM_INLINE void glm_ortho_aabb_rh_zo(vec3 box[2], mat4 dest)
-   CGLM_INLINE void glm_ortho_aabb_p_rh_zo(vec3 box[2],
+   CGLM_INLINE void glm_ortho_aabb_rh_zo(CGLM_IN(vec3) box[2], mat4 dest)
+   CGLM_INLINE void glm_ortho_aabb_p_rh_zo(CGLM_IN(vec3) box[2],
                                            float padding,
                                            mat4 dest)
-   CGLM_INLINE void glm_ortho_aabb_pz_rh_zo(vec3 box[2],
+   CGLM_INLINE void glm_ortho_aabb_pz_rh_zo(CGLM_IN(vec3) box[2],
                                             float padding,
                                             mat4 dest)
    CGLM_INLINE void glm_ortho_default_rh_zo(float aspect,
@@ -79,7 +79,7 @@ glm_ortho_rh_zo(float left,    float right,
  */
 CGLM_INLINE
 void
-glm_ortho_aabb_rh_zo(vec3 box[2], mat4 dest) {
+glm_ortho_aabb_rh_zo(CGLM_IN(vec3) box[2], mat4 dest) {
   glm_ortho_rh_zo(box[0][0],  box[1][0],
                   box[0][1],  box[1][1],
                  -box[1][2], -box[0][2],
@@ -99,7 +99,7 @@ glm_ortho_aabb_rh_zo(vec3 box[2], mat4 dest) {
  */
 CGLM_INLINE
 void
-glm_ortho_aabb_p_rh_zo(vec3 box[2], float padding, mat4 dest) {
+glm_ortho_aabb_p_rh_zo(CGLM_IN(vec3) box[2], float padding, mat4 dest) {
   glm_ortho_rh_zo(box[0][0] - padding,    box[1][0] + padding,
                   box[0][1] - padding,    box[1][1] + padding,
                 -(box[1][2] + padding), -(box[0][2] - padding),
@@ -119,7 +119,7 @@ glm_ortho_aabb_p_rh_zo(vec3 box[2], float padding, mat4 dest) {
  */
 CGLM_INLINE
 void
-glm_ortho_aabb_pz_rh_zo(vec3 box[2], float padding, mat4 dest) {
+glm_ortho_aabb_pz_rh_zo(CGLM_IN(vec3) box[2], float padding, mat4 dest) {
   glm_ortho_rh_zo(box[0][0],              box[1][0],
                   box[0][1],              box[1][1],
                 -(box[1][2] + padding), -(box[0][2] - padding),
diff --git a/include/cglm/clipspace/persp.h b/include/cglm/clipspace/persp.h
index 15aa715f1..759acdaab 100644
--- a/include/cglm/clipspace/persp.h
+++ b/include/cglm/clipspace/persp.h
@@ -7,10 +7,10 @@
 
 /*
  Functions:
-   CGLM_INLINE void  glm_persp_decomp_far(mat4 proj, float *farZ)
-   CGLM_INLINE float glm_persp_fovy(mat4 proj)
-   CGLM_INLINE float glm_persp_aspect(mat4 proj)
-   CGLM_INLINE void  glm_persp_sizes(mat4 proj, float fovy, vec4 dest)
+   CGLM_INLINE void  glm_persp_decomp_far(CGLM_IN(mat4) proj, float *farZ)
+   CGLM_INLINE float glm_persp_fovy(CGLM_IN(mat4) proj)
+   CGLM_INLINE float glm_persp_aspect(CGLM_IN(mat4) proj)
+   CGLM_INLINE void  glm_persp_sizes(CGLM_IN(mat4) proj, float fovy, vec4 dest)
  */
 
 #ifndef cglm_persp_h
@@ -30,7 +30,7 @@
  */
 CGLM_INLINE
 float
-glm_persp_fovy(mat4 proj) {
+glm_persp_fovy(CGLM_IN(mat4) proj) {
   return 2.0f * atanf(1.0f / proj[1][1]);
 }
 
@@ -41,7 +41,7 @@ glm_persp_fovy(mat4 proj) {
  */
 CGLM_INLINE
 float
-glm_persp_aspect(mat4 proj) {
+glm_persp_aspect(CGLM_IN(mat4) proj) {
   return proj[1][1] / proj[0][0];
 }
 
diff --git a/include/cglm/clipspace/persp_lh_no.h b/include/cglm/clipspace/persp_lh_no.h
index 6126b7215..516364d88 100644
--- a/include/cglm/clipspace/persp_lh_no.h
+++ b/include/cglm/clipspace/persp_lh_no.h
@@ -25,27 +25,27 @@
    CGLM_INLINE void glm_perspective_resize_lh_no(float aspect, mat4 proj)
    CGLM_INLINE void glm_persp_move_far_lh_no(mat4 proj,
                                              float deltaFar)
-   CGLM_INLINE void glm_persp_decomp_lh_no(mat4 proj,
+   CGLM_INLINE void glm_persp_decomp_lh_no(CGLM_IN(mat4) proj,
                                            float * __restrict nearZ,
                                            float * __restrict farZ,
                                            float * __restrict top,
                                            float * __restrict bottom,
                                            float * __restrict left,
                                            float * __restrict right)
-  CGLM_INLINE void glm_persp_decompv_lh_no(mat4 proj,
+  CGLM_INLINE void glm_persp_decompv_lh_no(CGLM_IN(mat4) proj,
                                            float dest[6])
-  CGLM_INLINE void glm_persp_decomp_x_lh_no(mat4 proj,
+  CGLM_INLINE void glm_persp_decomp_x_lh_no(CGLM_IN(mat4) proj,
                                             float * __restrict left,
                                             float * __restrict right)
-  CGLM_INLINE void glm_persp_decomp_y_lh_no(mat4 proj,
+  CGLM_INLINE void glm_persp_decomp_y_lh_no(CGLM_IN(mat4) proj,
                                             float * __restrict top,
                                             float * __restrict bottom)
-  CGLM_INLINE void glm_persp_decomp_z_lh_no(mat4 proj,
+  CGLM_INLINE void glm_persp_decomp_z_lh_no(CGLM_IN(mat4) proj,
                                             float * __restrict nearZ,
                                             float * __restrict farZ)
-  CGLM_INLINE void glm_persp_decomp_far_lh_no(mat4 proj, float * __restrict farZ)
-  CGLM_INLINE void glm_persp_decomp_near_lh_no(mat4 proj, float * __restrict nearZ)
-  CGLM_INLINE void glm_persp_sizes_lh_no(mat4 proj, float fovy, vec4 dest)
+  CGLM_INLINE void glm_persp_decomp_far_lh_no(CGLM_IN(mat4) proj, float * __restrict farZ)
+  CGLM_INLINE void glm_persp_decomp_near_lh_no(CGLM_IN(mat4) proj, float * __restrict nearZ)
+  CGLM_INLINE void glm_persp_sizes_lh_no(CGLM_IN(mat4) proj, float fovy, vec4 dest)
  */
 
 #ifndef cglm_persp_lh_no_h
@@ -239,7 +239,7 @@ glm_persp_move_far_lh_no(mat4 proj, float deltaFar) {
  */
 CGLM_INLINE
 void
-glm_persp_decomp_lh_no(mat4 proj,
+glm_persp_decomp_lh_no(CGLM_IN(mat4) proj,
                        float * __restrict nearZ, float * __restrict farZ,
                        float * __restrict top,   float * __restrict bottom,
                        float * __restrict left,  float * __restrict right) {
@@ -278,7 +278,7 @@ glm_persp_decomp_lh_no(mat4 proj,
  */
 CGLM_INLINE
 void
-glm_persp_decompv_lh_no(mat4 proj, float dest[6]) {
+glm_persp_decompv_lh_no(CGLM_IN(mat4) proj, float dest[6]) {
   glm_persp_decomp_lh_no(proj, &dest[0], &dest[1], &dest[2],
                                &dest[3], &dest[4], &dest[5]);
 }
@@ -295,7 +295,7 @@ glm_persp_decompv_lh_no(mat4 proj, float dest[6]) {
  */
 CGLM_INLINE
 void
-glm_persp_decomp_x_lh_no(mat4 proj,
+glm_persp_decomp_x_lh_no(CGLM_IN(mat4) proj,
                          float * __restrict left,
                          float * __restrict right) {
   float nearZ, m20, m00, m22;
@@ -321,7 +321,7 @@ glm_persp_decomp_x_lh_no(mat4 proj,
  */
 CGLM_INLINE
 void
-glm_persp_decomp_y_lh_no(mat4 proj,
+glm_persp_decomp_y_lh_no(CGLM_IN(mat4) proj,
                          float * __restrict top,
                          float * __restrict bottom) {
   float nearZ, m21, m11, m22;
@@ -347,7 +347,7 @@ glm_persp_decomp_y_lh_no(mat4 proj,
  */
 CGLM_INLINE
 void
-glm_persp_decomp_z_lh_no(mat4 proj,
+glm_persp_decomp_z_lh_no(CGLM_IN(mat4) proj,
                          float * __restrict nearZ,
                          float * __restrict farZ) {
   float m32, m22;
@@ -369,7 +369,7 @@ glm_persp_decomp_z_lh_no(mat4 proj,
  */
 CGLM_INLINE
 void
-glm_persp_decomp_far_lh_no(mat4 proj, float * __restrict farZ) {
+glm_persp_decomp_far_lh_no(CGLM_IN(mat4) proj, float * __restrict farZ) {
   *farZ = proj[3][2] / (-proj[2][2] + 1.0f);
 }
 
@@ -383,7 +383,7 @@ glm_persp_decomp_far_lh_no(mat4 proj, float * __restrict farZ) {
  */
 CGLM_INLINE
 void
-glm_persp_decomp_near_lh_no(mat4 proj, float * __restrict nearZ) {
+glm_persp_decomp_near_lh_no(CGLM_IN(mat4) proj, float * __restrict nearZ) {
   *nearZ = proj[3][2] / (-proj[2][2] - 1.0f);
 }
 
@@ -398,7 +398,7 @@ glm_persp_decomp_near_lh_no(mat4 proj, float * __restrict nearZ) {
  */
 CGLM_INLINE
 void
-glm_persp_sizes_lh_no(mat4 proj, float fovy, vec4 dest) {
+glm_persp_sizes_lh_no(CGLM_IN(mat4) proj, float fovy, vec4 dest) {
   float t, a, nearZ, farZ;
 
   t = 2.0f * tanf(fovy * 0.5f);
@@ -423,7 +423,7 @@ glm_persp_sizes_lh_no(mat4 proj, float fovy, vec4 dest) {
  */
 CGLM_INLINE
 float
-glm_persp_fovy_lh_no(mat4 proj) {
+glm_persp_fovy_lh_no(CGLM_IN(mat4) proj) {
   return glm_persp_fovy(proj);
 }
 
@@ -435,7 +435,7 @@ glm_persp_fovy_lh_no(mat4 proj) {
  */
 CGLM_INLINE
 float
-glm_persp_aspect_lh_no(mat4 proj) {
+glm_persp_aspect_lh_no(CGLM_IN(mat4) proj) {
   return glm_persp_aspect(proj);
 }
 
diff --git a/include/cglm/clipspace/persp_lh_zo.h b/include/cglm/clipspace/persp_lh_zo.h
index 905eacb69..badc1dff4 100644
--- a/include/cglm/clipspace/persp_lh_zo.h
+++ b/include/cglm/clipspace/persp_lh_zo.h
@@ -25,27 +25,27 @@
    CGLM_INLINE void glm_perspective_resize_lh_zo(float aspect, mat4 proj)
    CGLM_INLINE void glm_persp_move_far_lh_zo(mat4 proj,
                                              float deltaFar)
-   CGLM_INLINE void glm_persp_decomp_lh_zo(mat4 proj,
+   CGLM_INLINE void glm_persp_decomp_lh_zo(CGLM_IN(mat4) proj,
                                            float * __restrict nearZ,
                                            float * __restrict farZ,
                                            float * __restrict top,
                                            float * __restrict bottom,
                                            float * __restrict left,
                                            float * __restrict right)
-  CGLM_INLINE void glm_persp_decompv_lh_zo(mat4 proj,
+  CGLM_INLINE void glm_persp_decompv_lh_zo(CGLM_IN(mat4) proj,
                                            float dest[6])
-  CGLM_INLINE void glm_persp_decomp_x_lh_zo(mat4 proj,
+  CGLM_INLINE void glm_persp_decomp_x_lh_zo(CGLM_IN(mat4) proj,
                                             float * __restrict left,
                                             float * __restrict right)
-  CGLM_INLINE void glm_persp_decomp_y_lh_zo(mat4 proj,
+  CGLM_INLINE void glm_persp_decomp_y_lh_zo(CGLM_IN(mat4) proj,
                                             float * __restrict top,
                                             float * __restrict bottom)
-  CGLM_INLINE void glm_persp_decomp_z_lh_zo(mat4 proj,
+  CGLM_INLINE void glm_persp_decomp_z_lh_zo(CGLM_IN(mat4) proj,
                                             float * __restrict nearZ,
                                             float * __restrict farZ)
-  CGLM_INLINE void glm_persp_decomp_far_lh_zo(mat4 proj, float * __restrict farZ)
-  CGLM_INLINE void glm_persp_decomp_near_lh_zo(mat4 proj, float * __restrict nearZ)
-  CGLM_INLINE void glm_persp_sizes_lh_zo(mat4 proj, float fovy, vec4 dest)
+  CGLM_INLINE void glm_persp_decomp_far_lh_zo(CGLM_IN(mat4) proj, float * __restrict farZ)
+  CGLM_INLINE void glm_persp_decomp_near_lh_zo(CGLM_IN(mat4) proj, float * __restrict nearZ)
+  CGLM_INLINE void glm_persp_sizes_lh_zo(CGLM_IN(mat4) proj, float fovy, vec4 dest)
  */
 
 #ifndef cglm_persp_lh_zo_h
@@ -223,7 +223,7 @@ glm_perspective_resize_lh_zo(float aspect, mat4 proj) {
 
 /*!
  * @brief decomposes frustum values of perspective projection
- *        with angle values with a left-hand coordinate system and a 
+ *        with angle values with a left-hand coordinate system and a
  *        clip-space of [0, 1].
  *
  * @param[in]  proj    perspective projection matrix
@@ -236,7 +236,7 @@ glm_perspective_resize_lh_zo(float aspect, mat4 proj) {
  */
 CGLM_INLINE
 void
-glm_persp_decomp_lh_zo(mat4 proj,
+glm_persp_decomp_lh_zo(CGLM_IN(mat4) proj,
                     float * __restrict nearZ, float * __restrict farZ,
                     float * __restrict top,     float * __restrict bottom,
                     float * __restrict left,    float * __restrict right) {
@@ -266,7 +266,7 @@ glm_persp_decomp_lh_zo(mat4 proj,
 
 /*!
  * @brief decomposes frustum values of perspective projection
- *        with angle values with a left-hand coordinate system and a 
+ *        with angle values with a left-hand coordinate system and a
  *        clip-space of [0, 1].
  *        this makes easy to get all values at once
  *
@@ -275,7 +275,7 @@ glm_persp_decomp_lh_zo(mat4 proj,
  */
 CGLM_INLINE
 void
-glm_persp_decompv_lh_zo(mat4 proj, float dest[6]) {
+glm_persp_decompv_lh_zo(CGLM_IN(mat4) proj, float dest[6]) {
   glm_persp_decomp_lh_zo(proj, &dest[0], &dest[1], &dest[2],
                                &dest[3], &dest[4], &dest[5]);
 }
@@ -290,7 +290,7 @@ glm_persp_decompv_lh_zo(mat4 proj, float dest[6]) {
  */
 CGLM_INLINE
 void
-glm_persp_decomp_x_lh_zo(mat4 proj,
+glm_persp_decomp_x_lh_zo(CGLM_IN(mat4) proj,
                          float * __restrict left,
                          float * __restrict right) {
   float nearZ, m20, m00;
@@ -305,7 +305,7 @@ glm_persp_decomp_x_lh_zo(mat4 proj,
 
 /*!
  * @brief decomposes top and bottom values of perspective projection
- *        with angle values with a left-hand coordinate system and a 
+ *        with angle values with a left-hand coordinate system and a
  *        clip-space of [0, 1].
  *        y stands for y axis (top / bottom axis)
  *
@@ -315,7 +315,7 @@ glm_persp_decomp_x_lh_zo(mat4 proj,
  */
 CGLM_INLINE
 void
-glm_persp_decomp_y_lh_zo(mat4 proj,
+glm_persp_decomp_y_lh_zo(CGLM_IN(mat4) proj,
                          float * __restrict top,
                          float * __restrict bottom) {
   float nearZ, m21, m11;
@@ -330,7 +330,7 @@ glm_persp_decomp_y_lh_zo(mat4 proj,
 
 /*!
  * @brief decomposes near and far values of perspective projection
- *        with angle values with a left-hand coordinate system and a 
+ *        with angle values with a left-hand coordinate system and a
  *        clip-space of [0, 1].
  *        z stands for z axis (near / far axis)
  *
@@ -340,7 +340,7 @@ glm_persp_decomp_y_lh_zo(mat4 proj,
  */
 CGLM_INLINE
 void
-glm_persp_decomp_z_lh_zo(mat4 proj,
+glm_persp_decomp_z_lh_zo(CGLM_IN(mat4) proj,
                          float * __restrict nearZ,
                          float * __restrict farZ) {
   float m32, m22;
@@ -354,7 +354,7 @@ glm_persp_decomp_z_lh_zo(mat4 proj,
 
 /*!
  * @brief decomposes far value of perspective projection
- *        with angle values with a left-hand coordinate system and a 
+ *        with angle values with a left-hand coordinate system and a
  *        clip-space of [0, 1].
  *
  * @param[in]  proj   perspective projection matrix
@@ -362,13 +362,13 @@ glm_persp_decomp_z_lh_zo(mat4 proj,
  */
 CGLM_INLINE
 void
-glm_persp_decomp_far_lh_zo(mat4 proj, float * __restrict farZ) {
+glm_persp_decomp_far_lh_zo(CGLM_IN(mat4) proj, float * __restrict farZ) {
   *farZ = proj[3][2] / (-proj[2][2] + 1.0f);
 }
 
 /*!
  * @brief decomposes near value of perspective projection
- *        with angle values with a left-hand coordinate system and a 
+ *        with angle values with a left-hand coordinate system and a
  *        clip-space of [0, 1].
  *
  * @param[in]  proj    perspective projection matrix
@@ -376,7 +376,7 @@ glm_persp_decomp_far_lh_zo(mat4 proj, float * __restrict farZ) {
  */
 CGLM_INLINE
 void
-glm_persp_decomp_near_lh_zo(mat4 proj, float * __restrict nearZ) {
+glm_persp_decomp_near_lh_zo(CGLM_IN(mat4) proj, float * __restrict nearZ) {
   *nearZ = proj[3][2] / -proj[2][2];
 }
 
@@ -391,7 +391,7 @@ glm_persp_decomp_near_lh_zo(mat4 proj, float * __restrict nearZ) {
  */
 CGLM_INLINE
 void
-glm_persp_sizes_lh_zo(mat4 proj, float fovy, vec4 dest) {
+glm_persp_sizes_lh_zo(CGLM_IN(mat4) proj, float fovy, vec4 dest) {
   float t, a, nearZ, farZ;
 
   t = 2.0f * tanf(fovy * 0.5f);
@@ -416,7 +416,7 @@ glm_persp_sizes_lh_zo(mat4 proj, float fovy, vec4 dest) {
  */
 CGLM_INLINE
 float
-glm_persp_fovy_lh_zo(mat4 proj) {
+glm_persp_fovy_lh_zo(CGLM_IN(mat4) proj) {
   return glm_persp_fovy(proj);
 }
 
@@ -428,7 +428,7 @@ glm_persp_fovy_lh_zo(mat4 proj) {
  */
 CGLM_INLINE
 float
-glm_persp_aspect_lh_zo(mat4 proj) {
+glm_persp_aspect_lh_zo(CGLM_IN(mat4) proj) {
   return glm_persp_aspect(proj);
 }
 
diff --git a/include/cglm/clipspace/persp_rh_no.h b/include/cglm/clipspace/persp_rh_no.h
index 9ef719db4..6554eafa3 100644
--- a/include/cglm/clipspace/persp_rh_no.h
+++ b/include/cglm/clipspace/persp_rh_no.h
@@ -25,27 +25,27 @@
    CGLM_INLINE void glm_perspective_resize_rh_no(float aspect, mat4 proj)
    CGLM_INLINE void glm_persp_move_far_rh_no(mat4 proj,
                                              float deltaFar)
-   CGLM_INLINE void glm_persp_decomp_rh_no(mat4 proj,
+   CGLM_INLINE void glm_persp_decomp_rh_no(CGLM_IN(mat4) proj,
                                            float * __restrict nearZ,
                                            float * __restrict farZ,
                                            float * __restrict top,
                                            float * __restrict bottom,
                                            float * __restrict left,
                                            float * __restrict right)
-  CGLM_INLINE void glm_persp_decompv_rh_no(mat4 proj,
+  CGLM_INLINE void glm_persp_decompv_rh_no(CGLM_IN(mat4) proj,
                                            float dest[6])
-  CGLM_INLINE void glm_persp_decomp_x_rh_no(mat4 proj,
+  CGLM_INLINE void glm_persp_decomp_x_rh_no(CGLM_IN(mat4) proj,
                                             float * __restrict left,
                                             float * __restrict right)
-  CGLM_INLINE void glm_persp_decomp_y_rh_no(mat4 proj,
+  CGLM_INLINE void glm_persp_decomp_y_rh_no(CGLM_IN(mat4) proj,
                                             float * __restrict top,
                                             float * __restrict bottom)
-  CGLM_INLINE void glm_persp_decomp_z_rh_no(mat4 proj,
+  CGLM_INLINE void glm_persp_decomp_z_rh_no(CGLM_IN(mat4) proj,
                                             float * __restrict nearZ,
                                             float * __restrict farZ)
-  CGLM_INLINE void glm_persp_decomp_far_rh_no(mat4 proj, float * __restrict farZ)
-  CGLM_INLINE void glm_persp_decomp_near_rh_no(mat4 proj, float * __restrict nearZ)
-  CGLM_INLINE void glm_persp_sizes_rh_no(mat4 proj, float fovy, vec4 dest)
+  CGLM_INLINE void glm_persp_decomp_far_rh_no(CGLM_IN(mat4) proj, float * __restrict farZ)
+  CGLM_INLINE void glm_persp_decomp_near_rh_no(CGLM_IN(mat4) proj, float * __restrict nearZ)
+  CGLM_INLINE void glm_persp_sizes_rh_no(CGLM_IN(mat4) proj, float fovy, vec4 dest)
  */
 
 #ifndef cglm_persp_rh_no_h
@@ -239,7 +239,7 @@ glm_persp_move_far_rh_no(mat4 proj, float deltaFar) {
  */
 CGLM_INLINE
 void
-glm_persp_decomp_rh_no(mat4 proj,
+glm_persp_decomp_rh_no(CGLM_IN(mat4) proj,
                        float * __restrict nearZ, float * __restrict farZ,
                        float * __restrict top,     float * __restrict bottom,
                        float * __restrict left,    float * __restrict right) {
@@ -278,7 +278,7 @@ glm_persp_decomp_rh_no(mat4 proj,
  */
 CGLM_INLINE
 void
-glm_persp_decompv_rh_no(mat4 proj, float dest[6]) {
+glm_persp_decompv_rh_no(CGLM_IN(mat4) proj, float dest[6]) {
   glm_persp_decomp_rh_no(proj, &dest[0], &dest[1], &dest[2],
                                &dest[3], &dest[4], &dest[5]);
 }
@@ -295,7 +295,7 @@ glm_persp_decompv_rh_no(mat4 proj, float dest[6]) {
  */
 CGLM_INLINE
 void
-glm_persp_decomp_x_rh_no(mat4 proj,
+glm_persp_decomp_x_rh_no(CGLM_IN(mat4) proj,
                          float * __restrict left,
                          float * __restrict right) {
   float nearZ, m20, m00, m22;
@@ -321,7 +321,7 @@ glm_persp_decomp_x_rh_no(mat4 proj,
  */
 CGLM_INLINE
 void
-glm_persp_decomp_y_rh_no(mat4 proj,
+glm_persp_decomp_y_rh_no(CGLM_IN(mat4) proj,
                          float * __restrict top,
                          float * __restrict bottom) {
   float nearZ, m21, m11, m22;
@@ -347,9 +347,9 @@ glm_persp_decomp_y_rh_no(mat4 proj,
  */
 CGLM_INLINE
 void
-glm_persp_decomp_z_rh_no(mat4 proj,
-                      float * __restrict nearZ,
-                      float * __restrict farZ) {
+glm_persp_decomp_z_rh_no(CGLM_IN(mat4) proj,
+                         float * __restrict nearZ,
+                         float * __restrict farZ) {
   float m32, m22;
 
   m32 = proj[3][2];
@@ -369,7 +369,7 @@ glm_persp_decomp_z_rh_no(mat4 proj,
  */
 CGLM_INLINE
 void
-glm_persp_decomp_far_rh_no(mat4 proj, float * __restrict farZ) {
+glm_persp_decomp_far_rh_no(CGLM_IN(mat4) proj, float * __restrict farZ) {
   *farZ = proj[3][2] / (proj[2][2] + 1.0f);
 }
 
@@ -383,7 +383,7 @@ glm_persp_decomp_far_rh_no(mat4 proj, float * __restrict farZ) {
  */
 CGLM_INLINE
 void
-glm_persp_decomp_near_rh_no(mat4 proj, float * __restrict nearZ) {
+glm_persp_decomp_near_rh_no(CGLM_IN(mat4) proj, float * __restrict nearZ) {
   *nearZ = proj[3][2] / (proj[2][2] - 1.0f);
 }
 
@@ -398,7 +398,7 @@ glm_persp_decomp_near_rh_no(mat4 proj, float * __restrict nearZ) {
  */
 CGLM_INLINE
 void
-glm_persp_sizes_rh_no(mat4 proj, float fovy, vec4 dest) {
+glm_persp_sizes_rh_no(CGLM_IN(mat4) proj, float fovy, vec4 dest) {
   float t, a, nearZ, farZ;
 
   t = 2.0f * tanf(fovy * 0.5f);
@@ -423,7 +423,7 @@ glm_persp_sizes_rh_no(mat4 proj, float fovy, vec4 dest) {
  */
 CGLM_INLINE
 float
-glm_persp_fovy_rh_no(mat4 proj) {
+glm_persp_fovy_rh_no(CGLM_IN(mat4) proj) {
   return glm_persp_fovy(proj);
 }
 
@@ -435,7 +435,7 @@ glm_persp_fovy_rh_no(mat4 proj) {
  */
 CGLM_INLINE
 float
-glm_persp_aspect_rh_no(mat4 proj) {
+glm_persp_aspect_rh_no(CGLM_IN(mat4) proj) {
   return glm_persp_aspect(proj);
 }
 
diff --git a/include/cglm/clipspace/persp_rh_zo.h b/include/cglm/clipspace/persp_rh_zo.h
index 7aaabab44..0a935e0df 100644
--- a/include/cglm/clipspace/persp_rh_zo.h
+++ b/include/cglm/clipspace/persp_rh_zo.h
@@ -25,27 +25,27 @@
    CGLM_INLINE void glm_perspective_resize_rh_zo(float aspect, mat4 proj)
    CGLM_INLINE void glm_persp_move_far_rh_zo(mat4 proj,
                                              float deltaFar)
-   CGLM_INLINE void glm_persp_decomp_rh_zo(mat4 proj,
+   CGLM_INLINE void glm_persp_decomp_rh_zo(CGLM_IN(mat4) proj,
                                            float * __restrict nearZ,
                                            float * __restrict farZ,
                                            float * __restrict top,
                                            float * __restrict bottom,
                                            float * __restrict left,
                                            float * __restrict right)
-  CGLM_INLINE void glm_persp_decompv_rh_zo(mat4 proj,
+  CGLM_INLINE void glm_persp_decompv_rh_zo(CGLM_IN(mat4) proj,
                                            float dest[6])
-  CGLM_INLINE void glm_persp_decomp_x_rh_zo(mat4 proj,
+  CGLM_INLINE void glm_persp_decomp_x_rh_zo(CGLM_IN(mat4) proj,
                                             float * __restrict left,
                                             float * __restrict right)
-  CGLM_INLINE void glm_persp_decomp_y_rh_zo(mat4 proj,
+  CGLM_INLINE void glm_persp_decomp_y_rh_zo(CGLM_IN(mat4) proj,
                                             float * __restrict top,
                                             float * __restrict bottom)
-  CGLM_INLINE void glm_persp_decomp_z_rh_zo(mat4 proj,
+  CGLM_INLINE void glm_persp_decomp_z_rh_zo(CGLM_IN(mat4) proj,
                                             float * __restrict nearZ,
                                             float * __restrict farZ)
-  CGLM_INLINE void glm_persp_decomp_far_rh_zo(mat4 proj, float * __restrict farZ)
-  CGLM_INLINE void glm_persp_decomp_near_rh_zo(mat4 proj, float * __restrict nearZ)
-  CGLM_INLINE void glm_persp_sizes_rh_zo(mat4 proj, float fovy, vec4 dest)
+  CGLM_INLINE void glm_persp_decomp_far_rh_zo(CGLM_IN(mat4) proj, float * __restrict farZ)
+  CGLM_INLINE void glm_persp_decomp_near_rh_zo(CGLM_IN(mat4) proj, float * __restrict nearZ)
+  CGLM_INLINE void glm_persp_sizes_rh_zo(CGLM_IN(mat4) proj, float fovy, vec4 dest)
  */
 
 #ifndef cglm_persp_rh_zo_h
@@ -223,7 +223,7 @@ glm_persp_move_far_rh_zo(mat4 proj, float deltaFar) {
 
 /*!
  * @brief decomposes frustum values of perspective projection
- *        with angle values with a right-hand coordinate system and a 
+ *        with angle values with a right-hand coordinate system and a
  *        clip-space of [0, 1].
  *
  * @param[in]  proj    perspective projection matrix
@@ -236,7 +236,7 @@ glm_persp_move_far_rh_zo(mat4 proj, float deltaFar) {
  */
 CGLM_INLINE
 void
-glm_persp_decomp_rh_zo(mat4 proj,
+glm_persp_decomp_rh_zo(CGLM_IN(mat4) proj,
                     float * __restrict nearZ, float * __restrict farZ,
                     float * __restrict top,     float * __restrict bottom,
                     float * __restrict left,    float * __restrict right) {
@@ -266,7 +266,7 @@ glm_persp_decomp_rh_zo(mat4 proj,
 
 /*!
  * @brief decomposes frustum values of perspective projection
- *        with angle values with a right-hand coordinate system and a 
+ *        with angle values with a right-hand coordinate system and a
  *        clip-space of [0, 1].
  *        this makes easy to get all values at once
  *
@@ -275,7 +275,7 @@ glm_persp_decomp_rh_zo(mat4 proj,
  */
 CGLM_INLINE
 void
-glm_persp_decompv_rh_zo(mat4 proj, float dest[6]) {
+glm_persp_decompv_rh_zo(CGLM_IN(mat4) proj, float dest[6]) {
   glm_persp_decomp_rh_zo(proj, &dest[0], &dest[1], &dest[2],
                                &dest[3], &dest[4], &dest[5]);
 }
@@ -290,7 +290,7 @@ glm_persp_decompv_rh_zo(mat4 proj, float dest[6]) {
  */
 CGLM_INLINE
 void
-glm_persp_decomp_x_rh_zo(mat4 proj,
+glm_persp_decomp_x_rh_zo(CGLM_IN(mat4) proj,
                          float * __restrict left,
                          float * __restrict right) {
   float nearZ, m20, m00, m22;
@@ -306,7 +306,7 @@ glm_persp_decomp_x_rh_zo(mat4 proj,
 
 /*!
  * @brief decomposes top and bottom values of perspective projection
- *        with angle values with a right-hand coordinate system and a 
+ *        with angle values with a right-hand coordinate system and a
  *        clip-space of [0, 1].
  *        y stands for y axis (top / bottom axis)
  *
@@ -316,7 +316,7 @@ glm_persp_decomp_x_rh_zo(mat4 proj,
  */
 CGLM_INLINE
 void
-glm_persp_decomp_y_rh_zo(mat4 proj,
+glm_persp_decomp_y_rh_zo(CGLM_IN(mat4) proj,
                          float * __restrict top,
                          float * __restrict bottom) {
   float nearZ, m21, m11, m22;
@@ -332,7 +332,7 @@ glm_persp_decomp_y_rh_zo(mat4 proj,
 
 /*!
  * @brief decomposes near and far values of perspective projection
- *        with angle values with a right-hand coordinate system and a 
+ *        with angle values with a right-hand coordinate system and a
  *        clip-space of [0, 1].
  *        z stands for z axis (near / far axis)
  *
@@ -342,7 +342,7 @@ glm_persp_decomp_y_rh_zo(mat4 proj,
  */
 CGLM_INLINE
 void
-glm_persp_decomp_z_rh_zo(mat4 proj,
+glm_persp_decomp_z_rh_zo(CGLM_IN(mat4) proj,
                          float * __restrict nearZ,
                          float * __restrict farZ) {
   float m32, m22;
@@ -356,7 +356,7 @@ glm_persp_decomp_z_rh_zo(mat4 proj,
 
 /*!
  * @brief decomposes far value of perspective projection
- *        with angle values with a right-hand coordinate system and a 
+ *        with angle values with a right-hand coordinate system and a
  *        clip-space of [0, 1].
  *
  * @param[in]  proj   perspective projection matrix
@@ -364,13 +364,13 @@ glm_persp_decomp_z_rh_zo(mat4 proj,
  */
 CGLM_INLINE
 void
-glm_persp_decomp_far_rh_zo(mat4 proj, float * __restrict farZ) {
+glm_persp_decomp_far_rh_zo(CGLM_IN(mat4) proj, float * __restrict farZ) {
   *farZ = proj[3][2] / (proj[2][2] + 1.0f);
 }
 
 /*!
  * @brief decomposes near value of perspective projection
- *        with angle values with a right-hand coordinate system and a 
+ *        with angle values with a right-hand coordinate system and a
  *        clip-space of [0, 1].
  *
  * @param[in]  proj    perspective projection matrix
@@ -378,7 +378,7 @@ glm_persp_decomp_far_rh_zo(mat4 proj, float * __restrict farZ) {
  */
 CGLM_INLINE
 void
-glm_persp_decomp_near_rh_zo(mat4 proj, float * __restrict nearZ) {
+glm_persp_decomp_near_rh_zo(CGLM_IN(mat4) proj, float * __restrict nearZ) {
   *nearZ = proj[3][2] / proj[2][2];
 }
 
@@ -393,7 +393,7 @@ glm_persp_decomp_near_rh_zo(mat4 proj, float * __restrict nearZ) {
  */
 CGLM_INLINE
 void
-glm_persp_sizes_rh_zo(mat4 proj, float fovy, vec4 dest) {
+glm_persp_sizes_rh_zo(CGLM_IN(mat4) proj, float fovy, vec4 dest) {
   float t, a, nearZ, farZ;
 
   t = 2.0f * tanf(fovy * 0.5f);
@@ -418,7 +418,7 @@ glm_persp_sizes_rh_zo(mat4 proj, float fovy, vec4 dest) {
  */
 CGLM_INLINE
 float
-glm_persp_fovy_rh_zo(mat4 proj) {
+glm_persp_fovy_rh_zo(CGLM_IN(mat4) proj) {
   return glm_persp_fovy(proj);
 }
 
@@ -430,7 +430,7 @@ glm_persp_fovy_rh_zo(mat4 proj) {
  */
 CGLM_INLINE
 float
-glm_persp_aspect_rh_zo(mat4 proj) {
+glm_persp_aspect_rh_zo(CGLM_IN(mat4) proj) {
   return glm_persp_aspect(proj);
 }
 
diff --git a/include/cglm/clipspace/project_no.h b/include/cglm/clipspace/project_no.h
index 71fbc5248..3c7df3dd2 100644
--- a/include/cglm/clipspace/project_no.h
+++ b/include/cglm/clipspace/project_no.h
@@ -41,7 +41,7 @@
  */
 CGLM_INLINE
 void
-glm_unprojecti_no(vec3 pos, mat4 invMat, vec4 vp, vec3 dest) {
+glm_unprojecti_no(const vec3 pos, CGLM_IN(mat4) invMat, const vec4 vp, vec3 dest) {
   vec4 v;
 
   v[0] = 2.0f * (pos[0] - vp[0]) / vp[2] - 1.0f;
@@ -68,7 +68,7 @@ glm_unprojecti_no(vec3 pos, mat4 invMat, vec4 vp, vec3 dest) {
  */
 CGLM_INLINE
 void
-glm_project_no(vec3 pos, mat4 m, vec4 vp, vec3 dest) {
+glm_project_no(const vec3 pos, CGLM_IN(mat4) m, const vec4 vp, vec3 dest) {
   CGLM_ALIGN(16) vec4 pos4;
 
   glm_vec4(pos, 1.0f, pos4);
@@ -97,7 +97,7 @@ glm_project_no(vec3 pos, mat4 m, vec4 vp, vec3 dest) {
  */
 CGLM_INLINE
 float
-glm_project_z_no(vec3 v, mat4 m) {
+glm_project_z_no(const vec3 v, CGLM_IN(mat4) m) {
   float z, w;
 
   z = m[0][2] * v[0] + m[1][2] * v[1] + m[2][2] * v[2] + m[3][2];
diff --git a/include/cglm/clipspace/project_zo.h b/include/cglm/clipspace/project_zo.h
index dc320782c..be14d7b25 100644
--- a/include/cglm/clipspace/project_zo.h
+++ b/include/cglm/clipspace/project_zo.h
@@ -41,7 +41,7 @@
  */
 CGLM_INLINE
 void
-glm_unprojecti_zo(vec3 pos, mat4 invMat, vec4 vp, vec3 dest) {
+glm_unprojecti_zo(const vec3 pos, CGLM_IN(mat4) invMat, const vec4 vp, vec3 dest) {
   vec4 v;
 
   v[0] = 2.0f * (pos[0] - vp[0]) / vp[2] - 1.0f;
@@ -68,7 +68,7 @@ glm_unprojecti_zo(vec3 pos, mat4 invMat, vec4 vp, vec3 dest) {
  */
 CGLM_INLINE
 void
-glm_project_zo(vec3 pos, mat4 m, vec4 vp, vec3 dest) {
+glm_project_zo(const vec3 pos, CGLM_IN(mat4) m, const vec4 vp, vec3 dest) {
   CGLM_ALIGN(16) vec4 pos4;
 
   glm_vec4(pos, 1.0f, pos4);
@@ -77,7 +77,7 @@ glm_project_zo(vec3 pos, mat4 m, vec4 vp, vec3 dest) {
   glm_vec4_scale(pos4, 1.0f / pos4[3], pos4); /* pos = pos / pos.w */
 
   dest[2] = pos4[2];
-  
+
   glm_vec4_scale(pos4, 0.5f, pos4);
   glm_vec4_adds(pos4,  0.5f, pos4);
 
@@ -99,7 +99,7 @@ glm_project_zo(vec3 pos, mat4 m, vec4 vp, vec3 dest) {
  */
 CGLM_INLINE
 float
-glm_project_z_zo(vec3 v, mat4 m) {
+glm_project_z_zo(const vec3 v, CGLM_IN(mat4) m) {
   float z, w;
 
   z = m[0][2] * v[0] + m[1][2] * v[1] + m[2][2] * v[2] + m[3][2];
diff --git a/include/cglm/clipspace/view_lh.h b/include/cglm/clipspace/view_lh.h
index 56676946a..4cf4b8334 100644
--- a/include/cglm/clipspace/view_lh.h
+++ b/include/cglm/clipspace/view_lh.h
@@ -7,9 +7,9 @@
 
 /*
  Functions:
-   CGLM_INLINE void glm_lookat_lh(vec3 eye, vec3 center, vec3 up, mat4 dest)
-   CGLM_INLINE void glm_look_lh(vec3 eye, vec3 dir, vec3 up, mat4 dest)
-   CGLM_INLINE void glm_look_anyup_lh(vec3 eye, vec3 dir, mat4 dest)
+   CGLM_INLINE void glm_lookat_lh(const vec3 eye, const vec3 center, const vec3 up, mat4 dest)
+   CGLM_INLINE void glm_look_lh(const vec3 eye, const vec3 dir, const vec3 up, mat4 dest)
+   CGLM_INLINE void glm_look_anyup_lh(const vec3 eye, const vec3 dir, mat4 dest)
  */
 
 #ifndef cglm_view_lh_h
@@ -31,7 +31,7 @@
  */
 CGLM_INLINE
 void
-glm_lookat_lh(vec3 eye, vec3 center, vec3 up, mat4 dest) {
+glm_lookat_lh(const vec3 eye, const vec3 center, const vec3 up, mat4 dest) {
   CGLM_ALIGN(8) vec3 f, u, s;
 
   glm_vec3_sub(center, eye, f);
@@ -72,7 +72,7 @@ glm_lookat_lh(vec3 eye, vec3 center, vec3 up, mat4 dest) {
  */
 CGLM_INLINE
 void
-glm_look_lh(vec3 eye, vec3 dir, vec3 up, mat4 dest) {
+glm_look_lh(const vec3 eye, const vec3 dir, const vec3 up, mat4 dest) {
   CGLM_ALIGN(8) vec3 target;
   glm_vec3_add(eye, dir, target);
   glm_lookat_lh(eye, target, up, dest);
@@ -90,7 +90,7 @@ glm_look_lh(vec3 eye, vec3 dir, vec3 up, mat4 dest) {
  */
 CGLM_INLINE
 void
-glm_look_anyup_lh(vec3 eye, vec3 dir, mat4 dest) {
+glm_look_anyup_lh(const vec3 eye, const vec3 dir, mat4 dest) {
   CGLM_ALIGN(8) vec3 up;
   glm_vec3_ortho(dir, up);
   glm_look_lh(eye, dir, up, dest);
diff --git a/include/cglm/clipspace/view_lh_no.h b/include/cglm/clipspace/view_lh_no.h
index 454d9034f..092b11d6c 100644
--- a/include/cglm/clipspace/view_lh_no.h
+++ b/include/cglm/clipspace/view_lh_no.h
@@ -7,9 +7,9 @@
 
 /*
  Functions:
-   CGLM_INLINE void glm_lookat_lh_no(vec3 eye, vec3 center, vec3 up, mat4 dest)
-   CGLM_INLINE void glm_look_lh_no(vec3 eye, vec3 dir, vec3 up, mat4 dest)
-   CGLM_INLINE void glm_look_anyup_lh_no(vec3 eye, vec3 dir, mat4 dest)
+   CGLM_INLINE void glm_lookat_lh_no(const vec3 eye, const vec3 center, const vec3 up, mat4 dest)
+   CGLM_INLINE void glm_look_lh_no(const vec3 eye, const vec3 dir, const vec3 up, mat4 dest)
+   CGLM_INLINE void glm_look_anyup_lh_no(const vec3 eye, const vec3 dir, mat4 dest)
  */
 
 #ifndef cglm_view_lh_no_h
@@ -31,7 +31,7 @@
  */
 CGLM_INLINE
 void
-glm_lookat_lh_no(vec3 eye, vec3 center, vec3 up, mat4 dest) {
+glm_lookat_lh_no(const vec3 eye, const vec3 center, const vec3 up, mat4 dest) {
   glm_lookat_lh(eye, center, up, dest);
 }
 
@@ -51,7 +51,7 @@ glm_lookat_lh_no(vec3 eye, vec3 center, vec3 up, mat4 dest) {
  */
 CGLM_INLINE
 void
-glm_look_lh_no(vec3 eye, vec3 dir, vec3 up, mat4 dest) {
+glm_look_lh_no(const vec3 eye, const vec3 dir, const vec3 up, mat4 dest) {
   glm_look_lh(eye, dir, up, dest);
 }
 
@@ -67,7 +67,7 @@ glm_look_lh_no(vec3 eye, vec3 dir, vec3 up, mat4 dest) {
  */
 CGLM_INLINE
 void
-glm_look_anyup_lh_no(vec3 eye, vec3 dir, mat4 dest) {
+glm_look_anyup_lh_no(const vec3 eye, const vec3 dir, mat4 dest) {
   glm_look_anyup_lh(eye, dir, dest);
 }
 
diff --git a/include/cglm/clipspace/view_lh_zo.h b/include/cglm/clipspace/view_lh_zo.h
index 6b0c4d1d2..c94c67206 100644
--- a/include/cglm/clipspace/view_lh_zo.h
+++ b/include/cglm/clipspace/view_lh_zo.h
@@ -7,9 +7,9 @@
 
 /*
  Functions:
-   CGLM_INLINE void glm_lookat_lh_zo(vec3 eye, vec3 center, vec3 up, mat4 dest)
-   CGLM_INLINE void glm_look_lh_zo(vec3 eye, vec3 dir, vec3 up, mat4 dest)
-   CGLM_INLINE void glm_look_anyup_lh_zo(vec3 eye, vec3 dir, mat4 dest)
+   CGLM_INLINE void glm_lookat_lh_zo(const vec3 eye, const vec3 center, const vec3 up, mat4 dest)
+   CGLM_INLINE void glm_look_lh_zo(const vec3 eye, const vec3 dir, const vec3 up, mat4 dest)
+   CGLM_INLINE void glm_look_anyup_lh_zo(const vec3 eye, const vec3 dir, mat4 dest)
  */
 
 #ifndef cglm_view_lh_zo_h
@@ -31,7 +31,7 @@
  */
 CGLM_INLINE
 void
-glm_lookat_lh_zo(vec3 eye, vec3 center, vec3 up, mat4 dest) {
+glm_lookat_lh_zo(const vec3 eye, const vec3 center, const vec3 up, mat4 dest) {
   glm_lookat_lh(eye, center, up, dest);
 }
 
@@ -51,7 +51,7 @@ glm_lookat_lh_zo(vec3 eye, vec3 center, vec3 up, mat4 dest) {
  */
 CGLM_INLINE
 void
-glm_look_lh_zo(vec3 eye, vec3 dir, vec3 up, mat4 dest) {
+glm_look_lh_zo(const vec3 eye, const vec3 dir, const vec3 up, mat4 dest) {
   glm_look_lh(eye, dir, up, dest);
 }
 
@@ -67,7 +67,7 @@ glm_look_lh_zo(vec3 eye, vec3 dir, vec3 up, mat4 dest) {
  */
 CGLM_INLINE
 void
-glm_look_anyup_lh_zo(vec3 eye, vec3 dir, mat4 dest) {
+glm_look_anyup_lh_zo(const vec3 eye, const vec3 dir, mat4 dest) {
   glm_look_anyup_lh(eye, dir, dest);
 }
 
diff --git a/include/cglm/clipspace/view_rh.h b/include/cglm/clipspace/view_rh.h
index 51ec916be..c6c05bc61 100644
--- a/include/cglm/clipspace/view_rh.h
+++ b/include/cglm/clipspace/view_rh.h
@@ -7,9 +7,9 @@
 
 /*
  Functions:
-   CGLM_INLINE void glm_lookat_rh(vec3 eye, vec3 center, vec3 up, mat4 dest)
-   CGLM_INLINE void glm_look_rh(vec3 eye, vec3 dir, vec3 up, mat4 dest)
-   CGLM_INLINE void glm_look_anyup_rh(vec3 eye, vec3 dir, mat4 dest)
+   CGLM_INLINE void glm_lookat_rh(const vec3 eye, const vec3 center, const vec3 up, mat4 dest)
+   CGLM_INLINE void glm_look_rh(const vec3 eye, const vec3 dir, const vec3 up, mat4 dest)
+   CGLM_INLINE void glm_look_anyup_rh(const vec3 eye, const vec3 dir, mat4 dest)
  */
 
 #ifndef cglm_view_rh_h
@@ -31,7 +31,7 @@
  */
 CGLM_INLINE
 void
-glm_lookat_rh(vec3 eye, vec3 center, vec3 up, mat4 dest) {
+glm_lookat_rh(const vec3 eye, const vec3 center, const vec3 up, mat4 dest) {
   CGLM_ALIGN(8) vec3 f, u, s;
 
   glm_vec3_sub(center, eye, f);
@@ -72,7 +72,7 @@ glm_lookat_rh(vec3 eye, vec3 center, vec3 up, mat4 dest) {
  */
 CGLM_INLINE
 void
-glm_look_rh(vec3 eye, vec3 dir, vec3 up, mat4 dest) {
+glm_look_rh(const vec3 eye, const vec3 dir, const vec3 up, mat4 dest) {
   CGLM_ALIGN(8) vec3 target;
   glm_vec3_add(eye, dir, target);
   glm_lookat_rh(eye, target, up, dest);
@@ -90,7 +90,7 @@ glm_look_rh(vec3 eye, vec3 dir, vec3 up, mat4 dest) {
  */
 CGLM_INLINE
 void
-glm_look_anyup_rh(vec3 eye, vec3 dir, mat4 dest) {
+glm_look_anyup_rh(const vec3 eye, const vec3 dir, mat4 dest) {
   CGLM_ALIGN(8) vec3 up;
   glm_vec3_ortho(dir, up);
   glm_look_rh(eye, dir, up, dest);
diff --git a/include/cglm/clipspace/view_rh_no.h b/include/cglm/clipspace/view_rh_no.h
index ca36d302f..9ce6b53dc 100644
--- a/include/cglm/clipspace/view_rh_no.h
+++ b/include/cglm/clipspace/view_rh_no.h
@@ -7,9 +7,9 @@
 
 /*
  Functions:
-   CGLM_INLINE void glm_lookat_rh_no(vec3 eye, vec3 center, vec3 up, mat4 dest)
-   CGLM_INLINE void glm_look_rh_no(vec3 eye, vec3 dir, vec3 up, mat4 dest)
-   CGLM_INLINE void glm_look_anyup_rh_no(vec3 eye, vec3 dir, mat4 dest)
+   CGLM_INLINE void glm_lookat_rh_no(const vec3 eye, const vec3 center, const vec3 up, mat4 dest)
+   CGLM_INLINE void glm_look_rh_no(const vec3 eye, const vec3 dir, const vec3 up, mat4 dest)
+   CGLM_INLINE void glm_look_anyup_rh_no(const vec3 eye, const vec3 dir, mat4 dest)
  */
 
 #ifndef cglm_view_rh_no_h
@@ -31,7 +31,7 @@
  */
 CGLM_INLINE
 void
-glm_lookat_rh_no(vec3 eye, vec3 center, vec3 up, mat4 dest) {
+glm_lookat_rh_no(const vec3 eye, const vec3 center, const vec3 up, mat4 dest) {
   glm_lookat_rh(eye, center, up, dest);
 }
 
@@ -51,7 +51,7 @@ glm_lookat_rh_no(vec3 eye, vec3 center, vec3 up, mat4 dest) {
  */
 CGLM_INLINE
 void
-glm_look_rh_no(vec3 eye, vec3 dir, vec3 up, mat4 dest) {
+glm_look_rh_no(const vec3 eye, const vec3 dir, const vec3 up, mat4 dest) {
   glm_look_rh(eye, dir, up, dest);
 }
 
@@ -67,7 +67,7 @@ glm_look_rh_no(vec3 eye, vec3 dir, vec3 up, mat4 dest) {
  */
 CGLM_INLINE
 void
-glm_look_anyup_rh_no(vec3 eye, vec3 dir, mat4 dest) {
+glm_look_anyup_rh_no(const vec3 eye, const vec3 dir, mat4 dest) {
   glm_look_anyup_rh(eye, dir, dest);
 }
 
diff --git a/include/cglm/clipspace/view_rh_zo.h b/include/cglm/clipspace/view_rh_zo.h
index 1ad5c91bd..3c94d6f03 100644
--- a/include/cglm/clipspace/view_rh_zo.h
+++ b/include/cglm/clipspace/view_rh_zo.h
@@ -7,9 +7,9 @@
 
 /*
  Functions:
-   CGLM_INLINE void glm_lookat_rh_zo(vec3 eye, vec3 center, vec3 up, mat4 dest)
-   CGLM_INLINE void glm_look_rh_zo(vec3 eye, vec3 dir, vec3 up, mat4 dest)
-   CGLM_INLINE void glm_look_anyup_rh_zo(vec3 eye, vec3 dir, mat4 dest)
+   CGLM_INLINE void glm_lookat_rh_zo(const vec3 eye, const vec3 center, const vec3 up, mat4 dest)
+   CGLM_INLINE void glm_look_rh_zo(const vec3 eye, const vec3 dir, const vec3 up, mat4 dest)
+   CGLM_INLINE void glm_look_anyup_rh_zo(const vec3 eye, const vec3 dir, mat4 dest)
  */
 
 #ifndef cglm_view_rh_zo_h
@@ -31,7 +31,7 @@
  */
 CGLM_INLINE
 void
-glm_lookat_rh_zo(vec3 eye, vec3 center, vec3 up, mat4 dest) {
+glm_lookat_rh_zo(const vec3 eye, const vec3 center, const vec3 up, mat4 dest) {
   glm_lookat_rh(eye, center, up, dest);
 }
 
@@ -51,7 +51,7 @@ glm_lookat_rh_zo(vec3 eye, vec3 center, vec3 up, mat4 dest) {
  */
 CGLM_INLINE
 void
-glm_look_rh_zo(vec3 eye, vec3 dir, vec3 up, mat4 dest) {
+glm_look_rh_zo(const vec3 eye, const vec3 dir, const vec3 up, mat4 dest) {
   glm_look_rh(eye, dir, up, dest);
 }
 
@@ -67,7 +67,7 @@ glm_look_rh_zo(vec3 eye, vec3 dir, vec3 up, mat4 dest) {
  */
 CGLM_INLINE
 void
-glm_look_anyup_rh_zo(vec3 eye, vec3 dir, mat4 dest) {
+glm_look_anyup_rh_zo(const vec3 eye, const vec3 dir, mat4 dest) {
   glm_look_anyup_rh(eye, dir, dest);
 }
 
diff --git a/include/cglm/color.h b/include/cglm/color.h
index 69566ad2e..27d77b84f 100644
--- a/include/cglm/color.h
+++ b/include/cglm/color.h
@@ -18,7 +18,7 @@
  */
 CGLM_INLINE
 float
-glm_luminance(vec3 rgb) {
+glm_luminance(const vec3 rgb) {
   vec3 l = {0.212671f, 0.715160f, 0.072169f};
   return glm_dot(rgb, l);
 }
diff --git a/include/cglm/common.h b/include/cglm/common.h
index 1af754d39..4405e7a18 100644
--- a/include/cglm/common.h
+++ b/include/cglm/common.h
@@ -47,6 +47,14 @@
 #  define CGLM_LIKELY(expr)   (expr)
 #endif
 
+/* @tooold2rock-n-roll - issue #83 */
+/* it should be [__STDC_VERSION__ >= 202311L] for C23, but the current value seam to be the correct one. */
+#if defined(__STDC_VERSION__) && __STDC_VERSION__ >= 202000L
+#  define CGLM_IN(T) const T
+#else
+#  define CGLM_IN(T) T
+#endif
+
 #if defined(_M_FP_FAST) || defined(__FAST_MATH__)
 #  define CGLM_FAST_MATH
 #endif
diff --git a/include/cglm/curve.h b/include/cglm/curve.h
index 5033be500..eea73477b 100644
--- a/include/cglm/curve.h
+++ b/include/cglm/curve.h
@@ -31,7 +31,7 @@
  */
 CGLM_INLINE
 float
-glm_smc(float s, mat4 m, vec4 c) {
+glm_smc(float s, CGLM_IN(mat4) m, const vec4 c) {
   vec4 vs;
   glm_vec4_cubic(s, vs);
   return glm_mat4_rmc(vs, m, c);
diff --git a/include/cglm/euler.h b/include/cglm/euler.h
index 805fd7c5a..5a6e17033 100644
--- a/include/cglm/euler.h
+++ b/include/cglm/euler.h
@@ -19,23 +19,23 @@
 
  Functions:
    CGLM_INLINE glm_euler_seq glm_euler_order(int newOrder[3]);
-   CGLM_INLINE void glm_euler_angles(mat4 m, vec3 dest);
-   CGLM_INLINE void glm_euler(vec3 angles, mat4 dest);
-   CGLM_INLINE void glm_euler_xyz(vec3 angles, mat4 dest);
-   CGLM_INLINE void glm_euler_zyx(vec3 angles, mat4 dest);
-   CGLM_INLINE void glm_euler_zxy(vec3 angles, mat4 dest);
-   CGLM_INLINE void glm_euler_xzy(vec3 angles, mat4 dest);
-   CGLM_INLINE void glm_euler_yzx(vec3 angles, mat4 dest);
-   CGLM_INLINE void glm_euler_yxz(vec3 angles, mat4 dest);
+   CGLM_INLINE void glm_euler_angles(CGLM_IN(mat4) m, vec3 dest);
+   CGLM_INLINE void glm_euler(const vec3 angles, mat4 dest);
+   CGLM_INLINE void glm_euler_xyz(const vec3 angles, mat4 dest);
+   CGLM_INLINE void glm_euler_zyx(const vec3 angles, mat4 dest);
+   CGLM_INLINE void glm_euler_zxy(const vec3 angles, mat4 dest);
+   CGLM_INLINE void glm_euler_xzy(const vec3 angles, mat4 dest);
+   CGLM_INLINE void glm_euler_yzx(const vec3 angles, mat4 dest);
+   CGLM_INLINE void glm_euler_yxz(const vec3 angles, mat4 dest);
    CGLM_INLINE void glm_euler_by_order(vec3         angles,
                                        glm_euler_seq ord,
                                        mat4         dest);
-   CGLM_INLINE void glm_euler_xyz_quat(vec3 angles, versor dest);
-   CGLM_INLINE void glm_euler_xzy_quat(vec3 angles, versor dest);
-   CGLM_INLINE void glm_euler_yxz_quat(vec3 angles, versor dest);
-   CGLM_INLINE void glm_euler_yzx_quat(vec3 angles, versor dest);
-   CGLM_INLINE void glm_euler_zxy_quat(vec3 angles, versor dest);
-   CGLM_INLINE void glm_euler_zyx_quat(vec3 angles, versor dest);
+   CGLM_INLINE void glm_euler_xyz_quat(const vec3 angles, versor dest);
+   CGLM_INLINE void glm_euler_xzy_quat(const vec3 angles, versor dest);
+   CGLM_INLINE void glm_euler_yxz_quat(const vec3 angles, versor dest);
+   CGLM_INLINE void glm_euler_yzx_quat(const vec3 angles, versor dest);
+   CGLM_INLINE void glm_euler_zxy_quat(const vec3 angles, versor dest);
+   CGLM_INLINE void glm_euler_zyx_quat(const vec3 angles, versor dest);
  */
 
 #ifndef cglm_euler_h
@@ -97,7 +97,7 @@ glm_euler_order(int ord[3]) {
  */
 CGLM_INLINE
 void
-glm_euler_angles(mat4 m, vec3 dest) {
+glm_euler_angles(CGLM_IN(mat4) m, vec3 dest) {
   float m00, m01, m10, m11, m20, m21, m22;
   float thetaX, thetaY, thetaZ;
 
@@ -135,7 +135,7 @@ glm_euler_angles(mat4 m, vec3 dest) {
  */
 CGLM_INLINE
 void
-glm_euler_xyz(vec3 angles, mat4 dest) {
+glm_euler_xyz(const vec3 angles, mat4 dest) {
   float cx, cy, cz,
         sx, sy, sz, czsx, cxcz, sysz;
 
@@ -173,7 +173,7 @@ glm_euler_xyz(vec3 angles, mat4 dest) {
  */
 CGLM_INLINE
 void
-glm_euler(vec3 angles, mat4 dest) {
+glm_euler(const vec3 angles, mat4 dest) {
   glm_euler_xyz(angles, dest);
 }
 
@@ -185,7 +185,7 @@ glm_euler(vec3 angles, mat4 dest) {
  */
 CGLM_INLINE
 void
-glm_euler_xzy(vec3 angles, mat4 dest) {
+glm_euler_xzy(const vec3 angles, mat4 dest) {
   float cx, cy, cz,
   sx, sy, sz, sxsy, cysx, cxsy, cxcy;
 
@@ -224,7 +224,7 @@ glm_euler_xzy(vec3 angles, mat4 dest) {
  */
 CGLM_INLINE
 void
-glm_euler_yxz(vec3 angles, mat4 dest) {
+glm_euler_yxz(const vec3 angles, mat4 dest) {
   float cx, cy, cz,
         sx, sy, sz, cycz, sysz, czsy, cysz;
 
@@ -263,7 +263,7 @@ glm_euler_yxz(vec3 angles, mat4 dest) {
  */
 CGLM_INLINE
 void
-glm_euler_yzx(vec3 angles, mat4 dest) {
+glm_euler_yzx(const vec3 angles, mat4 dest) {
   float cx, cy, cz,
         sx, sy, sz, sxsy, cxcy, cysx, cxsy;
 
@@ -302,7 +302,7 @@ glm_euler_yzx(vec3 angles, mat4 dest) {
  */
 CGLM_INLINE
 void
-glm_euler_zxy(vec3 angles, mat4 dest) {
+glm_euler_zxy(const vec3 angles, mat4 dest) {
   float cx, cy, cz,
         sx, sy, sz, cycz, sxsy, cysz;
 
@@ -340,7 +340,7 @@ glm_euler_zxy(vec3 angles, mat4 dest) {
  */
 CGLM_INLINE
 void
-glm_euler_zyx(vec3 angles, mat4 dest) {
+glm_euler_zyx(const vec3 angles, mat4 dest) {
   float cx, cy, cz,
         sx, sy, sz, czsx, cxcz, sysz;
 
@@ -379,7 +379,7 @@ glm_euler_zyx(vec3 angles, mat4 dest) {
  */
 CGLM_INLINE
 void
-glm_euler_by_order(vec3 angles, glm_euler_seq ord, mat4 dest) {
+glm_euler_by_order(const vec3 angles, glm_euler_seq ord, mat4 dest) {
   float cx, cy, cz,
         sx, sy, sz;
 
@@ -479,13 +479,13 @@ glm_euler_by_order(vec3 angles, glm_euler_seq ord, mat4 dest) {
 /*!
  * @brief creates NEW quaternion using rotation angles and does
  *        rotations in x y z order (roll pitch yaw)
- * 
+ *
  * @param[in]   angles angles x y z (radians)
  * @param[out]  dest   quaternion
  */
 CGLM_INLINE
 void
-glm_euler_xyz_quat(vec3 angles, versor dest) {
+glm_euler_xyz_quat(const vec3 angles, versor dest) {
 #ifdef CGLM_FORCE_LEFT_HANDED
   glm_euler_xyz_quat_lh(angles, dest);
 #else
@@ -496,13 +496,13 @@ glm_euler_xyz_quat(vec3 angles, versor dest) {
 /*!
  * @brief creates NEW quaternion using rotation angles and does
  *        rotations in x z y order (roll yaw pitch)
- * 
+ *
  * @param[in]   angles angles x y z (radians)
  * @param[out]  dest   quaternion
  */
 CGLM_INLINE
 void
-glm_euler_xzy_quat(vec3 angles, versor dest) {
+glm_euler_xzy_quat(const vec3 angles, versor dest) {
 #ifdef CGLM_FORCE_LEFT_HANDED
   glm_euler_xzy_quat_lh(angles, dest);
 #else
@@ -513,13 +513,13 @@ glm_euler_xzy_quat(vec3 angles, versor dest) {
 /*!
  * @brief creates NEW quaternion using rotation angles and does
  *        rotations in y x z order (pitch roll yaw)
- * 
+ *
  * @param[in]   angles angles x y z (radians)
  * @param[out]  dest   quaternion
  */
 CGLM_INLINE
 void
-glm_euler_yxz_quat(vec3 angles, versor dest) {
+glm_euler_yxz_quat(const vec3 angles, versor dest) {
 #ifdef CGLM_FORCE_LEFT_HANDED
   glm_euler_yxz_quat_lh(angles, dest);
 #else
@@ -530,13 +530,13 @@ glm_euler_yxz_quat(vec3 angles, versor dest) {
 /*!
  * @brief creates NEW quaternion using rotation angles and does
  *        rotations in y z x order (pitch yaw roll)
- * 
+ *
  * @param[in]   angles angles x y z (radians)
  * @param[out]  dest   quaternion
  */
 CGLM_INLINE
 void
-glm_euler_yzx_quat(vec3 angles, versor dest) {
+glm_euler_yzx_quat(const vec3 angles, versor dest) {
 #ifdef CGLM_FORCE_LEFT_HANDED
   glm_euler_yzx_quat_lh(angles, dest);
 #else
@@ -547,13 +547,13 @@ glm_euler_yzx_quat(vec3 angles, versor dest) {
 /*!
  * @brief creates NEW quaternion using rotation angles and does
  *        rotations in z x y order (yaw roll pitch)
- * 
+ *
  * @param[in]   angles angles x y z (radians)
  * @param[out]  dest   quaternion
  */
 CGLM_INLINE
 void
-glm_euler_zxy_quat(vec3 angles, versor dest) {
+glm_euler_zxy_quat(const vec3 angles, versor dest) {
 #ifdef CGLM_FORCE_LEFT_HANDED
   glm_euler_zxy_quat_lh(angles, dest);
 #else
@@ -564,13 +564,13 @@ glm_euler_zxy_quat(vec3 angles, versor dest) {
 /*!
  * @brief creates NEW quaternion using rotation angles and does
  *        rotations in z y x order (yaw pitch roll)
- * 
+ *
  * @param[in]   angles angles x y z (radians)
  * @param[out]  dest   quaternion
  */
 CGLM_INLINE
 void
-glm_euler_zyx_quat(vec3 angles, versor dest) {
+glm_euler_zyx_quat(const vec3 angles, versor dest) {
 #ifdef CGLM_FORCE_LEFT_HANDED
   glm_euler_zyx_quat_lh(angles, dest);
 #else
diff --git a/include/cglm/frustum.h b/include/cglm/frustum.h
index 5aa3c17d9..8eb270d99 100644
--- a/include/cglm/frustum.h
+++ b/include/cglm/frustum.h
@@ -69,7 +69,7 @@
  */
 CGLM_INLINE
 void
-glm_frustum_planes(mat4 m, vec4 dest[6]) {
+glm_frustum_planes(CGLM_IN(mat4) m, vec4 dest[6]) {
   mat4 t;
 
   glm_mat4_transpose_to(m, t);
@@ -114,7 +114,7 @@ glm_frustum_planes(mat4 m, vec4 dest[6]) {
  */
 CGLM_INLINE
 void
-glm_frustum_corners(mat4 invMat, vec4 dest[8]) {
+glm_frustum_corners(CGLM_IN(mat4) invMat, vec4 dest[8]) {
   vec4 c[8];
 
   /* indexOf(nearCoord) = indexOf(farCoord) + 4 */
@@ -157,7 +157,7 @@ glm_frustum_corners(mat4 invMat, vec4 dest[8]) {
  */
 CGLM_INLINE
 void
-glm_frustum_center(vec4 corners[8], vec4 dest) {
+glm_frustum_center(CGLM_IN(vec4) corners[8], vec4 dest) {
   vec4 center;
 
   glm_vec4_copy(corners[0], center);
@@ -182,7 +182,7 @@ glm_frustum_center(vec4 corners[8], vec4 dest) {
  */
 CGLM_INLINE
 void
-glm_frustum_box(vec4 corners[8], mat4 m, vec3 box[2]) {
+glm_frustum_box(CGLM_IN(vec4) corners[8], CGLM_IN(mat4) m, vec3 box[2]) {
   vec4 v;
   vec3 min, max;
   int  i;
@@ -220,7 +220,7 @@ glm_frustum_box(vec4 corners[8], mat4 m, vec3 box[2]) {
  */
 CGLM_INLINE
 void
-glm_frustum_corners_at(vec4  corners[8],
+glm_frustum_corners_at(CGLM_IN(vec4) corners[8],
                        float splitDist,
                        float farDist,
                        vec4  planeCorners[4]) {
diff --git a/include/cglm/handed/euler_to_quat_lh.h b/include/cglm/handed/euler_to_quat_lh.h
index 1bb350b64..2c7cab7c2 100644
--- a/include/cglm/handed/euler_to_quat_lh.h
+++ b/include/cglm/handed/euler_to_quat_lh.h
@@ -7,12 +7,12 @@
 
 /*
  Functions:
-   CGLM_INLINE void glm_euler_xyz_quat_lh(vec3 angles, versor dest);
-   CGLM_INLINE void glm_euler_xzy_quat_lh(vec3 angles, versor dest);
-   CGLM_INLINE void glm_euler_yxz_quat_lh(vec3 angles, versor dest);
-   CGLM_INLINE void glm_euler_yzx_quat_lh(vec3 angles, versor dest);
-   CGLM_INLINE void glm_euler_zxy_quat_lh(vec3 angles, versor dest);
-   CGLM_INLINE void glm_euler_zyx_quat_lh(vec3 angles, versor dest);
+   CGLM_INLINE void glm_euler_xyz_quat_lh(const vec3 angles, versor dest);
+   CGLM_INLINE void glm_euler_xzy_quat_lh(const vec3 angles, versor dest);
+   CGLM_INLINE void glm_euler_yxz_quat_lh(const vec3 angles, versor dest);
+   CGLM_INLINE void glm_euler_yzx_quat_lh(const vec3 angles, versor dest);
+   CGLM_INLINE void glm_euler_zxy_quat_lh(const vec3 angles, versor dest);
+   CGLM_INLINE void glm_euler_zyx_quat_lh(const vec3 angles, versor dest);
  */
 
 /*
@@ -35,7 +35,7 @@
  */
 CGLM_INLINE
 void
-glm_euler_xyz_quat_lh(vec3 angles, versor dest) {
+glm_euler_xyz_quat_lh(const vec3 angles, versor dest) {
   float xc, yc, zc,
         xs, ys, zs;
 
@@ -58,7 +58,7 @@ glm_euler_xyz_quat_lh(vec3 angles, versor dest) {
  */
 CGLM_INLINE
 void
-glm_euler_xzy_quat_lh(vec3 angles, versor dest) {
+glm_euler_xzy_quat_lh(const vec3 angles, versor dest) {
   float xc, yc, zc,
         xs, ys, zs;
 
@@ -81,7 +81,7 @@ glm_euler_xzy_quat_lh(vec3 angles, versor dest) {
  */
 CGLM_INLINE
 void
-glm_euler_yxz_quat_lh(vec3 angles, versor dest) {
+glm_euler_yxz_quat_lh(const vec3 angles, versor dest) {
   float xc, yc, zc,
         xs, ys, zs;
 
@@ -104,7 +104,7 @@ glm_euler_yxz_quat_lh(vec3 angles, versor dest) {
  */
 CGLM_INLINE
 void
-glm_euler_yzx_quat_lh(vec3 angles, versor dest) {
+glm_euler_yzx_quat_lh(const vec3 angles, versor dest) {
   float xc, yc, zc,
         xs, ys, zs;
 
@@ -127,7 +127,7 @@ glm_euler_yzx_quat_lh(vec3 angles, versor dest) {
  */
 CGLM_INLINE
 void
-glm_euler_zxy_quat_lh(vec3 angles, versor dest) {
+glm_euler_zxy_quat_lh(const vec3 angles, versor dest) {
   float xc, yc, zc,
         xs, ys, zs;
 
@@ -150,7 +150,7 @@ glm_euler_zxy_quat_lh(vec3 angles, versor dest) {
  */
 CGLM_INLINE
 void
-glm_euler_zyx_quat_lh(vec3 angles, versor dest) {
+glm_euler_zyx_quat_lh(const vec3 angles, versor dest) {
   float xc, yc, zc,
         xs, ys, zs;
 
diff --git a/include/cglm/handed/euler_to_quat_rh.h b/include/cglm/handed/euler_to_quat_rh.h
index aeb6f81b3..6e6f93741 100644
--- a/include/cglm/handed/euler_to_quat_rh.h
+++ b/include/cglm/handed/euler_to_quat_rh.h
@@ -7,12 +7,12 @@
 
 /*
  Functions:
-   CGLM_INLINE void glm_euler_xyz_quat_rh(vec3 angles, versor dest);
-   CGLM_INLINE void glm_euler_xzy_quat_rh(vec3 angles, versor dest);
-   CGLM_INLINE void glm_euler_yxz_quat_rh(vec3 angles, versor dest);
-   CGLM_INLINE void glm_euler_yzx_quat_rh(vec3 angles, versor dest);
-   CGLM_INLINE void glm_euler_zxy_quat_rh(vec3 angles, versor dest);
-   CGLM_INLINE void glm_euler_zyx_quat_rh(vec3 angles, versor dest);
+   CGLM_INLINE void glm_euler_xyz_quat_rh(const vec3 angles, versor dest);
+   CGLM_INLINE void glm_euler_xzy_quat_rh(const vec3 angles, versor dest);
+   CGLM_INLINE void glm_euler_yxz_quat_rh(const vec3 angles, versor dest);
+   CGLM_INLINE void glm_euler_yzx_quat_rh(const vec3 angles, versor dest);
+   CGLM_INLINE void glm_euler_zxy_quat_rh(const vec3 angles, versor dest);
+   CGLM_INLINE void glm_euler_zyx_quat_rh(const vec3 angles, versor dest);
  */
 
 /*
@@ -28,13 +28,13 @@
 /*!
  * @brief creates NEW quaternion using rotation angles and does
  *        rotations in x y z order in right hand (roll pitch yaw)
- * 
+ *
  * @param[in]   angles angles x y z (radians)
  * @param[out]  dest   quaternion
  */
 CGLM_INLINE
 void
-glm_euler_xyz_quat_rh(vec3 angles, versor dest) {
+glm_euler_xyz_quat_rh(const vec3 angles, versor dest) {
   float xc, yc, zc,
         xs, ys, zs;
 
@@ -52,13 +52,13 @@ glm_euler_xyz_quat_rh(vec3 angles, versor dest) {
 /*!
  * @brief creates NEW quaternion using rotation angles and does
  *        rotations in x z y order in right hand (roll yaw pitch)
- * 
+ *
  * @param[in]   angles angles x y z (radians)
  * @param[out]  dest   quaternion
  */
 CGLM_INLINE
 void
-glm_euler_xzy_quat_rh(vec3 angles, versor dest) {
+glm_euler_xzy_quat_rh(const vec3 angles, versor dest) {
   float xc, yc, zc,
         xs, ys, zs;
 
@@ -69,20 +69,20 @@ glm_euler_xzy_quat_rh(vec3 angles, versor dest) {
   dest[0] = -xc * zs * ys + xs * zc * yc;
   dest[1] =  xc * zc * ys - xs * zs * yc;
   dest[2] =  xc * zs * yc + xs * zc * ys;
-  dest[3] =  xc * zc * yc + xs * zs * ys;  
+  dest[3] =  xc * zc * yc + xs * zs * ys;
 
 }
 
 /*!
  * @brief creates NEW quaternion using rotation angles and does
  *        rotations in y x z order in right hand (pitch roll yaw)
- * 
+ *
  * @param[in]   angles angles x y z (radians)
  * @param[out]  dest   quaternion
  */
 CGLM_INLINE
 void
-glm_euler_yxz_quat_rh(vec3 angles, versor dest) {
+glm_euler_yxz_quat_rh(const vec3 angles, versor dest) {
   float xc, yc, zc,
         xs, ys, zs;
 
@@ -99,13 +99,13 @@ glm_euler_yxz_quat_rh(vec3 angles, versor dest) {
 /*!
  * @brief creates NEW quaternion using rotation angles and does
  *        rotations in y z x order in right hand (pitch yaw roll)
- * 
+ *
  * @param[in]   angles angles x y z (radians)
  * @param[out]  dest   quaternion
  */
 CGLM_INLINE
 void
-glm_euler_yzx_quat_rh(vec3 angles, versor dest) {
+glm_euler_yzx_quat_rh(const vec3 angles, versor dest) {
   float xc, yc, zc,
         xs, ys, zs;
 
@@ -123,13 +123,13 @@ glm_euler_yzx_quat_rh(vec3 angles, versor dest) {
 /*!
  * @brief creates NEW quaternion using rotation angles and does
  *        rotations in z x y order in right hand (yaw roll pitch)
- * 
+ *
  * @param[in]   angles angles x y z (radians)
  * @param[out]  dest   quaternion
  */
 CGLM_INLINE
 void
-glm_euler_zxy_quat_rh(vec3 angles, versor dest) {
+glm_euler_zxy_quat_rh(const vec3 angles, versor dest) {
   float xc, yc, zc,
         xs, ys, zs;
 
@@ -146,13 +146,13 @@ glm_euler_zxy_quat_rh(vec3 angles, versor dest) {
 /*!
  * @brief creates NEW quaternion using rotation angles and does
  *        rotations in z y x order in right hand (yaw pitch roll)
- * 
+ *
  * @param[in]   angles angles x y z (radians)
  * @param[out]  dest   quaternion
  */
 CGLM_INLINE
 void
-glm_euler_zyx_quat_rh(vec3 angles, versor dest) {
+glm_euler_zyx_quat_rh(const vec3 angles, versor dest) {
   float xc, yc, zc,
         xs, ys, zs;
 
diff --git a/include/cglm/ivec2.h b/include/cglm/ivec2.h
index 8d5ad88bc..606a123b5 100644
--- a/include/cglm/ivec2.h
+++ b/include/cglm/ivec2.h
@@ -13,46 +13,46 @@
    GLM_IVEC2_ZERO
 
  Functions:
-  CGLM_INLINE void glm_ivec2(int * __restrict v, ivec2 dest)
-  CGLM_INLINE void glm_ivec2_copy(ivec2 a, ivec2 dest)
+  CGLM_INLINE void glm_ivec2(const int * __restrict v, ivec2 dest)
+  CGLM_INLINE void glm_ivec2_copy(const ivec2 a, ivec2 dest)
   CGLM_INLINE void glm_ivec2_zero(ivec2 v)
   CGLM_INLINE void glm_ivec2_one(ivec2 v)
-  CGLM_INLINE int glm_ivec2_dot(ivec2 a, ivec2 b)
-  CGLM_INLINE int glm_ivec2_cross(ivec2 a, ivec2 b)
-  CGLM_INLINE void glm_ivec2_add(ivec2 a, ivec2 b, ivec2 dest)
-  CGLM_INLINE void glm_ivec2_adds(ivec2 v, int s, ivec2 dest)
-  CGLM_INLINE void glm_ivec2_sub(ivec2 a, ivec2 b, ivec2 dest)
-  CGLM_INLINE void glm_ivec2_subs(ivec2 v, int s, ivec2 dest)
-  CGLM_INLINE void glm_ivec2_mul(ivec2 a, ivec2 b, ivec2 dest)
-  CGLM_INLINE void glm_ivec2_scale(ivec2 v, int s, ivec2 dest)
-  CGLM_INLINE void glm_ivec2_div(ivec2 a, ivec2 b, ivec2 dest)
-  CGLM_INLINE void glm_ivec2_divs(ivec2 v, int s, ivec2 dest)
-  CGLM_INLINE void glm_ivec2_mod(ivec2 a, ivec2 b, ivec2 dest)
-  CGLM_INLINE void glm_ivec2_addadd(ivec2 a, ivec2 b, ivec2 dest)
-  CGLM_INLINE void glm_ivec2_addadds(ivec2 a, int s, ivec2 dest)
-  CGLM_INLINE void glm_ivec2_subadd(ivec2 a, ivec2 b, ivec2 dest)
-  CGLM_INLINE void glm_ivec2_subadds(ivec2 a, int s, ivec2 dest)
-  CGLM_INLINE void glm_ivec2_muladd(ivec2 a, ivec2 b, ivec2 dest)
-  CGLM_INLINE void glm_ivec2_muladds(ivec2 a, int s, ivec2 dest)
-  CGLM_INLINE void glm_ivec2_maxadd(ivec2 a, ivec2 b, ivec2 dest)
-  CGLM_INLINE void glm_ivec2_minadd(ivec2 a, ivec2 b, ivec2 dest)
-  CGLM_INLINE void glm_ivec2_subsub(ivec2 a, ivec2 b, ivec2 dest)
-  CGLM_INLINE void glm_ivec2_subsubs(ivec2 a, int s, ivec2 dest)
-  CGLM_INLINE void glm_ivec2_addsub(ivec2 a, ivec2 b, ivec2 dest)
-  CGLM_INLINE void glm_ivec2_addsubs(ivec2 a, int s, ivec2 dest)
-  CGLM_INLINE void glm_ivec2_mulsub(ivec2 a, ivec2 b, ivec2 dest)
-  CGLM_INLINE void glm_ivec2_mulsubs(ivec2 a, int s, ivec2 dest)
-  CGLM_INLINE void glm_ivec2_maxsub(ivec2 a, ivec2 b, ivec2 dest)
-  CGLM_INLINE void glm_ivec2_minsub(ivec2 a, ivec2 b, ivec2 dest)
-  CGLM_INLINE int glm_ivec2_distance2(ivec2 a, ivec2 b)
-  CGLM_INLINE float glm_ivec2_distance(ivec2 a, ivec2 b)
+  CGLM_INLINE int glm_ivec2_dot(const ivec2 a, const ivec2 b)
+  CGLM_INLINE int glm_ivec2_cross(const ivec2 a, const ivec2 b)
+  CGLM_INLINE void glm_ivec2_add(const ivec2 a, const ivec2 b, ivec2 dest)
+  CGLM_INLINE void glm_ivec2_adds(const ivec2 v, int s, ivec2 dest)
+  CGLM_INLINE void glm_ivec2_sub(const ivec2 a, const ivec2 b, ivec2 dest)
+  CGLM_INLINE void glm_ivec2_subs(const ivec2 v, int s, ivec2 dest)
+  CGLM_INLINE void glm_ivec2_mul(const ivec2 a, const ivec2 b, ivec2 dest)
+  CGLM_INLINE void glm_ivec2_scale(const ivec2 v, int s, ivec2 dest)
+  CGLM_INLINE void glm_ivec2_div(const ivec2 a, const ivec2 b, ivec2 dest)
+  CGLM_INLINE void glm_ivec2_divs(const ivec2 v, int s, ivec2 dest)
+  CGLM_INLINE void glm_ivec2_mod(const ivec2 a, const ivec2 b, ivec2 dest)
+  CGLM_INLINE void glm_ivec2_addadd(const ivec2 a, const ivec2 b, ivec2 dest)
+  CGLM_INLINE void glm_ivec2_addadds(const ivec2 a, int s, ivec2 dest)
+  CGLM_INLINE void glm_ivec2_subadd(const ivec2 a, const ivec2 b, ivec2 dest)
+  CGLM_INLINE void glm_ivec2_subadds(const ivec2 a, int s, ivec2 dest)
+  CGLM_INLINE void glm_ivec2_muladd(const ivec2 a, const ivec2 b, ivec2 dest)
+  CGLM_INLINE void glm_ivec2_muladds(const ivec2 a, int s, ivec2 dest)
+  CGLM_INLINE void glm_ivec2_maxadd(const ivec2 a, const ivec2 b, ivec2 dest)
+  CGLM_INLINE void glm_ivec2_minadd(const ivec2 a, const ivec2 b, ivec2 dest)
+  CGLM_INLINE void glm_ivec2_subsub(const ivec2 a, const ivec2 b, ivec2 dest)
+  CGLM_INLINE void glm_ivec2_subsubs(const ivec2 a, int s, ivec2 dest)
+  CGLM_INLINE void glm_ivec2_addsub(const ivec2 a, const ivec2 b, ivec2 dest)
+  CGLM_INLINE void glm_ivec2_addsubs(const ivec2 a, int s, ivec2 dest)
+  CGLM_INLINE void glm_ivec2_mulsub(const ivec2 a, const ivec2 b, ivec2 dest)
+  CGLM_INLINE void glm_ivec2_mulsubs(const ivec2 a, int s, ivec2 dest)
+  CGLM_INLINE void glm_ivec2_maxsub(const ivec2 a, const ivec2 b, ivec2 dest)
+  CGLM_INLINE void glm_ivec2_minsub(const ivec2 a, const ivec2 b, ivec2 dest)
+  CGLM_INLINE int glm_ivec2_distance2(const ivec2 a, const ivec2 b)
+  CGLM_INLINE float glm_ivec2_distance(const ivec2 a, const ivec2 b)
   CGLM_INLINE void glm_ivec2_fill(ivec2 v, int val);
-  CGLM_INLINE bool glm_ivec2_eq(ivec2 v, int val);
-  CGLM_INLINE bool glm_ivec2_eqv(ivec2 a, ivec2 b);
-  CGLM_INLINE void glm_ivec2_maxv(ivec2 a, ivec2 b, ivec2 dest)
-  CGLM_INLINE void glm_ivec2_minv(ivec2 a, ivec2 b, ivec2 dest)
+  CGLM_INLINE bool glm_ivec2_eq(const ivec2 v, int val);
+  CGLM_INLINE bool glm_ivec2_eqv(const ivec2 a, const ivec2 b);
+  CGLM_INLINE void glm_ivec2_maxv(const ivec2 a, const ivec2 b, ivec2 dest)
+  CGLM_INLINE void glm_ivec2_minv(const ivec2 a, const ivec2 b, ivec2 dest)
   CGLM_INLINE void glm_ivec2_clamp(ivec2 v, int minVal, int maxVal)
-  CGLM_INLINE void glm_ivec2_abs(ivec2 v, ivec2 dest)
+  CGLM_INLINE void glm_ivec2_abs(const ivec2 v, ivec2 dest)
  */
 
 #ifndef cglm_ivec2_h
@@ -75,7 +75,7 @@
  */
 CGLM_INLINE
 void
-glm_ivec2(int * __restrict v, ivec2 dest) {
+glm_ivec2(const int * __restrict v, ivec2 dest) {
   dest[0] = v[0];
   dest[1] = v[1];
 }
@@ -88,7 +88,7 @@ glm_ivec2(int * __restrict v, ivec2 dest) {
  */
 CGLM_INLINE
 void
-glm_ivec2_copy(ivec2 a, ivec2 dest) {
+glm_ivec2_copy(const ivec2 a, ivec2 dest) {
   dest[0] = a[0];
   dest[1] = a[1];
 }
@@ -99,7 +99,7 @@ glm_ivec2_copy(ivec2 a, ivec2 dest) {
  * @param[out] v vector
  */
 CGLM_INLINE
-void 
+void
 glm_ivec2_zero(ivec2 v) {
   v[0] = v[1] = 0;
 }
@@ -125,7 +125,7 @@ glm_ivec2_one(ivec2 v) {
  */
 CGLM_INLINE
 int
-glm_ivec2_dot(ivec2 a, ivec2 b) {
+glm_ivec2_dot(const ivec2 a, const ivec2 b) {
   return a[0] * b[0] + a[1] * b[1];
 }
 
@@ -141,7 +141,7 @@ glm_ivec2_dot(ivec2 a, ivec2 b) {
  */
 CGLM_INLINE
 int
-glm_ivec2_cross(ivec2 a, ivec2 b) {
+glm_ivec2_cross(const ivec2 a, const ivec2 b) {
   return a[0] * b[1] - a[1] * b[0];
 }
 
@@ -154,7 +154,7 @@ glm_ivec2_cross(ivec2 a, ivec2 b) {
  */
 CGLM_INLINE
 void
-glm_ivec2_add(ivec2 a, ivec2 b, ivec2 dest) {
+glm_ivec2_add(const ivec2 a, const ivec2 b, ivec2 dest) {
   dest[0] = a[0] + b[0];
   dest[1] = a[1] + b[1];
 }
@@ -168,7 +168,7 @@ glm_ivec2_add(ivec2 a, ivec2 b, ivec2 dest) {
  */
 CGLM_INLINE
 void
-glm_ivec2_adds(ivec2 v, int s, ivec2 dest) {
+glm_ivec2_adds(const ivec2 v, int s, ivec2 dest) {
   dest[0] = v[0] + s;
   dest[1] = v[1] + s;
 }
@@ -182,7 +182,7 @@ glm_ivec2_adds(ivec2 v, int s, ivec2 dest) {
  */
 CGLM_INLINE
 void
-glm_ivec2_sub(ivec2 a, ivec2 b, ivec2 dest) {
+glm_ivec2_sub(const ivec2 a, const ivec2 b, ivec2 dest) {
   dest[0] = a[0] - b[0];
   dest[1] = a[1] - b[1];
 }
@@ -196,7 +196,7 @@ glm_ivec2_sub(ivec2 a, ivec2 b, ivec2 dest) {
  */
 CGLM_INLINE
 void
-glm_ivec2_subs(ivec2 v, int s, ivec2 dest) {
+glm_ivec2_subs(const ivec2 v, int s, ivec2 dest) {
   dest[0] = v[0] - s;
   dest[1] = v[1] - s;
 }
@@ -210,7 +210,7 @@ glm_ivec2_subs(ivec2 v, int s, ivec2 dest) {
  */
 CGLM_INLINE
 void
-glm_ivec2_mul(ivec2 a, ivec2 b, ivec2 dest) {
+glm_ivec2_mul(const ivec2 a, const ivec2 b, ivec2 dest) {
   dest[0] = a[0] * b[0];
   dest[1] = a[1] * b[1];
 }
@@ -224,7 +224,7 @@ glm_ivec2_mul(ivec2 a, ivec2 b, ivec2 dest) {
  */
 CGLM_INLINE
 void
-glm_ivec2_scale(ivec2 v, int s, ivec2 dest) {
+glm_ivec2_scale(const ivec2 v, int s, ivec2 dest) {
   dest[0] = v[0] * s;
   dest[1] = v[1] * s;
 }
@@ -238,7 +238,7 @@ glm_ivec2_scale(ivec2 v, int s, ivec2 dest) {
  */
 CGLM_INLINE
 void
-glm_ivec2_div(ivec2 a, ivec2 b, ivec2 dest) {
+glm_ivec2_div(const ivec2 a, const ivec2 b, ivec2 dest) {
   dest[0] = a[0] / b[0];
   dest[1] = a[1] / b[1];
 }
@@ -252,7 +252,7 @@ glm_ivec2_div(ivec2 a, ivec2 b, ivec2 dest) {
  */
 CGLM_INLINE
 void
-glm_ivec2_divs(ivec2 v, int s, ivec2 dest) {
+glm_ivec2_divs(const ivec2 v, int s, ivec2 dest) {
   dest[0] = v[0] / s;
   dest[1] = v[1] / s;
 }
@@ -266,7 +266,7 @@ glm_ivec2_divs(ivec2 v, int s, ivec2 dest) {
  */
 CGLM_INLINE
 void
-glm_ivec2_mod(ivec2 a, ivec2 b, ivec2 dest) {
+glm_ivec2_mod(const ivec2 a, const ivec2 b, ivec2 dest) {
   dest[0] = a[0] % b[0];
   dest[1] = a[1] % b[1];
 }
@@ -280,9 +280,9 @@ glm_ivec2_mod(ivec2 a, ivec2 b, ivec2 dest) {
  * @param[in]  b    second vector
  * @param[out] dest dest += (a + b)
  */
-CGLM_INLINE 
-void 
-glm_ivec2_addadd(ivec2 a, ivec2 b, ivec2 dest) {
+CGLM_INLINE
+void
+glm_ivec2_addadd(const ivec2 a, const ivec2 b, ivec2 dest) {
   dest[0] += a[0] + b[0];
   dest[1] += a[1] + b[1];
 }
@@ -296,9 +296,9 @@ glm_ivec2_addadd(ivec2 a, ivec2 b, ivec2 dest) {
  * @param[in]  s    scalar
  * @param[out] dest dest += (a + s)
  */
-CGLM_INLINE 
-void 
-glm_ivec2_addadds(ivec2 a, int s, ivec2 dest) {
+CGLM_INLINE
+void
+glm_ivec2_addadds(const ivec2 a, int s, ivec2 dest) {
   dest[0] += a[0] + s;
   dest[1] += a[1] + s;
 }
@@ -310,11 +310,11 @@ glm_ivec2_addadds(ivec2 a, int s, ivec2 dest) {
  *
  * @param[in]  a    first vector
  * @param[in]  b    second vector
- * @param[out] dest dest += (a - b)  
+ * @param[out] dest dest += (a - b)
  */
-CGLM_INLINE 
-void 
-glm_ivec2_subadd(ivec2 a, ivec2 b, ivec2 dest) {
+CGLM_INLINE
+void
+glm_ivec2_subadd(const ivec2 a, const ivec2 b, ivec2 dest) {
   dest[0] += a[0] - b[0];
   dest[1] += a[1] - b[1];
 }
@@ -328,9 +328,9 @@ glm_ivec2_subadd(ivec2 a, ivec2 b, ivec2 dest) {
  * @param[in]  s    scalar
  * @param[out] dest dest += (a - s)
  */
-CGLM_INLINE 
-void 
-glm_ivec2_subadds(ivec2 a, int s, ivec2 dest) {
+CGLM_INLINE
+void
+glm_ivec2_subadds(const ivec2 a, int s, ivec2 dest) {
   dest[0] += a[0] - s;
   dest[1] += a[1] - s;
 }
@@ -344,9 +344,9 @@ glm_ivec2_subadds(ivec2 a, int s, ivec2 dest) {
  * @param[in]  b    second vector
  * @param[out] dest dest += (a * b)
  */
-CGLM_INLINE 
-void 
-glm_ivec2_muladd(ivec2 a, ivec2 b, ivec2 dest) {
+CGLM_INLINE
+void
+glm_ivec2_muladd(const ivec2 a, const ivec2 b, ivec2 dest) {
   dest[0] += a[0] * b[0];
   dest[1] += a[1] * b[1];
 }
@@ -360,9 +360,9 @@ glm_ivec2_muladd(ivec2 a, ivec2 b, ivec2 dest) {
  * @param[in]  s    scalar
  * @param[out] dest dest += (a * s)
  */
-CGLM_INLINE 
-void 
-glm_ivec2_muladds(ivec2 a, int s, ivec2 dest) {
+CGLM_INLINE
+void
+glm_ivec2_muladds(const ivec2 a, int s, ivec2 dest) {
   dest[0] += a[0] * s;
   dest[1] += a[1] * s;
 }
@@ -376,9 +376,9 @@ glm_ivec2_muladds(ivec2 a, int s, ivec2 dest) {
  * @param[in]  b    second vector
  * @param[out] dest dest += max(a, b)
  */
-CGLM_INLINE 
-void 
-glm_ivec2_maxadd(ivec2 a, ivec2 b, ivec2 dest) {
+CGLM_INLINE
+void
+glm_ivec2_maxadd(const ivec2 a, const ivec2 b, ivec2 dest) {
   dest[0] += glm_imax(a[0], b[0]);
   dest[1] += glm_imax(a[1], b[1]);
 }
@@ -392,9 +392,9 @@ glm_ivec2_maxadd(ivec2 a, ivec2 b, ivec2 dest) {
  * @param[in]  b    second vector
  * @param[out] dest dest += min(a, b)
  */
-CGLM_INLINE 
-void 
-glm_ivec2_minadd(ivec2 a, ivec2 b, ivec2 dest) {
+CGLM_INLINE
+void
+glm_ivec2_minadd(const ivec2 a, const ivec2 b, ivec2 dest) {
   dest[0] += glm_imin(a[0], b[0]);
   dest[1] += glm_imin(a[1], b[1]);
 }
@@ -408,9 +408,9 @@ glm_ivec2_minadd(ivec2 a, ivec2 b, ivec2 dest) {
  * @param[in]  b    second vector
  * @param[out] dest dest -= (a - b)
  */
-CGLM_INLINE 
-void 
-glm_ivec2_subsub(ivec2 a, ivec2 b, ivec2 dest) {
+CGLM_INLINE
+void
+glm_ivec2_subsub(const ivec2 a, const ivec2 b, ivec2 dest) {
   dest[0] -= a[0] - b[0];
   dest[1] -= a[1] - b[1];
 }
@@ -424,9 +424,9 @@ glm_ivec2_subsub(ivec2 a, ivec2 b, ivec2 dest) {
  * @param[in]  s    scalar
  * @param[out] dest dest -= (a - s)
  */
-CGLM_INLINE 
-void 
-glm_ivec2_subsubs(ivec2 a, int s, ivec2 dest) {
+CGLM_INLINE
+void
+glm_ivec2_subsubs(const ivec2 a, int s, ivec2 dest) {
   dest[0] -= a[0] - s;
   dest[1] -= a[1] - s;
 }
@@ -440,9 +440,9 @@ glm_ivec2_subsubs(ivec2 a, int s, ivec2 dest) {
  * @param[in]  b    scalar
  * @param[out] dest dest -= (a + b)
  */
-CGLM_INLINE 
-void 
-glm_ivec2_addsub(ivec2 a, ivec2 b, ivec2 dest) {
+CGLM_INLINE
+void
+glm_ivec2_addsub(const ivec2 a, const ivec2 b, ivec2 dest) {
   dest[0] -= a[0] + b[0];
   dest[1] -= a[1] + b[1];
 }
@@ -456,9 +456,9 @@ glm_ivec2_addsub(ivec2 a, ivec2 b, ivec2 dest) {
  * @param[in]  s    scalar
  * @param[out] dest dest -= (a + b)
  */
-CGLM_INLINE 
-void 
-glm_ivec2_addsubs(ivec2 a, int s, ivec2 dest) {
+CGLM_INLINE
+void
+glm_ivec2_addsubs(const ivec2 a, int s, ivec2 dest) {
   dest[0] -= a[0] + s;
   dest[1] -= a[1] + s;
 }
@@ -472,9 +472,9 @@ glm_ivec2_addsubs(ivec2 a, int s, ivec2 dest) {
  * @param[in]  b    scalar
  * @param[out] dest dest -= (a * b)
  */
-CGLM_INLINE 
-void 
-glm_ivec2_mulsub(ivec2 a, ivec2 b, ivec2 dest) {
+CGLM_INLINE
+void
+glm_ivec2_mulsub(const ivec2 a, const ivec2 b, ivec2 dest) {
   dest[0] -= a[0] * b[0];
   dest[1] -= a[1] * b[1];
 }
@@ -488,9 +488,9 @@ glm_ivec2_mulsub(ivec2 a, ivec2 b, ivec2 dest) {
  * @param[in]  s    scalar
  * @param[out] dest dest -= (a * s)
  */
-CGLM_INLINE 
-void 
-glm_ivec2_mulsubs(ivec2 a, int s, ivec2 dest) {
+CGLM_INLINE
+void
+glm_ivec2_mulsubs(const ivec2 a, int s, ivec2 dest) {
   dest[0] -= a[0] * s;
   dest[1] -= a[1] * s;
 }
@@ -504,9 +504,9 @@ glm_ivec2_mulsubs(ivec2 a, int s, ivec2 dest) {
  * @param[in]  b    second vector
  * @param[out] dest dest -= max(a, b)
  */
-CGLM_INLINE 
-void 
-glm_ivec2_maxsub(ivec2 a, ivec2 b, ivec2 dest) {
+CGLM_INLINE
+void
+glm_ivec2_maxsub(const ivec2 a, const ivec2 b, ivec2 dest) {
   dest[0] -= glm_imax(a[0], b[0]);
   dest[1] -= glm_imax(a[1], b[1]);
 }
@@ -520,9 +520,9 @@ glm_ivec2_maxsub(ivec2 a, ivec2 b, ivec2 dest) {
  * @param[in]  b    second vector
  * @param[out] dest dest -= min(a, b)
  */
-CGLM_INLINE 
-void 
-glm_ivec2_minsub(ivec2 a, ivec2 b, ivec2 dest) {
+CGLM_INLINE
+void
+glm_ivec2_minsub(const ivec2 a, const ivec2 b, ivec2 dest) {
   dest[0] -= glm_imin(a[0], b[0]);
   dest[1] -= glm_imin(a[1], b[1]);
 }
@@ -536,7 +536,7 @@ glm_ivec2_minsub(ivec2 a, ivec2 b, ivec2 dest) {
  */
 CGLM_INLINE
 int
-glm_ivec2_distance2(ivec2 a, ivec2 b) {
+glm_ivec2_distance2(const ivec2 a, const ivec2 b) {
   int xd, yd;
   xd = a[0] - b[0];
   yd = a[1] - b[1];
@@ -552,7 +552,7 @@ glm_ivec2_distance2(ivec2 a, ivec2 b) {
  */
 CGLM_INLINE
 float
-glm_ivec2_distance(ivec2 a, ivec2 b) {
+glm_ivec2_distance(const ivec2 a, const ivec2 b) {
   return sqrtf((float)glm_ivec2_distance2(a, b));
 }
 
@@ -577,7 +577,7 @@ glm_ivec2_fill(ivec2 v, int val) {
  */
 CGLM_INLINE
 bool
-glm_ivec2_eq(ivec2 v, int val) {
+glm_ivec2_eq(const ivec2 v, int val) {
   return v[0] == val && v[0] == v[1];
 }
 
@@ -589,7 +589,7 @@ glm_ivec2_eq(ivec2 v, int val) {
  */
 CGLM_INLINE
 bool
-glm_ivec2_eqv(ivec2 a, ivec2 b) {
+glm_ivec2_eqv(const ivec2 a, const ivec2 b) {
   return a[0] == b[0]
          && a[1] == b[1];
 }
@@ -603,7 +603,7 @@ glm_ivec2_eqv(ivec2 a, ivec2 b) {
  */
 CGLM_INLINE
 void
-glm_ivec2_maxv(ivec2 a, ivec2 b, ivec2 dest) {
+glm_ivec2_maxv(const ivec2 a, const ivec2 b, ivec2 dest) {
   dest[0] = a[0] > b[0] ? a[0] : b[0];
   dest[1] = a[1] > b[1] ? a[1] : b[1];
 }
@@ -617,7 +617,7 @@ glm_ivec2_maxv(ivec2 a, ivec2 b, ivec2 dest) {
  */
 CGLM_INLINE
 void
-glm_ivec2_minv(ivec2 a, ivec2 b, ivec2 dest) {
+glm_ivec2_minv(const ivec2 a, const ivec2 b, ivec2 dest) {
   dest[0] = a[0] < b[0] ? a[0] : b[0];
   dest[1] = a[1] < b[1] ? a[1] : b[1];
 }
@@ -651,7 +651,7 @@ glm_ivec2_clamp(ivec2 v, int minVal, int maxVal) {
  */
 CGLM_INLINE
 void
-glm_ivec2_abs(ivec2 v, ivec2 dest) {
+glm_ivec2_abs(const ivec2 v, ivec2 dest) {
   dest[0] = abs(v[0]);
   dest[1] = abs(v[1]);
 }
diff --git a/include/cglm/ivec3.h b/include/cglm/ivec3.h
index 67eaa22c6..4cce8c603 100644
--- a/include/cglm/ivec3.h
+++ b/include/cglm/ivec3.h
@@ -13,47 +13,47 @@
    GLM_IVEC3_ZERO
 
  Functions:
-  CGLM_INLINE void glm_ivec3(ivec4 v4, ivec3 dest)
-  CGLM_INLINE void glm_ivec3_copy(ivec3 a, ivec3 dest)
+  CGLM_INLINE void glm_ivec3(const ivec4 v4, ivec3 dest)
+  CGLM_INLINE void glm_ivec3_copy(const ivec3 a, ivec3 dest)
   CGLM_INLINE void glm_ivec3_zero(ivec3 v)
   CGLM_INLINE void glm_ivec3_one(ivec3 v)
-  CGLM_INLINE int glm_ivec3_dot(ivec3 a, ivec3 b)
+  CGLM_INLINE int glm_ivec3_dot(const ivec3 a, const ivec3 b)
   CGLM_INLINE int glm_ivec3_norm2(ivec3 v)
   CGLM_INLINE int glm_ivec3_norm(ivec3 v)
-  CGLM_INLINE void glm_ivec3_add(ivec3 a, ivec3 b, ivec3 dest)
-  CGLM_INLINE void glm_ivec3_adds(ivec3 v, int s, ivec3 dest)
-  CGLM_INLINE void glm_ivec3_sub(ivec3 a, ivec3 b, ivec3 dest)
-  CGLM_INLINE void glm_ivec3_subs(ivec3 v, int s, ivec3 dest)
-  CGLM_INLINE void glm_ivec3_mul(ivec3 a, ivec3 b, ivec3 dest)
-  CGLM_INLINE void glm_ivec3_scale(ivec3 v, int s, ivec3 dest)
-  CGLM_INLINE void glm_ivec3_div(ivec3 a, ivec3 b, ivec3 dest)
-  CGLM_INLINE void glm_ivec3_divs(ivec3 v, int s, ivec3 dest)
-  CGLM_INLINE void glm_ivec3_mod(ivec3 a, ivec3 b, ivec3 dest)
-  CGLM_INLINE void glm_ivec3_addadd(ivec3 a, ivec3 b, ivec3 dest)
-  CGLM_INLINE void glm_ivec3_addadds(ivec3 a, int s, ivec3 dest)
-  CGLM_INLINE void glm_ivec3_subadd(ivec3 a, ivec3 b, ivec3 dest)
-  CGLM_INLINE void glm_ivec3_subadds(ivec3 a, int s, ivec3 dest)
-  CGLM_INLINE void glm_ivec3_muladd(ivec3 a, ivec3 b, ivec3 dest)
-  CGLM_INLINE void glm_ivec3_muladds(ivec3 a, int s, ivec3 dest)
-  CGLM_INLINE void glm_ivec3_maxadd(ivec3 a, ivec3 b, ivec3 dest)
-  CGLM_INLINE void glm_ivec3_minadd(ivec3 a, ivec3 b, ivec3 dest)
-  CGLM_INLINE void glm_ivec3_subsub(ivec3 a, ivec3 b, ivec3 dest)
-  CGLM_INLINE void glm_ivec3_subsubs(ivec3 a, int s, ivec3 dest)
-  CGLM_INLINE void glm_ivec3_addsub(ivec3 a, ivec3 b, ivec3 dest)
-  CGLM_INLINE void glm_ivec3_addsubs(ivec3 a, int s, ivec3 dest)
-  CGLM_INLINE void glm_ivec3_mulsub(ivec3 a, ivec3 b, ivec3 dest)
-  CGLM_INLINE void glm_ivec3_mulsubs(ivec3 a, int s, ivec3 dest)
-  CGLM_INLINE void glm_ivec3_maxsub(ivec3 a, ivec3 b, ivec3 dest)
-  CGLM_INLINE void glm_ivec3_minsub(ivec3 a, ivec3 b, ivec3 dest)
-  CGLM_INLINE int glm_ivec3_distance2(ivec3 a, ivec3 b)
-  CGLM_INLINE float glm_ivec3_distance(ivec3 a, ivec3 b)
+  CGLM_INLINE void glm_ivec3_add(const ivec3 a, const ivec3 b, ivec3 dest)
+  CGLM_INLINE void glm_ivec3_adds(const ivec3 v, int s, ivec3 dest)
+  CGLM_INLINE void glm_ivec3_sub(const ivec3 a, const ivec3 b, ivec3 dest)
+  CGLM_INLINE void glm_ivec3_subs(const ivec3 v, int s, ivec3 dest)
+  CGLM_INLINE void glm_ivec3_mul(const ivec3 a, const ivec3 b, ivec3 dest)
+  CGLM_INLINE void glm_ivec3_scale(const ivec3 v, int s, ivec3 dest)
+  CGLM_INLINE void glm_ivec3_div(const ivec3 a, const ivec3 b, ivec3 dest)
+  CGLM_INLINE void glm_ivec3_divs(const ivec3 v, int s, ivec3 dest)
+  CGLM_INLINE void glm_ivec3_mod(const ivec3 a, const ivec3 b, ivec3 dest)
+  CGLM_INLINE void glm_ivec3_addadd(const ivec3 a, const ivec3 b, ivec3 dest)
+  CGLM_INLINE void glm_ivec3_addadds(const ivec3 a, int s, ivec3 dest)
+  CGLM_INLINE void glm_ivec3_subadd(const ivec3 a, const ivec3 b, ivec3 dest)
+  CGLM_INLINE void glm_ivec3_subadds(const ivec3 a, int s, ivec3 dest)
+  CGLM_INLINE void glm_ivec3_muladd(const ivec3 a, const ivec3 b, ivec3 dest)
+  CGLM_INLINE void glm_ivec3_muladds(const ivec3 a, int s, ivec3 dest)
+  CGLM_INLINE void glm_ivec3_maxadd(const ivec3 a, const ivec3 b, ivec3 dest)
+  CGLM_INLINE void glm_ivec3_minadd(const ivec3 a, const ivec3 b, ivec3 dest)
+  CGLM_INLINE void glm_ivec3_subsub(const ivec3 a, const ivec3 b, ivec3 dest)
+  CGLM_INLINE void glm_ivec3_subsubs(const ivec3 a, int s, ivec3 dest)
+  CGLM_INLINE void glm_ivec3_addsub(const ivec3 a, const ivec3 b, ivec3 dest)
+  CGLM_INLINE void glm_ivec3_addsubs(const ivec3 a, int s, ivec3 dest)
+  CGLM_INLINE void glm_ivec3_mulsub(const ivec3 a, const ivec3 b, ivec3 dest)
+  CGLM_INLINE void glm_ivec3_mulsubs(const ivec3 a, int s, ivec3 dest)
+  CGLM_INLINE void glm_ivec3_maxsub(const ivec3 a, const ivec3 b, ivec3 dest)
+  CGLM_INLINE void glm_ivec3_minsub(const ivec3 a, const ivec3 b, ivec3 dest)
+  CGLM_INLINE int glm_ivec3_distance2(const ivec3 a, const ivec3 b)
+  CGLM_INLINE float glm_ivec3_distance(const ivec3 a, const ivec3 b)
   CGLM_INLINE void glm_ivec3_fill(ivec3 v, int val);
-  CGLM_INLINE bool glm_ivec3_eq(ivec3 v, int val);
-  CGLM_INLINE bool glm_ivec3_eqv(ivec3 a, ivec3 b);
-  CGLM_INLINE void glm_ivec3_maxv(ivec3 a, ivec3 b, ivec3 dest)
-  CGLM_INLINE void glm_ivec3_minv(ivec3 a, ivec3 b, ivec3 dest)
+  CGLM_INLINE bool glm_ivec3_eq(const ivec3 v, int val);
+  CGLM_INLINE bool glm_ivec3_eqv(const ivec3 a, const ivec3 b);
+  CGLM_INLINE void glm_ivec3_maxv(const ivec3 a, const ivec3 b, ivec3 dest)
+  CGLM_INLINE void glm_ivec3_minv(const ivec3 a, const ivec3 b, ivec3 dest)
   CGLM_INLINE void glm_ivec3_clamp(ivec3 v, int minVal, int maxVal)
-  CGLM_INLINE void glm_ivec3_abs(ivec3 v, ivec3 dest)
+  CGLM_INLINE void glm_ivec3_abs(const ivec3 v, ivec3 dest)
  */
 
 #ifndef cglm_ivec3_h
@@ -76,7 +76,7 @@
  */
 CGLM_INLINE
 void
-glm_ivec3(ivec4 v4, ivec3 dest) {
+glm_ivec3(const ivec4 v4, ivec3 dest) {
   dest[0] = v4[0];
   dest[1] = v4[1];
   dest[2] = v4[2];
@@ -90,7 +90,7 @@ glm_ivec3(ivec4 v4, ivec3 dest) {
  */
 CGLM_INLINE
 void
-glm_ivec3_copy(ivec3 a, ivec3 dest) {
+glm_ivec3_copy(const ivec3 a, ivec3 dest) {
   dest[0] = a[0];
   dest[1] = a[1];
   dest[2] = a[2];
@@ -102,7 +102,7 @@ glm_ivec3_copy(ivec3 a, ivec3 dest) {
  * @param[out] v vector
  */
 CGLM_INLINE
-void 
+void
 glm_ivec3_zero(ivec3 v) {
   v[0] = v[1] = v[2] = 0;
 }
@@ -128,7 +128,7 @@ glm_ivec3_one(ivec3 v) {
  */
 CGLM_INLINE
 int
-glm_ivec3_dot(ivec3 a, ivec3 b) {
+glm_ivec3_dot(const ivec3 a, const ivec3 b) {
   return a[0] * b[0] + a[1] * b[1] + a[2] * b[2];
 }
 
@@ -172,7 +172,7 @@ glm_ivec3_norm(ivec3 v) {
  */
 CGLM_INLINE
 void
-glm_ivec3_add(ivec3 a, ivec3 b, ivec3 dest) {
+glm_ivec3_add(const ivec3 a, const ivec3 b, ivec3 dest) {
   dest[0] = a[0] + b[0];
   dest[1] = a[1] + b[1];
   dest[2] = a[2] + b[2];
@@ -187,7 +187,7 @@ glm_ivec3_add(ivec3 a, ivec3 b, ivec3 dest) {
  */
 CGLM_INLINE
 void
-glm_ivec3_adds(ivec3 v, int s, ivec3 dest) {
+glm_ivec3_adds(const ivec3 v, int s, ivec3 dest) {
   dest[0] = v[0] + s;
   dest[1] = v[1] + s;
   dest[2] = v[2] + s;
@@ -202,7 +202,7 @@ glm_ivec3_adds(ivec3 v, int s, ivec3 dest) {
  */
 CGLM_INLINE
 void
-glm_ivec3_sub(ivec3 a, ivec3 b, ivec3 dest) {
+glm_ivec3_sub(const ivec3 a, const ivec3 b, ivec3 dest) {
   dest[0] = a[0] - b[0];
   dest[1] = a[1] - b[1];
   dest[2] = a[2] - b[2];
@@ -217,7 +217,7 @@ glm_ivec3_sub(ivec3 a, ivec3 b, ivec3 dest) {
  */
 CGLM_INLINE
 void
-glm_ivec3_subs(ivec3 v, int s, ivec3 dest) {
+glm_ivec3_subs(const ivec3 v, int s, ivec3 dest) {
   dest[0] = v[0] - s;
   dest[1] = v[1] - s;
   dest[2] = v[2] - s;
@@ -232,7 +232,7 @@ glm_ivec3_subs(ivec3 v, int s, ivec3 dest) {
  */
 CGLM_INLINE
 void
-glm_ivec3_mul(ivec3 a, ivec3 b, ivec3 dest) {
+glm_ivec3_mul(const ivec3 a, const ivec3 b, ivec3 dest) {
   dest[0] = a[0] * b[0];
   dest[1] = a[1] * b[1];
   dest[2] = a[2] * b[2];
@@ -247,7 +247,7 @@ glm_ivec3_mul(ivec3 a, ivec3 b, ivec3 dest) {
  */
 CGLM_INLINE
 void
-glm_ivec3_scale(ivec3 v, int s, ivec3 dest) {
+glm_ivec3_scale(const ivec3 v, int s, ivec3 dest) {
   dest[0] = v[0] * s;
   dest[1] = v[1] * s;
   dest[2] = v[2] * s;
@@ -262,7 +262,7 @@ glm_ivec3_scale(ivec3 v, int s, ivec3 dest) {
  */
 CGLM_INLINE
 void
-glm_ivec3_div(ivec3 a, ivec3 b, ivec3 dest) {
+glm_ivec3_div(const ivec3 a, const ivec3 b, ivec3 dest) {
   dest[0] = a[0] / b[0];
   dest[1] = a[1] / b[1];
   dest[2] = a[2] / b[2];
@@ -277,7 +277,7 @@ glm_ivec3_div(ivec3 a, ivec3 b, ivec3 dest) {
  */
 CGLM_INLINE
 void
-glm_ivec3_divs(ivec3 v, int s, ivec3 dest) {
+glm_ivec3_divs(const ivec3 v, int s, ivec3 dest) {
   dest[0] = v[0] / s;
   dest[1] = v[1] / s;
   dest[2] = v[2] / s;
@@ -294,7 +294,7 @@ glm_ivec3_divs(ivec3 v, int s, ivec3 dest) {
  */
 CGLM_INLINE
 void
-glm_ivec3_mod(ivec3 a, ivec3 b, ivec3 dest) {
+glm_ivec3_mod(const ivec3 a, const ivec3 b, ivec3 dest) {
   dest[0] = a[0] % b[0];
   dest[1] = a[1] % b[1];
   dest[2] = a[2] % b[2];
@@ -309,9 +309,9 @@ glm_ivec3_mod(ivec3 a, ivec3 b, ivec3 dest) {
  * @param[in]  b    second vector
  * @param[out] dest dest += (a + b)
  */
-CGLM_INLINE 
-void 
-glm_ivec3_addadd(ivec3 a, ivec3 b, ivec3 dest) {
+CGLM_INLINE
+void
+glm_ivec3_addadd(const ivec3 a, const ivec3 b, ivec3 dest) {
   dest[0] += a[0] + b[0];
   dest[1] += a[1] + b[1];
   dest[2] += a[2] + b[2];
@@ -326,9 +326,9 @@ glm_ivec3_addadd(ivec3 a, ivec3 b, ivec3 dest) {
  * @param[in]  s    scalar
  * @param[out] dest dest += (a + s)
  */
-CGLM_INLINE 
-void 
-glm_ivec3_addadds(ivec3 a, int s, ivec3 dest) {
+CGLM_INLINE
+void
+glm_ivec3_addadds(const ivec3 a, int s, ivec3 dest) {
   dest[0] += a[0] + s;
   dest[1] += a[1] + s;
   dest[2] += a[2] + s;
@@ -341,11 +341,11 @@ glm_ivec3_addadds(ivec3 a, int s, ivec3 dest) {
  *
  * @param[in]  a    first vector
  * @param[in]  b    second vector
- * @param[out] dest dest += (a - b)  
+ * @param[out] dest dest += (a - b)
  */
-CGLM_INLINE 
-void 
-glm_ivec3_subadd(ivec3 a, ivec3 b, ivec3 dest) {
+CGLM_INLINE
+void
+glm_ivec3_subadd(const ivec3 a, const ivec3 b, ivec3 dest) {
   dest[0] += a[0] - b[0];
   dest[1] += a[1] - b[1];
   dest[2] += a[2] - b[2];
@@ -360,9 +360,9 @@ glm_ivec3_subadd(ivec3 a, ivec3 b, ivec3 dest) {
  * @param[in]  s    scalar
  * @param[out] dest dest += (a - s)
  */
-CGLM_INLINE 
-void 
-glm_ivec3_subadds(ivec3 a, int s, ivec3 dest) {
+CGLM_INLINE
+void
+glm_ivec3_subadds(const ivec3 a, int s, ivec3 dest) {
   dest[0] += a[0] - s;
   dest[1] += a[1] - s;
   dest[2] += a[2] - s;
@@ -377,9 +377,9 @@ glm_ivec3_subadds(ivec3 a, int s, ivec3 dest) {
  * @param[in]  b    second vector
  * @param[out] dest dest += (a * b)
  */
-CGLM_INLINE 
-void 
-glm_ivec3_muladd(ivec3 a, ivec3 b, ivec3 dest) {
+CGLM_INLINE
+void
+glm_ivec3_muladd(const ivec3 a, const ivec3 b, ivec3 dest) {
   dest[0] += a[0] * b[0];
   dest[1] += a[1] * b[1];
   dest[2] += a[2] * b[2];
@@ -394,9 +394,9 @@ glm_ivec3_muladd(ivec3 a, ivec3 b, ivec3 dest) {
  * @param[in]  s    scalar
  * @param[out] dest dest += (a * s)
  */
-CGLM_INLINE 
-void 
-glm_ivec3_muladds(ivec3 a, int s, ivec3 dest) {
+CGLM_INLINE
+void
+glm_ivec3_muladds(const ivec3 a, int s, ivec3 dest) {
   dest[0] += a[0] * s;
   dest[1] += a[1] * s;
   dest[2] += a[2] * s;
@@ -411,9 +411,9 @@ glm_ivec3_muladds(ivec3 a, int s, ivec3 dest) {
  * @param[in]  b    second vector
  * @param[out] dest dest += max(a, b)
  */
-CGLM_INLINE 
-void 
-glm_ivec3_maxadd(ivec3 a, ivec3 b, ivec3 dest) {
+CGLM_INLINE
+void
+glm_ivec3_maxadd(const ivec3 a, const ivec3 b, ivec3 dest) {
   dest[0] += glm_imax(a[0], b[0]);
   dest[1] += glm_imax(a[1], b[1]);
   dest[2] += glm_imax(a[2], b[2]);
@@ -428,9 +428,9 @@ glm_ivec3_maxadd(ivec3 a, ivec3 b, ivec3 dest) {
  * @param[in]  b    second vector
  * @param[out] dest dest += min(a, b)
  */
-CGLM_INLINE 
-void 
-glm_ivec3_minadd(ivec3 a, ivec3 b, ivec3 dest) {
+CGLM_INLINE
+void
+glm_ivec3_minadd(const ivec3 a, const ivec3 b, ivec3 dest) {
   dest[0] += glm_imin(a[0], b[0]);
   dest[1] += glm_imin(a[1], b[1]);
   dest[2] += glm_imin(a[2], b[2]);
@@ -445,9 +445,9 @@ glm_ivec3_minadd(ivec3 a, ivec3 b, ivec3 dest) {
  * @param[in]  b    second vector
  * @param[out] dest dest -= (a - b)
  */
-CGLM_INLINE 
-void 
-glm_ivec3_subsub(ivec3 a, ivec3 b, ivec3 dest) {
+CGLM_INLINE
+void
+glm_ivec3_subsub(const ivec3 a, const ivec3 b, ivec3 dest) {
   dest[0] -= a[0] - b[0];
   dest[1] -= a[1] - b[1];
   dest[2] -= a[2] - b[2];
@@ -462,9 +462,9 @@ glm_ivec3_subsub(ivec3 a, ivec3 b, ivec3 dest) {
  * @param[in]  s    scalar
  * @param[out] dest dest -= (a - s)
  */
-CGLM_INLINE 
-void 
-glm_ivec3_subsubs(ivec3 a, int s, ivec3 dest) {
+CGLM_INLINE
+void
+glm_ivec3_subsubs(const ivec3 a, int s, ivec3 dest) {
   dest[0] -= a[0] - s;
   dest[1] -= a[1] - s;
   dest[2] -= a[2] - s;
@@ -479,9 +479,9 @@ glm_ivec3_subsubs(ivec3 a, int s, ivec3 dest) {
  * @param[in]  b    scalar
  * @param[out] dest dest -= (a + b)
  */
-CGLM_INLINE 
-void 
-glm_ivec3_addsub(ivec3 a, ivec3 b, ivec3 dest) {
+CGLM_INLINE
+void
+glm_ivec3_addsub(const ivec3 a, const ivec3 b, ivec3 dest) {
   dest[0] -= a[0] + b[0];
   dest[1] -= a[1] + b[1];
   dest[2] -= a[2] + b[2];
@@ -496,9 +496,9 @@ glm_ivec3_addsub(ivec3 a, ivec3 b, ivec3 dest) {
  * @param[in]  s    scalar
  * @param[out] dest dest -= (a + b)
  */
-CGLM_INLINE 
-void 
-glm_ivec3_addsubs(ivec3 a, int s, ivec3 dest) {
+CGLM_INLINE
+void
+glm_ivec3_addsubs(const ivec3 a, int s, ivec3 dest) {
   dest[0] -= a[0] + s;
   dest[1] -= a[1] + s;
   dest[2] -= a[2] + s;
@@ -513,9 +513,9 @@ glm_ivec3_addsubs(ivec3 a, int s, ivec3 dest) {
  * @param[in]  b    scalar
  * @param[out] dest dest -= (a * b)
  */
-CGLM_INLINE 
-void 
-glm_ivec3_mulsub(ivec3 a, ivec3 b, ivec3 dest) {
+CGLM_INLINE
+void
+glm_ivec3_mulsub(const ivec3 a, const ivec3 b, ivec3 dest) {
   dest[0] -= a[0] * b[0];
   dest[1] -= a[1] * b[1];
   dest[2] -= a[2] * b[2];
@@ -530,9 +530,9 @@ glm_ivec3_mulsub(ivec3 a, ivec3 b, ivec3 dest) {
  * @param[in]  s    scalar
  * @param[out] dest dest -= (a * s)
  */
-CGLM_INLINE 
-void 
-glm_ivec3_mulsubs(ivec3 a, int s, ivec3 dest) {
+CGLM_INLINE
+void
+glm_ivec3_mulsubs(const ivec3 a, int s, ivec3 dest) {
   dest[0] -= a[0] * s;
   dest[1] -= a[1] * s;
   dest[2] -= a[2] * s;
@@ -547,9 +547,9 @@ glm_ivec3_mulsubs(ivec3 a, int s, ivec3 dest) {
  * @param[in]  b    second vector
  * @param[out] dest dest -= max(a, b)
  */
-CGLM_INLINE 
-void 
-glm_ivec3_maxsub(ivec3 a, ivec3 b, ivec3 dest) {
+CGLM_INLINE
+void
+glm_ivec3_maxsub(const ivec3 a, const ivec3 b, ivec3 dest) {
   dest[0] -= glm_imax(a[0], b[0]);
   dest[1] -= glm_imax(a[1], b[1]);
   dest[2] -= glm_imax(a[2], b[2]);
@@ -564,9 +564,9 @@ glm_ivec3_maxsub(ivec3 a, ivec3 b, ivec3 dest) {
  * @param[in]  b    second vector
  * @param[out] dest dest -= min(a, b)
  */
-CGLM_INLINE 
-void 
-glm_ivec3_minsub(ivec3 a, ivec3 b, ivec3 dest) {
+CGLM_INLINE
+void
+glm_ivec3_minsub(const ivec3 a, const ivec3 b, ivec3 dest) {
   dest[0] -= glm_imin(a[0], b[0]);
   dest[1] -= glm_imin(a[1], b[1]);
   dest[2] -= glm_imin(a[2], b[2]);
@@ -581,7 +581,7 @@ glm_ivec3_minsub(ivec3 a, ivec3 b, ivec3 dest) {
  */
 CGLM_INLINE
 int
-glm_ivec3_distance2(ivec3 a, ivec3 b) {
+glm_ivec3_distance2(const ivec3 a, const ivec3 b) {
   int xd, yd, zd;
   xd = a[0] - b[0];
   yd = a[1] - b[1];
@@ -598,7 +598,7 @@ glm_ivec3_distance2(ivec3 a, ivec3 b) {
  */
 CGLM_INLINE
 float
-glm_ivec3_distance(ivec3 a, ivec3 b) {
+glm_ivec3_distance(const ivec3 a, const ivec3 b) {
   return sqrtf((float)glm_ivec3_distance2(a, b));
 }
 
@@ -622,7 +622,7 @@ glm_ivec3_fill(ivec3 v, int val) {
  */
 CGLM_INLINE
 bool
-glm_ivec3_eq(ivec3 v, int val) {
+glm_ivec3_eq(const ivec3 v, int val) {
   return v[0] == val && v[0] == v[1] && v[0] == v[2];
 }
 
@@ -634,7 +634,7 @@ glm_ivec3_eq(ivec3 v, int val) {
  */
 CGLM_INLINE
 bool
-glm_ivec3_eqv(ivec3 a, ivec3 b) {
+glm_ivec3_eqv(const ivec3 a, const ivec3 b) {
   return a[0] == b[0]
          && a[1] == b[1]
          && a[2] == b[2];
@@ -649,7 +649,7 @@ glm_ivec3_eqv(ivec3 a, ivec3 b) {
  */
 CGLM_INLINE
 void
-glm_ivec3_maxv(ivec3 a, ivec3 b, ivec3 dest) {
+glm_ivec3_maxv(const ivec3 a, const ivec3 b, ivec3 dest) {
   dest[0] = a[0] > b[0] ? a[0] : b[0];
   dest[1] = a[1] > b[1] ? a[1] : b[1];
   dest[2] = a[2] > b[2] ? a[2] : b[2];
@@ -664,7 +664,7 @@ glm_ivec3_maxv(ivec3 a, ivec3 b, ivec3 dest) {
  */
 CGLM_INLINE
 void
-glm_ivec3_minv(ivec3 a, ivec3 b, ivec3 dest) {
+glm_ivec3_minv(const ivec3 a, const ivec3 b, ivec3 dest) {
   dest[0] = a[0] < b[0] ? a[0] : b[0];
   dest[1] = a[1] < b[1] ? a[1] : b[1];
   dest[2] = a[2] < b[2] ? a[2] : b[2];
@@ -704,7 +704,7 @@ glm_ivec3_clamp(ivec3 v, int minVal, int maxVal) {
  */
 CGLM_INLINE
 void
-glm_ivec3_abs(ivec3 v, ivec3 dest) {
+glm_ivec3_abs(const ivec3 v, ivec3 dest) {
   dest[0] = abs(v[0]);
   dest[1] = abs(v[1]);
   dest[2] = abs(v[2]);
diff --git a/include/cglm/ivec4.h b/include/cglm/ivec4.h
index 6357599e2..c8f4a1283 100644
--- a/include/cglm/ivec4.h
+++ b/include/cglm/ivec4.h
@@ -13,38 +13,38 @@
    GLM_IVEC4_ZERO
 
  Functions:
-  CGLM_INLINE void glm_ivec4(ivec3 v3, int last, ivec4 dest)
-  CGLM_INLINE void glm_ivec4_copy(ivec4 a, ivec4 dest)
+  CGLM_INLINE void glm_ivec4(const ivec3 v3, int last, ivec4 dest)
+  CGLM_INLINE void glm_ivec4_copy(const ivec4 a, ivec4 dest)
   CGLM_INLINE void glm_ivec4_zero(ivec4 v)
   CGLM_INLINE void glm_ivec4_one(ivec4 v)
-  CGLM_INLINE void glm_ivec4_add(ivec4 a, ivec4 b, ivec4 dest)
-  CGLM_INLINE void glm_ivec4_adds(ivec4 v, int s, ivec4 dest)
-  CGLM_INLINE void glm_ivec4_sub(ivec4 a, ivec4 b, ivec4 dest)
-  CGLM_INLINE void glm_ivec4_subs(ivec4 v, int s, ivec4 dest)
-  CGLM_INLINE void glm_ivec4_mul(ivec4 a, ivec4 b, ivec4 dest)
-  CGLM_INLINE void glm_ivec4_scale(ivec4 v, int s, ivec4 dest)
-  CGLM_INLINE void glm_ivec4_addadd(ivec4 a, ivec4 b, ivec4 dest)
-  CGLM_INLINE void glm_ivec4_addadds(ivec4 a, int s, ivec4 dest)
-  CGLM_INLINE void glm_ivec4_subadd(ivec4 a, ivec4 b, ivec4 dest)
-  CGLM_INLINE void glm_ivec4_subadds(ivec4 a, int s, ivec4 dest)
-  CGLM_INLINE void glm_ivec4_muladd(ivec4 a, ivec4 b, ivec4 dest)
-  CGLM_INLINE void glm_ivec4_muladds(ivec4 a, int s, ivec4 dest)
-  CGLM_INLINE void glm_ivec4_maxadd(ivec4 a, ivec4 b, ivec4 dest)
-  CGLM_INLINE void glm_ivec4_minadd(ivec4 a, ivec4 b, ivec4 dest)
-  CGLM_INLINE void glm_ivec4_subsub(ivec4 a, ivec4 b, ivec4 dest)
-  CGLM_INLINE void glm_ivec4_subsubs(ivec4 a, int s, ivec4 dest)
-  CGLM_INLINE void glm_ivec4_addsub(ivec4 a, ivec4 b, ivec4 dest)
-  CGLM_INLINE void glm_ivec4_addsubs(ivec4 a, int s, ivec4 dest)
-  CGLM_INLINE void glm_ivec4_mulsub(ivec4 a, ivec4 b, ivec4 dest)
-  CGLM_INLINE void glm_ivec4_mulsubs(ivec4 a, int s, ivec4 dest)
-  CGLM_INLINE void glm_ivec4_maxsub(ivec4 a, ivec4 b, ivec4 dest)
-  CGLM_INLINE void glm_ivec4_minsub(ivec4 a, ivec4 b, ivec4 dest)
-  CGLM_INLINE int glm_ivec4_distance2(ivec4 a, ivec4 b)
-  CGLM_INLINE float glm_ivec4_distance(ivec4 a, ivec4 b)
-  CGLM_INLINE void glm_ivec4_maxv(ivec4 a, ivec4 b, ivec4 dest)
-  CGLM_INLINE void glm_ivec4_minv(ivec4 a, ivec4 b, ivec4 dest)
+  CGLM_INLINE void glm_ivec4_add(const ivec4 a, const ivec4 b, ivec4 dest)
+  CGLM_INLINE void glm_ivec4_adds(const ivec4 v, int s, ivec4 dest)
+  CGLM_INLINE void glm_ivec4_sub(const ivec4 a, const ivec4 b, ivec4 dest)
+  CGLM_INLINE void glm_ivec4_subs(const ivec4 v, int s, ivec4 dest)
+  CGLM_INLINE void glm_ivec4_mul(const ivec4 a, const ivec4 b, ivec4 dest)
+  CGLM_INLINE void glm_ivec4_scale(const ivec4 v, int s, ivec4 dest)
+  CGLM_INLINE void glm_ivec4_addadd(const ivec4 a, const ivec4 b, ivec4 dest)
+  CGLM_INLINE void glm_ivec4_addadds(const ivec4 a, int s, ivec4 dest)
+  CGLM_INLINE void glm_ivec4_subadd(const ivec4 a, const ivec4 b, ivec4 dest)
+  CGLM_INLINE void glm_ivec4_subadds(const ivec4 a, int s, ivec4 dest)
+  CGLM_INLINE void glm_ivec4_muladd(const ivec4 a, const ivec4 b, ivec4 dest)
+  CGLM_INLINE void glm_ivec4_muladds(const ivec4 a, int s, ivec4 dest)
+  CGLM_INLINE void glm_ivec4_maxadd(const ivec4 a, const ivec4 b, ivec4 dest)
+  CGLM_INLINE void glm_ivec4_minadd(const ivec4 a, const ivec4 b, ivec4 dest)
+  CGLM_INLINE void glm_ivec4_subsub(const ivec4 a, const ivec4 b, ivec4 dest)
+  CGLM_INLINE void glm_ivec4_subsubs(const ivec4 a, int s, ivec4 dest)
+  CGLM_INLINE void glm_ivec4_addsub(const ivec4 a, const ivec4 b, ivec4 dest)
+  CGLM_INLINE void glm_ivec4_addsubs(const ivec4 a, int s, ivec4 dest)
+  CGLM_INLINE void glm_ivec4_mulsub(const ivec4 a, const ivec4 b, ivec4 dest)
+  CGLM_INLINE void glm_ivec4_mulsubs(const ivec4 a, int s, ivec4 dest)
+  CGLM_INLINE void glm_ivec4_maxsub(const ivec4 a, const ivec4 b, ivec4 dest)
+  CGLM_INLINE void glm_ivec4_minsub(const ivec4 a, const ivec4 b, ivec4 dest)
+  CGLM_INLINE int glm_ivec4_distance2(const ivec4 a, const ivec4 b)
+  CGLM_INLINE float glm_ivec4_distance(const ivec4 a, const ivec4 b)
+  CGLM_INLINE void glm_ivec4_maxv(const ivec4 a, const ivec4 b, ivec4 dest)
+  CGLM_INLINE void glm_ivec4_minv(const ivec4 a, const ivec4 b, ivec4 dest)
   CGLM_INLINE void glm_ivec4_clamp(ivec4 v, int minVal, int maxVal)
-  CGLM_INLINE void glm_ivec4_abs(ivec4 v, ivec4 dest)
+  CGLM_INLINE void glm_ivec4_abs(const ivec4 v, ivec4 dest)
  */
 
 #ifndef cglm_ivec4_h
@@ -68,7 +68,7 @@
  */
 CGLM_INLINE
 void
-glm_ivec4(ivec3 v3, int last, ivec4 dest) {
+glm_ivec4(const ivec3 v3, int last, ivec4 dest) {
   dest[0] = v3[0];
   dest[1] = v3[1];
   dest[2] = v3[2];
@@ -83,7 +83,7 @@ glm_ivec4(ivec3 v3, int last, ivec4 dest) {
  */
 CGLM_INLINE
 void
-glm_ivec4_copy(ivec4 a, ivec4 dest) {
+glm_ivec4_copy(const ivec4 a, ivec4 dest) {
   dest[0] = a[0];
   dest[1] = a[1];
   dest[2] = a[2];
@@ -96,7 +96,7 @@ glm_ivec4_copy(ivec4 a, ivec4 dest) {
  * @param[out] v vector
  */
 CGLM_INLINE
-void 
+void
 glm_ivec4_zero(ivec4 v) {
   v[0] = v[1] = v[2] = v[3] = 0;
 }
@@ -121,7 +121,7 @@ glm_ivec4_one(ivec4 v) {
  */
 CGLM_INLINE
 void
-glm_ivec4_add(ivec4 a, ivec4 b, ivec4 dest) {
+glm_ivec4_add(const ivec4 a, const ivec4 b, ivec4 dest) {
   dest[0] = a[0] + b[0];
   dest[1] = a[1] + b[1];
   dest[2] = a[2] + b[2];
@@ -137,7 +137,7 @@ glm_ivec4_add(ivec4 a, ivec4 b, ivec4 dest) {
  */
 CGLM_INLINE
 void
-glm_ivec4_adds(ivec4 v, int s, ivec4 dest) {
+glm_ivec4_adds(const ivec4 v, int s, ivec4 dest) {
   dest[0] = v[0] + s;
   dest[1] = v[1] + s;
   dest[2] = v[2] + s;
@@ -153,7 +153,7 @@ glm_ivec4_adds(ivec4 v, int s, ivec4 dest) {
  */
 CGLM_INLINE
 void
-glm_ivec4_sub(ivec4 a, ivec4 b, ivec4 dest) {
+glm_ivec4_sub(const ivec4 a, const ivec4 b, ivec4 dest) {
   dest[0] = a[0] - b[0];
   dest[1] = a[1] - b[1];
   dest[2] = a[2] - b[2];
@@ -169,7 +169,7 @@ glm_ivec4_sub(ivec4 a, ivec4 b, ivec4 dest) {
  */
 CGLM_INLINE
 void
-glm_ivec4_subs(ivec4 v, int s, ivec4 dest) {
+glm_ivec4_subs(const ivec4 v, int s, ivec4 dest) {
   dest[0] = v[0] - s;
   dest[1] = v[1] - s;
   dest[2] = v[2] - s;
@@ -185,7 +185,7 @@ glm_ivec4_subs(ivec4 v, int s, ivec4 dest) {
  */
 CGLM_INLINE
 void
-glm_ivec4_mul(ivec4 a, ivec4 b, ivec4 dest) {
+glm_ivec4_mul(const ivec4 a, const ivec4 b, ivec4 dest) {
   dest[0] = a[0] * b[0];
   dest[1] = a[1] * b[1];
   dest[2] = a[2] * b[2];
@@ -201,7 +201,7 @@ glm_ivec4_mul(ivec4 a, ivec4 b, ivec4 dest) {
  */
 CGLM_INLINE
 void
-glm_ivec4_scale(ivec4 v, int s, ivec4 dest) {
+glm_ivec4_scale(const ivec4 v, int s, ivec4 dest) {
   dest[0] = v[0] * s;
   dest[1] = v[1] * s;
   dest[2] = v[2] * s;
@@ -217,9 +217,9 @@ glm_ivec4_scale(ivec4 v, int s, ivec4 dest) {
  * @param[in]  b    second vector
  * @param[out] dest dest += (a + b)
  */
-CGLM_INLINE 
-void 
-glm_ivec4_addadd(ivec4 a, ivec4 b, ivec4 dest) {
+CGLM_INLINE
+void
+glm_ivec4_addadd(const ivec4 a, const ivec4 b, ivec4 dest) {
   dest[0] += a[0] + b[0];
   dest[1] += a[1] + b[1];
   dest[2] += a[2] + b[2];
@@ -235,9 +235,9 @@ glm_ivec4_addadd(ivec4 a, ivec4 b, ivec4 dest) {
  * @param[in]  s    scalar
  * @param[out] dest dest += (a + s)
  */
-CGLM_INLINE 
-void 
-glm_ivec4_addadds(ivec4 a, int s, ivec4 dest) {
+CGLM_INLINE
+void
+glm_ivec4_addadds(const ivec4 a, int s, ivec4 dest) {
   dest[0] += a[0] + s;
   dest[1] += a[1] + s;
   dest[2] += a[2] + s;
@@ -251,11 +251,11 @@ glm_ivec4_addadds(ivec4 a, int s, ivec4 dest) {
  *
  * @param[in]  a    first vector
  * @param[in]  b    second vector
- * @param[out] dest dest += (a - b)  
+ * @param[out] dest dest += (a - b)
  */
-CGLM_INLINE 
-void 
-glm_ivec4_subadd(ivec4 a, ivec4 b, ivec4 dest) {
+CGLM_INLINE
+void
+glm_ivec4_subadd(const ivec4 a, const ivec4 b, ivec4 dest) {
   dest[0] += a[0] - b[0];
   dest[1] += a[1] - b[1];
   dest[2] += a[2] - b[2];
@@ -271,9 +271,9 @@ glm_ivec4_subadd(ivec4 a, ivec4 b, ivec4 dest) {
  * @param[in]  s    scalar
  * @param[out] dest dest += (a - s)
  */
-CGLM_INLINE 
-void 
-glm_ivec4_subadds(ivec4 a, int s, ivec4 dest) {
+CGLM_INLINE
+void
+glm_ivec4_subadds(const ivec4 a, int s, ivec4 dest) {
   dest[0] += a[0] - s;
   dest[1] += a[1] - s;
   dest[2] += a[2] - s;
@@ -289,9 +289,9 @@ glm_ivec4_subadds(ivec4 a, int s, ivec4 dest) {
  * @param[in]  b    second vector
  * @param[out] dest dest += (a * b)
  */
-CGLM_INLINE 
-void 
-glm_ivec4_muladd(ivec4 a, ivec4 b, ivec4 dest) {
+CGLM_INLINE
+void
+glm_ivec4_muladd(const ivec4 a, const ivec4 b, ivec4 dest) {
   dest[0] += a[0] * b[0];
   dest[1] += a[1] * b[1];
   dest[2] += a[2] * b[2];
@@ -307,9 +307,9 @@ glm_ivec4_muladd(ivec4 a, ivec4 b, ivec4 dest) {
  * @param[in]  s    scalar
  * @param[out] dest dest += (a * s)
  */
-CGLM_INLINE 
-void 
-glm_ivec4_muladds(ivec4 a, int s, ivec4 dest) {
+CGLM_INLINE
+void
+glm_ivec4_muladds(const ivec4 a, int s, ivec4 dest) {
   dest[0] += a[0] * s;
   dest[1] += a[1] * s;
   dest[2] += a[2] * s;
@@ -325,9 +325,9 @@ glm_ivec4_muladds(ivec4 a, int s, ivec4 dest) {
  * @param[in]  b    second vector
  * @param[out] dest dest += max(a, b)
  */
-CGLM_INLINE 
-void 
-glm_ivec4_maxadd(ivec4 a, ivec4 b, ivec4 dest) {
+CGLM_INLINE
+void
+glm_ivec4_maxadd(const ivec4 a, const ivec4 b, ivec4 dest) {
   dest[0] += glm_imax(a[0], b[0]);
   dest[1] += glm_imax(a[1], b[1]);
   dest[2] += glm_imax(a[2], b[2]);
@@ -343,9 +343,9 @@ glm_ivec4_maxadd(ivec4 a, ivec4 b, ivec4 dest) {
  * @param[in]  b    second vector
  * @param[out] dest dest += min(a, b)
  */
-CGLM_INLINE 
-void 
-glm_ivec4_minadd(ivec4 a, ivec4 b, ivec4 dest) {
+CGLM_INLINE
+void
+glm_ivec4_minadd(const ivec4 a, const ivec4 b, ivec4 dest) {
   dest[0] += glm_imin(a[0], b[0]);
   dest[1] += glm_imin(a[1], b[1]);
   dest[2] += glm_imin(a[2], b[2]);
@@ -361,9 +361,9 @@ glm_ivec4_minadd(ivec4 a, ivec4 b, ivec4 dest) {
  * @param[in]  b    second vector
  * @param[out] dest dest -= (a - b)
  */
-CGLM_INLINE 
-void 
-glm_ivec4_subsub(ivec4 a, ivec4 b, ivec4 dest) {
+CGLM_INLINE
+void
+glm_ivec4_subsub(const ivec4 a, const ivec4 b, ivec4 dest) {
   dest[0] -= a[0] - b[0];
   dest[1] -= a[1] - b[1];
   dest[2] -= a[2] - b[2];
@@ -379,9 +379,9 @@ glm_ivec4_subsub(ivec4 a, ivec4 b, ivec4 dest) {
  * @param[in]  s    scalar
  * @param[out] dest dest -= (a - s)
  */
-CGLM_INLINE 
-void 
-glm_ivec4_subsubs(ivec4 a, int s, ivec4 dest) {
+CGLM_INLINE
+void
+glm_ivec4_subsubs(const ivec4 a, int s, ivec4 dest) {
   dest[0] -= a[0] - s;
   dest[1] -= a[1] - s;
   dest[2] -= a[2] - s;
@@ -397,9 +397,9 @@ glm_ivec4_subsubs(ivec4 a, int s, ivec4 dest) {
  * @param[in]  b    scalar
  * @param[out] dest dest -= (a + b)
  */
-CGLM_INLINE 
-void 
-glm_ivec4_addsub(ivec4 a, ivec4 b, ivec4 dest) {
+CGLM_INLINE
+void
+glm_ivec4_addsub(const ivec4 a, const ivec4 b, ivec4 dest) {
   dest[0] -= a[0] + b[0];
   dest[1] -= a[1] + b[1];
   dest[2] -= a[2] + b[2];
@@ -415,9 +415,9 @@ glm_ivec4_addsub(ivec4 a, ivec4 b, ivec4 dest) {
  * @param[in]  s    scalar
  * @param[out] dest dest -= (a + b)
  */
-CGLM_INLINE 
-void 
-glm_ivec4_addsubs(ivec4 a, int s, ivec4 dest) {
+CGLM_INLINE
+void
+glm_ivec4_addsubs(const ivec4 a, int s, ivec4 dest) {
   dest[0] -= a[0] + s;
   dest[1] -= a[1] + s;
   dest[2] -= a[2] + s;
@@ -433,9 +433,9 @@ glm_ivec4_addsubs(ivec4 a, int s, ivec4 dest) {
  * @param[in]  b    scalar
  * @param[out] dest dest -= (a * b)
  */
-CGLM_INLINE 
-void 
-glm_ivec4_mulsub(ivec4 a, ivec4 b, ivec4 dest) {
+CGLM_INLINE
+void
+glm_ivec4_mulsub(const ivec4 a, const ivec4 b, ivec4 dest) {
   dest[0] -= a[0] * b[0];
   dest[1] -= a[1] * b[1];
   dest[2] -= a[2] * b[2];
@@ -451,9 +451,9 @@ glm_ivec4_mulsub(ivec4 a, ivec4 b, ivec4 dest) {
  * @param[in]  s    scalar
  * @param[out] dest dest -= (a * s)
  */
-CGLM_INLINE 
-void 
-glm_ivec4_mulsubs(ivec4 a, int s, ivec4 dest) {
+CGLM_INLINE
+void
+glm_ivec4_mulsubs(const ivec4 a, int s, ivec4 dest) {
   dest[0] -= a[0] * s;
   dest[1] -= a[1] * s;
   dest[2] -= a[2] * s;
@@ -469,9 +469,9 @@ glm_ivec4_mulsubs(ivec4 a, int s, ivec4 dest) {
  * @param[in]  b    second vector
  * @param[out] dest dest -= max(a, b)
  */
-CGLM_INLINE 
-void 
-glm_ivec4_maxsub(ivec4 a, ivec4 b, ivec4 dest) {
+CGLM_INLINE
+void
+glm_ivec4_maxsub(const ivec4 a, const ivec4 b, ivec4 dest) {
   dest[0] -= glm_imax(a[0], b[0]);
   dest[1] -= glm_imax(a[1], b[1]);
   dest[2] -= glm_imax(a[2], b[2]);
@@ -487,9 +487,9 @@ glm_ivec4_maxsub(ivec4 a, ivec4 b, ivec4 dest) {
  * @param[in]  b    second vector
  * @param[out] dest dest -= min(a, b)
  */
-CGLM_INLINE 
-void 
-glm_ivec4_minsub(ivec4 a, ivec4 b, ivec4 dest) {
+CGLM_INLINE
+void
+glm_ivec4_minsub(const ivec4 a, const ivec4 b, ivec4 dest) {
   dest[0] -= glm_imin(a[0], b[0]);
   dest[1] -= glm_imin(a[1], b[1]);
   dest[2] -= glm_imin(a[2], b[2]);
@@ -505,7 +505,7 @@ glm_ivec4_minsub(ivec4 a, ivec4 b, ivec4 dest) {
  */
 CGLM_INLINE
 int
-glm_ivec4_distance2(ivec4 a, ivec4 b) {
+glm_ivec4_distance2(const ivec4 a, const ivec4 b) {
   int xd, yd, zd, wd;
   xd = a[0] - b[0];
   yd = a[1] - b[1];
@@ -523,7 +523,7 @@ glm_ivec4_distance2(ivec4 a, ivec4 b) {
  */
 CGLM_INLINE
 float
-glm_ivec4_distance(ivec4 a, ivec4 b) {
+glm_ivec4_distance(const ivec4 a, const ivec4 b) {
   return sqrtf((float)glm_ivec4_distance2(a, b));
 }
 
@@ -536,7 +536,7 @@ glm_ivec4_distance(ivec4 a, ivec4 b) {
  */
 CGLM_INLINE
 void
-glm_ivec4_maxv(ivec4 a, ivec4 b, ivec4 dest) {
+glm_ivec4_maxv(const ivec4 a, const ivec4 b, ivec4 dest) {
   dest[0] = a[0] > b[0] ? a[0] : b[0];
   dest[1] = a[1] > b[1] ? a[1] : b[1];
   dest[2] = a[2] > b[2] ? a[2] : b[2];
@@ -552,7 +552,7 @@ glm_ivec4_maxv(ivec4 a, ivec4 b, ivec4 dest) {
  */
 CGLM_INLINE
 void
-glm_ivec4_minv(ivec4 a, ivec4 b, ivec4 dest) {
+glm_ivec4_minv(const ivec4 a, const ivec4 b, ivec4 dest) {
   dest[0] = a[0] < b[0] ? a[0] : b[0];
   dest[1] = a[1] < b[1] ? a[1] : b[1];
   dest[2] = a[2] < b[2] ? a[2] : b[2];
@@ -598,7 +598,7 @@ glm_ivec4_clamp(ivec4 v, int minVal, int maxVal) {
  */
 CGLM_INLINE
 void
-glm_ivec4_abs(ivec4 v, ivec4 dest) {
+glm_ivec4_abs(const ivec4 v, ivec4 dest) {
   dest[0] = abs(v[0]);
   dest[1] = abs(v[1]);
   dest[2] = abs(v[2]);
diff --git a/include/cglm/mat2.h b/include/cglm/mat2.h
index 9248460e1..19f608936 100644
--- a/include/cglm/mat2.h
+++ b/include/cglm/mat2.h
@@ -13,22 +13,22 @@
    GLM_MAT2_ZERO
 
  Functions:
-   CGLM_INLINE void  glm_mat2_make(float * restrict src, mat2 dest)
-   CGLM_INLINE void  glm_mat2_copy(mat2 mat, mat2 dest)
+   CGLM_INLINE void  glm_mat2_make(const float * restrict src, mat2 dest)
+   CGLM_INLINE void  glm_mat2_copy(CGLM_IN(mat2) mat, mat2 dest)
    CGLM_INLINE void  glm_mat2_identity(mat2 m)
    CGLM_INLINE void  glm_mat2_identity_array(mat2 * restrict mats, size_t count)
    CGLM_INLINE void  glm_mat2_zero(mat2 m)
-   CGLM_INLINE void  glm_mat2_mul(mat2 m1, mat2 m2, mat2 dest)
-   CGLM_INLINE void  glm_mat2_mulv(mat2 m, vec2 v, vec2 dest)
-   CGLM_INLINE void  glm_mat2_transpose_to(mat2 mat, mat2 dest)
+   CGLM_INLINE void  glm_mat2_mul(CGLM_IN(mat2) m1, CGLM_IN(mat2) m2, mat2 dest)
+   CGLM_INLINE void  glm_mat2_mulv(CGLM_IN(mat2) m, const vec2 v, vec2 dest)
+   CGLM_INLINE void  glm_mat2_transpose_to(CGLM_IN(mat2) mat, mat2 dest)
    CGLM_INLINE void  glm_mat2_transpose(mat2 m)
    CGLM_INLINE void  glm_mat2_scale(mat2 m, float s)
-   CGLM_INLINE void  glm_mat2_inv(mat2 mat, mat2 dest)
+   CGLM_INLINE void  glm_mat2_inv(CGLM_IN(mat2) mat, mat2 dest)
    CGLM_INLINE void  glm_mat2_swap_col(mat2 mat, int col1, int col2)
    CGLM_INLINE void  glm_mat2_swap_row(mat2 mat, int row1, int row2)
-   CGLM_INLINE float glm_mat2_det(mat2 m)
-   CGLM_INLINE float glm_mat2_trace(mat2 m)
-   CGLM_INLINE float glm_mat2_rmc(vec2 r, mat2 m, vec2 c)
+   CGLM_INLINE float glm_mat2_det(CGLM_IN(mat2) m)
+   CGLM_INLINE float glm_mat2_trace(CGLM_IN(mat2) m)
+   CGLM_INLINE float glm_mat2_rmc(const vec2 r, CGLM_IN(mat2) m, const vec2 c)
  */
 
 #ifndef cglm_mat2_h
@@ -79,7 +79,7 @@ glm_mat2_make(const float * __restrict src, mat2 dest) {
  */
 CGLM_INLINE
 void
-glm_mat2_copy(mat2 mat, mat2 dest) {
+glm_mat2_copy(CGLM_IN(mat2) mat, mat2 dest) {
   glm_vec4_ucopy(mat[0], dest[0]);
 }
 
@@ -94,7 +94,7 @@ glm_mat2_copy(mat2 mat, mat2 dest) {
  * glm_mat2_copy(GLM_MAT2_IDENTITY, mat); // C only
  *
  * // or
- * mat2 mat = GLM_MAT2_IDENTITY_INIT;
+ * CGLM_IN(mat2) mat = GLM_MAT2_IDENTITY_INIT;
  * @endcode
  *
  * @param[in, out] m mat2 (src, dest)
@@ -138,10 +138,10 @@ glm_mat2_zero(mat2 m) {
 /*!
  * @brief Multiply mat2 (m1) by mat2 (m2) and store in mat2 (dest).
  *
- *        m1, m2 and dest matrices can be same matrix, it is possible to write this: 
+ *        m1, m2 and dest matrices can be same matrix, it is possible to write this:
  *
  * @code
- * mat2 m = GLM_MAT2_IDENTITY_INIT;
+ * CGLM_IN(mat2) m = GLM_MAT2_IDENTITY_INIT;
  * glm_mat2_mul(m, m, m);
  * @endcode
  *
@@ -151,7 +151,7 @@ glm_mat2_zero(mat2 m) {
  */
 CGLM_INLINE
 void
-glm_mat2_mul(mat2 m1, mat2 m2, mat2 dest) {
+glm_mat2_mul(CGLM_IN(mat2) m1, CGLM_IN(mat2) m2, mat2 dest) {
 #if defined(__wasm__) && defined(__wasm_simd128__)
   glm_mat2_mul_wasm(m1, m2, dest);
 #elif defined( __SSE__ ) || defined( __SSE2__ )
@@ -180,7 +180,7 @@ glm_mat2_mul(mat2 m1, mat2 m2, mat2 dest) {
  */
 CGLM_INLINE
 void
-glm_mat2_mulv(mat2 m, vec2 v, vec2 dest) {
+glm_mat2_mulv(CGLM_IN(mat2) m, const vec2 v, vec2 dest) {
   dest[0] = m[0][0] * v[0] + m[1][0] * v[1];
   dest[1] = m[0][1] * v[0] + m[1][1] * v[1];
 }
@@ -193,7 +193,7 @@ glm_mat2_mulv(mat2 m, vec2 v, vec2 dest) {
  */
 CGLM_INLINE
 void
-glm_mat2_transpose_to(mat2 mat, mat2 dest) {
+glm_mat2_transpose_to(CGLM_IN(mat2) mat, mat2 dest) {
 #if defined(__wasm__) && defined(__wasm_simd128__)
   glm_mat2_transp_wasm(mat, dest);
 #elif defined( __SSE__ ) || defined( __SSE2__ )
@@ -252,7 +252,7 @@ glm_mat2_scale(mat2 m, float s) {
  */
 CGLM_INLINE
 void
-glm_mat2_inv(mat2 mat, mat2 dest) {
+glm_mat2_inv(CGLM_IN(mat2) mat, mat2 dest) {
   float det;
   float a = mat[0][0], b = mat[0][1],
         c = mat[1][0], d = mat[1][1];
@@ -318,7 +318,7 @@ glm_mat2_swap_row(mat2 mat, int row1, int row2) {
  */
 CGLM_INLINE
 float
-glm_mat2_det(mat2 m) {
+glm_mat2_det(CGLM_IN(mat2) m) {
   return m[0][0] * m[1][1] - m[1][0] * m[0][1];
 }
 
@@ -334,7 +334,7 @@ glm_mat2_det(mat2 m) {
  */
 CGLM_INLINE
 float
-glm_mat2_trace(mat2 m) {
+glm_mat2_trace(CGLM_IN(mat2) m) {
   return m[0][0] + m[1][1];
 }
 
@@ -354,7 +354,7 @@ glm_mat2_trace(mat2 m) {
  */
 CGLM_INLINE
 float
-glm_mat2_rmc(vec2 r, mat2 m, vec2 c) {
+glm_mat2_rmc(const vec2 r, CGLM_IN(mat2) m, const vec2 c) {
   vec2 tmp;
   glm_mat2_mulv(m, c, tmp);
   return glm_vec2_dot(r, tmp);
diff --git a/include/cglm/mat2x3.h b/include/cglm/mat2x3.h
index 0bb8d7095..02211399d 100644
--- a/include/cglm/mat2x3.h
+++ b/include/cglm/mat2x3.h
@@ -11,12 +11,12 @@
    GLM_MAT2X3_ZERO
 
  Functions:
-   CGLM_INLINE void glm_mat2x3_copy(mat2x3 src, mat2x3 dest);
+   CGLM_INLINE void glm_mat2x3_copy(CGLM_IN(mat2x3) src, mat2x3 dest);
    CGLM_INLINE void glm_mat2x3_zero(mat2x3 m);
    CGLM_INLINE void glm_mat2x3_make(const float * __restrict src, mat2x3 dest);
-   CGLM_INLINE void glm_mat2x3_mul(mat2x3 m1, mat3x2 m2, mat3 dest);
-   CGLM_INLINE void glm_mat2x3_mulv(mat2x3 m, vec2 v, vec3 dest);
-   CGLM_INLINE void glm_mat2x3_transpose(mat2x3 src, mat3x2 dest);
+   CGLM_INLINE void glm_mat2x3_mul(CGLM_IN(mat2x3) m1, CGLM_IN(mat3x2) m2, mat3 dest);
+   CGLM_INLINE void glm_mat2x3_mulv(CGLM_IN(mat2x3) m, const vec2 v, vec3 dest);
+   CGLM_INLINE void glm_mat2x3_transpose(CGLM_IN(mat2x3) src, mat3x2 dest);
    CGLM_INLINE void glm_mat2x3_scale(mat2x3 m, float s);
  */
 
@@ -38,7 +38,7 @@
  */
 CGLM_INLINE
 void
-glm_mat2x3_copy(mat2x3 src, mat2x3 dest) {
+glm_mat2x3_copy(CGLM_IN(mat2x3) src, mat2x3 dest) {
   glm_vec3_copy(src[0], dest[0]);
   glm_vec3_copy(src[1], dest[1]);
 }
@@ -86,8 +86,8 @@ glm_mat2x3_make(const float * __restrict src, mat2x3 dest) {
  */
 CGLM_INLINE
 void
-glm_mat2x3_mul(mat2x3 m1, mat3x2 m2, mat3 dest) {
-  float a00 = m1[0][0], a01 = m1[0][1], a02 = m1[0][2], 
+glm_mat2x3_mul(CGLM_IN(mat2x3) m1, CGLM_IN(mat3x2) m2, mat3 dest) {
+  float a00 = m1[0][0], a01 = m1[0][1], a02 = m1[0][2],
         a10 = m1[1][0], a11 = m1[1][1], a12 = m1[1][2],
 
         b00 = m2[0][0], b01 = m2[0][1],
@@ -116,7 +116,7 @@ glm_mat2x3_mul(mat2x3 m1, mat3x2 m2, mat3 dest) {
  */
 CGLM_INLINE
 void
-glm_mat2x3_mulv(mat2x3 m, vec2 v, vec3 dest) {
+glm_mat2x3_mulv(CGLM_IN(mat2x3) m, const vec2 v, vec3 dest) {
   float v0 = v[0], v1 = v[1];
 
   dest[0] = m[0][0] * v0 + m[1][0] * v1;
@@ -132,7 +132,7 @@ glm_mat2x3_mulv(mat2x3 m, vec2 v, vec3 dest) {
  */
 CGLM_INLINE
 void
-glm_mat2x3_transpose(mat2x3 src, mat3x2 dest) {
+glm_mat2x3_transpose(CGLM_IN(mat2x3) src, mat3x2 dest) {
   dest[0][0] = src[0][0];  dest[0][1] = src[1][0];
   dest[1][0] = src[0][1];  dest[1][1] = src[1][1];
   dest[2][0] = src[0][2];  dest[2][1] = src[1][2];
diff --git a/include/cglm/mat2x4.h b/include/cglm/mat2x4.h
index fa9adf3c6..550ca9fe6 100644
--- a/include/cglm/mat2x4.h
+++ b/include/cglm/mat2x4.h
@@ -11,12 +11,12 @@
    GLM_MAT2X4_ZERO
 
  Functions:
-   CGLM_INLINE void glm_mat2x4_copy(mat2x4 src, mat2x4 dest);
+   CGLM_INLINE void glm_mat2x4_copy(CGLM_IN(mat2x4) src, mat2x4 dest);
    CGLM_INLINE void glm_mat2x4_zero(mat2x4 m);
    CGLM_INLINE void glm_mat2x4_make(const float * __restrict src, mat2x4 dest);
-   CGLM_INLINE void glm_mat2x4_mul(mat2x4 m1, mat4x2 m2, mat4 dest);
-   CGLM_INLINE void glm_mat2x4_mulv(mat2x4 m, vec2 v, vec4 dest);
-   CGLM_INLINE void glm_mat2x4_transpose(mat2x4 src, mat4x2 dest);
+   CGLM_INLINE void glm_mat2x4_mul(CGLM_IN(mat2x4) m1, CGLM_IN(mat4x2) m2, mat4 dest);
+   CGLM_INLINE void glm_mat2x4_mulv(CGLM_IN(mat2x4) m, const vec2 v, vec4 dest);
+   CGLM_INLINE void glm_mat2x4_transpose(CGLM_IN(mat2x4) src, mat4x2 dest);
    CGLM_INLINE void glm_mat2x4_scale(mat2x4 m, float s);
  */
 
@@ -39,7 +39,7 @@
  */
 CGLM_INLINE
 void
-glm_mat2x4_copy(mat2x4 src, mat2x4 dest) {
+glm_mat2x4_copy(CGLM_IN(mat2x4) src, mat2x4 dest) {
   glm_vec4_ucopy(src[0], dest[0]);
   glm_vec4_ucopy(src[1], dest[1]);
 }
@@ -89,7 +89,7 @@ glm_mat2x4_make(const float * __restrict src, mat2x4 dest) {
  */
 CGLM_INLINE
 void
-glm_mat2x4_mul(mat2x4 m1, mat4x2 m2, mat4 dest) {
+glm_mat2x4_mul(CGLM_IN(mat2x4) m1, CGLM_IN(mat4x2) m2, mat4 dest) {
   float a00 = m1[0][0], a01 = m1[0][1], a02 = m1[0][2], a03 = m1[0][3],
         a10 = m1[1][0], a11 = m1[1][1], a12 = m1[1][2], a13 = m1[1][3],
 
@@ -128,7 +128,7 @@ glm_mat2x4_mul(mat2x4 m1, mat4x2 m2, mat4 dest) {
  */
 CGLM_INLINE
 void
-glm_mat2x4_mulv(mat2x4 m, vec2 v, vec4 dest) {
+glm_mat2x4_mulv(CGLM_IN(mat2x4) m, const vec2 v, vec4 dest) {
   float v0 = v[0], v1 = v[1];
 
   dest[0] = m[0][0] * v0 + m[1][0] * v1;
@@ -145,7 +145,7 @@ glm_mat2x4_mulv(mat2x4 m, vec2 v, vec4 dest) {
  */
 CGLM_INLINE
 void
-glm_mat2x4_transpose(mat2x4 src, mat4x2 dest) {
+glm_mat2x4_transpose(CGLM_IN(mat2x4) src, mat4x2 dest) {
   dest[0][0] = src[0][0];  dest[0][1] = src[1][0];
   dest[1][0] = src[0][1];  dest[1][1] = src[1][1];
   dest[2][0] = src[0][2];  dest[2][1] = src[1][2];
diff --git a/include/cglm/mat3.h b/include/cglm/mat3.h
index 10b373e49..7aee36073 100644
--- a/include/cglm/mat3.h
+++ b/include/cglm/mat3.h
@@ -14,23 +14,23 @@
    glm_mat3_dup(mat, dest)
 
  Functions:
-   CGLM_INLINE void  glm_mat3_copy(mat3 mat, mat3 dest);
+   CGLM_INLINE void  glm_mat3_copy(CGLM_IN(mat3) mat, mat3 dest);
    CGLM_INLINE void  glm_mat3_identity(mat3 mat);
    CGLM_INLINE void  glm_mat3_identity_array(mat3 * restrict mat, size_t count);
    CGLM_INLINE void  glm_mat3_zero(mat3 mat);
-   CGLM_INLINE void  glm_mat3_mul(mat3 m1, mat3 m2, mat3 dest);
-   CGLM_INLINE void  glm_mat3_transpose_to(mat3 m, mat3 dest);
+   CGLM_INLINE void  glm_mat3_mul(CGLM_IN(mat3) m1, CGLM_IN(mat3) m2, mat3 dest);
+   CGLM_INLINE void  glm_mat3_transpose_to(CGLM_IN(mat3) m, mat3 dest);
    CGLM_INLINE void  glm_mat3_transpose(mat3 m);
-   CGLM_INLINE void  glm_mat3_mulv(mat3 m, vec3 v, vec3 dest);
-   CGLM_INLINE float glm_mat3_trace(mat3 m);
-   CGLM_INLINE void  glm_mat3_quat(mat3 m, versor dest);
+   CGLM_INLINE void  glm_mat3_mulv(CGLM_IN(mat3) m, const vec3 v, vec3 dest);
+   CGLM_INLINE float glm_mat3_trace(CGLM_IN(mat3) m);
+   CGLM_INLINE void  glm_mat3_quat(CGLM_IN(mat3) m, versor dest);
    CGLM_INLINE void  glm_mat3_scale(mat3 m, float s);
-   CGLM_INLINE float glm_mat3_det(mat3 mat);
-   CGLM_INLINE void  glm_mat3_inv(mat3 mat, mat3 dest);
+   CGLM_INLINE float glm_mat3_det(CGLM_IN(mat3) mat);
+   CGLM_INLINE void  glm_mat3_inv(CGLM_IN(mat3) mat, mat3 dest);
    CGLM_INLINE void  glm_mat3_swap_col(mat3 mat, int col1, int col2);
    CGLM_INLINE void  glm_mat3_swap_row(mat3 mat, int row1, int row2);
-   CGLM_INLINE float glm_mat3_rmc(vec3 r, mat3 m, vec3 c);
-   CGLM_INLINE void  glm_mat3_make(float * restrict src, mat3 dest);
+   CGLM_INLINE float glm_mat3_rmc(const vec3 r, CGLM_IN(mat3) m, const vec3 c);
+   CGLM_INLINE void  glm_mat3_make(const float * restrict src, mat3 dest);
    CGLM_INLINE void  glm_mat3_textrans(float sx, float sy, float rot, float tx, float ty, mat3 dest);
  */
 
@@ -71,7 +71,7 @@
  */
 CGLM_INLINE
 void
-glm_mat3_copy(mat3 mat, mat3 dest) {
+glm_mat3_copy(CGLM_IN(mat3) mat, mat3 dest) {
   dest[0][0] = mat[0][0];
   dest[0][1] = mat[0][1];
   dest[0][2] = mat[0][2];
@@ -94,7 +94,7 @@ glm_mat3_copy(mat3 mat, mat3 dest) {
  * glm_mat3_copy(GLM_MAT3_IDENTITY, mat); // C only
  *
  * // or
- * mat3 mat = GLM_MAT3_IDENTITY_INIT;
+ * CGLM_IN(mat3) mat = GLM_MAT3_IDENTITY_INIT;
  * @endcode
  *
  * @param[in, out]  mat  destination
@@ -143,7 +143,7 @@ glm_mat3_zero(mat3 mat) {
  * m1, m2 and dest matrices can be same matrix, it is possible to write this:
  *
  * @code
- * mat3 m = GLM_MAT3_IDENTITY_INIT;
+ * CGLM_IN(mat3) m = GLM_MAT3_IDENTITY_INIT;
  * glm_mat3_mul(m, m, m);
  * @endcode
  *
@@ -153,7 +153,7 @@ glm_mat3_zero(mat3 mat) {
  */
 CGLM_INLINE
 void
-glm_mat3_mul(mat3 m1, mat3 m2, mat3 dest) {
+glm_mat3_mul(CGLM_IN(mat3) m1, CGLM_IN(mat3) m2, mat3 dest) {
 #if defined(__wasm__) && defined(__wasm_simd128__)
   glm_mat3_mul_wasm(m1, m2, dest);
 #elif defined( __SSE__ ) || defined( __SSE2__ )
@@ -189,7 +189,7 @@ glm_mat3_mul(mat3 m1, mat3 m2, mat3 dest) {
  */
 CGLM_INLINE
 void
-glm_mat3_transpose_to(mat3 m, mat3 dest) {
+glm_mat3_transpose_to(CGLM_IN(mat3) m, mat3 dest) {
   dest[0][0] = m[0][0];
   dest[0][1] = m[1][0];
   dest[0][2] = m[2][0];
@@ -235,7 +235,7 @@ glm_mat3_transpose(mat3 m) {
  */
 CGLM_INLINE
 void
-glm_mat3_mulv(mat3 m, vec3 v, vec3 dest) {
+glm_mat3_mulv(CGLM_IN(mat3) m, const vec3 v, vec3 dest) {
   vec3 res;
   res[0] = m[0][0] * v[0] + m[1][0] * v[1] + m[2][0] * v[2];
   res[1] = m[0][1] * v[0] + m[1][1] * v[1] + m[2][1] * v[2];
@@ -252,7 +252,7 @@ glm_mat3_mulv(mat3 m, vec3 v, vec3 dest) {
  */
 CGLM_INLINE
 float
-glm_mat3_trace(mat3 m) {
+glm_mat3_trace(CGLM_IN(mat3) m) {
   return m[0][0] + m[1][1] + m[2][2];
 }
 
@@ -264,7 +264,7 @@ glm_mat3_trace(mat3 m) {
  */
 CGLM_INLINE
 void
-glm_mat3_quat(mat3 m, versor dest) {
+glm_mat3_quat(CGLM_IN(mat3) m, versor dest) {
   float trace, r, rinv;
 
   /* it seems using like m12 instead of m[1][2] causes extra instructions */
@@ -330,7 +330,7 @@ glm_mat3_scale(mat3 m, float s) {
  */
 CGLM_INLINE
 float
-glm_mat3_det(mat3 mat) {
+glm_mat3_det(CGLM_IN(mat3) mat) {
   float a = mat[0][0], b = mat[0][1], c = mat[0][2],
         d = mat[1][0], e = mat[1][1], f = mat[1][2],
         g = mat[2][0], h = mat[2][1], i = mat[2][2];
@@ -346,7 +346,7 @@ glm_mat3_det(mat3 mat) {
  */
 CGLM_INLINE
 void
-glm_mat3_inv(mat3 mat, mat3 dest) {
+glm_mat3_inv(CGLM_IN(mat3) mat, mat3 dest) {
   float a = mat[0][0], b = mat[0][1], c = mat[0][2],
         d = mat[1][0], e = mat[1][1], f = mat[1][2],
         g = mat[2][0], h = mat[2][1], i = mat[2][2],
@@ -421,7 +421,7 @@ glm_mat3_swap_row(mat3 mat, int row1, int row2) {
  */
 CGLM_INLINE
 float
-glm_mat3_rmc(vec3 r, mat3 m, vec3 c) {
+glm_mat3_rmc(const vec3 r, CGLM_IN(mat3) m, const vec3 c) {
   vec3 tmp;
   glm_mat3_mulv(m, c, tmp);
   return glm_vec3_dot(r, tmp);
diff --git a/include/cglm/mat3x2.h b/include/cglm/mat3x2.h
index 52173c0c4..44a98f19f 100644
--- a/include/cglm/mat3x2.h
+++ b/include/cglm/mat3x2.h
@@ -11,12 +11,12 @@
    GLM_MAT3X2_ZERO
 
  Functions:
-   CGLM_INLINE void glm_mat3x2_copy(mat3x2 src, mat3x2 dest);
+   CGLM_INLINE void glm_mat3x2_copy(CGLM_IN(mat3x2) src, mat3x2 dest);
    CGLM_INLINE void glm_mat3x2_zero(mat3x2 m);
    CGLM_INLINE void glm_mat3x2_make(const float * __restrict src, mat3x2 dest);
-   CGLM_INLINE void glm_mat3x2_mul(mat3x2 m1, mat2x3 m2, mat2 dest);
-   CGLM_INLINE void glm_mat3x2_mulv(mat3x2 m, vec3 v, vec2 dest);
-   CGLM_INLINE void glm_mat3x2_transpose(mat3x2 src, mat2x3 dest);
+   CGLM_INLINE void glm_mat3x2_mul(CGLM_IN(mat3x2) m1, CGLM_IN(mat2x3) m2, mat2 dest);
+   CGLM_INLINE void glm_mat3x2_mulv(CGLM_IN(mat3x2) m, const vec3 v, vec2 dest);
+   CGLM_INLINE void glm_mat3x2_transpose(CGLM_IN(mat3x2) src, mat2x3 dest);
    CGLM_INLINE void glm_mat3x2_scale(mat3x2 m, float s);
  */
 
@@ -38,7 +38,7 @@
  */
 CGLM_INLINE
 void
-glm_mat3x2_copy(mat3x2 src, mat3x2 dest) {
+glm_mat3x2_copy(CGLM_IN(mat3x2) src, mat3x2 dest) {
   glm_vec2_copy(src[0], dest[0]);
   glm_vec2_copy(src[1], dest[1]);
   glm_vec2_copy(src[2], dest[2]);
@@ -88,7 +88,7 @@ glm_mat3x2_make(const float * __restrict src, mat3x2 dest) {
  */
 CGLM_INLINE
 void
-glm_mat3x2_mul(mat3x2 m1, mat2x3 m2, mat2 dest) {
+glm_mat3x2_mul(CGLM_IN(mat3x2) m1, CGLM_IN(mat2x3) m2, mat2 dest) {
   float a00 = m1[0][0], a01 = m1[0][1],
         a10 = m1[1][0], a11 = m1[1][1],
         a20 = m1[2][0], a21 = m1[2][1],
@@ -112,7 +112,7 @@ glm_mat3x2_mul(mat3x2 m1, mat2x3 m2, mat2 dest) {
  */
 CGLM_INLINE
 void
-glm_mat3x2_mulv(mat3x2 m, vec3 v, vec2 dest) {
+glm_mat3x2_mulv(CGLM_IN(mat3x2) m, const vec3 v, vec2 dest) {
   float v0 = v[0], v1 = v[1], v2 = v[2];
 
   dest[0] = m[0][0] * v0 + m[1][0] * v1 + m[2][0] * v2;
@@ -127,7 +127,7 @@ glm_mat3x2_mulv(mat3x2 m, vec3 v, vec2 dest) {
  */
 CGLM_INLINE
 void
-glm_mat3x2_transpose(mat3x2 src, mat2x3 dest) {
+glm_mat3x2_transpose(CGLM_IN(mat3x2) src, mat2x3 dest) {
   dest[0][0] = src[0][0];  dest[0][1] = src[1][0];  dest[0][2] = src[2][0];
   dest[1][0] = src[0][1];  dest[1][1] = src[1][1];  dest[1][2] = src[2][1];
 }
diff --git a/include/cglm/mat3x4.h b/include/cglm/mat3x4.h
index 52d8e7e31..fffc4e23f 100644
--- a/include/cglm/mat3x4.h
+++ b/include/cglm/mat3x4.h
@@ -11,12 +11,12 @@
    GLM_MAT3X4_ZERO
 
  Functions:
-   CGLM_INLINE void glm_mat3x4_copy(mat3x4 src, mat3x4 dest);
+   CGLM_INLINE void glm_mat3x4_copy(CGLM_IN(mat3x4) src, mat3x4 dest);
    CGLM_INLINE void glm_mat3x4_zero(mat3x4 m);
    CGLM_INLINE void glm_mat3x4_make(const float * __restrict src, mat3x4 dest);
    CGLM_INLINE void glm_mat3x4_mul(mat3x4 m1, mat4x3 m2, mat4 dest);
-   CGLM_INLINE void glm_mat3x4_mulv(mat3x4 m, vec3 v, vec4 dest);
-   CGLM_INLINE void glm_mat3x4_transpose(mat3x4 src, mat4x3 dest);
+   CGLM_INLINE void glm_mat3x4_mulv(CGLM_IN(mat3x4) m, const vec3 v, vec4 dest);
+   CGLM_INLINE void glm_mat3x4_transpose(CGLM_IN(mat3x4) src, mat4x3 dest);
    CGLM_INLINE void glm_mat3x4_scale(mat3x4 m, float s);
  */
 
@@ -40,7 +40,7 @@
  */
 CGLM_INLINE
 void
-glm_mat3x4_copy(mat3x4 src, mat3x4 dest) {
+glm_mat3x4_copy(CGLM_IN(mat3x4) src, mat3x4 dest) {
   glm_vec4_ucopy(src[0], dest[0]);
   glm_vec4_ucopy(src[1], dest[1]);
   glm_vec4_ucopy(src[2], dest[2]);
@@ -136,7 +136,7 @@ glm_mat3x4_mul(mat3x4 m1, mat4x3 m2, mat4 dest) {
  */
 CGLM_INLINE
 void
-glm_mat3x4_mulv(mat3x4 m, vec3 v, vec4 dest) {
+glm_mat3x4_mulv(CGLM_IN(mat3x4) m, const vec3 v, vec4 dest) {
   float v0 = v[0], v1 = v[1], v2 = v[2];
 
   dest[0] = m[0][0] * v0 + m[1][0] * v1 + m[2][0] * v2;
@@ -153,7 +153,7 @@ glm_mat3x4_mulv(mat3x4 m, vec3 v, vec4 dest) {
  */
 CGLM_INLINE
 void
-glm_mat3x4_transpose(mat3x4 src, mat4x3 dest) {
+glm_mat3x4_transpose(CGLM_IN(mat3x4) src, mat4x3 dest) {
   dest[0][0] = src[0][0];  dest[0][1] = src[1][0];  dest[0][2] = src[2][0];
   dest[1][0] = src[0][1];  dest[1][1] = src[1][1];  dest[1][2] = src[2][1];
   dest[2][0] = src[0][2];  dest[2][1] = src[1][2];  dest[2][2] = src[2][2];
diff --git a/include/cglm/mat4.h b/include/cglm/mat4.h
index c3fe7fdc9..decf5c5e4 100644
--- a/include/cglm/mat4.h
+++ b/include/cglm/mat4.h
@@ -18,32 +18,32 @@
    GLM_MAT4_ZERO
 
  Functions:
-   CGLM_INLINE void  glm_mat4_ucopy(mat4 mat, mat4 dest);
-   CGLM_INLINE void  glm_mat4_copy(mat4 mat, mat4 dest);
+   CGLM_INLINE void  glm_mat4_ucopy(CGLM_IN(mat4) mat, mat4 dest);
+   CGLM_INLINE void  glm_mat4_copy(CGLM_IN(mat4) mat, mat4 dest);
    CGLM_INLINE void  glm_mat4_identity(mat4 mat);
    CGLM_INLINE void  glm_mat4_identity_array(mat4 * restrict mat, size_t count);
    CGLM_INLINE void  glm_mat4_zero(mat4 mat);
-   CGLM_INLINE void  glm_mat4_pick3(mat4 mat, mat3 dest);
-   CGLM_INLINE void  glm_mat4_pick3t(mat4 mat, mat3 dest);
+   CGLM_INLINE void  glm_mat4_pick3(CGLM_IN(mat4) mat, mat3 dest);
+   CGLM_INLINE void  glm_mat4_pick3t(CGLM_IN(mat4) mat, mat3 dest);
    CGLM_INLINE void  glm_mat4_ins3(mat3 mat, mat4 dest);
-   CGLM_INLINE void  glm_mat4_mul(mat4 m1, mat4 m2, mat4 dest);
+   CGLM_INLINE void  glm_mat4_mul(CGLM_IN(mat4) m1, CGLM_IN(mat4) m2, mat4 dest);
    CGLM_INLINE void  glm_mat4_mulN(mat4 *matrices[], int len, mat4 dest);
-   CGLM_INLINE void  glm_mat4_mulv(mat4 m, vec4 v, vec4 dest);
-   CGLM_INLINE void  glm_mat4_mulv3(mat4 m, vec3 v, float last, vec3 dest);
-   CGLM_INLINE float glm_mat4_trace(mat4 m);
-   CGLM_INLINE float glm_mat4_trace3(mat4 m);
-   CGLM_INLINE void  glm_mat4_quat(mat4 m, versor dest) ;
-   CGLM_INLINE void  glm_mat4_transpose_to(mat4 m, mat4 dest);
+   CGLM_INLINE void  glm_mat4_mulv(CGLM_IN(mat4) m, const vec4 v, vec4 dest);
+   CGLM_INLINE void  glm_mat4_mulv3(CGLM_IN(mat4) m, const vec3 v, float last, vec3 dest);
+   CGLM_INLINE float glm_mat4_trace(CGLM_IN(mat4) m);
+   CGLM_INLINE float glm_mat4_trace3(CGLM_IN(mat4) m);
+   CGLM_INLINE void  glm_mat4_quat(CGLM_IN(mat4) m, versor dest) ;
+   CGLM_INLINE void  glm_mat4_transpose_to(CGLM_IN(mat4) m, mat4 dest);
    CGLM_INLINE void  glm_mat4_transpose(mat4 m);
    CGLM_INLINE void  glm_mat4_scale_p(mat4 m, float s);
-   CGLM_INLINE void  glm_mat4_scale(mat4 m, float s);
-   CGLM_INLINE float glm_mat4_det(mat4 mat);
-   CGLM_INLINE void  glm_mat4_inv(mat4 mat, mat4 dest);
-   CGLM_INLINE void  glm_mat4_inv_fast(mat4 mat, mat4 dest);
+   CGLM_INLINE void  glm_mat4_scale(CGLM_IN(mat4) m, float s);
+   CGLM_INLINE float glm_mat4_det(CGLM_IN(mat4) mat);
+   CGLM_INLINE void  glm_mat4_inv(CGLM_IN(mat4) mat, mat4 dest);
+   CGLM_INLINE void  glm_mat4_inv_fast(CGLM_IN(mat4) mat, mat4 dest);
    CGLM_INLINE void  glm_mat4_swap_col(mat4 mat, int col1, int col2);
    CGLM_INLINE void  glm_mat4_swap_row(mat4 mat, int row1, int row2);
-   CGLM_INLINE float glm_mat4_rmc(vec4 r, mat4 m, vec4 c);
-   CGLM_INLINE void  glm_mat4_make(float * restrict src, mat4 dest);
+   CGLM_INLINE float glm_mat4_rmc(const vec4 r, CGLM_IN(mat4) m, const vec4 c);
+   CGLM_INLINE void  glm_mat4_make(const float * restrict src, mat4 dest);
    CGLM_INLINE void  glm_mat4_textrans(float sx, float sy, float rot, float tx, float ty, mat4 dest);
  */
 
@@ -106,7 +106,7 @@
  */
 CGLM_INLINE
 void
-glm_mat4_ucopy(mat4 mat, mat4 dest) {
+glm_mat4_ucopy(CGLM_IN(mat4) mat, mat4 dest) {
   dest[0][0] = mat[0][0];  dest[1][0] = mat[1][0];
   dest[0][1] = mat[0][1];  dest[1][1] = mat[1][1];
   dest[0][2] = mat[0][2];  dest[1][2] = mat[1][2];
@@ -126,7 +126,7 @@ glm_mat4_ucopy(mat4 mat, mat4 dest) {
  */
 CGLM_INLINE
 void
-glm_mat4_copy(mat4 mat, mat4 dest) {
+glm_mat4_copy(CGLM_IN(mat4) mat, mat4 dest) {
 #if defined(__wasm__) && defined(__wasm_simd128__)
   glmm_store(dest[0], glmm_load(mat[0]));
   glmm_store(dest[1], glmm_load(mat[1]));
@@ -151,7 +151,7 @@ glm_mat4_copy(mat4 mat, mat4 dest) {
 }
 
 /*!
- * @brief make given matrix identity. It is identical with below, 
+ * @brief make given matrix identity. It is identical with below,
  *        but it is more easy to do that with this func especially for members
  *        e.g. glm_mat4_identity(aStruct->aMatrix);
  *
@@ -159,7 +159,7 @@ glm_mat4_copy(mat4 mat, mat4 dest) {
  * glm_mat4_copy(GLM_MAT4_IDENTITY, mat); // C only
  *
  * // or
- * mat4 mat = GLM_MAT4_IDENTITY_INIT;
+ * CGLM_IN(mat4) mat = GLM_MAT4_IDENTITY_INIT;
  * @endcode
  *
  * @param[in, out]  mat  destination
@@ -238,7 +238,7 @@ glm_mat4_zero(mat4 mat) {
  */
 CGLM_INLINE
 void
-glm_mat4_pick3(mat4 mat, mat3 dest) {
+glm_mat4_pick3(CGLM_IN(mat4) mat, mat3 dest) {
   dest[0][0] = mat[0][0];
   dest[0][1] = mat[0][1];
   dest[0][2] = mat[0][2];
@@ -262,7 +262,7 @@ glm_mat4_pick3(mat4 mat, mat3 dest) {
  */
 CGLM_INLINE
 void
-glm_mat4_pick3t(mat4 mat, mat3 dest) {
+glm_mat4_pick3t(CGLM_IN(mat4) mat, mat3 dest) {
   dest[0][0] = mat[0][0];
   dest[0][1] = mat[1][0];
   dest[0][2] = mat[2][0];
@@ -304,7 +304,7 @@ glm_mat4_ins3(mat3 mat, mat4 dest) {
  * m1, m2 and dest matrices can be same matrix, it is possible to write this:
  *
  * @code
- * mat4 m = GLM_MAT4_IDENTITY_INIT;
+ * CGLM_IN(mat4) m = GLM_MAT4_IDENTITY_INIT;
  * glm_mat4_mul(m, m, m);
  * @endcode
  *
@@ -314,7 +314,7 @@ glm_mat4_ins3(mat3 mat, mat4 dest) {
  */
 CGLM_INLINE
 void
-glm_mat4_mul(mat4 m1, mat4 m2, mat4 dest) {
+glm_mat4_mul(CGLM_IN(mat4) m1, CGLM_IN(mat4) m2, mat4 dest) {
 #if defined(__wasm__) && defined(__wasm_simd128__)
   glm_mat4_mul_wasm(m1, m2, dest);
 #elif defined(__AVX__)
@@ -396,7 +396,7 @@ glm_mat4_mulN(mat4 * __restrict matrices[], uint32_t len, mat4 dest) {
  */
 CGLM_INLINE
 void
-glm_mat4_mulv(mat4 m, vec4 v, vec4 dest) {
+glm_mat4_mulv(CGLM_IN(mat4) m, const vec4 v, vec4 dest) {
 #if defined(__wasm__) && defined(__wasm_simd128__)
   glm_mat4_mulv_wasm(m, v, dest);
 #elif defined( __SSE__ ) || defined( __SSE2__ )
@@ -422,7 +422,7 @@ glm_mat4_mulv(mat4 m, vec4 v, vec4 dest) {
  */
 CGLM_INLINE
 float
-glm_mat4_trace(mat4 m) {
+glm_mat4_trace(CGLM_IN(mat4) m) {
   return m[0][0] + m[1][1] + m[2][2] + m[3][3];
 }
 
@@ -435,7 +435,7 @@ glm_mat4_trace(mat4 m) {
  */
 CGLM_INLINE
 float
-glm_mat4_trace3(mat4 m) {
+glm_mat4_trace3(CGLM_IN(mat4) m) {
   return m[0][0] + m[1][1] + m[2][2];
 }
 
@@ -447,7 +447,7 @@ glm_mat4_trace3(mat4 m) {
  */
 CGLM_INLINE
 void
-glm_mat4_quat(mat4 m, versor dest) {
+glm_mat4_quat(CGLM_IN(mat4) m, versor dest) {
   float trace, r, rinv;
 
   /* it seems using like m12 instead of m[1][2] causes extra instructions */
@@ -501,7 +501,7 @@ glm_mat4_quat(mat4 m, versor dest) {
  */
 CGLM_INLINE
 void
-glm_mat4_mulv3(mat4 m, vec3 v, float last, vec3 dest) {
+glm_mat4_mulv3(CGLM_IN(mat4) m, const vec3 v, float last, vec3 dest) {
   vec4 res;
   glm_vec4(v, last, res);
   glm_mat4_mulv(m, res, res);
@@ -518,7 +518,7 @@ glm_mat4_mulv3(mat4 m, vec3 v, float last, vec3 dest) {
  */
 CGLM_INLINE
 void
-glm_mat4_transpose_to(mat4 m, mat4 dest) {
+glm_mat4_transpose_to(CGLM_IN(mat4) m, mat4 dest) {
 #if defined(__wasm__) && defined(__wasm_simd128__)
   glm_mat4_transp_wasm(m, dest);
 #elif defined(__AVX__)
@@ -612,7 +612,7 @@ glm_mat4_scale(mat4 m, float s) {
  */
 CGLM_INLINE
 float
-glm_mat4_det(mat4 mat) {
+glm_mat4_det(CGLM_IN(mat4) mat) {
 #if defined(__wasm__) && defined(__wasm_simd128__)
   return glm_mat4_det_wasm(mat);
 #elif defined( __SSE__ ) || defined( __SSE2__ )
@@ -649,7 +649,7 @@ glm_mat4_det(mat4 mat) {
  */
 CGLM_INLINE
 void
-glm_mat4_inv(mat4 mat, mat4 dest) {
+glm_mat4_inv(CGLM_IN(mat4) mat, mat4 dest) {
 #if defined(__wasm__) && defined(__wasm_simd128__)
   glm_mat4_inv_wasm(mat, dest);
 #elif defined( __SSE__ ) || defined( __SSE2__ )
@@ -663,7 +663,7 @@ glm_mat4_inv(mat4 mat, mat4 dest) {
         m = mat[3][0], n = mat[3][1], o = mat[3][2], p = mat[3][3],
 
         c1  = k * p - l * o,  c2  = c * h - d * g,  c3  = i * p - l * m,
-        c4  = a * h - d * e,  c5  = j * p - l * n,  c6  = b * h - d * f, 
+        c4  = a * h - d * e,  c5  = j * p - l * n,  c6  = b * h - d * f,
         c7  = i * n - j * m,  c8  = a * f - b * e,  c9  = j * o - k * n,
         c10 = b * g - c * f,  c11 = i * o - k * m,  c12 = a * g - c * e,
 
@@ -705,7 +705,7 @@ glm_mat4_inv(mat4 mat, mat4 dest) {
  */
 CGLM_INLINE
 void
-glm_mat4_inv_fast(mat4 mat, mat4 dest) {
+glm_mat4_inv_fast(CGLM_IN(mat4) mat, mat4 dest) {
 #if defined(__wasm__) && defined(__wasm_simd128__)
   glm_mat4_inv_fast_wasm(mat, dest);
 #elif defined( __SSE__ ) || defined( __SSE2__ )
@@ -774,7 +774,7 @@ glm_mat4_swap_row(mat4 mat, int row1, int row2) {
  */
 CGLM_INLINE
 float
-glm_mat4_rmc(vec4 r, mat4 m, vec4 c) {
+glm_mat4_rmc(const vec4 r, CGLM_IN(mat4) m, const vec4 c) {
   vec4 tmp;
   glm_mat4_mulv(m, c, tmp);
   return glm_vec4_dot(r, tmp);
diff --git a/include/cglm/mat4x2.h b/include/cglm/mat4x2.h
index 91684e440..10c40ffd4 100644
--- a/include/cglm/mat4x2.h
+++ b/include/cglm/mat4x2.h
@@ -11,12 +11,12 @@
    GLM_MAT4X2_ZERO
 
  Functions:
-   CGLM_INLINE void glm_mat4x2_copy(mat4x2 src, mat4x2 dest);
+   CGLM_INLINE void glm_mat4x2_copy(CGLM_IN(mat4x2) src, mat4x2 dest);
    CGLM_INLINE void glm_mat4x2_zero(mat4x2 m);
    CGLM_INLINE void glm_mat4x2_make(const float * __restrict src, mat4x2 dest);
-   CGLM_INLINE void glm_mat4x2_mul(mat4x2 m1, mat2x4 m2, mat2 dest);
-   CGLM_INLINE void glm_mat4x2_mulv(mat4x2 m, vec4 v, vec2 dest);
-   CGLM_INLINE void glm_mat4x2_transpose(mat4x2 src, mat2x4 dest);
+   CGLM_INLINE void glm_mat4x2_mul(CGLM_IN(mat4x2) m1, CGLM_IN(mat2x4) m2, mat2 dest);
+   CGLM_INLINE void glm_mat4x2_mulv(CGLM_IN(mat4x2) m, const vec4 v, vec2 dest);
+   CGLM_INLINE void glm_mat4x2_transpose(CGLM_IN(mat4x2) src, mat2x4 dest);
    CGLM_INLINE void glm_mat4x2_scale(mat4x2 m, float s);
  */
 
@@ -38,7 +38,7 @@
  */
 CGLM_INLINE
 void
-glm_mat4x2_copy(mat4x2 src, mat4x2 dest) {
+glm_mat4x2_copy(CGLM_IN(mat4x2) src, mat4x2 dest) {
   glm_vec2_copy(src[0], dest[0]);
   glm_vec2_copy(src[1], dest[1]);
   glm_vec2_copy(src[2], dest[2]);
@@ -92,7 +92,7 @@ glm_mat4x2_make(const float * __restrict src, mat4x2 dest) {
  */
 CGLM_INLINE
 void
-glm_mat4x2_mul(mat4x2 m1, mat2x4 m2, mat2 dest) {
+glm_mat4x2_mul(CGLM_IN(mat4x2) m1, CGLM_IN(mat2x4) m2, mat2 dest) {
   float a00 = m1[0][0], a01 = m1[0][1],
         a10 = m1[1][0], a11 = m1[1][1],
         a20 = m1[2][0], a21 = m1[2][1],
@@ -117,7 +117,7 @@ glm_mat4x2_mul(mat4x2 m1, mat2x4 m2, mat2 dest) {
  */
 CGLM_INLINE
 void
-glm_mat4x2_mulv(mat4x2 m, vec4 v, vec2 dest) {
+glm_mat4x2_mulv(CGLM_IN(mat4x2) m, const vec4 v, vec2 dest) {
   float v0 = v[0], v1 = v[1], v2 = v[2], v3 = v[3];
 
   dest[0] = m[0][0] * v0 + m[1][0] * v1 + m[2][0] * v2 + m[3][0] * v3;
@@ -132,9 +132,9 @@ glm_mat4x2_mulv(mat4x2 m, vec4 v, vec2 dest) {
  */
 CGLM_INLINE
 void
-glm_mat4x2_transpose(mat4x2 m, mat2x4 dest) {
-  dest[0][0] = m[0][0]; dest[0][1] = m[1][0]; dest[0][2] = m[2][0]; dest[0][3] = m[3][0];
-  dest[1][0] = m[0][1]; dest[1][1] = m[1][1]; dest[1][2] = m[2][1]; dest[1][3] = m[3][1];
+glm_mat4x2_transpose(CGLM_IN(mat4x2) src, mat2x4 dest) {
+  dest[0][0] = src[0][0]; dest[0][1] = src[1][0]; dest[0][2] = src[2][0]; dest[0][3] = src[3][0];
+  dest[1][0] = src[0][1]; dest[1][1] = src[1][1]; dest[1][2] = src[2][1]; dest[1][3] = src[3][1];
 }
 
 /*!
diff --git a/include/cglm/mat4x3.h b/include/cglm/mat4x3.h
index a42943758..ed526d2a8 100644
--- a/include/cglm/mat4x3.h
+++ b/include/cglm/mat4x3.h
@@ -1,5 +1,4 @@
-/*
- * Copyright (c), Recep Aslantas.
+/* Copyright (c), Recep Aslantas.
  *
  * MIT License (MIT), http://opensource.org/licenses/MIT
  * Full license can be found in the LICENSE file
@@ -11,12 +10,12 @@
    GLM_MAT4X3_ZERO
 
  Functions:
-   CGLM_INLINE void glm_mat4x3_copy(mat4x3 src, mat4x3 dest);
+   CGLM_INLINE void glm_mat4x3_copy(CGLM_IN(mat4x3) src, mat4x3 dest);
    CGLM_INLINE void glm_mat4x3_zero(mat4x3 m);
    CGLM_INLINE void glm_mat4x3_make(const float * __restrict src, mat4x3 dest);
-   CGLM_INLINE void glm_mat4x3_mul(mat4x3 m1, mat3x4 m2, mat3 dest);
-   CGLM_INLINE void glm_mat4x3_mulv(mat4x3 m, vec4 v, vec3 dest);
-   CGLM_INLINE void glm_mat4x3_transpose(mat4x3 src, mat3x4 dest);
+   CGLM_INLINE void glm_mat4x3_mul(CGLM_IN(mat4x3) m1, CGLM_IN(mat3x4) m2, mat3 dest);
+   CGLM_INLINE void glm_mat4x3_mulv(CGLM_IN(mat4x3) m, const vec4 v, vec3 dest);
+   CGLM_INLINE void glm_mat4x3_transpose(CGLM_IN(mat4x3) src, mat3x4 dest);
    CGLM_INLINE void glm_mat4x3_scale(mat4x3 m, float s);
  */
 
@@ -39,7 +38,7 @@
  */
 CGLM_INLINE
 void
-glm_mat4x3_copy(mat4x3 src, mat4x3 dest) {
+glm_mat4x3_copy(CGLM_IN(mat4x3) src, mat4x3 dest) {
   glm_vec3_copy(src[0], dest[0]);
   glm_vec3_copy(src[1], dest[1]);
   glm_vec3_copy(src[2], dest[2]);
@@ -97,7 +96,7 @@ glm_mat4x3_make(const float * __restrict src, mat4x3 dest) {
  */
 CGLM_INLINE
 void
-glm_mat4x3_mul(mat4x3 m1, mat3x4 m2, mat3 dest) {
+glm_mat4x3_mul(CGLM_IN(mat4x3) m1, CGLM_IN(mat3x4) m2, mat3 dest) {
   float a00 = m1[0][0], a01 = m1[0][1], a02 = m1[0][2],
         a10 = m1[1][0], a11 = m1[1][1], a12 = m1[1][2],
         a20 = m1[2][0], a21 = m1[2][1], a22 = m1[2][2],
@@ -129,7 +128,7 @@ glm_mat4x3_mul(mat4x3 m1, mat3x4 m2, mat3 dest) {
  */
 CGLM_INLINE
 void
-glm_mat4x3_mulv(mat4x3 m, vec4 v, vec3 dest) {
+glm_mat4x3_mulv(CGLM_IN(mat4x3) m, const vec4 v, vec3 dest) {
   float v0 = v[0], v1 = v[1], v2 = v[2], v3 = v[3];
 
   dest[0] = m[0][0] * v0 + m[1][0] * v1 + m[2][0] * v2 + m[3][0] * v3;
@@ -145,7 +144,7 @@ glm_mat4x3_mulv(mat4x3 m, vec4 v, vec3 dest) {
  */
 CGLM_INLINE
 void
-glm_mat4x3_transpose(mat4x3 src, mat3x4 dest) {
+glm_mat4x3_transpose(CGLM_IN(mat4x3) src, mat3x4 dest) {
   dest[0][0] = src[0][0]; dest[0][1] = src[1][0]; dest[0][2] = src[2][0]; dest[0][3] = src[3][0];
   dest[1][0] = src[0][1]; dest[1][1] = src[1][1]; dest[1][2] = src[2][1]; dest[1][3] = src[3][1];
   dest[2][0] = src[0][2]; dest[2][1] = src[1][2]; dest[2][2] = src[2][2]; dest[2][3] = src[3][2];
diff --git a/include/cglm/noise.h b/include/cglm/noise.h
index bec12e96a..936914a9c 100644
--- a/include/cglm/noise.h
+++ b/include/cglm/noise.h
@@ -8,7 +8,7 @@
  * https://github.com/stegu/webgl-noise
  * Following Stefan Gustavson's paper "Simplex noise demystified":
  * http://www.itn.liu.se/~stegu/simplexnoise/simplexnoise.pdf
- * 
+ *
  * Implementation based on glm::perlin function:
  * https://github.com/g-truc/glm/blob/master/glm/gtc/noise.inl
  */
@@ -203,15 +203,15 @@
 /* NOTE: This function is not *quite* analogous to glm__noiseDetail_i2gxyzw
  * to try to match the output of glm::perlin. I think it might be a bug in
  * in the original implementation, but for now I'm keeping it consistent. -MK
- * 
+ *
  * Follow up: The original implementation (glm v 1.0.1) does:
- * 
+ *
  *   vec<4, T, Q> gx0 = ixy0 * T(1.0 / 7.0);
- * 
+ *
  * as opposed to:
- * 
+ *
  *   vec<4, T, Q> gx0 = ixy0 / T(7);
- * 
+ *
  * This ends up mapping to different simd instructions, at least on AMD.
  * The delta is tiny but it gets amplified by the rest of the noise function.
  * Hence we too need to do `glm_vec4_scale` as opposed to `glm_vec4_divs`, to
@@ -390,7 +390,7 @@ glm_perlin_vec4(vec4 point) {
   vec4 g0110 = {gx10[2], gy10[2], gz10[2], gw10[2]}; /* g0110 = vec4(gx10.z, gy10.z, gz10.z, gw10.z); */
   vec4 g1010 = {gx10[1], gy10[1], gz10[1], gw10[1]}; /* g1010 = vec4(gx10.y, gy10.y, gz10.y, gw10.y); */
   vec4 g1110 = {gx10[3], gy10[3], gz10[3], gw10[3]}; /* g1110 = vec4(gx10.w, gy10.w, gz10.w, gw10.w); */
-  
+
   vec4 g0011 = {gx11[0], gy11[0], gz11[0], gw11[0]}; /* g0011 = vec4(gx11.x, gy11.x, gz11.x, gw11.x); */
   vec4 g0111 = {gx11[2], gy11[2], gz11[2], gw11[2]}; /* g0111 = vec4(gx11.z, gy11.z, gz11.z, gw11.z); */
   vec4 g1011 = {gx11[1], gy11[1], gz11[1], gw11[1]}; /* g1011 = vec4(gx11.y, gy11.y, gz11.y, gw11.y); */
@@ -408,15 +408,15 @@ glm_perlin_vec4(vec4 point) {
   /* n1000 = dot(g1000, vec4(Pf1.x, Pf0.y, Pf0.z, Pf0.w)) */
   vec4 n1000d = {Pf1[0], Pf0[1], Pf0[2], Pf0[3]};
   float n1000 = glm_vec4_dot(g1000, n1000d);
-  
+
   /* n0100 = dot(g0100, vec4(Pf0.x, Pf1.y, Pf0.z, Pf0.w)) */
   vec4 n0100d = {Pf0[0], Pf1[1], Pf0[2], Pf0[3]};
   float n0100 = glm_vec4_dot(g0100, n0100d);
-  
+
   /* n1100 = dot(g1100, vec4(Pf1.x, Pf1.y, Pf0.z, Pf0.w)) */
   vec4 n1100d = {Pf1[0], Pf1[1], Pf0[2], Pf0[3]};
   float n1100 = glm_vec4_dot(g1100, n1100d);
-  
+
   /* n0010 = dot(g0010, vec4(Pf0.x, Pf0.y, Pf1.z, Pf0.w)) */
   vec4 n0010d = {Pf0[0], Pf0[1], Pf1[2], Pf0[3]};
   float n0010 = glm_vec4_dot(g0010, n0010d);
@@ -467,23 +467,23 @@ glm_perlin_vec4(vec4 point) {
 
   vec4 fade_xyzw;
   glm__noiseDetail_fade_vec4(Pf0, fade_xyzw); /* fade_xyzw = fade(Pf0) */
-  
+
   /* n_0w = lerp(vec4(n0000, n1000, n0100, n1100), vec4(n0001, n1001, n0101, n1101), fade_xyzw.w) */
   vec4 n_0w1 = {n0000, n1000, n0100, n1100};
   vec4 n_0w2 = {n0001, n1001, n0101, n1101};
   vec4 n_0w;
   glm_vec4_lerp(n_0w1, n_0w2, fade_xyzw[3], n_0w);
-  
+
   /* n_1w = lerp(vec4(n0010, n1010, n0110, n1110), vec4(n0011, n1011, n0111, n1111), fade_xyzw.w) */
   vec4 n_1w1 = {n0010, n1010, n0110, n1110};
   vec4 n_1w2 = {n0011, n1011, n0111, n1111};
   vec4 n_1w;
   glm_vec4_lerp(n_1w1, n_1w2, fade_xyzw[3], n_1w);
-  
+
   /* n_zw = lerp(n_0w, n_1w, fade_xyzw.z) */
   vec4 n_zw;
   glm_vec4_lerp(n_0w, n_1w, fade_xyzw[2], n_zw);
-  
+
   /* n_yzw = lerp(vec2(n_zw.x, n_zw.y), vec2(n_zw.z, n_zw.w), fade_xyzw.y) */
   vec2 n_yzw;
   vec2 n_yzw1 = {n_zw[0], n_zw[1]};
@@ -505,7 +505,7 @@ glm_perlin_vec4(vec4 point) {
  */
 CGLM_INLINE
 float
-glm_perlin_vec3(vec3 point) {
+glm_perlin_vec3(const vec3 point) {
   /* Integer part of p for indexing */
   vec3 Pi0;
   glm_vec3_floor(point, Pi0); /* Pi0 = floor(point); */
@@ -632,7 +632,7 @@ glm_perlin_vec3(vec3 point) {
  */
 CGLM_INLINE
 float
-glm_perlin_vec2(vec2 point) {
+glm_perlin_vec2(const vec2 point) {
 
   /* Integer part of p for indexing */
   /* Pi = floor(vec4(point.x, point.y, point.x, point.y)) + vec4(0.0, 0.0, 1.0, 1.0); */
diff --git a/include/cglm/project.h b/include/cglm/project.h
index 1d0a4e5ea..564978be1 100644
--- a/include/cglm/project.h
+++ b/include/cglm/project.h
@@ -52,7 +52,7 @@
  */
 CGLM_INLINE
 void
-glm_unprojecti(vec3 pos, mat4 invMat, vec4 vp, vec3 dest) {
+glm_unprojecti(const vec3 pos, CGLM_IN(mat4) invMat, const vec4 vp, vec3 dest) {
 #if CGLM_CONFIG_CLIP_CONTROL & CGLM_CLIP_CONTROL_ZO_BIT
   glm_unprojecti_zo(pos, invMat, vp, dest);
 #elif CGLM_CONFIG_CLIP_CONTROL & CGLM_CLIP_CONTROL_NO_BIT
@@ -86,7 +86,7 @@ glm_unprojecti(vec3 pos, mat4 invMat, vec4 vp, vec3 dest) {
  */
 CGLM_INLINE
 void
-glm_unproject(vec3 pos, mat4 m, vec4 vp, vec3 dest) {
+glm_unproject(const vec3 pos, CGLM_IN(mat4) m, const vec4 vp, vec3 dest) {
   mat4 inv;
   glm_mat4_inv(m, inv);
   glm_unprojecti(pos, inv, vp, dest);
@@ -106,7 +106,7 @@ glm_unproject(vec3 pos, mat4 m, vec4 vp, vec3 dest) {
  */
 CGLM_INLINE
 void
-glm_project(vec3 pos, mat4 m, vec4 vp, vec3 dest) {
+glm_project(const vec3 pos, CGLM_IN(mat4) m, const vec4 vp, vec3 dest) {
 #if CGLM_CONFIG_CLIP_CONTROL & CGLM_CLIP_CONTROL_ZO_BIT
   glm_project_zo(pos, m, vp, dest);
 #elif CGLM_CONFIG_CLIP_CONTROL & CGLM_CLIP_CONTROL_NO_BIT
@@ -128,7 +128,7 @@ glm_project(vec3 pos, mat4 m, vec4 vp, vec3 dest) {
  */
 CGLM_INLINE
 float
-glm_project_z(vec3 v, mat4 m) {
+glm_project_z(const vec3 v, CGLM_IN(mat4) m) {
 #if CGLM_CONFIG_CLIP_CONTROL & CGLM_CLIP_CONTROL_ZO_BIT
   return glm_project_z_zo(v, m);
 #elif CGLM_CONFIG_CLIP_CONTROL & CGLM_CLIP_CONTROL_NO_BIT
@@ -146,20 +146,20 @@ glm_project_z(vec3 v, mat4 m) {
  */
 CGLM_INLINE
 void
-glm_pickmatrix(vec2 center, vec2 size, vec4 vp, mat4 dest) {
+glm_pickmatrix(vec2 center, vec2 size, const vec4 vp, mat4 dest) {
   mat4 res;
   vec3 v;
 
   if (size[0] <= 0.0f || size[1] <= 0.0f)
     return;
-  
+
   /* Translate and scale the picked region to the entire window */
   v[0] = (vp[2] - 2.0f * (center[0] - vp[0])) / size[0];
   v[1] = (vp[3] - 2.0f * (center[1] - vp[1])) / size[1];
   v[2] = 0.0f;
 
   glm_translate_make(res, v);
-  
+
   v[0] = vp[2] / size[0];
   v[1] = vp[3] / size[1];
   v[2] = 1.0f;
diff --git a/include/cglm/quat.h b/include/cglm/quat.h
index cf1f325f6..2149cb3c2 100644
--- a/include/cglm/quat.h
+++ b/include/cglm/quat.h
@@ -14,9 +14,9 @@
    CGLM_INLINE void glm_quat_identity(versor q);
    CGLM_INLINE void glm_quat_init(versor q, float x, float y, float z, float w);
    CGLM_INLINE void glm_quat(versor q, float angle, float x, float y, float z);
-   CGLM_INLINE void glm_quatv(versor q, float angle, vec3 axis);
+   CGLM_INLINE void glm_quatv(versor q, float angle, const vec3 axis);
    CGLM_INLINE void glm_quat_copy(versor q, versor dest);
-   CGLM_INLINE void glm_quat_from_vecs(vec3 a, vec3 b, versor dest);
+   CGLM_INLINE void glm_quat_from_vecs(const vec3 a, const vec3 b, versor dest);
    CGLM_INLINE float glm_quat_norm(versor q);
    CGLM_INLINE void glm_quat_normalize(versor q);
    CGLM_INLINE void glm_quat_normalize_to(versor q, versor dest);
@@ -41,14 +41,14 @@
    CGLM_INLINE void glm_quat_slerp(versor q, versor r, float t, versor dest);
    CGLM_INLINE void glm_quat_slerp_longest(versor q, versor r, float t, versor dest);
    CGLM_INLINE void glm_quat_nlerp(versor q, versor r, float t, versor dest);
-   CGLM_INLINE void glm_quat_look(vec3 eye, versor ori, mat4 dest);
-   CGLM_INLINE void glm_quat_for(vec3 dir, vec3 fwd, vec3 up, versor dest);
+   CGLM_INLINE void glm_quat_look(const vec3 eye, versor ori, mat4 dest);
+   CGLM_INLINE void glm_quat_for(const vec3 dir, vec3 fwd, const vec3 up, versor dest);
    CGLM_INLINE void glm_quat_forp(vec3 from,
                                   vec3 to,
                                   vec3 fwd,
-                                  vec3 up,
+                                  const vec3 up,
                                   versor dest);
-   CGLM_INLINE void glm_quat_rotatev(versor q, vec3 v, vec3 dest);
+   CGLM_INLINE void glm_quat_rotatev(versor q, const vec3 v, vec3 dest);
    CGLM_INLINE void glm_quat_rotate(mat4 m, versor q, mat4 dest);
    CGLM_INLINE void glm_quat_make(float * restrict src, versor dest);
  */
@@ -149,7 +149,7 @@ glm_quat_init(versor q, float x, float y, float z, float w) {
  */
 CGLM_INLINE
 void
-glm_quatv(versor q, float angle, vec3 axis) {
+glm_quatv(versor q, float angle, const vec3 axis) {
   CGLM_ALIGN(8) vec3 k;
   float a, c, s;
 
@@ -202,7 +202,7 @@ glm_quat_copy(versor q, versor dest) {
  */
 CGLM_INLINE
 void
-glm_quat_from_vecs(vec3 a, vec3 b, versor dest) {
+glm_quat_from_vecs(const vec3 a, const vec3 b, versor dest) {
   CGLM_ALIGN(8) vec3 axis;
   float cos_theta;
   float cos_half_theta;
@@ -690,9 +690,9 @@ void
 glm_quat_nlerp(versor from, versor to, float t, versor dest) {
   versor target;
   float  dot;
-  
+
   dot = glm_vec4_dot(from, to);
-  
+
   glm_vec4_scale(to, (dot >= 0) ? 1.0f : -1.0f, target);
   glm_quat_lerp(from, target, t, dest);
   glm_quat_normalize(dest);
@@ -798,7 +798,7 @@ glm_quat_slerp_longest(versor from, versor to, float t, versor dest) {
  */
 CGLM_INLINE
 void
-glm_quat_look(vec3 eye, versor ori, mat4 dest) {
+glm_quat_look(const vec3 eye, versor ori, mat4 dest) {
   /* orientation */
   glm_quat_mat4t(ori, dest);
 
@@ -816,14 +816,14 @@ glm_quat_look(vec3 eye, versor ori, mat4 dest) {
  */
 CGLM_INLINE
 void
-glm_quat_for(vec3 dir, vec3 up, versor dest) {
+glm_quat_for(const vec3 dir, const vec3 up, versor dest) {
   CGLM_ALIGN_MAT mat3 m;
 
-  glm_vec3_normalize_to(dir, m[2]); 
+  glm_vec3_normalize_to(dir, m[2]);
 
   /* No need to negate in LH, but we use RH here */
   glm_vec3_negate(m[2]);
-  
+
   glm_vec3_crossn(up, m[2], m[0]);
   glm_vec3_cross(m[2], m[0], m[1]);
 
@@ -841,7 +841,7 @@ glm_quat_for(vec3 dir, vec3 up, versor dest) {
  */
 CGLM_INLINE
 void
-glm_quat_forp(vec3 from, vec3 to, vec3 up, versor dest) {
+glm_quat_forp(const vec3 from, const vec3 to, const vec3 up, versor dest) {
   CGLM_ALIGN(8) vec3 dir;
   glm_vec3_sub(to, from, dir);
   glm_quat_for(dir, up, dest);
@@ -856,7 +856,7 @@ glm_quat_forp(vec3 from, vec3 to, vec3 up, versor dest) {
  */
 CGLM_INLINE
 void
-glm_quat_rotatev(versor q, vec3 v, vec3 dest) {
+glm_quat_rotatev(versor q, const vec3 v, vec3 dest) {
   CGLM_ALIGN(16) versor p;
   CGLM_ALIGN(8)  vec3   u, v1, v2;
   float s;
@@ -895,11 +895,11 @@ glm_quat_rotate(mat4 m, versor q, mat4 dest) {
  *
  * @param[in, out]   m     existing transform matrix
  * @param[in]        q     quaternion
- * @param[out]       pivot pivot
+ * @param[in]       pivot pivot
  */
 CGLM_INLINE
 void
-glm_quat_rotate_at(mat4 m, versor q, vec3 pivot) {
+glm_quat_rotate_at(mat4 m, versor q, const vec3 pivot) {
   CGLM_ALIGN(8) vec3 pivotInv;
 
   glm_vec3_negate_to(pivot, pivotInv);
@@ -923,7 +923,7 @@ glm_quat_rotate_at(mat4 m, versor q, vec3 pivot) {
  */
 CGLM_INLINE
 void
-glm_quat_rotate_atm(mat4 m, versor q, vec3 pivot) {
+glm_quat_rotate_atm(mat4 m, versor q, const vec3 pivot) {
   CGLM_ALIGN(8) vec3 pivotInv;
 
   glm_vec3_negate_to(pivot, pivotInv);
diff --git a/include/cglm/ray.h b/include/cglm/ray.h
index d7831bc9a..077002a4e 100644
--- a/include/cglm/ray.h
+++ b/include/cglm/ray.h
@@ -7,18 +7,18 @@
 
 /*
  Functions:
-   CGLM_INLINE bool glm_ray_triangle(vec3   origin,
-                                     vec3   direction,
-                                     vec3   v0,
-                                     vec3   v1,
-                                     vec3   v2,
+   CGLM_INLINE bool glm_ray_triangle(const vec3   origin,
+                                     const vec3   direction,
+                                     const vec3   v0,
+                                     const vec3   v1,
+                                     const vec3   v2,
                                      float *d);
- CGLM_INLINE bool glm_ray_sphere(vec3 origin,
-                                 vec3 dir,
-                                 vec4 s,
+ CGLM_INLINE bool glm_ray_sphere(const vec3 origin,
+                                 const vec3 dir,
+                                 const vec4 s,
                                  float * __restrict t1,
                                  float * __restrict t2)
- CGLM_INLINE void glm_ray_at(vec3 orig, vec3 dir, float t, vec3 point);
+ CGLM_INLINE void glm_ray_at(const vec3 orig, const vec3 dir, float t, vec3 point);
 */
 
 #ifndef cglm_ray_h
@@ -28,7 +28,7 @@
 
 /*!
  * @brief Möller–Trumbore ray-triangle intersection algorithm
- * 
+ *
  * @param[in] origin         origin of ray
  * @param[in] direction      direction of ray
  * @param[in] v0             first vertex of triangle
@@ -39,11 +39,11 @@
  */
 CGLM_INLINE
 bool
-glm_ray_triangle(vec3   origin,
-                 vec3   direction,
-                 vec3   v0,
-                 vec3   v1,
-                 vec3   v2,
+glm_ray_triangle(const vec3   origin,
+                 const vec3   direction,
+                 const vec3   v0,
+                 const vec3   v1,
+                 const vec3   v2,
                  float *d) {
   vec3        edge1, edge2, p, t, q;
   float       det, inv_det, u, v, dist;
@@ -58,7 +58,7 @@ glm_ray_triangle(vec3   origin,
     return false;
 
   inv_det = 1.0f / det;
-  
+
   glm_vec3_sub(origin, v0, t);
 
   u = inv_det * glm_vec3_dot(t, p);
@@ -100,10 +100,10 @@ glm_ray_triangle(vec3   origin,
  * @returns whether there is intersection
  */
 CGLM_INLINE
-bool 
-glm_ray_sphere(vec3 origin,
-               vec3 dir,
-               vec4 s,
+bool
+glm_ray_sphere(const vec3 origin,
+               const vec3 dir,
+               const vec4 s,
                float * __restrict t1,
                float * __restrict t2) {
   vec3  dp;
@@ -165,7 +165,7 @@ glm_ray_sphere(vec3 origin,
  */
 CGLM_INLINE
 void
-glm_ray_at(vec3 orig, vec3 dir, float t, vec3 point) {
+glm_ray_at(const vec3 orig, const vec3 dir, float t, vec3 point) {
   vec3 dst;
   glm_vec3_scale(dir, t, dst);
   glm_vec3_add(orig, dst, point);
diff --git a/include/cglm/simd/avx/affine.h b/include/cglm/simd/avx/affine.h
index b02ff0c7b..e274b927b 100644
--- a/include/cglm/simd/avx/affine.h
+++ b/include/cglm/simd/avx/affine.h
@@ -16,7 +16,7 @@
 
 CGLM_INLINE
 void
-glm_mul_avx(mat4 m1, mat4 m2, mat4 dest) {
+glm_mul_avx(CGLM_IN(mat4) m1, CGLM_IN(mat4) m2, mat4 dest) {
   /* D = R * L (Column-Major) */
 
   __m256 y0, y1, y2, y3, y4, y5, y6, y7, y8, y9;
diff --git a/include/cglm/simd/avx/mat4.h b/include/cglm/simd/avx/mat4.h
index 33771c29f..5034b560e 100644
--- a/include/cglm/simd/avx/mat4.h
+++ b/include/cglm/simd/avx/mat4.h
@@ -14,7 +14,7 @@
 
 CGLM_INLINE
 void
-glm_mat4_scale_avx(mat4 m, float s) {
+glm_mat4_scale_avx(CGLM_IN(mat4) m, float s) {
   __m256 y0, y1, y2, y3, y4;
 
   y0 = glmm_load256(m[0]);            /* h g f e d c b a */
@@ -32,7 +32,7 @@ glm_mat4_scale_avx(mat4 m, float s) {
 /* TODO: this must be tested and compared to SSE version, may be slower!!! */
 CGLM_INLINE
 void
-glm_mat4_transp_avx(mat4 m, mat4 dest) {
+glm_mat4_transp_avx(CGLM_IN(mat4) m, mat4 dest) {
   __m256 y0, y1, y2, y3;
 
   y0 = glmm_load256(m[0]);                   /* h g f e d c b a */
@@ -40,7 +40,7 @@ glm_mat4_transp_avx(mat4 m, mat4 dest) {
 
   y2 = _mm256_unpacklo_ps(y0, y1);           /* n f m e j b i a */
   y3 = _mm256_unpackhi_ps(y0, y1);           /* p h o g l d k c */
-  
+
   y0 = _mm256_permute2f128_ps(y2, y3, 0x20); /* l d k c j b i a */
   y1 = _mm256_permute2f128_ps(y2, y3, 0x31); /* p h o g n f m e */
 
@@ -56,7 +56,7 @@ glm_mat4_transp_avx(mat4 m, mat4 dest) {
 
 CGLM_INLINE
 void
-glm_mat4_mul_avx(mat4 m1, mat4 m2, mat4 dest) {
+glm_mat4_mul_avx(CGLM_IN(mat4) m1, CGLM_IN(mat4) m2, mat4 dest) {
   /* D = R * L (Column-Major) */
 
   __m256  y0, y1, y2, y3, y4, y5, y6, y7, y8, y9, y10, y11, y12, y13;
@@ -76,7 +76,7 @@ glm_mat4_mul_avx(mat4 m1, mat4 m2, mat4 dest) {
   yi1 = _mm256_set_epi32(3, 3, 3, 3, 2, 2, 2, 2);
   yi2 = _mm256_set_epi32(0, 0, 0, 0, 1, 1, 1, 1);
   yi3 = _mm256_set_epi32(2, 2, 2, 2, 3, 3, 3, 3);
-  
+
   /* f f f f a a a a */
   /* h h h h c c c c */
   /* e e e e b b b b */
diff --git a/include/cglm/simd/neon/affine.h b/include/cglm/simd/neon/affine.h
index b0a65a695..69436ea62 100644
--- a/include/cglm/simd/neon/affine.h
+++ b/include/cglm/simd/neon/affine.h
@@ -14,7 +14,7 @@
 
 CGLM_INLINE
 void
-glm_mul_neon(mat4 m1, mat4 m2, mat4 dest) {
+glm_mul_neon(CGLM_IN(mat4) m1, CGLM_IN(mat4) m2, mat4 dest) {
   /* D = R * L (Column-Major) */
 
   glmm_128 l, r0, r1, r2, r3, v0, v1, v2, v3;
@@ -52,7 +52,7 @@ glm_mul_neon(mat4 m1, mat4 m2, mat4 dest) {
 
 CGLM_INLINE
 void
-glm_mul_rot_neon(mat4 m1, mat4 m2, mat4 dest) {
+glm_mul_rot_neon(CGLM_IN(mat4) m1, CGLM_IN(mat4) m2, mat4 dest) {
   /* D = R * L (Column-Major) */
 
   glmm_128 l, r0, r1, r2, v0, v1, v2;
@@ -70,7 +70,7 @@ glm_mul_rot_neon(mat4 m1, mat4 m2, mat4 dest) {
   v0 = glmm_fmadd(glmm_splat_y(r0), l, v0);
   v1 = glmm_fmadd(glmm_splat_y(r1), l, v1);
   v2 = glmm_fmadd(glmm_splat_y(r2), l, v2);
-  
+
   l  = glmm_load(m1[2]);
   v0 = glmm_fmadd(glmm_splat_z(r0), l, v0);
   v1 = glmm_fmadd(glmm_splat_z(r1), l, v1);
@@ -84,7 +84,7 @@ glm_mul_rot_neon(mat4 m1, mat4 m2, mat4 dest) {
 
 CGLM_INLINE
 void
-glm_inv_tr_neon(mat4 mat) {
+glm_inv_tr_neon(CGLM_IN(mat4) mat) {
   float32x4x4_t vmat;
   glmm_128      r0, r1, r2, x0;
 
@@ -102,7 +102,7 @@ glm_inv_tr_neon(mat4 mat) {
   glmm_store(mat[1], r1);
   glmm_store(mat[2], r2);
   glmm_store(mat[3], x0);
-  
+
   mat[0][3] = 0.0f;
   mat[1][3] = 0.0f;
   mat[2][3] = 0.0f;
diff --git a/include/cglm/simd/neon/mat2.h b/include/cglm/simd/neon/mat2.h
index 7d0d9eba5..03c743399 100644
--- a/include/cglm/simd/neon/mat2.h
+++ b/include/cglm/simd/neon/mat2.h
@@ -14,20 +14,20 @@
 
 CGLM_INLINE
 void
-glm_mat2_mul_neon(mat2 m1, mat2 m2, mat2 dest) {
+glm_mat2_mul_neon(CGLM_IN(mat2) m1, CGLM_IN(mat2) m2, mat2 dest) {
   float32x4x2_t a1;
   glmm_128 x0,  x1, x2;
   float32x2_t   dc, ba;
 
   x1 = glmm_load(m1[0]); /* d c b a */
   x2 = glmm_load(m2[0]); /* h g f e */
-  
+
   dc = vget_high_f32(x1);
   ba = vget_low_f32(x1);
 
   /* g g e e, h h f f */
   a1 = vtrnq_f32(x2, x2);
-  
+
   /*
    dest[0][0] = a * e + c * f;
    dest[0][1] = b * e + d * f;
diff --git a/include/cglm/simd/neon/mat4.h b/include/cglm/simd/neon/mat4.h
index 6cf9811e4..ff38cbac4 100644
--- a/include/cglm/simd/neon/mat4.h
+++ b/include/cglm/simd/neon/mat4.h
@@ -14,9 +14,9 @@
 
 CGLM_INLINE
 void
-glm_mat4_scale_neon(mat4 m, float s) {
+glm_mat4_scale_neon(CGLM_IN(mat4) m, float s) {
   float32x4_t v0;
-  
+
   v0 = vdupq_n_f32(s);
 
   vst1q_f32(m[0], vmulq_f32(vld1q_f32(m[0]), v0));
@@ -27,9 +27,9 @@ glm_mat4_scale_neon(mat4 m, float s) {
 
 CGLM_INLINE
 void
-glm_mat4_transp_neon(mat4 m, mat4 dest) {
+glm_mat4_transp_neon(CGLM_IN(mat4) m, mat4 dest) {
   float32x4x4_t vmat;
-  
+
   vmat = vld4q_f32(m[0]);
 
   vst1q_f32(dest[0], vmat.val[0]);
@@ -40,7 +40,7 @@ glm_mat4_transp_neon(mat4 m, mat4 dest) {
 
 CGLM_INLINE
 void
-glm_mat4_mul_neon(mat4 m1, mat4 m2, mat4 dest) {
+glm_mat4_mul_neon(CGLM_IN(mat4) m1, CGLM_IN(mat4) m2, mat4 dest) {
   /* D = R * L (Column-Major) */
 
   glmm_128 l, r0, r1, r2, r3, v0, v1, v2, v3;
@@ -82,10 +82,10 @@ glm_mat4_mul_neon(mat4 m1, mat4 m2, mat4 dest) {
 
 CGLM_INLINE
 void
-glm_mat4_mulv_neon(mat4 m, vec4 v, vec4 dest) {
+glm_mat4_mulv_neon(CGLM_IN(mat4) m, const vec4 v, vec4 dest) {
   float32x4_t l0, l1, l2, l3;
   float32x2_t vlo, vhi;
-  
+
   l0  = vld1q_f32(m[0]);
   l1  = vld1q_f32(m[1]);
   l2  = vld1q_f32(m[2]);
@@ -104,7 +104,7 @@ glm_mat4_mulv_neon(mat4 m, vec4 v, vec4 dest) {
 
 CGLM_INLINE
 float
-glm_mat4_det_neon(mat4 mat) {
+glm_mat4_det_neon(CGLM_IN(mat4) mat) {
   float32x4_t   r0, r1, r2, r3, x0, x1, x2;
   float32x2_t   ij, op, mn, kl, nn, mm, jj, ii, gh, ef, t12, t34;
   float32x4x2_t a1;
@@ -126,7 +126,7 @@ glm_mat4_det_neon(mat4 mat) {
   nn = vdup_lane_f32(mn, 0);
   ii = vdup_lane_f32(ij, 1);
   jj = vdup_lane_f32(ij, 0);
-  
+
   /*
    t[1] = j * p - n * l;
    t[2] = j * o - n * k;
@@ -138,10 +138,10 @@ glm_mat4_det_neon(mat4 mat) {
 
   t12 = vget_low_f32(x0);
   t34 = vget_high_f32(x0);
-  
+
   /* 1 3 1 3 2 4 2 4 */
   a1 = vuzpq_f32(x0, x0);
-  
+
   /*
    t[0] = k * p - o * l;
    t[0] = k * p - o * l;
@@ -176,7 +176,7 @@ glm_mat4_det_neon(mat4 mat) {
 #if 0
 CGLM_INLINE
 void
-glm_mat4_inv_neon(mat4 mat, mat4 dest) {
+glm_mat4_inv_neon(CGLM_IN(mat4) mat, mat4 dest) {
   float32x4_t   r0, r1, r2, r3,
                 v0, v1, v2, v3,
                 t0, t1, t2, t3, t4, t5,
@@ -192,10 +192,10 @@ glm_mat4_inv_neon(mat4 mat, mat4 dest) {
   r1 = glmm_load(mat[1]); /* h g f e */
   r2 = glmm_load(mat[2]); /* l k j i */
   r3 = glmm_load(mat[3]); /* p o n m */
-  
+
   /* l p k o, j n i m */
   a1  = vzipq_f32(r3, r2);
-  
+
   jn  = vget_high_f32(a1.val[0]);
   im  = vget_low_f32(a1.val[0]);
   lp  = vget_high_f32(a1.val[1]);
@@ -206,7 +206,7 @@ glm_mat4_inv_neon(mat4 mat, mat4 dest) {
   x2  = vcombine_f32(vdup_lane_f32(ko, 0), ko);                   /* k o o o */
   x0  = vcombine_f32(vdup_lane_f32(lp, 1), vdup_lane_f32(hg, 1)); /* h h l l */
   x3  = vcombine_f32(vdup_lane_f32(ko, 1), vdup_lane_f32(hg, 0)); /* g g k k */
-  
+
   /* t1[0] = k * p - o * l;
      t1[0] = k * p - o * l;
      t2[0] = g * p - o * h;
@@ -216,43 +216,43 @@ glm_mat4_inv_neon(mat4 mat, mat4 dest) {
   fe = vget_low_f32(r1);
   x4 = vcombine_f32(vdup_lane_f32(jn, 0), jn);                   /* j n n n */
   x5 = vcombine_f32(vdup_lane_f32(jn, 1), vdup_lane_f32(fe, 1)); /* f f j j */
-  
+
   /* t1[1] = j * p - n * l;
      t1[1] = j * p - n * l;
      t2[1] = f * p - n * h;
      t3[1] = f * l - j * h; */
    t1 = glmm_fnmadd(x4, x0, vmulq_f32(x5, x1));
-  
+
   /* t1[2] = j * o - n * k
      t1[2] = j * o - n * k;
      t2[2] = f * o - n * g;
      t3[2] = f * k - j * g; */
   t2 = glmm_fnmadd(x4, x3, vmulq_f32(x5, x2));
-  
+
   x6 = vcombine_f32(vdup_lane_f32(im, 1), vdup_lane_f32(fe, 0)); /* e e i i */
   x7 = vcombine_f32(vdup_lane_f32(im, 0), im);                   /* i m m m */
-  
+
   /* t1[3] = i * p - m * l;
      t1[3] = i * p - m * l;
      t2[3] = e * p - m * h;
      t3[3] = e * l - i * h; */
   t3 = glmm_fnmadd(x7, x0, vmulq_f32(x6, x1));
-  
+
   /* t1[4] = i * o - m * k;
      t1[4] = i * o - m * k;
      t2[4] = e * o - m * g;
      t3[4] = e * k - i * g; */
   t4 = glmm_fnmadd(x7, x3, vmulq_f32(x6, x2));
-  
+
   /* t1[5] = i * n - m * j;
      t1[5] = i * n - m * j;
      t2[5] = e * n - m * f;
      t3[5] = e * j - i * f; */
   t5 = glmm_fnmadd(x7, x5, vmulq_f32(x6, x4));
-  
+
   /* h d f b, g c e a */
   a1 = vtrnq_f32(r0, r1);
-  
+
   x4 = vrev64q_f32(a1.val[0]); /* c g a e */
   x5 = vrev64q_f32(a1.val[1]); /* d h b f */
 
@@ -260,19 +260,19 @@ glm_mat4_inv_neon(mat4 mat, mat4 dest) {
   cg = vget_high_f32(x4);
   bf = vget_low_f32(x5);
   dh = vget_high_f32(x5);
-  
+
   x0 = vcombine_f32(ae, vdup_lane_f32(ae, 1)); /* a a a e */
   x1 = vcombine_f32(bf, vdup_lane_f32(bf, 1)); /* b b b f */
   x2 = vcombine_f32(cg, vdup_lane_f32(cg, 1)); /* c c c g */
   x3 = vcombine_f32(dh, vdup_lane_f32(dh, 1)); /* d d d h */
-  
+
   /*
    dest[0][0] =  f * t1[0] - g * t1[1] + h * t1[2];
    dest[0][1] =-(b * t1[0] - c * t1[1] + d * t1[2]);
    dest[0][2] =  b * t2[0] - c * t2[1] + d * t2[2];
    dest[0][3] =-(b * t3[0] - c * t3[1] + d * t3[2]); */
   v0 = glmm_xor(glmm_fmadd(x3, t2, glmm_fnmadd(x2, t1, vmulq_f32(x1, t0))), x8);
-  
+
   /*
    dest[2][0] =  e * t1[1] - f * t1[3] + h * t1[5];
    dest[2][1] =-(a * t1[1] - b * t1[3] + d * t1[5]);
@@ -286,7 +286,7 @@ glm_mat4_inv_neon(mat4 mat, mat4 dest) {
    dest[1][2] =-(a * t2[0] - c * t2[3] + d * t2[4]);
    dest[1][3] =  a * t3[0] - c * t3[3] + d * t3[4]; */
   v1 = glmm_xor(glmm_fmadd(x3, t4, glmm_fnmadd(x2, t3, vmulq_f32(x0, t0))), x9);
-  
+
   /*
    dest[3][0] =-(e * t1[2] - f * t1[4] + g * t1[5]);
    dest[3][1] =  a * t1[2] - b * t1[4] + c * t1[5];
@@ -318,7 +318,7 @@ glm_mat4_inv_neon(mat4 mat, mat4 dest) {
 
 CGLM_INLINE
 void
-glm_mat4_inv_neon(mat4 mat, mat4 dest) {
+glm_mat4_inv_neon(CGLM_IN(mat4) mat, mat4 dest) {
   float32x4_t   r0, r1, r2, r3,
                 v0, v1, v2, v3, v4, v5,
                 t0, t1, t2;
@@ -380,11 +380,11 @@ glm_mat4_inv_neon(mat4 mat, mat4 dest) {
   l0 = vget_low_f32(v0);
   l1 = vget_high_f32(v0);
 
-  l0 = vpadd_f32(l0, l0); /* [a+b, a+b] */ 
-  l1 = vpadd_f32(l1, l1); /* [c+d, c+d] */ 
-  l0 = vadd_f32(l0, l1);  /* [sum, sum] */ 
+  l0 = vpadd_f32(l0, l0); /* [a+b, a+b] */
+  l1 = vpadd_f32(l1, l1); /* [c+d, c+d] */
+  l0 = vadd_f32(l0, l1);  /* [sum, sum] */
 
-  v0 = vcombine_f32(l0, l0); 
+  v0 = vcombine_f32(l0, l0);
 #endif
 
   /* c5 * c12 + c6 * c11 */
@@ -394,8 +394,8 @@ glm_mat4_inv_neon(mat4 mat, mat4 dest) {
   l0 = vget_low_f32(v1);
   l1 = vget_high_f32(v1);
 
-  l0 = vpadd_f32(l0, l0); /* [a+b, a+b] */ 
-  l1 = vpadd_f32(l1, l1); /* [c+d, c+d] */ 
+  l0 = vpadd_f32(l0, l0); /* [a+b, a+b] */
+  l1 = vpadd_f32(l1, l1); /* [c+d, c+d] */
 
   v1 = vcombine_f32(l0, l1);
 #endif
diff --git a/include/cglm/simd/sse2/affine.h b/include/cglm/simd/sse2/affine.h
index 061999596..e35b6745c 100644
--- a/include/cglm/simd/sse2/affine.h
+++ b/include/cglm/simd/sse2/affine.h
@@ -14,7 +14,7 @@
 
 CGLM_INLINE
 void
-glm_mul_sse2(mat4 m1, mat4 m2, mat4 dest) {
+glm_mul_sse2(CGLM_IN(mat4) m1, CGLM_IN(mat4) m2, mat4 dest) {
   /* D = R * L (Column-Major) */
   glmm_128 l, r0, r1, r2, r3, v0, v1, v2, v3;
 
@@ -52,7 +52,7 @@ glm_mul_sse2(mat4 m1, mat4 m2, mat4 dest) {
 
 CGLM_INLINE
 void
-glm_mul_rot_sse2(mat4 m1, mat4 m2, mat4 dest) {
+glm_mul_rot_sse2(CGLM_IN(mat4) m1, CGLM_IN(mat4) m2, mat4 dest) {
   /* D = R * L (Column-Major) */
 
   glmm_128 l, r0, r1, r2, v0, v1, v2;
diff --git a/include/cglm/simd/sse2/mat2.h b/include/cglm/simd/sse2/mat2.h
index 31b3a2909..c13742422 100644
--- a/include/cglm/simd/sse2/mat2.h
+++ b/include/cglm/simd/sse2/mat2.h
@@ -14,7 +14,7 @@
 
 CGLM_INLINE
 void
-glm_mat2_mul_sse2(mat2 m1, mat2 m2, mat2 dest) {
+glm_mat2_mul_sse2(CGLM_IN(mat2) m1, CGLM_IN(mat2) m2, mat2 dest) {
   __m128 x0, x1, x2, x3, x4;
 
   x1 = glmm_load(m1[0]); /* d c b a */
@@ -38,7 +38,7 @@ glm_mat2_mul_sse2(mat2 m1, mat2 m2, mat2 dest) {
 
 CGLM_INLINE
 void
-glm_mat2_transp_sse2(mat2 m, mat2 dest) {
+glm_mat2_transp_sse2(CGLM_IN(mat2) m, mat2 dest) {
   /* d c b a */
   /* d b c a */
   glmm_store(dest[0], glmm_shuff1(glmm_load(m[0]), 3, 1, 2, 0));
diff --git a/include/cglm/simd/sse2/mat3.h b/include/cglm/simd/sse2/mat3.h
index f07320cf3..3d44ff095 100644
--- a/include/cglm/simd/sse2/mat3.h
+++ b/include/cglm/simd/sse2/mat3.h
@@ -14,9 +14,9 @@
 
 CGLM_INLINE
 void
-glm_mat3_mul_sse2(mat3 m1, mat3 m2, mat3 dest) {
+glm_mat3_mul_sse2(CGLM_IN(mat3) m1, CGLM_IN(mat3) m2, mat3 dest) {
   __m128 l0, l1, l2, r0, r1, r2, x0, x1, x2, x3, x4, x5, x6, x7, x8, x9;
-  
+
   l0 = _mm_loadu_ps(m1[0]);
   l1 = _mm_loadu_ps(&m1[1][1]);
 
@@ -52,7 +52,7 @@ glm_mat3_mul_sse2(mat3 m1, mat3 m2, mat3 dest) {
   x3 = glmm_shuff1(x2, 0, 2, 1, 0);                     /* a20 a22 a21 a20 */
   x2 = glmm_shuff1(x2, 1, 0, 2, 1);                     /* a21 a20 a22 a21 */
   x4 = _mm_shuffle_ps(r0, r1, _MM_SHUFFLE(1, 1, 2, 2)); /* b12 b12 b02 b02 */
-  
+
   x5 = glmm_shuff1(x4, 3, 0, 0, 0);                     /* b12 b02 b02 b02 */
   x4 = _mm_movehl_ps(r2, x4);                           /* b22 b22 b12 b12 */
   x0 = glmm_fmadd(x3, x5, x0);
diff --git a/include/cglm/simd/sse2/mat4.h b/include/cglm/simd/sse2/mat4.h
index 2127e72ab..e9c185e6d 100644
--- a/include/cglm/simd/sse2/mat4.h
+++ b/include/cglm/simd/sse2/mat4.h
@@ -1,5 +1,4 @@
-/*
- * Copyright (c), Recep Aslantas.
+/* Copyright (c), Recep Aslantas.
  *
  * MIT License (MIT), http://opensource.org/licenses/MIT
  * Full license can be found in the LICENSE file
@@ -28,7 +27,7 @@ glm_mat4_scale_sse2(mat4 m, float s) {
 
 CGLM_INLINE
 void
-glm_mat4_transp_sse2(mat4 m, mat4 dest) {
+glm_mat4_transp_sse2(CGLM_IN(mat4) m, mat4 dest) {
   __m128 r0, r1, r2, r3;
 
   r0 = glmm_load(m[0]);
@@ -46,7 +45,7 @@ glm_mat4_transp_sse2(mat4 m, mat4 dest) {
 
 CGLM_INLINE
 void
-glm_mat4_mul_sse2(mat4 m1, mat4 m2, mat4 dest) {
+glm_mat4_mul_sse2(CGLM_IN(mat4) m1, CGLM_IN(mat4) m2, mat4 dest) {
   /* D = R * L (Column-Major) */
 
   glmm_128 l, r0, r1, r2, r3, v0, v1, v2, v3;
@@ -88,7 +87,7 @@ glm_mat4_mul_sse2(mat4 m1, mat4 m2, mat4 dest) {
 
 CGLM_INLINE
 void
-glm_mat4_mulv_sse2(mat4 m, vec4 v, vec4 dest) {
+glm_mat4_mulv_sse2(CGLM_IN(mat4) m, const vec4 v, vec4 dest) {
   __m128 x0, x1, m0, m1, m2, m3, v0, v1, v2, v3;
 
   m0 = glmm_load(m[0]);
@@ -112,7 +111,7 @@ glm_mat4_mulv_sse2(mat4 m, vec4 v, vec4 dest) {
 
 CGLM_INLINE
 float
-glm_mat4_det_sse2(mat4 mat) {
+glm_mat4_det_sse2(CGLM_IN(mat4) mat) {
   __m128 r0, r1, r2, r3, x0, x1, x2;
 
   /* 127 <- 0, [square] det(A) = det(At) */
@@ -152,15 +151,15 @@ glm_mat4_det_sse2(mat4 mat) {
   x2 = glmm_fmadd(glmm_shuff1(r1, 2, 3, 3, 3),
                   _mm_shuffle_ps(x0, x1, _MM_SHUFFLE(2, 2, 3, 1)),
                   x2);
-  
+
   x2 = _mm_xor_ps(x2, glmm_float32x4_SIGNMASK_NPNP);
-  
+
   return glmm_hadd(_mm_mul_ps(x2, r0));
 }
 
 CGLM_INLINE
 void
-glm_mat4_inv_fast_sse2(mat4 mat, mat4 dest) {
+glm_mat4_inv_fast_sse2(CGLM_IN(mat4) mat, mat4 dest) {
   __m128 r0, r1, r2, r3,
          v0, v1, v2, v3,
          t0, t1, t2, t3, t4, t5,
@@ -175,7 +174,7 @@ glm_mat4_inv_fast_sse2(mat4 mat, mat4 dest) {
   r1 = glmm_load(mat[1]); /* h g f e */
   r2 = glmm_load(mat[2]); /* l k j i */
   r3 = glmm_load(mat[3]); /* p o n m */
-  
+
   x0 = _mm_movehl_ps(r3, r2);                            /* p o l k */
   x3 = _mm_movelh_ps(r2, r3);                            /* n m j i */
   x1 = glmm_shuff1(x0, 1, 3, 3 ,3);                      /* l p p p */
@@ -187,68 +186,68 @@ glm_mat4_inv_fast_sse2(mat4 mat, mat4 dest) {
   x5 = _mm_shuffle_ps(r2, r1, _MM_SHUFFLE(1, 1, 1, 1));  /* f f j j */
   x3 = _mm_shuffle_ps(r2, r1, _MM_SHUFFLE(2, 2, 2, 2));  /* g g k k */
   x0 = _mm_shuffle_ps(r2, r1, _MM_SHUFFLE(3, 3, 3, 3));  /* h h l l */
-  
+
   t0 = _mm_mul_ps(x3, x1);
   t1 = _mm_mul_ps(x5, x1);
   t2 = _mm_mul_ps(x5, x2);
   t3 = _mm_mul_ps(x6, x1);
   t4 = _mm_mul_ps(x6, x2);
   t5 = _mm_mul_ps(x6, x4);
-  
+
   /* t1[0] = k * p - o * l;
      t1[0] = k * p - o * l;
      t2[0] = g * p - o * h;
      t3[0] = g * l - k * h; */
   t0 = glmm_fnmadd(x2, x0, t0);
-  
+
   /* t1[1] = j * p - n * l;
      t1[1] = j * p - n * l;
      t2[1] = f * p - n * h;
      t3[1] = f * l - j * h; */
    t1 = glmm_fnmadd(x4, x0, t1);
-  
+
   /* t1[2] = j * o - n * k
      t1[2] = j * o - n * k;
      t2[2] = f * o - n * g;
      t3[2] = f * k - j * g; */
   t2 = glmm_fnmadd(x4, x3, t2);
-  
+
   /* t1[3] = i * p - m * l;
      t1[3] = i * p - m * l;
      t2[3] = e * p - m * h;
      t3[3] = e * l - i * h; */
   t3 = glmm_fnmadd(x7, x0, t3);
-  
+
   /* t1[4] = i * o - m * k;
      t1[4] = i * o - m * k;
      t2[4] = e * o - m * g;
      t3[4] = e * k - i * g; */
   t4 = glmm_fnmadd(x7, x3, t4);
-  
+
   /* t1[5] = i * n - m * j;
      t1[5] = i * n - m * j;
      t2[5] = e * n - m * f;
      t3[5] = e * j - i * f; */
   t5 = glmm_fnmadd(x7, x5, t5);
-  
+
   x4 = _mm_movelh_ps(r0, r1);        /* f e b a */
   x5 = _mm_movehl_ps(r1, r0);        /* h g d c */
-  
+
   x0 = glmm_shuff1(x4, 0, 0, 0, 2);  /* a a a e */
   x1 = glmm_shuff1(x4, 1, 1, 1, 3);  /* b b b f */
   x2 = glmm_shuff1(x5, 0, 0, 0, 2);  /* c c c g */
   x3 = glmm_shuff1(x5, 1, 1, 1, 3);  /* d d d h */
-  
+
   v2 = _mm_mul_ps(x0, t1);
   v1 = _mm_mul_ps(x0, t0);
   v3 = _mm_mul_ps(x0, t2);
   v0 = _mm_mul_ps(x1, t0);
-  
+
   v2 = glmm_fnmadd(x1, t3, v2);
   v3 = glmm_fnmadd(x1, t4, v3);
   v0 = glmm_fnmadd(x2, t1, v0);
   v1 = glmm_fnmadd(x2, t3, v1);
-  
+
   v3 = glmm_fmadd(x2, t5, v3);
   v0 = glmm_fmadd(x3, t2, v0);
   v2 = glmm_fmadd(x3, t5, v2);
@@ -260,7 +259,7 @@ glm_mat4_inv_fast_sse2(mat4 mat, mat4 dest) {
    dest[0][2] =  b * t2[0] - c * t2[1] + d * t2[2];
    dest[0][3] =-(b * t3[0] - c * t3[1] + d * t3[2]); */
   v0 = _mm_xor_ps(v0, x8);
-  
+
   /*
    dest[2][0] =  e * t1[1] - f * t1[3] + h * t1[5];
    dest[2][1] =-(a * t1[1] - b * t1[3] + d * t1[5]);
@@ -299,7 +298,7 @@ glm_mat4_inv_fast_sse2(mat4 mat, mat4 dest) {
 #if 0
 CGLM_INLINE
 void
-glm_mat4_inv_sse2(mat4 mat, mat4 dest) {
+glm_mat4_inv_sse2(CGLM_IN(mat4) mat, mat4 dest) {
   __m128 r0, r1, r2, r3,
          v0, v1, v2, v3,
          t0, t1, t2, t3, t4, t5,
@@ -314,7 +313,7 @@ glm_mat4_inv_sse2(mat4 mat, mat4 dest) {
   r1 = glmm_load(mat[1]); /* h g f e */
   r2 = glmm_load(mat[2]); /* l k j i */
   r3 = glmm_load(mat[3]); /* p o n m */
-  
+
   x0 = _mm_movehl_ps(r3, r2);                            /* p o l k */
   x3 = _mm_movelh_ps(r2, r3);                            /* n m j i */
   x1 = glmm_shuff1(x0, 1, 3, 3 ,3);                      /* l p p p */
@@ -326,68 +325,68 @@ glm_mat4_inv_sse2(mat4 mat, mat4 dest) {
   x5 = _mm_shuffle_ps(r2, r1, _MM_SHUFFLE(1, 1, 1, 1));  /* f f j j */
   x3 = _mm_shuffle_ps(r2, r1, _MM_SHUFFLE(2, 2, 2, 2));  /* g g k k */
   x0 = _mm_shuffle_ps(r2, r1, _MM_SHUFFLE(3, 3, 3, 3));  /* h h l l */
-  
+
   t0 = _mm_mul_ps(x3, x1);
   t1 = _mm_mul_ps(x5, x1);
   t2 = _mm_mul_ps(x5, x2);
   t3 = _mm_mul_ps(x6, x1);
   t4 = _mm_mul_ps(x6, x2);
   t5 = _mm_mul_ps(x6, x4);
-  
+
   /* t1[0] = k * p - o * l;
      t1[0] = k * p - o * l;
      t2[0] = g * p - o * h;
      t3[0] = g * l - k * h; */
   t0 = glmm_fnmadd(x2, x0, t0);
-  
+
   /* t1[1] = j * p - n * l;
      t1[1] = j * p - n * l;
      t2[1] = f * p - n * h;
      t3[1] = f * l - j * h; */
    t1 = glmm_fnmadd(x4, x0, t1);
-  
+
   /* t1[2] = j * o - n * k
      t1[2] = j * o - n * k;
      t2[2] = f * o - n * g;
      t3[2] = f * k - j * g; */
   t2 = glmm_fnmadd(x4, x3, t2);
-  
+
   /* t1[3] = i * p - m * l;
      t1[3] = i * p - m * l;
      t2[3] = e * p - m * h;
      t3[3] = e * l - i * h; */
   t3 = glmm_fnmadd(x7, x0, t3);
-  
+
   /* t1[4] = i * o - m * k;
      t1[4] = i * o - m * k;
      t2[4] = e * o - m * g;
      t3[4] = e * k - i * g; */
   t4 = glmm_fnmadd(x7, x3, t4);
-  
+
   /* t1[5] = i * n - m * j;
      t1[5] = i * n - m * j;
      t2[5] = e * n - m * f;
      t3[5] = e * j - i * f; */
   t5 = glmm_fnmadd(x7, x5, t5);
-  
+
   x4 = _mm_movelh_ps(r0, r1);        /* f e b a */
   x5 = _mm_movehl_ps(r1, r0);        /* h g d c */
-  
+
   x0 = glmm_shuff1(x4, 0, 0, 0, 2);  /* a a a e */
   x1 = glmm_shuff1(x4, 1, 1, 1, 3);  /* b b b f */
   x2 = glmm_shuff1(x5, 0, 0, 0, 2);  /* c c c g */
   x3 = glmm_shuff1(x5, 1, 1, 1, 3);  /* d d d h */
-  
+
   v2 = _mm_mul_ps(x0, t1);
   v1 = _mm_mul_ps(x0, t0);
   v3 = _mm_mul_ps(x0, t2);
   v0 = _mm_mul_ps(x1, t0);
-  
+
   v2 = glmm_fnmadd(x1, t3, v2);
   v3 = glmm_fnmadd(x1, t4, v3);
   v0 = glmm_fnmadd(x2, t1, v0);
   v1 = glmm_fnmadd(x2, t3, v1);
-  
+
   v3 = glmm_fmadd(x2, t5, v3);
   v0 = glmm_fmadd(x3, t2, v0);
   v2 = glmm_fmadd(x3, t5, v2);
@@ -399,7 +398,7 @@ glm_mat4_inv_sse2(mat4 mat, mat4 dest) {
    dest[0][2] =  b * t2[0] - c * t2[1] + d * t2[2];
    dest[0][3] =-(b * t3[0] - c * t3[1] + d * t3[2]); */
   v0 = _mm_xor_ps(v0, x8);
-  
+
   /*
    dest[2][0] =  e * t1[1] - f * t1[3] + h * t1[5];
    dest[2][1] =-(a * t1[1] - b * t1[3] + d * t1[5]);
@@ -437,7 +436,7 @@ glm_mat4_inv_sse2(mat4 mat, mat4 dest) {
 
 CGLM_INLINE
 void
-glm_mat4_inv_sse2(mat4 mat, mat4 dest) {
+glm_mat4_inv_sse2(CGLM_IN(mat4) mat, mat4 dest) {
   __m128 r0, r1, r2, r3, s1, s2,
          v0, v1, v2, v3, v4, v5,
          t0, t1, t2,
@@ -452,7 +451,7 @@ glm_mat4_inv_sse2(mat4 mat, mat4 dest) {
   r0 = glmm_load(mat[0]); /* d c b a */
   r3 = glmm_load(mat[3]); /* p o n m */
   r2 = glmm_load(mat[2]); /* l k j i */
-  
+
   x4  = _mm_unpackhi_ps(r0, r2); /* l d k c */
   x5  = _mm_unpacklo_ps(r0, r2); /* j b i a */
   x6  = _mm_unpackhi_ps(r1, r3); /* p h o g */
@@ -481,7 +480,7 @@ glm_mat4_inv_sse2(mat4 mat, mat4 dest) {
   x12 = _mm_movelh_ps(x4, x5);                           /* i a k c */
   x13 = _mm_movelh_ps(x6, x7);                           /* m e o g */
 #endif
-  
+
   t0 = _mm_mul_ps(x12, x10);
   t1 = _mm_mul_ps(x5, x6);
   t2 = _mm_mul_ps(x5, x9);
@@ -498,13 +497,13 @@ glm_mat4_inv_sse2(mat4 mat, mat4 dest) {
   v0 = glmm_shuff1(t2, 2, 3, 0, 1);
   v1 = glmm_shuff1(t1, 0, 1, 2, 3);
   v0 = _mm_mul_ps(t0, v0);
-  v1 = _mm_mul_ps(t1, v1);  
+  v1 = _mm_mul_ps(t1, v1);
   v2 = glmm_shuff1(v1, 1, 0, 0, 1);
   v3 = glmm_shuff1(v0, 0, 1, 2, 3);
   v1 = _mm_add_ps(v1, v2);
   v0 = _mm_add_ps(v0, v3);
   v2 = glmm_shuff1(v0, 1, 0, 0, 1);
-  v0 = _mm_add_ps(v0, v2); 
+  v0 = _mm_add_ps(v0, v2);
 
   v0 = _mm_sub_ps(v0, v1); /* det */
   v0 = _mm_div_ps(v5, v0); /* idt */
@@ -527,17 +526,17 @@ glm_mat4_inv_sse2(mat4 mat, mat4 dest) {
      dest[0][1] = (b * c1  - c * c5  + d * c9)  * ndt;
      dest[0][2] = (n * c2  - o * c6  + p * c10) * idt;
      dest[0][3] = (j * c2  - k * c6  + l * c10) * ndt;
-  
+
      dest[1][0] = (e * c1  - g * c3  + h * c11) * ndt;
      dest[1][1] = (a * c1  - c * c3  + d * c11) * idt;
      dest[1][2] = (m * c2  - o * c4  + p * c12) * ndt;
      dest[1][3] = (i * c2  - k * c4  + l * c12) * idt;
-  
+
      dest[2][0] = (e * c5  - f * c3  + h * c7)  * idt;
      dest[2][1] = (a * c5  - b * c3  + d * c7)  * ndt;
      dest[2][2] = (m * c6  - n * c4  + p * c8)  * idt;
      dest[2][3] = (i * c6  - j * c4  + l * c8)  * ndt;
-  
+
      dest[3][0] = (e * c9  - f * c11 + g * c7)  * ndt;
      dest[3][1] = (a * c9  - b * c11 + c * c7)  * idt;
      dest[3][2] = (m * c10 - n * c12 + o * c8)  * ndt;
diff --git a/include/cglm/simd/wasm/affine.h b/include/cglm/simd/wasm/affine.h
index 80b98fb9b..0f41bf5f8 100644
--- a/include/cglm/simd/wasm/affine.h
+++ b/include/cglm/simd/wasm/affine.h
@@ -14,7 +14,7 @@
 
 CGLM_INLINE
 void
-glm_mul_wasm(mat4 m1, mat4 m2, mat4 dest) {
+glm_mul_wasm(CGLM_IN(mat4) m1, CGLM_IN(mat4) m2, mat4 dest) {
   /* D = R * L (Column-Major) */
   glmm_128 l, r0, r1, r2, r3, v0, v1, v2, v3;
 
@@ -52,7 +52,7 @@ glm_mul_wasm(mat4 m1, mat4 m2, mat4 dest) {
 
 CGLM_INLINE
 void
-glm_mul_rot_wasm(mat4 m1, mat4 m2, mat4 dest) {
+glm_mul_rot_wasm(CGLM_IN(mat4) m1, CGLM_IN(mat4) m2, mat4 dest) {
   /* D = R * L (Column-Major) */
 
   glmm_128 l, r0, r1, r2, v0, v1, v2;
diff --git a/include/cglm/simd/wasm/mat2.h b/include/cglm/simd/wasm/mat2.h
index 80ce0fb87..001339d6c 100644
--- a/include/cglm/simd/wasm/mat2.h
+++ b/include/cglm/simd/wasm/mat2.h
@@ -14,7 +14,7 @@
 
 CGLM_INLINE
 void
-glm_mat2_mul_wasm(mat2 m1, mat2 m2, mat2 dest) {
+glm_mat2_mul_wasm(CGLM_IN(mat2) m1, CGLM_IN(mat2) m2, mat2 dest) {
   glmm_128 x0, x1, x2, x3, x4;
 
   x1 = glmm_load(m1[0]); /* d c b a */
@@ -40,7 +40,7 @@ glm_mat2_mul_wasm(mat2 m1, mat2 m2, mat2 dest) {
 
 CGLM_INLINE
 void
-glm_mat2_transp_wasm(mat2 m, mat2 dest) {
+glm_mat2_transp_wasm(CGLM_IN(mat2) m, mat2 dest) {
   /* d c b a */
   /* d b c a */
   glmm_store(dest[0], glmm_shuff1(glmm_load(m[0]), 3, 1, 2, 0));
diff --git a/include/cglm/simd/wasm/mat3.h b/include/cglm/simd/wasm/mat3.h
index dfe192d18..ab34fb708 100644
--- a/include/cglm/simd/wasm/mat3.h
+++ b/include/cglm/simd/wasm/mat3.h
@@ -14,9 +14,9 @@
 
 CGLM_INLINE
 void
-glm_mat3_mul_wasm(mat3 m1, mat3 m2, mat3 dest) {
+glm_mat3_mul_wasm(CGLM_IN(mat3) m1, CGLM_IN(mat3) m2, mat3 dest) {
   glmm_128 l0, l1, l2, r0, r1, r2, x0, x1, x2, x3, x4, x5, x6, x7, x8, x9;
-  
+
   l0 = wasm_v128_load(m1[0]);
   l1 = wasm_v128_load(&m1[1][1]);
 
@@ -55,7 +55,7 @@ glm_mat3_mul_wasm(mat3 m1, mat3 m2, mat3 dest) {
   x3 = glmm_shuff1(x2, 0, 2, 1, 0);                     /* a20 a22 a21 a20 */
   x2 = glmm_shuff1(x2, 1, 0, 2, 1);                     /* a21 a20 a22 a21 */
   x4 = wasm_i32x4_shuffle(r0, r1, 2, 2, 5, 5);          /* b12 b12 b02 b02 */
-  
+
   x5 = glmm_shuff1(x4, 3, 0, 0, 0);                     /* b12 b02 b02 b02 */
   /* x4 = _mm_movehl_ps(r2, x4); */
   x4 = wasm_i32x4_shuffle(r2, x4, 6, 7, 2, 3);          /* b22 b22 b12 b12 */
diff --git a/include/cglm/simd/wasm/mat4.h b/include/cglm/simd/wasm/mat4.h
index 79ed6885a..408b680ee 100644
--- a/include/cglm/simd/wasm/mat4.h
+++ b/include/cglm/simd/wasm/mat4.h
@@ -28,7 +28,7 @@ glm_mat4_scale_wasm(mat4 m, float s) {
 
 CGLM_INLINE
 void
-glm_mat4_transp_wasm(mat4 m, mat4 dest) {
+glm_mat4_transp_wasm(CGLM_IN(mat4) m, mat4 dest) {
   glmm_128 r0, r1, r2, r3, tmp0, tmp1, tmp2, tmp3;
 
   r0 = glmm_load(m[0]);
@@ -100,7 +100,7 @@ glm_mat4_mul_wasm(mat4 m1, mat4 m2, mat4 dest) {
 
 CGLM_INLINE
 void
-glm_mat4_mulv_wasm(mat4 m, vec4 v, vec4 dest) {
+glm_mat4_mulv_wasm(CGLM_IN(mat4) m, const vec4 v, vec4 dest) {
   glmm_128 x0, x1, m0, m1, m2, m3, v0, v1, v2, v3;
 
   m0 = glmm_load(m[0]);
@@ -166,7 +166,7 @@ glm_mat4_det_wasm(mat4 mat) {
                   x2);
   /* x2 = wasm_v128_xor(x2, wasm_f32x4_const(0.f, -0.f, 0.f, -0.f)); */
   x2 = wasm_v128_xor(x2, glmm_float32x4_SIGNMASK_PNPN);
-  
+
   return glmm_hadd(wasm_f32x4_mul(x2, r0));
 }
 
@@ -200,44 +200,44 @@ glm_mat4_inv_fast_wasm(mat4 mat, mat4 dest) {
   x5 = wasm_i32x4_shuffle(r2, r1, 1, 1, 5, 5);           /* f f j j */
   x3 = wasm_i32x4_shuffle(r2, r1, 2, 2, 6, 6);           /* g g k k */
   x0 = wasm_i32x4_shuffle(r2, r1, 3, 3, 7, 7);           /* h h l l */
-  
+
   t0 = wasm_f32x4_mul(x3, x1);
   t1 = wasm_f32x4_mul(x5, x1);
   t2 = wasm_f32x4_mul(x5, x2);
   t3 = wasm_f32x4_mul(x6, x1);
   t4 = wasm_f32x4_mul(x6, x2);
   t5 = wasm_f32x4_mul(x6, x4);
-  
+
   /* t1[0] = k * p - o * l;
      t1[0] = k * p - o * l;
      t2[0] = g * p - o * h;
      t3[0] = g * l - k * h; */
   t0 = glmm_fnmadd(x2, x0, t0);
-  
+
   /* t1[1] = j * p - n * l;
      t1[1] = j * p - n * l;
      t2[1] = f * p - n * h;
      t3[1] = f * l - j * h; */
    t1 = glmm_fnmadd(x4, x0, t1);
-  
+
   /* t1[2] = j * o - n * k
      t1[2] = j * o - n * k;
      t2[2] = f * o - n * g;
      t3[2] = f * k - j * g; */
   t2 = glmm_fnmadd(x4, x3, t2);
-  
+
   /* t1[3] = i * p - m * l;
      t1[3] = i * p - m * l;
      t2[3] = e * p - m * h;
      t3[3] = e * l - i * h; */
   t3 = glmm_fnmadd(x7, x0, t3);
-  
+
   /* t1[4] = i * o - m * k;
      t1[4] = i * o - m * k;
      t2[4] = e * o - m * g;
      t3[4] = e * k - i * g; */
   t4 = glmm_fnmadd(x7, x3, t4);
-  
+
   /* t1[5] = i * n - m * j;
      t1[5] = i * n - m * j;
      t2[5] = e * n - m * f;
@@ -247,22 +247,22 @@ glm_mat4_inv_fast_wasm(mat4 mat, mat4 dest) {
   x4 = wasm_i32x4_shuffle(r0, r1, 0, 1, 4, 5);           /* f e b a */
   /* x5 = _mm_movehl_ps(r1, r0); */
   x5 = wasm_i32x4_shuffle(r1, r0, 6, 7, 2, 3);           /* h g d c */
-  
+
   x0 = glmm_shuff1(x4, 0, 0, 0, 2);                      /* a a a e */
   x1 = glmm_shuff1(x4, 1, 1, 1, 3);                      /* b b b f */
   x2 = glmm_shuff1(x5, 0, 0, 0, 2);                      /* c c c g */
   x3 = glmm_shuff1(x5, 1, 1, 1, 3);                      /* d d d h */
-  
+
   v2 = wasm_f32x4_mul(x0, t1);
   v1 = wasm_f32x4_mul(x0, t0);
   v3 = wasm_f32x4_mul(x0, t2);
   v0 = wasm_f32x4_mul(x1, t0);
-  
+
   v2 = glmm_fnmadd(x1, t3, v2);
   v3 = glmm_fnmadd(x1, t4, v3);
   v0 = glmm_fnmadd(x2, t1, v0);
   v1 = glmm_fnmadd(x2, t3, v1);
-  
+
   v3 = glmm_fmadd(x2, t5, v3);
   v0 = glmm_fmadd(x3, t2, v0);
   v2 = glmm_fmadd(x3, t5, v2);
@@ -274,7 +274,7 @@ glm_mat4_inv_fast_wasm(mat4 mat, mat4 dest) {
    dest[0][2] =  b * t2[0] - c * t2[1] + d * t2[2];
    dest[0][3] =-(b * t3[0] - c * t3[1] + d * t3[2]); */
   v0 = wasm_v128_xor(v0, x8);
-  
+
   /*
    dest[2][0] =  e * t1[1] - f * t1[3] + h * t1[5];
    dest[2][1] =-(a * t1[1] - b * t1[3] + d * t1[5]);
@@ -341,44 +341,44 @@ glm_mat4_inv_wasm(mat4 mat, mat4 dest) {
   x5 = wasm_i32x4_shuffle(r2, r1, 1, 1, 5, 5);           /* f f j j */
   x3 = wasm_i32x4_shuffle(r2, r1, 2, 2, 6, 6);           /* g g k k */
   x0 = wasm_i32x4_shuffle(r2, r1, 3, 3, 7, 7);           /* h h l l */
-  
+
   t0 = wasm_f32x4_mul(x3, x1);
   t1 = wasm_f32x4_mul(x5, x1);
   t2 = wasm_f32x4_mul(x5, x2);
   t3 = wasm_f32x4_mul(x6, x1);
   t4 = wasm_f32x4_mul(x6, x2);
   t5 = wasm_f32x4_mul(x6, x4);
-  
+
   /* t1[0] = k * p - o * l;
      t1[0] = k * p - o * l;
      t2[0] = g * p - o * h;
      t3[0] = g * l - k * h; */
   t0 = glmm_fnmadd(x2, x0, t0);
-  
+
   /* t1[1] = j * p - n * l;
      t1[1] = j * p - n * l;
      t2[1] = f * p - n * h;
      t3[1] = f * l - j * h; */
    t1 = glmm_fnmadd(x4, x0, t1);
-  
+
   /* t1[2] = j * o - n * k
      t1[2] = j * o - n * k;
      t2[2] = f * o - n * g;
      t3[2] = f * k - j * g; */
   t2 = glmm_fnmadd(x4, x3, t2);
-  
+
   /* t1[3] = i * p - m * l;
      t1[3] = i * p - m * l;
      t2[3] = e * p - m * h;
      t3[3] = e * l - i * h; */
   t3 = glmm_fnmadd(x7, x0, t3);
-  
+
   /* t1[4] = i * o - m * k;
      t1[4] = i * o - m * k;
      t2[4] = e * o - m * g;
      t3[4] = e * k - i * g; */
   t4 = glmm_fnmadd(x7, x3, t4);
-  
+
   /* t1[5] = i * n - m * j;
      t1[5] = i * n - m * j;
      t2[5] = e * n - m * f;
@@ -388,22 +388,22 @@ glm_mat4_inv_wasm(mat4 mat, mat4 dest) {
   x4 = wasm_i32x4_shuffle(r0, r1, 0, 1, 4, 5);           /* f e b a */
   /* x5 = _mm_movehl_ps(r1, r0); */
   x5 = wasm_i32x4_shuffle(r1, r0, 6, 7, 2, 3);           /* h g d c */
-  
+
   x0 = glmm_shuff1(x4, 0, 0, 0, 2);                      /* a a a e */
   x1 = glmm_shuff1(x4, 1, 1, 1, 3);                      /* b b b f */
   x2 = glmm_shuff1(x5, 0, 0, 0, 2);                      /* c c c g */
   x3 = glmm_shuff1(x5, 1, 1, 1, 3);                      /* d d d h */
-  
+
   v2 = wasm_f32x4_mul(x0, t1);
   v1 = wasm_f32x4_mul(x0, t0);
   v3 = wasm_f32x4_mul(x0, t2);
   v0 = wasm_f32x4_mul(x1, t0);
-  
+
   v2 = glmm_fnmadd(x1, t3, v2);
   v3 = glmm_fnmadd(x1, t4, v3);
   v0 = glmm_fnmadd(x2, t1, v0);
   v1 = glmm_fnmadd(x2, t3, v1);
-  
+
   v3 = glmm_fmadd(x2, t5, v3);
   v0 = glmm_fmadd(x3, t2, v0);
   v2 = glmm_fmadd(x3, t5, v2);
@@ -415,7 +415,7 @@ glm_mat4_inv_wasm(mat4 mat, mat4 dest) {
    dest[0][2] =  b * t2[0] - c * t2[1] + d * t2[2];
    dest[0][3] =-(b * t3[0] - c * t3[1] + d * t3[2]); */
   v0 = wasm_v128_xor(v0, x8);
-  
+
   /*
    dest[2][0] =  e * t1[1] - f * t1[3] + h * t1[5];
    dest[2][1] =-(a * t1[1] - b * t1[3] + d * t1[5]);
diff --git a/include/cglm/simd/wasm/quat.h b/include/cglm/simd/wasm/quat.h
index 8d72546d1..6f41d8220 100644
--- a/include/cglm/simd/wasm/quat.h
+++ b/include/cglm/simd/wasm/quat.h
@@ -39,11 +39,11 @@ glm_quat_mul_wasm(versor p, versor q, versor dest) {
   x  = wasm_v128_xor(x, x1);
   y  = wasm_v128_xor(y, x2);
   z  = wasm_v128_xor(z, x3);
-  
+
   x1 = glmm_shuff1(xq, 0, 1, 2, 3);
   x2 = glmm_shuff1(xq, 1, 0, 3, 2);
   x3 = glmm_shuff1(xq, 2, 3, 0, 1);
-  
+
   r  = glmm_fmadd(x, x1, r);
   r  = glmm_fmadd(y, x2, r);
   r  = glmm_fmadd(z, x3, r);
diff --git a/include/cglm/sphere.h b/include/cglm/sphere.h
index 334b83ae8..c3d42d9dc 100644
--- a/include/cglm/sphere.h
+++ b/include/cglm/sphere.h
@@ -27,7 +27,7 @@
  */
 CGLM_INLINE
 float
-glm_sphere_radii(vec4 s) {
+glm_sphere_radii(const vec4 s) {
   return s[3];
 }
 
@@ -40,7 +40,7 @@ glm_sphere_radii(vec4 s) {
  */
 CGLM_INLINE
 void
-glm_sphere_transform(vec4 s, mat4 m, vec4 dest) {
+glm_sphere_transform(const vec4 s, CGLM_IN(mat4) m, vec4 dest) {
   glm_mat4_mulv3(m, s, 1.0f, dest);
   dest[3] = s[3];
 }
@@ -57,7 +57,7 @@ glm_sphere_transform(vec4 s, mat4 m, vec4 dest) {
  */
 CGLM_INLINE
 void
-glm_sphere_merge(vec4 s1, vec4 s2, vec4 dest) {
+glm_sphere_merge(const vec4 s1, const vec4 s2, vec4 dest) {
   float dist, radii;
 
   dist  = glm_vec3_distance(s1, s2);
@@ -78,7 +78,7 @@ glm_sphere_merge(vec4 s1, vec4 s2, vec4 dest) {
  */
 CGLM_INLINE
 bool
-glm_sphere_sphere(vec4 s1, vec4 s2) {
+glm_sphere_sphere(const vec4 s1, const vec4 s2) {
   return glm_vec3_distance2(s1, s2) <= glm_pow2(s1[3] + s2[3]);
 }
 
@@ -90,7 +90,7 @@ glm_sphere_sphere(vec4 s1, vec4 s2) {
  */
 CGLM_INLINE
 bool
-glm_sphere_point(vec4 s, vec3 point) {
+glm_sphere_point(const vec4 s, const vec3 point) {
   float rr;
   rr = s[3] * s[3];
   return glm_vec3_distance2(point, s) <= rr;
diff --git a/include/cglm/vec2-ext.h b/include/cglm/vec2-ext.h
index 2f47478e2..52871803d 100644
--- a/include/cglm/vec2-ext.h
+++ b/include/cglm/vec2-ext.h
@@ -8,27 +8,27 @@
 /*
  Functions:
    CGLM_INLINE void  glm_vec2_fill(vec2 v, float val)
-   CGLM_INLINE bool  glm_vec2_eq(vec2 v, float val);
-   CGLM_INLINE bool  glm_vec2_eq_eps(vec2 v, float val);
-   CGLM_INLINE bool  glm_vec2_eq_all(vec2 v);
-   CGLM_INLINE bool  glm_vec2_eqv(vec2 a, vec2 b);
-   CGLM_INLINE bool  glm_vec2_eqv_eps(vec2 a, vec2 b);
-   CGLM_INLINE float glm_vec2_max(vec2 v);
-   CGLM_INLINE float glm_vec2_min(vec2 v);
-   CGLM_INLINE bool  glm_vec2_isnan(vec2 v);
-   CGLM_INLINE bool  glm_vec2_isinf(vec2 v);
-   CGLM_INLINE bool  glm_vec2_isvalid(vec2 v);
-   CGLM_INLINE void  glm_vec2_sign(vec2 v, vec2 dest);
-   CGLM_INLINE void  glm_vec2_abs(vec2 v, vec2 dest);
-   CGLM_INLINE void  glm_vec2_fract(vec2 v, vec2 dest);
-   CGLM_INLINE void  glm_vec2_floor(vec2 v, vec2 dest);
-   CGLM_INLINE float glm_vec2_mods(vec2 v, float s, vec2 dest);
-   CGLM_INLINE float glm_vec2_steps(float edge, vec2 v, vec2 dest);
-   CGLM_INLINE void  glm_vec2_stepr(vec2 edge, float v, vec2 dest);
-   CGLM_INLINE void  glm_vec2_sqrt(vec2 v, vec2 dest);
-   CGLM_INLINE void  glm_vec2_complex_mul(vec2 a, vec2 b, vec2 dest)
-   CGLM_INLINE void  glm_vec2_complex_div(vec2 a, vec2 b, vec2 dest)
-   CGLM_INLINE void  glm_vec2_complex_conjugate(vec2 a, vec2 dest)
+   CGLM_INLINE bool  glm_vec2_eq(const vec2 v, float val);
+   CGLM_INLINE bool  glm_vec2_eq_eps(const vec2 v, float val);
+   CGLM_INLINE bool  glm_vec2_eq_all(const vec2 v);
+   CGLM_INLINE bool  glm_vec2_eqv(const vec2 a, const vec2 b);
+   CGLM_INLINE bool  glm_vec2_eqv_eps(const vec2 a, const vec2 b);
+   CGLM_INLINE float glm_vec2_max(const vec2 v);
+   CGLM_INLINE float glm_vec2_min(const vec2 v);
+   CGLM_INLINE bool  glm_vec2_isnan(const vec2 v);
+   CGLM_INLINE bool  glm_vec2_isinf(const vec2 v);
+   CGLM_INLINE bool  glm_vec2_isvalid(const vec2 v);
+   CGLM_INLINE void  glm_vec2_sign(const vec2 v, vec2 dest);
+   CGLM_INLINE void  glm_vec2_abs(const vec2 v, vec2 dest);
+   CGLM_INLINE void  glm_vec2_fract(const vec2 v, vec2 dest);
+   CGLM_INLINE void  glm_vec2_floor(const vec2 v, vec2 dest);
+   CGLM_INLINE float glm_vec2_mods(const vec2 v, float s, vec2 dest);
+   CGLM_INLINE float glm_vec2_steps(float edge, const vec2 v, vec2 dest);
+   CGLM_INLINE void  glm_vec2_stepr(const vec2 edge, float v, vec2 dest);
+   CGLM_INLINE void  glm_vec2_sqrt(const vec2 v, vec2 dest);
+   CGLM_INLINE void  glm_vec2_complex_mul(const vec2 a, const vec2 b, vec2 dest)
+   CGLM_INLINE void  glm_vec2_complex_div(const vec2 a, const vec2 b, vec2 dest)
+   CGLM_INLINE void  glm_vec2_complex_conjugate(const vec2 a, vec2 dest)
  */
 
 #ifndef cglm_vec2_ext_h
@@ -57,7 +57,7 @@ glm_vec2_fill(vec2 v, float val) {
  */
 CGLM_INLINE
 bool
-glm_vec2_eq(vec2 v, float val) {
+glm_vec2_eq(const vec2 v, float val) {
   return v[0] == val && v[0] == v[1];
 }
 
@@ -69,7 +69,7 @@ glm_vec2_eq(vec2 v, float val) {
  */
 CGLM_INLINE
 bool
-glm_vec2_eq_eps(vec2 v, float val) {
+glm_vec2_eq_eps(const vec2 v, float val) {
   return fabsf(v[0] - val) <= GLM_FLT_EPSILON
          && fabsf(v[1] - val) <= GLM_FLT_EPSILON;
 }
@@ -81,7 +81,7 @@ glm_vec2_eq_eps(vec2 v, float val) {
  */
 CGLM_INLINE
 bool
-glm_vec2_eq_all(vec2 v) {
+glm_vec2_eq_all(const vec2 v) {
   return glm_vec2_eq_eps(v, v[0]);
 }
 
@@ -93,7 +93,7 @@ glm_vec2_eq_all(vec2 v) {
  */
 CGLM_INLINE
 bool
-glm_vec2_eqv(vec2 a, vec2 b) {
+glm_vec2_eqv(const vec2 a, const vec2 b) {
   return a[0] == b[0] && a[1] == b[1];
 }
 
@@ -105,7 +105,7 @@ glm_vec2_eqv(vec2 a, vec2 b) {
  */
 CGLM_INLINE
 bool
-glm_vec2_eqv_eps(vec2 a, vec2 b) {
+glm_vec2_eqv_eps(const vec2 a, const vec2 b) {
   return fabsf(a[0] - b[0]) <= GLM_FLT_EPSILON
          && fabsf(a[1] - b[1]) <= GLM_FLT_EPSILON;
 }
@@ -117,7 +117,7 @@ glm_vec2_eqv_eps(vec2 a, vec2 b) {
  */
 CGLM_INLINE
 float
-glm_vec2_max(vec2 v) {
+glm_vec2_max(const vec2 v) {
   return glm_max(v[0], v[1]);
 }
 
@@ -128,7 +128,7 @@ glm_vec2_max(vec2 v) {
  */
 CGLM_INLINE
 float
-glm_vec2_min(vec2 v) {
+glm_vec2_min(const vec2 v) {
   return glm_min(v[0], v[1]);
 }
 
@@ -140,7 +140,7 @@ glm_vec2_min(vec2 v) {
  */
 CGLM_INLINE
 bool
-glm_vec2_isnan(vec2 v) {
+glm_vec2_isnan(const vec2 v) {
 #ifndef CGLM_FAST_MATH
   return isnan(v[0]) || isnan(v[1]);
 #else
@@ -157,7 +157,7 @@ glm_vec2_isnan(vec2 v) {
  */
 CGLM_INLINE
 bool
-glm_vec2_isinf(vec2 v) {
+glm_vec2_isinf(const vec2 v) {
 #ifndef CGLM_FAST_MATH
   return isinf(v[0]) || isinf(v[1]);
 #else
@@ -174,7 +174,7 @@ glm_vec2_isinf(vec2 v) {
  */
 CGLM_INLINE
 bool
-glm_vec2_isvalid(vec2 v) {
+glm_vec2_isvalid(const vec2 v) {
   return !glm_vec2_isnan(v) && !glm_vec2_isinf(v);
 }
 
@@ -187,7 +187,7 @@ glm_vec2_isvalid(vec2 v) {
  */
 CGLM_INLINE
 void
-glm_vec2_sign(vec2 v, vec2 dest) {
+glm_vec2_sign(const vec2 v, vec2 dest) {
   dest[0] = glm_signf(v[0]);
   dest[1] = glm_signf(v[1]);
 }
@@ -200,7 +200,7 @@ glm_vec2_sign(vec2 v, vec2 dest) {
  */
 CGLM_INLINE
 void
-glm_vec2_abs(vec2 v, vec2 dest) {
+glm_vec2_abs(const vec2 v, vec2 dest) {
   dest[0] = fabsf(v[0]);
   dest[1] = fabsf(v[1]);
 }
@@ -213,7 +213,7 @@ glm_vec2_abs(vec2 v, vec2 dest) {
  */
 CGLM_INLINE
 void
-glm_vec2_fract(vec2 v, vec2 dest) {
+glm_vec2_fract(const vec2 v, vec2 dest) {
   dest[0] = fminf(v[0] - floorf(v[0]), 0.999999940395355224609375f);
   dest[1] = fminf(v[1] - floorf(v[1]), 0.999999940395355224609375f);
 }
@@ -226,7 +226,7 @@ glm_vec2_fract(vec2 v, vec2 dest) {
  */
 CGLM_INLINE
 void
-glm_vec2_floor(vec2 v, vec2 dest) {
+glm_vec2_floor(const vec2 v, vec2 dest) {
   dest[0] = floorf(v[0]);
   dest[1] = floorf(v[1]);
 }
@@ -240,7 +240,7 @@ glm_vec2_floor(vec2 v, vec2 dest) {
  */
 CGLM_INLINE
 void
-glm_vec2_mods(vec2 v, float s, vec2 dest) {
+glm_vec2_mods(const vec2 v, float s, vec2 dest) {
   dest[0] = fmodf(v[0], s);
   dest[1] = fmodf(v[1], s);
 }
@@ -253,7 +253,7 @@ glm_vec2_mods(vec2 v, float s, vec2 dest) {
  */
 CGLM_INLINE
 void
-glm_vec2_sqrt(vec2 v, vec2 dest) {
+glm_vec2_sqrt(const vec2 v, vec2 dest) {
   dest[0] = sqrtf(v[0]);
   dest[1] = sqrtf(v[1]);
 }
@@ -267,7 +267,7 @@ glm_vec2_sqrt(vec2 v, vec2 dest) {
  */
 CGLM_INLINE
 void
-glm_vec2_complex_mul(vec2 a, vec2 b, vec2 dest) {
+glm_vec2_complex_mul(const vec2 a, const vec2 b, vec2 dest) {
   float tr, ti;
   tr = a[0] * b[0] - a[1] * b[1];
   ti = a[0] * b[1] + a[1] * b[0];
@@ -285,7 +285,7 @@ glm_vec2_complex_mul(vec2 a, vec2 b, vec2 dest) {
  */
 CGLM_INLINE
 void
-glm_vec2_steps(float edge, vec2 x, vec2 dest) {
+glm_vec2_steps(float edge, const vec2 x, vec2 dest) {
   dest[0] = glm_step(edge, x[0]);
   dest[1] = glm_step(edge, x[1]);
 }
@@ -300,7 +300,7 @@ glm_vec2_steps(float edge, vec2 x, vec2 dest) {
  */
 CGLM_INLINE
 void
-glm_vec2_stepr(vec2 edge, float x, vec2 dest) {
+glm_vec2_stepr(const vec2 edge, float x, vec2 dest) {
   dest[0] = glm_step(edge[0], x);
   dest[1] = glm_step(edge[1], x);
 }
@@ -314,7 +314,7 @@ glm_vec2_stepr(vec2 edge, float x, vec2 dest) {
  */
 CGLM_INLINE
 void
-glm_vec2_complex_div(vec2 a, vec2 b, vec2 dest) {
+glm_vec2_complex_div(const vec2 a, const vec2 b, vec2 dest) {
   float tr, ti;
   float const ibnorm2 = 1.0f / (b[0] * b[0] + b[1] * b[1]);
   tr = ibnorm2 * (a[0] * b[0] + a[1] * b[1]);
@@ -331,7 +331,7 @@ glm_vec2_complex_div(vec2 a, vec2 b, vec2 dest) {
  */
 CGLM_INLINE
 void
-glm_vec2_complex_conjugate(vec2 a, vec2 dest) {
+glm_vec2_complex_conjugate(const vec2 a, vec2 dest) {
   dest[0] =  a[0];
   dest[1] = -a[1];
 }
diff --git a/include/cglm/vec2.h b/include/cglm/vec2.h
index 0f4d749c1..f520ab74d 100644
--- a/include/cglm/vec2.h
+++ b/include/cglm/vec2.h
@@ -13,52 +13,52 @@
    GLM_VEC2_ZERO
 
  Functions:
-   CGLM_INLINE void  glm_vec2(float * __restrict v, vec2 dest)
-   CGLM_INLINE void  glm_vec2_copy(vec2 a, vec2 dest)
+   CGLM_INLINE void  glm_vec2(const float * __restrict v, vec2 dest)
+   CGLM_INLINE void  glm_vec2_copy(const vec2 a, vec2 dest)
    CGLM_INLINE void  glm_vec2_zero(vec2 v)
    CGLM_INLINE void  glm_vec2_one(vec2 v)
-   CGLM_INLINE float glm_vec2_dot(vec2 a, vec2 b)
-   CGLM_INLINE float glm_vec2_cross(vec2 a, vec2 b)
-   CGLM_INLINE float glm_vec2_norm2(vec2 v)
-   CGLM_INLINE float glm_vec2_norm(vec2 vec)
-   CGLM_INLINE void  glm_vec2_add(vec2 a, vec2 b, vec2 dest)
-   CGLM_INLINE void  glm_vec2_adds(vec2 v, float s, vec2 dest)
-   CGLM_INLINE void  glm_vec2_sub(vec2 a, vec2 b, vec2 dest)
-   CGLM_INLINE void  glm_vec2_subs(vec2 v, float s, vec2 dest)
-   CGLM_INLINE void  glm_vec2_mul(vec2 a, vec2 b, vec2 d)
-   CGLM_INLINE void  glm_vec2_scale(vec2 v, float s, vec2 dest)
-   CGLM_INLINE void  glm_vec2_scale_as(vec2 v, float s, vec2 dest)
-   CGLM_INLINE void  glm_vec2_div(vec2 a, vec2 b, vec2 dest)
-   CGLM_INLINE void  glm_vec2_divs(vec2 v, float s, vec2 dest)
-   CGLM_INLINE void  glm_vec2_addadd(vec2 a, vec2 b, vec2 dest)
-   CGLM_INLINE void  glm_vec2_subadd(vec2 a, vec2 b, vec2 dest)
-   CGLM_INLINE void  glm_vec2_muladd(vec2 a, vec2 b, vec2 dest)
-   CGLM_INLINE void  glm_vec2_muladds(vec2 a, float s, vec2 dest)
-   CGLM_INLINE void  glm_vec2_maxadd(vec2 a, vec2 b, vec2 dest)
-   CGLM_INLINE void  glm_vec2_minadd(vec2 a, vec2 b, vec2 dest)
-   CGLM_INLINE void  glm_vec2_subsub(vec2 a, vec2 b, vec2 dest)
-   CGLM_INLINE void  glm_vec2_addsub(vec2 a, vec2 b, vec2 dest)
-   CGLM_INLINE void  glm_vec2_mulsub(vec2 a, vec2 b, vec2 dest)
-   CGLM_INLINE void  glm_vec2_mulsubs(vec2 a, float s, vec2 dest)
-   CGLM_INLINE void  glm_vec2_maxsub(vec2 a, vec2 b, vec2 dest)
-   CGLM_INLINE void  glm_vec2_minsub(vec2 a, vec2 b, vec2 dest)
-   CGLM_INLINE void  glm_vec2_negate_to(vec2 v, vec2 dest)
+   CGLM_INLINE float glm_vec2_dot(const vec2 a, const vec2 b)
+   CGLM_INLINE float glm_vec2_cross(const vec2 a, const vec2 b)
+   CGLM_INLINE float glm_vec2_norm2(const vec2 v)
+   CGLM_INLINE float glm_vec2_norm(const vec2 vec)
+   CGLM_INLINE void  glm_vec2_add(const vec2 a, const vec2 b, vec2 dest)
+   CGLM_INLINE void  glm_vec2_adds(const vec2 v, float s, vec2 dest)
+   CGLM_INLINE void  glm_vec2_sub(const vec2 a, const vec2 b, vec2 dest)
+   CGLM_INLINE void  glm_vec2_subs(const vec2 v, float s, vec2 dest)
+   CGLM_INLINE void  glm_vec2_mul(const vec2 a, const vec2 b, vec2 d)
+   CGLM_INLINE void  glm_vec2_scale(const vec2 v, float s, vec2 dest)
+   CGLM_INLINE void  glm_vec2_scale_as(const vec2 v, float s, vec2 dest)
+   CGLM_INLINE void  glm_vec2_div(const vec2 a, const vec2 b, vec2 dest)
+   CGLM_INLINE void  glm_vec2_divs(const vec2 v, float s, vec2 dest)
+   CGLM_INLINE void  glm_vec2_addadd(const vec2 a, const vec2 b, vec2 dest)
+   CGLM_INLINE void  glm_vec2_subadd(const vec2 a, const vec2 b, vec2 dest)
+   CGLM_INLINE void  glm_vec2_muladd(const vec2 a, const vec2 b, vec2 dest)
+   CGLM_INLINE void  glm_vec2_muladds(const vec2 a, float s, vec2 dest)
+   CGLM_INLINE void  glm_vec2_maxadd(const vec2 a, const vec2 b, vec2 dest)
+   CGLM_INLINE void  glm_vec2_minadd(const vec2 a, const vec2 b, vec2 dest)
+   CGLM_INLINE void  glm_vec2_subsub(const vec2 a, const vec2 b, vec2 dest)
+   CGLM_INLINE void  glm_vec2_addsub(const vec2 a, const vec2 b, vec2 dest)
+   CGLM_INLINE void  glm_vec2_mulsub(const vec2 a, const vec2 b, vec2 dest)
+   CGLM_INLINE void  glm_vec2_mulsubs(const vec2 a, float s, vec2 dest)
+   CGLM_INLINE void  glm_vec2_maxsub(const vec2 a, const vec2 b, vec2 dest)
+   CGLM_INLINE void  glm_vec2_minsub(const vec2 a, const vec2 b, vec2 dest)
+   CGLM_INLINE void  glm_vec2_negate_to(const vec2 v, vec2 dest)
    CGLM_INLINE void  glm_vec2_negate(vec2 v)
    CGLM_INLINE void  glm_vec2_normalize(vec2 v)
-   CGLM_INLINE void  glm_vec2_normalize_to(vec2 vec, vec2 dest)
-   CGLM_INLINE void  glm_vec2_rotate(vec2 v, float angle, vec2 dest)
-   CGLM_INLINE void  glm_vec2_center(vec2 a, vec2 b, vec2 dest)
-   CGLM_INLINE float glm_vec2_distance2(vec2 a, vec2 b)
-   CGLM_INLINE float glm_vec2_distance(vec2 a, vec2 b)
+   CGLM_INLINE void  glm_vec2_normalize_to(const vec2 vec, vec2 dest)
+   CGLM_INLINE void  glm_vec2_rotate(const vec2 v, float angle, vec2 dest)
+   CGLM_INLINE void  glm_vec2_center(const vec2 a, const vec2 b, vec2 dest)
+   CGLM_INLINE float glm_vec2_distance2(const vec2 a, const vec2 b)
+   CGLM_INLINE float glm_vec2_distance(const vec2 a, const vec2 b)
    CGLM_INLINE void  glm_vec2_maxv(vec2 v1, vec2 v2, vec2 dest)
    CGLM_INLINE void  glm_vec2_minv(vec2 v1, vec2 v2, vec2 dest)
    CGLM_INLINE void  glm_vec2_clamp(vec2 v, float minVal, float maxVal)
-   CGLM_INLINE void  glm_vec2_swizzle(vec2 v, int mask, vec2 dest)
-   CGLM_INLINE void  glm_vec2_lerp(vec2 from, vec2 to, float t, vec2 dest)
-   CGLM_INLINE void  glm_vec2_step(vec2 edge, vec2 x, vec2 dest)
+   CGLM_INLINE void  glm_vec2_swizzle(const vec2 v, int mask, vec2 dest)
+   CGLM_INLINE void  glm_vec2_lerp(const vec2 from, const vec2 to, float t, vec2 dest)
+   CGLM_INLINE void  glm_vec2_step(const vec2 edge, const vec2 x, vec2 dest)
    CGLM_INLINE void  glm_vec2_make(float * restrict src, vec2 dest)
-   CGLM_INLINE void  glm_vec2_reflect(vec2 v, vec2 n, vec2 dest)
-   CGLM_INLINE void  glm_vec2_refract(vec2 v, vec2 n, float eta, vec2 dest)
+   CGLM_INLINE void  glm_vec2_reflect(const vec2 v, const vec2 n, vec2 dest)
+   CGLM_INLINE void  glm_vec2_refract(const vec2 v, const vec2 n, float eta, vec2 dest)
    CGLM_INLINE void  glm_vec2_swap(vec2 a, vec2 b)
  */
 
@@ -83,7 +83,7 @@
  */
 CGLM_INLINE
 void
-glm_vec2(float * __restrict v, vec2 dest) {
+glm_vec2(const float * __restrict v, vec2 dest) {
   dest[0] = v[0];
   dest[1] = v[1];
 }
@@ -96,7 +96,7 @@ glm_vec2(float * __restrict v, vec2 dest) {
  */
 CGLM_INLINE
 void
-glm_vec2_copy(vec2 a, vec2 dest) {
+glm_vec2_copy(const vec2 a, vec2 dest) {
   dest[0] = a[0];
   dest[1] = a[1];
 }
@@ -133,7 +133,7 @@ glm_vec2_one(vec2 v) {
  */
 CGLM_INLINE
 float
-glm_vec2_dot(vec2 a, vec2 b) {
+glm_vec2_dot(const vec2 a, const vec2 b) {
   return a[0] * b[0] + a[1] * b[1];
 }
 
@@ -149,7 +149,7 @@ glm_vec2_dot(vec2 a, vec2 b) {
  */
 CGLM_INLINE
 float
-glm_vec2_cross(vec2 a, vec2 b) {
+glm_vec2_cross(const vec2 a, const vec2 b) {
   /* just calculate the z-component */
   return a[0] * b[1] - a[1] * b[0];
 }
@@ -167,7 +167,7 @@ glm_vec2_cross(vec2 a, vec2 b) {
  */
 CGLM_INLINE
 float
-glm_vec2_norm2(vec2 v) {
+glm_vec2_norm2(const vec2 v) {
   return glm_vec2_dot(v, v);
 }
 
@@ -180,7 +180,7 @@ glm_vec2_norm2(vec2 v) {
  */
 CGLM_INLINE
 float
-glm_vec2_norm(vec2 vec) {
+glm_vec2_norm(const vec2 vec) {
   return sqrtf(glm_vec2_norm2(vec));
 }
 
@@ -193,7 +193,7 @@ glm_vec2_norm(vec2 vec) {
  */
 CGLM_INLINE
 void
-glm_vec2_add(vec2 a, vec2 b, vec2 dest) {
+glm_vec2_add(const vec2 a, const vec2 b, vec2 dest) {
   dest[0] = a[0] + b[0];
   dest[1] = a[1] + b[1];
 }
@@ -207,7 +207,7 @@ glm_vec2_add(vec2 a, vec2 b, vec2 dest) {
  */
 CGLM_INLINE
 void
-glm_vec2_adds(vec2 v, float s, vec2 dest) {
+glm_vec2_adds(const vec2 v, float s, vec2 dest) {
   dest[0] = v[0] + s;
   dest[1] = v[1] + s;
 }
@@ -221,7 +221,7 @@ glm_vec2_adds(vec2 v, float s, vec2 dest) {
  */
 CGLM_INLINE
 void
-glm_vec2_sub(vec2 a, vec2 b, vec2 dest) {
+glm_vec2_sub(const vec2 a, const vec2 b, vec2 dest) {
   dest[0] = a[0] - b[0];
   dest[1] = a[1] - b[1];
 }
@@ -235,7 +235,7 @@ glm_vec2_sub(vec2 a, vec2 b, vec2 dest) {
  */
 CGLM_INLINE
 void
-glm_vec2_subs(vec2 v, float s, vec2 dest) {
+glm_vec2_subs(const vec2 v, float s, vec2 dest) {
   dest[0] = v[0] - s;
   dest[1] = v[1] - s;
 }
@@ -249,7 +249,7 @@ glm_vec2_subs(vec2 v, float s, vec2 dest) {
  */
 CGLM_INLINE
 void
-glm_vec2_mul(vec2 a, vec2 b, vec2 dest) {
+glm_vec2_mul(const vec2 a, const vec2 b, vec2 dest) {
   dest[0] = a[0] * b[0];
   dest[1] = a[1] * b[1];
 }
@@ -263,7 +263,7 @@ glm_vec2_mul(vec2 a, vec2 b, vec2 dest) {
  */
 CGLM_INLINE
 void
-glm_vec2_scale(vec2 v, float s, vec2 dest) {
+glm_vec2_scale(const vec2 v, float s, vec2 dest) {
   dest[0] = v[0] * s;
   dest[1] = v[1] * s;
 }
@@ -277,7 +277,7 @@ glm_vec2_scale(vec2 v, float s, vec2 dest) {
  */
 CGLM_INLINE
 void
-glm_vec2_scale_as(vec2 v, float s, vec2 dest) {
+glm_vec2_scale_as(const vec2 v, float s, vec2 dest) {
   float norm;
   norm = glm_vec2_norm(v);
 
@@ -298,7 +298,7 @@ glm_vec2_scale_as(vec2 v, float s, vec2 dest) {
  */
 CGLM_INLINE
 void
-glm_vec2_div(vec2 a, vec2 b, vec2 dest) {
+glm_vec2_div(const vec2 a, const vec2 b, vec2 dest) {
   dest[0] = a[0] / b[0];
   dest[1] = a[1] / b[1];
 }
@@ -312,7 +312,7 @@ glm_vec2_div(vec2 a, vec2 b, vec2 dest) {
  */
 CGLM_INLINE
 void
-glm_vec2_divs(vec2 v, float s, vec2 dest) {
+glm_vec2_divs(const vec2 v, float s, vec2 dest) {
   dest[0] = v[0] / s;
   dest[1] = v[1] / s;
 }
@@ -328,7 +328,7 @@ glm_vec2_divs(vec2 v, float s, vec2 dest) {
  */
 CGLM_INLINE
 void
-glm_vec2_addadd(vec2 a, vec2 b, vec2 dest) {
+glm_vec2_addadd(const vec2 a, const vec2 b, vec2 dest) {
   dest[0] += a[0] + b[0];
   dest[1] += a[1] + b[1];
 }
@@ -344,7 +344,7 @@ glm_vec2_addadd(vec2 a, vec2 b, vec2 dest) {
  */
 CGLM_INLINE
 void
-glm_vec2_subadd(vec2 a, vec2 b, vec2 dest) {
+glm_vec2_subadd(const vec2 a, const vec2 b, vec2 dest) {
   dest[0] += a[0] - b[0];
   dest[1] += a[1] - b[1];
 }
@@ -360,7 +360,7 @@ glm_vec2_subadd(vec2 a, vec2 b, vec2 dest) {
  */
 CGLM_INLINE
 void
-glm_vec2_muladd(vec2 a, vec2 b, vec2 dest) {
+glm_vec2_muladd(const vec2 a, const vec2 b, vec2 dest) {
   dest[0] += a[0] * b[0];
   dest[1] += a[1] * b[1];
 }
@@ -376,7 +376,7 @@ glm_vec2_muladd(vec2 a, vec2 b, vec2 dest) {
  */
 CGLM_INLINE
 void
-glm_vec2_muladds(vec2 a, float s, vec2 dest) {
+glm_vec2_muladds(const vec2 a, float s, vec2 dest) {
   dest[0] += a[0] * s;
   dest[1] += a[1] * s;
 }
@@ -392,7 +392,7 @@ glm_vec2_muladds(vec2 a, float s, vec2 dest) {
  */
 CGLM_INLINE
 void
-glm_vec2_maxadd(vec2 a, vec2 b, vec2 dest) {
+glm_vec2_maxadd(const vec2 a, const vec2 b, vec2 dest) {
   dest[0] += glm_max(a[0], b[0]);
   dest[1] += glm_max(a[1], b[1]);
 }
@@ -408,7 +408,7 @@ glm_vec2_maxadd(vec2 a, vec2 b, vec2 dest) {
  */
 CGLM_INLINE
 void
-glm_vec2_minadd(vec2 a, vec2 b, vec2 dest) {
+glm_vec2_minadd(const vec2 a, const vec2 b, vec2 dest) {
   dest[0] += glm_min(a[0], b[0]);
   dest[1] += glm_min(a[1], b[1]);
 }
@@ -424,7 +424,7 @@ glm_vec2_minadd(vec2 a, vec2 b, vec2 dest) {
  */
 CGLM_INLINE
 void
-glm_vec2_subsub(vec2 a, vec2 b, vec2 dest) {
+glm_vec2_subsub(const vec2 a, const vec2 b, vec2 dest) {
   dest[0] -= a[0] - b[0];
   dest[1] -= a[1] - b[1];
 }
@@ -440,7 +440,7 @@ glm_vec2_subsub(vec2 a, vec2 b, vec2 dest) {
  */
 CGLM_INLINE
 void
-glm_vec2_addsub(vec2 a, vec2 b, vec2 dest) {
+glm_vec2_addsub(const vec2 a, const vec2 b, vec2 dest) {
   dest[0] -= a[0] + b[0];
   dest[1] -= a[1] + b[1];
 }
@@ -456,7 +456,7 @@ glm_vec2_addsub(vec2 a, vec2 b, vec2 dest) {
  */
 CGLM_INLINE
 void
-glm_vec2_mulsub(vec2 a, vec2 b, vec2 dest) {
+glm_vec2_mulsub(const vec2 a, const vec2 b, vec2 dest) {
   dest[0] -= a[0] * b[0];
   dest[1] -= a[1] * b[1];
 }
@@ -472,7 +472,7 @@ glm_vec2_mulsub(vec2 a, vec2 b, vec2 dest) {
  */
 CGLM_INLINE
 void
-glm_vec2_mulsubs(vec2 a, float s, vec2 dest) {
+glm_vec2_mulsubs(const vec2 a, float s, vec2 dest) {
   dest[0] -= a[0] * s;
   dest[1] -= a[1] * s;
 }
@@ -488,7 +488,7 @@ glm_vec2_mulsubs(vec2 a, float s, vec2 dest) {
  */
 CGLM_INLINE
 void
-glm_vec2_maxsub(vec2 a, vec2 b, vec2 dest) {
+glm_vec2_maxsub(const vec2 a, const vec2 b, vec2 dest) {
   dest[0] -= glm_max(a[0], b[0]);
   dest[1] -= glm_max(a[1], b[1]);
 }
@@ -504,7 +504,7 @@ glm_vec2_maxsub(vec2 a, vec2 b, vec2 dest) {
  */
 CGLM_INLINE
 void
-glm_vec2_minsub(vec2 a, vec2 b, vec2 dest) {
+glm_vec2_minsub(const vec2 a, const vec2 b, vec2 dest) {
   dest[0] -= glm_min(a[0], b[0]);
   dest[1] -= glm_min(a[1], b[1]);
 }
@@ -517,7 +517,7 @@ glm_vec2_minsub(vec2 a, vec2 b, vec2 dest) {
  */
 CGLM_INLINE
 void
-glm_vec2_negate_to(vec2 v, vec2 dest) {
+glm_vec2_negate_to(const vec2 v, vec2 dest) {
   dest[0] = -v[0];
   dest[1] = -v[1];
 }
@@ -561,7 +561,7 @@ glm_vec2_normalize(vec2 v) {
  */
 CGLM_INLINE
 void
-glm_vec2_normalize_to(vec2 v, vec2 dest) {
+glm_vec2_normalize_to(const vec2 v, vec2 dest) {
   float norm;
 
   norm = glm_vec2_norm(v);
@@ -587,7 +587,7 @@ glm_vec2_normalize_to(vec2 v, vec2 dest) {
  */
 CGLM_INLINE
 void
-glm_vec2_rotate(vec2 v, float angle, vec2 dest) {
+glm_vec2_rotate(const vec2 v, float angle, vec2 dest) {
   float c, s, x1, y1;
 
   c  = cosf(angle);
@@ -609,7 +609,7 @@ glm_vec2_rotate(vec2 v, float angle, vec2 dest) {
  */
 CGLM_INLINE
 void
-glm_vec2_center(vec2 a, vec2 b, vec2 dest) {
+glm_vec2_center(const vec2 a, const vec2 b, vec2 dest) {
   glm_vec2_add(a, b, dest);
   glm_vec2_scale(dest, 0.5f, dest);
 }
@@ -623,7 +623,7 @@ glm_vec2_center(vec2 a, vec2 b, vec2 dest) {
  */
 CGLM_INLINE
 float
-glm_vec2_distance2(vec2 a, vec2 b) {
+glm_vec2_distance2(const vec2 a, const vec2 b) {
   return glm_pow2(b[0] - a[0]) + glm_pow2(b[1] - a[1]);
 }
 
@@ -636,7 +636,7 @@ glm_vec2_distance2(vec2 a, vec2 b) {
  */
 CGLM_INLINE
 float
-glm_vec2_distance(vec2 a, vec2 b) {
+glm_vec2_distance(const vec2 a, const vec2 b) {
   return sqrtf(glm_vec2_distance2(a, b));
 }
 
@@ -649,7 +649,7 @@ glm_vec2_distance(vec2 a, vec2 b) {
  */
 CGLM_INLINE
 void
-glm_vec2_maxv(vec2 a, vec2 b, vec2 dest) {
+glm_vec2_maxv(const vec2 a, const vec2 b, vec2 dest) {
   dest[0] = glm_max(a[0], b[0]);
   dest[1] = glm_max(a[1], b[1]);
 }
@@ -663,7 +663,7 @@ glm_vec2_maxv(vec2 a, vec2 b, vec2 dest) {
  */
 CGLM_INLINE
 void
-glm_vec2_minv(vec2 a, vec2 b, vec2 dest) {
+glm_vec2_minv(const vec2 a, const vec2 b, vec2 dest) {
   dest[0] = glm_min(a[0], b[0]);
   dest[1] = glm_min(a[1], b[1]);
 }
@@ -691,7 +691,7 @@ glm_vec2_clamp(vec2 v, float minval, float maxval) {
  */
 CGLM_INLINE
 void
-glm_vec2_swizzle(vec2 v, int mask, vec2 dest) {
+glm_vec2_swizzle(const vec2 v, int mask, vec2 dest) {
   vec2 t;
 
   t[0] = v[(mask & (3 << 0))];
@@ -712,7 +712,7 @@ glm_vec2_swizzle(vec2 v, int mask, vec2 dest) {
  */
 CGLM_INLINE
 void
-glm_vec2_lerp(vec2 from, vec2 to, float t, vec2 dest) {
+glm_vec2_lerp(const vec2 from, const vec2 to, float t, vec2 dest) {
   vec2 s, v;
 
   /* from + s * (to - from) */
@@ -731,7 +731,7 @@ glm_vec2_lerp(vec2 from, vec2 to, float t, vec2 dest) {
  */
 CGLM_INLINE
 void
-glm_vec2_step(vec2 edge, vec2 x, vec2 dest) {
+glm_vec2_step(const vec2 edge, const vec2 x, vec2 dest) {
   dest[0] = glm_step(edge[0], x[0]);
   dest[1] = glm_step(edge[1], x[1]);
 }
@@ -757,7 +757,7 @@ glm_vec2_make(const float * __restrict src, vec2 dest) {
  */
 CGLM_INLINE
 void
-glm_vec2_reflect(vec2 v, vec2 n, vec2 dest) {
+glm_vec2_reflect(const vec2 v, const vec2 n, vec2 dest) {
   vec2 temp;
   glm_vec2_scale(n, 2.0f * glm_vec2_dot(v, n), temp);
   glm_vec2_sub(v, temp, dest);
@@ -779,7 +779,7 @@ glm_vec2_reflect(vec2 v, vec2 n, vec2 dest) {
  */
 CGLM_INLINE
 bool
-glm_vec2_refract(vec2 v, vec2 n, float eta, vec2 dest) {
+glm_vec2_refract(const vec2 v, const vec2 n, float eta, vec2 dest) {
   float ndi, eni, k;
 
   ndi = glm_vec2_dot(n, v);
@@ -801,11 +801,13 @@ glm_vec2_refract(vec2 v, vec2 n, float eta, vec2 dest) {
  * @param a the first vector to swap
  * @param b the second vector to swap
  */
-CGLM_INLINE void glm_vec2_swap(vec2 a, vec2 b) {
-	vec2 tmp;
-	glm_vec2_copy(a, tmp);
-	glm_vec2_copy(b, a);
-	glm_vec2_copy(tmp, b);
+CGLM_INLINE
+void
+glm_vec2_swap(vec2 a, vec2 b) {
+  vec2 tmp;
+  glm_vec2_copy(a, tmp);
+  glm_vec2_copy(b, a);
+  glm_vec2_copy(tmp, b);
 }
 
 #endif /* cglm_vec2_h */
diff --git a/include/cglm/vec3-ext.h b/include/cglm/vec3-ext.h
index 805afe584..115e948f5 100644
--- a/include/cglm/vec3-ext.h
+++ b/include/cglm/vec3-ext.h
@@ -28,8 +28,8 @@
    CGLM_INLINE void  glm_vec3_fract(vec3 v, vec3 dest);
    CGLM_INLINE void  glm_vec3_floor(vec3 v, vec3 dest);
    CGLM_INLINE float glm_vec3_mods(vec3 v, float s, vec3 dest);
-   CGLM_INLINE float glm_vec3_steps(float edge, vec3 v, vec3 dest);
-   CGLM_INLINE void  glm_vec3_stepr(vec3 edge, float v, vec3 dest);
+   CGLM_INLINE float glm_vec3_steps(float edge, const vec3 x, vec3 dest);
+   CGLM_INLINE void  glm_vec3_stepr(const vec3 edge, float v, vec3 dest);
    CGLM_INLINE float glm_vec3_hadd(vec3 v);
    CGLM_INLINE void  glm_vec3_sqrt(vec3 v, vec3 dest);
  */
@@ -72,7 +72,7 @@ glm_vec3_fill(vec3 v, float val) {
  */
 CGLM_INLINE
 bool
-glm_vec3_eq(vec3 v, float val) {
+glm_vec3_eq(const vec3 v, float val) {
   return v[0] == val && v[0] == v[1] && v[0] == v[2];
 }
 
@@ -84,7 +84,7 @@ glm_vec3_eq(vec3 v, float val) {
  */
 CGLM_INLINE
 bool
-glm_vec3_eq_eps(vec3 v, float val) {
+glm_vec3_eq_eps(const vec3 v, float val) {
   return fabsf(v[0] - val) <= GLM_FLT_EPSILON
          && fabsf(v[1] - val) <= GLM_FLT_EPSILON
          && fabsf(v[2] - val) <= GLM_FLT_EPSILON;
@@ -97,7 +97,7 @@ glm_vec3_eq_eps(vec3 v, float val) {
  */
 CGLM_INLINE
 bool
-glm_vec3_eq_all(vec3 v) {
+glm_vec3_eq_all(const vec3 v) {
   return glm_vec3_eq_eps(v, v[0]);
 }
 
@@ -109,7 +109,7 @@ glm_vec3_eq_all(vec3 v) {
  */
 CGLM_INLINE
 bool
-glm_vec3_eqv(vec3 a, vec3 b) {
+glm_vec3_eqv(const vec3 a, const vec3 b) {
   return a[0] == b[0]
          && a[1] == b[1]
          && a[2] == b[2];
@@ -123,7 +123,7 @@ glm_vec3_eqv(vec3 a, vec3 b) {
  */
 CGLM_INLINE
 bool
-glm_vec3_eqv_eps(vec3 a, vec3 b) {
+glm_vec3_eqv_eps(const vec3 a, const vec3 b) {
   return fabsf(a[0] - b[0]) <= GLM_FLT_EPSILON
          && fabsf(a[1] - b[1]) <= GLM_FLT_EPSILON
          && fabsf(a[2] - b[2]) <= GLM_FLT_EPSILON;
@@ -136,7 +136,7 @@ glm_vec3_eqv_eps(vec3 a, vec3 b) {
  */
 CGLM_INLINE
 float
-glm_vec3_max(vec3 v) {
+glm_vec3_max(const vec3 v) {
   float max;
 
   max = v[0];
@@ -155,7 +155,7 @@ glm_vec3_max(vec3 v) {
  */
 CGLM_INLINE
 float
-glm_vec3_min(vec3 v) {
+glm_vec3_min(const vec3 v) {
   float min;
 
   min = v[0];
@@ -175,7 +175,7 @@ glm_vec3_min(vec3 v) {
  */
 CGLM_INLINE
 bool
-glm_vec3_isnan(vec3 v) {
+glm_vec3_isnan(const vec3 v) {
 #ifndef CGLM_FAST_MATH
   return isnan(v[0]) || isnan(v[1]) || isnan(v[2]);
 #else
@@ -192,7 +192,7 @@ glm_vec3_isnan(vec3 v) {
  */
 CGLM_INLINE
 bool
-glm_vec3_isinf(vec3 v) {
+glm_vec3_isinf(const vec3 v) {
 #ifndef CGLM_FAST_MATH
   return isinf(v[0]) || isinf(v[1]) || isinf(v[2]);
 #else
@@ -209,7 +209,7 @@ glm_vec3_isinf(vec3 v) {
  */
 CGLM_INLINE
 bool
-glm_vec3_isvalid(vec3 v) {
+glm_vec3_isvalid(const vec3 v) {
   return !glm_vec3_isnan(v) && !glm_vec3_isinf(v);
 }
 
@@ -222,7 +222,7 @@ glm_vec3_isvalid(vec3 v) {
  */
 CGLM_INLINE
 void
-glm_vec3_sign(vec3 v, vec3 dest) {
+glm_vec3_sign(const vec3 v, vec3 dest) {
   dest[0] = glm_signf(v[0]);
   dest[1] = glm_signf(v[1]);
   dest[2] = glm_signf(v[2]);
@@ -236,7 +236,7 @@ glm_vec3_sign(vec3 v, vec3 dest) {
  */
 CGLM_INLINE
 void
-glm_vec3_abs(vec3 v, vec3 dest) {
+glm_vec3_abs(const vec3 v, vec3 dest) {
   dest[0] = fabsf(v[0]);
   dest[1] = fabsf(v[1]);
   dest[2] = fabsf(v[2]);
@@ -250,7 +250,7 @@ glm_vec3_abs(vec3 v, vec3 dest) {
  */
 CGLM_INLINE
 void
-glm_vec3_fract(vec3 v, vec3 dest) {
+glm_vec3_fract(const vec3 v, vec3 dest) {
   dest[0] = fminf(v[0] - floorf(v[0]), 0.999999940395355224609375f);
   dest[1] = fminf(v[1] - floorf(v[1]), 0.999999940395355224609375f);
   dest[2] = fminf(v[2] - floorf(v[2]), 0.999999940395355224609375f);
@@ -264,7 +264,7 @@ glm_vec3_fract(vec3 v, vec3 dest) {
  */
 CGLM_INLINE
 void
-glm_vec3_floor(vec3 v, vec3 dest) {
+glm_vec3_floor(const vec3 v, vec3 dest) {
   dest[0] = floorf(v[0]);
   dest[1] = floorf(v[1]);
   dest[2] = floorf(v[2]);
@@ -279,7 +279,7 @@ glm_vec3_floor(vec3 v, vec3 dest) {
  */
 CGLM_INLINE
 void
-glm_vec3_mods(vec3 v, float s, vec3 dest) {
+glm_vec3_mods(const vec3 v, float s, vec3 dest) {
   dest[0] = fmodf(v[0], s);
   dest[1] = fmodf(v[1], s);
   dest[2] = fmodf(v[2], s);
@@ -295,7 +295,7 @@ glm_vec3_mods(vec3 v, float s, vec3 dest) {
  */
 CGLM_INLINE
 void
-glm_vec3_steps(float edge, vec3 x, vec3 dest) {
+glm_vec3_steps(float edge, const vec3 x, vec3 dest) {
   dest[0] = glm_step(edge, x[0]);
   dest[1] = glm_step(edge, x[1]);
   dest[2] = glm_step(edge, x[2]);
@@ -311,7 +311,7 @@ glm_vec3_steps(float edge, vec3 x, vec3 dest) {
  */
 CGLM_INLINE
 void
-glm_vec3_stepr(vec3 edge, float x, vec3 dest) {
+glm_vec3_stepr(const vec3 edge, float x, vec3 dest) {
   dest[0] = glm_step(edge[0], x);
   dest[1] = glm_step(edge[1], x);
   dest[2] = glm_step(edge[2], x);
@@ -326,7 +326,7 @@ glm_vec3_stepr(vec3 edge, float x, vec3 dest) {
  */
 CGLM_INLINE
 float
-glm_vec3_hadd(vec3 v) {
+glm_vec3_hadd(const vec3 v) {
   return v[0] + v[1] + v[2];
 }
 
@@ -338,7 +338,7 @@ glm_vec3_hadd(vec3 v) {
  */
 CGLM_INLINE
 void
-glm_vec3_sqrt(vec3 v, vec3 dest) {
+glm_vec3_sqrt(const vec3 v, vec3 dest) {
   dest[0] = sqrtf(v[0]);
   dest[1] = sqrtf(v[1]);
   dest[2] = sqrtf(v[2]);
diff --git a/include/cglm/vec3.h b/include/cglm/vec3.h
index 5667e3e36..b7d876bca 100644
--- a/include/cglm/vec3.h
+++ b/include/cglm/vec3.h
@@ -20,32 +20,32 @@
    CGLM_INLINE void  glm_vec3_copy(vec3 a, vec3 dest);
    CGLM_INLINE void  glm_vec3_zero(vec3 v);
    CGLM_INLINE void  glm_vec3_one(vec3 v);
-   CGLM_INLINE float glm_vec3_dot(vec3 a, vec3 b);
+   CGLM_INLINE float glm_vec3_dot(const vec3 a, const vec3 b);
    CGLM_INLINE float glm_vec3_norm2(vec3 v);
    CGLM_INLINE float glm_vec3_norm(vec3 v);
    CGLM_INLINE float glm_vec3_norm_one(vec3 v);
    CGLM_INLINE float glm_vec3_norm_inf(vec3 v);
-   CGLM_INLINE void  glm_vec3_add(vec3 a, vec3 b, vec3 dest);
+   CGLM_INLINE void  glm_vec3_add(const vec3 a, const vec3 b, vec3 dest);
    CGLM_INLINE void  glm_vec3_adds(vec3 a, float s, vec3 dest);
-   CGLM_INLINE void  glm_vec3_sub(vec3 a, vec3 b, vec3 dest);
+   CGLM_INLINE void  glm_vec3_sub(const vec3 a, const vec3 b, vec3 dest);
    CGLM_INLINE void  glm_vec3_subs(vec3 a, float s, vec3 dest);
-   CGLM_INLINE void  glm_vec3_mul(vec3 a, vec3 b, vec3 dest);
+   CGLM_INLINE void  glm_vec3_mul(const vec3 a, const vec3 b, vec3 dest);
    CGLM_INLINE void  glm_vec3_scale(vec3 v, float s, vec3 dest);
    CGLM_INLINE void  glm_vec3_scale_as(vec3 v, float s, vec3 dest);
-   CGLM_INLINE void  glm_vec3_div(vec3 a, vec3 b, vec3 dest);
+   CGLM_INLINE void  glm_vec3_div(const vec3 a, const vec3 b, vec3 dest);
    CGLM_INLINE void  glm_vec3_divs(vec3 a, float s, vec3 dest);
-   CGLM_INLINE void  glm_vec3_addadd(vec3 a, vec3 b, vec3 dest);
-   CGLM_INLINE void  glm_vec3_subadd(vec3 a, vec3 b, vec3 dest);
-   CGLM_INLINE void  glm_vec3_muladd(vec3 a, vec3 b, vec3 dest);
+   CGLM_INLINE void  glm_vec3_addadd(const vec3 a, const vec3 b, vec3 dest);
+   CGLM_INLINE void  glm_vec3_subadd(const vec3 a, const vec3 b, vec3 dest);
+   CGLM_INLINE void  glm_vec3_muladd(const vec3 a, const vec3 b, vec3 dest);
    CGLM_INLINE void  glm_vec3_muladds(vec3 a, float s, vec3 dest);
-   CGLM_INLINE void  glm_vec3_maxadd(vec3 a, vec3 b, vec3 dest);
-   CGLM_INLINE void  glm_vec3_minadd(vec3 a, vec3 b, vec3 dest);
-   CGLM_INLINE void  glm_vec3_subsub(vec3 a, vec3 b, vec3 dest);
-   CGLM_INLINE void  glm_vec3_addsub(vec3 a, vec3 b, vec3 dest);
-   CGLM_INLINE void  glm_vec3_mulsub(vec3 a, vec3 b, vec3 dest);
+   CGLM_INLINE void  glm_vec3_maxadd(const vec3 a, const vec3 b, vec3 dest);
+   CGLM_INLINE void  glm_vec3_minadd(const vec3 a, const vec3 b, vec3 dest);
+   CGLM_INLINE void  glm_vec3_subsub(const vec3 a, const vec3 b, vec3 dest);
+   CGLM_INLINE void  glm_vec3_addsub(const vec3 a, const vec3 b, vec3 dest);
+   CGLM_INLINE void  glm_vec3_mulsub(const vec3 a, const vec3 b, vec3 dest);
    CGLM_INLINE void  glm_vec3_mulsubs(vec3 a, float s, vec3 dest);
-   CGLM_INLINE void  glm_vec3_maxsub(vec3 a, vec3 b, vec3 dest);
-   CGLM_INLINE void  glm_vec3_minsub(vec3 a, vec3 b, vec3 dest);
+   CGLM_INLINE void  glm_vec3_maxsub(const vec3 a, const vec3 b, vec3 dest);
+   CGLM_INLINE void  glm_vec3_minsub(const vec3 a, const vec3 b, vec3 dest);
    CGLM_INLINE void  glm_vec3_flipsign(vec3 v);
    CGLM_INLINE void  glm_vec3_flipsign_to(vec3 v, vec3 dest);
    CGLM_INLINE void  glm_vec3_negate_to(vec3 v, vec3 dest);
@@ -54,29 +54,29 @@
    CGLM_INLINE void  glm_vec3_inv_to(vec3 v, vec3 dest);
    CGLM_INLINE void  glm_vec3_normalize(vec3 v);
    CGLM_INLINE void  glm_vec3_normalize_to(vec3 v, vec3 dest);
-   CGLM_INLINE void  glm_vec3_cross(vec3 a, vec3 b, vec3 d);
-   CGLM_INLINE void  glm_vec3_crossn(vec3 a, vec3 b, vec3 dest);
-   CGLM_INLINE float glm_vec3_angle(vec3 a, vec3 b);
+   CGLM_INLINE void  glm_vec3_cross(const vec3 a, const vec3 b, vec3 d);
+   CGLM_INLINE void  glm_vec3_crossn(const vec3 a, const vec3 b, vec3 dest);
+   CGLM_INLINE float glm_vec3_angle(const vec3 a, const vec3 b);
    CGLM_INLINE void  glm_vec3_rotate(vec3 v, float angle, vec3 axis);
-   CGLM_INLINE void  glm_vec3_rotate_m4(mat4 m, vec3 v, vec3 dest);
-   CGLM_INLINE void  glm_vec3_rotate_m3(mat3 m, vec3 v, vec3 dest);
-   CGLM_INLINE void  glm_vec3_proj(vec3 a, vec3 b, vec3 dest);
-   CGLM_INLINE void  glm_vec3_center(vec3 a, vec3 b, vec3 dest);
-   CGLM_INLINE float glm_vec3_distance(vec3 a, vec3 b);
-   CGLM_INLINE float glm_vec3_distance2(vec3 a, vec3 b);
-   CGLM_INLINE void  glm_vec3_maxv(vec3 a, vec3 b, vec3 dest);
-   CGLM_INLINE void  glm_vec3_minv(vec3 a, vec3 b, vec3 dest);
+   CGLM_INLINE void  glm_vec3_rotate_m4(CGLM_IN(mat4) m, vec3 v, vec3 dest);
+   CGLM_INLINE void  glm_vec3_rotate_m3(CGLM_IN(mat3) m, vec3 v, vec3 dest);
+   CGLM_INLINE void  glm_vec3_proj(const vec3 a, const vec3 b, vec3 dest);
+   CGLM_INLINE void  glm_vec3_center(const vec3 a, const vec3 b, vec3 dest);
+   CGLM_INLINE float glm_vec3_distance(const vec3 a, const vec3 b);
+   CGLM_INLINE float glm_vec3_distance2(const vec3 a, const vec3 b);
+   CGLM_INLINE void  glm_vec3_maxv(const vec3 a, const vec3 b, vec3 dest);
+   CGLM_INLINE void  glm_vec3_minv(const vec3 a, const vec3 b, vec3 dest);
    CGLM_INLINE void  glm_vec3_ortho(vec3 v, vec3 dest);
    CGLM_INLINE void  glm_vec3_clamp(vec3 v, float minVal, float maxVal);
-   CGLM_INLINE void  glm_vec3_lerp(vec3 from, vec3 to, float t, vec3 dest);
-   CGLM_INLINE void  glm_vec3_lerpc(vec3 from, vec3 to, float t, vec3 dest);
-   CGLM_INLINE void  glm_vec3_mix(vec3 from, vec3 to, float t, vec3 dest);
-   CGLM_INLINE void  glm_vec3_mixc(vec3 from, vec3 to, float t, vec3 dest);
-   CGLM_INLINE void  glm_vec3_step(vec3 edge, vec3 x, vec3 dest);
-   CGLM_INLINE void  glm_vec3_smoothstep_uni(float edge0, float edge1, vec3 x, vec3 dest);
-   CGLM_INLINE void  glm_vec3_smoothstep(vec3 edge0, vec3 edge1, vec3 x, vec3 dest);
-   CGLM_INLINE void  glm_vec3_smoothinterp(vec3 from, vec3 to, float t, vec3 dest);
-   CGLM_INLINE void  glm_vec3_smoothinterpc(vec3 from, vec3 to, float t, vec3 dest);
+   CGLM_INLINE void  glm_vec3_lerp(const vec3 from, const vec3 to, float t, vec3 dest);
+   CGLM_INLINE void  glm_vec3_lerpc(const vec3 from, const vec3 to, float t, vec3 dest);
+   CGLM_INLINE void  glm_vec3_mix(const vec3 from, const vec3 to, float t, vec3 dest);
+   CGLM_INLINE void  glm_vec3_mixc(const vec3 from, const vec3 to, float t, vec3 dest);
+   CGLM_INLINE void  glm_vec3_step(const vec3 edge, const vec3 x, vec3 dest);
+   CGLM_INLINE void  glm_vec3_smoothstep_uni(float edge0, float edge1, const vec3 x, vec3 dest);
+   CGLM_INLINE void  glm_vec3_smoothstep(const vec3 edge0, const vec3 edge1, const vec3 x, vec3 dest);
+   CGLM_INLINE void  glm_vec3_smoothinterp(const vec3 from, const vec3 to, float t, vec3 dest);
+   CGLM_INLINE void  glm_vec3_smoothinterpc(const vec3 from, const vec3 to, float t, vec3 dest);
    CGLM_INLINE void  glm_vec3_swizzle(vec3 v, int mask, vec3 dest);
    CGLM_INLINE void  glm_vec3_make(float * restrict src, vec3 dest);
    CGLM_INLINE void  glm_vec3_faceforward(vec3 n, vec3 v, vec3 nref, vec3 dest);
@@ -85,8 +85,8 @@
    CGLM_INLINE void  glm_vec3_swap(vec3 a, vec3 b)
 
  Convenient:
-   CGLM_INLINE void  glm_cross(vec3 a, vec3 b, vec3 d);
-   CGLM_INLINE float glm_dot(vec3 a, vec3 b);
+   CGLM_INLINE void  glm_cross(const vec3 a, const vec3 b, vec3 d);
+   CGLM_INLINE float glm_dot(const vec3 a, const vec3 b);
    CGLM_INLINE void  glm_normalize(vec3 v);
    CGLM_INLINE void  glm_normalize_to(vec3 v, vec3 dest);
 
@@ -141,7 +141,7 @@
  */
 CGLM_INLINE
 void
-glm_vec3(vec4 v4, vec3 dest) {
+glm_vec3(const vec4 v4, vec3 dest) {
   dest[0] = v4[0];
   dest[1] = v4[1];
   dest[2] = v4[2];
@@ -155,7 +155,7 @@ glm_vec3(vec4 v4, vec3 dest) {
  */
 CGLM_INLINE
 void
-glm_vec3_copy(vec3 a, vec3 dest) {
+glm_vec3_copy(const vec3 a, vec3 dest) {
   dest[0] = a[0];
   dest[1] = a[1];
   dest[2] = a[2];
@@ -193,7 +193,7 @@ glm_vec3_one(vec3 v) {
  */
 CGLM_INLINE
 float
-glm_vec3_dot(vec3 a, vec3 b) {
+glm_vec3_dot(const vec3 a, const vec3 b) {
   return a[0] * b[0] + a[1] * b[1] + a[2] * b[2];
 }
 
@@ -210,7 +210,7 @@ glm_vec3_dot(vec3 a, vec3 b) {
  */
 CGLM_INLINE
 float
-glm_vec3_norm2(vec3 v) {
+glm_vec3_norm2(const vec3 v) {
   return glm_vec3_dot(v, v);
 }
 
@@ -224,7 +224,7 @@ glm_vec3_norm2(vec3 v) {
  */
 CGLM_INLINE
 float
-glm_vec3_norm(vec3 v) {
+glm_vec3_norm(const vec3 v) {
   return sqrtf(glm_vec3_norm2(v));
 }
 
@@ -244,7 +244,7 @@ glm_vec3_norm(vec3 v) {
  */
 CGLM_INLINE
 float
-glm_vec3_norm_one(vec3 v) {
+glm_vec3_norm_one(const vec3 v) {
   vec3 t;
   glm_vec3_abs(v, t);
   return glm_vec3_hadd(t);
@@ -265,7 +265,7 @@ glm_vec3_norm_one(vec3 v) {
  */
 CGLM_INLINE
 float
-glm_vec3_norm_inf(vec3 v) {
+glm_vec3_norm_inf(const vec3 v) {
   vec3 t;
   glm_vec3_abs(v, t);
   return glm_vec3_max(t);
@@ -280,7 +280,7 @@ glm_vec3_norm_inf(vec3 v) {
  */
 CGLM_INLINE
 void
-glm_vec3_add(vec3 a, vec3 b, vec3 dest) {
+glm_vec3_add(const vec3 a, const vec3 b, vec3 dest) {
   dest[0] = a[0] + b[0];
   dest[1] = a[1] + b[1];
   dest[2] = a[2] + b[2];
@@ -295,7 +295,7 @@ glm_vec3_add(vec3 a, vec3 b, vec3 dest) {
  */
 CGLM_INLINE
 void
-glm_vec3_adds(vec3 v, float s, vec3 dest) {
+glm_vec3_adds(const vec3 v, float s, vec3 dest) {
   dest[0] = v[0] + s;
   dest[1] = v[1] + s;
   dest[2] = v[2] + s;
@@ -310,7 +310,7 @@ glm_vec3_adds(vec3 v, float s, vec3 dest) {
  */
 CGLM_INLINE
 void
-glm_vec3_sub(vec3 a, vec3 b, vec3 dest) {
+glm_vec3_sub(const vec3 a, const vec3 b, vec3 dest) {
   dest[0] = a[0] - b[0];
   dest[1] = a[1] - b[1];
   dest[2] = a[2] - b[2];
@@ -325,7 +325,7 @@ glm_vec3_sub(vec3 a, vec3 b, vec3 dest) {
  */
 CGLM_INLINE
 void
-glm_vec3_subs(vec3 v, float s, vec3 dest) {
+glm_vec3_subs(const vec3 v, float s, vec3 dest) {
   dest[0] = v[0] - s;
   dest[1] = v[1] - s;
   dest[2] = v[2] - s;
@@ -340,7 +340,7 @@ glm_vec3_subs(vec3 v, float s, vec3 dest) {
  */
 CGLM_INLINE
 void
-glm_vec3_mul(vec3 a, vec3 b, vec3 dest) {
+glm_vec3_mul(const vec3 a, const vec3 b, vec3 dest) {
   dest[0] = a[0] * b[0];
   dest[1] = a[1] * b[1];
   dest[2] = a[2] * b[2];
@@ -355,7 +355,7 @@ glm_vec3_mul(vec3 a, vec3 b, vec3 dest) {
  */
 CGLM_INLINE
 void
-glm_vec3_scale(vec3 v, float s, vec3 dest) {
+glm_vec3_scale(const vec3 v, float s, vec3 dest) {
   dest[0] = v[0] * s;
   dest[1] = v[1] * s;
   dest[2] = v[2] * s;
@@ -370,7 +370,7 @@ glm_vec3_scale(vec3 v, float s, vec3 dest) {
  */
 CGLM_INLINE
 void
-glm_vec3_scale_as(vec3 v, float s, vec3 dest) {
+glm_vec3_scale_as(const vec3 v, float s, vec3 dest) {
   float norm;
   norm = glm_vec3_norm(v);
 
@@ -391,7 +391,7 @@ glm_vec3_scale_as(vec3 v, float s, vec3 dest) {
  */
 CGLM_INLINE
 void
-glm_vec3_div(vec3 a, vec3 b, vec3 dest) {
+glm_vec3_div(const vec3 a, const vec3 b, vec3 dest) {
   dest[0] = a[0] / b[0];
   dest[1] = a[1] / b[1];
   dest[2] = a[2] / b[2];
@@ -406,7 +406,7 @@ glm_vec3_div(vec3 a, vec3 b, vec3 dest) {
  */
 CGLM_INLINE
 void
-glm_vec3_divs(vec3 v, float s, vec3 dest) {
+glm_vec3_divs(const vec3 v, float s, vec3 dest) {
   dest[0] = v[0] / s;
   dest[1] = v[1] / s;
   dest[2] = v[2] / s;
@@ -423,7 +423,7 @@ glm_vec3_divs(vec3 v, float s, vec3 dest) {
  */
 CGLM_INLINE
 void
-glm_vec3_addadd(vec3 a, vec3 b, vec3 dest) {
+glm_vec3_addadd(const vec3 a, const vec3 b, vec3 dest) {
   dest[0] += a[0] + b[0];
   dest[1] += a[1] + b[1];
   dest[2] += a[2] + b[2];
@@ -440,7 +440,7 @@ glm_vec3_addadd(vec3 a, vec3 b, vec3 dest) {
  */
 CGLM_INLINE
 void
-glm_vec3_subadd(vec3 a, vec3 b, vec3 dest) {
+glm_vec3_subadd(const vec3 a, const vec3 b, vec3 dest) {
   dest[0] += a[0] - b[0];
   dest[1] += a[1] - b[1];
   dest[2] += a[2] - b[2];
@@ -457,7 +457,7 @@ glm_vec3_subadd(vec3 a, vec3 b, vec3 dest) {
  */
 CGLM_INLINE
 void
-glm_vec3_muladd(vec3 a, vec3 b, vec3 dest) {
+glm_vec3_muladd(const vec3 a, const vec3 b, vec3 dest) {
   dest[0] += a[0] * b[0];
   dest[1] += a[1] * b[1];
   dest[2] += a[2] * b[2];
@@ -491,7 +491,7 @@ glm_vec3_muladds(vec3 a, float s, vec3 dest) {
  */
 CGLM_INLINE
 void
-glm_vec3_maxadd(vec3 a, vec3 b, vec3 dest) {
+glm_vec3_maxadd(const vec3 a, const vec3 b, vec3 dest) {
   dest[0] += glm_max(a[0], b[0]);
   dest[1] += glm_max(a[1], b[1]);
   dest[2] += glm_max(a[2], b[2]);
@@ -508,7 +508,7 @@ glm_vec3_maxadd(vec3 a, vec3 b, vec3 dest) {
  */
 CGLM_INLINE
 void
-glm_vec3_minadd(vec3 a, vec3 b, vec3 dest) {
+glm_vec3_minadd(const vec3 a, const vec3 b, vec3 dest) {
   dest[0] += glm_min(a[0], b[0]);
   dest[1] += glm_min(a[1], b[1]);
   dest[2] += glm_min(a[2], b[2]);
@@ -525,7 +525,7 @@ glm_vec3_minadd(vec3 a, vec3 b, vec3 dest) {
  */
 CGLM_INLINE
 void
-glm_vec3_subsub(vec3 a, vec3 b, vec3 dest) {
+glm_vec3_subsub(const vec3 a, const vec3 b, vec3 dest) {
   dest[0] -= a[0] - b[0];
   dest[1] -= a[1] - b[1];
   dest[2] -= a[2] - b[2];
@@ -542,7 +542,7 @@ glm_vec3_subsub(vec3 a, vec3 b, vec3 dest) {
  */
 CGLM_INLINE
 void
-glm_vec3_addsub(vec3 a, vec3 b, vec3 dest) {
+glm_vec3_addsub(const vec3 a, const vec3 b, vec3 dest) {
   dest[0] -= a[0] + b[0];
   dest[1] -= a[1] + b[1];
   dest[2] -= a[2] + b[2];
@@ -559,7 +559,7 @@ glm_vec3_addsub(vec3 a, vec3 b, vec3 dest) {
  */
 CGLM_INLINE
 void
-glm_vec3_mulsub(vec3 a, vec3 b, vec3 dest) {
+glm_vec3_mulsub(const vec3 a, const vec3 b, vec3 dest) {
   dest[0] -= a[0] * b[0];
   dest[1] -= a[1] * b[1];
   dest[2] -= a[2] * b[2];
@@ -576,7 +576,7 @@ glm_vec3_mulsub(vec3 a, vec3 b, vec3 dest) {
  */
 CGLM_INLINE
 void
-glm_vec3_mulsubs(vec3 a, float s, vec3 dest) {
+glm_vec3_mulsubs(const vec3 a, float s, vec3 dest) {
   dest[0] -= a[0] * s;
   dest[1] -= a[1] * s;
   dest[2] -= a[2] * s;
@@ -593,7 +593,7 @@ glm_vec3_mulsubs(vec3 a, float s, vec3 dest) {
  */
 CGLM_INLINE
 void
-glm_vec3_maxsub(vec3 a, vec3 b, vec3 dest) {
+glm_vec3_maxsub(const vec3 a, const vec3 b, vec3 dest) {
   dest[0] -= glm_max(a[0], b[0]);
   dest[1] -= glm_max(a[1], b[1]);
   dest[2] -= glm_max(a[2], b[2]);
@@ -610,7 +610,7 @@ glm_vec3_maxsub(vec3 a, vec3 b, vec3 dest) {
  */
 CGLM_INLINE
 void
-glm_vec3_minsub(vec3 a, vec3 b, vec3 dest) {
+glm_vec3_minsub(const vec3 a, const vec3 b, vec3 dest) {
   dest[0] -= glm_min(a[0], b[0]);
   dest[1] -= glm_min(a[1], b[1]);
   dest[2] -= glm_min(a[2], b[2]);
@@ -624,7 +624,7 @@ glm_vec3_minsub(vec3 a, vec3 b, vec3 dest) {
  */
 CGLM_INLINE
 void
-glm_vec3_negate_to(vec3 v, vec3 dest) {
+glm_vec3_negate_to(const vec3 v, vec3 dest) {
   dest[0] = -v[0];
   dest[1] = -v[1];
   dest[2] = -v[2];
@@ -669,7 +669,7 @@ glm_vec3_normalize(vec3 v) {
  */
 CGLM_INLINE
 void
-glm_vec3_normalize_to(vec3 v, vec3 dest) {
+glm_vec3_normalize_to(const vec3 v, vec3 dest) {
   float norm;
 
   norm = glm_vec3_norm(v);
@@ -691,7 +691,7 @@ glm_vec3_normalize_to(vec3 v, vec3 dest) {
  */
 CGLM_INLINE
 void
-glm_vec3_cross(vec3 a, vec3 b, vec3 dest) {
+glm_vec3_cross(const vec3 a, const vec3 b, vec3 dest) {
   vec3 c;
   /* (u2.v3 - u3.v2, u3.v1 - u1.v3, u1.v2 - u2.v1) */
   c[0] = a[1] * b[2] - a[2] * b[1];
@@ -709,7 +709,7 @@ glm_vec3_cross(vec3 a, vec3 b, vec3 dest) {
  */
 CGLM_INLINE
 void
-glm_vec3_crossn(vec3 a, vec3 b, vec3 dest) {
+glm_vec3_crossn(const vec3 a, const vec3 b, vec3 dest) {
   glm_vec3_cross(a, b, dest);
   glm_vec3_normalize(dest);
 }
@@ -724,7 +724,7 @@ glm_vec3_crossn(vec3 a, vec3 b, vec3 dest) {
  */
 CGLM_INLINE
 float
-glm_vec3_angle(vec3 a, vec3 b) {
+glm_vec3_angle(const vec3 a, const vec3 b) {
   float norm, dot;
 
   /* maybe compiler generate approximation instruction (rcp) */
@@ -786,7 +786,7 @@ glm_vec3_rotate(vec3 v, float angle, vec3 axis) {
  */
 CGLM_INLINE
 void
-glm_vec3_rotate_m4(mat4 m, vec3 v, vec3 dest) {
+glm_vec3_rotate_m4(CGLM_IN(mat4) m, const vec3 v, vec3 dest) {
   vec4 x, y, z, res;
 
   glm_vec4_normalize_to(m[0], x);
@@ -809,7 +809,7 @@ glm_vec3_rotate_m4(mat4 m, vec3 v, vec3 dest) {
  */
 CGLM_INLINE
 void
-glm_vec3_rotate_m3(mat3 m, vec3 v, vec3 dest) {
+glm_vec3_rotate_m3(CGLM_IN(mat3) m, const vec3 v, vec3 dest) {
   vec4 res, x, y, z;
 
   glm_vec4(m[0], 0.0f, x);
@@ -836,7 +836,7 @@ glm_vec3_rotate_m3(mat3 m, vec3 v, vec3 dest) {
  */
 CGLM_INLINE
 void
-glm_vec3_proj(vec3 a, vec3 b, vec3 dest) {
+glm_vec3_proj(const vec3 a, const vec3 b, vec3 dest) {
   glm_vec3_scale(b,
                  glm_vec3_dot(a, b) / glm_vec3_norm2(b),
                  dest);
@@ -851,7 +851,7 @@ glm_vec3_proj(vec3 a, vec3 b, vec3 dest) {
  */
 CGLM_INLINE
 void
-glm_vec3_center(vec3 a, vec3 b, vec3 dest) {
+glm_vec3_center(const vec3 a, const vec3 b, vec3 dest) {
   glm_vec3_add(a, b, dest);
   glm_vec3_scale(dest, 0.5f, dest);
 }
@@ -865,7 +865,7 @@ glm_vec3_center(vec3 a, vec3 b, vec3 dest) {
  */
 CGLM_INLINE
 float
-glm_vec3_distance2(vec3 a, vec3 b) {
+glm_vec3_distance2(const vec3 a, const vec3 b) {
   return glm_pow2(a[0] - b[0])
        + glm_pow2(a[1] - b[1])
        + glm_pow2(a[2] - b[2]);
@@ -880,7 +880,7 @@ glm_vec3_distance2(vec3 a, vec3 b) {
  */
 CGLM_INLINE
 float
-glm_vec3_distance(vec3 a, vec3 b) {
+glm_vec3_distance(const vec3 a, const vec3 b) {
   return sqrtf(glm_vec3_distance2(a, b));
 }
 
@@ -893,7 +893,7 @@ glm_vec3_distance(vec3 a, vec3 b) {
  */
 CGLM_INLINE
 void
-glm_vec3_maxv(vec3 a, vec3 b, vec3 dest) {
+glm_vec3_maxv(const vec3 a, const vec3 b, vec3 dest) {
   dest[0] = glm_max(a[0], b[0]);
   dest[1] = glm_max(a[1], b[1]);
   dest[2] = glm_max(a[2], b[2]);
@@ -908,7 +908,7 @@ glm_vec3_maxv(vec3 a, vec3 b, vec3 dest) {
  */
 CGLM_INLINE
 void
-glm_vec3_minv(vec3 a, vec3 b, vec3 dest) {
+glm_vec3_minv(const vec3 a, const vec3 b, vec3 dest) {
   dest[0] = glm_min(a[0], b[0]);
   dest[1] = glm_min(a[1], b[1]);
   dest[2] = glm_min(a[2], b[2]);
@@ -922,7 +922,7 @@ glm_vec3_minv(vec3 a, vec3 b, vec3 dest) {
  */
 CGLM_INLINE
 void
-glm_vec3_ortho(vec3 v, vec3 dest) {
+glm_vec3_ortho(const vec3 v, vec3 dest) {
   float ignore;
   float f      = modff(fabsf(v[0]) + 0.5f, &ignore);
   vec3  result = {-v[1], v[0] - f * v[2], f * v[1]};
@@ -956,7 +956,7 @@ glm_vec3_clamp(vec3 v, float minVal, float maxVal) {
  */
 CGLM_INLINE
 void
-glm_vec3_lerp(vec3 from, vec3 to, float t, vec3 dest) {
+glm_vec3_lerp(const vec3 from, const vec3 to, float t, vec3 dest) {
   vec3 s, v;
 
   /* from + s * (to - from) */
@@ -978,7 +978,7 @@ glm_vec3_lerp(vec3 from, vec3 to, float t, vec3 dest) {
  */
 CGLM_INLINE
 void
-glm_vec3_lerpc(vec3 from, vec3 to, float t, vec3 dest) {
+glm_vec3_lerpc(const vec3 from, const vec3 to, float t, vec3 dest) {
   glm_vec3_lerp(from, to, glm_clamp_zo(t), dest);
 }
 
@@ -994,7 +994,7 @@ glm_vec3_lerpc(vec3 from, vec3 to, float t, vec3 dest) {
  */
 CGLM_INLINE
 void
-glm_vec3_mix(vec3 from, vec3 to, float t, vec3 dest) {
+glm_vec3_mix(const vec3 from, const vec3 to, float t, vec3 dest) {
   glm_vec3_lerp(from, to, t, dest);
 }
 
@@ -1010,7 +1010,7 @@ glm_vec3_mix(vec3 from, vec3 to, float t, vec3 dest) {
  */
 CGLM_INLINE
 void
-glm_vec3_mixc(vec3 from, vec3 to, float t, vec3 dest) {
+glm_vec3_mixc(const vec3 from, const vec3 to, float t, vec3 dest) {
   glm_vec3_lerpc(from, to, t, dest);
 }
 
@@ -1023,7 +1023,7 @@ glm_vec3_mixc(vec3 from, vec3 to, float t, vec3 dest) {
  */
 CGLM_INLINE
 void
-glm_vec3_step(vec3 edge, vec3 x, vec3 dest) {
+glm_vec3_step(const vec3 edge, const vec3 x, vec3 dest) {
   dest[0] = glm_step(edge[0], x[0]);
   dest[1] = glm_step(edge[1], x[1]);
   dest[2] = glm_step(edge[2], x[2]);
@@ -1039,7 +1039,7 @@ glm_vec3_step(vec3 edge, vec3 x, vec3 dest) {
  */
 CGLM_INLINE
 void
-glm_vec3_smoothstep_uni(float edge0, float edge1, vec3 x, vec3 dest) {
+glm_vec3_smoothstep_uni(float edge0, float edge1, const vec3 x, vec3 dest) {
   dest[0] = glm_smoothstep(edge0, edge1, x[0]);
   dest[1] = glm_smoothstep(edge0, edge1, x[1]);
   dest[2] = glm_smoothstep(edge0, edge1, x[2]);
@@ -1055,7 +1055,7 @@ glm_vec3_smoothstep_uni(float edge0, float edge1, vec3 x, vec3 dest) {
  */
 CGLM_INLINE
 void
-glm_vec3_smoothstep(vec3 edge0, vec3 edge1, vec3 x, vec3 dest) {
+glm_vec3_smoothstep(const vec3 edge0, const vec3 edge1, const vec3 x, vec3 dest) {
   dest[0] = glm_smoothstep(edge0[0], edge1[0], x[0]);
   dest[1] = glm_smoothstep(edge0[1], edge1[1], x[1]);
   dest[2] = glm_smoothstep(edge0[2], edge1[2], x[2]);
@@ -1073,9 +1073,9 @@ glm_vec3_smoothstep(vec3 edge0, vec3 edge1, vec3 x, vec3 dest) {
  */
 CGLM_INLINE
 void
-glm_vec3_smoothinterp(vec3 from, vec3 to, float t, vec3 dest) {
+glm_vec3_smoothinterp(const vec3 from, const vec3 to, float t, vec3 dest) {
   vec3 s, v;
-    
+
   /* from + s * (to - from) */
   glm_vec3_broadcast(glm_smooth(t), s);
   glm_vec3_sub(to, from, v);
@@ -1095,7 +1095,7 @@ glm_vec3_smoothinterp(vec3 from, vec3 to, float t, vec3 dest) {
  */
 CGLM_INLINE
 void
-glm_vec3_smoothinterpc(vec3 from, vec3 to, float t, vec3 dest) {
+glm_vec3_smoothinterpc(const vec3 from, const vec3 to, float t, vec3 dest) {
   glm_vec3_smoothinterp(from, to, glm_clamp_zo(t), dest);
 }
 
@@ -1110,7 +1110,7 @@ glm_vec3_smoothinterpc(vec3 from, vec3 to, float t, vec3 dest) {
  */
 CGLM_INLINE
 void
-glm_vec3_swizzle(vec3 v, int mask, vec3 dest) {
+glm_vec3_swizzle(const vec3 v, int mask, vec3 dest) {
   vec3 t;
 
   t[0] = v[(mask & (3 << 0))];
@@ -1131,7 +1131,7 @@ glm_vec3_swizzle(vec3 v, int mask, vec3 dest) {
  */
 CGLM_INLINE
 void
-glm_cross(vec3 a, vec3 b, vec3 d) {
+glm_cross(const vec3 a, const vec3 b, vec3 d) {
   glm_vec3_cross(a, b, d);
 }
 
@@ -1147,7 +1147,7 @@ glm_cross(vec3 a, vec3 b, vec3 d) {
  */
 CGLM_INLINE
 float
-glm_dot(vec3 a, vec3 b) {
+glm_dot(const vec3 a, const vec3 b) {
   return glm_vec3_dot(a, b);
 }
 
@@ -1174,7 +1174,7 @@ glm_normalize(vec3 v) {
  */
 CGLM_INLINE
 void
-glm_normalize_to(vec3 v, vec3 dest) {
+glm_normalize_to(const vec3 v, vec3 dest) {
   glm_vec3_normalize_to(v, dest);
 }
 
@@ -1204,7 +1204,7 @@ glm_vec3_make(const float * __restrict src, vec3 dest) {
  */
 CGLM_INLINE
 void
-glm_vec3_faceforward(vec3 n, vec3 v, vec3 nref, vec3 dest) {
+glm_vec3_faceforward(const vec3 n, const vec3 v, const vec3 nref, vec3 dest) {
   if (glm_vec3_dot(v, nref) < 0.0f) {
     /* N is facing away from I */
     glm_vec3_copy(n, dest);
@@ -1223,7 +1223,7 @@ glm_vec3_faceforward(vec3 n, vec3 v, vec3 nref, vec3 dest) {
  */
 CGLM_INLINE
 void
-glm_vec3_reflect(vec3 v, vec3 n, vec3 dest) {
+glm_vec3_reflect(const vec3 v, const vec3 n, vec3 dest) {
   vec3 temp;
   glm_vec3_scale(n, 2.0f * glm_vec3_dot(v, n), temp);
   glm_vec3_sub(v, temp, dest);
@@ -1245,7 +1245,7 @@ glm_vec3_reflect(vec3 v, vec3 n, vec3 dest) {
  */
 CGLM_INLINE
 bool
-glm_vec3_refract(vec3 v, vec3 n, float eta, vec3 dest) {
+glm_vec3_refract(const vec3 v, const vec3 n, float eta, vec3 dest) {
   float ndi, eni, k;
 
   ndi = glm_vec3_dot(n, v);
@@ -1267,11 +1267,13 @@ glm_vec3_refract(vec3 v, vec3 n, float eta, vec3 dest) {
  * @param a the first vector to swap
  * @param b the second vector to swap
  */
-CGLM_INLINE void glm_vec3_swap(vec3 a, vec3 b) {
-	vec3 tmp;
-	glm_vec3_copy(a, tmp);
-	glm_vec3_copy(b, a);
-	glm_vec3_copy(tmp, b);
+CGLM_INLINE
+void
+glm_vec3_swap(vec3 a, vec3 b) {
+  vec3 tmp;
+  glm_vec3_copy(a, tmp);
+  glm_vec3_copy(b, a);
+  glm_vec3_copy(tmp, b);
 }
 
 #endif /* cglm_vec3_h */
diff --git a/include/cglm/vec4-ext.h b/include/cglm/vec4-ext.h
index 617c163e1..d1530410d 100644
--- a/include/cglm/vec4-ext.h
+++ b/include/cglm/vec4-ext.h
@@ -13,25 +13,25 @@
  Functions:
    CGLM_INLINE void  glm_vec4_broadcast(float val, vec4 d);
    CGLM_INLINE void  glm_vec4_fill(vec4 v, float val);
-   CGLM_INLINE bool  glm_vec4_eq(vec4 v, float val);
-   CGLM_INLINE bool  glm_vec4_eq_eps(vec4 v, float val);
-   CGLM_INLINE bool  glm_vec4_eq_all(vec4 v);
-   CGLM_INLINE bool  glm_vec4_eqv(vec4 a, vec4 b);
-   CGLM_INLINE bool  glm_vec4_eqv_eps(vec4 a, vec4 b);
-   CGLM_INLINE float glm_vec4_max(vec4 v);
-   CGLM_INLINE float glm_vec4_min(vec4 v);
-   CGLM_INLINE bool  glm_vec4_isnan(vec4 v);
-   CGLM_INLINE bool  glm_vec4_isinf(vec4 v);
-   CGLM_INLINE bool  glm_vec4_isvalid(vec4 v);
-   CGLM_INLINE void  glm_vec4_sign(vec4 v, vec4 dest);
-   CGLM_INLINE void  glm_vec4_abs(vec4 v, vec4 dest);
-   CGLM_INLINE void  glm_vec4_fract(vec4 v, vec4 dest);
-   CGLM_INLINE void  glm_vec4_floor(vec4 v, vec4 dest);
-   CGLM_INLINE float glm_vec4_mods(vec4 v, float s, vec4 dest);
-   CGLM_INLINE float glm_vec4_steps(float edge, vec4 v, vec4 dest);
-   CGLM_INLINE void  glm_vec4_stepr(vec4 edge, float v, vec4 dest);
-   CGLM_INLINE float glm_vec4_hadd(vec4 v);
-   CGLM_INLINE void  glm_vec4_sqrt(vec4 v, vec4 dest);
+   CGLM_INLINE bool  glm_vec4_eq(const vec4 v, float val);
+   CGLM_INLINE bool  glm_vec4_eq_eps(const vec4 v, float val);
+   CGLM_INLINE bool  glm_vec4_eq_all(const vec4 v);
+   CGLM_INLINE bool  glm_vec4_eqv(const vec4 a, const vec4 b);
+   CGLM_INLINE bool  glm_vec4_eqv_eps(const vec4 a, const vec4 b);
+   CGLM_INLINE float glm_vec4_max(const vec4 v);
+   CGLM_INLINE float glm_vec4_min(const vec4 v);
+   CGLM_INLINE bool  glm_vec4_isnan(const vec4 v);
+   CGLM_INLINE bool  glm_vec4_isinf(const vec4 v);
+   CGLM_INLINE bool  glm_vec4_isvalid(const vec4 v);
+   CGLM_INLINE void  glm_vec4_sign(const vec4 v, vec4 dest);
+   CGLM_INLINE void  glm_vec4_abs(const vec4 v, vec4 dest);
+   CGLM_INLINE void  glm_vec4_fract(const vec4 v, vec4 dest);
+   CGLM_INLINE void  glm_vec4_floor(const vec4 v, vec4 dest);
+   CGLM_INLINE float glm_vec4_mods(const vec4 v, float s, vec4 dest);
+   CGLM_INLINE float glm_vec4_steps(float edge, const vec4 v, vec4 dest);
+   CGLM_INLINE void  glm_vec4_stepr(const vec4 edge, float v, vec4 dest);
+   CGLM_INLINE float glm_vec4_hadd(const vec4 v);
+   CGLM_INLINE void  glm_vec4_sqrt(const vec4 v, vec4 dest);
  */
 
 #ifndef cglm_vec4_ext_h
@@ -84,7 +84,7 @@ glm_vec4_fill(vec4 v, float val) {
  */
 CGLM_INLINE
 bool
-glm_vec4_eq(vec4 v, float val) {
+glm_vec4_eq(const vec4 v, float val) {
   return v[0] == val
          && v[0] == v[1]
          && v[0] == v[2]
@@ -99,7 +99,7 @@ glm_vec4_eq(vec4 v, float val) {
  */
 CGLM_INLINE
 bool
-glm_vec4_eq_eps(vec4 v, float val) {
+glm_vec4_eq_eps(const vec4 v, float val) {
   return fabsf(v[0] - val) <= GLM_FLT_EPSILON
          && fabsf(v[1] - val) <= GLM_FLT_EPSILON
          && fabsf(v[2] - val) <= GLM_FLT_EPSILON
@@ -113,7 +113,7 @@ glm_vec4_eq_eps(vec4 v, float val) {
  */
 CGLM_INLINE
 bool
-glm_vec4_eq_all(vec4 v) {
+glm_vec4_eq_all(const vec4 v) {
   return glm_vec4_eq_eps(v, v[0]);
 }
 
@@ -125,7 +125,7 @@ glm_vec4_eq_all(vec4 v) {
  */
 CGLM_INLINE
 bool
-glm_vec4_eqv(vec4 a, vec4 b) {
+glm_vec4_eqv(const vec4 a, const vec4 b) {
   return a[0] == b[0]
          && a[1] == b[1]
          && a[2] == b[2]
@@ -140,7 +140,7 @@ glm_vec4_eqv(vec4 a, vec4 b) {
  */
 CGLM_INLINE
 bool
-glm_vec4_eqv_eps(vec4 a, vec4 b) {
+glm_vec4_eqv_eps(const vec4 a, const vec4 b) {
   return fabsf(a[0] - b[0]) <= GLM_FLT_EPSILON
          && fabsf(a[1] - b[1]) <= GLM_FLT_EPSILON
          && fabsf(a[2] - b[2]) <= GLM_FLT_EPSILON
@@ -154,7 +154,7 @@ glm_vec4_eqv_eps(vec4 a, vec4 b) {
  */
 CGLM_INLINE
 float
-glm_vec4_max(vec4 v) {
+glm_vec4_max(const vec4 v) {
   float max;
 
   max = glm_vec3_max(v);
@@ -171,7 +171,7 @@ glm_vec4_max(vec4 v) {
  */
 CGLM_INLINE
 float
-glm_vec4_min(vec4 v) {
+glm_vec4_min(const vec4 v) {
   float min;
 
   min = glm_vec3_min(v);
@@ -189,7 +189,7 @@ glm_vec4_min(vec4 v) {
  */
 CGLM_INLINE
 bool
-glm_vec4_isnan(vec4 v) {
+glm_vec4_isnan(const vec4 v) {
 #ifndef CGLM_FAST_MATH
   return isnan(v[0]) || isnan(v[1]) || isnan(v[2]) || isnan(v[3]);
 #else
@@ -206,7 +206,7 @@ glm_vec4_isnan(vec4 v) {
  */
 CGLM_INLINE
 bool
-glm_vec4_isinf(vec4 v) {
+glm_vec4_isinf(const vec4 v) {
 #ifndef CGLM_FAST_MATH
   return isinf(v[0]) || isinf(v[1]) || isinf(v[2]) || isinf(v[3]);
 #else
@@ -223,7 +223,7 @@ glm_vec4_isinf(vec4 v) {
  */
 CGLM_INLINE
 bool
-glm_vec4_isvalid(vec4 v) {
+glm_vec4_isvalid(const vec4 v) {
   return !glm_vec4_isnan(v) && !glm_vec4_isinf(v);
 }
 
@@ -236,7 +236,7 @@ glm_vec4_isvalid(vec4 v) {
  */
 CGLM_INLINE
 void
-glm_vec4_sign(vec4 v, vec4 dest) {
+glm_vec4_sign(const vec4 v, vec4 dest) {
 #if defined( __SSE__ ) || defined( __SSE2__ )
   __m128 x0, x1, x2, x3, x4;
 
@@ -264,7 +264,7 @@ glm_vec4_sign(vec4 v, vec4 dest) {
  */
 CGLM_INLINE
 void
-glm_vec4_abs(vec4 v, vec4 dest) {
+glm_vec4_abs(const vec4 v, vec4 dest) {
 #if defined(__wasm__) && defined(__wasm_simd128__)
   glmm_store(dest, glmm_abs(glmm_load(v)));
 #elif defined( __SSE__ ) || defined( __SSE2__ )
@@ -287,7 +287,7 @@ glm_vec4_abs(vec4 v, vec4 dest) {
  */
 CGLM_INLINE
 void
-glm_vec4_fract(vec4 v, vec4 dest) {
+glm_vec4_fract(const vec4 v, vec4 dest) {
   dest[0] = fminf(v[0] - floorf(v[0]), 0.999999940395355224609375f);
   dest[1] = fminf(v[1] - floorf(v[1]), 0.999999940395355224609375f);
   dest[2] = fminf(v[2] - floorf(v[2]), 0.999999940395355224609375f);
@@ -302,7 +302,7 @@ glm_vec4_fract(vec4 v, vec4 dest) {
  */
 CGLM_INLINE
 void
-glm_vec4_floor(vec4 v, vec4 dest) {
+glm_vec4_floor(const vec4 v, vec4 dest) {
   dest[0] = floorf(v[0]);
   dest[1] = floorf(v[1]);
   dest[2] = floorf(v[2]);
@@ -318,7 +318,7 @@ glm_vec4_floor(vec4 v, vec4 dest) {
  */
 CGLM_INLINE
 void
-glm_vec4_mods(vec4 v, float s, vec4 dest) {
+glm_vec4_mods(const vec4 v, float s, vec4 dest) {
   dest[0] = fmodf(v[0], s);
   dest[1] = fmodf(v[1], s);
   dest[2] = fmodf(v[2], s);
@@ -335,7 +335,7 @@ glm_vec4_mods(vec4 v, float s, vec4 dest) {
  */
 CGLM_INLINE
 void
-glm_vec4_steps(float edge, vec4 x, vec4 dest) {
+glm_vec4_steps(float edge, const vec4 x, vec4 dest) {
   dest[0] = glm_step(edge, x[0]);
   dest[1] = glm_step(edge, x[1]);
   dest[2] = glm_step(edge, x[2]);
@@ -352,7 +352,7 @@ glm_vec4_steps(float edge, vec4 x, vec4 dest) {
  */
 CGLM_INLINE
 void
-glm_vec4_stepr(vec4 edge, float x, vec4 dest) {
+glm_vec4_stepr(const vec4 edge, float x, vec4 dest) {
   dest[0] = glm_step(edge[0], x);
   dest[1] = glm_step(edge[1], x);
   dest[2] = glm_step(edge[2], x);
@@ -368,7 +368,7 @@ glm_vec4_stepr(vec4 edge, float x, vec4 dest) {
  */
 CGLM_INLINE
 float
-glm_vec4_hadd(vec4 v) {
+glm_vec4_hadd(const vec4 v) {
 #if defined(__wasm__) && defined(__wasm_simd128__)
   return glmm_hadd(glmm_load(v));
 #elif defined( __SSE__ ) || defined( __SSE2__ )
@@ -386,7 +386,7 @@ glm_vec4_hadd(vec4 v) {
  */
 CGLM_INLINE
 void
-glm_vec4_sqrt(vec4 v, vec4 dest) {
+glm_vec4_sqrt(const vec4 v, vec4 dest) {
 #if defined(__wasm__) && defined(__wasm_simd128__)
   glmm_store(dest, wasm_f32x4_sqrt(glmm_load(v)));
 #elif defined( __SSE__ ) || defined( __SSE2__ )
diff --git a/include/cglm/vec4.h b/include/cglm/vec4.h
index f12fa0452..a22bf11bf 100644
--- a/include/cglm/vec4.h
+++ b/include/cglm/vec4.h
@@ -15,57 +15,57 @@
    GLM_VEC4_ZERO
 
  Functions:
-   CGLM_INLINE void  glm_vec4(vec3 v3, float last, vec4 dest);
-   CGLM_INLINE void  glm_vec4_copy3(vec4 a, vec3 dest);
-   CGLM_INLINE void  glm_vec4_copy(vec4 v, vec4 dest);
-   CGLM_INLINE void  glm_vec4_ucopy(vec4 v, vec4 dest);
-   CGLM_INLINE float glm_vec4_dot(vec4 a, vec4 b);
-   CGLM_INLINE float glm_vec4_norm2(vec4 v);
-   CGLM_INLINE float glm_vec4_norm(vec4 v);
-   CGLM_INLINE float glm_vec4_norm_one(vec4 v);
-   CGLM_INLINE float glm_vec4_norm_inf(vec4 v);
-   CGLM_INLINE void  glm_vec4_add(vec4 a, vec4 b, vec4 dest);
-   CGLM_INLINE void  glm_vec4_adds(vec4 v, float s, vec4 dest);
-   CGLM_INLINE void  glm_vec4_sub(vec4 a, vec4 b, vec4 dest);
-   CGLM_INLINE void  glm_vec4_subs(vec4 v, float s, vec4 dest);
-   CGLM_INLINE void  glm_vec4_mul(vec4 a, vec4 b, vec4 dest);
-   CGLM_INLINE void  glm_vec4_scale(vec4 v, float s, vec4 dest);
-   CGLM_INLINE void  glm_vec4_scale_as(vec4 v, float s, vec4 dest);
-   CGLM_INLINE void  glm_vec4_div(vec4 a, vec4 b, vec4 dest);
-   CGLM_INLINE void  glm_vec4_divs(vec4 v, float s, vec4 dest);
-   CGLM_INLINE void  glm_vec4_addadd(vec4 a, vec4 b, vec4 dest);
-   CGLM_INLINE void  glm_vec4_subadd(vec4 a, vec4 b, vec4 dest);
-   CGLM_INLINE void  glm_vec4_muladd(vec4 a, vec4 b, vec4 dest);
-   CGLM_INLINE void  glm_vec4_muladds(vec4 a, float s, vec4 dest);
-   CGLM_INLINE void  glm_vec4_maxadd(vec4 a, vec4 b, vec4 dest);
-   CGLM_INLINE void  glm_vec4_minadd(vec4 a, vec4 b, vec4 dest);
-   CGLM_INLINE void  glm_vec4_subsub(vec4 a, vec4 b, vec4 dest);
-   CGLM_INLINE void  glm_vec4_addsub(vec4 a, vec4 b, vec4 dest);
-   CGLM_INLINE void  glm_vec4_mulsub(vec4 a, vec4 b, vec4 dest);
-   CGLM_INLINE void  glm_vec4_mulsubs(vec4 a, float s, vec4 dest);
-   CGLM_INLINE void  glm_vec4_maxsub(vec4 a, vec4 b, vec4 dest);
-   CGLM_INLINE void  glm_vec4_minsub(vec4 a, vec4 b, vec4 dest);
+   CGLM_INLINE void  glm_vec4(const vec3 v3, float last, vec4 dest);
+   CGLM_INLINE void  glm_vec4_copy3(const vec4 a, vec3 dest);
+   CGLM_INLINE void  glm_vec4_copy(const vec4 v, vec4 dest);
+   CGLM_INLINE void  glm_vec4_ucopy(const vec4 v, vec4 dest);
+   CGLM_INLINE float glm_vec4_dot(const vec4 a, const vec4 b);
+   CGLM_INLINE float glm_vec4_norm2(const vec4 v);
+   CGLM_INLINE float glm_vec4_norm(const vec4 v);
+   CGLM_INLINE float glm_vec4_norm_one(const vec4 v);
+   CGLM_INLINE float glm_vec4_norm_inf(const vec4 v);
+   CGLM_INLINE void  glm_vec4_add(const vec4 a, const vec4 b, vec4 dest);
+   CGLM_INLINE void  glm_vec4_adds(const vec4 v, float s, vec4 dest);
+   CGLM_INLINE void  glm_vec4_sub(const vec4 a, const vec4 b, vec4 dest);
+   CGLM_INLINE void  glm_vec4_subs(const vec4 v, float s, vec4 dest);
+   CGLM_INLINE void  glm_vec4_mul(const vec4 a, const vec4 b, vec4 dest);
+   CGLM_INLINE void  glm_vec4_scale(const vec4 v, float s, vec4 dest);
+   CGLM_INLINE void  glm_vec4_scale_as(const vec4 v, float s, vec4 dest);
+   CGLM_INLINE void  glm_vec4_div(const vec4 a, const vec4 b, vec4 dest);
+   CGLM_INLINE void  glm_vec4_divs(const vec4 v, float s, vec4 dest);
+   CGLM_INLINE void  glm_vec4_addadd(const vec4 a, const vec4 b, vec4 dest);
+   CGLM_INLINE void  glm_vec4_subadd(const vec4 a, const vec4 b, vec4 dest);
+   CGLM_INLINE void  glm_vec4_muladd(const vec4 a, const vec4 b, vec4 dest);
+   CGLM_INLINE void  glm_vec4_muladds(const vec4 a, float s, vec4 dest);
+   CGLM_INLINE void  glm_vec4_maxadd(const vec4 a, const vec4 b, vec4 dest);
+   CGLM_INLINE void  glm_vec4_minadd(const vec4 a, const vec4 b, vec4 dest);
+   CGLM_INLINE void  glm_vec4_subsub(const vec4 a, const vec4 b, vec4 dest);
+   CGLM_INLINE void  glm_vec4_addsub(const vec4 a, const vec4 b, vec4 dest);
+   CGLM_INLINE void  glm_vec4_mulsub(const vec4 a, const vec4 b, vec4 dest);
+   CGLM_INLINE void  glm_vec4_mulsubs(const vec4 a, float s, vec4 dest);
+   CGLM_INLINE void  glm_vec4_maxsub(const vec4 a, const vec4 b, vec4 dest);
+   CGLM_INLINE void  glm_vec4_minsub(const vec4 a, const vec4 b, vec4 dest);
    CGLM_INLINE void  glm_vec4_negate(vec4 v);
-   CGLM_INLINE void  glm_vec4_inv(vec4 v);
-   CGLM_INLINE void  glm_vec4_inv_to(vec4 v, vec4 dest);
+   CGLM_INLINE void  glm_vec4_inv(const vec4 v);
+   CGLM_INLINE void  glm_vec4_inv_to(const vec4 v, vec4 dest);
    CGLM_INLINE void  glm_vec4_normalize(vec4 v);
    CGLM_INLINE void  glm_vec4_normalize_to(vec4 vec, vec4 dest);
-   CGLM_INLINE float glm_vec4_distance(vec4 a, vec4 b);
-   CGLM_INLINE float glm_vec4_distance2(vec4 a, vec4 b);
-   CGLM_INLINE void  glm_vec4_maxv(vec4 a, vec4 b, vec4 dest);
-   CGLM_INLINE void  glm_vec4_minv(vec4 a, vec4 b, vec4 dest);
+   CGLM_INLINE float glm_vec4_distance(const vec4 a, const vec4 b);
+   CGLM_INLINE float glm_vec4_distance2(const vec4 a, const vec4 b);
+   CGLM_INLINE void  glm_vec4_maxv(const vec4 a, const vec4 b, vec4 dest);
+   CGLM_INLINE void  glm_vec4_minv(const vec4 a, const vec4 b, vec4 dest);
    CGLM_INLINE void  glm_vec4_clamp(vec4 v, float minVal, float maxVal);
-   CGLM_INLINE void  glm_vec4_lerp(vec4 from, vec4 to, float t, vec4 dest);
-   CGLM_INLINE void  glm_vec4_lerpc(vec4 from, vec4 to, float t, vec4 dest);
-   CGLM_INLINE void  glm_vec4_step(vec4 edge, vec4 x, vec4 dest);
-   CGLM_INLINE void  glm_vec4_smoothstep_uni(float edge0, float edge1, vec4 x, vec4 dest);
-   CGLM_INLINE void  glm_vec4_smoothstep(vec4 edge0, vec4 edge1, vec4 x, vec4 dest);
-   CGLM_INLINE void  glm_vec4_smoothinterp(vec4 from, vec4 to, float t, vec4 dest);
-   CGLM_INLINE void  glm_vec4_smoothinterpc(vec4 from, vec4 to, float t, vec4 dest);
-   CGLM_INLINE void  glm_vec4_swizzle(vec4 v, int mask, vec4 dest);
+   CGLM_INLINE void  glm_vec4_lerp(const vec4 from, const vec4 to, float t, vec4 dest);
+   CGLM_INLINE void  glm_vec4_lerpc(const vec4 from, const vec4 to, float t, vec4 dest);
+   CGLM_INLINE void  glm_vec4_step(const vec4 edge, const vec4 x, vec4 dest);
+   CGLM_INLINE void  glm_vec4_smoothstep_uni(float edge0, float edge1, const vec4 x, vec4 dest);
+   CGLM_INLINE void  glm_vec4_smoothstep(const vec4 edge0, const vec4 edge1, const vec4 x, vec4 dest);
+   CGLM_INLINE void  glm_vec4_smoothinterp(const vec4 from, const vec4 to, float t, vec4 dest);
+   CGLM_INLINE void  glm_vec4_smoothinterpc(const vec4 from, const vec4 to, float t, vec4 dest);
+   CGLM_INLINE void  glm_vec4_swizzle(const vec4 v, int mask, vec4 dest);
    CGLM_INLINE void  glm_vec4_make(float * restrict src, vec4 dest);
-   CGLM_INLINE void  glm_vec4_reflect(vec4 v, vec4 n, vec4 dest);
-   CGLM_INLINE void  glm_vec4_refract(vec4 v, vec4 n, float eta, vec4 dest);
+   CGLM_INLINE void  glm_vec4_reflect(const vec4 v, const vec4 n, vec4 dest);
+   CGLM_INLINE void  glm_vec4_refract(const vec4 v, const vec4 n, float eta, vec4 dest);
    CGLM_INLINE void  glm_vec4_swap(vec4 a, vec4 b)
 
  DEPRECATED:
@@ -118,7 +118,7 @@
  */
 CGLM_INLINE
 void
-glm_vec4(vec3 v3, float last, vec4 dest) {
+glm_vec4(const vec3 v3, float last, vec4 dest) {
   dest[0] = v3[0];
   dest[1] = v3[1];
   dest[2] = v3[2];
@@ -133,7 +133,7 @@ glm_vec4(vec3 v3, float last, vec4 dest) {
  */
 CGLM_INLINE
 void
-glm_vec4_copy3(vec4 a, vec3 dest) {
+glm_vec4_copy3(const vec4 a, vec3 dest) {
   dest[0] = a[0];
   dest[1] = a[1];
   dest[2] = a[2];
@@ -147,7 +147,7 @@ glm_vec4_copy3(vec4 a, vec3 dest) {
  */
 CGLM_INLINE
 void
-glm_vec4_copy(vec4 v, vec4 dest) {
+glm_vec4_copy(const vec4 v, vec4 dest) {
 #if defined(__wasm__) && defined(__wasm_simd128__)
   glmm_store(dest, glmm_load(v));
 #elif defined( __SSE__ ) || defined( __SSE2__ )
@@ -172,7 +172,7 @@ glm_vec4_copy(vec4 v, vec4 dest) {
  */
 CGLM_INLINE
 void
-glm_vec4_ucopy(vec4 v, vec4 dest) {
+glm_vec4_ucopy(const vec4 v, vec4 dest) {
 #if defined(__wasm__) && defined(__wasm_simd128__)
   /* note here wasm v128.load/v128.store support unaligned loads and stores */
   wasm_v128_store(dest, wasm_v128_load(v));
@@ -238,7 +238,7 @@ glm_vec4_one(vec4 v) {
  */
 CGLM_INLINE
 float
-glm_vec4_dot(vec4 a, vec4 b) {
+glm_vec4_dot(const vec4 a, const vec4 b) {
 #if defined(CGLM_SIMD)
   return glmm_dot(glmm_load(a), glmm_load(b));
 #else
@@ -259,7 +259,7 @@ glm_vec4_dot(vec4 a, vec4 b) {
  */
 CGLM_INLINE
 float
-glm_vec4_norm2(vec4 v) {
+glm_vec4_norm2(const vec4 v) {
   return glm_vec4_dot(v, v);
 }
 
@@ -273,7 +273,7 @@ glm_vec4_norm2(vec4 v) {
  */
 CGLM_INLINE
 float
-glm_vec4_norm(vec4 v) {
+glm_vec4_norm(const vec4 v) {
 #if defined(CGLM_SIMD)
   return glmm_norm(glmm_load(v));
 #else
@@ -297,7 +297,7 @@ glm_vec4_norm(vec4 v) {
  */
 CGLM_INLINE
 float
-glm_vec4_norm_one(vec4 v) {
+glm_vec4_norm_one(const vec4 v) {
 #if defined(CGLM_SIMD)
   return glmm_norm_one(glmm_load(v));
 #else
@@ -322,7 +322,7 @@ glm_vec4_norm_one(vec4 v) {
  */
 CGLM_INLINE
 float
-glm_vec4_norm_inf(vec4 v) {
+glm_vec4_norm_inf(const vec4 v) {
 #if defined(CGLM_SIMD)
   return glmm_norm_inf(glmm_load(v));
 #else
@@ -341,7 +341,7 @@ glm_vec4_norm_inf(vec4 v) {
  */
 CGLM_INLINE
 void
-glm_vec4_add(vec4 a, vec4 b, vec4 dest) {
+glm_vec4_add(const vec4 a, const vec4 b, vec4 dest) {
 #if defined(__wasm__) && defined(__wasm_simd128__)
   glmm_store(dest, wasm_f32x4_add(glmm_load(a), glmm_load(b)));
 #elif defined( __SSE__ ) || defined( __SSE2__ )
@@ -365,7 +365,7 @@ glm_vec4_add(vec4 a, vec4 b, vec4 dest) {
  */
 CGLM_INLINE
 void
-glm_vec4_adds(vec4 v, float s, vec4 dest) {
+glm_vec4_adds(const vec4 v, float s, vec4 dest) {
 #if defined(__wasm__) && defined(__wasm_simd128__)
   glmm_store(dest, wasm_f32x4_add(glmm_load(v), wasm_f32x4_splat(s)));
 #elif defined( __SSE__ ) || defined( __SSE2__ )
@@ -389,7 +389,7 @@ glm_vec4_adds(vec4 v, float s, vec4 dest) {
  */
 CGLM_INLINE
 void
-glm_vec4_sub(vec4 a, vec4 b, vec4 dest) {
+glm_vec4_sub(const vec4 a, const vec4 b, vec4 dest) {
 #if defined(__wasm__) && defined(__wasm_simd128__)
   glmm_store(dest, wasm_f32x4_sub(glmm_load(a), glmm_load(b)));
 #elif defined( __SSE__ ) || defined( __SSE2__ )
@@ -413,7 +413,7 @@ glm_vec4_sub(vec4 a, vec4 b, vec4 dest) {
  */
 CGLM_INLINE
 void
-glm_vec4_subs(vec4 v, float s, vec4 dest) {
+glm_vec4_subs(const vec4 v, float s, vec4 dest) {
 #if defined(__wasm__) && defined(__wasm_simd128__)
   glmm_store(dest, wasm_f32x4_sub(glmm_load(v), wasm_f32x4_splat(s)));
 #elif defined( __SSE__ ) || defined( __SSE2__ )
@@ -437,7 +437,7 @@ glm_vec4_subs(vec4 v, float s, vec4 dest) {
  */
 CGLM_INLINE
 void
-glm_vec4_mul(vec4 a, vec4 b, vec4 dest) {
+glm_vec4_mul(const vec4 a, const vec4 b, vec4 dest) {
 #if defined(__wasm__) && defined(__wasm_simd128__)
   glmm_store(dest, wasm_f32x4_mul(glmm_load(a), glmm_load(b)));
 #elif defined( __SSE__ ) || defined( __SSE2__ )
@@ -461,7 +461,7 @@ glm_vec4_mul(vec4 a, vec4 b, vec4 dest) {
  */
 CGLM_INLINE
 void
-glm_vec4_scale(vec4 v, float s, vec4 dest) {
+glm_vec4_scale(const vec4 v, float s, vec4 dest) {
 #if defined(__wasm__) && defined(__wasm_simd128__)
   glmm_store(dest, wasm_f32x4_mul(glmm_load(v), wasm_f32x4_splat(s)));
 #elif defined( __SSE__ ) || defined( __SSE2__ )
@@ -485,7 +485,7 @@ glm_vec4_scale(vec4 v, float s, vec4 dest) {
  */
 CGLM_INLINE
 void
-glm_vec4_scale_as(vec4 v, float s, vec4 dest) {
+glm_vec4_scale_as(const vec4 v, float s, vec4 dest) {
   float norm;
   norm = glm_vec4_norm(v);
 
@@ -506,7 +506,7 @@ glm_vec4_scale_as(vec4 v, float s, vec4 dest) {
  */
 CGLM_INLINE
 void
-glm_vec4_div(vec4 a, vec4 b, vec4 dest) {
+glm_vec4_div(const vec4 a, const vec4 b, vec4 dest) {
 #if defined(CGLM_SIMD)
   glmm_store(dest, glmm_div(glmm_load(a), glmm_load(b)));
 #else
@@ -526,7 +526,7 @@ glm_vec4_div(vec4 a, vec4 b, vec4 dest) {
  */
 CGLM_INLINE
 void
-glm_vec4_divs(vec4 v, float s, vec4 dest) {
+glm_vec4_divs(const vec4 v, float s, vec4 dest) {
 #if defined(CGLM_SIMD)
   glmm_store(dest, glmm_div(glmm_load(v), glmm_set1(s)));
 #else
@@ -545,7 +545,7 @@ glm_vec4_divs(vec4 v, float s, vec4 dest) {
  */
 CGLM_INLINE
 void
-glm_vec4_addadd(vec4 a, vec4 b, vec4 dest) {
+glm_vec4_addadd(const vec4 a, const vec4 b, vec4 dest) {
 #if defined(__wasm__) && defined(__wasm_simd128__)
   glmm_store(dest, wasm_f32x4_add(
           glmm_load(dest),
@@ -577,7 +577,7 @@ glm_vec4_addadd(vec4 a, vec4 b, vec4 dest) {
  */
 CGLM_INLINE
 void
-glm_vec4_subadd(vec4 a, vec4 b, vec4 dest) {
+glm_vec4_subadd(const vec4 a, const vec4 b, vec4 dest) {
 #if defined(__wasm__) && defined(__wasm_simd128__)
   glmm_store(dest, wasm_f32x4_add(
           glmm_load(dest),
@@ -609,7 +609,7 @@ glm_vec4_subadd(vec4 a, vec4 b, vec4 dest) {
  */
 CGLM_INLINE
 void
-glm_vec4_muladd(vec4 a, vec4 b, vec4 dest) {
+glm_vec4_muladd(const vec4 a, const vec4 b, vec4 dest) {
 #if defined(CGLM_SIMD)
   glmm_store(dest, glmm_fmadd(glmm_load(a), glmm_load(b), glmm_load(dest)));
 #else
@@ -631,7 +631,7 @@ glm_vec4_muladd(vec4 a, vec4 b, vec4 dest) {
  */
 CGLM_INLINE
 void
-glm_vec4_muladds(vec4 a, float s, vec4 dest) {
+glm_vec4_muladds(const vec4 a, float s, vec4 dest) {
 #if defined(CGLM_SIMD)
   glmm_store(dest, glmm_fmadd(glmm_load(a), glmm_set1(s), glmm_load(dest)));
 #else
@@ -653,7 +653,7 @@ glm_vec4_muladds(vec4 a, float s, vec4 dest) {
  */
 CGLM_INLINE
 void
-glm_vec4_maxadd(vec4 a, vec4 b, vec4 dest) {
+glm_vec4_maxadd(const vec4 a, const vec4 b, vec4 dest) {
 #if defined(__wasm__) && defined(__wasm_simd128__)
   glmm_store(dest, wasm_f32x4_add(glmm_load(dest),
                                   glmm_max(glmm_load(a), glmm_load(b))));
@@ -682,7 +682,7 @@ glm_vec4_maxadd(vec4 a, vec4 b, vec4 dest) {
  */
 CGLM_INLINE
 void
-glm_vec4_minadd(vec4 a, vec4 b, vec4 dest) {
+glm_vec4_minadd(const vec4 a, const vec4 b, vec4 dest) {
 #if defined(__wasm__) && defined(__wasm_simd128__)
   glmm_store(dest, wasm_f32x4_add(glmm_load(dest),
                                   glmm_min(glmm_load(a), glmm_load(b))));
@@ -711,7 +711,7 @@ glm_vec4_minadd(vec4 a, vec4 b, vec4 dest) {
  */
 CGLM_INLINE
 void
-glm_vec4_subsub(vec4 a, vec4 b, vec4 dest) {
+glm_vec4_subsub(const vec4 a, const vec4 b, vec4 dest) {
 #if defined(__wasm__) && defined(__wasm_simd128__)
   glmm_store(dest, wasm_f32x4_sub(
           glmm_load(dest),
@@ -743,7 +743,7 @@ glm_vec4_subsub(vec4 a, vec4 b, vec4 dest) {
  */
 CGLM_INLINE
 void
-glm_vec4_addsub(vec4 a, vec4 b, vec4 dest) {
+glm_vec4_addsub(const vec4 a, const vec4 b, vec4 dest) {
 #if defined(__wasm__) && defined(__wasm_simd128__)
   glmm_store(dest, wasm_f32x4_sub(
           glmm_load(dest),
@@ -775,7 +775,7 @@ glm_vec4_addsub(vec4 a, vec4 b, vec4 dest) {
  */
 CGLM_INLINE
 void
-glm_vec4_mulsub(vec4 a, vec4 b, vec4 dest) {
+glm_vec4_mulsub(const vec4 a, const vec4 b, vec4 dest) {
 #if defined(CGLM_SIMD)
   glmm_store(dest, glmm_fnmadd(glmm_load(a), glmm_load(b), glmm_load(dest)));
 #else
@@ -797,7 +797,7 @@ glm_vec4_mulsub(vec4 a, vec4 b, vec4 dest) {
  */
 CGLM_INLINE
 void
-glm_vec4_mulsubs(vec4 a, float s, vec4 dest) {
+glm_vec4_mulsubs(const vec4 a, float s, vec4 dest) {
 #if defined(CGLM_SIMD)
   glmm_store(dest, glmm_fnmadd(glmm_load(a), glmm_set1(s), glmm_load(dest)));
 #else
@@ -819,7 +819,7 @@ glm_vec4_mulsubs(vec4 a, float s, vec4 dest) {
  */
 CGLM_INLINE
 void
-glm_vec4_maxsub(vec4 a, vec4 b, vec4 dest) {
+glm_vec4_maxsub(const vec4 a, const vec4 b, vec4 dest) {
 #if defined(__wasm__) && defined(__wasm_simd128__)
   glmm_store(dest, wasm_f32x4_sub(glmm_load(dest),
                                   glmm_max(glmm_load(a), glmm_load(b))));
@@ -848,7 +848,7 @@ glm_vec4_maxsub(vec4 a, vec4 b, vec4 dest) {
  */
 CGLM_INLINE
 void
-glm_vec4_minsub(vec4 a, vec4 b, vec4 dest) {
+glm_vec4_minsub(const vec4 a, const vec4 b, vec4 dest) {
 #if defined(__wasm__) && defined(__wasm_simd128__)
   glmm_store(dest, wasm_f32x4_sub(glmm_load(dest),
                                   glmm_min(glmm_load(a), glmm_load(b))));
@@ -874,7 +874,7 @@ glm_vec4_minsub(vec4 a, vec4 b, vec4 dest) {
  */
 CGLM_INLINE
 void
-glm_vec4_negate_to(vec4 v, vec4 dest) {
+glm_vec4_negate_to(const vec4 v, vec4 dest) {
 #if defined(__wasm__) && defined(__wasm_simd128__)
   glmm_store(dest, wasm_f32x4_neg(glmm_load(v)));
 #elif defined( __SSE__ ) || defined( __SSE2__ )
@@ -901,14 +901,14 @@ glm_vec4_negate(vec4 v) {
 }
 
 /*!
- * @brief normalize vec4 to dest
+ * @brief normalize const vec4 to dest
  *
  * @param[in]  v    source
  * @param[out] dest destination
  */
 CGLM_INLINE
 void
-glm_vec4_normalize_to(vec4 v, vec4 dest) {
+glm_vec4_normalize_to(const vec4 v, vec4 dest) {
 #if defined(__wasm__) && defined(__wasm_simd128__)
   glmm_128 xdot, x0;
   float  dot;
@@ -972,7 +972,7 @@ glm_vec4_normalize(vec4 v) {
  */
 CGLM_INLINE
 float
-glm_vec4_distance(vec4 a, vec4 b) {
+glm_vec4_distance(const vec4 a, const vec4 b) {
 #if defined(__wasm__) && defined(__wasm_simd128__)
   return glmm_norm(wasm_f32x4_sub(glmm_load(a), glmm_load(b)));
 #elif defined( __SSE__ ) || defined( __SSE2__ )
@@ -996,7 +996,7 @@ glm_vec4_distance(vec4 a, vec4 b) {
  */
 CGLM_INLINE
 float
-glm_vec4_distance2(vec4 a, vec4 b) {
+glm_vec4_distance2(const vec4 a, const vec4 b) {
 #if defined(__wasm__) && defined(__wasm_simd128__)
   return glmm_norm2(wasm_f32x4_sub(glmm_load(a), glmm_load(b)));
 #elif defined( __SSE__ ) || defined( __SSE2__ )
@@ -1020,7 +1020,7 @@ glm_vec4_distance2(vec4 a, vec4 b) {
  */
 CGLM_INLINE
 void
-glm_vec4_maxv(vec4 a, vec4 b, vec4 dest) {
+glm_vec4_maxv(const vec4 a, const vec4 b, vec4 dest) {
 #if defined(CGLM_SIMD)
   glmm_store(dest, glmm_max(glmm_load(a), glmm_load(b)));
 #else
@@ -1040,7 +1040,7 @@ glm_vec4_maxv(vec4 a, vec4 b, vec4 dest) {
  */
 CGLM_INLINE
 void
-glm_vec4_minv(vec4 a, vec4 b, vec4 dest) {
+glm_vec4_minv(const vec4 a, const vec4 b, vec4 dest) {
 #if defined(CGLM_SIMD)
   glmm_store(dest, glmm_min(glmm_load(a), glmm_load(b)));
 #else
@@ -1090,7 +1090,7 @@ glm_vec4_clamp(vec4 v, float minVal, float maxVal) {
  */
 CGLM_INLINE
 void
-glm_vec4_lerp(vec4 from, vec4 to, float t, vec4 dest) {
+glm_vec4_lerp(const vec4 from, const vec4 to, float t, vec4 dest) {
   vec4 s, v;
 
   /* from + s * (to - from) */
@@ -1112,7 +1112,7 @@ glm_vec4_lerp(vec4 from, vec4 to, float t, vec4 dest) {
  */
 CGLM_INLINE
 void
-glm_vec4_lerpc(vec4 from, vec4 to, float t, vec4 dest) {
+glm_vec4_lerpc(const vec4 from, const vec4 to, float t, vec4 dest) {
   glm_vec4_lerp(from, to, glm_clamp_zo(t), dest);
 }
 
@@ -1128,7 +1128,7 @@ glm_vec4_lerpc(vec4 from, vec4 to, float t, vec4 dest) {
  */
 CGLM_INLINE
 void
-glm_vec4_mix(vec4 from, vec4 to, float t, vec4 dest) {
+glm_vec4_mix(const vec4 from, const vec4 to, float t, vec4 dest) {
   glm_vec4_lerp(from, to, t, dest);
 }
 
@@ -1144,7 +1144,7 @@ glm_vec4_mix(vec4 from, vec4 to, float t, vec4 dest) {
  */
 CGLM_INLINE
 void
-glm_vec4_mixc(vec4 from, vec4 to, float t, vec4 dest) {
+glm_vec4_mixc(const vec4 from, const vec4 to, float t, vec4 dest) {
   glm_vec4_lerpc(from, to, t, dest);
 }
 
@@ -1157,7 +1157,7 @@ glm_vec4_mixc(vec4 from, vec4 to, float t, vec4 dest) {
  */
 CGLM_INLINE
 void
-glm_vec4_step(vec4 edge, vec4 x, vec4 dest) {
+glm_vec4_step(const vec4 edge, const vec4 x, vec4 dest) {
   dest[0] = glm_step(edge[0], x[0]);
   dest[1] = glm_step(edge[1], x[1]);
   dest[2] = glm_step(edge[2], x[2]);
@@ -1174,7 +1174,7 @@ glm_vec4_step(vec4 edge, vec4 x, vec4 dest) {
  */
 CGLM_INLINE
 void
-glm_vec4_smoothstep_uni(float edge0, float edge1, vec4 x, vec4 dest) {
+glm_vec4_smoothstep_uni(float edge0, float edge1, const vec4 x, vec4 dest) {
   dest[0] = glm_smoothstep(edge0, edge1, x[0]);
   dest[1] = glm_smoothstep(edge0, edge1, x[1]);
   dest[2] = glm_smoothstep(edge0, edge1, x[2]);
@@ -1191,7 +1191,7 @@ glm_vec4_smoothstep_uni(float edge0, float edge1, vec4 x, vec4 dest) {
  */
 CGLM_INLINE
 void
-glm_vec4_smoothstep(vec4 edge0, vec4 edge1, vec4 x, vec4 dest) {
+glm_vec4_smoothstep(const vec4 edge0, const vec4 edge1, const vec4 x, vec4 dest) {
   dest[0] = glm_smoothstep(edge0[0], edge1[0], x[0]);
   dest[1] = glm_smoothstep(edge0[1], edge1[1], x[1]);
   dest[2] = glm_smoothstep(edge0[2], edge1[2], x[2]);
@@ -1210,9 +1210,9 @@ glm_vec4_smoothstep(vec4 edge0, vec4 edge1, vec4 x, vec4 dest) {
  */
 CGLM_INLINE
 void
-glm_vec4_smoothinterp(vec4 from, vec4 to, float t, vec4 dest) {
+glm_vec4_smoothinterp(const vec4 from, const vec4 to, float t, vec4 dest) {
   vec4 s, v;
-    
+
   /* from + smoothstep * (to - from) */
   glm_vec4_broadcast(glm_smooth(t), s);
   glm_vec4_sub(to, from, v);
@@ -1232,7 +1232,7 @@ glm_vec4_smoothinterp(vec4 from, vec4 to, float t, vec4 dest) {
  */
 CGLM_INLINE
 void
-glm_vec4_smoothinterpc(vec4 from, vec4 to, float t, vec4 dest) {
+glm_vec4_smoothinterpc(const vec4 from, const vec4 to, float t, vec4 dest) {
   glm_vec4_smoothinterp(from, to, glm_clamp_zo(t), dest);
 }
 
@@ -1266,7 +1266,7 @@ glm_vec4_cubic(float s, vec4 dest) {
  */
 CGLM_INLINE
 void
-glm_vec4_swizzle(vec4 v, int mask, vec4 dest) {
+glm_vec4_swizzle(const vec4 v, int mask, vec4 dest) {
   vec4 t;
 
   t[0] = v[(mask & (3 << 0))];
@@ -1299,7 +1299,7 @@ glm_vec4_make(const float * __restrict src, vec4 dest) {
  */
 CGLM_INLINE
 void
-glm_vec4_reflect(vec4 v, vec4 n, vec4 dest) {
+glm_vec4_reflect(const vec4 v, const vec4 n, vec4 dest) {
   vec4 temp;
 
   /* TODO: direct simd touch */
@@ -1329,7 +1329,7 @@ glm_vec4_reflect(vec4 v, vec4 n, vec4 dest) {
  */
 CGLM_INLINE
 bool
-glm_vec4_refract(vec4 v, vec4 n, float eta, vec4 dest) {
+glm_vec4_refract(const vec4 v, const vec4 n, float eta, vec4 dest) {
   float ndi, eni, k;
 
   ndi = glm_vec4_dot(n, v);
@@ -1351,11 +1351,13 @@ glm_vec4_refract(vec4 v, vec4 n, float eta, vec4 dest) {
  * @param a the first vector to swap
  * @param b the second vector to swap
  */
-CGLM_INLINE void glm_vec4_swap(vec4 a, vec4 b) {
-	vec4 tmp;
-	glm_vec4_copy(a, tmp);
-	glm_vec4_copy(b, a);
-	glm_vec4_copy(tmp, b);
+CGLM_INLINE
+void
+glm_vec4_swap(vec4 a, vec4 b) {
+  vec4 tmp;
+  glm_vec4_copy(a, tmp);
+  glm_vec4_copy(b, a);
+  glm_vec4_copy(tmp, b);
 }
 
 #endif /* cglm_vec4_h */