Started working on propagating a logger object instead of having to resort to Sysout

Mwahaha, Jared you will have to review this :manic_laugther:

CodeModel/src/main/java/org/openzen/zenscript/codemodel/HighLevelDefinition.java

 		}
 		
 		if (isDestructible() && destructor == null && !(this instanceof ExpansionDefinition)) {
-			System.out.println("Added destructor to " + position);
+			//System.out.println("Added destructor to " + position);
 			destructor = new DestructorMember(position, this, Modifiers.PUBLIC);
 			members.add(destructor);
 		}

CodeModel/src/main/java/org/openzen/zenscript/codemodel/SemanticModule.java

 import java.util.HashMap;
 import java.util.List;
 import java.util.Map;
+
+import org.openzen.zencode.shared.logging.*;
 import org.openzen.zenscript.codemodel.annotations.AnnotationDefinition;
 import org.openzen.zenscript.codemodel.annotations.AnnotationProcessor;
 import org.openzen.zenscript.codemodel.context.ModuleContext;
 	public final List<ExpansionDefinition> expansions;
 	public final AnnotationDefinition[] annotations;
 	public final StorageType[] storageTypes;
+	public final IZSLogger logger;
 	
 	public SemanticModule(
-			Module module,
-			SemanticModule[] dependencies,
-			FunctionParameter[] parameters,
-			State state,
-			ZSPackage rootPackage,
-			ZSPackage modulePackage,
-			PackageDefinitions definitions,
-			List<ScriptBlock> scripts,
-			GlobalTypeRegistry registry,
-			List<ExpansionDefinition> expansions,
-			AnnotationDefinition[] annotations,
-			StorageType[] storageTypes)
+	        Module module,
+            SemanticModule[] dependencies,
+            FunctionParameter[] parameters,
+            State state,
+            ZSPackage rootPackage,
+            ZSPackage modulePackage,
+            PackageDefinitions definitions,
+            List<ScriptBlock> scripts,
+            GlobalTypeRegistry registry,
+            List<ExpansionDefinition> expansions,
+            AnnotationDefinition[] annotations,
+            StorageType[] storageTypes,
+            IZSLogger logger)
 	{
 		this.name = module.name;
 		this.module = module;
 		this.expansions = expansions;
 		this.annotations = annotations;
 		this.storageTypes = storageTypes;
-	}
+        this.logger = logger;
+    }
 	
 	public boolean isValid() {
 		return state != State.INVALID;
 				registry,
 				expansions,
 				annotations,
-				storageTypes);
+				storageTypes,
+                logger);
 	}
 	
 	public ModuleContext getContext() {

CodeModel/src/main/java/org/openzen/zenscript/codemodel/partial/PartialMemberGroupExpression.java

 				// ignore this here
 			}
 		}
-		if (results.isEmpty())
-			System.out.println("!");
+		//if (results.isEmpty())
+		//	System.out.println("!");
 		return results;
 	}
 

CodeModel/src/main/java/org/openzen/zenscript/codemodel/type/DefinitionTypeID.java

 		DefinitionTypeID current = this;
 		do {
 			if (current.typeArguments != null) {
-				if (current.definition.typeParameters == null)
-					System.out.println("Type parameters but no generic parameters");
-				else
-					for (int i = 0; i < current.typeArguments.length; i++)
-						mapping.put(current.definition.typeParameters[i], current.typeArguments[i]);
-			}
+                if(current.definition.typeParameters != null) {
+                    for (int i = 0; i < current.typeArguments.length; i++)
+                        mapping.put(current.definition.typeParameters[i], current.typeArguments[i]);
+                }//else {
+                //    System.out.println("Type parameters but no generic parameters");
+                //}
+            }
 
 			current = current.outer;
 		} while (current != null && !current.definition.isStatic());

CompilerShared/src/main/java/org/openzen/zenscript/compiler/Target.java

  */
 package org.openzen.zenscript.compiler;
 
+import org.openzen.zencode.shared.logging.*;
 import org.openzen.zenscript.codemodel.SemanticModule;
 
 /**
  * @author Hoofdgebruiker
  */
 public interface Target {
-	public ZenCodeCompiler createCompiler(SemanticModule module);
+	public ZenCodeCompiler createCompiler(SemanticModule module, IZSLogger logger);
 	
 	public String getModule();
 	

Constructor/src/main/java/org/openzen/zenscript/constructor/ConstructorRegistry.java

 package org.openzen.zenscript.constructor;
 
 import org.json.JSONObject;
+import org.openzen.zencode.shared.logging.*;
 import org.openzen.zenscript.codemodel.SemanticModule;
 import org.openzen.zenscript.codemodel.definition.ZSPackage;
 import org.openzen.zenscript.codemodel.type.GlobalTypeRegistry;
 		}
 
 		@Override
