diff --git a/Semantic_Analysis.jai b/Semantic_Analysis.jai
index d7fec14..1bca38c 100644
--- a/Semantic_Analysis.jai
+++ b/Semantic_Analysis.jai
@@ -13,7 +13,7 @@ VERTEX_MAIN_FUNCTION_PREFIX :: "vertex";
 PIXEL_MAIN_FUNCTION_PREFIX  :: "pixel";
 PROPERTIES_PREFIX           :: "properties";
 
-Semantic_Type :: enum {	
+Type_Kind :: enum {	
 	Invalid :: 128;
 
 	Int       :: 0;
@@ -56,7 +56,7 @@ Typenames :: string.[
 ];
 
 Type_Variable :: struct {
-	type : Semantic_Type;
+	type : Type_Kind;
 	kind : Type_Variable_Kind;
 	builtin : bool;
 
@@ -844,16 +844,16 @@ proper_type_to_string :: (variables : []Type_Variable, var : Type_Variable, allo
 }
 														 
 
-get_type_from_identifier :: (checker : *Semantic_Checker, scope : Scope_Handle, node : *AST_Node, typename : *string = null) -> Semantic_Type {
+get_type_from_identifier :: (checker : *Semantic_Checker, scope : Scope_Handle, node : *AST_Node, typename : *string = null) -> Type_Kind {
 	type_string := node.token.ident_value;
 
 	if type_string == {
-		case Typenames[Semantic_Type.Int];       return .Int;
-		case Typenames[Semantic_Type.Half];      return .Half;
-		case Typenames[Semantic_Type.Float];     return .Float; 
-		case Typenames[Semantic_Type.Double];    return .Double;		
-		case Typenames[Semantic_Type.Sampler];   return .Sampler;
-		case Typenames[Semantic_Type.Texture2D]; return .Texture2D;
+		case Typenames[Type_Kind.Int];       return .Int;
+		case Typenames[Type_Kind.Half];      return .Half;
+		case Typenames[Type_Kind.Float];     return .Float; 
+		case Typenames[Type_Kind.Double];    return .Double;		
+		case Typenames[Type_Kind.Sampler];   return .Sampler;
+		case Typenames[Type_Kind.Texture2D]; return .Texture2D;
 	}
 	
 	symbol := find_symbol(checker, type_string, scope);
@@ -910,7 +910,7 @@ declare_struct :: (checker : *Semantic_Checker, node : *AST_Node, name : string)
 	for child : node.children {
 		if child.kind == .FieldList {
 			for field : child.children {
-				type_var := create_field(checker, field);
+				type_var := check_field(checker, field);
 
 				if type_var > 0 {
 					from_handle(checker, type_var).scope = scope_handle;
@@ -1095,7 +1095,7 @@ declare_function :: (checker : *Semantic_Checker, node : *AST_Node, builtin : bo
 	return handle;
 }
 
-create_function :: (checker : *Semantic_Checker, node : *AST_Node) {
+check_function :: (checker : *Semantic_Checker, node : *AST_Node) {
 	name_to_check := get_actual_function_name(node);
 	find_result := find_symbol(checker, name_to_check, checker.current_scope);
 
@@ -1142,7 +1142,7 @@ create_function :: (checker : *Semantic_Checker, node : *AST_Node) {
 	}
 }
 
-create_variable :: (checker : *Semantic_Checker, node : *AST_Node, struct_field_parent : *AST_Node = null) -> Type_Variable_Handle {
+check_variable :: (checker : *Semantic_Checker, node : *AST_Node, struct_field_parent : *AST_Node = null) -> Type_Variable_Handle {
 	find_result := find_symbol(checker, node.name, checker.current_scope);
 	// x : int;
 	// x.d = 5;
@@ -1175,7 +1175,7 @@ create_variable :: (checker : *Semantic_Checker, node : *AST_Node, struct_field_
 					field_not_defined_on_struct(checker, child, struct_symbol);
 					return 0;
 				}
-				access := create_variable(checker, child, node);
+				access := check_variable(checker, child, node);
 				use_scope(checker, previous_scope);
 				return access;
 			}
@@ -1188,10 +1188,10 @@ create_variable :: (checker : *Semantic_Checker, node : *AST_Node, struct_field_
 }
 
 can_declare :: (checker : *Semantic_Checker, name : string) -> bool {
-	max_value := Semantic_Type.Max_Builtin;
+	max_value := Type_Kind.Max_Builtin;
 
 	for i : 0..max_value - 1 {
-		kind := cast(Semantic_Type)i;
+		kind := cast(Type_Kind)i;
 		if name == Typenames[kind] {
 			return false;
 		}
@@ -1200,7 +1200,7 @@ can_declare :: (checker : *Semantic_Checker, name : string) -> bool {
 }
 
 //@Incomplete(niels): Handle meta stuff here
-create_field :: (checker : *Semantic_Checker, node : *AST_Node) -> Type_Variable_Handle {
+check_field :: (checker : *Semantic_Checker, node : *AST_Node) -> Type_Variable_Handle {
 	variable, handle := new_type_variable(checker);
 	variable.name = node.name;
 	typename : string;
@@ -1399,15 +1399,15 @@ check_call :: (checker : *Semantic_Checker, node : *AST_Node, type_var : Type_Va
 check_node :: (checker : *Semantic_Checker, node : *AST_Node) -> Type_Variable_Handle {
 	if node.kind == {
 		case .Function; {
-			create_function(checker, node);
+			check_function(checker, node);
 			return 0;
 		}
 		case. Field; {
-			field_var := create_field(checker, node);		
+			field_var := check_field(checker, node);		
 			return field_var;
 		}
 		case .Unnamed_Field; {
-			field_var := create_field(checker, node);
+			field_var := check_field(checker, node);
 			return field_var;
 		}
 		case .Unary; {
@@ -1497,7 +1497,7 @@ check_node :: (checker : *Semantic_Checker, node : *AST_Node) -> Type_Variable_H
 			}
 		}
 		case .Variable; {
-			return create_variable(checker, node);
+			return check_variable(checker, node);
 		}
 		case .Integer; {
 			type_variable, handle := new_type_variable(checker);
@@ -1565,22 +1565,6 @@ traverse :: (checker : *Semantic_Checker) {
 	traverse(checker, checker.program_root);
 }
 
-// find :: (checker : *Semantic_Checker, root_handle : Type_Variable_Handle) -> Type_Variable_Handle {
-// 	assert(root_handle > 0);
-// 	root := from_handle(checker, root_handle);
-
-// 	// if root.uf_parent != root_handle {
-// 	// 	root.uf_parent = find(checker, root.uf_parent);
-// 	// }
-	
-// 	return root.uf_parent;
-// }
-
-Unification_Result :: enum {
-	Unification_Success;
-	Unification_Failure;
-}
-
 types_compatible :: (checker : *Semantic_Checker, lhs : Type_Variable_Handle, rhs : Type_Variable_Handle, param_matching : bool = false) -> bool {
 	lhs_var := from_handle(checker, lhs);
 	rhs_var := from_handle(checker, rhs);
@@ -1662,12 +1646,6 @@ types_compatible :: (checker : *Semantic_Checker, lhs : Type_Variable_Handle, rh
 	return false;
 }
 
-// HLSL_BUILTIN :: #run -> string {
-// 	T := #load "hlsl_builtin.jai";
-
-// 	return "";
-// };
-
 add_hlsl_builtins :: (checker : *Semantic_Checker)  {
 	source_location := #location().fully_pathed_filename;
 	path_array := split(source_location, "/");
@@ -1746,7 +1724,7 @@ check :: (result : *Compile_Result) {
 		checker.current_sampler_index = 0;
 		checker.current_texture_index = 0;
 		checker.result_file = file;
-		array_reserve(*checker.messages, 16);
+		array_reserve(*checker.messages, 32);
 
 		init_semantic_checker(*checker, file.ast_root, file.file.path);
 
@@ -1754,31 +1732,12 @@ check :: (result : *Compile_Result) {
 		add_hlsl_builtins(*checker);
 
 		type_check(*checker, file.ast_root);
-
-		// file.vertex_entry_point.node = checker.result.vertex_entry_point;
-		// file.pixel_entry_point.node  = checker.result.pixel_entry_point;
 		
 		result.had_error |= checker.had_error;
 		copy_messages(checker.messages, *result.messages);
 	}
 }
 
-// check :: (checker : *Semantic_Checker, root : *AST_Node) -> Semantic_Check_Result {
-// 	checker.current_buffer_index = 0;
-// 	checker.current_sampler_index = 0;
-// 	checker.current_texture_index = 0;
-// 	array_reserve(*checker.messages, 16);
-// 	add_hlsl_builtins(checker);
-
-// 	type_check(checker, root);
-	
-// 	return checker.result;	
-// }
-
-// check :: (checker : *Semantic_Checker) -> Semantic_Check_Result {
-// 	return check(checker, checker.program_root);
-// }
-
 // ===========================================================
 // Pretty printing
 
@@ -1805,7 +1764,6 @@ type_to_string :: (type_variable : Type_Variable) -> string {
 		case .Array;
 		return "array";
 	}
-
 	return "";
 }
 
diff --git a/module.jai b/module.jai
index 7ebaf05..f54f561 100644
--- a/module.jai
+++ b/module.jai
@@ -4,7 +4,6 @@
 #load "Semantic_Analysis.jai";
 #load "Codegen.jai";
 
-
 add_define :: (env : *Environment, key : string) {
 	for define : env.defines {
 		if define == key {