diff --git a/include/cglm/call/vec3.h b/include/cglm/call/vec3.h
index 63d7e38..106257e 100644
--- a/include/cglm/call/vec3.h
+++ b/include/cglm/call/vec3.h
@@ -46,15 +46,15 @@ glmc_vec3_cross(vec3 a, vec3 b, vec3 d);
 
 CGLM_EXPORT
 float
-glmc_vec3_norm(vec3 vec);
+glmc_vec3_norm(vec3 v);
 
 CGLM_EXPORT
 float
-glmc_vec3_norm2(vec3 vec);
+glmc_vec3_norm2(vec3 v);
 
 CGLM_EXPORT
 void
-glmc_vec3_normalize_to(vec3 vec, vec3 dest);
+glmc_vec3_normalize_to(vec3 v, vec3 dest);
 
 CGLM_EXPORT
 void
@@ -62,7 +62,7 @@ glmc_vec3_normalize(vec3 v);
 
 CGLM_EXPORT
 void
-glmc_vec3_add(vec3 v1, vec3 v2, vec3 dest);
+glmc_vec3_add(vec3 a, vec3 b, vec3 dest);
 
 CGLM_EXPORT
 void
@@ -122,7 +122,7 @@ glmc_vec3_negate_to(vec3 v, vec3 dest);
 
 CGLM_EXPORT
 float
-glmc_vec3_angle(vec3 v1, vec3 v2);
+glmc_vec3_angle(vec3 a, vec3 b);
 
 CGLM_EXPORT
 void
@@ -142,23 +142,23 @@ glmc_vec3_proj(vec3 a, vec3 b, vec3 dest);
 
 CGLM_EXPORT
 void
-glmc_vec3_center(vec3 v1, vec3 v2, vec3 dest);
+glmc_vec3_center(vec3 a, vec3 b, vec3 dest);
 
 CGLM_EXPORT
 float
-glmc_vec3_distance2(vec3 v1, vec3 v2);
+glmc_vec3_distance2(vec3 a, vec3 b);
 
 CGLM_EXPORT
 float
-glmc_vec3_distance(vec3 v1, vec3 v2);
+glmc_vec3_distance(vec3 a, vec3 b);
 
 CGLM_EXPORT
 void
-glmc_vec3_maxv(vec3 v1, vec3 v2, vec3 dest);
+glmc_vec3_maxv(vec3 a, vec3 b, vec3 dest);
 
 CGLM_EXPORT
 void
-glmc_vec3_minv(vec3 v1, vec3 v2, vec3 dest);
+glmc_vec3_minv(vec3 a, vec3 b, vec3 dest);
 
 CGLM_EXPORT
 void
@@ -196,11 +196,11 @@ glmc_vec3_eq_all(vec3 v);
 
 CGLM_EXPORT
 bool
-glmc_vec3_eqv(vec3 v1, vec3 v2);
+glmc_vec3_eqv(vec3 a, vec3 b);
 
 CGLM_EXPORT
 bool
-glmc_vec3_eqv_eps(vec3 v1, vec3 v2);
+glmc_vec3_eqv_eps(vec3 a, vec3 b);
 
 CGLM_EXPORT
 float
diff --git a/include/cglm/call/vec4.h b/include/cglm/call/vec4.h
index c71f440..1923da6 100644
--- a/include/cglm/call/vec4.h
+++ b/include/cglm/call/vec4.h
@@ -35,7 +35,7 @@ glmc_vec4_one(vec4 v);
 
 CGLM_EXPORT
 void
-glmc_vec4_copy3(vec4 a, vec3 dest);
+glmc_vec4_copy3(vec4 v, vec3 dest);
 
 CGLM_EXPORT
 void
@@ -51,15 +51,15 @@ glmc_vec4_dot(vec4 a, vec4 b);
 
 CGLM_EXPORT
 float
-glmc_vec4_norm(vec4 vec);
+glmc_vec4_norm(vec4 v);
 
 CGLM_EXPORT
 float
-glmc_vec4_norm2(vec4 vec);
+glmc_vec4_norm2(vec4 v);
 
 CGLM_EXPORT
 void
-glmc_vec4_normalize_to(vec4 vec, vec4 dest);
+glmc_vec4_normalize_to(vec4 v, vec4 dest);
 
 CGLM_EXPORT
 void
@@ -127,15 +127,15 @@ glmc_vec4_negate_to(vec4 v, vec4 dest);
 
 CGLM_EXPORT
 float
-glmc_vec4_distance(vec4 v1, vec4 v2);
+glmc_vec4_distance(vec4 a, vec4 b);
 
 CGLM_EXPORT
 void
-glmc_vec4_maxv(vec4 v1, vec4 v2, vec4 dest);
+glmc_vec4_maxv(vec4 a, vec4 b, vec4 dest);
 
 CGLM_EXPORT
 void
-glmc_vec4_minv(vec4 v1, vec4 v2, vec4 dest);
+glmc_vec4_minv(vec4 a, vec4 b, vec4 dest);
 
 CGLM_EXPORT
 void
