Majorly refactored, node grid is fully implemented. About to attempt active path locking.

43 files changed, 1967 insertions, 693 deletions

diff --git a/src/jcgp/CGP.java b/src/jcgp/CGP.java
index 16d2be7..6b68fd8 100644
--- a/src/jcgp/CGP.java
+++ b/src/jcgp/CGP.java
@@ -1,153 +1,234 @@
 package jcgp;
 
 import java.util.HashMap;
+import java.util.Iterator;
+import java.util.Map;
+import java.util.Map.Entry;
 import java.util.Random;
 
 import javafx.beans.property.Property;
-import javafx.beans.property.SimpleIntegerProperty;
+import jcgp.function.Arithmetic;
+import jcgp.function.BitwiseLogic;
+import jcgp.function.BooleanLogic;
+import jcgp.function.Function;
+import jcgp.function.FunctionSet;
 import jcgp.modules.ea.EvolutionaryAlgorithm;
 import jcgp.modules.ea.StandardEA;
 import jcgp.modules.fitness.FitnessFunction;
 import jcgp.modules.fitness.TestCase;
-import jcgp.modules.fitness.TruthTableEvaluator;
-import jcgp.modules.function.Arithmetic;
-import jcgp.modules.function.BitwiseLogic;
-import jcgp.modules.function.BooleanLogic;
-import jcgp.modules.function.FunctionSet;
+import jcgp.modules.fitness.TestCaseEvaluator;
 import jcgp.modules.mutator.Mutator;
 import jcgp.modules.mutator.PointMutator;
 import jcgp.parameters.BooleanParameter;
-import jcgp.parameters.DoubleParameter;
 import jcgp.parameters.IntegerParameter;
 import jcgp.parameters.Parameter;
 import jcgp.population.Population;
 
 public class CGP {
 
-	// CGP components
+	/**
+	 * 
+	 * 
+	 * @author Eduardo Pedroni
+	 *
+	 */
+	public static class Resources {
+		private HashMap<String, Parameter> moduleParameters = new HashMap<String, Parameter>();
+		private HashMap<String, Parameter> coreParameters = new HashMap<String, Parameter>();
+		private HashMap<String, Parameter> allParameters = new HashMap<String, Parameter>();
+
+		private Random numberGenerator;
+		
+		// function sets
+		private FunctionSet[] functionSets =  new FunctionSet[] {
+				new Arithmetic(),
+				new BitwiseLogic(),
+				new BooleanLogic() };
+		private FunctionSet functionSet = functionSets[0];
+		
+		private TestCase[] testCases;
+		
+		public Resources() {
+			createCoreParameters();
+			
+			numberGenerator = new Random((int) get("seed"));
+			functionSet = functionSets[0];
+			
+			set("arity", functionSet.getMaxArity());
+		}
+		
+		public Object get(String key) {
+			return allParameters.get(key).getValue();
+		}
+		
+		public void set(String key, Object value) {
+			allParameters.get(key).setValue(value);
+		}
+		
+		public Property<?> getProperty(String key) {
+			return allParameters.get(key).valueProperty();
+		}
+		
+		public void setManagedParameter(String key, boolean value) {
+			allParameters.get(key).setManaged(value);
+		}
+		
+		public void setHiddenParameter(String key, boolean value) {
+			allParameters.get(key).setHidden(value);
+		}
+		
+		public boolean contains(String key) {
+			return allParameters.containsKey(key);
+		}
+		
+		private void createCoreParameters() {		
+			coreParameters.put("rows", new IntegerParameter(9, "Rows"));
+			coreParameters.put("columns", new IntegerParameter(10, "Columns"));
+			coreParameters.put("inputs", new IntegerParameter(3, "Inputs"));
+			coreParameters.put("outputs", new IntegerParameter(3, "Outputs"));
+			coreParameters.put("popSize", new IntegerParameter(5, "Population"));
+			coreParameters.put("levelsBack", new IntegerParameter(2, "Levels back"));
+			
+			coreParameters.put("nodes", new IntegerParameter(90, "Nodes", true, true));
+			
+			coreParameters.put("generations", new IntegerParameter(1000000, "Generations"));
+			coreParameters.put("currentGen", new IntegerParameter(0, "Generation"));
+			coreParameters.put("runs", new IntegerParameter(5, "Runs"));
+
+			coreParameters.put("arity", new IntegerParameter(0, "Max arity", true, true));
+
+			coreParameters.put("seed", new IntegerParameter(123, "Random seed", true, true));
+			
+			coreParameters.put("debug", new BooleanParameter(false, "Debug"));
+			
+			allParameters.putAll(coreParameters);
+		}
+		
+		private void resetParameters(EvolutionaryAlgorithm ea, Mutator mu, FitnessFunction ff) {
+			Iterator<Entry<String, Parameter>> it = coreParameters.entrySet().iterator();
+		    while (it.hasNext()) {
+		    	((Parameter) ((Map.Entry<String, Parameter>) it.next())).reset();
+		    }
+		    
+		    allParameters.clear();
+		    allParameters.putAll(coreParameters);
+		    addModuleParameters(ea, mu, ff);
+		}
+
+		private void addModuleParameters(EvolutionaryAlgorithm ea, Mutator mu, FitnessFunction ff) {
+			moduleParameters.clear();
+			moduleParameters.putAll(ea.activate(this));
+			moduleParameters.putAll(mu.activate(this));
+			moduleParameters.putAll(ff.activate(this));
+			
+			allParameters.putAll(moduleParameters);
+		}
+		
+		/*
+		 * Utility functions
+		 */
+		public int getRandomInt(int limit) {
+			return numberGenerator.nextInt(limit);
+		}
+		
+		public double getRandomDouble(int limit) {
+			return numberGenerator.nextDouble() * limit;
+		}
+		
+		public double getRandomDouble() {
+			return numberGenerator.nextDouble();
+		}
+		
+		/*
+		 * Function set functions
+		 */
+		public Function getRandomFunction() {
+			return functionSet.getFunction(numberGenerator.nextInt(functionSet.getFunctionCount()));
+		}
+
+		public Function getFunction(int index) {
+			return functionSet.getFunction(index);
+		}
+		
+		public void setFunctionSet(int index) {
+			functionSet = functionSets[index];
+		}
+		
+		/*
+		 * Test cases
+		 */
+		public void setTestCases(TestCase ... testCases) {
+			this.testCases = testCases;
+		}
+
+		public TestCase getTestCase(int index) {
+			return testCases[index];
+		}
+
+		public int getTestCaseCount() {
+			return testCases.length;
+		}
+	}
+	
+	private Resources resources = new Resources();
+	
+	/*
+	 * The following arrays contain all available modules. These collections are read by the GUI
+	 * when generating menus, so modules not added here will *NOT* be selectable in the GUI.
+	 * 
+	 * Each array is accompanied by a field which contains a reference to the currently selected
+	 * module, 0 by default.
+	 */
+	// mutators
 	private Mutator[] mutators = new Mutator[] {
-			new PointMutator()};
+			new PointMutator() };
 	private Mutator mutator = mutators[0];
 	
+	// evolutionary algorithms
 	private EvolutionaryAlgorithm[] evolutionaryAlgorithms = new EvolutionaryAlgorithm[] {
-			new StandardEA()};
+			new StandardEA() };
 	private EvolutionaryAlgorithm evolutionaryAlgorithm = evolutionaryAlgorithms[0];
 	
+	// fitness evaluators
 	private FitnessFunction[] fitnessFunctions = new FitnessFunction[] {
-			new TruthTableEvaluator()};
+			new TestCaseEvaluator() };
 	private FitnessFunction fitnessFunction = fitnessFunctions[0];
 
-	private FunctionSet[] functionSets =  new FunctionSet[] {
-			new FunctionSet("Arithmetic",
-					new Arithmetic.Addition(),
-					new Arithmetic.Subtraction(),
-					new Arithmetic.Multiplication(),
-					new Arithmetic.Division()),
-
-			new FunctionSet("32-bit logic",
-					new BitwiseLogic.And(), 
-					new BitwiseLogic.Or(), 
-					new BitwiseLogic.Nand(), 
-					new BitwiseLogic.Nor(), 
-					new BitwiseLogic.Xor(),
-					new BitwiseLogic.Xnor(),
-					new BitwiseLogic.Not()),
-
-			new FunctionSet("1-bit logic",
-					new BooleanLogic.And(), 
-					new BooleanLogic.Or(), 
-					new BooleanLogic.Nand(), 
-					new BooleanLogic.Nor(), 
-					new BooleanLogic.Xor(),
-					new BooleanLogic.Xnor(),
-					new BooleanLogic.Not())};
+	// the population of chromosomes	
+	private Population population = new Population(resources);
 
-	
-	
-	private Population population;
-
-	private HashMap<String, Parameter> parameters = new HashMap<String, Parameter>();
 
 	public CGP() {
-		createBaseParameters();
-
-		for (int i = 0; i < (int) get("generations"); i++) {
-			
-			set("currentGen", ((int) get("currentGen")) + 1);
-			fitnessFunction.evaluate(population);
-			evolutionaryAlgorithm.evolve(population, mutator);
-			
-			if (evolutionaryAlgorithm.getFittestChromosome().getFitness() >= 3) {
-				break;
-			}
-		}	
-	}
-
-	private void createBaseParameters() {
-		// make fundamental parameters
-		parameters.put("rows", new IntegerParameter(3, "Rows"));
-		parameters.put("columns", new IntegerParameter(3, "Columns"));
-		parameters.put("inputs", new IntegerParameter(3, "Inputs"));
-		parameters.put("outputs", new IntegerParameter(3, "Outputs"));
-		parameters.put("popSize", new IntegerParameter(5, "Population"));
+		resources.addModuleParameters(evolutionaryAlgorithm, mutator, fitnessFunction);
 		
-		parameters.put("nodes", new IntegerParameter(9, "", true, true));
+		resources.setTestCases(new TestCase(new Integer[]{1, 2, 3}, new Integer[]{4, 5, 6}),
+							   new TestCase(new Integer[]{1, 12, 4}, new Integer[]{6, 21, 2}));
 		
-		parameters.put("gens", new IntegerParameter(100, "Generations"));
-		parameters.put("currentGen", new IntegerParameter(0, "Generation"));
-		parameters.put("runs", new IntegerParameter(5, "Runs"));
-		
-		parameters.put("debug", new BooleanParameter(false, "Debug"));
+//		for (int i = 0; i < (int) resources.get("generations"); i++) {
+//			
+//			resources.set("currentGen", ((int) resources.get("currentGen")) + 1);
+//			
+//			fitnessFunction.evaluate(population, resources);
+//			evolutionaryAlgorithm.evolve(population, mutator, resources);
+//			
+//			System.out.println("fitness: " + evolutionaryAlgorithm.getFittestChromosome().getFitness());
+//			
+//			if (evolutionaryAlgorithm.getFittestChromosome().getFitness() >= 6) {
+//				System.out.println("solution found");
+//				evolutionaryAlgorithm.getFittestChromosome().printNodes();
+//				break;
+//			}
+//		}	
 	}
 
