diff --git a/future_features.txt b/future_features.txt
index 88b0a92..0a26ad2 100644
--- a/future_features.txt
+++ b/future_features.txt
@@ -1,5 +1,12 @@
-Declaration of a pointer and multiplication are ambigious!
-( T* a; maybe either a declaration or a multiplication)
+correctly importing / running tests is a nightmare with relative paths.
+
+Namespaces
+Imports allow renaming of either entire scope or individual members, and can import from within a scope
+
+correct c genration for triple mutually recursive types across 2 files (wehre
+A depends on B depends on C, but two of them are in the same file and there's
+also pointers for the other two) Will need splitting into multiple C files to
+be cleanest, I think)
 
 Fix destructors being placed after return.
 Fix functions before declaration? (in class? (this is from an old file))
diff --git a/include/.ASTData.h.swp b/include/.ASTData.h.swp
deleted file mode 100644
index ea4dd95..0000000
Binary files a/include/.ASTData.h.swp and /dev/null differ
diff --git a/include/CGenerator.h b/include/CGenerator.h
index a0472fb..13103e4 100644
--- a/include/CGenerator.h
+++ b/include/CGenerator.h
@@ -4,6 +4,8 @@
 #include <string>
 #include <iostream>
 #include <fstream>
+#include <utility>
+#include <sys/stat.h>
 
 #include "NodeTree.h"
 #include "ASTData.h"
@@ -12,6 +14,7 @@
 #include "util.h"
 #include "Poset.h"
 
