diff --git a/HandmadeMath.h b/HandmadeMath.h
index 81fa521..f7c20b5 100644
--- a/HandmadeMath.h
+++ b/HandmadeMath.h
@@ -34,10 +34,9 @@
 
   Version History:
       0.2 (*) Updated documentation
-          () Better C compliance
-          () Prefix all handmade math functions 
-          () Remove use of math.h
-          () Better operator overloading
+          (*) Better C compliance
+          (*) Prefix all handmade math functions 
+          (*) Better operator overloading
 
   LICENSE
 
@@ -90,7 +89,7 @@ extern "C" {
 #define MOD(a, m) ((a) % (m)) >= 0 ? ((a) % (m)) : (((a) % (m)) + (m))
 #define Square(x) ((x) * (x))
 
-typedef union vec2
+typedef union hmm_vec2
 {
     struct
     {
@@ -108,9 +107,9 @@ typedef union vec2
     };
 
     float Elements[2];
-} vec2;
+} hmm_vec2;
 
-typedef union vec3
+typedef union hmm_vec3
 {
     struct
     {
@@ -129,38 +128,38 @@ typedef union vec3
 
     struct
     {
-        vec2 XY;
+        hmm_vec2 XY;
         float Ignored0_;
     };
 
     struct
     {
         float Ignored1_;
-        vec2 YZ;
+        hmm_vec2 YZ;
     };
 
     struct
     {
-        vec2 UV;
+        hmm_vec2 UV;
         float Ignored2_;
     };
 
     struct
     {
         float Ignored3_;
-        vec2 VW;
+        hmm_vec2 VW;
     };
 
     float Elements[3];
-} vec3;
+} hmm_vec3;
 