-		public ZenCodeCompiler createCompiler(SemanticModule module) {
-			return new JavaSourceZenCompiler(output, module.registry);
+		public ZenCodeCompiler createCompiler(SemanticModule module, IZSLogger logger) {
+			return new JavaSourceZenCompiler(output, module.registry, logger);
 		}
 
 		@Override
 		
 		public final GlobalTypeRegistry registry;
 		private final SimpleJavaCompileSpace space;
+		private final IZSLogger logger;
 		
-		public JavaSourceZenCompiler(File output, GlobalTypeRegistry registry) {
+		public JavaSourceZenCompiler(File output, GlobalTypeRegistry registry, IZSLogger logger) {
 			this.output = output;
 			compiler = new JavaSourceCompiler(registry);
 			this.registry = registry;
 			space = new SimpleJavaCompileSpace(registry);
-		}
+            this.logger = logger;
+        }
 
 		@Override
 		public void addModule(SemanticModule module) {
-			JavaSourceModule result = compiler.compile(module, space, module.modulePackage.fullName);
+			JavaSourceModule result = compiler.compile(logger, module, space, module.modulePackage.fullName);
 			writeMappings(result);
 			
 			modules.add(result);
 		}
 
 		@Override
-		public ZenCodeCompiler createCompiler(SemanticModule module) {
-			return new JavaBytecodeJarCompiler();
+		public ZenCodeCompiler createCompiler(SemanticModule module, IZSLogger logger) {
+			return new JavaBytecodeJarCompiler(logger);
 		}
 
 		@Override
 		private final ZSPackage stdlib = new ZSPackage(root, "stdlib");
 		public final GlobalTypeRegistry registry = new GlobalTypeRegistry(stdlib);
 		
-		private final JavaCompiler compiler = new JavaCompiler();
+		private final JavaCompiler compiler;
 		private final List<JavaBytecodeModule> modules = new ArrayList<>();
 		private final SimpleJavaCompileSpace space = new SimpleJavaCompileSpace(registry);
-
-		@Override
+        private final IZSLogger logger;
+        
+        public JavaBytecodeJarCompiler(IZSLogger logger) {
+            this.logger = logger;
+            compiler = new JavaCompiler(logger);
+        }
+        
+        @Override
 		public void addModule(SemanticModule module) {
 			JavaBytecodeModule result = compiler.compile(module.modulePackage.fullName, module, space);
 			modules.add(result);
 
 		@Override
 		public void run() {
-			JavaBytecodeRunUnit unit = new JavaBytecodeRunUnit();
+			JavaBytecodeRunUnit unit = new JavaBytecodeRunUnit(logger);
 			for (JavaBytecodeModule module : modules)
 				unit.add(module);
 			//unit.add(compiler.helpers);

Constructor/src/main/java/org/openzen/zenscript/constructor/Main.java

 import org.openzen.zenscript.constructor.module.ModuleReference;
 import org.openzen.zenscript.constructor.module.SourceModuleReference;
 import org.openzen.zenscript.constructor.module.directory.DirectorySourceModule;
+import org.openzen.zenscript.constructor.module.logging.*;
 
 public class Main {
     /**
 			return;
 		}
 		
-		Consumer<CompileException> exceptionLogger = exception -> System.err.println(exception.toString());
+        ModuleLogger exceptionLogger = new EmptyModuleLogger();
 		
 		File currentDirectory = new File(arguments.directory);
 		ZSPackage root = ZSPackage.createRoot();

Constructor/src/main/java/org/openzen/zenscript/constructor/ModuleLoader.java

 import java.util.Stack;
 import java.util.function.Consumer;
 import org.openzen.zencode.shared.CompileException;
+import org.openzen.zencode.shared.logging.*;
 import org.openzen.zenscript.codemodel.SemanticModule;
 import org.openzen.zenscript.codemodel.type.GlobalTypeRegistry;
 import org.openzen.zenscript.constructor.module.ModuleReference;
+import org.openzen.zenscript.constructor.module.logging.*;
 
 /**
  *
 	private final Stack<String> compilingModulesStack = new Stack<>();
 	
 	private final GlobalTypeRegistry registry;
-	private final Consumer<CompileException> exceptionLogger;
+	private final ModuleLogger exceptionLogger;
 	
-	public ModuleLoader(GlobalTypeRegistry registry, Consumer<CompileException> exceptionLogger) {
+	public ModuleLoader(GlobalTypeRegistry registry, ModuleLogger exceptionLogger) {
 		this.registry = registry;
 		this.exceptionLogger = exceptionLogger;
 	}

Constructor/src/main/java/org/openzen/zenscript/constructor/ParsedModule.java

 import org.json.JSONObject;
 import org.json.JSONTokener;
 import org.openzen.zencode.shared.CompileException;
+import org.openzen.zencode.shared.logging.*;
 import org.openzen.zenscript.codemodel.context.CompilingPackage;
 import org.openzen.zenscript.lexer.ParseException;
 import org.openzen.zenscript.parser.BracketExpressionParser;
 	public final String packageName;
 	public final String javaPackageName;
 	public final String host;
-	private final Consumer<CompileException> exceptionLogger;
+	//private final CompileExceptionLogger exceptionLogger;
 	
-	public ParsedModule(String name, File directory, File moduleFile, Consumer<CompileException> exceptionLogger) throws IOException {
+	public ParsedModule(String name, File directory, File moduleFile, CompileExceptionLogger exceptionLogger) throws IOException {
 		this.name = name;
 		this.sourceDirectory = new File(directory, "src");
-		this.exceptionLogger = exceptionLogger;
+		//this.exceptionLogger = exceptionLogger;
 		
 		BufferedInputStream input = new BufferedInputStream(new FileInputStream(moduleFile));
 		JSONObject json = new JSONObject(new JSONTokener(input));

Constructor/src/main/java/org/openzen/zenscript/constructor/module/DirectoryModuleReference.java

 import org.openzen.zenscript.constructor.module.directory.SourceDirectoryPackage;
 import java.io.File;
 import java.io.IOException;
+import java.lang.*;
+import java.lang.String;
 import java.util.ArrayList;
 import java.util.List;
-import java.util.function.Consumer;
 import org.json.JSONArray;
 import org.json.JSONObject;
 import org.openzen.zencode.shared.CompileException;
 import org.openzen.zenscript.constructor.ModuleLoader;
 import org.openzen.zenscript.codemodel.type.TypeSymbol;
 import org.openzen.zenscript.codemodel.type.storage.StorageType;
+import org.openzen.zenscript.constructor.module.logging.*;
 import org.openzen.zenscript.lexer.ParseException;
 import org.openzen.zenscript.parser.ParsedFile;
 
 	}
 
 	@Override
-	public SemanticModule load(ModuleLoader loader, GlobalTypeRegistry registry, Consumer<CompileException> exceptionLogger) {
+	public SemanticModule load(ModuleLoader loader, GlobalTypeRegistry registry, ModuleLogger exceptionLogger) {
 		if (!directory.exists())
 			throw new ConstructorException("Error: module directory not found: " + directory);
 		

Constructor/src/main/java/org/openzen/zenscript/constructor/module/ModuleReference.java

 
 import java.util.function.Consumer;
 import org.openzen.zencode.shared.CompileException;
+import org.openzen.zencode.shared.logging.*;
 import org.openzen.zenscript.codemodel.SemanticModule;
 import org.openzen.zenscript.codemodel.type.GlobalTypeRegistry;
 import org.openzen.zenscript.constructor.ModuleLoader;
+import org.openzen.zenscript.constructor.module.logging.*;
 
 /**
  *
 public interface ModuleReference {
 	public String getName();
 	
-	public SemanticModule load(ModuleLoader loader, GlobalTypeRegistry registry, Consumer<CompileException> exceptionLogger);
+	public SemanticModule load(ModuleLoader loader, GlobalTypeRegistry registry, ModuleLogger exceptionLogger);
 	
 	public SourcePackage getRootPackage();
 }

Constructor/src/main/java/org/openzen/zenscript/constructor/module/SourceModule.java

 import java.util.Map;
 import java.util.function.Consumer;
 import org.openzen.zencode.shared.CompileException;
+import org.openzen.zencode.shared.logging.*;
 import org.openzen.zenscript.codemodel.SemanticModule;
 import org.openzen.zenscript.codemodel.type.GlobalTypeRegistry;
 import org.openzen.zenscript.codemodel.type.ISymbol;
 	
 	public SourcePackage getRootPackage();
 	
-	public SemanticModule[] loadDependencies(ModuleLoader loader, GlobalTypeRegistry registry, Consumer<CompileException> exceptionLogger);
+	public SemanticModule[] loadDependencies(ModuleLoader loader, GlobalTypeRegistry registry, CompileExceptionLogger exceptionLogger);
 	
 	public Map<String, ISymbol> getGlobals(SemanticModule module);
 }

Constructor/src/main/java/org/openzen/zenscript/constructor/module/SourceModuleReference.java

 import org.openzen.zencode.shared.CompileException;
 import org.openzen.zencode.shared.CompileExceptionCode;
 import org.openzen.zencode.shared.SourceFile;
+import org.openzen.zencode.shared.logging.*;
 import org.openzen.zenscript.codemodel.FunctionParameter;
 import org.openzen.zenscript.codemodel.Module;
 import org.openzen.zenscript.codemodel.ModuleSpace;
 import org.openzen.zenscript.constructor.ConstructorException;
 import org.openzen.zenscript.constructor.ModuleLoader;
 import org.openzen.zenscript.codemodel.type.storage.StorageType;
+import org.openzen.zenscript.constructor.module.logging.*;
 import org.openzen.zenscript.lexer.ParseException;
 import org.openzen.zenscript.parser.BracketExpressionParser;
 import org.openzen.zenscript.parser.ParsedFile;
 	}
 
 	@Override
-	public SemanticModule load(ModuleLoader loader, GlobalTypeRegistry registry, Consumer<CompileException> exceptionLogger) {
-		SemanticModule[] dependencies = module.loadDependencies(loader, registry, exceptionLogger);
+	public SemanticModule load(ModuleLoader loader, GlobalTypeRegistry registry, ModuleLogger logger) {
+		SemanticModule[] dependencies = module.loadDependencies(loader, registry, logger);
 
 		ModuleSpace space = new ModuleSpace(registry, new ArrayList<>(), StorageType.getStandard());
 		for (SemanticModule module : dependencies) {
 		Module module = new Module(getName());
 		CompilingPackage compilingPackage = new CompilingPackage(pkg, module);
 
-		ParsedFile[] parsedFiles = parse(compilingPackage, exceptionLogger);
-		SemanticModule result = ParsedFile.compileSyntaxToSemantic(dependencies, compilingPackage, parsedFiles, space, FunctionParameter.NONE, exceptionLogger);
+		ParsedFile[] parsedFiles = parse(compilingPackage, logger);
+		SemanticModule result = ParsedFile.compileSyntaxToSemantic(dependencies, compilingPackage, parsedFiles, space, FunctionParameter.NONE, logger);
 		result.globals.putAll(this.module.getGlobals(result));
 		return result;
 	}
 		return module.getRootPackage();
 	}
 	
-	public ParsedFile[] parse(CompilingPackage compilingPackage, Consumer<CompileException> exceptionLogger) {
+	public ParsedFile[] parse(CompilingPackage compilingPackage, CompileExceptionLogger exceptionLogger) {
 		// TODO: load bracket parsers from host plugins
 		List<ParsedFile> files = new ArrayList<>();
 		parse(files, compilingPackage, null, module.getRootPackage(), exceptionLogger);
 		return files.toArray(new ParsedFile[files.size()]);
 	}
 	
-	private static void parse(List<ParsedFile> files, CompilingPackage pkg, BracketExpressionParser bracketParser, SourcePackage directory, Consumer<CompileException> exceptionLogger) {
+	private static void parse(List<ParsedFile> files, CompilingPackage pkg, BracketExpressionParser bracketParser, SourcePackage directory, CompileExceptionLogger exceptionLogger) {
 		for (SourceFile file : directory.getFiles()) {
 			try {
 				files.add(ParsedFile.parse(pkg, bracketParser, file));
 			} catch (ParseException ex) {
-				exceptionLogger.accept(new CompileException(ex.position, CompileExceptionCode.PARSE_ERROR, ex.message));
+				exceptionLogger.logCompileException(new CompileException(ex.position, CompileExceptionCode.PARSE_ERROR, ex.message));
 			}
 		}
 		for (SourcePackage subpkg : directory.getSubPackages()) {

Constructor/src/main/java/org/openzen/zenscript/constructor/module/directory/DirectorySourceModule.java

 import org.json.JSONArray;
 import org.json.JSONObject;
 import org.openzen.zencode.shared.CompileException;
+import org.openzen.zencode.shared.logging.*;
 import org.openzen.zenscript.codemodel.HighLevelDefinition;
 import org.openzen.zenscript.codemodel.ModuleSpace;
 import org.openzen.zenscript.codemodel.SemanticModule;
 	}
 
 	@Override
-	public SemanticModule[] loadDependencies(ModuleLoader loader, GlobalTypeRegistry registry, Consumer<CompileException> exceptionLogger) {
+	public SemanticModule[] loadDependencies(ModuleLoader loader, GlobalTypeRegistry registry, CompileExceptionLogger exceptionLogger) {
 		List<String> dependencyNames = new ArrayList<>();
 		if (!isStdLib)
 			dependencyNames.add("stdlib");

Constructor/src/main/java/org/openzen/zenscript/constructor/module/logging/EmptyModuleLogger.java

+package org.openzen.zenscript.constructor.module.logging;
+
+import org.openzen.zencode.shared.*;
+
+public class EmptyModuleLogger implements ModuleLogger {
+    
+    @Override
+    public void logCompileException(CompileException exception) {
+        error(exception.getMessage());
+    }
+    
+    @Override
+    public void info(String message) {
+        System.out.println(message);
+    }
+    
+    @Override
+    public void debug(String message) {
+        System.out.println(message);
+    }
+    
+    @Override
+    public void warning(String message) {
+        System.out.println(message);
+    }
+    
+    @Override
+    public void error(String message) {
+        System.err.println(message);
+    }
+    
+    @Override
+    public void throwingErr(String message, Throwable throwable) {
+        System.err.println(message);
+        throwable.printStackTrace();
+    }
+    
+    @Override
+    public void throwingWarn(String message, Throwable throwable) {
+        System.out.println(message);
+        throwable.printStackTrace(System.out);
+    }
+}

Constructor/src/main/java/org/openzen/zenscript/constructor/module/logging/ModuleLogger.java

+package org.openzen.zenscript.constructor.module.logging;
+
+import org.openzen.zencode.shared.logging.*;
+import org.openzen.zenscript.parser.logger.*;
+
+public interface ModuleLogger extends CompileExceptionLogger, ParserLogger {}

IDE/src/main/java/org/openzen/zenscript/ide/host/local/LocalModule.java

 import org.openzen.zenscript.ide.host.IDEModule;
 import org.openzen.zenscript.ide.host.IDEModuleType;
 import org.openzen.zenscript.ide.host.IDEPackage;
-import org.openzen.zenscript.validator.Validator;
+import org.openzen.zenscript.ide.host.local.logging.*;
+import org.openzen.zenscript.validator.*;
+import org.openzen.zenscript.validator.logger.*;
 
 /**
  *
 	@Override
 	public void prebuild(ModuleLoader loader, Consumer<IDECodeError> errors) {
 		SemanticModule module = loader.getModule(this.module.getName());
-		Validator.validate(module, entry -> errors.accept(new IDECodeError(null, entry.position, entry.message)));
+		Validator.validate(module, new LocalValidatorLogger(errors));
 	}
 }

IDE/src/main/java/org/openzen/zenscript/ide/host/local/LocalTarget.java

 import java.util.function.Consumer;
 import live.LiveObject;
 import live.SimpleLiveObject;
+import org.openzen.zencode.shared.logging.*;
 import org.openzen.zenscript.codemodel.SemanticModule;
 import org.openzen.zenscript.codemodel.definition.ZSPackage;
 import org.openzen.zenscript.codemodel.type.GlobalTypeRegistry;
 import org.openzen.zenscript.constructor.module.directory.DirectorySourceModule;
 import org.openzen.zenscript.constructor.module.ModuleReference;
 import org.openzen.zenscript.constructor.module.SourceModuleReference;
+import org.openzen.zenscript.constructor.module.logging.*;
 import org.openzen.zenscript.ide.host.IDECodeError;
 import org.openzen.zenscript.ide.host.IDECompileState;
 import org.openzen.zenscript.ide.host.IDESourceFile;
 import org.openzen.zenscript.ide.host.IDETarget;
-import org.openzen.zenscript.ide.ui.view.output.ErrorOutputSpan;
-import org.openzen.zenscript.ide.ui.view.output.OutputLine;
+import org.openzen.zenscript.ide.host.local.logging.*;
+import org.openzen.zenscript.ide.ui.view.output.*;
+import org.openzen.zenscript.parser.logger.*;
 import org.openzen.zenscript.validator.ValidationLogEntry;
 import org.openzen.zenscript.validator.Validator;
+import org.openzen.zenscript.validator.logger.*;
 import stdlib.Strings;
 
 /**
 		ZSPackage root = ZSPackage.createRoot();
 		ZSPackage stdlibPackage = new ZSPackage(root, "stdlib");
 		GlobalTypeRegistry registry = new GlobalTypeRegistry(stdlibPackage);
-		
-		ModuleLoader moduleLoader = new ModuleLoader(registry, exception -> {
-			IDESourceFile sourceFile = new LocalSourceFile(exception.position.file);
-			state.addError(sourceFile, new IDECodeError(sourceFile, exception.position, exception.message));
-			
-			String[] lines = Strings.split(exception.getMessage(), '\n');
-			for (String line : lines) {
-				output.accept(new OutputLine(new ErrorOutputSpan(line)));
-			}
-		});
+        final LocalModuleLogger localModuleLogger = new LocalModuleLogger(state, output);
+        ModuleLoader moduleLoader = new ModuleLoader(registry, localModuleLogger);
+        
 		//moduleLoader.register("stdlib", new DirectoryModuleReference("stdlib", new File("../../StdLibs/stdlib"), true));
 		moduleLoader.register("stdlib", new SourceModuleReference(new DirectorySourceModule("stdlib", new File("../../StdLibs/stdlib"), true), true));
 		Set<String> compiledModules = new HashSet<>();
-		
-		Consumer<ValidationLogEntry> validationLogger = entry -> {
-			String[] message = Strings.split(entry.message, '\n');
-			output.accept(new OutputLine(new ErrorOutputSpan(entry.kind + " " + entry.position.toString() + ": " + message[0])));
-			for (int i = 1; i < message.length; i++)
-				output.accept(new OutputLine(new ErrorOutputSpan("    " + message[i])));
-			
-			IDESourceFile sourceFile = new LocalSourceFile(entry.position.file);
-			state.addError(sourceFile, new IDECodeError(sourceFile, entry.position, entry.message));
-		};
-		try {
+        
+        try {
 			for (Library library : project.libraries) {
 				for (ModuleReference module : library.modules)
 					moduleLoader.register(module.getName(), module);
 			}
 			
 			SemanticModule module = moduleLoader.getModule(target.getModule());
-			module = Validator.validate(module.normalize(), validationLogger);
+			module = Validator.validate(module.normalize(), localModuleLogger);
 			
 			if (compile) {
-				ZenCodeCompiler compiler = target.createCompiler(module);
+				ZenCodeCompiler compiler = target.createCompiler(module, localModuleLogger);
 				if (!module.isValid())
 					return compiler;
 
 				SemanticModule stdlib = moduleLoader.getModule("stdlib");
-				stdlib = Validator.validate(stdlib.normalize(), validationLogger);
+				stdlib = Validator.validate(stdlib.normalize(), localModuleLogger);
 				if (!stdlib.isValid())
 					return compiler;
 
 				compiler.addModule(stdlib);
 				compiledModules.add(stdlib.name);
 
-				boolean isValid = compileDependencies(moduleLoader, compiler, compiledModules, new Stack<>(), module, validationLogger);
+				boolean isValid = compileDependencies(moduleLoader, compiler, compiledModules, new Stack<>(), module, localModuleLogger);
 				if (!isValid)
 					return compiler;
 
 		}
 	}
 	
-	private boolean compileDependencies(ModuleLoader loader, ZenCodeCompiler compiler, Set<String> compiledModules, Stack<String> compilingModules, SemanticModule module, Consumer<ValidationLogEntry> logger) {
+	private boolean compileDependencies(ModuleLoader loader, ZenCodeCompiler compiler, Set<String> compiledModules, Stack<String> compilingModules, SemanticModule module, ValidatorLogger logger) {
 		for (SemanticModule dependency : module.dependencies) {
 			if (compiledModules.contains(dependency.name))
 				continue;

IDE/src/main/java/org/openzen/zenscript/ide/host/local/logging/LocalModuleLogger.java

+package org.openzen.zenscript.ide.host.local.logging;
+
+import org.openzen.zencode.shared.*;
+import org.openzen.zenscript.constructor.module.logging.*;
+import org.openzen.zenscript.ide.host.*;
+import org.openzen.zenscript.ide.host.local.*;
+import org.openzen.zenscript.ide.ui.view.output.*;
+import org.openzen.zenscript.validator.*;
+import org.openzen.zenscript.validator.logger.*;
+import stdlib.*;
+
+import java.util.function.*;
+
+public class LocalModuleLogger implements ModuleLogger, ValidatorLogger {
+    
+    private final LocalCompileState state;
+    private final Consumer<OutputLine> output;
+    
+    public LocalModuleLogger(LocalCompileState state, Consumer<OutputLine> output) {
+        this.state = state;
+        this.output = output;
+    }
+    
+    @Override
+    public void logCompileException(CompileException exception) {
+        IDESourceFile sourceFile = new LocalSourceFile(exception.position.file);
+        state.addError(sourceFile, new IDECodeError(sourceFile, exception.position, exception.message));
+        
+        String[] lines = Strings.split(exception.getMessage(), '\n');
+        for(String line : lines) {
+            output.accept(new OutputLine(new ErrorOutputSpan(line)));
+        }
+    }
+    
+    @Override
+    public void info(String message) {
+        output.accept(new OutputLine(new BasicOutputSpan(message)));
+    }
+    
+    @Override
+    public void debug(String message) {
+        output.accept(new OutputLine(new BasicOutputSpan(message)));
+    }
+    
+    @Override
+    public void warning(String message) {
+        output.accept(new OutputLine(new BasicOutputSpan(message)));
+    }
+    
+    @Override
+    public void error(String message) {
+        output.accept(new OutputLine(new ErrorOutputSpan(message)));
+    }
+    
+    @Override
+    public void throwingErr(String message, Throwable throwable) {
+        output.accept(new OutputLine(new ErrorOutputSpan(message)));
+    }
+    
+    @Override
+    public void throwingWarn(String message, Throwable throwable) {
+        output.accept(new OutputLine(new BasicOutputSpan(message)));
+    }
+    
+    @Override
+    public void logValidationError(ValidationLogEntry entry) {
+        String[] message = Strings.split(entry.message, '\n');
+        output.accept(new OutputLine(new ErrorOutputSpan(entry.kind + " " + entry.position.toString() + ": " + message[0])));
+        for(int i = 1; i < message.length; i++)
+            output.accept(new OutputLine(new ErrorOutputSpan("    " + message[i])));
+        
+        IDESourceFile sourceFile = new LocalSourceFile(entry.position.file);
+        state.addError(sourceFile, new IDECodeError(sourceFile, entry.position, entry.message));
+    }
+    
+    @Override
+    public void logValidationWarning(ValidationLogEntry warningEntry) {
+        logValidationError(warningEntry);
+    }
+}

IDE/src/main/java/org/openzen/zenscript/ide/host/local/logging/LocalValidatorLogger.java

+package org.openzen.zenscript.ide.host.local.logging;
+
+import org.openzen.zenscript.ide.host.*;
+import org.openzen.zenscript.validator.*;
+import org.openzen.zenscript.validator.logger.*;
+
+import java.util.function.*;
+
+public class LocalValidatorLogger implements ValidatorLogger {
+    
+    private final Consumer<IDECodeError> errors;
+    
+    public LocalValidatorLogger(Consumer<IDECodeError> errors) {
+        this.errors = errors;
+    }
+    
+    @Override
+    public void info(String message) {
+        throw new UnsupportedOperationException();
+    }
+    
+    @Override
+    public void debug(String message) {
+        throw new UnsupportedOperationException();
+    }
+    
+    @Override
+    public void warning(String message) {
+        throw new UnsupportedOperationException();
+    }
+    
+    @Override
+    public void error(String message) {
+        throw new UnsupportedOperationException();
+    }
+    
+    @Override
+    public void throwingErr(String message, Throwable throwable) {
+        throw new UnsupportedOperationException();
+    }
+    
+    @Override
+    public void throwingWarn(String message, Throwable throwable) {
+        throw new UnsupportedOperationException();
+    }
+    
+    @Override
+    public void logValidationError(ValidationLogEntry errorEntry) {
+        logValidationWarning(errorEntry);
+    }
+    
+    @Override
+    public void logValidationWarning(ValidationLogEntry entry) {
+        final IDECodeError ideCodeError = new IDECodeError(null, entry.position, entry.message);
+        errors.accept(ideCodeError);
+    }
+}

JavaBytecodeCompiler/src/main/java/org/openzen/zenscript/javabytecode/JavaBytecodeContext.java

 import org.objectweb.asm.Opcodes;
 import org.objectweb.asm.Type;
 import org.openzen.zencode.shared.CodePosition;
+import org.openzen.zencode.shared.logging.*;
 import org.openzen.zenscript.codemodel.definition.ZSPackage;
 import org.openzen.zenscript.codemodel.type.StoredType;
 import org.openzen.zenscript.codemodel.type.TypeID;
 	private final JavaTypeDescriptorVisitor descriptorVisitor;
 	private int lambdaCounter = 0;
 	
-	public JavaBytecodeContext(JavaBytecodeModule target, JavaCompileSpace space, ZSPackage modulePackage, String basePackage) {
-		super(space, modulePackage, basePackage);
+	public JavaBytecodeContext(JavaBytecodeModule target, JavaCompileSpace space, ZSPackage modulePackage, String basePackage, IZSLogger logger) {
+		super(space, modulePackage, basePackage, logger);
 		
 		this.target = target;
 		
 		rangeWriter.visitField(Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL, "to", getDescriptor(range.baseType), null, null).visitEnd();
 		
 		JavaMethod method = JavaMethod.getConstructor(range.cls, "(" + getDescriptor(range.baseType) + getDescriptor(range.baseType) + ")V", Opcodes.ACC_PUBLIC);
-		JavaWriter constructorWriter = new JavaWriter(CodePosition.GENERATED, rangeWriter, method, null, method.descriptor, null);
+		JavaWriter constructorWriter = new JavaWriter(logger, CodePosition.GENERATED, rangeWriter, method, null, method.descriptor, null);
 		constructorWriter.loadObject(0);
 		constructorWriter.invokeSpecial("java/lang/Object", "<init>", "()V");
 		constructorWriter.loadObject(0);

JavaBytecodeCompiler/src/main/java/org/openzen/zenscript/javabytecode/JavaBytecodeModule.java

 import java.util.HashMap;
 import java.util.List;
 import java.util.Map;
+
+import org.openzen.zencode.shared.logging.*;
 import org.openzen.zenscript.codemodel.FunctionParameter;
 import org.openzen.zenscript.codemodel.Module;
 import org.openzen.zenscript.javashared.JavaCompiledModule;
 public class JavaBytecodeModule extends JavaCompiledModule {
 	private final Map<String, byte[]> classes = new HashMap<>();
 	private final List<JavaScriptMethod> scripts = new ArrayList<>();
-	
-	public JavaBytecodeModule(Module module, FunctionParameter[] parameters) {
+    private final IZSLogger logger;
+    
+    public JavaBytecodeModule(Module module, FunctionParameter[] parameters, IZSLogger logger) {
 		super(module, parameters);
-	}
+        this.logger = logger;
+    }
 	
 	public void addClass(String name, byte[] bytecode) {
 		if (bytecode == null)
 			return;
 
 		if(name.startsWith("java")) {
-			System.err.println("Invalid name " + name);
+			logger.debug("Warning: Invalid name " + name);
 		} else {
 			classes.put(name, bytecode);
 		}

JavaBytecodeCompiler/src/main/java/org/openzen/zenscript/javabytecode/JavaBytecodeRunUnit.java

 import org.objectweb.asm.Opcodes;
 import org.objectweb.asm.Type;
 import org.openzen.zencode.shared.CodePosition;
+import org.openzen.zencode.shared.logging.*;
 import org.openzen.zenscript.codemodel.FunctionHeader;
 import org.openzen.zenscript.codemodel.FunctionParameter;
 import org.openzen.zenscript.codemodel.type.BasicTypeID;
 	private final List<JavaParameterInfo> scriptParameterInfo = new ArrayList<>();
 
 	private boolean scriptsWritten = false;
-
-	public void add(JavaBytecodeModule module) {
+	private final IZSLogger logger;
+    
+    public JavaBytecodeRunUnit(IZSLogger logger) {
+        this.logger = logger;
+    }
+    
+    public void add(JavaBytecodeModule module) {
 		scriptsWritten = false;
 
 		for (Map.Entry<String, byte[]> classEntry : module.getClasses().entrySet())
 		headerBuilder.append(")V");
 
 		JavaMethod runMethod = JavaMethod.getStatic(new JavaClass("script", "Scripts", JavaClass.Kind.CLASS), "run", headerBuilder.toString(), Opcodes.ACC_PUBLIC | Opcodes.ACC_STATIC);
-		final JavaWriter runWriter = new JavaWriter(CodePosition.GENERATED, scriptsClassWriter, runMethod, null, null, null);
+		final JavaWriter runWriter = new JavaWriter(logger, CodePosition.GENERATED, scriptsClassWriter, runMethod, null, null, null);
 		runWriter.start();
 		for (JavaScriptMethod method : scripts) {
 			for (int i = 0; i < method.parameters.length; i++) {

JavaBytecodeCompiler/src/main/java/org/openzen/zenscript/javabytecode/JavaCompiler.java

 import org.objectweb.asm.Opcodes;
 import org.openzen.zencode.shared.CodePosition;
 import org.openzen.zencode.shared.SourceFile;
+import org.openzen.zencode.shared.logging.*;
 import org.openzen.zenscript.codemodel.FunctionHeader;
 import org.openzen.zenscript.codemodel.FunctionParameter;
 import org.openzen.zenscript.codemodel.HighLevelDefinition;
  * @author Hoofdgebruiker
  */
 public class JavaCompiler {
-	private int generatedScriptBlockCounter = 0;
+    
+    private int generatedScriptBlockCounter = 0;
 	private int expansionCounter = 0;
-
-	public JavaCompiler() {}
+	private IZSLogger logger;
+    
+    public JavaCompiler(IZSLogger logger) {
+        this.logger = logger;
+    }
 	
 	public JavaBytecodeModule compile(String packageName, SemanticModule module, JavaCompileSpace space) {
 		Map<String, JavaScriptFile> scriptBlocks = new LinkedHashMap<>();
 		
-		JavaBytecodeModule target = new JavaBytecodeModule(module.module, module.parameters);
-		JavaBytecodeContext context = new JavaBytecodeContext(target, space, module.modulePackage, packageName);
+		JavaBytecodeModule target = new JavaBytecodeModule(module.module, module.parameters, logger);
+		JavaBytecodeContext context = new JavaBytecodeContext(target, space, module.modulePackage, packageName, logger);
 		context.addModule(module.module, target);
 		
 		for (HighLevelDefinition definition : module.definitions.getAll()) {
 			JavaMethod method = JavaMethod.getStatic(new JavaClass(context.getPackageName(script.pkg), className, JavaClass.Kind.CLASS), methodName, scriptDescriptor, Opcodes.ACC_PUBLIC | Opcodes.ACC_STATIC);
 			scriptFile.scriptMethods.add(new JavaScriptMethod(method, module.parameters, javaScriptParameters));
 
-			final JavaStatementVisitor statementVisitor = new JavaStatementVisitor(context, context.getJavaModule(script.module), new JavaWriter(CodePosition.UNKNOWN, visitor, method, null, null, null));
+			final JavaStatementVisitor statementVisitor = new JavaStatementVisitor(context, context.getJavaModule(script.module), new JavaWriter(logger, CodePosition.UNKNOWN, visitor, method, null, null, null));
 			statementVisitor.start();
 			for (Statement statement : script.statements) {
 				statement.accept(statementVisitor);
 
 			if (target.getClasses().containsKey(entry.getKey())) {
 				//TODO Scripts and definitions seem to create the same class. Bad!
-				System.err.println("Trying to register " + entry.getKey() + " a 2nd time");
+				logger.warning("Warning: Trying to register " + entry.getKey() + " a 2nd time");
 			}else{
 				target.addClass(entry.getKey(), entry.getValue().classWriter.toByteArray());
 			}

JavaBytecodeCompiler/src/main/java/org/openzen/zenscript/javabytecode/compiler/JavaExpressionVisitor.java

 		//Bridge method!!!
 		if (!Objects.equals(methodInfo.descriptor, descriptor)) {
 			final JavaMethod bridgeMethodInfo = new JavaMethod(methodInfo.cls, methodInfo.kind, methodInfo.name, methodInfo.compile, methodInfo.descriptor, methodInfo.modifiers | JavaModifiers.BRIDGE | JavaModifiers.SYNTHETIC, methodInfo.genericResult, methodInfo.typeParameterArguments);
-			final JavaWriter bridgeWriter = new JavaWriter(expression.position, lambdaCW, bridgeMethodInfo, null, methodInfo.descriptor, null, "java/lang/Override");
+			final JavaWriter bridgeWriter = new JavaWriter(context.logger, expression.position, lambdaCW, bridgeMethodInfo, null, methodInfo.descriptor, null, "java/lang/Override");
 			bridgeWriter.start();
 			
 			//This.name(parameters, casted)
 			
 			final JavaMethod actualMethod = new JavaMethod(methodInfo.cls, methodInfo.kind, methodInfo.name, methodInfo.compile, context.getMethodDescriptor(expression.header), methodInfo.modifiers, methodInfo.genericResult, methodInfo.typeParameterArguments);
 			//No @Override
-			functionWriter = new JavaWriter(expression.position, lambdaCW, actualMethod, null, signature, null);
+			functionWriter = new JavaWriter(context.logger, expression.position, lambdaCW, actualMethod, null, signature, null);
 		} else {
-			functionWriter = new JavaWriter(expression.position, lambdaCW, methodInfo, null, signature, null, "java/lang/Override");
+			functionWriter = new JavaWriter(context.logger, expression.position, lambdaCW, methodInfo, null, signature, null, "java/lang/Override");
 		}
 
 		javaWriter.newObject(className);
 		final String constructorDesc = calcFunctionSignature(expression.closure);
 
 
-		final JavaWriter constructorWriter = new JavaWriter(expression.position, lambdaCW, JavaMethod.getConstructor(javaWriter.method.cls, constructorDesc, Opcodes.ACC_PUBLIC), null, null, null);
+		final JavaWriter constructorWriter = new JavaWriter(context.logger, expression.position, lambdaCW, JavaMethod.getConstructor(javaWriter.method.cls, constructorDesc, Opcodes.ACC_PUBLIC), null, null, null);
 		constructorWriter.start();
 		constructorWriter.loadObject(0);
 		constructorWriter.dup();
 
 		//Constructor
 		{
-			final JavaWriter constructorWriter = new JavaWriter(expression.position, lambdaCW, JavaMethod.getConstructor(javaWriter.method.cls, constructorDesc, Opcodes.ACC_PUBLIC), null, null, null);
+			final JavaWriter constructorWriter = new JavaWriter(context.logger, expression.position, lambdaCW, JavaMethod.getConstructor(javaWriter.method.cls, constructorDesc, Opcodes.ACC_PUBLIC), null, null, null);
 			constructorWriter.start();
 			constructorWriter.loadObject(0);
 			constructorWriter.dup();
 		//The actual method
 		{
 			final JavaMethod actualMethod = new JavaMethod(tag.method.cls, tag.method.kind, tag.method.name, tag.method.compile, tag.method.descriptor, tag.method.modifiers & ~JavaModifiers.ABSTRACT, tag.method.genericResult, tag.method.typeParameterArguments);
-			final JavaWriter functionWriter = new JavaWriter(expression.position, lambdaCW, actualMethod, null, methodDescriptor, null, "java/lang/Override");
+			final JavaWriter functionWriter = new JavaWriter(context.logger, expression.position, lambdaCW, actualMethod, null, methodDescriptor, null, "java/lang/Override");
 			functionWriter.start();
 
 			//this.wrapped

JavaBytecodeCompiler/src/main/java/org/openzen/zenscript/javabytecode/compiler/definitions/JavaDefinitionVisitor.java

 
 	@Override
 	public byte[] visitEnum(EnumDefinition definition) {
-		System.out.println("Compiling enum " + definition.name + " in " + definition.position.getFilename());
+		context.logger.debug("Compiling enum " + definition.name + " in " + definition.position.getFilename());
 
 		String superTypeInternalName = definition.getSuperType() == null ? "java/lang/Object" : context.getInternalName(definition.getSuperType());
 
         }
 
 		JavaMethod valuesMethod = JavaMethod.getStatic(toClass, "values", "()[L" + toClass.internalName + ";", Opcodes.ACC_STATIC | Opcodes.ACC_PUBLIC);
-		JavaWriter valuesWriter = new JavaWriter(definition.position, writer, true, valuesMethod, definition, null, null);
+		JavaWriter valuesWriter = new JavaWriter(context.logger, definition.position, writer, true, valuesMethod, definition, null, null);
 		valuesWriter.start();
 		valuesWriter.getStaticField(toClass.internalName, "$VALUES", "[L" + toClass.internalName + ";");
 		valuesWriter.invokeVirtual(ARRAY_CLONE);
 		valuesWriter.end();
 
 		JavaMethod valueOfMethod = JavaMethod.getStatic(toClass, "valueOf", "(Ljava/lang/String;)L" + toClass.internalName + ";", Opcodes.ACC_STATIC | Opcodes.ACC_PUBLIC);
-		JavaWriter valueOfWriter = new JavaWriter(definition.position, writer, true, valueOfMethod, definition, null, null);
+		JavaWriter valueOfWriter = new JavaWriter(context.logger, definition.position, writer, true, valueOfMethod, definition, null, null);
 		valueOfWriter.start();
 		valueOfWriter.invokeStatic(CLASS_FORNAME);
 		valueOfWriter.loadObject(0);
         final String signature = context.getMethodSignature(definition.header);
 		final JavaMethod method = context.getJavaMethod(definition.caller);
 
-		final JavaWriter writer = new JavaWriter(definition.position, outerWriter, true, method, definition, signature, null);
+		final JavaWriter writer = new JavaWriter(context.logger, definition.position, outerWriter, true, method, definition, signature, null);
         final JavaStatementVisitor statementVisitor = new JavaStatementVisitor(context, context.getJavaModule(definition.module), writer);
         statementVisitor.start();
 		boolean returns = definition.caller.body.accept(statementVisitor);
 			optionInitSignatureBuilder.append(")V");
 
 			JavaMethod constructorMethod = JavaMethod.getConstructor(optionTag.variantOptionClass, optionInitDescBuilder.toString(), JavaModifiers.PUBLIC);
-			final JavaWriter initWriter = new JavaWriter(option.position, optionWriter, constructorMethod, variant, optionInitSignatureBuilder.toString(), null);
+			final JavaWriter initWriter = new JavaWriter(context.logger, option.position, optionWriter, constructorMethod, variant, optionInitSignatureBuilder.toString(), null);
 			initWriter.start();
 			initWriter.loadObject(0);
 			initWriter.dup();
 
 			//Denominator for switch-cases
 			JavaMethod denominator = JavaMethod.getVirtual(optionTag.variantOptionClass, "getDenominator", "()I", JavaModifiers.PUBLIC);
-			final JavaWriter getDenominator = new JavaWriter(option.position, optionWriter, denominator, null, null, null, "java/lang/Override");
+			final JavaWriter getDenominator = new JavaWriter(context.logger, option.position, optionWriter, denominator, null, null, null, "java/lang/Override");
 			getDenominator.start();
 			getDenominator.constant(option.ordinal);
 			getDenominator.returnInt();
 			member.accept(visitor);
 		}
 
-		final JavaWriter superInitWriter = new JavaWriter(variant.position, writer, JavaMethod.getConstructor(toClass, "()V", Opcodes.ACC_PUBLIC), variant, "()V", null);
+		final JavaWriter superInitWriter = new JavaWriter(context.logger, variant.position, writer, JavaMethod.getConstructor(toClass, "()V", Opcodes.ACC_PUBLIC), variant, "()V", null);
 		superInitWriter.start();
 		superInitWriter.loadObject(0);
 		superInitWriter.invokeSpecial("java/lang/Object", "<init>", "()V");

JavaBytecodeCompiler/src/main/java/org/openzen/zenscript/javabytecode/compiler/definitions/JavaExpansionMemberVisitor.java

 		this.context = context;
 		javaModule = context.getJavaModule(definition.module);
 
-		final JavaWriter javaWriter = new JavaWriter(definition.position, writer, new JavaMethod(context.getJavaClass(definition), JavaMethod.Kind.STATICINIT, "<clinit>", true, "()V", 0, false), definition, null, null);
+		final JavaWriter javaWriter = new JavaWriter(context.logger, definition.position, writer, new JavaMethod(context.getJavaClass(definition), JavaMethod.Kind.STATICINIT, "<clinit>", true, "()V", 0, false), definition, null, null);
 		this.clinitStatementVisitor = new JavaStatementVisitor(context, javaModule, javaWriter);
 		this.clinitStatementVisitor.start();
 		CompilerUtils.writeDefaultFieldInitializers(context, javaWriter, definition, true);
 		}
 
 
-		final JavaWriter methodWriter = new JavaWriter(member.position, writer, true, method, definition, true, methodSignature, methodDescriptor, null);
+		final JavaWriter methodWriter = new JavaWriter(context.logger, member.position, writer, true, method, definition, true, methodSignature, methodDescriptor, null);
 		methodWriter.label(methodStart);
 
 		if (!isStatic) {
 		final Label methodEnd = new Label();
 
 		final JavaMethod method = context.getJavaMethod(member);
-		final JavaWriter methodWriter = new JavaWriter(member.position, this.writer, true, method, definition, true, signature, descriptor, new String[0]);
+		final JavaWriter methodWriter = new JavaWriter(context.logger, member.position, this.writer, true, method, definition, true, signature, descriptor, new String[0]);
 
 		methodWriter.label(methodStart);
 
 		final Label methodEnd = new Label();
 
 		final JavaMethod javaMethod = context.getJavaMethod(member);
-		final JavaWriter methodWriter = new JavaWriter(member.position, writer, true, javaMethod, member.definition, true, signature, description, new String[0]);
+		final JavaWriter methodWriter = new JavaWriter(context.logger, member.position, writer, true, javaMethod, member.definition, true, signature, description, new String[0]);
 
 
 		methodWriter.label(methodStart);
 		final Label methodEnd = new Label();
 
 		final JavaMethod javaMethod = context.getJavaMethod(member);
-		final JavaWriter methodWriter = new JavaWriter(member.position, writer, true, javaMethod, member.definition, true, methodSignature, methodDescriptor, new String[0]);
+		final JavaWriter methodWriter = new JavaWriter(context.logger, member.position, writer, true, javaMethod, member.definition, true, methodSignature, methodDescriptor, new String[0]);
 
 		methodWriter.label(methodStart);
 		methodWriter.nameVariable(0, "expandedObj", methodStart, methodEnd, context.getType(this.expandedClass));

JavaBytecodeCompiler/src/main/java/org/openzen/zenscript/javabytecode/compiler/definitions/JavaMemberVisitor.java

 import org.objectweb.asm.Label;
 import org.objectweb.asm.Opcodes;
 import org.objectweb.asm.Type;
+import org.openzen.zencode.shared.logging.*;
 import org.openzen.zenscript.codemodel.FunctionParameter;
 import org.openzen.zenscript.codemodel.HighLevelDefinition;
 import org.openzen.zenscript.codemodel.Modifiers;
 		this.context = context;
 		javaModule = context.getJavaModule(definition.module);
 
-        final JavaWriter javaWriter = new JavaWriter(definition.position, writer, new JavaMethod(toClass, JavaMethod.Kind.STATICINIT, "<clinit>", true, "()V", 0, false), definition, null, null);
+        final JavaWriter javaWriter = new JavaWriter(context.logger, definition.position, writer, new JavaMethod(toClass, JavaMethod.Kind.STATICINIT, "<clinit>", true, "()V", 0, false), definition, null, null);
         this.clinitStatementVisitor = new JavaStatementVisitor(context, javaModule, javaWriter);
         this.clinitStatementVisitor.start();
         CompilerUtils.writeDefaultFieldInitializers(context, javaWriter, definition, true);
 
         final Label constructorStart = new Label();
         final Label constructorEnd = new Label();
-        final JavaWriter constructorWriter = new JavaWriter(member.position, writer, method, definition, context.getMethodSignature(member.header), null);
+        final JavaWriter constructorWriter = new JavaWriter(context.logger, member.position, writer, method, definition, context.getMethodSignature(member.header), null);
         constructorWriter.label(constructorStart);
         CompilerUtils.tagConstructorParameters(context, javaModule, member.definition, member.header, isEnum);
         if(isEnum) {
 
 		if (!member.isConstructorForwarded()) {
 			if (isEnum) {
-				System.out.println("Writing enum constructor");
+				context.logger.debug("Writing enum constructor");
 				constructorWriter.getVisitor().newLocal(Type.getType(String.class));
 				constructorWriter.getVisitor().newLocal(Type.getType(int.class));
 				constructorWriter.loadObject(0);
 				constructorWriter.loadInt(2);
 				constructorWriter.invokeSpecial(Type.getInternalName(Enum.class), "<init>", "(Ljava/lang/String;I)V");
 			} else if (definition.getSuperType() == null) {
-				System.out.println("Writing regular constructor");
+				context.logger.debug("Writing regular constructor");
 				constructorWriter.loadObject(0);
 				constructorWriter.invokeSpecial(Type.getInternalName(Object.class), "<init>", "()V");
 			}
 
 		final Label constructorStart = new Label();
 		final Label constructorEnd = new Label();
-		final JavaWriter destructorWriter = new JavaWriter(member.position, writer, method, definition, null, null);
+		final JavaWriter destructorWriter = new JavaWriter(context.logger, member.position, writer, method, definition, null, null);
 		destructorWriter.label(constructorStart);
 		
         final JavaStatementVisitor statementVisitor = new JavaStatementVisitor(context, javaModule, destructorWriter);
         final boolean isAbstract = member.body == null || Modifiers.isAbstract(member.getEffectiveModifiers());
         final JavaMethod method = context.getJavaMethod(member);
 		
-		final JavaWriter methodWriter = new JavaWriter(member.position, writer, method, definition, context.getMethodSignature(member.header), null);
+		final JavaWriter methodWriter = new JavaWriter(context.logger, member.position, writer, method, definition, context.getMethodSignature(member.header), null);
 
 		if (!isAbstract) {
 			if (method.isAbstract() || method.cls.kind == JavaClass.Kind.INTERFACE)
 		final Label methodEnd = new Label();
 
 		final JavaMethod method = context.getJavaMethod(member);
-		final JavaWriter methodWriter = new JavaWriter(member.position, this.writer, true, method, definition, false, signature, descriptor, new String[0]);
+		final JavaWriter methodWriter = new JavaWriter(context.logger, member.position, this.writer, true, method, definition, false, signature, descriptor, new String[0]);
 
 		methodWriter.label(methodStart);
 		final JavaStatementVisitor statementVisitor = new JavaStatementVisitor(context, javaModule, methodWriter);
 		final Label methodEnd = new Label();
 
 		final JavaMethod javaMethod = context.getJavaMethod(member);
-		final JavaWriter methodWriter = new JavaWriter(member.position, writer, true, javaMethod, member.definition, false, signature, description, new String[0]);
+		final JavaWriter methodWriter = new JavaWriter(context.logger, member.position, writer, true, javaMethod, member.definition, false, signature, description, new String[0]);
 		methodWriter.label(methodStart);
 
 		//in script you use $ but the parameter is named "value", which to choose?
 		final Label methodEnd = new Label();
 
 
-		final JavaWriter methodWriter = new JavaWriter(member.position, writer, true, javaMethod, member.definition, false, methodSignature, methodDescriptor, new String[0]);
+		final JavaWriter methodWriter = new JavaWriter(context.logger, member.position, writer, true, javaMethod, member.definition, false, methodSignature, methodDescriptor, new String[0]);
 
 		methodWriter.label(methodStart);
 

JavaIntegration/src/main/java/org/openzen/zencode/java/EmptyLogger.java

-package org.openzen.zencode.java;
-
-public class EmptyLogger implements IZSLogger {
-    
-    @Override
-    public void info(String message) {
-    
-    }
-    
-    @Override
-    public void debug(String message) {
-    
-    }
-    
-    @Override
-    public void warning(String message) {
-    
-    }
-    
-    @Override
-    public void error(String message) {
-    
-    }
-    
-    @Override
-    public void throwingErr(String message, Throwable throwable) {
-    
-    }
-    
-    @Override
-    public void throwingWarn(String message, Throwable throwable) {
-    
-    }
-}

JavaIntegration/src/main/java/org/openzen/zencode/java/JavaNativeLoader.java

 import java.util.*;
 import java.util.function.Consumer;
 import org.openzen.zencode.shared.CompileException;
+import org.openzen.zencode.shared.logging.*;
 import org.openzen.zenscript.codemodel.definition.ZSPackage;
 
 /**
 	private final Class<?>[] classes;
 	private final Class<?>[] globals;
 	private final Map<String, LoadingModule> modulesByName = new HashMap<>();
-	private boolean loaded = false;
+    private final IZSLogger logger;
+    private boolean loaded = false;
 	
-	public JavaNativeLoader(Class<?>[] classes, Class<?>[] globals) {
+	public JavaNativeLoader(Class<?>[] classes, Class<?>[] globals, IZSLogger logger) {
 		this.classes = classes;
 		this.globals = globals;
+		this.logger = logger;
 	}
 	
 	public LoadingModule addModule(
 		for (Class<?> cls : classes) {
 			LoadingModule module = findModuleByPackage(modulesByPackage, getPackageName(cls));
 			if (module == null) {
-				System.out.println("Warning: module not found for class " + cls.getName());
+				logger.warning("Module not found for class " + cls.getName());
 			} else {
 				module.classes.add(cls);
 			}
 		for (Class<?> cls : globals) {
 			LoadingModule module = findModuleByPackage(modulesByPackage, getPackageName(cls));
 			if (module == null) {
-				System.out.println("Warning: module not found for class " + cls.getName());
+				logger.warning("Module not found for class " + cls.getName());
 			} else {
 				module.globals.add(cls);
 			}
 		}
 		
 		module.resolved = new JavaNativeModule(
+                logger,
 				module.pkg,
 				module.name,
 				module.basePackage,

JavaIntegration/src/main/java/org/openzen/zencode/java/JavaNativeModule.java

 			final Class<?> classFromType = getClassFromType(expandedType);
 			if(classFromType == null) {
 				//TODO REMOVE
-				System.err.println("Could not get class for type " + expandedType + " attempting to do stuff anyways");
-			} else 	if(!method.getParameterTypes()[0].isAssignableFrom(classFromType))
-				throw new IllegalArgumentException("Cannot add extension method " + method + " as its first parameter does not match the extended type.");
+				logger.debug("Could not get class for type " + expandedType + " attempting to do stuff anyways");
+			} else if(!method.getParameterTypes()[0].isAssignableFrom(classFromType)) {
+                throw new IllegalArgumentException("Cannot add extension method " + method + " as its first parameter does not match the extended type.");
+            }
 
 
 			final ZenCodeType.Method methodAnnotation = method.getAnnotation(ZenCodeType.Method.class);

JavaIntegration/src/main/java/org/openzen/zencode/java/ScriptingEngine.java

  */
 package org.openzen.zencode.java;
 
+import org.openzen.zencode.java.logger.*;
 import org.openzen.zencode.shared.*;
 import org.openzen.zenscript.codemodel.*;
 import org.openzen.zenscript.codemodel.context.*;
 import java.io.*;
 import java.lang.reflect.InvocationTargetException;
 import java.util.*;
-import java.util.function.*;
 
 /**
  *
 	
 	public boolean debug = false;
 	
-	public IZSLogger logger;
+	public final ScriptingEngineLogger logger;
 	
 	public ScriptingEngine() {
-		space = new ModuleSpace(registry, new ArrayList<>(), StorageType.getStandard());
-		
-		try {
-            ZippedPackage stdlibs = new ZippedPackage(ScriptingEngine.class.getResourceAsStream("/StdLibs.jar"));
-            SemanticModule stdlibModule = stdlibs.loadModule(space, "stdlib", null, new SemanticModule[0], FunctionParameter.NONE, stdlib);
-			stdlibModule = Validator.validate(stdlibModule, error -> System.out.println(error.toString()));
-			space.addModule("stdlib", stdlibModule);
-			registerCompiled(stdlibModule);
-		} catch (CompileException | ParseException | IOException ex) {
-			throw new RuntimeException(ex);
-		}
-		this.logger = new EmptyLogger();
+        this(new ScriptingEngineStreamLogger());
     }
     
-    public ScriptingEngine(IZSLogger logger) {
-        this();
+    public ScriptingEngine(ScriptingEngineLogger logger) {
+        this.space = new ModuleSpace(registry, new ArrayList<>(), StorageType.getStandard());
         this.logger = logger;
+        try {
+            ZippedPackage stdlibs = new ZippedPackage(ScriptingEngine.class.getResourceAsStream("/StdLibs.jar"));
+            SemanticModule stdlibModule = stdlibs.loadModule(space, "stdlib", null, SemanticModule.NONE, FunctionParameter.NONE, stdlib, logger);
+            stdlibModule = Validator.validate(stdlibModule, logger);
+            space.addModule("stdlib", stdlibModule);
+            registerCompiled(stdlibModule);
+        } catch (CompileException | ParseException | IOException ex) {
+            throw new RuntimeException(ex);
+        }
     }
 	
 	public JavaNativeModule createNativeModule(String name, String basePackage, JavaNativeModule... dependencies) {
 		ZSPackage testPackage = new ZSPackage(space.rootPackage, name);
-		return new JavaNativeModule(testPackage, name, basePackage, registry, dependencies);
+		return new JavaNativeModule(logger, testPackage, name, basePackage, registry, dependencies);
 	}
 	
 	public void registerNativeProvided(JavaNativeModule module) throws CompileException {
 		SemanticModule semantic = Validator.validate(
-				module.toSemantic(space), System.out::println);
+				module.toSemantic(space), logger);
 		if (!semantic.isValid())
 			return;
 		
 			BracketExpressionParser bracketParser,
 			FunctionParameter[] scriptParameters,
 			String... dependencies) throws ParseException
-	{
-		return createScriptedModule(name, sources, bracketParser, scriptParameters, Throwable::printStackTrace, System.out::println, sourceFile -> System.out.println("Loading " + sourceFile.getFilename()), dependencies);
-	}
-	
-	public SemanticModule createScriptedModule(
-			String name,
-			SourceFile[] sources,
-			BracketExpressionParser bracketParser,
-			FunctionParameter[] scriptParameters,
-			Consumer<CompileException> compileExceptionConsumer,
-			Consumer<ValidationLogEntry> validatorErrorConsumer,
-			Consumer<SourceFile> sourceFileConsumer,
-			String... dependencies) throws ParseException
 	{
 		Module scriptModule = new Module(name);
 		CompilingPackage scriptPackage = new CompilingPackage(new ZSPackage(space.rootPackage, name), scriptModule);
 		
 		ParsedFile[] files = new ParsedFile[sources.length];
 		for (int i = 0; i < sources.length; i++) {
-			sourceFileConsumer.accept(sources[i]);
+			logger.logSourceFile(sources[i]);
 			files[i] = ParsedFile.parse(scriptPackage, bracketParser, sources[i]);
 		}
 		
 				files,
 				space,
 				scriptParameters,
-				compileExceptionConsumer);
+				logger);
 		if (!scripts.isValid())
 			return scripts;
 		
 		return Validator.validate(
 				scripts.normalize(),
-				validatorErrorConsumer);
+				logger);
 	}
 	
 	public void registerCompiled(SemanticModule module) {
         for (JavaNativeModule nativeModule : nativeModules)
             javaSpace.register(nativeModule.getCompiled());
         
-        JavaCompiler compiler = new JavaCompiler();
+        JavaCompiler compiler = new JavaCompiler(logger);
         
-        JavaBytecodeRunUnit runUnit = new JavaBytecodeRunUnit();
+        JavaBytecodeRunUnit runUnit = new JavaBytecodeRunUnit(logger);
         for (SemanticModule compiled : compiledModules)
             runUnit.add(compiler.compile(compiled.name, compiled, javaSpace));
         if (debug)

JavaIntegration/src/main/java/org/openzen/zencode/java/logger/ScriptingEngineLogger.java

+package org.openzen.zencode.java.logger;
+
+import org.openzen.zencode.shared.logging.*;
+import org.openzen.zenscript.parser.logger.*;
+import org.openzen.zenscript.validator.logger.*;
+
+public interface ScriptingEngineLogger extends ValidatorLogger, SourceFileLogger, ParserLogger {}

JavaIntegration/src/main/java/org/openzen/zencode/java/logger/ScriptingEngineStreamLogger.java

+package org.openzen.zencode.java.logger;
+
+import org.openzen.zencode.shared.*;
+import org.openzen.zenscript.validator.*;
+
+import java.io.*;
+
+public class ScriptingEngineStreamLogger implements ScriptingEngineLogger {
+    
+    private final PrintStream infoStream, debugStream, warningStream, errorStream;
+    
+    public ScriptingEngineStreamLogger(PrintStream debugStream, PrintStream infoStream, PrintStream warningStream, PrintStream errorStream) {
+        this.infoStream = infoStream;
+        this.debugStream = debugStream;
+        this.warningStream = warningStream;
+        this.errorStream = errorStream;
+    }
+    
+    public ScriptingEngineStreamLogger(PrintStream normalStream, PrintStream errorStream) {
+        this(normalStream, normalStream, normalStream, errorStream);
+    }
+    
+    public ScriptingEngineStreamLogger() {
+        this(System.out, System.err);
+    }
+    
+    @Override
+    public void info(String message) {
+        infoStream.println("INFO: " + message);
+        infoStream.flush();
+    }
+    
+    @Override
+    public void debug(String message) {
+        debugStream.println("DEBUG:   " + message);
+        debugStream.flush();
+    }
+    
+    @Override
+    public void warning(String message) {
+        warningStream.println("WARNING: " + message);
+        warningStream.flush();
+    }
+    
+    @Override
+    public void error(String message) {
+        errorStream.println("ERROR:   " + message);
+    }
+    
+    @Override
+    public void throwingErr(String message, Throwable throwable) {
+        errorStream.println("ERROR:   " + message);
+        throwable.printStackTrace(errorStream);
+        errorStream.flush();
+    }
+    
+    @Override
+    public void throwingWarn(String message, Throwable throwable) {
+        warningStream.println("WARNING: " + message);
+        throwable.printStackTrace(warningStream);
+        warningStream.flush();
+    }
+    
+    @Override
+    public void logCompileException(CompileException exception) {
+        throw new UnsupportedOperationException();
+    }
+    
+    @Override
+    public void logSourceFile(SourceFile file) {
+        info("Loading File: " + file.getFilename());
+    }
+    
+    @Override
+    public void logValidationError(ValidationLogEntry errorEntry) {
+        error(errorEntry.toString());
+    }
+    
+    @Override
+    public void logValidationWarning(ValidationLogEntry warningEntry) {
+        warning(warningEntry.toString());
+    }
+}

JavaShared/src/main/java/org/openzen/zenscript/javashared/JavaClass.java

 			return new JavaClass("", internalName, kind, new String[0]);
 		
 		int lastSlash = internalName.lastIndexOf('/');
-		if (lastSlash < 0)
-			System.out.println(internalName);
+		//if (lastSlash < 0)
+		//	System.out.println(internalName);
 		
 		String pkg = lastSlash < 0 ? "" : internalName.substring(0, lastSlash);
 		String className = lastSlash < 0 ? internalName : internalName.substring(lastSlash + 1);

JavaShared/src/main/java/org/openzen/zenscript/javashared/JavaContext.java

 import java.util.List;
 import java.util.Map;
 import org.openzen.zencode.shared.CodePosition;
+import org.openzen.zencode.shared.logging.*;
 import org.openzen.zenscript.codemodel.FunctionHeader;
 import org.openzen.zenscript.codemodel.FunctionParameter;
 import org.openzen.zenscript.codemodel.HighLevelDefinition;
 	
 	public final ZSPackage modulePackage;
 	public final String basePackage;
+	public final IZSLogger logger;
 	
-	public JavaContext(JavaCompileSpace space, ZSPackage modulePackage, String basePackage) {
+	public JavaContext(JavaCompileSpace space, ZSPackage modulePackage, String basePackage, IZSLogger logger) {
+	    this.logger = logger;
 		this.space = space;
 		this.registry = space.getRegistry();
 		

JavaShared/src/main/java/org/openzen/zenscript/javashared/prepare/JavaPrepareClassMethodVisitor.java

 	@Override
 	public Void visitConst(ConstMember member) {
 		if (DEBUG_EMPTY && cls.empty)
-			System.out.println("Class " + cls.fullName + " not empty because of const " + member.name);
+			context.logger.debug("Class " + cls.fullName + " not empty because of const " + member.name);
 		
 		cls.empty = false;
 		module.setFieldInfo(member, new JavaField(cls, member.name, context.getDescriptor(member.getType()), context.getSignature(member.getType())));
 	@Override
 	public Void visitDestructor(DestructorMember member) {
 		if (DEBUG_EMPTY && cls.empty)
-			System.out.println("Class " + cls.fullName + " not empty because of destructor");
+			context.logger.debug("Class " + cls.fullName + " not empty because of destructor");
 		
 		cls.empty = false;
 		return null;
 				m.accept(this);
 		} else {
 			if (DEBUG_EMPTY && cls.empty)
-				System.out.println("Class " + cls.fullName + " not empty because of unmergeable implementation");
+				context.logger.debug("Class " + cls.fullName + " not empty because of unmergeable implementation");
 			
 			cls.empty = false;
 			
 		member.innerDefinition.accept(innerDefinitionPrepare);
 		
 		if (DEBUG_EMPTY && cls.empty)
-			System.out.println("Class " + cls.fullName + " not empty because of inner definition " + member.innerDefinition.name);
+			context.logger.debug("Class " + cls.fullName + " not empty because of inner definition " + member.innerDefinition.name);
 		cls.empty = false;
 		return null;
 	}
 	@Override
 	public Void visitStaticInitializer(StaticInitializerMember member) {
 		if (DEBUG_EMPTY && cls.empty)
-			System.out.println("Class " + cls.fullName + " not empty because of static initializer");
+			context.logger.debug("Class " + cls.fullName + " not empty because of static initializer");
 		
 		cls.empty = false;
 		return null;
 		
 		if (method.compile && member.getBuiltin() != BuiltinID.CLASS_DEFAULT_CONSTRUCTOR) {
 			if (DEBUG_EMPTY && cls.empty)
-				System.out.println("Class " + cls.fullName + " not empty because of " + member.describe());
+				context.logger.debug("Class " + cls.fullName + " not empty because of " + member.describe());
 			
 			cls.empty = false;
 		}

JavaShared/src/main/java/org/openzen/zenscript/javashared/prepare/JavaPrepareDefinitionMemberVisitor.java

 		if (definition.module != module.module)
 			throw new IllegalArgumentException("Definition is not in the same module as the current module!");
 		
-		System.out.println("~~ Preparing " + definition.name);
+		context.logger.debug("~~ Preparing " + definition.name);
 		definition.accept(this);
 	}
 	
 	}
 	
 	private void visitClassMembers(HighLevelDefinition definition, JavaClass cls, JavaNativeClass nativeClass, boolean startsEmpty) {
-		System.out.println("Preparing " + cls.internalName);
+		context.logger.debug("Preparing " + cls.internalName);
 		JavaPrepareClassMethodVisitor methodVisitor = new JavaPrepareClassMethodVisitor(context, module, cls, nativeClass, this, startsEmpty);
 		for (IDefinitionMember member : definition.members) {
 			member.accept(methodVisitor);
 	}
 	
 	private void visitExpansionMembers(HighLevelDefinition definition, JavaClass cls, JavaNativeClass nativeClass) {
-		System.out.println("Preparing " + cls.internalName);
+		context.logger.debug("Preparing " + cls.internalName);
 		JavaPrepareExpansionMethodVisitor methodVisitor = new JavaPrepareExpansionMethodVisitor(context, module, cls, nativeClass);
 		for (IDefinitionMember member : definition.members) {
 			member.accept(methodVisitor);

JavaShared/src/main/java/org/openzen/zenscript/javashared/prepare/JavaPrepareExpansionMethodVisitor.java

 		module.setFieldInfo(member, field);
 		
 		if (DEBUG_EMPTY && cls.empty)
-			System.out.println("Class " + cls.fullName + " not empty because of const");
+			context.logger.debug("Class " + cls.fullName + " not empty because of const");
 		
 		cls.empty = false;
 		return null;
 		
 		if (method.compile) {
 			if (DEBUG_EMPTY && cls.empty)
-				System.out.println("Class " + cls.fullName + " not empty because of " + member.describe());
+				context.logger.debug("Class " + cls.fullName + " not empty because of " + member.describe());
 			
 			cls.empty = false;
 		}

JavaSourceCompiler/src/main/java/org/openzen/zenscript/javasource/JavaSourceCompiler.java

 import java.util.HashMap;
 import java.util.Map;
 import org.openzen.zencode.shared.SourceFile;
+import org.openzen.zencode.shared.logging.*;
 import org.openzen.zenscript.codemodel.FunctionParameter;
 import org.openzen.zenscript.codemodel.HighLevelDefinition;
 import org.openzen.zenscript.codemodel.Module;
 		settings = new JavaSourceFormattingSettings.Builder().build();
 	}
 	
-	public JavaSourceModule compile(SemanticModule module, JavaCompileSpace space, String basePackage) {
-		JavaSourceContext context = new JavaSourceContext(helpers, settings, space, module.modulePackage, basePackage);
+	public JavaSourceModule compile(IZSLogger logger, SemanticModule module, JavaCompileSpace space, String basePackage) {
+		JavaSourceContext context = new JavaSourceContext(logger, helpers, settings, space, module.modulePackage, basePackage);
 		
 		JavaSourceModule result = new JavaSourceModule(module.module, module.parameters);
 		context.addModule(module.module, result);

JavaSourceCompiler/src/main/java/org/openzen/zenscript/javasource/JavaSourceContext.java

  */
 package org.openzen.zenscript.javasource;
 
+import org.openzen.zencode.shared.logging.*;
 import org.openzen.zenscript.codemodel.definition.ZSPackage;
 import org.openzen.zenscript.codemodel.type.StoredType;
 import org.openzen.zenscript.codemodel.type.TypeID;
 	private final JavaSyntheticClassGenerator generator;
 	public final JavaSourceSyntheticHelperGenerator helperGenerator;
 	
-	public JavaSourceContext(JavaSourceModule helpers, JavaSourceFormattingSettings settings, JavaCompileSpace space, ZSPackage modulePackage, String basePackage) {
-		super(space, modulePackage, basePackage);
+	public JavaSourceContext(IZSLogger logger, JavaSourceModule helpers, JavaSourceFormattingSettings settings, JavaCompileSpace space, ZSPackage modulePackage, String basePackage) {
+		super(space, modulePackage, basePackage, logger);
 		
 		typeDescriptorVisitor = new JavaTypeDescriptorVisitor(this);
 		this.generator = new JavaSourceSyntheticTypeGenerator(helpers, settings, this);

Parser/src/main/java/org/openzen/zenscript/parser/FolderPackage.java

 import org.openzen.zenscript.codemodel.context.CompilingPackage;
 import org.openzen.zenscript.codemodel.definition.ZSPackage;
 import org.openzen.zenscript.lexer.ParseException;
+import org.openzen.zenscript.parser.logger.*;
 
 import java.io.BufferedReader;
 import java.io.File;
         files.add(parent);
     }
 	
-	public SemanticModule loadModule(ModuleSpace space, String name, BracketExpressionParser bracketParser, SemanticModule[] dependencies, FunctionParameter[] scriptParameters) throws ParseException {
-		return loadModule(space, name, bracketParser, dependencies, scriptParameters, new ZSPackage(space.rootPackage, name));
+	public SemanticModule loadModule(ModuleSpace space, String name, BracketExpressionParser bracketParser, SemanticModule[] dependencies, FunctionParameter[] scriptParameters, ParserLogger logger) throws ParseException {
+		return loadModule(space, name, bracketParser, dependencies, scriptParameters, new ZSPackage(space.rootPackage, name), logger);
 	}
 	
-	public SemanticModule loadModule(ModuleSpace space, String name, BracketExpressionParser bracketParser, SemanticModule[] dependencies, FunctionParameter[] scriptParameters, ZSPackage pkg) throws ParseException {
+	public SemanticModule loadModule(ModuleSpace space, String name, BracketExpressionParser bracketParser, SemanticModule[] dependencies, FunctionParameter[] scriptParameters, ZSPackage pkg, ParserLogger logger) throws ParseException {
 		List<SourceFile> sourceFiles = files.get(name);
 		if (sourceFiles == null)
 			return null; // no such module
 				scriptPackage,
 				files,
 				space,
-				scriptParameters, Throwable::printStackTrace);
+				scriptParameters,
+                logger);
 		return scripts.normalize();
 	}
 }

Parser/src/main/java/org/openzen/zenscript/parser/ParsedFile.java

 import org.openzen.zencode.shared.FileSourceFile;
 import org.openzen.zencode.shared.LiteralSourceFile;
 import org.openzen.zencode.shared.SourceFile;
+import org.openzen.zencode.shared.logging.*;
 import org.openzen.zenscript.codemodel.FunctionHeader;
 import org.openzen.zenscript.codemodel.FunctionParameter;
 import org.openzen.zenscript.codemodel.HighLevelDefinition;
 import org.openzen.zenscript.codemodel.type.ISymbol;
 import org.openzen.zenscript.lexer.ParseException;
 import org.openzen.zenscript.lexer.ZSTokenParser;
+import org.openzen.zenscript.parser.logger.*;
 import org.openzen.zenscript.parser.statements.ParsedStatement;
 
 import java.io.File;
 import java.util.HashMap;
 import java.util.List;
 import java.util.Map;
-import java.util.function.Consumer;
 
 import static org.openzen.zenscript.lexer.ZSTokenType.EOF;
 import static org.openzen.zenscript.lexer.ZSTokenType.K_IMPORT;
 			ParsedFile[] files,
 			ModuleSpace registry,
 			FunctionParameter[] parameters,
-			Consumer<CompileException> exceptionLogger) {
+			ParserLogger logger) {
 		// We are considering all these files to be in the same package, so make
 		// a single PackageDefinition instance. If these files were in multiple
 		// packages, we'd need an instance for every package.
 		}
 		
 		if (failed)
-			return new SemanticModule(pkg.module, dependencies, parameters, SemanticModule.State.INVALID, rootPackage, pkg.getPackage(), definitions, Collections.emptyList(), registry.registry, expansions, registry.getAnnotations(), registry.getStorageTypes());
+			return new SemanticModule(pkg.module, dependencies, parameters, SemanticModule.State.INVALID, rootPackage, pkg.getPackage(), definitions, Collections.emptyList(), registry.registry, expansions, registry.getAnnotations(), registry.getStorageTypes(), logger);
 		
 		// scripts will store all the script blocks encountered in the files
 		PrecompilationState precompiler = new PrecompilationState();
 			// compileCode will convert the parsed statements and expressions
 			// into semantic code. This semantic code can then be compiled
 			// to various targets.
-			file.compileCode(moduleContext, precompiler, rootPackage, pkg, expansions, scripts, globals, scriptHeader, exceptionLogger, importErrors);
+			file.compileCode(moduleContext, precompiler, rootPackage, pkg, expansions, scripts, globals, scriptHeader, logger, importErrors);
 		}
         
         for(CompileException error : importErrors.values()) {
-            exceptionLogger.accept(error);
+            logger.logCompileException(error);
         }
 		return new SemanticModule(
 				pkg.module,
 				registry.registry,
 				expansions,
 				registry.getAnnotations(),
-				registry.getStorageTypes());
+				registry.getStorageTypes(), logger);
 	}
 	
 	public static ParsedFile parse(CompilingPackage compilingPackage, BracketExpressionParser bracketParser, File file) throws ParseException {
             List<ScriptBlock> scripts,
             Map<String, ISymbol> globals,
             FunctionHeader scriptHeader,
-            Consumer<CompileException> exceptionLogger, Map<String, CompileException> importErrors) {
+            CompileExceptionLogger exceptionLogger,
+            Map<String, CompileException> importErrors) {
 		FileResolutionContext context = new FileResolutionContext(moduleContext, rootPackage, modulePackage);
 		loadImports(context, rootPackage, modulePackage, importErrors);
 		
 			try {
 				definition.compile(scope);
 			} catch (CompileException ex) {
-				exceptionLogger.accept(ex);
+				exceptionLogger.logCompileException(ex);
 			}
 		}
 		

Parser/src/main/java/org/openzen/zenscript/parser/ZippedPackage.java

 import org.openzen.zenscript.codemodel.context.CompilingPackage;
 import org.openzen.zenscript.codemodel.definition.ZSPackage;
 import org.openzen.zenscript.lexer.ParseException;
+import org.openzen.zenscript.parser.logger.*;
 
 /**
  *
 		}
 	}
 	
-	public SemanticModule loadModule(ModuleSpace space, String name, BracketExpressionParser bracketParser, SemanticModule[] dependencies, FunctionParameter[] scriptParameters) throws ParseException {
-		return loadModule(space, name, bracketParser, dependencies, scriptParameters, new ZSPackage(space.rootPackage, name));
+	public SemanticModule loadModule(ModuleSpace space, String name, BracketExpressionParser bracketParser, SemanticModule[] dependencies, FunctionParameter[] scriptParameters, ParserLogger logger) throws ParseException {
+		return loadModule(space, name, bracketParser, dependencies, scriptParameters, new ZSPackage(space.rootPackage, name), logger);
 	}
 	
-	public SemanticModule loadModule(ModuleSpace space, String name, BracketExpressionParser bracketParser, SemanticModule[] dependencies, FunctionParameter[] scriptParameters, ZSPackage pkg) throws ParseException {
+	public SemanticModule loadModule(ModuleSpace space, String name, BracketExpressionParser bracketParser, SemanticModule[] dependencies, FunctionParameter[] scriptParameters, ZSPackage pkg, ParserLogger logger) throws ParseException {
 		List<SourceFile> sourceFiles = files.get(name);
 		if (sourceFiles == null)
 			return null; // no such module
 				files,
 				space,
 				scriptParameters,
-				ex -> ex.printStackTrace());
+				logger);
 		return scripts.normalize();
 	}
 }

Parser/src/main/java/org/openzen/zenscript/parser/expression/ParsedNewExpression.java

 		try {
 			TypeMembers members = scope.getTypeMembers(type);
 			TypeMemberGroup constructors = members.getOrCreateGroup(OperatorType.CONSTRUCTOR);
-			/*for (TypeMember<FunctionalMemberRef> member : constructors.getMethodMembers()) {
-				if (member.member.getBuiltin() == BuiltinID.ARRAY_CONSTRUCTOR_PROJECTED)
-					System.out.println("X");
-			}*/
 
 			List<StoredType>[] predictedTypes = constructors.predictCallTypes(position, scope, scope.hints, arguments.arguments.size());
 			CallArguments compiledArguments = arguments.compileCall(position, scope, null, constructors);

Parser/src/main/java/org/openzen/zenscript/parser/logger/ParserLogger.java

+package org.openzen.zenscript.parser.logger;
+
+import org.openzen.zencode.shared.logging.*;
+
+public interface ParserLogger extends IZSLogger, CompileExceptionLogger {}

ScriptingExample/src/main/java/org/openzen/zenscript/scriptingexample/logging/StreamLogger.java

-package org.openzen.zenscript.scriptingexample.logging;
-
-import org.openzen.zencode.java.IZSLogger;
-
-import java.io.PrintStream;
-
-public class StreamLogger implements IZSLogger {
-    private final PrintStream infoStream, debugStream, warningStream, errorStream;
-
-    public StreamLogger(PrintStream debugStream, PrintStream infoStream, PrintStream warningStream, PrintStream errorStream) {
-        this.infoStream = infoStream;
-        this.debugStream = debugStream;
-        this.warningStream = warningStream;
-        this.errorStream = errorStream;
-    }
-
-    public StreamLogger(PrintStream normalStream, PrintStream errorStream) {
-        this(normalStream, normalStream, normalStream, errorStream);
-    }
-
-    public StreamLogger(){
-        this(System.out, System.err);
-    }
-
-    @Override
-    public void info(String message) {
-        System.out.println("INFO: " + message);
-    }
-
-    @Override
-    public void debug(String message) {
-        System.out.println("DEBUG:   " + message);
-    }
-
-    @Override
-    public void warning(String message) {
-        System.out.println("WARNING: " + message);
-    }
-
-    @Override
-    public void error(String message) {
-        System.err.println("ERROR:   " + message);
-    }
-
-    @Override
-    public void throwingErr(String message, Throwable throwable) {
-        System.err.println("ERROR:   " + message);
-        throwable.printStackTrace(System.err);
-        System.err.flush();
-    }
-
-    @Override
-    public void throwingWarn(String message, Throwable throwable) {
-        System.err.println("WARNING: " + message);
-        throwable.printStackTrace(System.out);
-        System.out.flush();
-    }
-}

Shared/src/main/java/org/openzen/zencode/shared/logging/CompileExceptionLogger.java

+package org.openzen.zencode.shared.logging;
+
+import org.openzen.zencode.shared.*;
+
+public interface CompileExceptionLogger {
+    void logCompileException(CompileException exception);
+}

JavaIntegration/src/main/java/org/openzen/zencode/java/IZSLogger.java → Shared/src/main/java/org/openzen/zencode/shared/logging/IZSLogger.java

-package org.openzen.zencode.java;
+package org.openzen.zencode.shared.logging;
 
 public interface IZSLogger {
     

Shared/src/main/java/org/openzen/zencode/shared/logging/SourceFileLogger.java

+package org.openzen.zencode.shared.logging;
+
+import org.openzen.zencode.shared.*;
+
+public interface SourceFileLogger {
+    void logSourceFile(SourceFile file);
+}

Validator/src/main/java/org/openzen/zenscript/validator/Validator.java

 import java.util.ArrayList;
 import java.util.Collections;
 import java.util.List;
-import java.util.function.Consumer;
+
 import org.openzen.zencode.shared.CodePosition;
 import org.openzen.zenscript.codemodel.AccessScope;
 import org.openzen.zenscript.codemodel.FunctionHeader;
 import org.openzen.zenscript.codemodel.statement.Statement;
 import org.openzen.zenscript.codemodel.type.GlobalTypeRegistry;
 import org.openzen.zenscript.validator.analysis.StatementScope;
+import org.openzen.zenscript.validator.logger.*;
 import org.openzen.zenscript.validator.visitors.DefinitionValidator;
 import org.openzen.zenscript.validator.visitors.StatementValidator;
 
  * @author Hoofdgebruiker
  */
 public class Validator {
-	public static SemanticModule validate(SemanticModule module, Consumer<ValidationLogEntry> logger) {
+	public static SemanticModule validate(SemanticModule module, ValidatorLogger logger) {
 		if (module.state != SemanticModule.State.NORMALIZED)
 			throw new IllegalStateException("Module is not yet normalized");
 		
 		}
 		
 		for (ValidationLogEntry entry : validator.getLog()) {
-			logger.accept(entry);
+			logger.logValidationLogEntry(entry);
 		}
 		
 		SemanticModule.State state = validator.hasErrors() ? SemanticModule.State.INVALID : SemanticModule.State.VALIDATED;
 				module.registry,
 				module.expansions,
 				module.annotations,
-				module.storageTypes);
+				module.storageTypes,
+                logger);
 	}
 	
 	private final List<ValidationLogEntry> log = new ArrayList<>();

Validator/src/main/java/org/openzen/zenscript/validator/logger/IZSValidationLogger.java

+package org.openzen.zenscript.validator.logger;
+
+import org.openzen.zenscript.validator.*;
+
+public interface IZSValidationLogger {
+    
+    default void logValidationLogEntry(ValidationLogEntry entry) {
+        switch(entry.kind) {
+            case ERROR:
+                logValidationError(entry);
+                break;
+            case WARNING:
+                logValidationWarning(entry);
+                break;
+        }
+    }
+    
+    void logValidationError(ValidationLogEntry errorEntry);
+    
+    void logValidationWarning(ValidationLogEntry warningEntry);
+}

Validator/src/main/java/org/openzen/zenscript/validator/logger/ValidatorLogger.java

+package org.openzen.zenscript.validator.logger;
+
+import org.openzen.zencode.shared.logging.*;
+
+public interface ValidatorLogger extends IZSValidationLogger, IZSLogger {}