@@ -169,11 +169,11 @@ glmc_vec4_eq_all(vec4 v);
 
 CGLM_EXPORT
 bool
-glmc_vec4_eqv(vec4 v1, vec4 v2);
+glmc_vec4_eqv(vec4 a, vec4 b);
 
 CGLM_EXPORT
 bool
-glmc_vec4_eqv_eps(vec4 v1, vec4 v2);
+glmc_vec4_eqv_eps(vec4 a, vec4 b);
 
 CGLM_EXPORT
 float
diff --git a/include/cglm/quat.h b/include/cglm/quat.h
index eee4f53..1db0161 100644
--- a/include/cglm/quat.h
+++ b/include/cglm/quat.h
@@ -19,7 +19,7 @@
    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);
-   CGLM_INLINE float glm_quat_dot(versor q1, versor q2);
+   CGLM_INLINE float glm_quat_dot(versor p, versor q);
    CGLM_INLINE void glm_quat_conjugate(versor q, versor dest);
    CGLM_INLINE void glm_quat_inv(versor q, versor dest);
    CGLM_INLINE void glm_quat_add(versor p, versor q, versor dest);
diff --git a/include/cglm/vec3-ext.h b/include/cglm/vec3-ext.h
index 34166f4..0e64325 100644
--- a/include/cglm/vec3-ext.h
+++ b/include/cglm/vec3-ext.h
@@ -11,13 +11,12 @@
 
 /*
  Functions:
-   CGLM_INLINE void  glm_vec3_mulv(vec3 a, vec3 b, vec3 d);
    CGLM_INLINE void  glm_vec3_broadcast(float val, vec3 d);
    CGLM_INLINE bool  glm_vec3_eq(vec3 v, float val);
    CGLM_INLINE bool  glm_vec3_eq_eps(vec3 v, float val);
    CGLM_INLINE bool  glm_vec3_eq_all(vec3 v);
-   CGLM_INLINE bool  glm_vec3_eqv(vec3 v1, vec3 v2);
-   CGLM_INLINE bool  glm_vec3_eqv_eps(vec3 v1, vec3 v2);
+   CGLM_INLINE bool  glm_vec3_eqv(vec3 a, vec3 b);
+   CGLM_INLINE bool  glm_vec3_eqv_eps(vec3 a, vec3 b);
    CGLM_INLINE float glm_vec3_max(vec3 v);
    CGLM_INLINE float glm_vec3_min(vec3 v);
    CGLM_INLINE bool  glm_vec3_isnan(vec3 v);
@@ -36,21 +35,6 @@
 #include <math.h>
 #include <float.h>
 
-/*!
- * @brief DEPRECATED! use glm_vec3_mul
- *
- * @param[in]  a vec1
- * @param[in]  b vec2
- * @param[out] d vec3 = (v1[0] * v2[0],  v1[1] * v2[1], v1[2] * v2[2])
- */
-CGLM_INLINE
-void
-glm_vec3_mulv(vec3 a, vec3 b, vec3 d) {
-  d[0] = a[0] * b[0];
-  d[1] = a[1] * b[1];
-  d[2] = a[2] * b[2];
-}
-
 /*!
  * @brief fill a vector with specified value
  *
@@ -103,29 +87,29 @@ glm_vec3_eq_all(vec3 v) {
 /*!
  * @brief check if vector is equal to another (without epsilon)
  *
- * @param[in] v1 vector
- * @param[in] v2 vector
+ * @param[in] a vector
+ * @param[in] b vector
  */
 CGLM_INLINE
 bool
