Damn I didn't even know this language could do that, I guess an issue

with namespacing fixed itself

modules/Base.core

@@ -74,10 +74,10 @@ Utf32ToUtf16 :: (codepoint: U32): [2]U16, S64
 StringToString16 :: (arena: *Arena, in: String): String16
   in_str := &in[0]
   // @Note(Krzosa): Should be more then enough space
-  alloc_size := (Length(in)*2)+1
+  alloc_size := (Len(in)*2)+1
   result := String16{str = PushSize(arena, alloc_size->U64)}
-  for i := 0, i < Length(in)
-    s32, s32_len := Utf8ToUtf32(in_str + i, Length(in) - i)
+  for i := 0, i < Len(in)
+    s32, s32_len := Utf8ToUtf32(in_str + i, Len(in) - i)
     if s32_len != 0
       i += s32_len
       s16, s16_len := Utf32ToUtf16(s32)

modules/Math.core

@@ -4,45 +4,6 @@ sinf  :: #foreign (value: F32): F32
 
 Vec2I  :: struct;; x: S64; y: S64
 Vec2   :: struct;; x: F32; y: F32
-Vec3   :: struct;; x: F32; y: F32; z: F32
-
-Vec3_Cross :: (a: Vec3, b: Vec3): Vec3
-  result := Vec3{
-    a.y * b.z - a.z * b.y,
-    a.z * b.x - a.x * b.z,
-    a.x * b.y - a.y * b.x,
-  }
-  return result
-
-Vec3_Normalize :: (a: Vec3): Vec3
-  length := Vec3_Length(a)
-  result := a / length
-  return result
-
-Vec3_Reflect :: (a: Vec3, normal: Vec3): Vec3
-  an := Vec3_Dot(a, normal)*2
-  result := a - a * an
-  return result
-
-Vec3_ConvertToARGB :: (a: Vec3): U32
-  a.x = F32_Clamp(0, a.x, 1)
-  a.y = F32_Clamp(0, a.y, 1)
-  a.z = F32_Clamp(0, a.z, 1)
-  r := (a.x * 255)->U32 << 16
-  g := (a.y * 255)->U32 << 8
-  b := (a.z * 255)->U32 << 0
-  result := r | g | b
-  return result
-
-Vec3_Length :: (a: Vec3): F32            ;; return sqrtf(a.x*a.x + a.y*a.y + a.z*a.z)
-Vec3_Negate :: (a: Vec3): Vec3           ;; return Vec3{-a.x, -a.y, -a.z}
-Vec3_Dot    :: (a: Vec3, b: Vec3): F32   ;; return a.x*b.x + a.y*b.y + a.z*b.z
-"*" :: (a: Vec3, b: Vec3): Vec3 ;; return Vec3{a.x*b.x, a.y*b.y, a.z*b.z}
-"*" :: (a: Vec3, b: F32) : Vec3 ;; return Vec3{a.x*b, a.y*b, a.z*b}
-"+" :: (a: Vec3, b: Vec3): Vec3 ;; return Vec3{a.x+b.x, a.y+b.y, a.z+b.z}
-"/" :: (a: Vec3, b: Vec3): Vec3 ;; return Vec3{a.x/b.x, a.y/b.y, a.z/b.z}
-"/" :: (a: Vec3, b: F32): Vec3 ;; return Vec3{a.x/b, a.y/b, a.z/b}
-"-" :: (a: Vec3, b: Vec3): Vec3 ;; return Vec3{a.x-b.x, a.y-b.y, a.z-b.z}
 
 F32_Clamp :: (min: F32, value: F32, max: F32): F32
   if value > max;; return max

modules/MathVec3.core

@@ -0,0 +1,41 @@
+#import "Math.core"
+
+Vec3 :: struct;; x: F32; y: F32; z: F32
+
+Cross :: (a: Vec3, b: Vec3): Vec3
+  result := Vec3{
+    a.y * b.z - a.z * b.y,
+    a.z * b.x - a.x * b.z,
+    a.x * b.y - a.y * b.x,
+  }
+  return result
+
+Normalize :: (a: Vec3): Vec3
+  length := Length(a)
+  result := a / length
+  return result
+
+Reflect :: (a: Vec3, normal: Vec3): Vec3
+  an := Dot(a, normal)*2
+  result := a - a * an
+  return result
+
+ConvertToARGB :: (a: Vec3): U32
+  a.x = F32_Clamp(0, a.x, 1)
+  a.y = F32_Clamp(0, a.y, 1)
+  a.z = F32_Clamp(0, a.z, 1)
+  r := (a.x * 255)->U32 << 16
+  g := (a.y * 255)->U32 << 8
+  b := (a.z * 255)->U32 << 0
+  result := r | g | b
+  return result
+
+Length :: (a: Vec3): F32          ;; return sqrtf(a.x*a.x + a.y*a.y + a.z*a.z)
+Negate :: (a: Vec3): Vec3         ;; return Vec3{-a.x, -a.y, -a.z}
+Dot    :: (a: Vec3, b: Vec3): F32 ;; return a.x*b.x + a.y*b.y + a.z*b.z
+"*" :: (a: Vec3, b: Vec3): Vec3   ;; return Vec3{a.x*b.x, a.y*b.y, a.z*b.z}
+"*" :: (a: Vec3, b: F32) : Vec3   ;; return Vec3{a.x*b, a.y*b, a.z*b}
+"+" :: (a: Vec3, b: Vec3): Vec3   ;; return Vec3{a.x+b.x, a.y+b.y, a.z+b.z}
+"/" :: (a: Vec3, b: Vec3): Vec3   ;; return Vec3{a.x/b.x, a.y/b.y, a.z/b.z}
+"/" :: (a: Vec3, b: F32): Vec3    ;; return Vec3{a.x/b, a.y/b, a.z/b}
+"-" :: (a: Vec3, b: Vec3): Vec3   ;; return Vec3{a.x-b.x, a.y-b.y, a.z-b.z}

modules/Windows.core

@@ -101,9 +101,9 @@ Print :: (string: String, args: ..)
   buffer_len: S64
 
   arg_counter := 0
-  for i := 0, i < Length(string), i+=1
+  for i := 0, i < Len(string), i+=1
     if string[i] == '%'
-      Assert(arg_counter < Length(args), "Passing too many [%] to a print lambda")
+      Assert(arg_counter < Len(args), "Passing too many [%] to a print lambda")
       arg := args[arg_counter++]
 
       if arg.type == S64