+// Note the use of std::pair to hold two strings - the running string for the header file and the running string for  the c file.
 
 class CGenerator {
 	public:
@@ -19,12 +22,16 @@ class CGenerator {
 		~CGenerator();
 		void generateCompSet(std::map<std::string, NodeTree<ASTData>*> ASTs, std::string outputName);
         std::string generateClassStruct(NodeTree<ASTData>* from);
+        bool isUnderTranslationUnit(NodeTree<ASTData>* from, NodeTree<ASTData>* typeDefinition);
+        NodeTree<ASTData>* highestScope(NodeTree<ASTData>* node);
+        std::pair<std::string, std::string> generateTranslationUnit(NodeTree<ASTData>* from);
 		std::string generate(NodeTree<ASTData>* from, NodeTree<ASTData>* enclosingObject = NULL);
         std::string generateAliasChains(NodeTree<ASTData>* scopeNode, NodeTree<ASTData>* definition);
 		static std::string ValueTypeToCType(Type *type);
 		static std::string ValueTypeToCTypeDecoration(Type *type);
+        static std::string ValueTypeToCTypeThingHelper(Type *type, std::string ptrStr);
 		static std::string CifyName(std::string name);
-		std::string generateObjectMethod(NodeTree<ASTData>* enclosingObject, NodeTree<ASTData>* from, std::string *functionPrototype);
+        std::string generateObjectMethod(NodeTree<ASTData>* enclosingObject, NodeTree<ASTData>* from, std::string *functionPrototype);
         NodeTree<ASTData>* getMethodsObjectType(NodeTree<ASTData>* scope, std::string functionName);
 		std::string generatorString;
 	private:
diff --git a/include/Tester.h b/include/Tester.h
index 7bf1815..6aa6be2 100644
--- a/include/Tester.h
+++ b/include/Tester.h
@@ -15,7 +15,7 @@ class Tester {
 		int ssystem(std::string command);
 		bool run(std::string fileName);
 		bool compareFiles(std::string file1Path, std::string file2Path);
-		void cleanExtras(std::string fileName);
+		void cleanExtras(std::string path);
 
 	private:
 		std::string krakenInvocation;
@@ -27,5 +27,7 @@ class Tester {
 		std::string shell;
 		std::string changePermissions;
 		std::string redirect;
+		std::string sep;
+		std::string cd;
 };
 #endif
diff --git a/src/.ASTTransformation.cpp.swp b/src/.ASTTransformation.cpp.swp
deleted file mode 100644
index 12f0889..0000000
Binary files a/src/.ASTTransformation.cpp.swp and /dev/null differ
diff --git a/src/CGenerator.cpp b/src/CGenerator.cpp
index 6234d7a..b2969bc 100644
--- a/src/CGenerator.cpp
+++ b/src/CGenerator.cpp
@@ -7,24 +7,35 @@ CGenerator::~CGenerator() {
 
 }
 
+// Note the use of std::pair to hold two strings - the running string for the header file and the running string for  the c file.
 void CGenerator::generateCompSet(std::map<std::string, NodeTree<ASTData>*> ASTs, std::string outputName) {
 	//Generate an entire set of files
 	std::string buildString = "#!/bin/sh\ncc -std=c99 ";
+	std::cout << "\n\n =====GENERATE PASS===== \n\n" << std::endl;
+    if (mkdir(("./" + outputName).c_str(), 0755)) {
+        std::cout << "Could not make directory " << outputName << std::endl;
+        //throw "could not make directory ";
+    }
 	for (auto i = ASTs.begin(); i != ASTs.end(); i++) {
+		std::cout << "\n\nGenerate pass for: " << i->first << std::endl;
 		buildString += i->first + ".c ";
-		std::ofstream outputCFile;
-		outputCFile.open(i->first + ".c");
-		if (outputCFile.is_open()) {
+		std::ofstream outputCFile, outputHFile;
+		outputCFile.open(outputName + "/" + i->first + ".c");
+		outputHFile.open(outputName + "/" + i->first + ".h");
+		if (outputCFile.is_open() || outputHFile.is_open()) {
             // Prequel common to all files
-			outputCFile << "#include <stdbool.h>\n#include <stdlib.h>\n#include <stdio.h>\n" << generate(i->second);
+            auto chPair = generateTranslationUnit(i->second);
+			outputHFile << "#include <stdbool.h>\n#include <stdlib.h>\n#include <stdio.h>\n" << chPair.first;
+			outputCFile << "#include \"" + i->first + ".h\"\n\n" << chPair.second;
 		} else {
-			std::cout << "Cannot open file " << i->first << ".c" << std::endl;
+			std::cout << "Cannot open file " << i->first << ".c/h" << std::endl;
 		}
 		outputCFile.close();
+		outputHFile.close();
 	}
 	buildString += "-o " + outputName;
 	std::ofstream outputBuild;
-	outputBuild.open(outputName + ".sh");
+	outputBuild.open(outputName + "/" + split(outputName, '/').back() + ".sh");
 	outputBuild << buildString;
 	outputBuild.close();
 }
@@ -70,6 +81,164 @@ std::string CGenerator::generateAliasChains(NodeTree<ASTData>* scopeNode, NodeTr
     return output;
 }
 
+bool CGenerator::isUnderTranslationUnit(NodeTree<ASTData>* from, NodeTree<ASTData>* node) {
+    auto scope = from->getDataRef()->scope;
+    for (auto i : scope)
+        for (auto j : i.second)
+            if (j == node)
+                return true;
+
+    auto upper = scope.find("~enclosing_scope");
+    if (upper != scope.end())
+        return isUnderTranslationUnit(upper->second[0], node);
+    return false;
+}
+
+NodeTree<ASTData>* CGenerator::highestScope(NodeTree<ASTData>* node) {
+    auto it = node->getDataRef()->scope.find("~enclosing_scope");
+    while (it != node->getDataRef()->scope.end()) {
+        node = it->second[0];
+        it = node->getDataRef()->scope.find("~enclosing_scope");
+    }
+    return node;
+}
+
+// We do translation units in their own function so they can do the pariwise h/c stuff and regualr in function body generation does not
+std::pair<std::string, std::string> CGenerator::generateTranslationUnit(NodeTree<ASTData>* from) {
+	ASTData data = from->getData();
+	std::vector<NodeTree<ASTData>*> children = from->getChildren();
+    std::string cOutput, hOutput;
+    // Ok, so we've got to do this in passes to preserve mututally recursive definitions.
+    //
+    // First Pass: All classes get "struct dummy_thing; typedef struct dummy_thing thing;".
+    //                  Also, other typedefs follow after their naming.
+    // Second Pass: All top level variable declarations
+    // Third Pass: Define all actual structs of a class, in correct order (done with posets)
+    // Fourth Pass: Declare all function prototypes (as functions may be mutually recursive too).
+    //                  (this includes object methods)
+    // Fifth Pass: Define all functions (including object methods).
+
+    // However, most of these do not actually have to be done as separate passes. First, second, fourth, and fifth
+    // are done simultanously, but append to different strings that are then concatinated properly, in order.
+
+    std::string importIncludes = "/**\n * Import Includes\n */\n\n";
+    std::string variableExternDeclarations = "/**\n * Extern Variable Declarations \n */\n\n";
+    std::string plainTypedefs = "/**\n * Plain Typedefs\n */\n\n";
+    std::string variableDeclarations = "/**\n * Variable Declarations \n */\n\n";
+    std::string classStructs = "/**\n * Class Structs\n */\n\n";
+    std::string functionPrototypes = "/**\n * Function Prototypes\n */\n\n";
+    std::string functionDefinitions = "/**\n * Function Definitions\n */\n\n";
+
+    // Ok, let's handle the included files
+    for (auto i : from->getChildren())
+        if (i->getDataRef()->type == import)
+            importIncludes += "#include \"" + i->getDataRef()->symbol.getName() + ".krak.h\" //woo importing!\n";
+
+    // And get the correct order for emiting classes, but not if they're not in our file, then they will get included
+    // Note that this is not sufsticated enough for some multiple file mutually recursive types, but I want to get this simple version working first
+    Poset<NodeTree<ASTData>*> typedefPoset;
+    for (int i = 0; i < children.size(); i++) {
+        if (children[i]->getDataRef()->type == type_def) {
+            // If we're an alias type, continue. We handle those differently
+            if (children[i]->getDataRef()->valueType->typeDefinition != children[i])
+                continue;
+
+            typedefPoset.addVertex(children[i]); // We add this definition by itself just in case there are no dependencies.
+            // If it has dependencies, there's no harm in adding it here
+            // Go through every child in the class looking for declaration statements. For each of these that is not a primitive type
+            // we will add a dependency from this definition to that definition in the poset.
+            std::vector<NodeTree<ASTData>*> classChildren = children[i]->getChildren();
+            for (auto j : classChildren) {
+                if (j->getDataRef()->type == declaration_statement) {
+                    Type* decType = j->getChildren()[0]->getDataRef()->valueType;           // Type of the declaration
+                    if (decType->typeDefinition && decType->getIndirection() == 0 && isUnderTranslationUnit(from, decType->typeDefinition))	        // If this is a custom type and not a pointer and actually should be defined in this file
+                        typedefPoset.addRelationship(children[i], decType->typeDefinition); // Add a dependency
+                }
+            }
+        }
+    }
+    //Now generate the typedef's in the correct, topological order
+    for (NodeTree<ASTData>* i : typedefPoset.getTopoSort())
+        classStructs += generateClassStruct(i) + "\n";
+
+    // Declare everything in translation unit scope here. (allows stuff from other files, automatic forward declarations)
+    // Also, everything in all of the import's scopes
+    std::map<std::string, std::vector<NodeTree<ASTData>*>> combinedMap;
+    combinedMap = from->getDataRef()->scope; // Actually, just do this file. We're moving back to using include files
+    for (auto i = combinedMap.begin(); i != combinedMap.end(); i++) {
+        for (auto declaration : i->second) {
+            std::vector<NodeTree<ASTData>*> decChildren = declaration->getChildren();
+            ASTData declarationData = declaration->getData();
+            switch(declarationData.type) {
+                case identifier:
+                    variableDeclarations += ValueTypeToCType(declarationData.valueType) + " " + declarationData.symbol.getName() + "; /*identifier*/\n";
+                    variableExternDeclarations += "extern " + ValueTypeToCType(declarationData.valueType) + " " + declarationData.symbol.getName() + "; /*extern identifier*/\n";
+                    break;
+                case function:
+                    {
+                        if (declarationData.valueType->baseType == template_type)
+                            functionPrototypes += "/* template function " + declarationData.symbol.toString() + " */\n";
+                        else if (decChildren.size() == 0) //Not a real function, must be a built in passthrough
+                            functionPrototypes += "/* built in function: " + declarationData.symbol.toString() + " */\n";
+                        else {
+                            functionPrototypes += "\n" + ValueTypeToCType(declarationData.valueType) + " ";
+                            std::string nameDecoration, parameters;
+                            for (int j = 0; j < decChildren.size()-1; j++) {
+                                if (j > 0)
+                                    parameters += ", ";
+                                parameters += ValueTypeToCType(decChildren[j]->getData().valueType) + " " + generate(decChildren[j], nullptr);
+                                nameDecoration += "_" + ValueTypeToCTypeDecoration(decChildren[j]->getData().valueType);
+                            }
+                            functionPrototypes += CifyName(declarationData.symbol.getName() + nameDecoration) + "(" + parameters + "); /*func*/\n";
+                            // Only generate function if this is the unit it was defined in
+                            std::cout << "Generating " << CifyName(declarationData.symbol.getName()) << std::endl;
+                            if (contains(children, declaration))
+                                functionDefinitions += generate(declaration, nullptr);
+                        }
+                    }
+                    break;
+                case type_def:
+                    //type
+                    plainTypedefs += "/*typedef " + declarationData.symbol.getName() + " */\n";
+
+                    if (declarationData.valueType->baseType == template_type) {
+                        plainTypedefs += "/* non instantiated template " + declarationData.symbol.getName() + " */";
+                    } else if (declarationData.valueType->typeDefinition != declaration) {
+                        if (declarationData.valueType->typeDefinition)
+                            continue; // Aliases of objects are done with the thing it alises
+                        // Otherwise, we're actually a renaming of a primitive, can generate here
+                        plainTypedefs += "typedef " + ValueTypeToCType(declarationData.valueType) + " " + CifyName(declarationData.symbol.getName()) + ";\n";
+                        plainTypedefs += generateAliasChains(from, declaration);
+                    } else {
+                        plainTypedefs += "typedef struct __struct_dummy_" + CifyName(declarationData.symbol.getName()) + "__ " + CifyName(declarationData.symbol.getName())  + ";\n";
+                        functionPrototypes += "/* Method Prototypes for " + declarationData.symbol.getName() + " */\n";
+                        // We use a seperate string for this because we only include it if this is the file we're defined in
+                        std::string objectFunctionDefinitions = "/* Method Definitions for " + declarationData.symbol.getName() + " */\n";
+                        for (int j = 0; j < decChildren.size(); j++) {
+                            std::cout << decChildren[j]->getName() << std::endl;
+                            if (decChildren[j]->getName() == "function") //If object method
+                                objectFunctionDefinitions += generateObjectMethod(declaration, decChildren[j], &functionPrototypes) + "\n";
+                        }
+                        // Add all aliases to the plain typedefs. This will add any alias that aliases to this object, and any alias that aliases to that, and so on
+                        plainTypedefs += generateAliasChains(from, declaration);
+                        functionPrototypes += "/* Done with " + declarationData.symbol.getName() + " */\n";
+                        // If this is the file the object is defined in, include methods
+                        if (contains(children, declaration))
+                            functionDefinitions += objectFunctionDefinitions + "/* Done with " + declarationData.symbol.getName() + " */\n";
+                    }
+                    break;
+                default:
+                    //std::cout << "Declaration? named " << declaration->getName() << " of unknown type " << ASTData::ASTTypeToString(declarationData.type) << " in translation unit scope" << std::endl;
+                    cOutput += "/*unknown declaration named " + declaration->getName() + "*/\n";
+                    hOutput += "/*unknown declaration named " + declaration->getName() + "*/\n";
+            }
+        }
+    }
+    hOutput += plainTypedefs + importIncludes + variableExternDeclarations + classStructs + functionPrototypes;
+    cOutput += variableDeclarations + functionDefinitions;
+    return std::make_pair(hOutput, cOutput);
+}
+
 //The enclosing object is for when we're generating the inside of object methods. They allow us to check scope lookups against the object we're in
 std::string CGenerator::generate(NodeTree<ASTData>* from, NodeTree<ASTData>* enclosingObject) {
 	ASTData data = from->getData();
@@ -78,127 +247,17 @@ std::string CGenerator::generate(NodeTree<ASTData>* from, NodeTree<ASTData>* enc
 	switch (data.type) {
 		case translation_unit:
 		{
-            // Ok, so we've got to do this in passes to preserve mututally recursive definitions.
-            //
-            // First Pass: All classes get "struct dummy_thing; typedef struct dummy_thing thing;".
-            //                  Also, other typedefs follow after their naming.
-            // Second Pass: All top level variable declarations
-            // Third Pass: Define all actual structs of a class, in correct order (done with posets)
-            // Fourth Pass: Declare all function prototypes (as functions may be mutually recursive too).
-            //                  (this includes object methods)
-            // Fifth Pass: Define all functions (including object methods).
-
-            // However, most of these do not actually have to be done as separate passes. First, second, fourth, and fifth
-            // are done simultanously, but append to different strings that are then concatinated properly, in order.
-
-            std::string plainTypedefs = "/**\n * Plain Typedefs\n */\n\n";
-            std::string variableDeclarations = "/**\n * Variable Declarations \n */\n\n";
-            std::string classStructs = "/**\n * Class Structs\n */\n\n";
-            std::string functionPrototypes = "/**\n * Function Prototypes\n */\n\n";
-            std::string functionDefinitions = "/**\n * Function Definitions\n */\n\n";
-
-			Poset<NodeTree<ASTData>*> typedefPoset;
-			for (int i = 0; i < children.size(); i++) {
-				if (children[i]->getDataRef()->type == type_def) {
-                    // If we're an alias type, continue. We handle those differently
-                    if (children[i]->getDataRef()->valueType->typeDefinition != children[i])
-                        continue;
-
-					typedefPoset.addVertex(children[i]); // We add this definition by itself just in case there are no dependencies.
-													     // If it has dependencies, there's no harm in adding it here
-					// Go through every child in the class looking for declaration statements. For each of these that is not a primitive type
-					// we will add a dependency from this definition to that definition in the poset.
-					std::vector<NodeTree<ASTData>*> classChildren = children[i]->getChildren();
-					for (auto j : classChildren) {
-						if (j->getDataRef()->type == declaration_statement) {
-							Type* decType = j->getChildren()[0]->getDataRef()->valueType;           // Type of the declaration
-							if (decType->typeDefinition && decType->getIndirection() == 0)	        // If this is a custom type and not a pointer
-								typedefPoset.addRelationship(children[i], decType->typeDefinition); // Add a dependency
-						}
-					}
-                }
-			}
-			//Now generate the typedef's in the correct, topological order
-			for (NodeTree<ASTData>* i : typedefPoset.getTopoSort())
-				classStructs += generateClassStruct(i) + "\n";
-
-			//Declare everything in translation unit scope here. (allows stuff from other files, automatic forward declarations)
-			for (auto i = data.scope.begin(); i != data.scope.end(); i++) {
-				for (auto declaration : i->second) {
-					std::vector<NodeTree<ASTData>*> decChildren = declaration->getChildren();
-					ASTData declarationData = declaration->getData();
-					switch(declarationData.type) {
-						case identifier:
-							variableDeclarations += ValueTypeToCType(declarationData.valueType) + " " + declarationData.symbol.getName() + "; /*identifier*/\n";
-							break;
-						case function:
-						{
-							if (declarationData.valueType->baseType == template_type)
-								functionPrototypes += "/* template function " + declarationData.symbol.toString() + " */\n";
-							else if (decChildren.size() == 0) //Not a real function, must be a built in passthrough
-								functionPrototypes += "/* built in function: " + declarationData.symbol.toString() + " */\n";
-							else {
-								functionPrototypes += "\n" + ValueTypeToCType(declarationData.valueType) + " ";
-								std::string nameDecoration, parameters;
-								for (int j = 0; j < decChildren.size()-1; j++) {
-									if (j > 0)
-										parameters += ", ";
-									parameters += ValueTypeToCType(decChildren[j]->getData().valueType) + " " + generate(decChildren[j], enclosingObject);
-									nameDecoration += "_" + ValueTypeToCTypeDecoration(decChildren[j]->getData().valueType);
-								}
-								functionPrototypes += CifyName(declarationData.symbol.getName() + nameDecoration) + "(" + parameters + "); /*func*/\n";
-                                // Only generate function if this is the unit it was defined in
-                                std::cout << "Generating " << CifyName(declarationData.symbol.getName()) << std::endl;
-                                if (contains(children, declaration))
-                                    functionDefinitions += generate(declaration, enclosingObject);
-							}
-						}
-							break;
-                        case type_def:
-                            //type
-                            plainTypedefs += "/*typedef " + declarationData.symbol.getName() + " */\n";
-
-                            if (declarationData.valueType->baseType == template_type) {
-                                plainTypedefs += "/* non instantiated template " + declarationData.symbol.getName() + " */";
-                            } else if (declarationData.valueType->typeDefinition != declaration) {
-                                if (declarationData.valueType->typeDefinition)
-                                    continue; // Aliases of objects are done with the thing it alises
-                                // Otherwise, we're actually a renaming of a primitive, can generate here
-                                plainTypedefs += "typedef " + ValueTypeToCType(declarationData.valueType) + " " + CifyName(declarationData.symbol.getName()) + ";\n";
-                                plainTypedefs += generateAliasChains(from, declaration);
-                            } else {
-                                plainTypedefs += "typedef struct __struct_dummy_" + CifyName(declarationData.symbol.getName()) + "__ " + CifyName(declarationData.symbol.getName())  + ";\n";
-                                functionPrototypes += "/* Method Prototypes for " + declarationData.symbol.getName() + " */\n";
-                                // We use a seperate string for this because we only include it if this is the file we're defined in
-                                std::string objectFunctionDefinitions = "/* Method Definitions for " + declarationData.symbol.getName() + " */\n";
-                                for (int j = 0; j < decChildren.size(); j++) {
-                                    std::cout << decChildren[j]->getName() << std::endl;
-                                    if (decChildren[j]->getName() == "function") //If object method
-                                        objectFunctionDefinitions += generateObjectMethod(declaration, decChildren[j], &functionPrototypes) + "\n";
-                                }
-                                // Add all aliases to the plain typedefs. This will add any alias that aliases to this object, and any alias that aliases to that, and so on
-                                plainTypedefs += generateAliasChains(from, declaration);
-                                functionPrototypes += "/* Done with " + declarationData.symbol.getName() + " */\n";
-                                // If this is the file the object is defined in, include methods
-                                if (contains(children, declaration))
-                                    functionDefinitions += objectFunctionDefinitions + "/* Done with " + declarationData.symbol.getName() + " */\n";
-                            }
-                                break;
-						default:
-							//std::cout << "Declaration? named " << declaration->getName() << " of unknown type " << ASTData::ASTTypeToString(declarationData.type) << " in translation unit scope" << std::endl;
-							output += "/*unknown declaration named " + declaration->getName() + "*/\n";
-					}
-				}
-			}
-            output += plainTypedefs + variableDeclarations + classStructs + functionPrototypes + functionDefinitions;
-			return output;
+            // Should not happen! We do this in it's own function now!
+            std::cout << "Trying to normal generate a translation unit! That's a nono! (" << from->getDataRef()->toString() << ")" << std::endl;
+            throw "That's not gonna work";
 		}
 			break;
 		case interpreter_directive:
 			//Do nothing
 			break;
 		case import:
-			return "/* would import \"" + data.symbol.getName() + "\" but....*/\n";
+            return "/* never reached import? */\n";
+			//return "include \"" + data.symbol.getName() + ".h\" //woo importing!\n";
 			//return "#include <" + data.symbol.getName() + ">\n";
 		case identifier:
 		{
@@ -421,7 +480,9 @@ std::string CGenerator::generateObjectMethod(NodeTree<ASTData>* enclosingObject,
     return functionSignature + "\n" +  generate(children[children.size()-1], enclosingObject); //Pass in the object so we can properly handle access to member stuff
 }
 
-std::string CGenerator::ValueTypeToCType(Type *type) {
+std::string CGenerator::ValueTypeToCType(Type *type) { return ValueTypeToCTypeThingHelper(type, "*"); }
+std::string CGenerator::ValueTypeToCTypeDecoration(Type *type) { return ValueTypeToCTypeThingHelper(type, "_P__"); }
+std::string CGenerator::ValueTypeToCTypeThingHelper(Type *type, std::string ptrStr) {
 	std::string return_type;
 	switch (type->baseType) {
 		case none:
@@ -453,43 +514,7 @@ std::string CGenerator::ValueTypeToCType(Type *type) {
 			break;
 	}
 	for (int i = 0; i < type->getIndirection(); i++)
-		return_type += "*";
-	return return_type;
-}
-
-std::string CGenerator::ValueTypeToCTypeDecoration(Type *type) {
-	std::string return_type;
-	switch (type->baseType) {
-		case none:
-			if (type->typeDefinition)
-				return_type = CifyName(type->typeDefinition->getDataRef()->symbol.getName());
-			else
-				return_type = "none";
-			break;
-		case void_type:
-			return_type = "void";
-			break;
-		case boolean:
-			return_type = "bool";
-			break;
-		case integer:
-			return_type = "int";
-			break;
-		case floating:
-			return_type = "float";
-			break;
-		case double_percision:
-			return_type = "double";
-			break;
-		case character:
-			return_type = "char";
-			break;
-		default:
-			return_type = "unknown_ValueType";
-			break;
-	}
-	for (int i = 0; i < type->getIndirection(); i++)
-		return_type += "_P__";
+		return_type += ptrStr;
 	return return_type;
 }
 
@@ -510,6 +535,7 @@ std::string CGenerator::CifyName(std::string name) {
 											"--", "doubleminus",
 											"<<", "doubleleft",
 											">>", "doubleright",
+											"::", "scopeop",
 											"==", "doubleequals",
 											"!=", "notequals",
 											"&&", "doubleamprsnd",
diff --git a/src/Tester.cpp b/src/Tester.cpp
index 3f4cbdf..99642fc 100644
--- a/src/Tester.cpp
+++ b/src/Tester.cpp
@@ -2,13 +2,15 @@
 
 Tester::Tester(std::string krakenInvocation, std::string krakenGrammerLocation) : krakenInvocation(krakenInvocation), krakenGrammerLocation(krakenGrammerLocation) {
 	//initlization list
-	removeCmd = "rm";
+	removeCmd = "rm -r";
 	resultsExtention = ".results";
 	expectedExtention = ".expected_results";
 	krakenExtention = ".krak";
 	changePermissions = "chmod 755";
 	shell = "sh";
+    cd = "cd";
 	redirect = ">";
+	sep = "/";
 }
 
 Tester::~Tester() {
@@ -21,27 +23,24 @@ int Tester::ssystem(std::string command) {
 
 void Tester::cleanExtras(std::string fileName) {
 	ssystem(removeCmd + " " + fileName);
-	ssystem(removeCmd + " " + fileName + krakenExtention + "out*");
-	ssystem(removeCmd + " " + fileName + krakenExtention + ".c");
-	ssystem(removeCmd + " " + fileName + ".sh");
-	ssystem(removeCmd + " " + fileName + resultsExtention);
 }
 
-bool Tester::run(std::string fileName) {
+bool Tester::run(std::string path) {
+    std::string fileName = split(path, *sep.c_str()).back();
 	std::cout << "Testing: " << fileName << " with " << krakenInvocation << " and " << krakenGrammerLocation << std::endl;
-	
-	cleanExtras(fileName);
-	
-	ssystem(changePermissions + " " + fileName);
-	ssystem(krakenInvocation + " " + fileName + krakenExtention + " " + krakenGrammerLocation + " " + fileName);
-	ssystem(shell + " " + fileName + ".sh");
-	ssystem(fileName + " " + redirect + " " + fileName + resultsExtention);
 
-	bool result = compareFiles(fileName + expectedExtention, fileName + resultsExtention);
-	
+	cleanExtras(path);
+	ssystem(krakenInvocation + " " + path + krakenExtention + " " + krakenGrammerLocation + " " + path);
+	ssystem(changePermissions + " " + path + sep + fileName + ".sh");
+	ssystem(cd + " " + path + "; " + "./" + fileName + ".sh");
+	ssystem(changePermissions + " " + path + sep + fileName);
+	ssystem(path + sep + fileName + " " + redirect + " " + path + sep + fileName + resultsExtention);
+
+	bool result = compareFiles(fileName + expectedExtention, path + sep + fileName + resultsExtention);
+
 	//If the test was succesful, we don't need all the extra files
 	if (result)
-		cleanExtras(fileName);
+		cleanExtras(path);
 
 	return result;
 }
diff --git a/stdlib/trivial_container.krak b/stdlib/trivial_container.krak
index 80bebeb..4b70141 100644
--- a/stdlib/trivial_container.krak
+++ b/stdlib/trivial_container.krak
@@ -3,7 +3,7 @@ import io;
 typedef template <T> trivialContainer {
 	|T| data;
 	|void| print() {
-		print(data);
+        io::print(data);
 	}
 };
 
diff --git a/tests/OperatorOverloadTest.krak b/tests/OperatorOverloadTest.krak
index bcc1d78..4218ba2 100644
--- a/tests/OperatorOverloadTest.krak
+++ b/tests/OperatorOverloadTest.krak
@@ -1,4 +1,4 @@
-import io;
+import io:*;
 
 typedef Vec2 {
 	|int| x;
diff --git a/tests/RecursiveTest.krak b/tests/RecursiveTest.krak
index 03c8b9f..87deed8 100644
--- a/tests/RecursiveTest.krak
+++ b/tests/RecursiveTest.krak
@@ -1,4 +1,4 @@
-import io;
+import io:*;
 
 |int| fibanacci(|int| num) {
 	if (num < 2)
diff --git a/tests/commentFirstTest.krak b/tests/commentFirstTest.krak
index 0cd8f27..4030ec5 100644
--- a/tests/commentFirstTest.krak
+++ b/tests/commentFirstTest.krak
@@ -1,5 +1,5 @@
 /* Comment first! */
-import io;
+import io:*;
 
 |int| main() {
     println(1337);
diff --git a/tests/declarationsTest.krak b/tests/declarationsTest.krak
index 4e29cc4..84e8ee3 100644
--- a/tests/declarationsTest.krak
+++ b/tests/declarationsTest.krak
@@ -1,5 +1,5 @@
-import io;
-import mem;
+import io:*;
+import mem:*;
 
 typedef ClassWithConstructor {
     |int| data;
diff --git a/tests/destructorTest.krak b/tests/destructorTest.krak
index a63276f..65223f1 100644
--- a/tests/destructorTest.krak
+++ b/tests/destructorTest.krak
@@ -1,4 +1,4 @@
-import io;
+import io:*;
 
 typedef DestructorPrint {
     |char*| myStr;
diff --git a/tests/emptyBracesFunction.krak b/tests/emptyBracesFunction.krak
index d02cbd7..1413c75 100644
--- a/tests/emptyBracesFunction.krak
+++ b/tests/emptyBracesFunction.krak
@@ -4,6 +4,6 @@ import io;
 
 |int| main() {
     nothing();
-    println("It was nothing");
+    io::println("It was nothing");
     return 0;
 }
diff --git a/tests/functionMultipleTemplateTest.krak b/tests/functionMultipleTemplateTest.krak
index a30f9d5..e6ff2dc 100644
--- a/tests/functionMultipleTemplateTest.krak
+++ b/tests/functionMultipleTemplateTest.krak
@@ -1,4 +1,4 @@
-import io;
+import io:*;
 
 template <T,J> |void| addAndPrint(|T| a, |J| b) {
 	print(a+b);
diff --git a/tests/functionOrderingTest.krak b/tests/functionOrderingTest.krak
index c26f5a9..9c89e95 100644
--- a/tests/functionOrderingTest.krak
+++ b/tests/functionOrderingTest.krak
@@ -1,4 +1,4 @@
-import io;
+import io:*;
 
 |int| ret1() {
 	return ret2() / 2;
diff --git a/tests/functionTemplateTest.krak b/tests/functionTemplateTest.krak
index e6b2597..e104d20 100644
--- a/tests/functionTemplateTest.krak
+++ b/tests/functionTemplateTest.krak
@@ -1,13 +1,13 @@
 import io;
 
 template <T> |T| addAndPrint(|T| a, |T| b) {
-	print(a+b);
+    io::print(a+b);
 	return a+b;
 }
 
 |int| main() {
 	addAndPrint<int>(10,12);
-	print("\n");
+    io::print("\n");
 
 	return 0;
 }
diff --git a/tests/memTest.krak b/tests/memTest.krak
index 6ddbac9..b9a2c41 100644
--- a/tests/memTest.krak
+++ b/tests/memTest.krak
@@ -1,5 +1,5 @@
-import mem;
-import io;
+import mem:*;
+import io:*;
 
 typedef AnObject {
 	|int| a;
diff --git a/tests/moreComplexObjectTest.krak b/tests/moreComplexObjectTest.krak
index 2c06e6b..59fe0df 100644
--- a/tests/moreComplexObjectTest.krak
+++ b/tests/moreComplexObjectTest.krak
@@ -1,4 +1,4 @@
-import io;
+import io:*;
 
 typedef firstObject {
 	|int| objectNum;
diff --git a/tests/moreObjectTemplateTest.krak b/tests/moreObjectTemplateTest.krak
index 6c7ae78..e4be5b2 100644
--- a/tests/moreObjectTemplateTest.krak
+++ b/tests/moreObjectTemplateTest.krak
@@ -1,5 +1,5 @@
-import io;
-import trivial_container;
+import io:*;
+import trivial_container:*;
 
 typedef RegularObject {
 	|int| num;
diff --git a/tests/newScoping.expected_results b/tests/newScoping.expected_results
index 1e96910..2d170cc 100644
--- a/tests/newScoping.expected_results
+++ b/tests/newScoping.expected_results
@@ -1,12 +1,12 @@
 Qualified io!
-7
+0
 9
 11
 Qualified Container!
 Even template functions qualified!
 
 Unqualified io!
-8
+0
 10
 12
 Unqualified Container!
diff --git a/tests/objectOrderingTest.krak b/tests/objectOrderingTest.krak
index 4812bb8..7fb978f 100644
--- a/tests/objectOrderingTest.krak
+++ b/tests/objectOrderingTest.krak
@@ -1,4 +1,4 @@
-import io;
+import io:*;
 
 typedef objectA {
 	|int| a;
diff --git a/tests/runTests.sh b/tests/runTests.sh
index f86e0bf..26182d2 100755
--- a/tests/runTests.sh
+++ b/tests/runTests.sh
@@ -1,7 +1,8 @@
 #!/bin/bash
 
 krakenPath="../build/kraken"
-testDir=${1:-"../tests"}
+#testDir=${1:-"../tests"}
+testDir="."
 ext=${2:-"krak"}
 
 fileList=""
diff --git a/tests/scopeUnqualified.krak b/tests/scopeUnqualified.krak
index 8e0035b..f540dbf 100644
--- a/tests/scopeUnqualified.krak
+++ b/tests/scopeUnqualified.krak
@@ -3,7 +3,7 @@
 
 typedef unqualified_class {
     |int| number;
-    |qualified_class*| construct(|int| num) {
+    |unqualified_class*| construct(|int| num) {
         number = num;
         return this;
     }
diff --git a/tests/simpleFunctionTest.krak b/tests/simpleFunctionTest.krak
index 2e45927..146e497 100644
--- a/tests/simpleFunctionTest.krak
+++ b/tests/simpleFunctionTest.krak
@@ -1,4 +1,4 @@
-import io;
+import io:*;
 
 |int| addAndPrintInt(|int| a, |int| b) {
 	print(a+b);
diff --git a/tests/simpleObjectMultipleTemplateTest.krak b/tests/simpleObjectMultipleTemplateTest.krak
index f3615e4..c67136f 100644
--- a/tests/simpleObjectMultipleTemplateTest.krak
+++ b/tests/simpleObjectMultipleTemplateTest.krak
@@ -5,12 +5,12 @@ typedef template <T,J> TemplateTest {
 	|T| a;
 	|J| b;
 	|void| print() {
-		print("a: ");
-		print(a);
-		print("\n");
-		print("b: ");
-		print(b);
-		print("\n");
+        io::print("a: ");
+        io::print(a);
+        io::print("\n");
+        io::print("b: ");
+        io::print(b);
+        io::print("\n");
 	}
 };
 
diff --git a/tests/simpleObjectTemplateTest.krak b/tests/simpleObjectTemplateTest.krak
index 7aeebc2..396e6ff 100644
--- a/tests/simpleObjectTemplateTest.krak
+++ b/tests/simpleObjectTemplateTest.krak
@@ -5,12 +5,12 @@ typedef template <T> TemplateTest {
 	|int| a;
 	|T| b;
 	|void| print() {
-		print("a: ");
-		print(a);
-		print("\n");
-		print("b: ");
-		print(b);
-		print("\n");
+        io::print("a: ");
+        io::print(a);
+        io::print("\n");
+        io::print("b: ");
+        io::print(b);
+        io::print("\n");
 	}
 };
 
diff --git a/tests/simpleObjectTest.krak b/tests/simpleObjectTest.krak
index 3e8f14f..a06ed8a 100644
--- a/tests/simpleObjectTest.krak
+++ b/tests/simpleObjectTest.krak
@@ -1,11 +1,10 @@
-
 import io;
 
 typedef FirstObject {
 	|int| objectNum;
 	|void| PrintSelf(|int| a) {
-		print(objectNum);
-		print(a);
+        io::print(objectNum);
+        io::print(a);
 	}
 };
 
@@ -13,6 +12,6 @@ typedef FirstObject {
 	|FirstObject| wooObject;
 	wooObject.objectNum = 5;
 	wooObject.PrintSelf(7);
-	print("\n");
+    io::print("\n");
 	return 0;
 }
diff --git a/tests/templateTest.krak b/tests/templateTest.krak
index 8843126..91b4fef 100644
--- a/tests/templateTest.krak
+++ b/tests/templateTest.krak
@@ -1,5 +1,5 @@
-import io;
-import trivial_container;
+import io:*;
+import trivial_container:*;
 
 typedef template <T> TemplateTest {
 	|int| a;
diff --git a/tests/testArrayNotation.krak b/tests/testArrayNotation.krak
index 9b04b25..02402f3 100644
--- a/tests/testArrayNotation.krak
+++ b/tests/testArrayNotation.krak
@@ -1,5 +1,5 @@
-import io;
-import mem;
+import io:*;
+import mem:*;
 
 |int| main() {
 	|int| b;
diff --git a/tests/topLevelVarInit.expected_results b/tests/topLevelVarInit.expected_results
new file mode 100644
index 0000000..d81cc07
--- /dev/null
+++ b/tests/topLevelVarInit.expected_results
@@ -0,0 +1 @@
+42
diff --git a/tests/topLevelVarInit.krak b/tests/topLevelVarInit.krak
new file mode 100644
index 0000000..9f8aa92
--- /dev/null
+++ b/tests/topLevelVarInit.krak
@@ -0,0 +1,8 @@
+import io;
+
+|int| a = 42;
+
+|int| main() {
+    io::println(a);
+    return 0;
+}
diff --git a/tests/traitsTest.krak b/tests/traitsTest.krak
index 566e5ed..b9b55b0 100644
--- a/tests/traitsTest.krak
+++ b/tests/traitsTest.krak
@@ -1,4 +1,4 @@
-import io;
+import io:*;
 
 typedef NoTraits {};
 
@@ -48,13 +48,13 @@ typedef template<T(FirstTrait, SecondTrait)> OneTwoObj {};
     |Trait2| c;
     |TwoTrait| d;
     |AlreadySpecilized| e;
-    
+
     OneTwoFunc<NoTraits>(a);
     OneTwoFunc<Trait1>(b);
     OneTwoFunc<Trait2>(c);
     OneTwoFunc<TwoTrait>(d);
 //    OneTwoFunc<AlreadySpecilized>(e);
-   
+
     println();
 
     |OneTwoObj<NoTraits>| alpha;
diff --git a/tests/typeExpr.krak b/tests/typeExpr.krak
index e7dcae2..4b2db33 100644
--- a/tests/typeExpr.krak
+++ b/tests/typeExpr.krak
@@ -7,7 +7,7 @@ typedef ClassWithConstructor {
         return this;
     }
     |void| printData() {
-        println(data);
+        io::println(data);
     }
 };
 
@@ -15,6 +15,6 @@ typedef ClassWithConstructor {
     |ClassWithConstructor| object.construct(4);
     object.printData();
     |int| a = 8;
-    println(a);
+    io::println(a);
     return 0;
 }
diff --git a/tests/vectorTest.krak b/tests/vectorTest.krak
index 579fe24..c47e3de 100644
--- a/tests/vectorTest.krak
+++ b/tests/vectorTest.krak
@@ -1,6 +1,6 @@
-import io;
-import mem;
-import vector;
+import io:*;
+import mem:*;
+import vector:*;
 
 typedef AbleToBeDestroyed (Destructable) {
     |void| destruct() {
@@ -16,9 +16,9 @@ typedef AbleToBeDestroyed (Destructable) {
     intVec.addEnd(7);
     for (|int| i = 0; i < intVec.size; i++;)
         print(intVec.at(i));
-    
+
     println();
-    
+
     |vector<AbleToBeDestroyed>*| desVec = new<vector<AbleToBeDestroyed>>()->construct();
     |AbleToBeDestroyed| testDestruct;
     desVec->addEnd(testDestruct);