-glm_vec3_eqv(vec3 v1, vec3 v2) {
-  return v1[0] == v2[0]
-         && v1[1] == v2[1]
-         && v1[2] == v2[2];
+glm_vec3_eqv(vec3 a, vec3 b) {
+  return a[0] == b[0]
+         && a[1] == b[1]
+         && a[2] == b[2];
 }
 
 /*!
  * @brief check if vector is equal to another (with epsilon)
  *
- * @param[in] v1 vector
- * @param[in] v2 vector
+ * @param[in] a vector
+ * @param[in] b vector
  */
 CGLM_INLINE
 bool
-glm_vec3_eqv_eps(vec3 v1, vec3 v2) {
-  return fabsf(v1[0] - v2[0]) <= FLT_EPSILON
-         && fabsf(v1[1] - v2[1]) <= FLT_EPSILON
-         && fabsf(v1[2] - v2[2]) <= FLT_EPSILON;
+glm_vec3_eqv_eps(vec3 a, vec3 b) {
+  return fabsf(a[0] - b[0]) <= FLT_EPSILON
+         && fabsf(a[1] - b[1]) <= FLT_EPSILON
+         && fabsf(a[2] - b[2]) <= FLT_EPSILON;
 }
 
 /*!
diff --git a/include/cglm/vec3.h b/include/cglm/vec3.h
index de83ada..d311c27 100644
--- a/include/cglm/vec3.h
+++ b/include/cglm/vec3.h
@@ -7,7 +7,6 @@
 
 /*
  Macros:
-   glm_vec3_dup(v, dest)
    GLM_VEC3_ONE_INIT
    GLM_VEC3_ZERO_INIT
    GLM_VEC3_ONE
@@ -24,7 +23,7 @@
    CGLM_INLINE float glm_vec3_dot(vec3 a, vec3 b);
    CGLM_INLINE void  glm_vec3_cross(vec3 a, vec3 b, vec3 d);
    CGLM_INLINE float glm_vec3_norm2(vec3 v);
-   CGLM_INLINE float glm_vec3_norm(vec3 vec);
+   CGLM_INLINE float glm_vec3_norm(vec3 v);
    CGLM_INLINE void  glm_vec3_add(vec3 a, 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);
@@ -45,17 +44,17 @@
    CGLM_INLINE void  glm_vec3_inv(vec3 v);
    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 vec, vec3 dest);
-   CGLM_INLINE float glm_vec3_distance(vec3 v1, vec3 v2);
-   CGLM_INLINE float glm_vec3_angle(vec3 v1, vec3 v2);
+   CGLM_INLINE void  glm_vec3_normalize_to(vec3 v, vec3 dest);
+   CGLM_INLINE float glm_vec3_distance(vec3 a, vec3 b);
+   CGLM_INLINE float glm_vec3_angle(vec3 a, 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 v1, vec3 v2, vec3 dest);
-   CGLM_INLINE float glm_vec3_distance2(vec3 v1, vec3 v2);
-   CGLM_INLINE void  glm_vec3_maxv(vec3 v1, vec3 v2, vec3 dest);
-   CGLM_INLINE void  glm_vec3_minv(vec3 v1, vec3 v2, vec3 dest);
+   CGLM_INLINE void  glm_vec3_center(vec3 a, vec3 b, vec3 dest);
+   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_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);
@@ -72,6 +71,7 @@
    glm_vec3_flipsign_to
    glm_vec3_inv
    glm_vec3_inv_to
+   glm_vec3_mulv
  */
 
 #ifndef cglm_vec3_h
@@ -88,6 +88,7 @@
 #define glm_vec3_flipsign_to(v, dest) glm_vec3_negate_to(v, dest)
 #define glm_vec3_inv(v)               glm_vec3_negate(v)
 #define glm_vec3_inv_to(v, dest)      glm_vec3_negate_to(v, dest)
+#define glm_vec3_mulv(a, b, d)        glm_vec3_mul(a, b, d)
 
 #define GLM_VEC3_ONE_INIT   {1.0f, 1.0f, 1.0f}
 #define GLM_VEC3_ZERO_INIT  {0.0f, 0.0f, 0.0f}
@@ -199,14 +200,14 @@ glm_vec3_norm2(vec3 v) {
 /*!
  * @brief norm (magnitude) of vec3
  *
- * @param[in] vec vector
+ * @param[in] v vector
  *
  * @return norm
  */
 CGLM_INLINE
 float
-glm_vec3_norm(vec3 vec) {
-  return sqrtf(glm_vec3_norm2(vec));
+glm_vec3_norm(vec3 v) {
+  return sqrtf(glm_vec3_norm2(v));
 }
 
 /*!
@@ -240,7 +241,7 @@ glm_vec3_adds(vec3 v, float s, vec3 dest) {
 }
 
 /*!
- * @brief subtract v2 vector from v1 vector store result in dest
+ * @brief subtract b vector from a vector store result in dest
  *
  * @param[in]  a    vector1
  * @param[in]  b    vector2
@@ -272,16 +273,16 @@ glm_vec3_subs(vec3 v, float s, vec3 dest) {
 /*!
  * @brief multiply two vector (component-wise multiplication)
  *
- * @param a v1
- * @param b v2
- * @param d v3 = (a[0] * b[0], a[1] * b[1], a[2] * b[2])
+ * @param a    vector1
+ * @param b    vector2
+ * @param dest v3 = (a[0] * b[0], a[1] * b[1], a[2] * b[2])
  */
 CGLM_INLINE
 void
-glm_vec3_mul(vec3 a, vec3 b, vec3 d) {
-  d[0] = a[0] * b[0];
-  d[1] = a[1] * b[1];
-  d[2] = a[2] * b[2];
+glm_vec3_mul(vec3 a, vec3 b, vec3 dest) {
+  dest[0] = a[0] * b[0];
+  dest[1] = a[1] * b[1];
+  dest[2] = a[2] * b[2];
 }
 
 /*!
@@ -466,40 +467,40 @@ glm_vec3_normalize(vec3 v) {
 /*!
  * @brief normalize vec3 to dest
  *
- * @param[in]  vec  source
+ * @param[in]  v    source
  * @param[out] dest destination
  */
 CGLM_INLINE
 void
-glm_vec3_normalize_to(vec3 vec, vec3 dest) {
+glm_vec3_normalize_to(vec3 v, vec3 dest) {
   float norm;
 
-  norm = glm_vec3_norm(vec);
+  norm = glm_vec3_norm(v);
 
   if (norm == 0.0f) {
     glm_vec3_zero(dest);
     return;
   }
 
-  glm_vec3_scale(vec, 1.0f / norm, dest);
+  glm_vec3_scale(v, 1.0f / norm, dest);
 }
 
 /*!
  * @brief angle betwen two vector
  *
- * @param[in] v1  vector1
- * @param[in] v2  vector2
+ * @param[in] a  vector1
+ * @param[in] b  vector2
  *
  * @return angle as radians
  */
 CGLM_INLINE
 float
-glm_vec3_angle(vec3 v1, vec3 v2) {
+glm_vec3_angle(vec3 a, vec3 b) {
   float norm, dot;
 
   /* maybe compiler generate approximation instruction (rcp) */
-  norm = 1.0f / (glm_vec3_norm(v1) * glm_vec3_norm(v2));
-  dot  = glm_vec3_dot(v1, v2) * norm;
+  norm = 1.0f / (glm_vec3_norm(a) * glm_vec3_norm(b));
+  dot  = glm_vec3_dot(a, b) * norm;
 
   if (dot > 1.0f)
     return 0.0f;
@@ -600,8 +601,8 @@ glm_vec3_rotate_m3(mat3 m, vec3 v, vec3 dest) {
 /*!
  * @brief project a vector onto b vector
  *
- * @param[in]  a vector1
- * @param[in]  b vector2
+ * @param[in]  a    vector1
+ * @param[in]  b    vector2
  * @param[out] dest projected vector
  */
 CGLM_INLINE
@@ -615,73 +616,73 @@ glm_vec3_proj(vec3 a, vec3 b, vec3 dest) {
 /**
  * @brief find center point of two vector
  *
- * @param[in]  v1 vector1
- * @param[in]  v2 vector2
+ * @param[in]  a    vector1
+ * @param[in]  b    vector2
  * @param[out] dest center point
  */
 CGLM_INLINE
 void
-glm_vec3_center(vec3 v1, vec3 v2, vec3 dest) {
-  glm_vec3_add(v1, v2, dest);
+glm_vec3_center(vec3 a, vec3 b, vec3 dest) {
+  glm_vec3_add(a, b, dest);
   glm_vec3_scale(dest, 0.5f, dest);
 }
 
 /**
  * @brief squared distance between two vectors
  *
- * @param[in] v1 vector1
- * @param[in] v2 vector2
+ * @param[in] a vector1
+ * @param[in] b vector2
  * @return returns squared distance (distance * distance)
  */
 CGLM_INLINE
 float
-glm_vec3_distance2(vec3 v1, vec3 v2) {
-  return glm_pow2(v2[0] - v1[0])
-       + glm_pow2(v2[1] - v1[1])
-       + glm_pow2(v2[2] - v1[2]);
+glm_vec3_distance2(vec3 a, vec3 b) {
+  return glm_pow2(b[0] - a[0])
+       + glm_pow2(b[1] - a[1])
+       + glm_pow2(b[2] - a[2]);
 }
 
 /**
  * @brief distance between two vectors
  *
- * @param[in] v1 vector1
- * @param[in] v2 vector2
+ * @param[in] a vector1
+ * @param[in] b vector2
  * @return returns distance
  */
 CGLM_INLINE
 float
-glm_vec3_distance(vec3 v1, vec3 v2) {
-  return sqrtf(glm_vec3_distance2(v1, v2));
+glm_vec3_distance(vec3 a, vec3 b) {
+  return sqrtf(glm_vec3_distance2(a, b));
 }
 
 /*!
  * @brief max values of vectors
  *
- * @param[in]  v1   vector1
- * @param[in]  v2   vector2
+ * @param[in]  a    vector1
+ * @param[in]  b    vector2
  * @param[out] dest destination
  */
 CGLM_INLINE
 void
-glm_vec3_maxv(vec3 v1, vec3 v2, vec3 dest) {
-  dest[0] = glm_max(v1[0], v2[0]);
-  dest[1] = glm_max(v1[1], v2[1]);
-  dest[2] = glm_max(v1[2], v2[2]);
+glm_vec3_maxv(vec3 a, 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]);
 }
 
 /*!
  * @brief min values of vectors
  *
- * @param[in]  v1   vector1
- * @param[in]  v2   vector2
+ * @param[in]  a    vector1
+ * @param[in]  b    vector2
  * @param[out] dest destination
  */
 CGLM_INLINE
 void
-glm_vec3_minv(vec3 v1, vec3 v2, vec3 dest) {
-  dest[0] = glm_min(v1[0], v2[0]);
-  dest[1] = glm_min(v1[1], v2[1]);
-  dest[2] = glm_min(v1[2], v2[2]);
+glm_vec3_minv(vec3 a, 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]);
 }
 
 /*!
diff --git a/include/cglm/vec4-ext.h b/include/cglm/vec4-ext.h
index 3e41c30..07821ac 100644
--- a/include/cglm/vec4-ext.h
+++ b/include/cglm/vec4-ext.h
@@ -11,13 +11,12 @@
 
 /*
  Functions:
-   CGLM_INLINE void  glm_vec4_mulv(vec4 a, vec4 b, vec4 d);
    CGLM_INLINE void  glm_vec4_broadcast(float val, vec4 d);
    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 v1, vec4 v2);
-   CGLM_INLINE bool  glm_vec4_eqv_eps(vec4 v1, vec4 v2);
+   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);
@@ -36,26 +35,6 @@
 #include <math.h>
 #include <float.h>
 
-/*!
- * @brief DEPRECATED! use glm_vec4_mul
- *
- * @param a v1
- * @param b v2
- * @param d v3 = (v1[0] * v2[0],  v1[1] * v2[1], v1[2] * v2[2], v1[3] * v2[3])
- */
-CGLM_INLINE
-void
-glm_vec4_mulv(vec4 a, vec4 b, vec4 d) {
-#if defined( __SSE__ ) || defined( __SSE2__ )
-  glmm_store(d, _mm_mul_ps(glmm_load(a), glmm_load(b)));
-#else
-  d[0] = a[0] * b[0];
-  d[1] = a[1] * b[1];
-  d[2] = a[2] * b[2];
-  d[3] = a[3] * b[3];
-#endif
-}
-
 /*!
  * @brief fill a vector with specified value
  *
@@ -118,31 +97,31 @@ glm_vec4_eq_all(vec4 v) {
 /*!
  * @brief check if vector is equal to another (without epsilon)
  *
- * @param v1 vector
- * @param v2 vector
+ * @param a vector
+ * @param b vector
  */
 CGLM_INLINE
 bool
-glm_vec4_eqv(vec4 v1, vec4 v2) {
-  return v1[0] == v2[0]
-         && v1[1] == v2[1]
-         && v1[2] == v2[2]
-         && v1[3] == v2[3];
+glm_vec4_eqv(vec4 a, vec4 b) {
+  return a[0] == b[0]
+         && a[1] == b[1]
+         && a[2] == b[2]
+         && a[3] == b[3];
 }
 
 /*!
  * @brief check if vector is equal to another (with epsilon)
  *
- * @param v1 vector
- * @param v2 vector
+ * @param a vector
+ * @param b vector
  */
 CGLM_INLINE
 bool
-glm_vec4_eqv_eps(vec4 v1, vec4 v2) {
-  return fabsf(v1[0] - v2[0]) <= FLT_EPSILON
-         && fabsf(v1[1] - v2[1]) <= FLT_EPSILON
-         && fabsf(v1[2] - v2[2]) <= FLT_EPSILON
-         && fabsf(v1[3] - v2[3]) <= FLT_EPSILON;
+glm_vec4_eqv_eps(vec4 a, vec4 b) {
+  return fabsf(a[0] - b[0]) <= FLT_EPSILON
+         && fabsf(a[1] - b[1]) <= FLT_EPSILON
+         && fabsf(a[2] - b[2]) <= FLT_EPSILON
+         && fabsf(a[3] - b[3]) <= FLT_EPSILON;
 }
 
 /*!
diff --git a/include/cglm/vec4.h b/include/cglm/vec4.h
index b170530..2e3f6cf 100644
--- a/include/cglm/vec4.h
+++ b/include/cglm/vec4.h
@@ -7,8 +7,6 @@
 
 /*
  Macros:
-   glm_vec4_dup3(v, dest)
-   glm_vec4_dup(v, dest)
    GLM_VEC4_ONE_INIT
    GLM_VEC4_BLACK_INIT
    GLM_VEC4_ZERO_INIT
@@ -23,7 +21,7 @@
    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 vec);
+   CGLM_INLINE float glm_vec4_norm(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);
@@ -41,9 +39,9 @@
    CGLM_INLINE void  glm_vec4_inv_to(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 v1, vec4 v2);
-   CGLM_INLINE void  glm_vec4_maxv(vec4 v1, vec4 v2, vec4 dest);
-   CGLM_INLINE void  glm_vec4_minv(vec4 v1, vec4 v2, vec4 dest);
+   CGLM_INLINE float glm_vec4_distance(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 void  glm_vec4_clamp(vec4 v, float minVal, float maxVal);
    CGLM_INLINE void  glm_vec4_lerp(vec4 from, vec4 to, float t, vec4 dest)
 
@@ -54,6 +52,7 @@
    glm_vec4_flipsign_to
    glm_vec4_inv
    glm_vec4_inv_to
+   glm_vec4_mulv
  */
 
 #ifndef cglm_vec4_h
@@ -70,6 +69,7 @@
 #define glm_vec4_flipsign_to(v, dest)  glm_vec4_negate_to(v, dest)
 #define glm_vec4_inv(v)                glm_vec4_negate(v)
 #define glm_vec4_inv_to(v, dest)       glm_vec4_negate_to(v, dest)
+#define glm_vec4_mulv(a, b, d)         glm_vec4_mul(a, b, d)
 
 #define GLM_VEC4_ONE_INIT   {1.0f, 1.0f, 1.0f, 1.0f}
 #define GLM_VEC4_BLACK_INIT {0.0f, 0.0f, 0.0f, 1.0f}
@@ -230,24 +230,24 @@ glm_vec4_norm2(vec4 v) {
 /*!
  * @brief norm (magnitude) of vec4
  *
- * @param[in] vec vector
+ * @param[in] v vector
  *
  * @return norm
  */
 CGLM_INLINE
 float
-glm_vec4_norm(vec4 vec) {
+glm_vec4_norm(vec4 v) {
 #if defined( __SSE__ ) || defined( __SSE2__ )
   __m128 x0;
-  x0 = glmm_load(vec);
+  x0 = glmm_load(v);
   return _mm_cvtss_f32(_mm_sqrt_ss(glmm_dot(x0, x0)));
 #else
-  return sqrtf(glm_vec4_norm2(vec));
+  return sqrtf(glm_vec4_norm2(v));
 #endif
 }
 
 /*!
- * @brief add v2 vector to v1 vector store result in dest
+ * @brief add b vector to a vector store result in dest
  *
  * @param[in]  a    vector1
  * @param[in]  b    vector2
@@ -287,7 +287,7 @@ glm_vec4_adds(vec4 v, float s, vec4 dest) {
 }
 
 /*!
- * @brief subtract b vector from a vector store result in dest (d = v1 - v2)
+ * @brief subtract b vector from a vector store result in dest (d = a - b)
  *
  * @param[in]  a    vector1
  * @param[in]  b    vector2
@@ -329,20 +329,20 @@ glm_vec4_subs(vec4 v, float s, vec4 dest) {
 /*!
  * @brief multiply two vector (component-wise multiplication)
  *
- * @param a v1
- * @param b v2
- * @param d v3 = (a[0] * b[0], a[1] * b[1], a[2] * b[2], a[3] * b[3])
+ * @param a vector1
+ * @param b vector2
+ * @param d dest = (a[0] * b[0], a[1] * b[1], a[2] * b[2], a[3] * b[3])
  */
 CGLM_INLINE
 void
-glm_vec4_mul(vec4 a, vec4 b, vec4 d) {
+glm_vec4_mul(vec4 a, vec4 b, vec4 dest) {
 #if defined( __SSE__ ) || defined( __SSE2__ )
-  glmm_store(d, _mm_mul_ps(glmm_load(a), glmm_load(b)));
+  glmm_store(dest, _mm_mul_ps(glmm_load(a), glmm_load(b)));
 #else
-  d[0] = a[0] * b[0];
-  d[1] = a[1] * b[1];
-  d[2] = a[2] * b[2];
-  d[3] = a[3] * b[3];
+  dest[0] = a[0] * b[0];
+  dest[1] = a[1] * b[1];
+  dest[2] = a[2] * b[2];
+  dest[3] = a[3] * b[3];
 #endif
 }
 
@@ -388,7 +388,7 @@ glm_vec4_scale_as(vec4 v, float s, vec4 dest) {
 }
 
 /*!
- * @brief div vector with another component-wise division: d = v1 / v2
+ * @brief div vector with another component-wise division: d = a / b
  *
  * @param[in]  a    vector 1
  * @param[in]  b    vector 2
@@ -554,17 +554,17 @@ glm_vec4_negate(vec4 v) {
 /*!
  * @brief normalize vec4 to dest
  *
- * @param[in]  vec  source
+ * @param[in]  v    source
  * @param[out] dest destination
  */
 CGLM_INLINE
 void
-glm_vec4_normalize_to(vec4 vec, vec4 dest) {
+glm_vec4_normalize_to(vec4 v, vec4 dest) {
 #if defined( __SSE__ ) || defined( __SSE2__ )
   __m128 xdot, x0;
   float  dot;
 
-  x0   = glmm_load(vec);
+  x0   = glmm_load(v);
   xdot = glmm_dot(x0, x0);
   dot  = _mm_cvtss_f32(xdot);
 
@@ -577,14 +577,14 @@ glm_vec4_normalize_to(vec4 vec, vec4 dest) {
 #else
   float norm;
 
-  norm = glm_vec4_norm(vec);
+  norm = glm_vec4_norm(v);
 
   if (norm == 0.0f) {
     glm_vec4_zero(dest);
     return;
   }
 
-  glm_vec4_scale(vec, 1.0f / norm, dest);
+  glm_vec4_scale(v, 1.0f / norm, dest);
 #endif
 }
 
@@ -602,56 +602,56 @@ glm_vec4_normalize(vec4 v) {
 /**
  * @brief distance between two vectors
  *
- * @param[in] v1 vector1
- * @param[in] v2 vector2
+ * @param[in] a vector1
+ * @param[in] b vector2
  * @return returns distance
  */
 CGLM_INLINE
 float
-glm_vec4_distance(vec4 v1, vec4 v2) {
-  return sqrtf(glm_pow2(v2[0] - v1[0])
-             + glm_pow2(v2[1] - v1[1])
-             + glm_pow2(v2[2] - v1[2])
-             + glm_pow2(v2[3] - v1[3]));
+glm_vec4_distance(vec4 a, vec4 b) {
+  return sqrtf(glm_pow2(b[0] - a[0])
+             + glm_pow2(b[1] - a[1])
+             + glm_pow2(b[2] - a[2])
+             + glm_pow2(b[3] - a[3]));
 }
 
 /*!
  * @brief max values of vectors
  *
- * @param[in]  v1   vector1
- * @param[in]  v2   vector2
+ * @param[in]  a    vector1
+ * @param[in]  b    vector2
  * @param[out] dest destination
  */
 CGLM_INLINE
 void
-glm_vec4_maxv(vec4 v1, vec4 v2, vec4 dest) {
+glm_vec4_maxv(vec4 a, vec4 b, vec4 dest) {
 #if defined( __SSE__ ) || defined( __SSE2__ )
-  glmm_store(dest, _mm_max_ps(glmm_load(v1), glmm_load(v2)));
+  glmm_store(dest, _mm_max_ps(glmm_load(a), glmm_load(b)));
 #else
-  dest[0] = glm_max(v1[0], v2[0]);
-  dest[1] = glm_max(v1[1], v2[1]);
-  dest[2] = glm_max(v1[2], v2[2]);
-  dest[3] = glm_max(v1[3], v2[3]);
+  dest[0] = glm_max(a[0], b[0]);
+  dest[1] = glm_max(a[1], b[1]);
+  dest[2] = glm_max(a[2], b[2]);
+  dest[3] = glm_max(a[3], b[3]);
 #endif
 }
 
 /*!
  * @brief min values of vectors
  *
- * @param[in]  v1   vector1
- * @param[in]  v2   vector2
+ * @param[in]  a    vector1
+ * @param[in]  b    vector2
  * @param[out] dest destination
  */
 CGLM_INLINE
 void
-glm_vec4_minv(vec4 v1, vec4 v2, vec4 dest) {
+glm_vec4_minv(vec4 a, vec4 b, vec4 dest) {
 #if defined( __SSE__ ) || defined( __SSE2__ )
-  glmm_store(dest, _mm_min_ps(glmm_load(v1), glmm_load(v2)));
+  glmm_store(dest, _mm_min_ps(glmm_load(a), glmm_load(b)));
 #else
-  dest[0] = glm_min(v1[0], v2[0]);
-  dest[1] = glm_min(v1[1], v2[1]);
-  dest[2] = glm_min(v1[2], v2[2]);
-  dest[3] = glm_min(v1[3], v2[3]);
+  dest[0] = glm_min(a[0], b[0]);
+  dest[1] = glm_min(a[1], b[1]);
+  dest[2] = glm_min(a[2], b[2]);
+  dest[3] = glm_min(a[3], b[3]);
 #endif
 }
 
diff --git a/src/vec3.c b/src/vec3.c
index 9e26cc4..1b6ef3c 100644
--- a/src/vec3.c
+++ b/src/vec3.c
@@ -46,14 +46,14 @@ glmc_vec3_cross(vec3 a, vec3 b, vec3 d) {
 
 CGLM_EXPORT
 float
-glmc_vec3_norm(vec3 vec) {
-  return glm_vec3_norm(vec);
+glmc_vec3_norm(vec3 v) {
+  return glm_vec3_norm(v);
 }
 
 CGLM_EXPORT
 void
-glmc_vec3_normalize_to(vec3 vec, vec3 dest) {
-  glm_vec3_normalize_to(vec, dest);
+glmc_vec3_normalize_to(vec3 v, vec3 dest) {
+  glm_vec3_normalize_to(v, dest);
 }
 
 CGLM_EXPORT
@@ -64,14 +64,14 @@ glmc_vec3_normalize(vec3 v) {
 
 CGLM_EXPORT
 float
-glmc_vec3_norm2(vec3 vec) {
-  return glm_vec3_norm2(vec);
+glmc_vec3_norm2(vec3 v) {
+  return glm_vec3_norm2(v);
 }
 
 CGLM_EXPORT
 void
-glmc_vec3_add(vec3 v1, vec3 v2, vec3 dest) {
-  glm_vec3_add(v1, v2, dest);
+glmc_vec3_add(vec3 a, vec3 b, vec3 dest) {
+  glm_vec3_add(a, b, dest);
 }
 
 CGLM_EXPORT
@@ -160,8 +160,8 @@ glmc_vec3_negate_to(vec3 v, vec3 dest) {
 
 CGLM_EXPORT
 float
-glmc_vec3_angle(vec3 v1, vec3 v2) {
-  return glm_vec3_angle(v1, v2);
+glmc_vec3_angle(vec3 a, vec3 b) {
+  return glm_vec3_angle(a, b);
 }
 
 CGLM_EXPORT
@@ -190,32 +190,32 @@ glmc_vec3_proj(vec3 a, vec3 b, vec3 dest) {
 
 CGLM_EXPORT
 void
-glmc_vec3_center(vec3 v1, vec3 v2, vec3 dest) {
-  glm_vec3_center(v1, v2, dest);
+glmc_vec3_center(vec3 a, vec3 b, vec3 dest) {
+  glm_vec3_center(a, b, dest);
 }
 
 CGLM_EXPORT
 float
-glmc_vec3_distance2(vec3 v1, vec3 v2) {
-  return glm_vec3_distance2(v1, v2);
+glmc_vec3_distance2(vec3 a, vec3 b) {
+  return glm_vec3_distance2(a, b);
 }
 
 CGLM_EXPORT
 float
-glmc_vec3_distance(vec3 v1, vec3 v2) {
-  return glm_vec3_distance(v1, v2);
+glmc_vec3_distance(vec3 a, vec3 b) {
+  return glm_vec3_distance(a, b);
 }
 
 CGLM_EXPORT
 void
-glmc_vec3_maxv(vec3 v1, vec3 v2, vec3 dest) {
-  glm_vec3_minv(v1, v2, dest);
+glmc_vec3_maxv(vec3 a, vec3 b, vec3 dest) {
+  glm_vec3_minv(a, b, dest);
 }
 
 CGLM_EXPORT
 void
-glmc_vec3_minv(vec3 v1, vec3 v2, vec3 dest) {
-  glm_vec3_maxv(v1, v2, dest);
+glmc_vec3_minv(vec3 a, vec3 b, vec3 dest) {
+  glm_vec3_maxv(a, b, dest);
 }
 
 CGLM_EXPORT
@@ -270,14 +270,14 @@ glmc_vec3_eq_all(vec3 v) {
 
 CGLM_EXPORT
 bool
-glmc_vec3_eqv(vec3 v1, vec3 v2) {
-  return glm_vec3_eqv(v1, v2);
+glmc_vec3_eqv(vec3 a, vec3 b) {
+  return glm_vec3_eqv(a, b);
 }
 
 CGLM_EXPORT
 bool
-glmc_vec3_eqv_eps(vec3 v1, vec3 v2) {
-  return glm_vec3_eqv_eps(v1, v2);
+glmc_vec3_eqv_eps(vec3 a, vec3 b) {
+  return glm_vec3_eqv_eps(a, b);
 }
 
 CGLM_EXPORT
diff --git a/src/vec4.c b/src/vec4.c
index a559b12..97b0da4 100644
--- a/src/vec4.c
+++ b/src/vec4.c
@@ -28,8 +28,8 @@ glmc_vec4_one(vec4 v) {
 
 CGLM_EXPORT
 void
-glmc_vec4_copy3(vec4 a, vec3 dest) {
-  glm_vec4_copy3(a, dest);
+glmc_vec4_copy3(vec4 v, vec3 dest) {
+  glm_vec4_copy3(v, dest);
 }
 
 CGLM_EXPORT
@@ -52,14 +52,14 @@ glmc_vec4_dot(vec4 a, vec4 b) {
 
 CGLM_EXPORT
 float
-glmc_vec4_norm(vec4 vec) {
-  return glm_vec4_norm(vec);
+glmc_vec4_norm(vec4 v) {
+  return glm_vec4_norm(v);
 }
 
 CGLM_EXPORT
 void
-glmc_vec4_normalize_to(vec4 vec, vec4 dest) {
-  glm_vec4_normalize_to(vec, dest);
+glmc_vec4_normalize_to(vec4 v, vec4 dest) {
+  glm_vec4_normalize_to(v, dest);
 }
 
 CGLM_EXPORT
@@ -70,8 +70,8 @@ glmc_vec4_normalize(vec4 v) {
 
 CGLM_EXPORT
 float
-glmc_vec4_norm2(vec4 vec) {
-  return glm_vec4_norm2(vec);
+glmc_vec4_norm2(vec4 v) {
+  return glm_vec4_norm2(v);
 }
 
 CGLM_EXPORT
@@ -166,20 +166,20 @@ glmc_vec4_negate_to(vec4 v, vec4 dest) {
 
 CGLM_EXPORT
 float
-glmc_vec4_distance(vec4 v1, vec4 v2) {
-  return glm_vec4_distance(v1, v2);
+glmc_vec4_distance(vec4 a, vec4 b) {
+  return glm_vec4_distance(a, b);
 }
 
 CGLM_EXPORT
 void
-glmc_vec4_maxv(vec4 v1, vec4 v2, vec4 dest) {
-  glm_vec4_minv(v1, v2, dest);
+glmc_vec4_maxv(vec4 a, vec4 b, vec4 dest) {
+  glm_vec4_minv(a, b, dest);
 }
 
 CGLM_EXPORT
 void
-glmc_vec4_minv(vec4 v1, vec4 v2, vec4 dest) {
-  glm_vec4_maxv(v1, v2, dest);
+glmc_vec4_minv(vec4 a, vec4 b, vec4 dest) {
+  glm_vec4_maxv(a, b, dest);
 }
 
 CGLM_EXPORT
@@ -228,14 +228,14 @@ glmc_vec4_eq_all(vec4 v) {
 
 CGLM_EXPORT
 bool
-glmc_vec4_eqv(vec4 v1, vec4 v2) {
-  return glm_vec4_eqv(v1, v2);
+glmc_vec4_eqv(vec4 a, vec4 b) {
+  return glm_vec4_eqv(a, b);
 }
 
 CGLM_EXPORT
 bool
-glmc_vec4_eqv_eps(vec4 v1, vec4 v2) {
-  return glm_vec4_eqv_eps(v1, v2);
+glmc_vec4_eqv_eps(vec4 a, vec4 b) {
+  return glm_vec4_eqv_eps(a, b);
 }
 
 CGLM_EXPORT