-//	/**
-//	 * 
-//	 */
-//	private void loadModules() {
-//		// initialise function set
-//		FunctionSet functionSet = new FunctionSet(new Arithmetic.Addition(), new Arithmetic.Subtraction(), new Arithmetic.Multiplication());
-//		
-//		// initialise utilities
-//		Utilities.setResources(new Random(1234), functionSet);
-//		
-//		// initialise fitness function and truth table
-//		TruthTable.setTestCases(new TestCase(new Object[] {2, 5, 4}, new Object[] {1, 10, 15}));
-//		fitnessFunction = new TruthTableEvaluator();
-//
-//		// initialise EA
-//		evolutionaryAlgorithm = new StandardEA();
-//		mutator = new StandardMutator();
-//		
-//		// initialise population
-//		population = new Population();
-//	}
-	
-	// Parameter methods
-	public void register(String key, Parameter value) {
-		parameters.put(key, value);
-	}
-	
-	/**
-	 * @param key
-	 * @return
-	 */
-	public Object get(String key) {
-		return parameters.get(key).getValue();
-	}
-	
-	public void set(String key, Object value) {
-		parameters.get(key).setValue(value);
-	}
-	
-	@SuppressWarnings("rawtypes")
-	public Property getProperty(String key) {
-		return parameters.get(key).valueProperty();
+
+	public Resources getResources() {
+		return resources;
 	}
-	
-	public boolean contains(String key) {
-		return parameters.containsKey(key);
+
+
+	public Population getPopulation() {
+		return population;
 	}
 	
-	// Utility methods
-	
 }
diff --git a/src/jcgp/GUI.java b/src/jcgp/GUI.java
new file mode 100644
index 0000000..1e1d4e4
--- /dev/null
+++ b/src/jcgp/GUI.java
@@ -0,0 +1,111 @@
+package jcgp;
+
+import javafx.application.Application;
+import javafx.event.EventHandler;
+import javafx.scene.Node;
+import javafx.scene.Scene;
+import javafx.scene.control.Tab;
+import javafx.scene.control.TabPane;
+import javafx.scene.control.TabPane.TabClosingPolicy;
+import javafx.scene.input.MouseDragEvent;
+import javafx.scene.layout.BorderPane;
+import javafx.stage.Stage;
+import jcgp.CGP.Resources;
+import jcgp.gui.Console;
+import jcgp.gui.SettingsPane;
+import jcgp.gui.population.ChromosomePane;
+import jcgp.gui.population.GUIGene;
+import jcgp.gui.population.GUINode;
+import jcgp.gui.population.GUIOutput;
+
+public class GUI extends Application {
+	
+	public static final String NEUTRAL_COLOUR = "#FFFFFF";
+	public static final String HARD_HIGHLIGHT_COLOUR = "#89AAD6";
+	public static final String SOFT_HIGHLIGHT_COLOUR = "#C7DFFF";
+	public static final String GOOD_SELECTION_COLOUR = "#BDFFC2";
+	public static final String NEUTRAL_SELECTION_COLOUR = "#FBFFB8";
+	public static final String BAD_SELECTION_COLOUR = "#FF9C9C";
+	
+	private static CGP cgp;
+	public static Resources resources;
+	
+	
+	private BorderPane window;
+	
+	private ChromosomePane[] chromosomes;
+	private TabPane mainPane;
+	
+	private static Console console;
+	private SettingsPane settings;
+
+	public static void main(String[] args) {
+		
+		cgp = new CGP();
+		resources = cgp.getResources();
+		
+		launch();
+		
+	}
+	
+	@Override
+	public void start(Stage primaryStage) throws Exception {
+		
+		/*
+		 * Instantiate the various GUI elements here. 
+		 * 
+		 * 
+		 */
+		
+		mainPane = new TabPane();
+		mainPane.setTabClosingPolicy(TabClosingPolicy.UNAVAILABLE);
+		chromosomes = new ChromosomePane[(int) cgp.getResources().get("popSize")];
+		Tab tab;
+		for (int i = 0; i < chromosomes.length; i++) {
+			chromosomes[i] = new ChromosomePane(cgp.getPopulation().getChromosome(i), cgp.getResources());
+			tab = new Tab("Chr " + i);
+			tab.setContent(chromosomes[i]);
+			mainPane.getTabs().add(tab);
+		}
+		
+		mainPane.setPrefHeight(500);
+		
+		window = new BorderPane();
+		window.setCenter(mainPane);
+				
+		Scene scene = new Scene(window);
+		
+		primaryStage.addEventFilter(MouseDragEvent.MOUSE_DRAG_RELEASED, new EventHandler<MouseDragEvent>() {
+			@Override
+			public void handle(MouseDragEvent event) {
+				// preemptively determine whether this event will reach a GUIGene
+				// sodding Controls...
+				if (event.getTarget() instanceof Node) {
+					Node source = ((Node) event.getTarget());
+					while (source != null) {
+						if (source instanceof GUIGene) {
+							return;
+						}
+						source = source.getParent();
+					}
+				}
+				event.consume();
+				((GUIGene) event.getGestureSource()).resetState();
+				if (event.getGestureSource() instanceof GUINode) {
+					((GUINode) event.getGestureSource()).updateLines();
+				} else if (event.getGestureSource() instanceof GUIOutput) {
+					((GUIOutput) event.getGestureSource()).updateLine();
+				}
+			}
+		});
+		
+		primaryStage.setMinHeight(600);
+		primaryStage.setMinWidth(800);
+		
+		primaryStage.setScene(scene);
+		primaryStage.show();
+		
+		
+	}
+
+}
diff --git a/src/jcgp/Main.java b/src/jcgp/Main.java
deleted file mode 100644
index d2b438d..0000000
--- a/src/jcgp/Main.java
+++ /dev/null
@@ -1,9 +0,0 @@
-package jcgp;
-
-public class Main {
-	
-	public static void main(String[] args) {
-		CGP cgp = new CGP();
-			
-	}
-}
diff --git a/src/jcgp/TruthTable.java b/src/jcgp/TruthTable.java
deleted file mode 100644
index e62f56b..0000000
--- a/src/jcgp/TruthTable.java
+++ /dev/null
@@ -1,21 +0,0 @@
-package jcgp;
-
-import jcgp.modules.fitness.TestCase;
-
-public class TruthTable {
-
-	private static TestCase[] testCases;
-
-	public static void setTestCases(TestCase ... testCases) {
-		TruthTable.testCases = testCases;
-	}
-
-	public static TestCase getTestCase(int index) {
-		return testCases[index];
-	}
-
-	public static int getTestCaseCount() {
-		return testCases.length;
-	}
-	
-}
diff --git a/src/jcgp/Utilities.java b/src/jcgp/Utilities.java
deleted file mode 100644
index ff5387f..0000000
--- a/src/jcgp/Utilities.java
+++ /dev/null
@@ -1,98 +0,0 @@
-package jcgp;
-
-import java.util.Random;
-
-import jcgp.modules.function.Function;
-import jcgp.modules.function.FunctionSet;
-import jcgp.parameters.Parameters;
-import jcgp.population.*;
-
-public class Utilities {
-	
-	private static Random numberGenerator;
-	private static FunctionSet functionSet;
-	
-	public static void setResources(Random numberGenerator, FunctionSet functionSet) {
-		Utilities.numberGenerator = numberGenerator;
-		Utilities.functionSet = functionSet;
-	}
-
-	public static int getRandomInt(int limit){
-		return numberGenerator.nextInt(limit);
-	}
-
-	public static double getRandomDouble(int limit){
-		return numberGenerator.nextDouble() * limit;
-	}
-
-	/**
-	 * @param chromosome the chromosome to choose from
-	 * @return a random input
-	 */
-	public static Input getRandomInput(Chromosome chromosome){
-		return chromosome.getInput(getRandomInt(Parameters.getInputs()));
-	}
-
-	/**
-	 * Returns a random allowed node respecting levels back.
-	 * 
-	 * This method will NOT pick inputs.
-	 * 
-	 * @param chromosome the chromosome to pick from
-	 * @param column the column to use as reference
-	 * @return a random node
-	 */
-	public static Node getRandomNode(Chromosome chromosome, int column){
-		// work out the allowed range obeying levels back
-		int allowedColumns = ((column >= Parameters.getLevelsBack()) ? Parameters.getLevelsBack() : column);
-		int offset = column - allowedColumns;
-
-		// pick a random allowed column and row
-		int randomColumn = (getRandomInt(allowedColumns) + offset);
-		int randomRow = (getRandomInt(Parameters.getRows()));
-
-		return chromosome.getNode(randomRow, randomColumn);
-	}
-
-	/**
-	 * Returns a random allowed node.
-	 * 
-	 * This method will NOT pick inputs.
-	 * 
-	 * @param chromosome the chromosome to pick from
-	 * @param column the column to use as reference
-	 * @param levelsBack whether or not to respect levels back
-	 * @return a random node
-	 */
-	public static Node getRandomNode(Chromosome chromosome, int column, boolean levelsBack){
-		if (levelsBack) {
-			return getRandomNode(chromosome, column);
-		} else {
-			// pick any random column before the given column
-			int randomColumn = (getRandomInt(column));
-			// pick a random rowgetColumns
-			int randomRow = (getRandomInt(Parameters.getRows()));
-			return chromosome.getNode(randomRow, randomColumn);
-		}
-	}
-
-
-	/**
-	 * pick from any column - use this for setting outputs
-	 * 
-	 * @param chromosome
-	 * @return
-	 */
-	public static Node getRandomNode(Chromosome chromosome) {
-		return chromosome.getNode(getRandomInt(Parameters.getRows()), getRandomInt(Parameters.getColumns()));
-	}
-
-	public static Function getRandomFunction() {
-		return functionSet.getFunction(Utilities.getRandomInt(functionSet.getFunctionCount()));
-	}
-
-	public static Function getFunction(int index) {
-		return functionSet.getFunction(index);
-	}
-
-}
diff --git a/src/jcgp/modules/function/Arithmetic.java b/src/jcgp/function/Arithmetic.java
index aa5e9bf..7ec1366 100644
--- a/src/jcgp/modules/function/Arithmetic.java
+++ b/src/jcgp/function/Arithmetic.java
@@ -1,10 +1,25 @@
-package jcgp.modules.function;
+package jcgp.function;
+
+import java.util.ArrayList;
+import java.util.Arrays;
 
 import jcgp.exceptions.InvalidArgumentsException;
 import jcgp.population.Connection;
 
-public class Arithmetic {
-
+public class Arithmetic extends FunctionSet {
+	
+	public Arithmetic() {
+		maxArity = 2;
+		name = "Arithmetic";
+		functionList = new Function[]{
+				new Addition(),
+				new Subtraction(),
+				new Multiplication(),
+				new Division()};
+		
+		allowedFunctions = new ArrayList<Function>(Arrays.asList(functionList));
+	}
+	
 	public static class Addition extends Function {
 
 		private int arity = 2;
@@ -26,6 +41,11 @@ public class Arithmetic {
 		public int getArity() {
 			return arity;
 		}
+
+		@Override
+		public String getName() {
+			return "Addition";
+		}
 	}
 
 	public static class Subtraction extends Function {
@@ -49,6 +69,11 @@ public class Arithmetic {
 		public int getArity() {
 			return arity;
 		}
+
+		@Override
+		public String getName() {
+			return "Subtraction";
+		}
 	}
 
 	public static class Multiplication extends Function {
@@ -72,6 +97,11 @@ public class Arithmetic {
 		public int getArity() {
 			return arity;
 		}
+
+		@Override
+		public String getName() {
+			return "Multiplication";
+		}
 	}
 
 	public static class Division extends Function {
@@ -100,6 +130,11 @@ public class Arithmetic {
 		public int getArity() {
 			return arity;
 		}
+
+		@Override
+		public String getName() {
+			return "Division";
+		}
 	}
 	
 }
diff --git a/src/jcgp/modules/function/BitwiseLogic.java b/src/jcgp/function/BitwiseLogic.java
index c8452e6..033534d 100644
--- a/src/jcgp/modules/function/BitwiseLogic.java
+++ b/src/jcgp/function/BitwiseLogic.java
@@ -1,9 +1,27 @@
-package jcgp.modules.function;
+package jcgp.function;
+
+import java.util.ArrayList;
+import java.util.Arrays;
 
 import jcgp.exceptions.InvalidArgumentsException;
 import jcgp.population.Connection;
 
-public class BitwiseLogic {
+public class BitwiseLogic extends FunctionSet {
+	
+	public BitwiseLogic() {
+		maxArity = 2;
+		name = "32-bit Logic";
+		functionList = new Function[]{
+				new And(),
+				new Or(),
+				new Not(),
+				new Xor(),
+				new Nand(),
+				new Nor(),
+				new Xnor()};
+		
+		allowedFunctions = new ArrayList<Function>(Arrays.asList(functionList));
+	}
 
 	public static class And extends Function {	
 		private int arity = 2;
@@ -25,6 +43,11 @@ public class BitwiseLogic {
 		public int getArity() {
 			return arity;
 		}
+
+		@Override
+		public String getName() {
+			return "AND";
+		}
 	}
 	
 	public static class Or extends Function {	
@@ -47,6 +70,11 @@ public class BitwiseLogic {
 		public int getArity() {
 			return arity;
 		}
+
+		@Override
+		public String getName() {
+			return "OR";
+		}
 	}
 
 	public static class Not extends Function {	
@@ -68,6 +96,11 @@ public class BitwiseLogic {
 		public int getArity() {
 			return arity;
 		}
+
+		@Override
+		public String getName() {
+			return "NOT";
+		}
 	}
 
 	public static class Xor extends Function {	
@@ -90,6 +123,11 @@ public class BitwiseLogic {
 		public int getArity() {
 			return arity;
 		}
+
+		@Override
+		public String getName() {
+			return "XOR";
+		}
 	}
 
 	public static class Nand extends Function {	
@@ -112,6 +150,11 @@ public class BitwiseLogic {
 		public int getArity() {
 			return arity;
 		}
+
+		@Override
+		public String getName() {
+			return "NAND";
+		}
 	}
 
 	public static class Nor extends Function {	
@@ -134,6 +177,11 @@ public class BitwiseLogic {
 		public int getArity() {
 			return arity;
 		}
+
+		@Override
+		public String getName() {
+			return "NOR";
+		}
 	}
 
 	public static class Xnor extends Function {	
@@ -156,6 +204,11 @@ public class BitwiseLogic {
 		public int getArity() {
 			return arity;
 		}
+
+		@Override
+		public String getName() {
+			return "XNOR";
+		}
 	}
 
 	
diff --git a/src/jcgp/modules/function/BooleanLogic.java b/src/jcgp/function/BooleanLogic.java
index f98d1db..d31b798 100644
--- a/src/jcgp/modules/function/BooleanLogic.java
+++ b/src/jcgp/function/BooleanLogic.java
@@ -1,9 +1,27 @@
-package jcgp.modules.function;
+package jcgp.function;
+
+import java.util.ArrayList;
+import java.util.Arrays;
 
 import jcgp.exceptions.InvalidArgumentsException;
 import jcgp.population.Connection;
 
-public class BooleanLogic {
+public class BooleanLogic extends FunctionSet {
+	
+	public BooleanLogic() {
+		maxArity = 2;
+		name = "1-bit Logic";
+		functionList = new Function[]{
+				new And(),
+				new Or(),
+				new Not(),
+				new Xor(),
+				new Nand(),
+				new Nor(),
+				new Xnor()};
+		
+		allowedFunctions = new ArrayList<Function>(Arrays.asList(functionList));
+	}
 
 	public static class And extends Function {	
 		private int arity = 2;
@@ -25,6 +43,11 @@ public class BooleanLogic {
 		public int getArity() {
 			return arity;
 		}
+
+		@Override
+		public String getName() {
+			return "AND";
+		}
 	}
 	
 	public static class Or extends Function {	
@@ -47,6 +70,11 @@ public class BooleanLogic {
 		public int getArity() {
 			return arity;
 		}
+
+		@Override
+		public String getName() {
+			return "OR";
+		}
 	}
 
 	public static class Not extends Function {	
@@ -68,6 +96,11 @@ public class BooleanLogic {
 		public int getArity() {
 			return arity;
 		}
+
+		@Override
+		public String getName() {
+			return "NOT";
+		}
 	}
 
 	public static class Xor extends Function {	
@@ -90,6 +123,11 @@ public class BooleanLogic {
 		public int getArity() {
 			return arity;
 		}
+
+		@Override
+		public String getName() {
+			return "XOR";
+		}
 	}
 
 	public static class Nand extends Function {	
@@ -112,6 +150,11 @@ public class BooleanLogic {
 		public int getArity() {
 			return arity;
 		}
+
+		@Override
+		public String getName() {
+			return "NAND";
+		}
 	}
 
 	public static class Nor extends Function {	
@@ -134,6 +177,11 @@ public class BooleanLogic {
 		public int getArity() {
 			return arity;
 		}
+
+		@Override
+		public String getName() {
+			return "NOR";
+		}
 	}
 
 	public static class Xnor extends Function {	
@@ -156,6 +204,11 @@ public class BooleanLogic {
 		public int getArity() {
 			return arity;
 		}
+
+		@Override
+		public String getName() {
+			return "XNOR";
+		}
 	}
 
 	
diff --git a/src/jcgp/modules/function/Function.java b/src/jcgp/function/Function.java
index 3314c2f..64dd206 100644
--- a/src/jcgp/modules/function/Function.java
+++ b/src/jcgp/function/Function.java
@@ -1,12 +1,13 @@
-package jcgp.modules.function;
+package jcgp.function;
 
 import jcgp.exceptions.InvalidArgumentsException;
 import jcgp.population.Connection;
 
 public abstract class Function {
-		
+			
 	public abstract Object run(Connection ... connections) throws InvalidArgumentsException;
 	
 	public abstract int getArity();
 	
+	public abstract String getName();	
 }
diff --git a/src/jcgp/function/FunctionSet.java b/src/jcgp/function/FunctionSet.java
new file mode 100644
index 0000000..07b4ea4
--- /dev/null
+++ b/src/jcgp/function/FunctionSet.java
@@ -0,0 +1,54 @@
+package jcgp.function;
+
+import java.util.ArrayList;
+import java.util.Iterator;
+
+/**
+ * 
+ * @author Eduardo Pedroni
+ *
+ */
+public abstract class FunctionSet {
+		protected Function[] functionList;
+		protected ArrayList<Function> allowedFunctions;
+		protected int maxArity;
+		protected String name;
+		
+//		public int getTotalFunctionCount() {
+//			return functionList.length;
+//		}
+		
+		public int getFunctionCount() {
+			return allowedFunctions.size();
+		}
+		
+		public Function getFunction(int index) {
+			return allowedFunctions.get(index);
+		}
+		
+		public int getMaxArity(){
+			return maxArity;
+		}
+		
+		public String getName() {
+			return name;
+		}
+		
+		public void disableFunction(int index) {
+			for (Iterator<Function> iterator = allowedFunctions.iterator(); iterator.hasNext();) {
+				if (index < functionList.length) {
+					Function function = (Function) iterator.next();
+					if (function == functionList[index]) {
+						iterator.remove();
+					}
+				}
+				
+			}
+		}
+		
+		public void enableFunction(int index) {
+			if (!allowedFunctions.contains(functionList[index])) {
+				allowedFunctions.add(functionList[index]);
+			}
+		}
+	}
\ No newline at end of file
diff --git a/src/jcgp/gui/Console.java b/src/jcgp/gui/Console.java
new file mode 100644
index 0000000..9008531
--- /dev/null
+++ b/src/jcgp/gui/Console.java
@@ -0,0 +1,13 @@
+package jcgp.gui;
+
+import javafx.scene.control.TextArea;
+
+public class Console extends TextArea {
+
+	public Console() {
+		super();
+		setDisable(true);
+		setPrefHeight(100);
+	}
+	
+}
diff --git a/src/jcgp/gui/GUI.java b/src/jcgp/gui/GUI.java
deleted file mode 100644
index 0e4b91a..0000000
--- a/src/jcgp/gui/GUI.java
+++ /dev/null
@@ -1,14 +0,0 @@
-package jcgp.gui;
-
-import javafx.application.Application;
-import javafx.stage.Stage;
-
-public class GUI extends Application {
-
-	@Override
-	public void start(Stage primaryStage) throws Exception {
-		
-
-	}
-
-}
diff --git a/src/jcgp/gui/SettingsPane.java b/src/jcgp/gui/SettingsPane.java
new file mode 100644
index 0000000..53056d3
--- /dev/null
+++ b/src/jcgp/gui/SettingsPane.java
@@ -0,0 +1,11 @@
+package jcgp.gui;
+
+import javafx.scene.layout.VBox;
+
+public class SettingsPane extends VBox {
+
+	public SettingsPane() {
+		super();
+		setPrefSize(180, 500);
+	}
+}
diff --git a/src/jcgp/gui/population/ChromosomePane.java b/src/jcgp/gui/population/ChromosomePane.java
new file mode 100644
index 0000000..546314e
--- /dev/null
+++ b/src/jcgp/gui/population/ChromosomePane.java
@@ -0,0 +1,97 @@
+package jcgp.gui.population;
+
+import java.util.ArrayList;
+
+import javafx.scene.control.ScrollPane;
+import javafx.scene.layout.Pane;
+import javafx.scene.shape.Line;
+import jcgp.CGP.Resources;
+import jcgp.population.Chromosome;
+
+
+public class ChromosomePane extends ScrollPane {
+
+	private GUINode[][] guiNodes;
+	private GUIInput[] guiInputs;
+	private GUIOutput[] guiOutputs;
+	
+	private Pane content;
+	
+	private ArrayList<Line> connectionLines;
+	
+	public ChromosomePane(Chromosome chromosome, Resources resources) {
+		super();		
+		connectionLines = new ArrayList<Line>();
+		
+		content = new Pane();
+		content.setId("content pane for genes");
+		
+		// generate the GUIGenes
+		// inputs
+		guiInputs = new GUIInput[(int) resources.get("inputs")];
+		for (int i = 0; i < guiInputs.length; i++) {
+			// make the GUI elements
+			guiInputs[i] = new GUIInput(this, chromosome.getInput(i));
+			content.getChildren().addAll(guiInputs[i]);
+		}
+		// nodes
+		guiNodes = new GUINode[(int) resources.get("rows")][(int) resources.get("columns")];
+		double angle, xPos, yPos;
+		for (int r = 0; r < guiNodes.length; r++) {
+			for (int c = 0; c < guiNodes[r].length; c++) {
+				// make the connection lines
+				Line lines[] = new Line[(int) resources.get("arity")];
+				for (int l = 0; l < lines.length; l++) {
+					angle = ((((double) (l + 1)) / ((double) (lines.length + 1))) * GUIGene.THETA) - (GUIGene.THETA / 2);
+					xPos = (-Math.cos(angle) * GUIGene.NODE_RADIUS) + (((c + 1) * (2 * GUIGene.NODE_RADIUS + GUIGene.SPACING)) + GUIGene.NODE_RADIUS);
+					yPos = (Math.sin(angle) * GUIGene.NODE_RADIUS) + ((r * (2 * GUIGene.NODE_RADIUS + GUIGene.SPACING)) + GUIGene.NODE_RADIUS);
+					
+					lines[l] = new Line(xPos, yPos, xPos, yPos);
+					lines[l].setMouseTransparent(true);
+					lines[l].setVisible(false);
+					connectionLines.add(lines[l]);
+				}
+				// make the GUI elements
+				guiNodes[r][c] = new GUINode(this, chromosome.getNode(r, c), resources, lines);
+			}
+			content.getChildren().addAll(guiNodes[r]);
+		}
+		
+		// outputs
+		guiOutputs = new GUIOutput[(int) resources.get("outputs")];
+		for (int i = 0; i < guiOutputs.length; i++) {
+			xPos = (((int) resources.get("columns") + 1) * (2 * GUIGene.NODE_RADIUS + GUIGene.SPACING));
+			yPos = (chromosome.getOutput(i).getIndex() * (2 * GUIGene.NODE_RADIUS + GUIGene.SPACING)) + GUIGene.NODE_RADIUS;
+			// make the line
+			Line line = new Line(xPos, yPos, xPos, yPos);
+			line.setMouseTransparent(true);
+			line.setVisible(false);
+			connectionLines.add(line);
+			// make the GUI elements
+			guiOutputs[i] = new GUIOutput(this, chromosome.getOutput(i), resources, line);
+			content.getChildren().addAll(guiOutputs[i]);
+		}
+
+		content.getChildren().addAll(connectionLines);
+		setPrefWidth(620);	
+		setContent(content);
+	}
+	
+	
+	public GUINode getGuiNode(int row, int column) {
+		return guiNodes[row][column];
+	}
+	
+	public GUIInput getGuiInput(int index) {
+		return guiInputs[index];
+	}
+	
+	public GUIOutput getGuiOutput(int index) {
+		return guiOutputs[index];
+	}
+	
+	public Pane getContentPane() {
+		return content;
+	}
+	
+}
diff --git a/src/jcgp/gui/population/GUIGene.java b/src/jcgp/gui/population/GUIGene.java
new file mode 100644
index 0000000..ef44110
--- /dev/null
+++ b/src/jcgp/gui/population/GUIGene.java
@@ -0,0 +1,56 @@
+package jcgp.gui.population;
+
+import javafx.beans.property.SimpleObjectProperty;
+import javafx.scene.Group;
+import javafx.scene.shape.Circle;
+import javafx.scene.text.Text;
+import jcgp.population.Gene;
+
+enum GUIGeneState {
+	NEUTRAL,
+	HOVER,
+	INDIRECT_HOVER,
+	ACTIVE_HOVER,
+	SOURCE,
+	TARGET,
+	NO_CHANGE_TARGET,
+	FORBIDDEN_TARGET
+}
+
+public abstract class GUIGene extends Group {
+
+	public static final double NODE_RADIUS = 30;
+	public static final double SPACING = 15;
+	
+	public static final double THETA = Math.PI / 1.4;
+	public static final double SOCKET_RADIUS = Math.sqrt(NODE_RADIUS) / 1.8;
+	
+	public static final double NODE_TEXT = 0;
+	
+	protected Text text;
+	protected Circle mainCircle;
+	
+	protected SimpleObjectProperty<GUIGeneState> stateProperty = new SimpleObjectProperty<GUIGeneState>(GUIGeneState.NEUTRAL);
+
+	protected ChromosomePane parent;
+	
+	public SimpleObjectProperty<GUIGeneState> stateProperty() {
+		return stateProperty;
+	}
+	
+	public void setState(GUIGeneState newState) {
+		stateProperty.set(newState);
+	}
+
+	public void showText(boolean value) {
+		text.setVisible(value);
+	}
+	
+	public abstract Gene getGene();
+
+	public abstract void setConnections(GUIGeneState newState);
+
+	public abstract void resetState();
+	
+	
+}
diff --git a/src/jcgp/gui/population/GUIInput.java b/src/jcgp/gui/population/GUIInput.java
new file mode 100644
index 0000000..6f7a523
--- /dev/null
+++ b/src/jcgp/gui/population/GUIInput.java
@@ -0,0 +1,193 @@
+package jcgp.gui.population;
+
+import javafx.beans.value.ChangeListener;
+import javafx.beans.value.ObservableValue;
+import javafx.event.EventHandler;
+import javafx.geometry.VPos;
+import javafx.scene.input.MouseDragEvent;
+import javafx.scene.input.MouseEvent;
+import javafx.scene.paint.Paint;
+import javafx.scene.shape.Circle;
+import javafx.scene.text.Font;
+import javafx.scene.text.Text;
+import javafx.scene.text.TextAlignment;
+import jcgp.GUI;
+import jcgp.population.Input;
+import jcgp.population.Node;
+import jcgp.population.Output;
+
+public class GUIInput extends GUIGene {
+
+	private Circle outputSocket;
+	private Input input;
+
+	public GUIInput(ChromosomePane parentRef, final Input input) {
+
+		this.parent = parentRef;
+		this.input = input;
+		
+		relocate(NODE_RADIUS,
+				(input.getIndex() * (2 * NODE_RADIUS + SPACING)) + NODE_RADIUS);
+		
+		mainCircle = new Circle(NODE_RADIUS, Paint.valueOf("white"));
+		mainCircle.setStroke(Paint.valueOf("black"));
+
+		text = new Text("I: " + input.getIndex());
+		text.setFont(Font.font("Arial", 12));
+		text.setTextOrigin(VPos.CENTER);
+		text.setTextAlignment(TextAlignment.CENTER);
+		text.setWrappingWidth(NODE_RADIUS * 2);
+		text.setX(-NODE_RADIUS);
+		text.setVisible(true);
+
+		outputSocket = new Circle(NODE_RADIUS, 0, SOCKET_RADIUS, Paint.valueOf("white"));
+		outputSocket.setId(String.valueOf(0));
+		outputSocket.setStroke(Paint.valueOf("black"));
+
+		getChildren().addAll(mainCircle, text, outputSocket);
+		
+		/*
+		 * Mouse event handlers on whole gene
+		 */
+		addEventFilter(MouseDragEvent.MOUSE_DRAG_ENTERED, new EventHandler<MouseDragEvent>() {
+			@Override
+			public void handle(MouseDragEvent event) {
+				// the drag has entered this node, react appropriately
+				// this happens even if we are the source of the drag
+				if (event.getGestureSource() instanceof GUINode) {
+					Node source = ((GUINode) event.getGestureSource()).getGene();
+					for (int i = 0; i < (int) GUI.resources.get("arity"); i++) {
+						if (input == source.getConnection(i)) {
+							stateProperty.set(GUIGeneState.NO_CHANGE_TARGET);
+							return;
+						}
+					}
+				} else if (event.getGestureSource() instanceof GUIOutput) {
+					Output source = ((GUIOutput) event.getGestureSource()).getGene();
+					if (((GUIGene) event.getSource()).getGene() == source.getSource()) {
+						((GUIGene) event.getSource()).setState(GUIGeneState.NO_CHANGE_TARGET);
+					}
+				}
+				stateProperty.set(GUIGeneState.TARGET);
+			}
+		});
+
+		addEventFilter(MouseDragEvent.MOUSE_DRAG_OVER, new EventHandler<MouseDragEvent>() {
+			@Override
+			public void handle(MouseDragEvent event) {
+				// the user is dragging over this node, react appropriately
+				// this happens even if we are the source of the drag
+				
+			}
+		});
+		
+		addEventFilter(MouseDragEvent.MOUSE_DRAG_EXITED, new EventHandler<MouseDragEvent>() {
+			@Override
+			public void handle(MouseDragEvent event) {
+				// the drag has exited this node, react appropriately
+				// this happens even if we are the source of the drag
+				if (stateProperty.get() == GUIGeneState.NO_CHANGE_TARGET) {
+					stateProperty.set(GUIGeneState.INDIRECT_HOVER);
+				} else {
+					stateProperty.set(GUIGeneState.NEUTRAL);
+				}
+			}
+
+		});
+		
+		addEventFilter(MouseDragEvent.MOUSE_DRAG_RELEASED, new EventHandler<MouseDragEvent>() {
+			@Override
+			public void handle(MouseDragEvent event) {
+				// set states to reflect the new situation
+				((GUIGene) event.getGestureSource()).setState(GUIGeneState.NEUTRAL);
+				((GUIGene) event.getGestureSource()).setConnections(GUIGeneState.NEUTRAL);
+				stateProperty.set(GUIGeneState.HOVER);
+				// the user released the drag gesture on this node, react appropriately
+				if (event.getGestureSource() instanceof GUINode) {
+					((GUINode) event.getGestureSource()).setChangingConnection(input);
+				} else if (event.getGestureSource() instanceof GUIOutput) {
+					((GUIOutput) event.getGestureSource()).getGene().setConnection(0, input);
+				}			
+			}
+		});
+		
+		addEventFilter(MouseEvent.MOUSE_ENTERED, new EventHandler<MouseEvent>() {
+			@Override
+			public void handle(MouseEvent event) {
+				// cursor has entered this node without dragging, or it is dragging and this is the source
+				if (stateProperty.get() == GUIGeneState.NEUTRAL) {
+					stateProperty.set(GUIGeneState.INDIRECT_HOVER);
+				}
+			}
+		});
+		
+		addEventFilter(MouseEvent.MOUSE_EXITED, new EventHandler<MouseEvent>() {
+			@Override
+			public void handle(MouseEvent event) {
+				// cursor has left this node without dragging, or it is dragging and this is the source
+				if (stateProperty.get() == GUIGeneState.INDIRECT_HOVER) {
+					stateProperty.set(GUIGeneState.NEUTRAL);
+					setConnections(GUIGeneState.NEUTRAL);
+				}
+			}
+		});
+		
+		stateProperty.addListener(new ChangeListener<GUIGeneState>() {
+			@Override
+			public void changed(ObservableValue<? extends GUIGeneState> observable,	GUIGeneState oldValue, GUIGeneState newValue) {
+				
+				switch (newValue) {
+				case ACTIVE_HOVER:
+					mainCircle.setFill(Paint.valueOf(GUI.SOFT_HIGHLIGHT_COLOUR));
+					break;
+				case FORBIDDEN_TARGET:
+					mainCircle.setFill(Paint.valueOf(GUI.BAD_SELECTION_COLOUR));
+					break;
+				case HOVER:
+					mainCircle.setFill(Paint.valueOf(GUI.HARD_HIGHLIGHT_COLOUR));
+					break;
+				case INDIRECT_HOVER:
+					mainCircle.setFill(Paint.valueOf(GUI.SOFT_HIGHLIGHT_COLOUR));
+					break;
+				case NEUTRAL:
+					mainCircle.setFill(Paint.valueOf(GUI.NEUTRAL_COLOUR));
+					break;
+				case NO_CHANGE_TARGET:
+					mainCircle.setFill(Paint.valueOf(GUI.NEUTRAL_SELECTION_COLOUR));
+					break;
+				case SOURCE:
+					mainCircle.setFill(Paint.valueOf(GUI.HARD_HIGHLIGHT_COLOUR));
+					break;
+				case TARGET:
+					mainCircle.setFill(Paint.valueOf(GUI.GOOD_SELECTION_COLOUR));
+					break;
+				default:
+					break;
+				
+				}
+			}
+		});
+	
+	}
+
+	@Override
+	public Input getGene() {
+		return input;
+	}
+
+	/**
+	 * Set all connections to a given state.
+	 * 
+	 * @param newState the state to set connections to.
+	 */
+	@Override
+	public void setConnections(GUIGeneState newState) {
+		// nothing
+	}
+
+	@Override
+	public void resetState() {
+		stateProperty.set(GUIGeneState.NEUTRAL);
+		
+	}	
+}
diff --git a/src/jcgp/gui/population/GUINode.java b/src/jcgp/gui/population/GUINode.java
new file mode 100644
index 0000000..4350e52
--- /dev/null
+++ b/src/jcgp/gui/population/GUINode.java
@@ -0,0 +1,417 @@
+package jcgp.gui.population;
+
+import javafx.beans.value.ChangeListener;
+import javafx.beans.value.ObservableValue;
+import javafx.event.EventHandler;
+import javafx.geometry.VPos;
+import javafx.scene.control.Label;
+import javafx.scene.input.MouseDragEvent;
+import javafx.scene.input.MouseEvent;
+import javafx.scene.paint.Paint;
+import javafx.scene.shape.Circle;
+import javafx.scene.shape.Line;
+import javafx.scene.text.Font;
+import javafx.scene.text.Text;
+import javafx.scene.text.TextAlignment;
+import jcgp.CGP.Resources;
+import jcgp.GUI;
+import jcgp.function.Function;
+import jcgp.population.Connection;
+import jcgp.population.Input;
+import jcgp.population.Node;
+import jcgp.population.Output;
+
+public class GUINode extends GUIGene {
+	
+	private Circle[] sockets;
+	private Circle output;
+
+	private Line[] lines;
+
+	private Label connectionNumber;
+
+	private Node node;
+	
+	private int connectionIndex;
+	
+	public GUINode(ChromosomePane parentRef, final Node node, Resources resources, Line[] connectionLines) {
+
+		// store references
+		this.parent = parentRef;
+		this.node = node;
+		this.lines = connectionLines;
+		
+		// move the GUIGene to the right position
+		relocate(((node.getColumn() + 1) * (2 * NODE_RADIUS + SPACING)) + NODE_RADIUS,
+				(node.getRow() * (2 * NODE_RADIUS + SPACING)) + NODE_RADIUS);
+
+		// set the line ends correctly
+		updateLines();
+		
+		connectionNumber = new Label();
+		connectionNumber.setStyle("-fx-background-color:rgb(255, 255, 255); -fx-border-color:rgba(0, 0, 0, 0.5); ");
+		connectionNumber.setVisible(false);
+
+		output = new Circle(NODE_RADIUS, 0, SOCKET_RADIUS, Paint.valueOf("white"));
+		output.setStroke(Paint.valueOf("black"));
+
+		mainCircle = new Circle(NODE_RADIUS, Paint.valueOf("white"));
+		mainCircle.setStroke(Paint.valueOf("black"));
+
+		text = new Text(node.getFunction().getName());
+		this.node.functionProperty().addListener(new ChangeListener<Function>() {
+			@Override
+			public void changed(ObservableValue<? extends Function> observable,
+					Function oldValue, Function newValue) {
+				text.setText(newValue.getName());				
+			}
+		});
+		text.setFont(Font.font("Arial", 12));
+		text.setTextOrigin(VPos.CENTER);
+		text.setTextAlignment(TextAlignment.CENTER);
+		text.setWrappingWidth(NODE_RADIUS * 2);
+		text.setX(-NODE_RADIUS);
+		text.setVisible(true);
+
+		sockets = new Circle[(int) resources.get("arity")];
+		double angle, xPos, yPos;
+		for (int l = 0; l < sockets.length; l++) {
+			angle = ((((double) (l + 1)) / ((double) ((int) resources.get("arity") + 1))) * THETA) - (THETA / 2);
+			xPos = -Math.cos(angle) * NODE_RADIUS;
+			yPos = Math.sin(angle) * NODE_RADIUS;
+
+			sockets[l] = new Circle(xPos, yPos, GUIGene.SOCKET_RADIUS, Paint.valueOf("white"));
+			sockets[l].setId(String.valueOf(l));
+			sockets[l].setStroke(Paint.valueOf("black"));
+			
+			final Circle s = sockets[l];
+			final int index = l;
+			
+			/*
+			 * Mouse event handlers on sockets
+			 * 
+			 */
+			s.addEventFilter(MouseDragEvent.DRAG_DETECTED, new EventHandler<MouseEvent>() {
+				@Override
+				public void handle(MouseEvent event) {
+					// the mouse has been dragged out of the socket, this means a full drag is in progress
+					startFullDrag();
+				}
+			});
+			
+			s.addEventFilter(MouseEvent.MOUSE_ENTERED, new EventHandler<MouseEvent>() {
+				@Override
+				public void handle(MouseEvent event) {
+					// user is hovering over connection socket
+					connectionNumber.setText("C: " + s.getId());
+					connectionNumber.relocate(s.getCenterX() + 5, s.getCenterY() - 10);
+					connectionNumber.setVisible(true);
+				}
+			});
+			
+			s.addEventFilter(MouseEvent.MOUSE_EXITED, new EventHandler<MouseEvent>() {
+				@Override
+				public void handle(MouseEvent event) {
+					// user exits the connection socket
+					connectionNumber.setVisible(false);
+				}
+			});
+			
+			s.addEventFilter(MouseDragEvent.MOUSE_PRESSED, new EventHandler<MouseEvent>() {
+				@Override
+				public void handle(MouseEvent event) {
+					// mouse was pressed on the socket
+					stateProperty.set(GUIGeneState.SOURCE);
+					connectionIndex = index;
+ 				}
+			});
+			
+			s.addEventFilter(MouseDragEvent.MOUSE_DRAGGED, new EventHandler<MouseEvent>() {
+				@Override
+				public void handle(MouseEvent event) {
+					lines[connectionIndex].setEndX(event.getX() + ((Circle) event.getSource()).getParent().getLayoutX());
+					lines[connectionIndex].setEndY(event.getY() + ((Circle) event.getSource()).getParent().getLayoutY());
+				}
+			});	
+			
+			s.addEventFilter(MouseDragEvent.MOUSE_RELEASED, new EventHandler<MouseEvent>() {
+				@Override
+				public void handle(MouseEvent event) {
+					if (event.isDragDetect()) {
+						// mouse was released before dragging out of the socket
+						updateLine(index);
+						stateProperty.set(GUIGeneState.HOVER);
+					}
+ 				}
+			});
+		}
+		
+		/*
+		 * Mouse event handlers on whole gene
+		 */
+		addEventFilter(MouseDragEvent.MOUSE_DRAG_ENTERED, new EventHandler<MouseDragEvent>() {
+			@Override
+			public void handle(MouseDragEvent event) {
+				// the drag has entered this node, react appropriately
+				// this happens even if we are the source of the drag
+				if (isAllowed((GUIGene) event.getGestureSource(), (GUIGene) event.getSource())) {
+					if (event.getGestureSource() instanceof GUINode) {
+						Node source = ((GUINode) event.getGestureSource()).getGene();
+						for (int i = 0; i < lines.length; i++) {
+							if (node == source.getConnection(i)) {
+								stateProperty.set(GUIGeneState.NO_CHANGE_TARGET);
+								return;
+							}
+						}
+					} else if (event.getGestureSource() instanceof GUIOutput) {
+						Output source = ((GUIOutput) event.getGestureSource()).getGene();
+						if (((GUIGene) event.getSource()).getGene() == source.getSource()) {
+							((GUIGene) event.getSource()).setState(GUIGeneState.NO_CHANGE_TARGET);
+						}
+					}
+					stateProperty.set(GUIGeneState.TARGET);
+				} else {
+					stateProperty.set(GUIGeneState.FORBIDDEN_TARGET);
+				}
+			}
+		});
+
+		addEventFilter(MouseDragEvent.MOUSE_DRAG_OVER, new EventHandler<MouseDragEvent>() {
+			@Override
+			public void handle(MouseDragEvent event) {
+				// the user is dragging over this node, react appropriately
+				// this happens even if we are the source of the drag
+				
+			}
+		});
+		
+		addEventFilter(MouseDragEvent.MOUSE_DRAG_EXITED, new EventHandler<MouseDragEvent>() {
+			@Override
+			public void handle(MouseDragEvent event) {
+				// the drag has exited this node, react appropriately
+				// this happens even if we are the source of the drag
+				if (event.isPrimaryButtonDown()) {
+					if (event.getGestureSource() == event.getSource()) {
+						stateProperty.set(GUIGeneState.SOURCE);
+					} else {
+						if (stateProperty.get() == GUIGeneState.NO_CHANGE_TARGET) {
+							stateProperty.set(GUIGeneState.INDIRECT_HOVER);
+						} else {
+							stateProperty.set(GUIGeneState.NEUTRAL);
+						}
+					}
+				}
+			}
+		});
+		
+		addEventFilter(MouseDragEvent.MOUSE_DRAG_RELEASED, new EventHandler<MouseDragEvent>() {
+			@Override
+			public void handle(MouseDragEvent event) {
+				// set states to reflect the new situation
+				((GUIGene) event.getGestureSource()).setState(GUIGeneState.NEUTRAL);
+				((GUIGene) event.getGestureSource()).setConnections(GUIGeneState.NEUTRAL);
+				stateProperty.set(GUIGeneState.HOVER);
+				// the user released the drag gesture on this node, react appropriately
+				if (isAllowed((GUIGene) event.getGestureSource(), (GUIGene) event.getSource())) {
+					if (event.getGestureSource() instanceof GUINode) {
+						((GUINode) event.getGestureSource()).setChangingConnection(node);
+					} else if (event.getGestureSource() instanceof GUIOutput) {
+						((GUIOutput) event.getGestureSource()).getGene().setConnection(0, node);
+					}
+				}
+				if (event.getGestureSource() instanceof GUINode) {
+					((GUINode) event.getGestureSource()).updateLines();
+				} else if (event.getGestureSource() instanceof GUIOutput) {
+					((GUIOutput) event.getGestureSource()).updateLine();
+				}
+				
+			}
+		});
+		
+		
+		addEventFilter(MouseEvent.MOUSE_ENTERED, new EventHandler<MouseEvent>() {
+			@Override
+			public void handle(MouseEvent event) {
+				// cursor has entered this node without dragging, or it is dragging and this is the source
+				if (stateProperty.get() == GUIGeneState.NEUTRAL) {
+					stateProperty.set(GUIGeneState.HOVER);
+				}
+			}
+		});
+		
+		addEventFilter(MouseEvent.MOUSE_EXITED, new EventHandler<MouseEvent>() {
+			@Override
+			public void handle(MouseEvent event) {
+				// cursor has left this node without dragging, or it is dragging and this is the source
+				if (stateProperty.get() == GUIGeneState.HOVER) {
+					stateProperty.set(GUIGeneState.NEUTRAL);
+					setConnections(GUIGeneState.NEUTRAL);
+				}
+			}
+		});
+
+		getChildren().addAll(mainCircle, text);
+		getChildren().addAll(sockets);
+		getChildren().addAll(output, connectionNumber);
+		
+		stateProperty.addListener(new ChangeListener<GUIGeneState>() {
+			@Override
+			public void changed(ObservableValue<? extends GUIGeneState> observable,	GUIGeneState oldValue, GUIGeneState newValue) {
+				
+				switch (newValue) {
+				case ACTIVE_HOVER:
+					mainCircle.setFill(Paint.valueOf(GUI.SOFT_HIGHLIGHT_COLOUR));
+					showLines(true);
+					setConnections(GUIGeneState.ACTIVE_HOVER);
+					break;
+				case FORBIDDEN_TARGET:
+					mainCircle.setFill(Paint.valueOf(GUI.BAD_SELECTION_COLOUR));
+					break;
+				case HOVER:
+					mainCircle.setFill(Paint.valueOf(GUI.HARD_HIGHLIGHT_COLOUR));
+					showLines(true);
+					setConnections(GUIGeneState.INDIRECT_HOVER);
+					break;
+				case INDIRECT_HOVER:
+					mainCircle.setFill(Paint.valueOf(GUI.SOFT_HIGHLIGHT_COLOUR));
+					break;
+				case NEUTRAL:
+					mainCircle.setFill(Paint.valueOf(GUI.NEUTRAL_COLOUR));
+					showLines(false);
+					if (oldValue == GUIGeneState.ACTIVE_HOVER) {
+						setConnections(GUIGeneState.NEUTRAL);
+					}
+					break;
+				case NO_CHANGE_TARGET:
+					mainCircle.setFill(Paint.valueOf(GUI.NEUTRAL_SELECTION_COLOUR));
+					break;
+				case SOURCE:
+					mainCircle.setFill(Paint.valueOf(GUI.HARD_HIGHLIGHT_COLOUR));
+					break;
+				case TARGET:
+					mainCircle.setFill(Paint.valueOf(GUI.GOOD_SELECTION_COLOUR));
+					break;
+				default:
+					break;
+				
+				}
+			}
+		});
+		
+		for (int c = 0; c < lines.length; c++) {
+			final int i = c;
+			node.connections().get(c).addListener(new ChangeListener<Connection>() {
+				@Override
+				public void changed(ObservableValue<? extends Connection> observable,
+						Connection oldValue, Connection newValue) {
+					updateLine(i);
+				}
+			});
+		}
+		
+	}
+	
+	
+	private boolean isAllowed(GUIGene source, GUIGene target) {
+		if (source instanceof GUINode) {
+			// if the source is a node, all inputs and some nodes are valid
+			if (target instanceof GUIInput) {
+				return true;
+			} else if (target instanceof GUINode) {
+				// target and source are nodes, let's look at levels back
+				Node t = ((GUINode) target).getGene(), s = ((GUINode) source).getGene();
+				if (s.getColumn() - t.getColumn() > 0 && s.getColumn() - t.getColumn() <= (int) GUI.resources.get("levelsBack")) {
+					return true;
+				}
+				return false;
+			} else if (target instanceof GUIOutput) {
+				return false;
+			} else {
+				throw new ClassCastException("Target was neither GUINode nor GUIInput nor GUIOutput.");
+			}
+		} else if (source instanceof GUIOutput) {
+			// if the source is an output, any node or input is valid
+			if (target instanceof GUINode || target instanceof GUIInput) {
+				return true;
+			} else if (target instanceof GUIOutput) {
+				return false;
+			} else {
+				throw new ClassCastException("Target was neither GUINode nor GUIInput nor GUIOutput.");
+			}
+		}
+		// if the source was neither node nor output, something bad is happening
+		throw new ClassCastException("Source was neither GUINode nor GUIOutput.");
+	}
+
+
+	/**
+	 * Place the end of the specified line on the output of the associated connection. 
+	 * 
+	 * @param index the line to be updated.
+	 */
+	public void updateLine(int index) {
+		if (node.getConnection(index) instanceof Node) {
+			int row = ((Node) node.getConnection(index)).getRow(), 
+					column = ((Node) node.getConnection(index)).getColumn();
+			lines[index].setEndX(((column + 1) * (2 * NODE_RADIUS + SPACING)) + 2 * NODE_RADIUS);
+			lines[index].setEndY((row * (2 * NODE_RADIUS + SPACING)) + NODE_RADIUS);
+		} else if (node.getConnection(index) instanceof Input) {
+			int inputIndex = ((Input) node.getConnection(index)).getIndex();
+			lines[index].setEndX(2 * NODE_RADIUS);
+			lines[index].setEndY(inputIndex * (2 * NODE_RADIUS + SPACING) + NODE_RADIUS);
+		}
+	}
+
+	/**
+	 * Updates the end of all lines to match the associated connections. 
+	 */
+	public void updateLines() {
+		for (int c = 0; c < lines.length; c++) {
+			updateLine(c);
+		}
+	}
+	
+	/**
+	 * Toggle visibility of all connection lines.
+	 * 
+	 * @param value whether to show the lines or not.
+	 */
+	private void showLines(boolean value) {
+		for (int i = 0; i < lines.length; i++) {
+			lines[i].setVisible(value);
+		}
+	}
+
+	@Override
+	public Node getGene() {
+		return node;
+	}
+
+
+	@Override
+	public void setConnections(GUIGeneState newState) {
+		for (int i = 0; i < lines.length; i++) {
+			if (node.getConnection(i) instanceof Node) {
+				parent.getGuiNode(((Node) node.getConnection(i)).getRow(), ((Node) node.getConnection(i)).getColumn()).setState(newState);
+			} else if (node.getConnection(i) instanceof Input) {
+				parent.getGuiInput(((Input) node.getConnection(i)).getIndex()).setState(newState);
+			}
+		}
+	}
+	
+	/**
+	 * This method sets the connection currently being changed to the 
+	 * specified value.
+	 */
+	public void setChangingConnection(Connection newConnection) {
+		node.setConnection(connectionIndex, newConnection);
+	}
+
+
+	@Override
+	public void resetState() {
+		stateProperty.set(GUIGeneState.NEUTRAL);
+		setConnections(GUIGeneState.NEUTRAL);
+	}
+	
+}
diff --git a/src/jcgp/gui/population/GUIOutput.java b/src/jcgp/gui/population/GUIOutput.java
new file mode 100644
index 0000000..602a022
--- /dev/null
+++ b/src/jcgp/gui/population/GUIOutput.java
@@ -0,0 +1,277 @@
+package jcgp.gui.population;
+
+import javafx.beans.value.ChangeListener;
+import javafx.beans.value.ObservableValue;
+import javafx.event.EventHandler;
+import javafx.geometry.VPos;
+import javafx.scene.control.Label;
+import javafx.scene.input.MouseDragEvent;
+import javafx.scene.input.MouseEvent;
+import javafx.scene.paint.Paint;
+import javafx.scene.shape.Circle;
+import javafx.scene.shape.Line;
+import javafx.scene.text.Font;
+import javafx.scene.text.Text;
+import javafx.scene.text.TextAlignment;
+import jcgp.GUI;
+import jcgp.CGP.Resources;
+import jcgp.population.Connection;
+import jcgp.population.Input;
+import jcgp.population.Node;
+import jcgp.population.Output;
+
+public class GUIOutput extends GUIGene {
+
+	private Circle socket;
+
+	private Label connectionLabel;
+
+	private Line sourceLine;
+
+	private Output output;
+
+	public GUIOutput(ChromosomePane parentRef, final Output output, Resources resources, Line line) {
+
+		this.parent = parentRef;
+		this.output = output;
+		this.sourceLine = line;
+
+		relocate((((int) resources.get("columns") + 1) * (2 * NODE_RADIUS + SPACING)) + NODE_RADIUS,
+				(output.getIndex() * (2 * NODE_RADIUS + SPACING)) + NODE_RADIUS);
+		
+		// set the line ends correctly
+		updateLine();
+
+		mainCircle = new Circle(NODE_RADIUS, Paint.valueOf("white"));
+		mainCircle.setStroke(Paint.valueOf("black"));
+
+		text = new Text("O: " + output.getIndex());
+		text.setFont(Font.font("Arial", 12));
+		text.setTextOrigin(VPos.CENTER);
+		text.setTextAlignment(TextAlignment.CENTER);
+		text.setWrappingWidth(NODE_RADIUS * 2);
+		text.setX(-NODE_RADIUS);
+		text.setVisible(true);
+
+		socket = new Circle(-NODE_RADIUS, 0, SOCKET_RADIUS, Paint.valueOf("white"));
+		socket.setId(String.valueOf(0));
+		socket.setStroke(Paint.valueOf("black"));
+		
+		connectionLabel = new Label("S");
+		connectionLabel.setStyle("-fx-background-color:rgb(255, 255, 255); -fx-border-color:rgba(0, 0, 0, 0.5); ");
+		connectionLabel.relocate(socket.getCenterX() + 5, socket.getCenterY() - 10);
+		connectionLabel.setVisible(false);
+
+		/*
+		 * Mouse event handlers on sockets
+		 * 
+		 */
+		socket.addEventFilter(MouseDragEvent.DRAG_DETECTED, new EventHandler<MouseEvent>() {
+			@Override
+			public void handle(MouseEvent event) {
+				// the mouse has been dragged out of the socket, this means a full drag is in progress
+				startFullDrag();
+			}
+		});
+
+		socket.addEventFilter(MouseEvent.MOUSE_ENTERED, new EventHandler<MouseEvent>() {
+			@Override
+			public void handle(MouseEvent event) {
+				// user is hovering over connection socket
+				connectionLabel.setVisible(true);
+			}
+		});
+
+		socket.addEventFilter(MouseEvent.MOUSE_EXITED, new EventHandler<MouseEvent>() {
+			@Override
+			public void handle(MouseEvent event) {
+				// user exits the connection socket
+				connectionLabel.setVisible(false);
+			}
+		});
+
+		socket.addEventFilter(MouseDragEvent.MOUSE_PRESSED, new EventHandler<MouseEvent>() {
+			@Override
+			public void handle(MouseEvent event) {
+				// mouse was pressed on the socket
+				stateProperty.set(GUIGeneState.SOURCE);
+			}
+		});
+
+		socket.addEventFilter(MouseDragEvent.MOUSE_DRAGGED, new EventHandler<MouseEvent>() {
+			@Override
+			public void handle(MouseEvent event) {
+				sourceLine.setEndX(event.getX() + ((Circle) event.getSource()).getParent().getLayoutX());
+				sourceLine.setEndY(event.getY() + ((Circle) event.getSource()).getParent().getLayoutY());
+			}
+		});	
+
+		socket.addEventFilter(MouseDragEvent.MOUSE_RELEASED, new EventHandler<MouseEvent>() {
+			@Override
+			public void handle(MouseEvent event) {
+				if (event.isDragDetect()) {
+					// mouse was released before dragging out of the socket
+					updateLine();
+					stateProperty.set(GUIGeneState.HOVER);
+				}
+			}
+		});
+
+		
+		/*
+		 * Mouse event handlers on whole gene
+		 */
+		addEventFilter(MouseDragEvent.MOUSE_DRAG_ENTERED, new EventHandler<MouseDragEvent>() {
+			@Override
+			public void handle(MouseDragEvent event) {
+				// the drag has entered this node, react appropriately
+				stateProperty.set(GUIGeneState.FORBIDDEN_TARGET);
+			}
+		});
+
+		addEventFilter(MouseDragEvent.MOUSE_DRAG_OVER, new EventHandler<MouseDragEvent>() {
+			@Override
+			public void handle(MouseDragEvent event) {
+				// the user is dragging over this node, react appropriately
+				// this happens even if we are the source of the drag
+				
+			}
+		});
+		
+		addEventFilter(MouseDragEvent.MOUSE_DRAG_EXITED, new EventHandler<MouseDragEvent>() {
+			@Override
+			public void handle(MouseDragEvent event) {
+				// the drag has exited this node, react appropriately
+				// this happens even if we are the source of the drag
+				if (event.isPrimaryButtonDown()) {
+					if (event.getGestureSource() == event.getSource()) {
+						stateProperty.set(GUIGeneState.SOURCE);
+					} else {
+						if (stateProperty.get() == GUIGeneState.NO_CHANGE_TARGET) {
+							stateProperty.set(GUIGeneState.INDIRECT_HOVER);
+						} else {
+							stateProperty.set(GUIGeneState.NEUTRAL);
+						}
+					}
+				}
+			}
+		});
+		
+		addEventFilter(MouseDragEvent.MOUSE_DRAG_RELEASED, new EventHandler<MouseDragEvent>() {
+			@Override
+			public void handle(MouseDragEvent event) {
+				// making a connection to an output is illegal
+				// set states to reflect the new situation
+				((GUIGene) event.getGestureSource()).setState(GUIGeneState.NEUTRAL);
+				((GUIGene) event.getGestureSource()).setConnections(GUIGeneState.NEUTRAL);
+				stateProperty.set(GUIGeneState.HOVER);
+			}
+		});
+		
+		
+		addEventFilter(MouseEvent.MOUSE_ENTERED, new EventHandler<MouseEvent>() {
+			@Override
+			public void handle(MouseEvent event) {
+				// cursor has entered this node without dragging, or it is dragging and this is the source
+				if (stateProperty.get() == GUIGeneState.NEUTRAL) {
+					stateProperty.set(GUIGeneState.HOVER);
+				}
+			}
+		});
+		
+		addEventFilter(MouseEvent.MOUSE_EXITED, new EventHandler<MouseEvent>() {
+			@Override
+			public void handle(MouseEvent event) {
+				// cursor has left this node without dragging, or it is dragging and this is the source
+				if (stateProperty.get() == GUIGeneState.HOVER) {
+					stateProperty.set(GUIGeneState.NEUTRAL);
+					setConnections(GUIGeneState.NEUTRAL);
+				}
+			}
+		});
+		
+
+		getChildren().addAll(mainCircle, text, socket, connectionLabel);
+
+		stateProperty.addListener(new ChangeListener<GUIGeneState>() {
+			@Override
+			public void changed(ObservableValue<? extends GUIGeneState> observable,	GUIGeneState oldValue, GUIGeneState newValue) {
+
+
+				switch (newValue) {
+				case ACTIVE_HOVER:
+					break;
+				case FORBIDDEN_TARGET:
+					mainCircle.setFill(Paint.valueOf(GUI.BAD_SELECTION_COLOUR));
+					break;
+				case HOVER:
+					mainCircle.setFill(Paint.valueOf(GUI.HARD_HIGHLIGHT_COLOUR));
+					sourceLine.setVisible(true);
+					setConnections(GUIGeneState.ACTIVE_HOVER);
+					break;
+				case INDIRECT_HOVER:
+					mainCircle.setFill(Paint.valueOf(GUI.SOFT_HIGHLIGHT_COLOUR));
+					break;
+				case NEUTRAL:
+					mainCircle.setFill(Paint.valueOf(GUI.NEUTRAL_COLOUR));
+					sourceLine.setVisible(false);
+					break;
+				case NO_CHANGE_TARGET:
+					mainCircle.setFill(Paint.valueOf(GUI.NEUTRAL_SELECTION_COLOUR));
+					break;
+				case SOURCE:
+					mainCircle.setFill(Paint.valueOf(GUI.HARD_HIGHLIGHT_COLOUR));
+					break;
+				case TARGET:
+					mainCircle.setFill(Paint.valueOf(GUI.GOOD_SELECTION_COLOUR));
+					break;
+				default:
+					break;
+				
+				}
+			}
+		});
+		
+		output.sourceProperty().addListener(new ChangeListener<Connection>() {
+			@Override
+			public void changed(ObservableValue<? extends Connection> observable,
+					Connection oldValue, Connection newValue) {
+				updateLine();
+			}
+		});
+
+	}
+
+	public void updateLine() {
+		if (output.getSource() instanceof Node) {
+			int row = ((Node) output.getSource()).getRow(), 
+					column = ((Node) output.getSource()).getColumn();
+			sourceLine.setEndX(((column + 1) * (2 * NODE_RADIUS + SPACING)) + 2 * NODE_RADIUS);
+			sourceLine.setEndY((row * (2 * NODE_RADIUS + SPACING)) + NODE_RADIUS);
+		} else if (output.getSource() instanceof Input) {
+			int inputIndex = ((Input) output.getSource()).getIndex();
+			sourceLine.setEndX(2 * NODE_RADIUS);
+			sourceLine.setEndY(inputIndex * (2 * NODE_RADIUS + SPACING) + NODE_RADIUS);
+		}
+	}
+
+	@Override
+	public Output getGene() {
+		return output;
+	}
+
+	@Override
+	public void setConnections(GUIGeneState newState) {
+		if (output.getSource() instanceof Node) {
+			parent.getGuiNode(((Node) output.getSource()).getRow(), ((Node) output.getSource()).getColumn()).setState(newState);
+		} else if (output.getSource() instanceof Input) {
+			parent.getGuiInput(((Input) output.getSource()).getIndex()).setState(newState);
+		}
+	}
+
+	@Override
+	public void resetState() {
+		stateProperty.set(GUIGeneState.NEUTRAL);
+		setConnections(GUIGeneState.NEUTRAL);
+	}
+}
diff --git a/src/jcgp/modules/Module.java b/src/jcgp/modules/Module.java
index b8d44d2..5ce96b9 100644
--- a/src/jcgp/modules/Module.java
+++ b/src/jcgp/modules/Module.java
@@ -1,14 +1,11 @@
 package jcgp.modules;
 
+import java.util.HashMap;
+
+import jcgp.CGP.Resources;
 import jcgp.parameters.Parameter;
-import jcgp.parameters.Parameters;
 
-public abstract class Module {
+public interface Module {
 
-	/**
-	 * Register a new parameter
-	 */
-	protected final void registerParameter(String key, Parameter value) {
-		Parameters.add(key, value);
-	};
+	public HashMap<String, Parameter> activate(Resources parameters);
 }
diff --git a/src/jcgp/modules/ea/EvolutionaryAlgorithm.java b/src/jcgp/modules/ea/EvolutionaryAlgorithm.java
index 8de8c87..d3fa709 100644
--- a/src/jcgp/modules/ea/EvolutionaryAlgorithm.java
+++ b/src/jcgp/modules/ea/EvolutionaryAlgorithm.java
@@ -1,12 +1,14 @@
 package jcgp.modules.ea;
 
+import jcgp.CGP.Resources;
+import jcgp.modules.Module;
 import jcgp.modules.mutator.Mutator;
 import jcgp.population.Chromosome;
 import jcgp.population.Population;
 
-public interface EvolutionaryAlgorithm {
+public interface EvolutionaryAlgorithm extends Module {
 
-	public abstract void evolve(Population population, Mutator mutator);
+	public abstract void evolve(Population population, Mutator mutator, Resources parameters);
 
 	public abstract Chromosome getFittestChromosome();
 
diff --git a/src/jcgp/modules/ea/StandardEA.java b/src/jcgp/modules/ea/StandardEA.java
index 2db8776..f2473f5 100644
--- a/src/jcgp/modules/ea/StandardEA.java
+++ b/src/jcgp/modules/ea/StandardEA.java
@@ -1,14 +1,16 @@
 package jcgp.modules.ea;
 
+import java.util.HashMap;
+
+import jcgp.CGP.Resources;
 import jcgp.modules.mutator.Mutator;
-import jcgp.parameters.Parameters;
 import jcgp.parameters.IntegerParameter;
-import jcgp.parameters.BooleanParameter;
+import jcgp.parameters.Parameter;
 import jcgp.population.Chromosome;
 import jcgp.population.Population;
 
 /**
- * (1 + λ) EA.
+ * (μ + λ) EA.
  * 
  * 
  * @author Eduardo Pedroni
@@ -17,28 +19,38 @@ import jcgp.population.Population;
 public class StandardEA implements EvolutionaryAlgorithm {
 	
 	private Chromosome fittestChromosome;
+	
+	private IntegerParameter parents, offspring;
+	private HashMap<String, Parameter> localParameters;
+	
+	public StandardEA() {		
+		parents = new IntegerParameter(1, "Parents");
+		offspring = new IntegerParameter(4, "Offspring");		
+		
+		localParameters = new HashMap<String, Parameter>();
+		
+		localParameters.put("mu", parents);
+		localParameters.put("lambda", offspring);
+	}
 
 	@Override
-	public void evolve(Population population, Mutator mutator) {
+	public void evolve(Population population, Mutator mutator, Resources parameters) {
 		// select fittest chromosome
 		int fittest = 0;
 		
-		for (int i = 1; i < ((IntegerParameter) Parameters.get("population")).getValue(); i++) {
+		for (int i = 1; i < (int) parameters.get("popSize"); i++) {
 			if (population.getChromosome(i).getFitness() >= population.getChromosome(fittest).getFitness()) {
 				fittest = i;
 			}
 		}
 		fittestChromosome = population.getChromosome(fittest);
 		population.setBestIndividual(fittest);
-		if (((BooleanParameter) Parameters.get("debug")).getValue()) {
-			System.out.println("Best fitness: " + fittestChromosome.getFitness());
-		}
 		// create copies of fittest chromosome, mutate them
 		Chromosome fc = population.getChromosome(fittest);
-		for (int i = 0; i < ((IntegerParameter) Parameters.get("population")).getValue(); i++) {
+		for (int i = 0; i < (int) parameters.get("popSize"); i++) {
 			if (i != fittest) {
 				population.getChromosome(i).copyConnections(fc);
-				mutator.mutate(population.getChromosome(i));
+				mutator.mutate(population.getChromosome(i), parameters);
 			}
 		}
 	}
@@ -47,4 +59,11 @@ public class StandardEA implements EvolutionaryAlgorithm {
 	public Chromosome getFittestChromosome() {
 		return fittestChromosome;
 	}
+
+	@Override
+	public HashMap<String, Parameter> activate(Resources parameters) {
+		parameters.setManagedParameter("popSize", true);
+		
+		return localParameters;
+	}
 }
diff --git a/src/jcgp/modules/fitness/FitnessFunction.java b/src/jcgp/modules/fitness/FitnessFunction.java
index 8ed1b56..509c230 100644
--- a/src/jcgp/modules/fitness/FitnessFunction.java
+++ b/src/jcgp/modules/fitness/FitnessFunction.java
@@ -1,9 +1,11 @@
 package jcgp.modules.fitness;
 
+import jcgp.CGP.Resources;
+import jcgp.modules.Module;
 import jcgp.population.Population;
 
-public interface FitnessFunction {
+public interface FitnessFunction extends Module {
 
-	public void evaluate(Population population);
+	public void evaluate(Population population, Resources resources);
 	
 }
diff --git a/src/jcgp/modules/fitness/TestCase.java b/src/jcgp/modules/fitness/TestCase.java
index 0cb09f1..081a257 100644
--- a/src/jcgp/modules/fitness/TestCase.java
+++ b/src/jcgp/modules/fitness/TestCase.java
@@ -1,26 +1,13 @@
 package jcgp.modules.fitness;
 
-import jcgp.exceptions.ParameterMismatchException;
-import jcgp.parameters.Parameters;
-
 public class TestCase {
 
 	private Object[] inputs;
 	private Object[] outputs;
 	
-	public TestCase(Object[] inputs, Object[] outputs) throws ParameterMismatchException {
-		if (inputs.length == Parameters.getInputs()) {
-			this.inputs = inputs;
-		} else {
-			throw new ParameterMismatchException();
-		}
-		
-		if (outputs.length == Parameters.getOutputs()) {
-			this.outputs = outputs;
-		} else {
-			throw new ParameterMismatchException();
-		}
-		
+	public TestCase(Object[] inputs, Object[] outputs) {
+		this.inputs = inputs;
+		this.outputs = outputs;
 	}
 	
 	public Object getInput(int index) {
diff --git a/src/jcgp/modules/fitness/TestCaseEvaluator.java b/src/jcgp/modules/fitness/TestCaseEvaluator.java
new file mode 100644
index 0000000..1dade74
--- /dev/null
+++ b/src/jcgp/modules/fitness/TestCaseEvaluator.java
@@ -0,0 +1,34 @@
+package jcgp.modules.fitness;
+
+import java.util.HashMap;
+
+import jcgp.CGP.Resources;
+import jcgp.parameters.Parameter;
+import jcgp.population.Population;
+
+public class TestCaseEvaluator implements FitnessFunction {
+	
+	@Override
+	public void evaluate(Population population, Resources resources) {
+		// for every chromosome in the population
+		for (int i = 0; i < (int) resources.get("popSize"); i++) {
+			int fitness = 0;
+			// for every test case
+			for (int t = 0; t < resources.getTestCaseCount(); t++) {
+				population.getChromosome(i).setInputs(resources.getTestCase(t).getInputs());
+				// check every output
+				for (int o = 0; o < (int) resources.get("outputs"); o++) {
+					if (population.getChromosome(i).getOutput(o).calculate() == resources.getTestCase(t).getOutput(o)) {
+						fitness++;
+					}
+				}
+			}
+			population.getChromosome(i).setFitness(fitness);
+		}
+	}
+
+	@Override
+	public HashMap<String, Parameter> activate(Resources parameters) {
+		return new HashMap<String, Parameter>();
+	}
+}
diff --git a/src/jcgp/modules/fitness/TruthTableEvaluator.java b/src/jcgp/modules/fitness/TruthTableEvaluator.java
deleted file mode 100644
index a69de96..0000000
--- a/src/jcgp/modules/fitness/TruthTableEvaluator.java
+++ /dev/null
@@ -1,30 +0,0 @@
-package jcgp.modules.fitness;
-
-import jcgp.TruthTable;
-import jcgp.parameters.Parameters;
-import jcgp.population.Population;
-
-public class TruthTableEvaluator implements FitnessFunction {
-
-	@Override
-	public void evaluate(Population population) {
-		// for every chromosome in the population
-		for (int i = 0; i < Parameters.getPopulationSize(); i++) {
-			int fitness = 0;
-			// for every test case
-			for (int t = 0; t < TruthTable.getTestCaseCount(); t++) {
-				population.getChromosome(i).setInputs(TruthTable.getTestCase(t).getInputs());
-				// check every output
-				for (int o = 0; o < Parameters.getOutputs(); o++) {
-					if (population.getChromosome(i).getOutput(o).calculate() == TruthTable.getTestCase(t).getOutput(o)) {
-						fitness++;
-					}
-				}
-			}
-			population.getChromosome(i).setFitness(fitness);
-			if (Parameters.getDebug()) {
-				System.out.println("active nodes: " + population.getChromosome(i).getActiveNodes().size());
-			}
-		}
-	}
-}
diff --git a/src/jcgp/modules/function/FunctionSet.java b/src/jcgp/modules/function/FunctionSet.java
deleted file mode 100644
index fb3724f..0000000
--- a/src/jcgp/modules/function/FunctionSet.java
+++ /dev/null
@@ -1,45 +0,0 @@
-package jcgp.modules.function;
-
-/**
- * 
- * TODO: if function set flexibility is desired (i.e. add more functions as the program runs)
- * an add function method should be created
- * this would lead to concurrency problems, so tread lightly!
- * 
- * 
- * @author Eduardo Pedroni
- *
- */
-public class FunctionSet {
-		private Function[] functionList;
-		private int maxArity = 0;
-		private String name;
-		
-		public FunctionSet(String name, Function ... functions) {
-			functionList = functions;
-			for (Function function : functionList) {
-				if (function.getArity() > maxArity) {
-					maxArity = function.getArity();
-				}
-			}
-			
-			this.name = name;
-			
-		}
-		
-		public int getFunctionCount() {
-			return functionList.length;
-		}
-		
-		public Function getFunction(int index) {
-			return functionList[index];
-		}
-		
-		public int getMaxArity(){
-			return maxArity;
-		}
-		
-		public String getName() {
-			return name;
-		}
-	}
\ No newline at end of file
diff --git a/src/jcgp/modules/mutator/Mutator.java b/src/jcgp/modules/mutator/Mutator.java
index 10df8cd..5234f45 100644
--- a/src/jcgp/modules/mutator/Mutator.java
+++ b/src/jcgp/modules/mutator/Mutator.java
@@ -1,9 +1,11 @@
 package jcgp.modules.mutator;
 
+import jcgp.CGP.Resources;
+import jcgp.modules.Module;
 import jcgp.population.Chromosome;
 
-public interface Mutator {
+public interface Mutator extends Module {
 
-	void mutate(Chromosome chromosome);
+	void mutate(Chromosome chromosome, Resources parameters);
 	
 }
diff --git a/src/jcgp/modules/mutator/PointMutator.java b/src/jcgp/modules/mutator/PointMutator.java
index b06d678..ea1ed32 100644
--- a/src/jcgp/modules/mutator/PointMutator.java
+++ b/src/jcgp/modules/mutator/PointMutator.java
@@ -1,36 +1,49 @@
 package jcgp.modules.mutator;
 
-import jcgp.Utilities;
-import jcgp.parameters.IntegerParameter;
-import jcgp.parameters.Parameters;
+import java.util.HashMap;
+
+import jcgp.parameters.DoubleParameter;
+import jcgp.parameters.Parameter;
+import jcgp.CGP.Resources;
 import jcgp.population.Chromosome;
 import jcgp.population.MutableElement;
 import jcgp.population.Node;
 import jcgp.population.Output;
 
 public class PointMutator implements Mutator {
-
+	
+	private Parameter mutationRate;
+	private HashMap<String, Parameter> localParameters;
+	
 	public PointMutator() {
-		Parameters.add("mutRate", new IntegerParameter(10, "Mutation rate"));
+		mutationRate = new DoubleParameter(0.5, "Percent mutation");
+		
+		localParameters = new HashMap<String, Parameter>();
+		localParameters.put("mutRate", mutationRate);
 	}
-	
+
 	@Override
-	public void mutate(Chromosome chromosome) {
-		int mutations = (int) (((int) Parameters.get("mutRate").getValue()) * ((((double) Parameters.get("nodes").getValue()) + ((double) Parameters.get("outputs").getValue())) / 100));
-		
+	public void mutate(Chromosome chromosome, Resources resources) {
+		int mutations = (int) Math.ceil((((double) mutationRate.getValue()) * (((((Integer) resources.get("nodes")).doubleValue() + ((Integer) resources.get("outputs")).doubleValue())) / (double) 100)));
 		for (int i = 0; i < mutations; i++) {
 			MutableElement m = chromosome.getRandomMutableElement();
 			
 			if (m instanceof Output) {
-				m.setConnection(chromosome.getRandomConnection());
+				m.setConnection(0, chromosome.getRandomConnection());
 			} else if (m instanceof Node) {
-				int geneType = Utilities.getRandomInt(1 + ((int) Parameters.get("Max arity").getValue()));
+				int geneType = resources.getRandomInt(1 + ((int) resources.get("arity")));
 				if (geneType < 1) {
-					((Node) m).setFunction(Utilities.getRandomFunction());
+					((Node) m).setFunction(resources.getRandomFunction());
 				} else {
-					m.setConnection(chromosome.getRandomConnection(((Node) m).getColumn()));
+					m.setConnection(resources.getRandomInt((int) resources.get("arity")), chromosome.getRandomConnection(((Node) m).getColumn()));
 				}
 			}
 		}
 	}
+
+	@Override
+	public HashMap<String, Parameter> activate(Resources parameters) {
+		return localParameters;
+	}
+
 }
diff --git a/src/jcgp/parameters/BooleanParameter.java b/src/jcgp/parameters/BooleanParameter.java
index aff0bc5..0f339a1 100644
--- a/src/jcgp/parameters/BooleanParameter.java
+++ b/src/jcgp/parameters/BooleanParameter.java
@@ -3,34 +3,30 @@ package jcgp.parameters;
 import javafx.beans.property.SimpleBooleanProperty;
 
 public class BooleanParameter extends Parameter {
-	
-	SimpleBooleanProperty value;
-		
+			
 	public BooleanParameter(boolean value, String name) {
+		super(name);
 		this.value = new SimpleBooleanProperty(value);
-		this.name = name;
 	}
 	
 	public BooleanParameter(boolean value, String name, boolean managed, boolean hidden) {
+		super(name, managed, hidden);
 		this.value = new SimpleBooleanProperty(value);
-		this.name = name;
-		this.managed = managed;
-		this.hidden = hidden;
 	}
 	
 	@Override
-	public Object getValue() {
-		return this.value.get();
+	public Boolean getValue() {
+		return ((SimpleBooleanProperty) this.value).get();
 	}
 	
 	@Override
 	public SimpleBooleanProperty valueProperty() {
-		return value;
+		return (SimpleBooleanProperty) value;
 	}
 
 	@Override
 	public void setValue(Object value) {
-		this.value.set((boolean) value);
+		((SimpleBooleanProperty) this.value).set((boolean) value);
 	}
 	
 }
diff --git a/src/jcgp/parameters/DoubleParameter.java b/src/jcgp/parameters/DoubleParameter.java
index 2725457..ade99cc 100644
--- a/src/jcgp/parameters/DoubleParameter.java
+++ b/src/jcgp/parameters/DoubleParameter.java
@@ -3,37 +3,30 @@ package jcgp.parameters;
 import javafx.beans.property.SimpleDoubleProperty;
 
 public class DoubleParameter extends Parameter {
-	
-	SimpleDoubleProperty value;
-		
+			
 	public DoubleParameter(double value, String name) {
+		super(name);
 		this.value = new SimpleDoubleProperty(value);
-		this.name = name;
 	}
 	
 	public DoubleParameter(double value, String name, boolean managed, boolean hidden) {
+		super(name, managed, hidden);
 		this.value = new SimpleDoubleProperty(value);
-		this.name = name;
-		this.managed = managed;
-		this.hidden = hidden;
-	}
-	
-	public void setValue(double value) {
-		this.value.set(value);
 	}
 	
 	@Override
-	public Object getValue() {
-		return this.value.get();
+	public Double getValue() {
+		return ((SimpleDoubleProperty) value).get();
 	}
 	
+	@Override
 	public SimpleDoubleProperty valueProperty() {
-		return value;
+		return (SimpleDoubleProperty) value;
 	}
 
 	@Override
 	public void setValue(Object value) {
-		this.value.set((double) value);
+		((SimpleDoubleProperty) this.value).set((double) value);
 		
 	}
 	
diff --git a/src/jcgp/parameters/IntegerParameter.java b/src/jcgp/parameters/IntegerParameter.java
index f0109f7..cc60179 100644
--- a/src/jcgp/parameters/IntegerParameter.java
+++ b/src/jcgp/parameters/IntegerParameter.java
@@ -3,39 +3,30 @@ package jcgp.parameters;
 import javafx.beans.property.SimpleIntegerProperty;
 
 public class IntegerParameter extends Parameter {
-		
-	SimpleIntegerProperty value;
 	
 	public IntegerParameter(int value, String name) {
+		super(name);
 		this.value = new SimpleIntegerProperty(value);
-		this.name = name;
 	}
 	
 	public IntegerParameter(int value, String name, boolean managed, boolean hidden) {
+		super(name, managed, hidden);
 		this.value = new SimpleIntegerProperty(value);
-		this.name = name;
-		this.managed = managed;
-		this.hidden = hidden;
-	}
-	
-	public void setValue(int value) {
-		this.value.set(value);
 	}
 	
 	@Override
-	public Object getValue() {
-		return this.value.get();
+	public Integer getValue() {
+		return ((SimpleIntegerProperty) this.value).get();
 	}
 	
 	@Override
 	public SimpleIntegerProperty valueProperty() {
-		return value;
+		return (SimpleIntegerProperty) value;
 	}
 
 	@Override
 	public void setValue(Object value) {
-		this.value.set((int) value);
-		
+		((SimpleIntegerProperty) this.value).set((int) value);
 	}
 	
 }
diff --git a/src/jcgp/parameters/Parameter.java b/src/jcgp/parameters/Parameter.java
index 64b19c8..fcff9fd 100644
--- a/src/jcgp/parameters/Parameter.java
+++ b/src/jcgp/parameters/Parameter.java
@@ -1,13 +1,28 @@
 package jcgp.parameters;
 
 import javafx.beans.property.Property;
-
 public abstract class Parameter {
 	
 	protected boolean managed = false;
 	protected boolean hidden = false;
+	
+	protected boolean originalManaged = false;
+	protected boolean originalHidden = false;
+	
+	protected Property<?> value;
+	
 	protected String name;
 	
+	public Parameter(String name, boolean managed, boolean hidden) {
+		this.name = name;
+		this.managed = originalManaged = managed;
+		this.hidden = originalHidden = hidden;
+	}
+	
+	public Parameter(String name) {
+		this.name = name;
+	}
+	
 	public void setManaged(boolean value) {
 		managed = value;
 	}
@@ -32,6 +47,12 @@ public abstract class Parameter {
 	
 	public abstract void setValue(Object value);
 	
-	@SuppressWarnings("rawtypes")
-	public abstract Property valueProperty();
+	public Property<?> valueProperty() {
+		return value;
+	}
+
+	public void reset() {
+		hidden = originalHidden;
+		managed = originalManaged;
+	}
 }
diff --git a/src/jcgp/population/Chromosome.java b/src/jcgp/population/Chromosome.java
index 1f0b312..a7f2ed3 100644
--- a/src/jcgp/population/Chromosome.java
+++ b/src/jcgp/population/Chromosome.java
@@ -2,11 +2,12 @@ package jcgp.population;
 
 import java.util.ArrayList;
 
-import jcgp.Utilities;
+import jcgp.CGP.Resources;
 import jcgp.exceptions.ParameterMismatchException;
-import jcgp.parameters.Parameters;
 
 public class Chromosome {
+	
+	private Resources resources;
 
 	private Input[] inputs;
 	private Node[][] nodes;
@@ -21,13 +22,12 @@ public class Chromosome {
 	 * Initialise a chromosome with the specified parameters. Random valid connections
 	 * are created.
 	 * 
-	 * @param outputs 
-	 * @param columns 
-	 * @param rows 
-	 * @param inputs 
 	 * 
 	 */
-	public Chromosome() {
+	public Chromosome(Resources resources) {
+		// store a reference to the parameters
+		this.resources = resources;
+		
 		// allocate memory for all elements of the chromosome
 		instantiateElements();
 		// set random connections so that the chromosome can be evaluated
@@ -42,6 +42,9 @@ public class Chromosome {
 	 * @param clone the chromosome to be copied
 	 */
 	public Chromosome(Chromosome clone) {
+		// store a reference to the parameters
+		this.resources = clone.getParameters();
+		
 		// allocate memory for all elements of the chromosome
 		instantiateElements();
 		// initialise all connections based on argument
@@ -52,20 +55,22 @@ public class Chromosome {
 	 *
 	 */
 	private void instantiateElements() {
-		inputs = new Input[((int) Parameters.get("inputs").getValue())];
-		for (int i = 0; i < ((int) Parameters.get("inputs").getValue()); i++) {
+		inputs = new Input[((int) resources.get("inputs"))];
+		for (int i = 0; i < ((int) resources.get("inputs")); i++) {
 			inputs[i] = new Input(i);
 		}
 
+		int arity = (int) resources.get("arity");
+		
 		// rows first
-		nodes = new Node[((int) Parameters.get("rows").getValue())][((int) Parameters.get("columns").getValue())];
-		for (int r = 0; r < ((int) Parameters.get("rows").getValue()); r++) {
-			for (int c = 0; c < ((int) Parameters.get("columns").getValue()); c++) {
-				nodes[r][c] = new Node(this, r, c);
+		nodes = new Node[((int) resources.get("rows"))][((int) resources.get("columns"))];
+		for (int r = 0; r < ((int) resources.get("rows")); r++) {
+			for (int c = 0; c < ((int) resources.get("columns")); c++) {
+				nodes[r][c] = new Node(this, r, c, arity);
 			}
 		}
-		outputs = new Output[((int) Parameters.get("outputs").getValue())];
-		for (int o = 0; o < ((int) Parameters.get("outputs").getValue()); o++) {
+		outputs = new Output[((int) resources.get("outputs"))];
+		for (int o = 0; o < ((int) resources.get("outputs")); o++) {
 			outputs[o] = new Output(this, o);
 		}
 	}
@@ -75,19 +80,21 @@ public class Chromosome {
 	 */
 	private void initialiseConnections() {
 
+		int arity = (int) resources.get("arity");
+		
 		// initialise nodes - [rows][columns]
 		for (int r = 0; r < nodes.length; r++) {
 			for (int c = 0; c < nodes[r].length; c++) {
-				Connection[] connections = new Connection[((int) Parameters.get("maxArity").getValue())];
+				Connection[] connections = new Connection[arity];
 				for (int i = 0; i < connections.length; i++) {
 					connections[i] = getRandomConnection(c);
 				}
-				nodes[r][c].initialise(Utilities.getRandomFunction(), connections);
+				nodes[r][c].initialise(resources.getRandomFunction(), connections);
 			}
 		}
 
 		for (Output output : outputs) {
-			output.setConnection(getRandomConnection());
+			output.setConnection(0, getRandomConnection());
 		}
 
 	}
@@ -96,11 +103,13 @@ public class Chromosome {
 	 * @param clone
 	 */
 	public void copyConnections(Chromosome clone) {
+		int arity = (int) resources.get("arity");
+		
 		// copy nodes - [rows][columns]
 		for (int r = 0; r < nodes.length; r++) {
 			for (int c = 0; c < nodes[r].length; c++) {
 				// make array of connections to initialise with
-				Connection[] connections = new Connection[((int) Parameters.get("maxArity").getValue())];
+				Connection[] connections = new Connection[arity];
 				// populate with connections equivalent to clone
 				Connection copyConnection;
 				for (int i = 0; i < connections.length; i++) {
@@ -123,9 +132,9 @@ public class Chromosome {
 		for (int o = 0; o < outputs.length; o++) {
 			copyOutput = clone.getOutput(o).getSource();
 			if (copyOutput instanceof Input) {
-				outputs[o].setConnection(inputs[((Input) copyOutput).getIndex()]);
+				outputs[o].setConnection(0, inputs[((Input) copyOutput).getIndex()]);
 			} else if (copyOutput instanceof Node) {
-				outputs[o].setConnection(nodes[((Node) copyOutput).getRow()][((Node) copyOutput).getColumn()]);
+				outputs[o].setConnection(0, nodes[((Node) copyOutput).getRow()][((Node) copyOutput).getColumn()]);
 			} else {
 				// something bad happened
 				System.out.println("Warning: Connection of subtype " + copyOutput.getClass().toString() + " is not explicitly handled by copy constructor.");
@@ -177,7 +186,7 @@ public class Chromosome {
 	 */
 	public MutableElement getRandomMutableElement() {
 		// choose output or node
-		int index = Utilities.getRandomInt(outputs.length + ((int) Parameters.get("rows").getValue()) * ((int) Parameters.get("columns").getValue()));
+		int index = resources.getRandomInt(outputs.length + ((int) resources.get("rows")) * ((int) resources.get("columns")));
 
 		if (index < outputs.length) {
 			// outputs
@@ -185,7 +194,7 @@ public class Chromosome {
 		} else {
 			// node	
 			index -= outputs.length;
-			return nodes[index / ((int) Parameters.get("columns").getValue())][index % ((int) Parameters.get("columns").getValue())];
+			return nodes[index / ((int) resources.get("columns"))][index % ((int) resources.get("columns"))];
 		}
 	}
 
@@ -199,11 +208,11 @@ public class Chromosome {
 	 */
 	public Connection getRandomConnection(int column) {
 		// work out the allowed range obeying levels back
-		int allowedColumns = ((column >= ((int) Parameters.get("levelsBack").getValue())) ? ((int) Parameters.get("levelsBack").getValue()) : column);
+		int allowedColumns = ((column >= ((int) resources.get("levelsBack"))) ? ((int) resources.get("levelsBack")) : column);
 		int offset = ((column - allowedColumns) * nodes.length) - inputs.length;
 
 		// choose input or allowed node
-		int index = Utilities.getRandomInt(inputs.length + (nodes.length * allowedColumns));
+		int index = resources.getRandomInt(inputs.length + (nodes.length * allowedColumns));
 		if (index < inputs.length) {
 			// input
 			return inputs[index];
@@ -226,7 +235,7 @@ public class Chromosome {
 	 */
 	public Connection getRandomConnection() {
 		// choose output or node
-		int index = Utilities.getRandomInt(inputs.length + ((int) Parameters.get("columns").getValue()) * ((int) Parameters.get("rows").getValue()));
+		int index = resources.getRandomInt(inputs.length + ((int) resources.get("columns")) * ((int) resources.get("rows")));
 
 		if (index < inputs.length) {
 			// outputs
@@ -234,7 +243,7 @@ public class Chromosome {
 		} else {
 			// node	
 			index -= inputs.length;
-			return nodes[index / ((int) Parameters.get("columns").getValue())][index % ((int) Parameters.get("columns").getValue())];
+			return nodes[index / ((int) resources.get("columns"))][index % ((int) resources.get("columns"))];
 		}
 	}
 
@@ -269,15 +278,15 @@ public class Chromosome {
 	}
 
 	public boolean compareTo(Chromosome chromosome) {
-		for (int r = 0; r < ((int) Parameters.get("rows").getValue()); r++) {
-			for (int c = 0; c < ((int) Parameters.get("columns").getValue()); c++) {
+		for (int r = 0; r < ((int) resources.get("rows")); r++) {
+			for (int c = 0; c < ((int) resources.get("columns")); c++) {
 				if (!(nodes[r][c].copyOf(chromosome.getNode(r, c)))) {
 					return false;
 				}
 			}
 		}
 		
-		for (int o = 0; o < ((int) Parameters.get("outputs").getValue()); o++) {
+		for (int o = 0; o < ((int) resources.get("outputs")); o++) {
 			if (!(outputs[o].copyOf(chromosome.getOutput(o)))) {
 				return false;
 			}
@@ -302,20 +311,26 @@ public class Chromosome {
 	}
 	
 	public void printNodes() {
-		for (int r = 0; r < ((int) Parameters.get("rows").getValue()); r++) {
+		int arity = (int) resources.get("arity");
+		
+		for (int r = 0; r < ((int) resources.get("rows")); r++) {
 			System.out.print("r: " + r + "\t");
-			for (int c = 0; c < ((int) Parameters.get("columns").getValue()); c++) {
+			for (int c = 0; c < ((int) resources.get("columns")); c++) {
 				System.out.print("N: (" + r + ", " + c + ") ");
-				for (int i = 0; i < ((int) Parameters.get("maxArity").getValue()); i++) {
+				for (int i = 0; i < arity; i++) {
 					System.out.print("C" + i + ": (" + nodes[r][c].getConnection(i).getDescription() + ") ");
 				}
-				System.out.print("F: " + nodes[r][c].getFunction().toString() + "\t");
+				System.out.print("F: " + nodes[r][c].getFunction().getName() + "\t");
 			}
 			System.out.print("\n");
 		}
 		
-		for (int o = 0; o < ((int) Parameters.get("outputs").getValue()); o++) {
+		for (int o = 0; o < ((int) resources.get("outputs")); o++) {
 			System.out.print("o: " + o + " (" + outputs[o].getSource().getDescription() + ")\t");
 		}
 	}
+	
+	public Resources getParameters() {
+		return resources;
+	}
 }
diff --git a/src/jcgp/population/Gene.java b/src/jcgp/population/Gene.java
new file mode 100644
index 0000000..8865a01
--- /dev/null
+++ b/src/jcgp/population/Gene.java
@@ -0,0 +1,5 @@
+package jcgp.population;
+
+public abstract class Gene {
+
+}
diff --git a/src/jcgp/population/Input.java b/src/jcgp/population/Input.java
index 5c545d6..cfcb3ce 100644
--- a/src/jcgp/population/Input.java
+++ b/src/jcgp/population/Input.java
@@ -1,6 +1,6 @@
 package jcgp.population;
 
-public class Input implements Connection {
+public class Input extends Gene implements Connection {
 	
 	private Object value = 0;
 	private int index;
diff --git a/src/jcgp/population/MutableElement.java b/src/jcgp/population/MutableElement.java
index 114a4ab..12f6bd1 100644
--- a/src/jcgp/population/MutableElement.java
+++ b/src/jcgp/population/MutableElement.java
@@ -2,8 +2,16 @@ package jcgp.population;
 
 public interface MutableElement {
 	
-	public void setConnection(Connection newConnection);
-
+	/**
+	 * This method sets the indexed connection to the specified new connection.
+	 * Implementing classes may choose to ignore the given index (such as in the
+	 * case of outputs, which only have one connection).
+	 * 
+	 * @param index
+	 * @param newConnection
+	 */
+	public void setConnection(int index, Connection newConnection);
+	
 	/**
 	 * This method returns true if and only if:</br>
 	 * 	- the elements being compared are not the same instance;</br>
@@ -15,7 +23,8 @@ public interface MutableElement {
 	 * The relationship computed by this method is:</br>
 	 *  - symmetric: a.copyOf(b) == b.copyOf(a);</br>
 	 *  - not reflexive: a.copyOf(a) returns false;</br>
-	 *  - not transitive: if a.copyOf(b) is true and b.copyOf(c) is true, a.copyOf(c) is not necessarily true;</br>
+	 *  - not transitive: if a.copyOf(b) is true and b.copyOf(c) is true, a.copyOf(c) is
+	 *    not necessarily true since it is possible that a == c.</br>
 	 * 
 	 * @param m
 	 * @return
diff --git a/src/jcgp/population/Node.java b/src/jcgp/population/Node.java
index 9fafe32..d7013d3 100644
--- a/src/jcgp/population/Node.java
+++ b/src/jcgp/population/Node.java
@@ -1,51 +1,58 @@
 package jcgp.population;
 
 import java.util.ArrayList;
-import java.util.Arrays;
 
-import jcgp.Utilities;
+import javafx.beans.property.SimpleObjectProperty;
 import jcgp.exceptions.InsufficientConnectionsException;
-import jcgp.modules.function.Function;
-import jcgp.parameters.Parameters;
+import jcgp.function.Function;
 
 
-public class Node implements MutableElement, Connection {
+public class Node extends Gene implements MutableElement, Connection {
 
-	private Function function;
-	private Connection[] connections;
+	private SimpleObjectProperty<Function> function;
+	private ArrayList<SimpleObjectProperty<Connection>> connections;
 	private int column, row;
 	private Chromosome chromosome;
 
-	public Node(Chromosome chromosome, int row, int column) {
+	public Node(Chromosome chromosome, int row, int column, int arity) {
+		this.function = new SimpleObjectProperty<Function>();
 		this.chromosome = chromosome;
 		this.column = column;
 		this.row = row;
-		this.connections = new Connection[((int) Parameters.get("maxArity").getValue())];
+		this.connections = new ArrayList<SimpleObjectProperty<Connection>>(arity);
+		for (int c = 0; c < arity; c++) {
+			connections.add(new SimpleObjectProperty<Connection>());
+		}
 	}
 
 	@Override
 	public Object getValue() {
 		//System.out.print("Calculating node: (" + row + ", " + column + ") > ");
-		return function.run(Arrays.copyOfRange(connections, 0, function.getArity()));
+		Connection[] list = new Connection[function.get().getArity()];
+		for (int i = 0; i < list.length; i++) {
+			list[i] = connections.get(i).get();
+		}
+		
+		return function.get().run(list);
 	}
 
 	public void setFunction(Function newFunction) {
-		function = newFunction;
+		function.set(newFunction);
 		chromosome.recomputeActiveNodes();
 	}
 
 	@Override
-	public void setConnection(Connection newConnection) {
-		connections[Utilities.getRandomInt(connections.length)] = newConnection;
+	public void setConnection(int index, Connection newConnection) {
+		connections.get(index).set(newConnection);
 		chromosome.recomputeActiveNodes();
 	}
 
 	public void initialise(Function newFunction, Connection ... newConnections) throws InsufficientConnectionsException {
-
-		function = newFunction;
-
-		if (newConnections.length >= ((int) Parameters.get("maxArity").getValue())) {
-			connections = newConnections;
+		function.set(newFunction);
+		if (newConnections.length >= connections.size()) {
+			for (int i = 0; i < connections.size(); i++) {
+				connections.get(i).set(newConnections[i]);
+			}
 		} else {
 			throw new InsufficientConnectionsException();
 		}
@@ -60,20 +67,28 @@ public class Node implements MutableElement, Connection {
 	}
 
 	public Function getFunction() {
+		return function.get();
+	}
+	
+	public SimpleObjectProperty<Function> functionProperty() {
 		return function;
 	}
 
+	public ArrayList<SimpleObjectProperty<Connection>> connections() {
+		return connections;
+	}
+	
 	public Connection getConnection(int index) {
-		return connections[index];
+		return connections.get(index).get();
 	}
 
 	public void getActive(ArrayList<Node> activeNodes) {
 		if (!activeNodes.contains(this)) {
 			activeNodes.add(this);
 		}
-		for (int i = 0; i < function.getArity(); i++) {
-			if (connections[i] instanceof Node) {
-				((Node) connections[i]).getActive(activeNodes);
+		for (int i = 0; i < function.get().getArity(); i++) {
+			if (connections.get(i).get() instanceof Node) {
+				((Node) connections.get(i).get()).getActive(activeNodes);
 			}
 
 		}
@@ -84,17 +99,17 @@ public class Node implements MutableElement, Connection {
 		if (this != m) {
 			if (m instanceof Node) {
 				Node n = (Node) m;
-				if (function == n.getFunction()) {
+				if (function.get() == n.getFunction()) {
 					if (column == n.getColumn() && row == n.getRow()) {
-						for (int i = 0; i < connections.length; i++) {
-							if (connections[i] != n.getConnection(i)) {
-								if (connections[i] instanceof Input && n.getConnection(i) instanceof Input) {
-									if (((Input) connections[i]).getIndex() != ((Input) n.getConnection(i)).getIndex()) {
+						for (int i = 0; i < connections.size(); i++) {
+							if (connections.get(i).get() != n.getConnection(i)) {
+								if (connections.get(i).get() instanceof Input && n.getConnection(i) instanceof Input) {
+									if (((Input) connections.get(i).get()).getIndex() != ((Input) n.getConnection(i)).getIndex()) {
 										return false;
 									}
-								} else if (connections[i] instanceof Node && n.getConnection(i) instanceof Node) {
-									if (((Node) connections[i]).getRow() != ((Node) n.getConnection(i)).getRow() &&
-											((Node) connections[i]).getColumn() != ((Node) n.getConnection(i)).getColumn()) {
+								} else if (connections.get(i).get() instanceof Node && n.getConnection(i) instanceof Node) {
+									if (((Node) connections.get(i).get()).getRow() != ((Node) n.getConnection(i)).getRow() &&
+											((Node) connections.get(i).get()).getColumn() != ((Node) n.getConnection(i)).getColumn()) {
 										return false;
 									}
 								} else {
diff --git a/src/jcgp/population/Output.java b/src/jcgp/population/Output.java
index ccecae0..b7c6128 100644
--- a/src/jcgp/population/Output.java
+++ b/src/jcgp/population/Output.java
@@ -2,15 +2,18 @@ package jcgp.population;
 
 import java.util.ArrayList;
 
-public class Output implements MutableElement {
+import javafx.beans.property.SimpleObjectProperty;
+
+public class Output extends Gene implements MutableElement {
 	
-	private Connection source;
+	private SimpleObjectProperty<Connection> source;
 	private Chromosome chromosome;
 	private int index;
 	
 	public Output(Chromosome chromosome, int index) {
 		this.chromosome = chromosome;
 		this.index = index;
+		this.source = new SimpleObjectProperty<Connection>();
 	}
 
 	public Object calculate() {
@@ -19,8 +22,8 @@ public class Output implements MutableElement {
 	}
 
 	@Override
-	public void setConnection(Connection newConnection) {
-		source = newConnection;
+	public void setConnection(int index, Connection newConnection) {
+		source.set(newConnection);
 		chromosome.recomputeActiveNodes();
 	}
 
@@ -29,12 +32,16 @@ public class Output implements MutableElement {
 	}
 
 	public Connection getSource() {
+		return source.get();
+	}
+	
+	public SimpleObjectProperty<Connection> sourceProperty() {
 		return source;
 	}
 
 	public void getActiveNodes(ArrayList<Node> activeNodes) {
-		if (source instanceof Node) {
-			((Node) source).getActive(activeNodes);
+		if (source.get() instanceof Node) {
+			((Node) source.get()).getActive(activeNodes);
 		}
 	}
 	
@@ -44,14 +51,14 @@ public class Output implements MutableElement {
 			if (m instanceof Output) {
 				Output o = (Output) m;
 				if (index == o.getIndex()) {
-					if (source != o.getSource()) {
-						if (source instanceof Input && o.getSource() instanceof Input) {
-							if (((Input) source).getIndex() == ((Input) o.getSource()).getIndex()) {
+					if (source.get() != o.getSource()) {
+						if (source.get() instanceof Input && o.getSource() instanceof Input) {
+							if (((Input) source.get()).getIndex() == ((Input) o.getSource()).getIndex()) {
 								return true;
 							}
-						} else if (source instanceof Node && o.getSource() instanceof Node) {
-							if (((Node) source).getRow() == ((Node) o.getSource()).getRow() &&
-									((Node) source).getColumn() == ((Node) o.getSource()).getColumn()) {
+						} else if (source.get() instanceof Node && o.getSource() instanceof Node) {
+							if (((Node) source.get()).getRow() == ((Node) o.getSource()).getRow() &&
+									((Node) source.get()).getColumn() == ((Node) o.getSource()).getColumn()) {
 								return true;
 							}
 						} 
diff --git a/src/jcgp/population/Population.java b/src/jcgp/population/Population.java
index 5718515..bc9c9e8 100644
--- a/src/jcgp/population/Population.java
+++ b/src/jcgp/population/Population.java
@@ -1,14 +1,22 @@
 package jcgp.population;
 
-import jcgp.parameters.Parameters;
+import jcgp.CGP.Resources;
+
 
 public class Population {
 	
 	private Chromosome[] chromosomes;
-	private Chromosome bestIndividual;
+	private int fittest;
+	
+	public Population(Resources parameters) {
+		chromosomes = new Chromosome[((int) parameters.get("popSize"))];
+		for (int c = 0; c < chromosomes.length; c++) {
+			chromosomes[c] = new Chromosome(parameters);
+		}
+	}
 	
-	public Population(Chromosome parent) {
-		chromosomes = new Chromosome[((int) Parameters.get("population").getValue())];
+	public Population(Chromosome parent, Resources parameters) {
+		chromosomes = new Chromosome[((int) parameters.get("popSize"))];
 		// make a clone for safety
 		this.chromosomes[0] = new Chromosome(parent);
 		// generate the rest of the individuals
@@ -16,13 +24,6 @@ public class Population {
 			chromosomes[c] = new Chromosome(chromosomes[0]);
 		}
 	}
-	
-	public Population() {
-		chromosomes = new Chromosome[((int) Parameters.get("population").getValue())];
-		for (int c = 0; c < chromosomes.length; c++) {
-			chromosomes[c] = new Chromosome();
-		}
-	}
 
 	/**
 	 * Returns all chromosomes, parents first, then offspring.
@@ -35,10 +36,10 @@ public class Population {
 	}
 	
 	public void setBestIndividual(int index) {
-		bestIndividual = chromosomes[index];
+		fittest = index;
 	}
 	
 	public Chromosome getBestIndividual() {
-		return bestIndividual;
+		return chromosomes[fittest];
 	}
 }
diff --git a/src/jcgp/tests/ChromosomeTests.java b/src/jcgp/tests/ChromosomeTests.java
index c61785e..6323b88 100644
--- a/src/jcgp/tests/ChromosomeTests.java
+++ b/src/jcgp/tests/ChromosomeTests.java
@@ -1,13 +1,8 @@
 package jcgp.tests;
 
-import static org.junit.Assert.*;
-
-import java.util.Random;
-
-import jcgp.Utilities;
-import jcgp.modules.function.Arithmetic;
-import jcgp.modules.function.FunctionSet;
-import jcgp.parameters.Parameters;
+import static org.junit.Assert.assertTrue;
+import static org.junit.Assert.fail;
+import jcgp.CGP.Resources;
 import jcgp.population.Chromosome;
 import jcgp.population.Connection;
 import jcgp.population.Input;
@@ -45,30 +40,16 @@ import org.junit.Test;
 public class ChromosomeTests {
 
 	private Chromosome chromosome;
+	private static Resources resources;
 
 	@BeforeClass
 	public static void setUpBeforeClass() {
-		// initialise function set
-		FunctionSet functionSet = new FunctionSet(new Arithmetic.Addition(), new Arithmetic.Subtraction());
-
-		// initialise utilities
-		Utilities.setResources(new Random(1234), functionSet);
-
-		// initialise parameters
-		Parameters.setMutationRate(10);
-		Parameters.setTotalGenerations(10);
-		Parameters.setTotalRuns(5);
-		Parameters.setMaxArity(functionSet.getMaxArity());
+		resources = new Resources();
 	}
 
 	@Before
 	public void setUp() throws Exception {
-		Parameters.setColumns(5);
-		Parameters.setRows(2);
-		Parameters.setInputs(2);
-		Parameters.setOutputs(4);
-		Parameters.setLevelsBack(5);
-		chromosome = new Chromosome();
+		chromosome = new Chromosome(resources);
 	}
 
 	/**
@@ -81,7 +62,7 @@ public class ChromosomeTests {
 
 		// compare all elements, one by one
 		// check outputs
-		for (int o = 0; o < Parameters.getOutputs(); o++) {
+		for (int o = 0; o < (int) resources.get("outputs"); o++) {
 			// check that no cross-references exist between chromosomes
 			assertTrue("Cloned chromosome contains a reference to a member of the original chromosome.",
 					clone.getOutput(o) != chromosome.getOutput(o) && 
@@ -99,8 +80,8 @@ public class ChromosomeTests {
 			}
 		}
 		// check nodes, rows first
-		for (int row = 0; row < Parameters.getRows(); row++) {
-			for (int column = 0; column < Parameters.getColumns(); column++) {
+		for (int row = 0; row < (int) resources.get("rows"); row++) {
+			for (int column = 0; column < (int) resources.get("columns"); column++) {
 				// check that nodes are not pointers to the same instance
 				assertTrue("Both chromosomes contain a reference to the same node.", clone.getNode(row, column) != chromosome.getNode(row, column));
 				// check that both nodes reference their own position in the grid correctly
@@ -110,7 +91,7 @@ public class ChromosomeTests {
 				assertTrue("Equivalent nodes have different functions.", clone.getNode(row, column).getFunction() == chromosome.getNode(row, column).getFunction());
 
 				// compare each connection
-				for (int connection = 0; connection < Parameters.getMaxArity(); connection++) {
+				for (int connection = 0; connection < (int) resources.get("arity"); connection++) {
 					// first look at whether they are actually the same instance
 					assertTrue("Nodes are connected to the same connection instance.", 
 							clone.getNode(row, column).getConnection(connection) !=	chromosome.getNode(row, column).getConnection(connection));
@@ -149,12 +130,12 @@ public class ChromosomeTests {
 		clone.setInputs((Object[]) testInputs);
 
 		// check that both chromosomes have the same outputs
-		for (int i = 0; i < Parameters.getOutputs(); i++) {
+		for (int i = 0; i < (int) resources.get("outputs"); i++) {
 			assertTrue("Incorrect output returned", ((Integer) chromosome.getOutput(i).calculate()) == ((Integer) clone.getOutput(i).calculate()));
 		}
 
 		// mutate an output in clone, check that the same node in chromosome produces a different output
-		clone.getOutput(1).setConnection(clone.getInput(2));
+		clone.getOutput(1).setConnection(resources.getRandomInt((int) resources.get("arity")), clone.getInput(2));
 
 		assertTrue("Mutation affected nodes in both chromosomes.",
 				clone.getOutput(1).calculate() != chromosome.getOutput(1).calculate());
@@ -183,7 +164,7 @@ public class ChromosomeTests {
 
 		// get random connections with the last column as reference, check that they're all within range
 		int connectionNodes = 0, connectionOutOfRange = 0, connectionInputs = 0, connectionPicks = 100000;
-		int chosenColumn = Parameters.getColumns() - 1;
+		int chosenColumn = (int) resources.get("columns") - 1;
 		for (int i = 0; i < connectionPicks; i++) {
 			Connection c = chromosome.getRandomConnection(chosenColumn);
 			if (c instanceof Node) {
@@ -199,10 +180,10 @@ public class ChromosomeTests {
 
 			}	
 		}
-		System.out.println("Out of " + connectionPicks + " connections picked from " + ((chosenColumn >= Parameters.getLevelsBack()) ? Parameters.getLevelsBack() : chosenColumn) * Parameters.getRows() +
-				" allowed nodes and " + Parameters.getInputs() + " inputs, " + connectionNodes + " were nodes and " + connectionInputs + " were inputs.");
+		System.out.println("Out of " + connectionPicks + " connections picked from " + ((chosenColumn >= (int) resources.get("levelsBack")) ? (int) resources.get("levelsBack") : chosenColumn) * (int) resources.get("rows") +
+				" allowed nodes and " + (int) resources.get("inputs") + " inputs, " + connectionNodes + " were nodes and " + connectionInputs + " were inputs.");
 
-		System.out.println("Node/input ratio: " + ((double) ((chosenColumn >= Parameters.getLevelsBack()) ? Parameters.getLevelsBack() : chosenColumn) * Parameters.getRows()) / (double) Parameters.getInputs() +
+		System.out.println("Node/input ratio: " + ((Integer) (((chosenColumn >= (int) resources.get("levelsBack")) ? (int) resources.get("levelsBack") : chosenColumn) * (Integer) resources.get("rows"))).doubleValue() / ((Integer) resources.get("inputs")).doubleValue() +
 				", picked ratio: " + (double) connectionNodes / (double) connectionInputs);
 
 		System.out.println(connectionOutOfRange + " nodes that disrespected levels back were picked.");
@@ -226,10 +207,10 @@ public class ChromosomeTests {
 				fail("Return is neither Node nor Output.");
 			}
 		}
-		System.out.println("Out of " + mutablePicks + " mutable elements picked from " + Parameters.getNodeCount() +
-				" nodes and " + Parameters.getOutputs() + " outputs, " + mutableNodes + " were nodes and " +
+		System.out.println("Out of " + mutablePicks + " mutable elements picked from " + (int) resources.get("nodes") +
+				" nodes and " + (int) resources.get("outputs") + " outputs, " + mutableNodes + " were nodes and " +
 				mutableOutputs + " were outputs.");
-		System.out.println("Node/output ratio: " + (double) Parameters.getNodeCount() / (double) Parameters.getOutputs() +
+		System.out.println("Node/output ratio: " + ((Integer) resources.get("nodes")).doubleValue() / ((Integer) resources.get("outputs")).doubleValue() +
 				", picked ratio: " + (double) mutableNodes / (double) mutableOutputs + "\n");
 	}
 
@@ -253,12 +234,12 @@ public class ChromosomeTests {
 	@Test
 	public void setInputTest() {
 		// set input values, check that acquired values are correct
-		Integer[] testInputs = new Integer[Parameters.getInputs()];
-		for (int i = 0; i < Parameters.getInputs(); i++) {
+		Integer[] testInputs = new Integer[(int) resources.get("inputs")];
+		for (int i = 0; i < (int) resources.get("inputs"); i++) {
 			testInputs[i] = i * 2 - 3;
 		}
 		chromosome.setInputs((Object[]) testInputs);
-		for (int i = 0; i < Parameters.getInputs(); i++) {
+		for (int i = 0; i < (int) resources.get("inputs"); i++) {
 			assertTrue("Incorrect input returned.", ((Integer) chromosome.getInput(i).getValue()) == i * 2 - 3);
 		}
 	}
@@ -269,8 +250,8 @@ public class ChromosomeTests {
 	@Test
 	public void getNodeTest() {
 		// get all nodes one by one, check that they are all correct
-		for (int r = 0; r < Parameters.getRows(); r++) {
-			for (int c = 0; c < Parameters.getColumns(); c++) {
+		for (int r = 0; r < (int) resources.get("rows"); r++) {
+			for (int c = 0; c < (int) resources.get("columns"); c++) {
 				assertTrue("Incorrect node returned.", chromosome.getNode(r, c).getColumn() == c &&
 						chromosome.getNode(r, c).getRow() == r);
 			}
@@ -304,7 +285,7 @@ public class ChromosomeTests {
 		assertTrue("Symmetry not obeyed.", c.compareActiveTo(chromosome));
 
 		// create a new random chromosome, this time they should not match
-		c = new Chromosome();
+		c = new Chromosome(resources);
 		assertTrue("Active nodes did match.", !chromosome.compareActiveTo(c));
 	}
 
@@ -319,7 +300,7 @@ public class ChromosomeTests {
 		assertTrue("Symmetry not obeyed.", c.compareTo(chromosome));
 
 		// create a new random chromosome, this time they should not match
-		c = new Chromosome();
+		c = new Chromosome(resources);
 		assertTrue("Chromosomes did match.", !chromosome.compareTo(c));
 	}
 	/**
@@ -333,20 +314,20 @@ public class ChromosomeTests {
 	 */
 	private Chromosome createKnownConfiguration() {
 		// with a small topology, build a chromosome of known connections and check outputs
-		Parameters.setColumns(3);
-		Parameters.setRows(3);
-		Parameters.setInputs(3);
-		Parameters.setOutputs(2);
-		Parameters.setLevelsBack(3);
+		resources.set("columns", 3);
+		resources.set("rows", 3);
+		resources.set("inputs", 3);
+		resources.set("outputs", 2);
+		resources.set("levelsBack", 3);
 
-		Chromosome c = new Chromosome();
+		Chromosome c = new Chromosome(resources);
 
-		c.getNode(0, 0).initialise(Utilities.getFunction(0), c.getInput(0), c.getInput(1));
-		c.getNode(1, 1).initialise(Utilities.getFunction(0), c.getNode(0, 0), c.getInput(1));
-		c.getNode(1, 2).initialise(Utilities.getFunction(0), c.getNode(1, 1), c.getInput(2));
+		c.getNode(0, 0).initialise(resources.getFunction(0), c.getInput(0), c.getInput(1));
+		c.getNode(1, 1).initialise(resources.getFunction(0), c.getNode(0, 0), c.getInput(1));
+		c.getNode(1, 2).initialise(resources.getFunction(0), c.getNode(1, 1), c.getInput(2));
 
-		c.getOutput(0).setConnection(c.getNode(0, 0));
-		c.getOutput(1).setConnection(c.getNode(1, 2));
+		c.getOutput(0).setConnection(0, c.getNode(0, 0));
+		c.getOutput(1).setConnection(0, c.getNode(1, 2));
 
 		return c;
 	}
diff --git a/src/jcgp/tests/NodeTests.java b/src/jcgp/tests/NodeTests.java
index 74b8140..330ef7a 100644
--- a/src/jcgp/tests/NodeTests.java
+++ b/src/jcgp/tests/NodeTests.java
@@ -1,13 +1,9 @@
 package jcgp.tests;
 
 import static org.junit.Assert.assertTrue;
-
-import java.util.Random;
-
-import jcgp.Utilities;
-import jcgp.modules.function.Arithmetic;
-import jcgp.modules.function.Function;
-import jcgp.parameters.Parameters;
+import jcgp.CGP.Resources;
+import jcgp.function.Arithmetic;
+import jcgp.function.Function;
 import jcgp.population.Chromosome;
 import jcgp.population.Connection;
 import jcgp.population.Node;
@@ -35,32 +31,22 @@ public class NodeTests {
 
 	private Node node;
 	private static Chromosome chromosome;
+	private static Resources resources;
 	// these numbers will be used by the node under test
 	private final int arg1 = 2;
 	private final int arg2 = 5;
 
 	@BeforeClass
 	public static void setUpBeforeClass() {
-		// initialise utilities
-		Utilities.setResources(new Random(1234), null);
-
-		// initialise parameters
-		Parameters.setColumns(0);
-		Parameters.setRows(0);
-		Parameters.setInputs(0);
-		Parameters.setOutputs(0);
-		Parameters.setLevelsBack(0);
-		Parameters.setMutationRate(10);
-		Parameters.setTotalGenerations(100);
-		Parameters.setTotalRuns(5);
-		Parameters.setMaxArity(2);
-
-		chromosome = new Chromosome();
+		
+		resources = new Resources();
+
+		chromosome = new Chromosome(resources);
 	}
 
 	@Before
 	public void setUp() throws Exception {
-		node = new Node(chromosome, 0, 0);
+		node = new Node(chromosome, 0, 0, (int) resources.get("arity"));
 		// make node with anonymous addition function and hard-coded value connections
 		node.initialise(new Arithmetic.Addition(),
 				new Connection[]{new Connection() {
@@ -117,6 +103,12 @@ public class NodeTests {
 				// blank
 				return 0;
 			}
+
+			@Override
+			public String getName() {
+				// blank
+				return null;
+			}
 		};
 
 		node.setFunction(f);
@@ -194,7 +186,7 @@ public class NodeTests {
 				return null;
 			}
 		};
-		node.setConnection(conn2);
+		node.setConnection(resources.getRandomInt((int) resources.get("arity")), conn2);
 
 		assertTrue("Connection was not found in node.", node.getConnection(0) == conn2 || node.getConnection(1) == conn2);
 
diff --git a/src/jcgp/tests/OutputTests.java b/src/jcgp/tests/OutputTests.java
index b8f7d96..00cfea3 100644
--- a/src/jcgp/tests/OutputTests.java
+++ b/src/jcgp/tests/OutputTests.java
@@ -2,10 +2,7 @@ package jcgp.tests;
 
 import static org.junit.Assert.assertTrue;
 
-import java.util.Random;
-
-import jcgp.Utilities;
-import jcgp.parameters.Parameters;
+import jcgp.CGP.Resources;
 import jcgp.population.Chromosome;
 import jcgp.population.Connection;
 import jcgp.population.Output;
@@ -30,27 +27,15 @@ public class OutputTests {
 
 	private Output output;
 	private static Chromosome chromosome;
+	private static Resources resources;
 	// these are the test values
 	private final int outputValue = 10;
 	private final int outputIndex = 2;
 
 	@BeforeClass
 	public static void setUpBeforeClass() {
-		// initialise utilities
-		Utilities.setResources(new Random(1234), null);
-
-		// initialise parameters
-		Parameters.setColumns(0);
-		Parameters.setRows(0);
-		Parameters.setInputs(0);
-		Parameters.setOutputs(0);
-		Parameters.setLevelsBack(0);
-		Parameters.setMutationRate(10);
-		Parameters.setTotalGenerations(100);
-		Parameters.setTotalRuns(5);
-		Parameters.setMaxArity(2);
-
-		chromosome = new Chromosome();
+		resources = new Resources();
+		chromosome = new Chromosome(resources);
 	}
 
 	@Before
@@ -61,7 +46,7 @@ public class OutputTests {
 	@Test
 	public void evaluationsTest() {
 		// set source connection, check that the appropriate value is returned
-		output.setConnection(new Connection() {
+		output.setConnection(0, new Connection() {
 
 			@Override
 			public Object getValue() {
@@ -96,7 +81,7 @@ public class OutputTests {
 				return null;
 			}
 		};
-		output.setConnection(newConn);
+		output.setConnection(0, newConn);
 
 		assertTrue("Incorrect connection returned.", output.getSource() == newConn);
 	}
diff --git a/src/jcgp/tests/PopulationTests.java b/src/jcgp/tests/PopulationTests.java
index d646b90..474b8d5 100644
--- a/src/jcgp/tests/PopulationTests.java
+++ b/src/jcgp/tests/PopulationTests.java
@@ -1,13 +1,7 @@
 package jcgp.tests;
 
-import static org.junit.Assert.*;
-
-import java.util.Random;
-
-import jcgp.Utilities;
-import jcgp.modules.function.Arithmetic;
-import jcgp.modules.function.FunctionSet;
-import jcgp.parameters.Parameters;
+import static org.junit.Assert.assertTrue;
+import jcgp.CGP.Resources;
 import jcgp.population.Chromosome;
 import jcgp.population.Population;
 
@@ -19,9 +13,7 @@ import org.junit.Test;
  * 
  * Tests which cover the behaviour specified for a population.
  * 
- *  - A population should be able to return parents and offspring separately. 
- *  - It should be possible to iterate through all the chromosomes in a population
- *    with one indexing system - parents then offspring.
+ *  - It should be possible to iterate through all the chromosomes in a population.
  *  - When constructed with no arguments, it should generate populationSize
  *    random chromosomes, distributed according to the EA parameters.
  *  - If one or more chromosomes are passed into the constructor, it should use them
@@ -34,81 +26,61 @@ import org.junit.Test;
 public class PopulationTests {
 
 	private Population population;
+	private static Resources resources;
 
 	@BeforeClass
 	public static void setUpBeforeClass() throws Exception {
-		// initialise function set
-		FunctionSet functionSet = new FunctionSet(new Arithmetic.Addition(), new Arithmetic.Subtraction());
-
-		// initialise utilities
-		Utilities.setResources(new Random(1234), functionSet);
-
-		// initialise parameters
-		Parameters.setColumns(20);
-		Parameters.setRows(20);
-		Parameters.setInputs(2);
-		Parameters.setOutputs(4);
-		Parameters.setLevelsBack(1);
-		Parameters.setMutationRate(10);
-		Parameters.setTotalGenerations(100);
-		Parameters.setTotalRuns(5);
-		Parameters.setPopulationSize(1, 4);
-		Parameters.setMaxArity(functionSet.getMaxArity());
+		resources = new Resources();
+		
+		
+//		// initialise function set
+//		FunctionSet functionSet = new FunctionSet(new Arithmetic.Addition(), new Arithmetic.Subtraction());
+//
+//		// initialise utilities
+//		Utilities.setResources(new Random(1234), functionSet);
+//
+//		// initialise parameters
+//		Resources.setColumns(20);
+//		Resources.setRows(20);
+//		Resources.setInputs(2);
+//		Resources.setOutputs(4);
+//		Resources.setLevelsBack(1);
+//		Resources.setMutationRate(10);
+//		Resources.setTotalGenerations(100);
+//		Resources.setTotalRuns(5);
+//		Resources.setPopulationSize(1, 4);
+//		Resources.setMaxArity(functionSet.getMaxArity());
 	}
 
 	@Before
 	public void setUp() throws Exception {
-		population = new Population();
+		population = new Population(resources);
 	}
 
 	@Test
 	public void defaultPopulationTest() {
 		// check that the constructor really generates populationSize chromosomes when none is given
-		int offspring = 0, parent = 0;
-		while (true) {
-			try {
-				population.getOffspring(offspring);
-			} catch (IndexOutOfBoundsException e) {
-				break;
-			}
-			offspring++;
-		}
+		int chromosomes = 0;
 		while (true) {
 			try {
-				population.getParent(parent);
+				population.getChromosome(chromosomes);
 			} catch (IndexOutOfBoundsException e) {
 				break;
 			}
-			parent++;
+			chromosomes++;
 		}
-		assertTrue("Incorrect number of chromosomes generated.", offspring + parent == Parameters.getPopulationSize());
-	}
-	
-	@Test
-	public void offspringParentTest() {
-		// the first parent should not be the same as the first offspring
-		assertTrue("Same chromosome returned as parent and offspring", population.getOffspring(0) != population.getParent(0));
+
+		assertTrue("Incorrect number of chromosomes generated.", chromosomes == (int) resources.get("popSize"));
 	}
 	
 	@Test
-	public void singleIndexTest() {
-		// assuming 1+4
-		// the first chromosome should be the first (and only) parent
-		assertTrue("Incorrect chromosome returned.", population.getChromosome(0) == population.getParent(0));
-		// the next 4 chromosomes should be the offspring, in order
-		for (int i = 0; i < Parameters.getOffspringCount(); i++) {
-			assertTrue("Incorrect chromosome returned.", population.getChromosome(i + 1) == population.getOffspring(i));
-		}
-	}
-
-	@Test
 	public void preinitialisedChromosomeTest() {
 		// the original chromosome that will be cloned
-		Chromosome oc = new Chromosome();
+		Chromosome oc = new Chromosome(resources);
 
 		// initialise a population with a copy of it
-		population = new Population(oc);
+		population = new Population(oc, resources);
 		// check that the first parent chromosome is identical to, but not the same instance as, the one given
-		assertTrue("Incorrect chromosome in population.", population.getParent(0).compareTo(oc) && population.getParent(0) != oc);
+		assertTrue("Incorrect chromosome in population.", population.getChromosome(0).compareTo(oc) && population.getChromosome(0) != oc);
 	}
 }