-typedef union vec4
+typedef union hmm_vec4
 {
     struct
     {
         union
         {
-            vec3 XYZ;
+            hmm_vec3 XYZ;
             struct
             {
                 float X, Y, Z;
@@ -173,7 +172,7 @@ typedef union vec4
     {
         union
         {
-            vec3 RGB;
+            hmm_vec3 RGB;
             struct
             {
                 float R, G, B;
@@ -185,7 +184,7 @@ typedef union vec4
 
     struct
     {
-        vec2 XY;
+        hmm_vec2 XY;
         float Ignored0_;
         float Ignored1_;
     };
@@ -193,7 +192,7 @@ typedef union vec4
     struct
     {
         float Ignored2_;
-        vec2 YZ;
+        hmm_vec2 YZ;
         float Ignored3_;
     };
 
@@ -201,68 +200,68 @@ typedef union vec4
     {
         float Ignored4_;
         float Ignored5_;
-        vec2 ZW;
+        hmm_vec2 ZW;
     };
 
     float Elements[4];
-} vec4;
+} hmm_vec4;
 
-typedef union mat4
+typedef union hmm_mat4
 {
     float Elements[4][4];
-} mat4;
+} hmm_mat4;
 
-typedef vec2 v2;
-typedef vec3 v3;
-typedef vec4 v4;
-typedef mat4 m4;    
+typedef hmm_vec2 hmm_v2;
+typedef hmm_vec3 hmm_v3;
+typedef hmm_vec4 hmm_v4;
+typedef hmm_mat4 hmm_m4;    
 
-HMMDEF float ToRadians(float Degrees);
-HMMDEF float Inner(vec3 A, vec3 B);
-HMMDEF float SquareRoot(float Float);
-HMMDEF float LengthSquareRoot(vec3 A);
-HMMDEF float Length(vec3 A);    
-HMMDEF float Power(float Base, int Exponent);
-HMMDEF float Clamp(float Min, float Value, float Max);
+HMMDEF float HMM_ToRadians(float Degrees);
+HMMDEF float HMM_Inner(hmm_vec3 A, hmm_vec3 B);
+HMMDEF float HMM_SquareRoot(float Float);
+HMMDEF float HMM_LengthSquareRoot(hmm_vec3 A);
+HMMDEF float HMM_Length(hmm_vec3 A);    
+HMMDEF float HMM_Power(float Base, int Exponent);
+HMMDEF float HMM_Clamp(float Min, float Value, float Max);
 
-HMMDEF vec3 Normalize(vec3 A);
-HMMDEF vec3 Cross(vec3 VecOne, vec3 VecTwo);
-HMMDEF float Dot(vec3 VecOne, vec3 VecTwo);
+HMMDEF hmm_vec3 HMM_Normalize(hmm_vec3 A);
+HMMDEF hmm_vec3 HMM_Cross(hmm_vec3 VecOne, hmm_vec3 VecTwo);
+HMMDEF float HMM_Dot(hmm_vec3 VecOne, hmm_vec3 VecTwo);
 
-HMMDEF vec2 Vec2i(int X, int Y);
-HMMDEF vec2 Vec2(float X, float Y);
-HMMDEF vec3 Vec3(float X, float Y, float Z);
-HMMDEF vec3 Vec3i(int X, int Y, int Z);
-HMMDEF vec4 Vec4(float X, float Y, float Z, float W);
-HMMDEF vec4 Vec4i(int X, int Y, int Z, int W);
+HMMDEF hmm_vec2 HMM_Vec2i(int X, int Y);
+HMMDEF hmm_vec2 HMM_Vec2(float X, float Y);
+HMMDEF hmm_vec3 HMM_Vec3(float X, float Y, float Z);
+HMMDEF hmm_vec3 HMM_Vec3i(int X, int Y, int Z);
+HMMDEF hmm_vec4 HMM_Vec4(float X, float Y, float Z, float W);
+HMMDEF hmm_vec4 HMM_Vec4i(int X, int Y, int Z, int W);
 
-HMMDEF vec2 AddVec2(vec2 Left, vec2 Right);
-HMMDEF vec3 AddVec3(vec3 Left, vec3 Right);
-HMMDEF vec4 AddVec4(vec4 Left, vec4 Right);
+HMMDEF hmm_vec2 HMM_AddVec2(hmm_vec2 Left, hmm_vec2 Right);
+HMMDEF hmm_vec3 HMM_AddVec3(hmm_vec3 Left, hmm_vec3 Right);
+HMMDEF hmm_vec4 HMM_AddVec4(hmm_vec4 Left, hmm_vec4 Right);
 
-HMMDEF vec2 SubtractVec2(vec2 Left, vec2 Right);
-HMMDEF vec3 SubtractVec3(vec3 Left, vec3 Right);
-HMMDEF vec4 SubtractVec4(vec4 Left, vec4 Right);
+HMMDEF hmm_vec2 HMM_SubtractVec2(hmm_vec2 Left, hmm_vec2 Right);
+HMMDEF hmm_vec3 HMM_SubtractVec3(hmm_vec3 Left, hmm_vec3 Right);
+HMMDEF hmm_vec4 HMM_SubtractVec4(hmm_vec4 Left, hmm_vec4 Right);
 
-HMMDEF vec2 MultiplyVec2(vec2 Left, vec2 Right);
-HMMDEF vec3 MultiplyVec3(vec3 Left, vec3 Right);
-HMMDEF vec4 MultiplyVec4(vec4 Left, vec4 Right);
+HMMDEF hmm_vec2 HMM_MultiplyVec2(hmm_vec2 Left, hmm_vec2 Right);
+HMMDEF hmm_vec3 HMM_MultiplyVec3(hmm_vec3 Left, hmm_vec3 Right);
+HMMDEF hmm_vec4 HMM_MultiplyVec4(hmm_vec4 Left, hmm_vec4 Right);
 
-HMMDEF vec2 DivideVec2(vec2 Left, vec2 Right);
-HMMDEF vec3 DivideVec3(vec3 Left, vec3 Right);
-HMMDEF vec4 DivideVec4(vec4 Left, vec4 Right);
+HMMDEF hmm_vec2 HMM_DivideVec2(hmm_vec2 Left, hmm_vec2 Right);
+HMMDEF hmm_vec3 HMM_DivideVec3(hmm_vec3 Left, hmm_vec3 Right);
+HMMDEF hmm_vec4 HMM_DivideVec4(hmm_vec4 Left, hmm_vec4 Right);
 
-HMMDEF mat4 Mat4(void);
-HMMDEF mat4 Mat4d(float Diagonal);
-HMMDEF mat4 MultiplyMat4(mat4 Left, mat4 Right);
+HMMDEF hmm_mat4 HMM_Mat4(void);
+HMMDEF hmm_mat4 HMM_Mat4d(float Diagonal);
+HMMDEF hmm_mat4 HMM_MultiplyMat4(hmm_mat4 Left, hmm_mat4 Right);
 
-HMMDEF mat4 Orthographic(float Left, float Right, float Bottom, float Top, float Near, float Far);
-HMMDEF mat4 Perspective(float FOV, float AspectRatio, float Near, float Far);
-HMMDEF mat4 Translate(vec3 Translation);
-HMMDEF mat4 Rotate(float Angle, vec3 Axis);
-HMMDEF mat4 Scale(vec3 Scale);
+HMMDEF hmm_mat4 HMM_Orthographic(float Left, float Right, float Bottom, float Top, float Near, float Far);
+HMMDEF hmm_mat4 HMM_Perspective(float FOV, float AspectRatio, float Near, float Far);
+HMMDEF hmm_mat4 HMM_Translate(hmm_vec3 Translation);
+HMMDEF hmm_mat4 HMM_Rotate(float Angle, hmm_vec3 Axis);
+HMMDEF hmm_mat4 HMM_Scale(hmm_vec3 Scale);
 
-HMMDEF mat4 LookAt(vec3 Eye, vec3 Center, vec3 Up);
+HMMDEF hmm_mat4 HMM_LookAt(hmm_vec3 Eye, hmm_vec3 Center, hmm_vec3 Up);
 
 #ifdef __cplusplus
 }
@@ -270,41 +269,42 @@ HMMDEF mat4 LookAt(vec3 Eye, vec3 Center, vec3 Up);
 
 #ifdef HANDMADE_MATH_CPP_MODE
 
-HMMDEF vec2 Add(int X, int Y);
-HMMDEF vec3 Add(int X, int Y, int Z);
-HMMDEF vec4 Add(int X, int Y, int Z, int W);
+HMMDEF hmm_vec2 HMM_Add(int X, int Y);
+HMMDEF hmm_vec3 HMM_Add(int X, int Y, int Z);
+HMMDEF hmm_vec4 HMM_Add(int X, int Y, int Z, int W);
 
-HMMDEF vec2 Subtract(int X, int Y);
-HMMDEF vec3 Subtract(int X, int Y, int Z);
-HMMDEF vec4 Subtract(int X, int Y, int Z, int W);
+HMMDEF hmm_vec2 HMM_Subtract(int X, int Y);
+HMMDEF hmm_vec3 HMM_Subtract(int X, int Y, int Z);
+HMMDEF hmm_vec4 HMM_Subtract(int X, int Y, int Z, int W);
 
-HMMDEF vec2 Multiply(int X, int Y);
-HMMDEF vec3 Multiply(int X, int Y, int Z);
-HMMDEF vec4 Multiply(int X, int Y, int Z, int W);
-HMMDEF mat4 Multiply(mat4 Left, mat4 Right);
+HMMDEF hmm_vec2 HMM_Multiply(int X, int Y);
+HMMDEF hmm_vec3 HMM_Multiply(int X, int Y, int Z);
+HMMDEF hmm_vec4 HMM_Multiply(int X, int Y, int Z, int W);
+HMMDEF hmm_mat4 HMM_Multiply(hmm_mat4 Left, hmm_mat4 Right);
 
-HMMDEF vec2 Divide(int X, int Y);
-HMMDEF vec3 Divide(int X, int Y, int Z);
-HMMDEF vec4 Divide(int X, int Y, int Z, int W);
+HMMDEF hmm_vec2 HMM_Divide(int X, int Y);
+HMMDEF hmm_vec3 HMM_Divide(int X, int Y, int Z);
+HMMDEF hmm_vec4 HMM_Divide(int X, int Y, int Z, int W);
 
-HMMDEF vec2 operator+(vec2 Left, vec2 Right);
-HMMDEF vec3 operator+(vec3 Left, vec3 Right);
-HMMDEF vec4 operator+(vec4 Left, vec4 Right);
+HMMDEF hmm_vec2 operator+(hmm_vec2 Left, hmm_vec2 Right);
+HMMDEF hmm_vec3 operator+(hmm_vec3 Left, hmm_vec3 Right);
+HMMDEF hmm_vec4 operator+(hmm_vec4 Left, hmm_vec4 Right);
 
-HMMDEF vec2 operator-(vec2 Left, vec2 Right);
-HMMDEF vec3 operator-(vec3 Left, vec3 Right);
-HMMDEF vec4 operator-(vec4 Left, vec4 Right);
+HMMDEF hmm_vec2 operator-(hmm_vec2 Left, hmm_vec2 Right);
+HMMDEF hmm_vec3 operator-(hmm_vec3 Left, hmm_vec3 Right);
+HMMDEF hmm_vec4 operator-(hmm_vec4 Left, hmm_vec4 Right);
 
-HMMDEF vec2 operator*(vec2 Left, vec2 Right);
-HMMDEF vec3 operator*(vec3 Left, vec3 Right);
-HMMDEF vec4 operator*(vec4 Left, vec4 Right);
-HMMDEF mat4 operator*(mat4 Left, mat4 Right);
-HMMDEF vec3 operator*(vec3 Left, float Right);
-HMMDEF vec2 operator*(vec2 Left, float Right);
+HMMDEF hmm_vec2 operator*(hmm_vec2 Left, hmm_vec2 Right);
+HMMDEF hmm_vec3 operator*(hmm_vec3 Left, hmm_vec3 Right);
+HMMDEF hmm_vec4 operator*(hmm_vec4 Left, hmm_vec4 Right);
+HMMDEF hmm_mat4 operator*(hmm_mat4 Left, hmm_mat4 Right);
 
-HMMDEF vec2 operator/(vec2 Left, vec2 Right);
-HMMDEF vec3 operator/(vec3 Left, vec3 Right);
-HMMDEF vec4 operator/(vec4 Left, vec4 Right);
+HMMDEF hmm_vec3 operator*(hmm_vec3 Left, float Right);
+HMMDEF hmm_vec2 operator*(hmm_vec2 Left, float Right);
+
+HMMDEF hmm_vec2 operator/(hmm_vec2 Left, hmm_vec2 Right);
+HMMDEF hmm_vec3 operator/(hmm_vec3 Left, hmm_vec3 Right);
+HMMDEF hmm_vec4 operator/(hmm_vec4 Left, hmm_vec4 Right);
 
 #endif /* HANDMADE_MATH_CPP */
 
@@ -313,7 +313,7 @@ HMMDEF vec4 operator/(vec4 Left, vec4 Right);
 #ifdef HANDMADE_MATH_IMPLEMENTATION
 
 HINLINE float
-ToRadians(float Degrees)
+HMM_ToRadians(float Degrees)
 {
     float Result = Degrees * (Pi32 / 180.0f);
 
@@ -321,7 +321,7 @@ ToRadians(float Degrees)
 }
 
 HINLINE float
-Inner(vec3 A, vec3 B)
+HMM_Inner(hmm_vec3 A, hmm_vec3 B)
 {
     float Result = A.X * B.X + A.Y * B.Y + A.Z * B.Z;
 
@@ -329,30 +329,30 @@ Inner(vec3 A, vec3 B)
 }
 
 HINLINE float
-SquareRoot(float Float)
-{
+HMM_SquareRoot(float Float)
+{    
     float Result = sqrtf(Float);
 
-    return (Result);
+    return(Result);
 }
 
 HINLINE float
-LengthSquareRoot(vec3 A)
+HMM_LengthSquareRoot(hmm_vec3 A)
 {
-    float Result = Inner(A, A);
+    float Result = HMM_Inner(A, A);
 
     return (Result);
 }
 
 HINLINE float
-Length(vec3 A)
+HMM_Length(hmm_vec3 A)
 {
-    float Result = SquareRoot(LengthSquareRoot(A));
+    float Result = HMM_SquareRoot(HMM_LengthSquareRoot(A));
     return (Result);
 }
 
 HINLINE float
-Power(float Base, int Exponent)
+HMM_Power(float Base, int Exponent)
 {
     float Result = 1;
     if(Exponent > 0)
@@ -375,7 +375,7 @@ Power(float Base, int Exponent)
 }
 
 HINLINE float
-Lerp(float A, float Time, float B)
+HMM_Lerp(float A, float Time, float B)
 {
     float Result = (1.0f - Time) * A + Time * B;
 
@@ -383,7 +383,7 @@ Lerp(float A, float Time, float B)
 }
 
 HINLINE float
-Clamp(float Min, float Value, float Max)
+HMM_Clamp(float Min, float Value, float Max)
 {
     float Result = Value;
 
@@ -399,22 +399,22 @@ Clamp(float Min, float Value, float Max)
     return (Result);
 }
 
-HINLINE vec3
-Normalize(vec3 A)
+HINLINE hmm_vec3
+HMM_Normalize(hmm_vec3 A)
 {
-    vec3 Result = {0};
+    hmm_vec3 Result = {0};
 
-    Result.X = A.X * (1.0f / Length(A));
-    Result.Y = A.Y * (1.0f / Length(A));
-    Result.Z = A.Z * (1.0f / Length(A));
+    Result.X = A.X * (1.0f / HMM_Length(A));
+    Result.Y = A.Y * (1.0f / HMM_Length(A));
+    Result.Z = A.Z * (1.0f / HMM_Length(A));
     
     return (Result);
 }
 
-HINLINE vec3
-Cross(vec3 VecOne, vec3 VecTwo)
+HINLINE hmm_vec3
+HMM_Cross(hmm_vec3 VecOne, hmm_vec3 VecTwo)
 {
-    vec3 Result;
+    hmm_vec3 Result;
 
     Result.X = (VecOne.Y * VecTwo.Z) - (VecOne.Z * VecTwo.Y);
     Result.Y = (VecOne.Z * VecTwo.X) - (VecOne.X * VecTwo.Z);
@@ -424,7 +424,7 @@ Cross(vec3 VecOne, vec3 VecTwo)
 }
 
 HINLINE float
-Dot(vec3 VecOne, vec3 VecTwo)
+HMM_Dot(hmm_vec3 VecOne, hmm_vec3 VecTwo)
 {
     float Result = 0;
 
@@ -433,10 +433,10 @@ Dot(vec3 VecOne, vec3 VecTwo)
     return (Result);
 }
 
-HINLINE vec2
-Vec2(float X, float Y)
+HINLINE hmm_vec2
+HMM_Vec2(float X, float Y)
 {
-    vec2 Result;
+    hmm_vec2 Result;
 
     Result.X = X;
     Result.Y = Y;
@@ -444,10 +444,10 @@ Vec2(float X, float Y)
     return (Result);
 }
 
-HINLINE vec2
-Vec2i(int X, int Y)
+HINLINE hmm_vec2
+HMM_Vec2i(int X, int Y)
 {
-    vec2 Result;
+    hmm_vec2 Result;
 
     Result.X = (float)X;
     Result.Y = (float)Y;
@@ -455,10 +455,10 @@ Vec2i(int X, int Y)
     return (Result);
 }
 
-HINLINE vec3
-Vec3(float X, float Y, float Z)
+HINLINE hmm_vec3
+HMM_Vec3(float X, float Y, float Z)
 {
-    vec3 Result;
+    hmm_vec3 Result;
 
     Result.X = X;
     Result.Y = Y;
@@ -467,10 +467,10 @@ Vec3(float X, float Y, float Z)
     return (Result);
 }
 
-HINLINE vec3
-Vec3i(int X, int Y, int Z)
+HINLINE hmm_vec3
+HMM_Vec3i(int X, int Y, int Z)
 {
-    vec3 Result;
+    hmm_vec3 Result;
 
     Result.X = (float)X;
     Result.Y = (float)Y;
@@ -479,10 +479,10 @@ Vec3i(int X, int Y, int Z)
     return (Result);
 }
 
-HINLINE vec4
-Vec4(float X, float Y, float Z, float W)
+HINLINE hmm_vec4
+HMM_Vec4(float X, float Y, float Z, float W)
 {
-    vec4 Result;
+    hmm_vec4 Result;
 
     Result.X = X;
     Result.Y = Y;
@@ -492,10 +492,10 @@ Vec4(float X, float Y, float Z, float W)
     return (Result);
 }
 
-HINLINE vec4
-Vec4i(int X, int Y, int Z, int W)
+HINLINE hmm_vec4
+HMM_Vec4i(int X, int Y, int Z, int W)
 {
-    vec4 Result;
+    hmm_vec4 Result;
 
     Result.X = (float)X;
     Result.Y = (float)Y;
@@ -505,10 +505,10 @@ Vec4i(int X, int Y, int Z, int W)
     return (Result);
 }
 
-HINLINE vec2
-AddVec2(vec2 Left, vec2 Right)
+HINLINE hmm_vec2
+HMM_AddVec2(hmm_vec2 Left, hmm_vec2 Right)
 {
-    vec2 Result;
+    hmm_vec2 Result;
 
     Result.X = Left.X + Right.X;
     Result.Y = Left.Y + Right.Y;
@@ -516,10 +516,10 @@ AddVec2(vec2 Left, vec2 Right)
     return (Result);
 }
 
-HINLINE vec3
-AddVec3(vec3 Left, vec3 Right)
+HINLINE hmm_vec3
+HMM_AddVec3(hmm_vec3 Left, hmm_vec3 Right)
 {
-    vec3 Result;
+    hmm_vec3 Result;
 
     Result.X = Left.X + Right.X;
     Result.Y = Left.Y + Right.Y;
@@ -528,10 +528,10 @@ AddVec3(vec3 Left, vec3 Right)
     return (Result);
 }
 
-HINLINE vec4
-AddVec4(vec4 Left, vec4 Right)
+HINLINE hmm_vec4
+HMM_AddVec4(hmm_vec4 Left, hmm_vec4 Right)
 {
-    vec4 Result;
+    hmm_vec4 Result;
 
     Result.X = Left.X + Right.X;
     Result.Y = Left.Y + Right.Y;
@@ -541,10 +541,10 @@ AddVec4(vec4 Left, vec4 Right)
     return (Result);
 }
 
-HINLINE vec2
-SubtractVec2(vec2 Left, vec2 Right)
+HINLINE hmm_vec2
+HMM_SubtractVec2(hmm_vec2 Left, hmm_vec2 Right)
 {
-    vec2 Result;
+    hmm_vec2 Result;
 
     Result.X = Left.X - Right.X;
     Result.Y = Left.Y - Right.Y;
@@ -552,10 +552,10 @@ SubtractVec2(vec2 Left, vec2 Right)
     return (Result);
 }
 
-HINLINE vec3
-SubtractVec3(vec3 Left, vec3 Right)
+HINLINE hmm_vec3
+HMM_SubtractVec3(hmm_vec3 Left, hmm_vec3 Right)
 {
-    vec3 Result;
+    hmm_vec3 Result;
 
     Result.X = Left.X - Right.X;
     Result.Y = Left.Y - Right.Y;
@@ -564,10 +564,10 @@ SubtractVec3(vec3 Left, vec3 Right)
     return (Result);
 }
 
-HINLINE vec4
-SubtractVec4(vec4 Left, vec4 Right)
+HINLINE hmm_vec4
+HMM_SubtractVec4(hmm_vec4 Left, hmm_vec4 Right)
 {
-    vec4 Result;
+    hmm_vec4 Result;
 
     Result.X = Left.X - Right.X;
     Result.Y = Left.Y - Right.Y;
@@ -577,10 +577,10 @@ SubtractVec4(vec4 Left, vec4 Right)
     return (Result);
 }
 
-HINLINE vec2
-MultiplyVec2(vec2 Left, vec2 Right)
+HINLINE hmm_vec2
+HMM_MultiplyVec2(hmm_vec2 Left, hmm_vec2 Right)
 {
-    vec2 Result;
+    hmm_vec2 Result;
 
     Result.X = Left.X * Right.X;
     Result.Y = Left.Y * Right.Y;
@@ -588,10 +588,10 @@ MultiplyVec2(vec2 Left, vec2 Right)
     return (Result);
 }
 
-HINLINE vec3
-MultiplyVec3(vec3 Left, vec3 Right)
+HINLINE hmm_vec3
+HMM_MultiplyVec3(hmm_vec3 Left, hmm_vec3 Right)
 {
-    vec3 Result;
+    hmm_vec3 Result;
 
     Result.X = Left.Z * Right.X;
     Result.Y = Left.Y * Right.Y;
@@ -600,10 +600,10 @@ MultiplyVec3(vec3 Left, vec3 Right)
     return (Result);
 }
 
-HINLINE vec4
-MultiplyVec4(vec4 Left, vec4 Right)
+HINLINE hmm_vec4
+HMM_MultiplyVec4(hmm_vec4 Left, hmm_vec4 Right)
 {
-    vec4 Result;
+    hmm_vec4 Result;
 
     Result.X = Left.X * Right.X;
     Result.Y = Left.Y * Right.Y;
@@ -613,10 +613,10 @@ MultiplyVec4(vec4 Left, vec4 Right)
     return (Result);
 }
 
-HINLINE vec2
-DivideVec2(vec2 Left, vec2 Right)
+HINLINE hmm_vec2
+HMM_DivideVec2(hmm_vec2 Left, hmm_vec2 Right)
 {
-    vec2 Result;
+    hmm_vec2 Result;
 
     Result.X = Left.X / Right.X;
     Result.Y = Left.Y / Right.Y;
@@ -624,10 +624,10 @@ DivideVec2(vec2 Left, vec2 Right)
     return (Result);
 }
 
-HINLINE vec3
-DivideVec3(vec3 Left, vec3 Right)
+HINLINE hmm_vec3
+HMM_DivideVec3(hmm_vec3 Left, hmm_vec3 Right)
 {
-    vec3 Result;
+    hmm_vec3 Result;
 
     Result.X = Left.X / Right.X;
     Result.Y = Left.Y / Right.Y;
@@ -636,10 +636,10 @@ DivideVec3(vec3 Left, vec3 Right)
     return (Result);
 }
 
-HINLINE vec4
-DivideVec4(vec4 Left, vec4 Right)
+HINLINE hmm_vec4
+HMM_DivideVec4(hmm_vec4 Left, hmm_vec4 Right)
 {
-    vec4 Result;
+    hmm_vec4 Result;
 
     Result.X = Left.X / Right.X;
     Result.Y = Left.Y / Right.Y;
@@ -649,18 +649,18 @@ DivideVec4(vec4 Left, vec4 Right)
     return (Result);
 }
 
-HINLINE mat4
-Mat4()
+HINLINE hmm_mat4
+HMM_Mat4()
 {
-    mat4 Result = {0};
+    hmm_mat4 Result = {0};
 
     return (Result);
 }
 
-mat4
-Mat4d(float Diagonal)
+hmm_mat4
+HMM_Mat4d(float Diagonal)
 {
-    mat4 Result;
+    hmm_mat4 Result;
 
     int Rows;
     for(Rows = 0; Rows < 4; ++Rows)
@@ -680,10 +680,10 @@ Mat4d(float Diagonal)
     return (Result);
 }
 
-mat4
-MultiplyMat4(mat4 Left, mat4 Right)
+hmm_mat4
+HMM_MultiplyMat4(hmm_mat4 Left, hmm_mat4 Right)
 {
-    mat4 Result = Mat4();
+    hmm_mat4 Result = HMM_Mat4();
 
     int Rows;
     for(Rows = 0; Rows < 4; ++Rows)
@@ -705,10 +705,10 @@ MultiplyMat4(mat4 Left, mat4 Right)
     return (Result);
 }
 
-mat4
-Orthographic(float Left, float Right, float Bottom, float Top, float Near, float Far)
+hmm_mat4
+HMM_Orthographic(float Left, float Right, float Bottom, float Top, float Near, float Far)
 {
-    mat4 Result = Mat4d(1.0f);
+    hmm_mat4 Result = HMM_Mat4d(1.0f);
 
     Result.Elements[0][0] = 2.0f / (Right - Left);
     Result.Elements[1][1] = 2.0f / (Top - Bottom);
@@ -721,10 +721,10 @@ Orthographic(float Left, float Right, float Bottom, float Top, float Near, float
     return (Result);
 }
 
-mat4
-Perspective(float FOV, float AspectRatio, float Near, float Far)
+hmm_mat4
+HMM_Perspective(float FOV, float AspectRatio, float Near, float Far)
 {
-    mat4 Result = Mat4d(1.0f);
+    hmm_mat4 Result = HMM_Mat4d(1.0f);
 
     Result.Elements[0][0] = 1.0f / (AspectRatio * tanf(FOV / 2.0f));
     Result.Elements[1][1] = 1.0f / tanf(FOV / 2.0f);
@@ -736,10 +736,10 @@ Perspective(float FOV, float AspectRatio, float Near, float Far)
     return (Result);
 }
 
-mat4
-Translate(vec3 Translation)
+hmm_mat4
+HMM_Translate(hmm_vec3 Translation)
 {
-    mat4 Result = Mat4d(1.0f);
+    hmm_mat4 Result = HMM_Mat4d(1.0f);
 
     Result.Elements[3][0] = Translation.X;
     Result.Elements[3][1] = Translation.Y;
@@ -748,34 +748,34 @@ Translate(vec3 Translation)
     return (Result);
 }
 
-mat4
-Rotate(float Angle, vec3 Axis)
+hmm_mat4
+HMM_Rotate(float Angle, hmm_vec3 Axis)
 {
-    mat4 Result = Mat4d(1.0f);
+    hmm_mat4 Result = HMM_Mat4d(1.0f);
 
-    Result.Elements[0][0] = Axis.X * Axis.X * (1.0f - cosf(ToRadians(Angle))) + cosf(ToRadians(Angle));
-    Result.Elements[0][1] = Axis.Y * Axis.X * (1.0f - cosf(ToRadians(Angle))) + Axis.Z * (sinf(ToRadians(Angle)));
-    Result.Elements[0][2] = Axis.X * Axis.Z * (1.0f - cosf(ToRadians(Angle))) - Axis.Y * (sinf(ToRadians(Angle)));
+    Result.Elements[0][0] = Axis.X * Axis.X * (1.0f - cosf(HMM_ToRadians(Angle))) + cosf(HMM_ToRadians(Angle));
+    Result.Elements[0][1] = Axis.Y * Axis.X * (1.0f - cosf(HMM_ToRadians(Angle))) + Axis.Z * (sinf(HMM_ToRadians(Angle)));
+    Result.Elements[0][2] = Axis.X * Axis.Z * (1.0f - cosf(HMM_ToRadians(Angle))) - Axis.Y * (sinf(HMM_ToRadians(Angle)));
 
-    Result.Elements[1][0] = Axis.X * Axis.Y * (1.0f - cosf(ToRadians(Angle))) - Axis.Z * (sinf(ToRadians(Angle)));
-    Result.Elements[1][1] = Axis.Y * Axis.Y * (1.0f - cosf(ToRadians(Angle))) + (cosf(ToRadians(Angle)));
-    Result.Elements[1][2] = Axis.Y * Axis.Z * (1.0f - cosf(ToRadians(Angle))) + Axis.X * (sinf(ToRadians(Angle)));
+    Result.Elements[1][0] = Axis.X * Axis.Y * (1.0f - cosf(HMM_ToRadians(Angle))) - Axis.Z * (sinf(HMM_ToRadians(Angle)));
+    Result.Elements[1][1] = Axis.Y * Axis.Y * (1.0f - cosf(HMM_ToRadians(Angle))) + (cosf(HMM_ToRadians(Angle)));
+    Result.Elements[1][2] = Axis.Y * Axis.Z * (1.0f - cosf(HMM_ToRadians(Angle))) + Axis.X * (sinf(HMM_ToRadians(Angle)));
 
-    Result.Elements[2][0] = Axis.X * Axis.Z * (1.0f - cosf(ToRadians(Angle))) + Axis.Y * (sinf(ToRadians(Angle)));
-    Result.Elements[2][1] = Axis.Y * Axis.Z * (1.0f - cosf(ToRadians(Angle))) - Axis.X * (sinf(ToRadians(Angle)));
-    Result.Elements[2][2] = Axis.Z * Axis.Z * (1.0f - cosf(ToRadians(Angle))) * (cosf(ToRadians(Angle)));
+    Result.Elements[2][0] = Axis.X * Axis.Z * (1.0f - cosf(HMM_ToRadians(Angle))) + Axis.Y * (sinf(HMM_ToRadians(Angle)));
+    Result.Elements[2][1] = Axis.Y * Axis.Z * (1.0f - cosf(HMM_ToRadians(Angle))) - Axis.X * (sinf(HMM_ToRadians(Angle)));
+    Result.Elements[2][2] = Axis.Z * Axis.Z * (1.0f - cosf(HMM_ToRadians(Angle))) * (cosf(HMM_ToRadians(Angle)));
 
     return (Result);
 }
 
-mat4
-LookAt(vec3 Eye, vec3 Center, vec3 Up)
+hmm_mat4
+HMM_LookAt(hmm_vec3 Eye, hmm_vec3 Center, hmm_vec3 Up)
 {
-    mat4 Result = {0};
+    hmm_mat4 Result = {0};
 
-    vec3 F = Normalize(SubtractVec3(Center, Eye));
-    vec3 S = Normalize(Cross(F, Up));
-    vec3 U = Cross(S, F);
+    hmm_vec3 F = HMM_Normalize(HMM_SubtractVec3(Center, Eye));
+    hmm_vec3 S = HMM_Normalize(HMM_Cross(F, Up));
+    hmm_vec3 U = HMM_Cross(S, F);
 
     Result.Elements[0][0] = S.X;
     Result.Elements[0][1] = U.X;
@@ -789,18 +789,18 @@ LookAt(vec3 Eye, vec3 Center, vec3 Up)
     Result.Elements[2][1] = U.Z;
     Result.Elements[2][2] = -F.Z;
 
-    Result.Elements[3][0] = -Dot(S, Eye);
-    Result.Elements[3][1] = -Dot(U, Eye);
-    Result.Elements[3][2] = Dot(F, Eye);
+    Result.Elements[3][0] = -HMM_Dot(S, Eye);
+    Result.Elements[3][1] = -HMM_Dot(U, Eye);
+    Result.Elements[3][2] = HMM_Dot(F, Eye);
     Result.Elements[3][3] = 1.0f;
 
     return (Result);
 }
 
-mat4
-Scale(vec3 Scale)
+hmm_mat4
+HMM_Scale(hmm_vec3 Scale)
 {
-    mat4 Result = Mat4d(1.0f);
+    hmm_mat4 Result = HMM_Mat4d(1.0f);
 
     Result.Elements[0][0] = Scale.X;
     Result.Elements[1][1] = Scale.Y;
@@ -811,175 +811,178 @@ Scale(vec3 Scale)
 
 #ifdef HANDMADE_MATH_CPP_MODE
 
-HMMDEF HINLINE vec2
-Add(vec2 Left, vec2 Right)
+HINLINE hmm_vec2
+Add(hmm_vec2 Left, hmm_vec2 Right)
 {
-    vec2 Result = AddVec2(Left, Right);
+    hmm_vec2 Result = HMM_AddVec2(Left, Right);
 
     return (Result);
 }
 
-HMMDEF HINLINE vec3
-Add(vec3 Left, vec3 Right)
+HINLINE hmm_vec3
+Add(hmm_vec3 Left, hmm_vec3 Right)
 {
-    vec3 Result = AddVec3(Left, Right);
+    hmm_vec3 Result = HMM_AddVec3(Left, Right);
 
     return (Result);
 }
 
-HMMDEF HINLINE vec4
-Add(vec4 Left, vec4 Right)
+HMMDEF HINLINE hmm_vec4
+Add(hmm_vec4 Left, hmm_vec4 Right)
 {
-    vec4 Result = AddVec4(Left, Right);
+    hmm_vec4 Result = HMM_AddVec4(Left, Right);
 
     return (Result);
 }
 
-HMMDEF HINLINE vec2
-Subtract(vec2 Left, vec2 Right)
+HINLINE hmm_vec2
+Subtract(hmm_vec2 Left, hmm_vec2 Right)
 {
-    vec2 Result = SubtractVec2(Left, Right);
+    hmm_vec2 Result = HMM_SubtractVec2(Left, Right);
 
     return (Result);
 }
 
-HMMDEF HINLINE vec3
-Subtract(vec3 Left, vec3 Right)
+HINLINE hmm_vec3
+Subtract(hmm_vec3 Left, hmm_vec3 Right)
 {
-    vec3 Result = SubtractVec3(Left, Right);
+    hmm_vec3 Result = HMM_SubtractVec3(Left, Right);
 
     return (Result);
 }
 
-HMMDEF HINLINE vec4
-Subtract(vec4 Left, vec4 Right)
+HINLINE hmm_vec4
+Subtract(hmm_vec4 Left, hmm_vec4 Right)
 {
-    vec4 Result = SubtractVec4(Left, Right);
+    hmm_vec4 Result = HMM_SubtractVec4(Left, Right);
 
     return (Result);
 }
 
-HMMDEF HINLINE vec2
-Multiply(vec2 Left, vec2 Right)
+HINLINE hmm_vec2
+Multiply(hmm_vec2 Left, hmm_vec2 Right)
 {
-    vec2 Result = MultiplyVec2(Left, Right);
+    hmm_vec2 Result = HMM_MultiplyVec2(Left, Right);
 
     return (Result);
 }
 
-HMMDEF HINLINE vec3
-Multiply(vec3 Left, vec3 Right)
+HINLINE hmm_vec3
+Multiply(hmm_vec3 Left, hmm_vec3 Right)
 {
-    vec3 Result = MultiplyVec3(Left, Right);
+    hmm_vec3 Result = HMM_MultiplyVec3(Left, Right);
 
     return (Result);
 }
 
-HMMDEF HINLINE vec4
-Multiply(vec4 Left, vec4 Right)
+HINLINE hmm_vec4
+Multiply(hmm_vec4 Left, hmm_vec4 Right)
 {
-    vec4 Result = MultiplyVec4(Left, Right);
+    hmm_vec4 Result = HMM_MultiplyVec4(Left, Right);
 
     return (Result);
 }
 
-HMMDEF HINLINE mat4
-Multiply(mat4 Left, mat4 Right)
+HINLINE hmm_mat4
+Multiply(hmm_mat4 Left, hmm_mat4 Right)
 {
-    mat4 Result = MultiplyMat4(Left, Right);
+    hmm_mat4 Result = HMM_MultiplyMat4(Left, Right);
 
     return (Result);
 }
 
-HMMDEF HINLINE vec2
-Divide(vec2 Left, vec2 Right)
+HINLINE hmm_vec2
+Divide(hmm_vec2 Left, hmm_vec2 Right)
 {
-    vec2 Result = DivideVec2(Left, Right);
+    hmm_vec2 Result = HMM_DivideVec2(Left, Right);
 
     return (Result);
 }
 
-HMMDEF HINLINE vec3
-Divide(vec3 Left, vec3 Right)
+HINLINE hmm_vec3
+Divide(hmm_vec3 Left, hmm_vec3 Right)
 {
-    vec3 Result = DivideVec3(Left, Right);
+    hmm_vec3 Result = HMM_DivideVec3(Left, Right);
 
     return (Result);
 }
 
-HMMDEF HINLINE vec4
-Divide(vec4 Left, vec4 Right)
+HINLINE hmm_vec4
+Divide(hmm_vec4 Left, hmm_vec4 Right)
 {
-    vec4 Result = DivideVec4(Left, Right);
+    hmm_vec4 Result = HMM_DivideVec4(Left, Right);
 
     return (Result);
 }
 
-HMMDEF HINLINE vec2
-operator+(vec2 Left, vec2 Right)
+HINLINE hmm_vec2
+operator+(hmm_vec2 Left, hmm_vec2 Right)
 {
-    vec2 Result = Add(Left, Right);
+    hmm_vec2 Result = Add(Left, Right);
 
     return (Result);
 }
 
-HMMDEF HINLINE vec3
-operator+(vec3 Left, vec3 Right)
+HINLINE hmm_vec3
+operator+(hmm_vec3 Left, hmm_vec3 Right)
 {
-    vec3 Result = Add(Left, Right);
+    hmm_vec3 Result = Add(Left, Right);
 
     return (Result);
 }
 
-HMMDEF HINLINE vec4
-operator+(vec4 Left, vec4 Right)
+HINLINE hmm_vec4
+operator+(hmm_vec4 Left, hmm_vec4 Right)
 {
-    vec4 Result = Add(Left, Right);
+    hmm_vec4 Result = Add(Left, Right);
 
     return (Result);
 }
 
-HMMDEF HINLINE vec2
-operator-(vec2 Left, vec2 Right)
+HINLINE hmm_vec2
+operator-(hmm_vec2 Left, hmm_vec2 Right)
 {
-    vec2 Result = Subtract(Left, Right);
+    hmm_vec2 Result = Subtract(Left, Right);
 
     return (Result);
 }
 
-HMMDEF HINLINE vec3
-operator-(vec3 Left, vec3 Right)
+HINLINE hmm_vec3
+operator-(hmm_vec3 Left, hmm_vec3 Right)
 {
-    vec3 Result = Subtract(Left, Right);
+    hmm_vec3 Result = Subtract(Left, Right);
 
     return (Result);
 }
 
-HMMDEF HINLINE vec4
-operator-(vec4 Left, vec4 Right)
+HINLINE hmm_vec4
+operator-(hmm_vec4 Left, hmm_vec4 Right)
 {
-    vec4 Result = Subtract(Left, Right);
+    hmm_vec4 Result = Subtract(Left, Right);
 
     return (Result);
 }
 
-HMMDEF HINLINE vec2 operator*(vec2 Left, vec2 Right)
+HINLINE hmm_vec2
+operator*(hmm_vec2 Left, hmm_vec2 Right)
 {
-    vec2 Result = Multiply(Left, Right);
+    hmm_vec2 Result = Multiply(Left, Right);
 
     return (Result);
 }
 
-HMMDEF HINLINE vec3 operator*(vec3 Left, vec3 Right)
+HINLINE hmm_vec3
+operator*(hmm_vec3 Left, hmm_vec3 Right)
 {
-    vec3 Result = Multiply(Left, Right);
+    hmm_vec3 Result = Multiply(Left, Right);
 
     return (Result);
 }
 
-HMMDEF HINLINE vec3 operator*(vec3 Left, float Right)
+HINLINE hmm_vec3
+operator*(hmm_vec3 Left, float Right)
 {
-    vec3 Result;
+    hmm_vec3 Result;
 
     Result.X = Right * Left.X;
     Result.Y = Right * Left.Y;
@@ -988,9 +991,10 @@ HMMDEF HINLINE vec3 operator*(vec3 Left, float Right)
     return (Result);
 }
 
-HMMDEF vec2 operator*(vec2 Left, float Right)
+HINLINE hmm_vec2
+operator*(hmm_vec2 Left, float Right)
 {
-    vec2 Result;
+    hmm_vec2 Result;
 
     Result.X = Right * Left.X;
     Result.Y = Right * Left.Y;
@@ -998,40 +1002,42 @@ HMMDEF vec2 operator*(vec2 Left, float Right)
     return (Result);
 }
 
-HMMDEF HINLINE vec4 operator*(vec4 Left, vec4 Right)
+HINLINE hmm_vec4
+operator*(hmm_vec4 Left, hmm_vec4 Right)
 {
-    vec4 Result = Multiply(Left, Right);
+    hmm_vec4 Result = Multiply(Left, Right);
 
     return (Result);
 }
 
-HMMDEF HINLINE mat4 operator*(mat4 Left, mat4 Right)
+HINLINE hmm_mat4
+operator*(hmm_mat4 Left, hmm_mat4 Right)
 {
-    mat4 Result = Multiply(Left, Right);
+    hmm_mat4 Result = Multiply(Left, Right);
 
     return (Result);
 }
 
-HMMDEF HINLINE vec2
-operator/(vec2 Left, vec2 Right)
+HINLINE hmm_vec2
+operator/(hmm_vec2 Left, hmm_vec2 Right)
 {
-    vec2 Result = Divide(Left, Right);
+    hmm_vec2 Result = Divide(Left, Right);
 
     return (Result);
 }
 
-HMMDEF HINLINE vec3
-operator/(vec3 Left, vec3 Right)
+HINLINE hmm_vec3
+operator/(hmm_vec3 Left, hmm_vec3 Right)
 {
-    vec3 Result = Divide(Left, Right);
+    hmm_vec3 Result = Divide(Left, Right);
 
     return (Result);
 }
 
-HMMDEF HINLINE vec4
-operator/(vec4 Left, vec4 Right)
+HINLINE hmm_vec4
+operator/(hmm_vec4 Left, hmm_vec4 Right)
 {
-    vec4 Result = Divide(Left, Right);
+    hmm_vec4 Result = Divide(Left, Right);
 
     return (Result);
 }
diff --git a/main.c b/main.c
index 368e57e..0c3ee2a 100644
--- a/main.c
+++ b/main.c
@@ -4,8 +4,15 @@
 int
 main(void)
 {
-    v2 VecOne = Vec2(1.0f, 1.0f);
-    v2 VecTwo = Vec2(3.0f, 3.0f);
+    hmm_mat4 MatrixOne = HMM_Mat4d(1.0f);
+    hmm_mat4 MatrixTwo = HMM_Mat4d(4.0f);
 
-    v2 Result = AddVec2(VecOne, VecTwo);
+    hmm_mat4 MatrixResult = HMM_MultiplyMat4(MatrixOne, MatrixTwo);
+    
+    hmm_v2 VecOne = HMM_Vec2(1.0f, 1.0f);
+    hmm_v2 VecTwo = HMM_Vec2(3.0f, 3.0f);
+
+    hmm_v2 Result = HMM_AddVec2(VecOne, VecTwo);
+
+    return(0);
 }
diff --git a/main.cpp b/main.cpp
new file mode 100644
index 0000000..1ca20cd
--- /dev/null
+++ b/main.cpp
@@ -0,0 +1,26 @@
+#define HANDMADE_MATH_IMPLEMENTATION
+#define HANDMADE_MATH_CPP_MODE
+#include "HandmadeMath.h"
+
+int
+main(void)
+{
+    hmm_mat4 MatrixOne = HMM_Mat4d(1.0f);
+    hmm_mat4 MatrixTwo = HMM_Mat4d(4.0f);
+
+    hmm_mat4 ResultMatrix = MatrixOne * MatrixTwo;
+
+    hmm_mat4 OrthographicMatrix = HMM_Orthographic(-1.0f, 1.0f, -1.0f, 1.0f, 0.0f, 1.0f);
+    hmm_mat4 PrespectiveMatrix = HMM_Perspective(45.0f, 16/9, 0.0f, 100.0f);
+
+    hmm_mat4 TranslationMatrix = HMM_Translate(HMM_Vec3(1.0f, 0.0f, 0.0f));
+    hmm_mat4 RotationMatrix = HMM_Rotate(45.0f, HMM_Vec3(1, 0, 0));
+
+    hmm_mat4 LookAtMatrix = HMM_LookAt(HMM_Vec3(0, 1, 0), HMM_Vec3(0, 0, 0), HMM_Vec3(1, 0, 0));
+
+    hmm_mat4 ScaleMatrix = HMM_Scale(HMM_Vec3(1.0f, 0.0f, 0.0f));
+
+    float SquareRootResult = HMM_SquareRoot(36);
+    
+    return(0);
+}