Move sources and resources

33 files changed, 6590 insertions, 0 deletions

diff --git a/src/main/java/gtPlusPlus/xmod/gregtech/loaders/GT_Material_Loader.java b/src/main/java/gtPlusPlus/xmod/gregtech/loaders/GT_Material_Loader.java
new file mode 100644
index 0000000000..4c8707e5e8
--- /dev/null
+++ b/src/main/java/gtPlusPlus/xmod/gregtech/loaders/GT_Material_Loader.java
@@ -0,0 +1,290 @@
+package gtPlusPlus.xmod.gregtech.loaders;
+
+import java.lang.reflect.*;
+import java.util.HashMap;
+import java.util.Map;
+
+import gregtech.api.enums.Materials;
+import gregtech.api.enums.OrePrefixes;
+
+import gtPlusPlus.api.objects.Logger;
+import gtPlusPlus.api.objects.data.AutoMap;
+import gtPlusPlus.core.lib.CORE;
+import gtPlusPlus.core.util.Utils;
+import gtPlusPlus.core.util.minecraft.MaterialUtils;
+import gtPlusPlus.core.util.reflect.ReflectionUtils;
+
+public class GT_Material_Loader {
+
+	private volatile static GT_Material_Loader instance = new GT_Material_Loader();
+	private volatile Object mProxyObject;
+	private static AutoMap<Materials> mMaterials = new AutoMap<Materials>();
+	private static volatile boolean mHasRun = false;
+
+	public synchronized GT_Material_Loader getInstance(){
+		return GT_Material_Loader.instance;
+	}
+	
+	public synchronized boolean getRunAbility(){
+		return (mHasRun ? false : true);
+	}
+	public synchronized void setRunAbility(boolean b){
+		mHasRun = Utils.invertBoolean(b);
+	}
+
+	public GT_Material_Loader() {
+		if (getRunAbility()){
+		//Set Singleton Instance
+		instance = this;				 
+
+		//Try Reflectively add ourselves to the GT loader.
+			Class mInterface = ReflectionUtils.getClass("gregtech.api.interfaces.IMaterialHandler");
+			if (CORE.MAIN_GREGTECH_5U_EXPERIMENTAL_FORK && mInterface != null){
+
+				//Make this class Dynamically implement IMaterialHandler
+				if (mProxyObject == null){
+					mProxyObject = Proxy.newProxyInstance(
+							mInterface.getClassLoader(), new Class[] { mInterface }, 
+							new MaterialHandler(getInstance()));		
+				}
+
+				if (ReflectionUtils.invoke(Materials.class, "add", new Class[]{ReflectionUtils.getClass("gregtech.api.interfaces.IMaterialHandler")}, new Object[]{mProxyObject})){
+					Logger.REFLECTION("Successfully invoked add, on the proxied object implementing IMaterialHandler.");
+
+
+					Logger.REFLECTION("Examining Proxy to ensure it implements the correct Interface.");
+					Class[] i = mProxyObject.getClass().getInterfaces();
+					for (int r=0;r<i.length;r++){
+						Logger.REFLECTION("Contains "+i[r].getCanonicalName()+".");
+						if (i[r] == mInterface){
+							Logger.REFLECTION("Found gregtech.api.interfaces.IMaterialHandler. This Proxy is valid.");
+						}
+					}
+				}
+				else {
+					Logger.REFLECTION("Failed to invoke add, on the proxied object implementing IMaterialHandler.");
+				}
+			}	
+		//Materials.add(this);
+		
+		//Stupid shit running twice, I don't think so.
+		setRunAbility(false);
+		}
+	}
+
+	public void onMaterialsInit() {
+		Logger.DEBUG_MATERIALS("onMaterialsInit()");
+	}
+
+	public void onComponentInit() {
+		Logger.DEBUG_MATERIALS("onComponentInit()");
+		if (!mMaterials.isEmpty()){
+			Logger.DEBUG_MATERIALS("Found "+mMaterials.size()+" materials to re-enable.");
+			for (Materials M : mMaterials.values()){
+				String name = MaterialUtils.getMaterialName(M);
+				Logger.DEBUG_MATERIALS("Trying to enable "+name+".");
+				boolean success = tryEnableAllComponentsForMaterial(M);
+				if (success){
+					Logger.DEBUG_MATERIALS("Success! Enabled "+name+".");
+				}
+				else {
+					Logger.DEBUG_MATERIALS("Failure... Did not enable "+name+".");					
+				}
+			}
+		}
+	}
+
+	public void onComponentIteration(Materials aMaterial) {
+		Logger.DEBUG_MATERIALS("onComponentIteration()");
+	}
+
+	public synchronized boolean enableMaterial(Materials m){
+		if (mMaterials.setValue(m)){
+			Logger.DEBUG_MATERIALS("Added "+MaterialUtils.getMaterialName(m)+" to internal Map.");
+			return true;
+		}
+		Logger.DEBUG_MATERIALS("Failed to add "+MaterialUtils.getMaterialName(m)+" to internal Map.");
+		return false;
+	}
+
+
+
+
+
+
+	/*
+	 * Static internal handler methods
+	 */
+
+	private static synchronized boolean tryEnableMaterial(Materials mMaterial){
+		if (!CORE.MAIN_GREGTECH_5U_EXPERIMENTAL_FORK){
+			return false;
+		}			
+
+		boolean value = ReflectionUtils.setField(mMaterial, "mHasParentMod", true);	
+		if (value){
+			Logger.DEBUG_MATERIALS("Set mHasParentMod true for "+mMaterial.mDefaultLocalName);
+		}
+		else {
+			Logger.DEBUG_MATERIALS("Failed to set mHasParentMod true for "+mMaterial.mDefaultLocalName);
+		}
+		return value; 
+	}
+
+	private static synchronized boolean tryEnableMaterialPart(OrePrefixes prefix, Materials mMaterial){
+		if (!CORE.MAIN_GREGTECH_5U_EXPERIMENTAL_FORK){
+			return false;
+		}		
+		try {
+			Method enableComponent = ReflectionUtils.getClass("gregtech.api.enums.OrePrefixes").getDeclaredMethod("enableComponent", Materials.class);
+			enableComponent.invoke(prefix, mMaterial);
+			Logger.DEBUG_MATERIALS("Enabled "+prefix.name()+" for "+mMaterial.mDefaultLocalName+".");
+			return true;
+		}
+		catch (IllegalAccessException | IllegalArgumentException | InvocationTargetException | NoSuchMethodException | SecurityException error) {
+			Logger.DEBUG_MATERIALS("Failed to enabled "+prefix.name()+" for "+mMaterial.mDefaultLocalName+". Caught "+error.getCause().toString()+".");
+			error.printStackTrace();			
+		}		
+		Logger.DEBUG_MATERIALS("Did not enable "+prefix.name()+" for "+mMaterial.mDefaultLocalName+". Report this error to Alkalus on Github.");
+		return false;
+	}
+
+	private static synchronized boolean tryEnableAllComponentsForMaterial(Materials material){
+		if (!CORE.MAIN_GREGTECH_5U_EXPERIMENTAL_FORK){
+			return false;
+		}		
+		try {
+			tryEnableMaterial(material);
+			int mValid = 0;
+			for(OrePrefixes ore:OrePrefixes.values()){
+				if (tryEnableMaterialPart(ore, material)){
+					mValid++;
+				}
+			}
+			if (mValid > 0){
+				Logger.DEBUG_MATERIALS("Success - Re-enabled all components for "+MaterialUtils.getMaterialName(material));
+			}
+			else {
+				Logger.DEBUG_MATERIALS("Failure - Did not enable any components for "+MaterialUtils.getMaterialName(material));
+			}
+			return mValid > 0;			
+		}
+		catch (SecurityException | IllegalArgumentException e) {
+			Logger.DEBUG_MATERIALS("Total Failure - Unable to re-enable "+MaterialUtils.getMaterialName(material)+". Most likely an IllegalArgumentException, but small chance it's a SecurityException.");
+			return false;
+		}		
+	}
+
+
+
+
+
+
+
+
+
+	/**
+	 * Special Dynamic Interface Class
+	 */
+
+	public class MaterialHandler implements InvocationHandler {
+
+		private final Map<String, Method> methods = new HashMap<String, Method>();
+		private Object target;
+
+		public MaterialHandler(Object target) {
+			Logger.REFLECTION("Created a Proxy Interface which implements IMaterialHandler.");
+			this.target = target;	 
+			for(Method method: target.getClass().getDeclaredMethods()) {
+				Logger.REFLECTION("Adding "+method.getName()+" to internal method map.");
+				this.methods.put(method.getName(), method);
+			}
+		}
+
+		@Override
+		public Object invoke(Object proxy, Method method, Object[] args) 
+				throws Throwable {
+			long start = System.nanoTime();
+			Object result = methods.get(method.getName()).invoke(target, args);
+			long elapsed = System.nanoTime() - start;	 
+			Logger.INFO("[Debug] Executed "+method.getName()+" in "+elapsed+" ns");	 
+			return result;
+		}
+	}
+
+
+	/*
+	public static class ProxyListener implements java.lang.reflect.InvocationHandler {		
+
+		public static Object IMaterialHandlerProxy;
+
+		ProxyListener(){
+
+			Logger.REFLECTION("Failed setting IMaterialHandler Proxy instance.");
+		}
+
+		//Loading the class at runtime
+		public static void main(String[] args) throws IllegalAccessException, IllegalArgumentException, InvocationTargetException, NoSuchMethodException, SecurityException, ClassNotFoundException {
+		    Class<?> someInterface = ReflectionUtils.getClass("gregtech.api.interfaces.IMaterialHandler");
+		    Object instance = Proxy.newProxyInstance(someInterface.getClassLoader(), new Class<?>[]{someInterface}, new InvocationHandler() {
+
+		        @Override
+		        public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
+		            //Handle the invocations
+		            if(method.getName().equals("onMaterialsInit")){
+		            	Logger.REFLECTION("Invoked onMaterialsInit() via IMaterialHandler proxy");
+		                return 1;
+		            }
+		            else if(method.getName().equals("onComponentInit")){
+		            	Logger.REFLECTION("Invoked onComponentInit() via IMaterialHandler proxy");
+		                return 2;
+		            }
+		            else if(method.getName().equals("onComponentIteration")){
+		            	Logger.REFLECTION("Invoked onComponentIteration() via IMaterialHandler proxy");
+		                return 3;
+		            }
+		            else {
+		            	return -1;
+		            }
+		        }
+		    }); 
+		    System.out.println(instance.getClass().getDeclaredMethod("someMethod", (Class<?>[])null).invoke(instance, new Object[]{}));
+		}
+
+		private static class MaterialHandler implements InvocationHandler {
+	        private final Object original;
+
+	        public MaterialHandler(Object original) {
+	            this.original = original;
+	        }
+
+	        @Override
+			public Object invoke(Object proxy, Method method, Object[] args)
+	                throws IllegalAccessException, IllegalArgumentException,
+	                InvocationTargetException {
+	            System.out.println("BEFORE");
+	            method.invoke(original, args);
+	            System.out.println("AFTER");
+	            return null;
+	        }
+	    }
+
+	    public static void init(){ 
+
+	    	Class<?> someInterface = ReflectionUtils.getClass("gregtech.api.interfaces.IMaterialHandler");		   
+	        GT_Material_Loader original = GT_Material_Loader.instance;
+	        MaterialHandler handler = new MaterialHandler(original);
+
+	        Object f = Proxy.newProxyInstance(someInterface.getClassLoader(),
+	                new Class[] { someInterface },
+	                handler);
+
+	        f.originalMethod("Hallo");
+	    }
+
+
+
+	}
+
+	 */
+}
diff --git a/src/main/java/gtPlusPlus/xmod/gregtech/loaders/Gregtech_Blocks.java b/src/main/java/gtPlusPlus/xmod/gregtech/loaders/Gregtech_Blocks.java
new file mode 100644
index 0000000000..e918d8015e
--- /dev/null
+++ b/src/main/java/gtPlusPlus/xmod/gregtech/loaders/Gregtech_Blocks.java
@@ -0,0 +1,22 @@
+package gtPlusPlus.xmod.gregtech.loaders;
+
+import gtPlusPlus.core.block.ModBlocks;
+import gtPlusPlus.xmod.gregtech.common.blocks.*;
+
+public class Gregtech_Blocks {
+
+	public static void run(){
+		
+		//Casing Blocks
+		ModBlocks.blockCasingsMisc = new GregtechMetaCasingBlocks();
+		ModBlocks.blockCasings2Misc = new GregtechMetaCasingBlocks2();
+		ModBlocks.blockCasings3Misc = new GregtechMetaCasingBlocks3();
+		ModBlocks.blockCasings4Misc = new GregtechMetaCasingBlocks4();
+		ModBlocks.blockCasings5Misc = new GregtechMetaCasingBlocks5();
+
+		ModBlocks.blockCasingsTieredGTPP = new GregtechMetaTieredCasingBlocks1();
+		ModBlocks.blockSpecialMultiCasings = new GregtechMetaSpecialMultiCasings();
+		ModBlocks.blockCustomMachineCasings = new GregtechMetaSpecialMachineCasings();
+
+	}
+}
diff --git a/src/main/java/gtPlusPlus/xmod/gregtech/loaders/ProcessingAngleGrinder.java b/src/main/java/gtPlusPlus/xmod/gregtech/loaders/ProcessingAngleGrinder.java
new file mode 100644
index 0000000000..51316f024a
--- /dev/null
+++ b/src/main/java/gtPlusPlus/xmod/gregtech/loaders/ProcessingAngleGrinder.java
@@ -0,0 +1,135 @@
+
+package gtPlusPlus.xmod.gregtech.loaders;
+
+import gregtech.api.enums.GT_Values;
+import gregtech.api.enums.ItemList;
+import gregtech.api.enums.Materials;
+import gregtech.api.enums.OrePrefixes;
+import gregtech.api.enums.SubTag;
+import gregtech.api.util.GT_ModHandler;
+import gregtech.api.util.GT_ModHandler.RecipeBits;
+import gregtech.api.util.GT_OreDictUnificator;
+import gtPlusPlus.api.objects.Logger;
+import gtPlusPlus.core.material.ELEMENT;
+import gtPlusPlus.core.recipe.common.CI;
+import gtPlusPlus.core.util.minecraft.MaterialUtils;
+import gtPlusPlus.xmod.gregtech.api.enums.GregtechOrePrefixes;
+import gtPlusPlus.xmod.gregtech.api.enums.GregtechOrePrefixes.GT_Materials;
+import gtPlusPlus.xmod.gregtech.api.interfaces.internal.Interface_OreRecipeRegistrator;
+import gtPlusPlus.xmod.gregtech.common.items.MetaGeneratedGregtechTools;
+import net.minecraft.item.ItemStack;
+
+public class ProcessingAngleGrinder implements Interface_OreRecipeRegistrator, Runnable {
+	public ProcessingAngleGrinder() {
+		GregtechOrePrefixes.toolAngleGrinder.add(this);
+	}
+
+	@Override
+	public void registerOre(final GregtechOrePrefixes aPrefix, final Materials aMaterial, final String aOreDictName,
+			final String aModName, final ItemStack aStack) {
+		if ((aMaterial != Materials.Stone) && (aMaterial != Materials.Flint)) {
+			if (aMaterial != Materials.Rubber) {
+				if ((!aMaterial.contains(SubTag.WOOD)) && (!aMaterial.contains(SubTag.BOUNCY))
+						&& (!aMaterial.contains(SubTag.NO_SMASHING))) {
+					
+				}
+			}
+		}
+	}
+
+	@Override
+	public void registerOre(final GregtechOrePrefixes aPrefix, final GT_Materials aMaterial, final String aOreDictName,
+			final String aModName, final ItemStack aStack) {
+		// TODO Auto-generated method stub
+
+	}
+
+	public void materialsLoops() {
+		final Materials[] i = Materials.values();
+		final int size = i.length;
+		Logger.MATERIALS("Materials to attempt tool gen. with: " + size);
+		int used = 0;
+		Materials aMaterial = null;
+		for (int r = 0; r < size; r++) {
+			aMaterial = i[r];
+			if ((aMaterial != Materials.Stone) && (aMaterial != Materials.Flint) && (aMaterial != Materials.Rubber)
+					&& (aMaterial != Materials._NULL)) {
+				if ((!aMaterial.contains(SubTag.WOOD)) && (!aMaterial.contains(SubTag.BOUNCY))
+						&& (!aMaterial.contains(SubTag.NO_SMASHING)) && (!aMaterial.contains(SubTag.TRANSPARENT))
+						&& (!aMaterial.contains(SubTag.FLAMMABLE)) && (!aMaterial.contains(SubTag.MAGICAL))
+						&& (!aMaterial.contains(SubTag.NO_SMELTING))) {
+					Logger.MATERIALS("Generating Angle Grinder from "+MaterialUtils.getMaterialName(aMaterial));
+					// Input 1
+					
+
+					final ItemStack plate = GT_OreDictUnificator.get(OrePrefixes.plate, aMaterial, 1L);
+					final ItemStack longrod = GT_OreDictUnificator.get(OrePrefixes.stickLong, aMaterial, 1L);
+
+					if ((null != plate && longrod != null)) {						
+					     addRecipe(aMaterial, 1600000L, 3, ItemList.Battery_RE_HV_Lithium.get(1));
+					     addRecipe(aMaterial, 1200000L, 3, ItemList.Battery_RE_HV_Cadmium.get(1));
+					     addRecipe(aMaterial, 800000L, 3, ItemList.Battery_RE_HV_Sodium.get(1));						
+						used++;
+					} else {
+						Logger.MATERIALS("Unable to generate Angle Grinder from "+MaterialUtils.getMaterialName(aMaterial)+", Plate or Long Rod may be invalid. Invalid | Plate? "+(plate == null) +" | Rod? "+(longrod == null)+" |");
+					}
+					// GT_ModHandler.addCraftingRecipe(,
+					// GT_ModHandler.RecipeBits.DO_NOT_CHECK_FOR_COLLISIONS |
+					// GT_ModHandler.RecipeBits.BUFFERED, new Object[]{"P H", "PIP", " I ",
+					// Character.valueOf('I'), OrePrefixes.ingot.get(aMaterial),
+					// Character.valueOf('P'), OrePrefixes.plate.get(aMaterial),
+					// Character.valueOf('H'), OrePrefixes.toolHeadHammer.get(aMaterial)});
+				} else {
+					Logger.MATERIALS("Unable to generate Angle Grinder from "+MaterialUtils.getMaterialName(aMaterial));
+				}
+			} else {
+				Logger.MATERIALS("Unable to generate Angle Grinder from "+MaterialUtils.getMaterialName(aMaterial));
+			}
+
+		}
+
+		Logger.INFO("Materials used for tool gen: " + used);
+	}
+
+	@Override
+	public void run() {
+		Logger.INFO("Generating Angle Grinders for all valid GT Materials.");
+		this.materialsLoops();
+	}
+	
+	public boolean addRecipe(Materials aMaterial, long aBatteryStorage, int aVoltageTier, ItemStack aBattery) {
+		
+		ItemStack aOutputStack = MetaGeneratedGregtechTools.INSTANCE.getToolWithStats(
+				 MetaGeneratedGregtechTools.ANGLE_GRINDER,
+				 1,
+				 aMaterial,
+				 Materials.Titanium, 
+				 new long[]{aBatteryStorage, GT_Values.V[aVoltageTier], 3L, -1L});
+		
+		
+
+		long aDura = MetaGeneratedGregtechTools.getToolMaxDamage(aOutputStack);	
+		if (aDura <= 32000) {
+			Logger.MATERIALS("Unable to generate Angle Grinder from "+MaterialUtils.getMaterialName(aMaterial)+", Durability: "+aDura);
+			return false;
+		}
+		
+		 return GT_ModHandler.addCraftingRecipe(
+				 aOutputStack,
+				 RecipeBits.DISMANTLEABLE | RecipeBits.DO_NOT_CHECK_FOR_COLLISIONS | RecipeBits.BUFFERED, 
+				 new Object[]{
+						 "SXL",
+						 "GMG",
+						 "PBP",
+						 'X', ItemList.Component_Grinder_Tungsten.get(1),
+						 'M', CI.getElectricMotor(aVoltageTier, 1),
+						 'S', OrePrefixes.screw.get(Materials.Titanium),
+						 'L', OrePrefixes.stickLong.get(aMaterial),
+						 'P', OrePrefixes.plate.get(aMaterial),
+						 'G', ELEMENT.STANDALONE.BLACK_METAL.getGear(1),
+						 'B', aBattery
+						 });
+		    
+	}
+
+}
\ No newline at end of file
diff --git a/src/main/java/gtPlusPlus/xmod/gregtech/loaders/ProcessingElectricButcherKnife.java b/src/main/java/gtPlusPlus/xmod/gregtech/loaders/ProcessingElectricButcherKnife.java
new file mode 100644
index 0000000000..9fe9ad7816
--- /dev/null
+++ b/src/main/java/gtPlusPlus/xmod/gregtech/loaders/ProcessingElectricButcherKnife.java
@@ -0,0 +1,134 @@
+
+package gtPlusPlus.xmod.gregtech.loaders;
+
+import gregtech.api.enums.GT_Values;
+import gregtech.api.enums.ItemList;
+import gregtech.api.enums.Materials;
+import gregtech.api.enums.OrePrefixes;
+import gregtech.api.enums.SubTag;
+import gregtech.api.util.GT_ModHandler;
+import gregtech.api.util.GT_ModHandler.RecipeBits;
+import gregtech.api.util.GT_OreDictUnificator;
+import gregtech.common.items.GT_MetaGenerated_Tool_01;
+import gtPlusPlus.api.objects.Logger;
+import gtPlusPlus.core.material.ELEMENT;
+import gtPlusPlus.core.recipe.common.CI;
+import gtPlusPlus.core.util.minecraft.MaterialUtils;
+import gtPlusPlus.core.util.minecraft.RecipeUtils;
+import gtPlusPlus.xmod.gregtech.api.enums.GregtechOrePrefixes;
+import gtPlusPlus.xmod.gregtech.api.enums.GregtechOrePrefixes.GT_Materials;
+import gtPlusPlus.xmod.gregtech.api.interfaces.internal.Interface_OreRecipeRegistrator;
+import gtPlusPlus.xmod.gregtech.common.items.MetaGeneratedGregtechTools;
+import net.minecraft.item.ItemStack;
+
+public class ProcessingElectricButcherKnife implements Interface_OreRecipeRegistrator, Runnable {
+	public ProcessingElectricButcherKnife() {
+		GregtechOrePrefixes.toolElectricButcherKnife.add(this);
+	}
+
+	@Override
+	public void registerOre(final GregtechOrePrefixes aPrefix, final Materials aMaterial, final String aOreDictName,
+			final String aModName, final ItemStack aStack) {
+		if ((aMaterial != Materials.Stone) && (aMaterial != Materials.Flint)) {
+			if (aMaterial != Materials.Rubber) {
+				if ((!aMaterial.contains(SubTag.WOOD)) && (!aMaterial.contains(SubTag.BOUNCY))
+						&& (!aMaterial.contains(SubTag.NO_SMASHING))) {
+					
+				}
+			}
+		}
+	}
+
+	@Override
+	public void registerOre(final GregtechOrePrefixes aPrefix, final GT_Materials aMaterial, final String aOreDictName,
+			final String aModName, final ItemStack aStack) {
+		// TODO Auto-generated method stub
+
+	}
+
+	public void materialsLoops() {
+		final Materials[] i = Materials.values();
+		final int size = i.length;
+		Logger.MATERIALS("Materials to attempt tool gen. with: " + size);
+		int used = 0;
+		Materials aMaterial = null;
+		for (int r = 0; r < size; r++) {
+			aMaterial = i[r];
+			if ((aMaterial != Materials.Stone) && (aMaterial != Materials.Flint) && (aMaterial != Materials.Rubber)
+					&& (aMaterial != Materials._NULL)) {
+				if ((!aMaterial.contains(SubTag.WOOD)) && (!aMaterial.contains(SubTag.BOUNCY))
+						&& (!aMaterial.contains(SubTag.NO_SMASHING)) && (!aMaterial.contains(SubTag.TRANSPARENT))
+						&& (!aMaterial.contains(SubTag.FLAMMABLE)) && (!aMaterial.contains(SubTag.MAGICAL))
+						&& (!aMaterial.contains(SubTag.NO_SMELTING))) {
+					Logger.MATERIALS("Generating Electric Butcher Knife from "+MaterialUtils.getMaterialName(aMaterial));
+					// Input 1
+					
+
+					final ItemStack plate = GT_OreDictUnificator.get(OrePrefixes.plate, aMaterial, 1L);
+					final ItemStack screw = GT_OreDictUnificator.get(OrePrefixes.screw, aMaterial, 1L);
+
+					if ((null != plate) && screw != null) {						
+					     addRecipe(aMaterial, 1600000L, 3, ItemList.Battery_RE_HV_Lithium.get(1));
+					     addRecipe(aMaterial, 1200000L, 3, ItemList.Battery_RE_HV_Cadmium.get(1));
+					     addRecipe(aMaterial, 800000L, 3, ItemList.Battery_RE_HV_Sodium.get(1));						
+						used++;
+					} else {
+						Logger.MATERIALS("Unable to generate Electric Butcher Knife from "+MaterialUtils.getMaterialName(aMaterial)+", Plate or Long Rod may be invalid. Invalid | Plate? "+(plate == null) +" | Rod? "+" |");
+					}
+					// GT_ModHandler.addCraftingRecipe(,
+					// GT_ModHandler.RecipeBits.DO_NOT_CHECK_FOR_COLLISIONS |
+					// GT_ModHandler.RecipeBits.BUFFERED, new Object[]{"P H", "PIP", " I ",
+					// Character.valueOf('I'), OrePrefixes.ingot.get(aMaterial),
+					// Character.valueOf('P'), OrePrefixes.plate.get(aMaterial),
+					// Character.valueOf('H'), OrePrefixes.toolHeadHammer.get(aMaterial)});
+				} else {
+					Logger.MATERIALS("Unable to generate Electric Butcher Knife from "+MaterialUtils.getMaterialName(aMaterial));
+				}
+			} else {
+				Logger.MATERIALS("Unable to generate Electric Butcher Knife from "+MaterialUtils.getMaterialName(aMaterial));
+			}
+
+		}
+
+		Logger.INFO("Materials used for tool gen: " + used);
+	}
+
+	@Override
+	public void run() {
+		Logger.INFO("Generating Electric Butcher Knives for all valid GT Materials.");
+		this.materialsLoops();
+	}
+	
+	public boolean addRecipe(Materials aMaterial, long aBatteryStorage, int aVoltageTier, ItemStack aBattery) {
+		
+		ItemStack aOutputStack = MetaGeneratedGregtechTools.INSTANCE.getToolWithStats(
+				 MetaGeneratedGregtechTools.ELECTRIC_BUTCHER_KNIFE,
+				 1,
+				 aMaterial,
+				 Materials.Titanium, 
+				 new long[]{aBatteryStorage, GT_Values.V[aVoltageTier], 3L, -1L});
+		
+		ItemStack aInputCutter = GT_MetaGenerated_Tool_01.INSTANCE.getToolWithStats(
+				GT_MetaGenerated_Tool_01.BUTCHERYKNIFE,
+				 1,
+				 aMaterial,
+				 aMaterial, 
+				 null);
+
+		long aDura = MetaGeneratedGregtechTools.getToolMaxDamage(aOutputStack);	
+		if (aDura <= 32000) {
+			Logger.MATERIALS("Unable to generate Electric Butcher Knife from "+MaterialUtils.getMaterialName(aMaterial)+", Durability: "+aDura);
+			return false;
+		}
+		
+		
+		
+		return RecipeUtils.addShapedRecipe(
+				OrePrefixes.wireFine.get(Materials.Electrum), aInputCutter, OrePrefixes.wireFine.get(Materials.Electrum),
+				OrePrefixes.plate.get(aMaterial), CI.getElectricMotor(aVoltageTier, 1), OrePrefixes.plate.get(aMaterial),
+				OrePrefixes.screw.get(aMaterial), aBattery, OrePrefixes.screw.get(aMaterial), 
+				aOutputStack);
+		    
+	}
+
+}
\ No newline at end of file
diff --git a/src/main/java/gtPlusPlus/xmod/gregtech/loaders/ProcessingElectricLighter.java b/src/main/java/gtPlusPlus/xmod/gregtech/loaders/ProcessingElectricLighter.java
new file mode 100644
index 0000000000..5f6c5a0427
--- /dev/null
+++ b/src/main/java/gtPlusPlus/xmod/gregtech/loaders/ProcessingElectricLighter.java
@@ -0,0 +1,131 @@
+
+package gtPlusPlus.xmod.gregtech.loaders;
+
+import gregtech.api.enums.GT_Values;
+import gregtech.api.enums.ItemList;
+import gregtech.api.enums.Materials;
+import gregtech.api.enums.OrePrefixes;
+import gregtech.api.enums.SubTag;
+import gregtech.api.util.GT_ModHandler;
+import gregtech.api.util.GT_ModHandler.RecipeBits;
+import gregtech.api.util.GT_OreDictUnificator;
+import gregtech.common.items.GT_MetaGenerated_Tool_01;
+import gtPlusPlus.api.objects.Logger;
+import gtPlusPlus.core.material.ELEMENT;
+import gtPlusPlus.core.recipe.common.CI;
+import gtPlusPlus.core.util.minecraft.MaterialUtils;
+import gtPlusPlus.core.util.minecraft.RecipeUtils;
+import gtPlusPlus.xmod.gregtech.api.enums.GregtechOrePrefixes;
+import gtPlusPlus.xmod.gregtech.api.enums.GregtechOrePrefixes.GT_Materials;
+import gtPlusPlus.xmod.gregtech.api.interfaces.internal.Interface_OreRecipeRegistrator;
+import gtPlusPlus.xmod.gregtech.common.items.MetaGeneratedGregtechTools;
+import net.minecraft.item.ItemStack;
+
+public class ProcessingElectricLighter implements Interface_OreRecipeRegistrator, Runnable {
+	public ProcessingElectricLighter() {
+		GregtechOrePrefixes.toolElectricLighter.add(this);
+	}
+
+	@Override
+	public void registerOre(final GregtechOrePrefixes aPrefix, final Materials aMaterial, final String aOreDictName,
+			final String aModName, final ItemStack aStack) {
+		if ((aMaterial != Materials.Stone) && (aMaterial != Materials.Flint)) {
+			if (aMaterial != Materials.Rubber) {
+				if ((!aMaterial.contains(SubTag.WOOD)) && (!aMaterial.contains(SubTag.BOUNCY))
+						&& (!aMaterial.contains(SubTag.NO_SMASHING))) {
+					
+				}
+			}
+		}
+	}
+
+	@Override
+	public void registerOre(final GregtechOrePrefixes aPrefix, final GT_Materials aMaterial, final String aOreDictName,
+			final String aModName, final ItemStack aStack) {
+		// TODO Auto-generated method stub
+
+	}
+
+	public void materialsLoops() {
+		final Materials[] i = Materials.values();
+		final int size = i.length;
+		Logger.MATERIALS("Materials to attempt tool gen. with: " + size);
+		int used = 0;
+		Materials aMaterial = null;
+		for (int r = 0; r < size; r++) {
+			aMaterial = i[r];
+			if ((aMaterial != Materials.Stone) && (aMaterial != Materials.Flint) && (aMaterial != Materials.Rubber)
+					&& (aMaterial != Materials._NULL)) {
+				if ((!aMaterial.contains(SubTag.WOOD)) && (!aMaterial.contains(SubTag.BOUNCY))
+						&& (!aMaterial.contains(SubTag.NO_SMASHING)) && (!aMaterial.contains(SubTag.TRANSPARENT))
+						&& (!aMaterial.contains(SubTag.FLAMMABLE)) && (!aMaterial.contains(SubTag.MAGICAL))
+						&& (!aMaterial.contains(SubTag.NO_SMELTING))) {
+					Logger.MATERIALS("Generating Electric Lighter from "+MaterialUtils.getMaterialName(aMaterial));
+					// Input 1
+					
+
+					final ItemStack plate = GT_OreDictUnificator.get(OrePrefixes.plate, aMaterial, 1L);
+
+					if ((null != plate)) {						
+					     addRecipe(aMaterial, 1600000L, 3, ItemList.Battery_RE_HV_Lithium.get(1));
+					     addRecipe(aMaterial, 1200000L, 3, ItemList.Battery_RE_HV_Cadmium.get(1));
+					     addRecipe(aMaterial, 800000L, 3, ItemList.Battery_RE_HV_Sodium.get(1));						
+						used++;
+					} else {
+						Logger.MATERIALS("Unable to generate Electric Lighter from "+MaterialUtils.getMaterialName(aMaterial)+", Plate or Long Rod may be invalid. Invalid | Plate? "+(plate == null) +" | Rod? "+" |");
+					}
+					// GT_ModHandler.addCraftingRecipe(,
+					// GT_ModHandler.RecipeBits.DO_NOT_CHECK_FOR_COLLISIONS |
+					// GT_ModHandler.RecipeBits.BUFFERED, new Object[]{"P H", "PIP", " I ",
+					// Character.valueOf('I'), OrePrefixes.ingot.get(aMaterial),
+					// Character.valueOf('P'), OrePrefixes.plate.get(aMaterial),
+					// Character.valueOf('H'), OrePrefixes.toolHeadHammer.get(aMaterial)});
+				} else {
+					Logger.MATERIALS("Unable to generate Electric Lighter from "+MaterialUtils.getMaterialName(aMaterial));
+				}
+			} else {
+				Logger.MATERIALS("Unable to generate Electric Lighter from "+MaterialUtils.getMaterialName(aMaterial));
+			}
+
+		}
+
+		Logger.INFO("Materials used for tool gen: " + used);
+	}
+
+	@Override
+	public void run() {
+		Logger.INFO("Generating Electric Lighters for all valid GT Materials.");
+		this.materialsLoops();
+	}
+	
+	public boolean addRecipe(Materials aMaterial, long aBatteryStorage, int aVoltageTier, ItemStack aBattery) {
+		
+		ItemStack aOutputStack = MetaGeneratedGregtechTools.INSTANCE.getToolWithStats(
+				 MetaGeneratedGregtechTools.ELECTRIC_LIGHTER,
+				 1,
+				 aMaterial,
+				 Materials.Titanium, 
+				 new long[]{aBatteryStorage, GT_Values.V[aVoltageTier], 3L, -1L});
+		
+		ItemStack aInputCutter = GT_MetaGenerated_Tool_01.INSTANCE.getToolWithStats(
+				GT_MetaGenerated_Tool_01.SOLDERING_IRON_LV,
+				 1,
+				 aMaterial,
+				 aMaterial, 
+				 null);
+
+		long aDura = MetaGeneratedGregtechTools.getToolMaxDamage(aOutputStack);	
+		if (aDura <= 32000) {
+			Logger.MATERIALS("Unable to generate Electric Lighter from "+MaterialUtils.getMaterialName(aMaterial)+", Durability: "+aDura);
+			return false;
+		}
+		
+		return RecipeUtils.addShapedRecipe(
+				OrePrefixes.wireGt04.get(Materials.Gold), aInputCutter, OrePrefixes.wireGt04.get(Materials.Gold),
+				ELEMENT.STANDALONE.RUNITE.getPlate(1), CI.getSensor(aVoltageTier, 1), ELEMENT.STANDALONE.RUNITE.getPlate(1), 
+				OrePrefixes.plate.get(aMaterial), aBattery, OrePrefixes.plate.get(aMaterial), 
+				aOutputStack);
+		    
+	}
+
+}
\ No newline at end of file
diff --git a/src/main/java/gtPlusPlus/xmod/gregtech/loaders/ProcessingElectricSnips.java b/src/main/java/gtPlusPlus/xmod/gregtech/loaders/ProcessingElectricSnips.java
new file mode 100644
index 0000000000..dfcb7de4f8
--- /dev/null
+++ b/src/main/java/gtPlusPlus/xmod/gregtech/loaders/ProcessingElectricSnips.java
@@ -0,0 +1,130 @@
+
+package gtPlusPlus.xmod.gregtech.loaders;
+
+import gregtech.api.enums.GT_Values;
+import gregtech.api.enums.ItemList;
+import gregtech.api.enums.Materials;
+import gregtech.api.enums.OrePrefixes;
+import gregtech.api.enums.SubTag;
+import gregtech.api.util.GT_ModHandler;
+import gregtech.api.util.GT_ModHandler.RecipeBits;
+import gregtech.api.util.GT_OreDictUnificator;
+import gregtech.common.items.GT_MetaGenerated_Tool_01;
+import gtPlusPlus.api.objects.Logger;
+import gtPlusPlus.core.material.ELEMENT;
+import gtPlusPlus.core.recipe.common.CI;
+import gtPlusPlus.core.util.minecraft.MaterialUtils;
+import gtPlusPlus.core.util.minecraft.RecipeUtils;
+import gtPlusPlus.xmod.gregtech.api.enums.GregtechOrePrefixes;
+import gtPlusPlus.xmod.gregtech.api.enums.GregtechOrePrefixes.GT_Materials;
+import gtPlusPlus.xmod.gregtech.api.interfaces.internal.Interface_OreRecipeRegistrator;
+import gtPlusPlus.xmod.gregtech.common.items.MetaGeneratedGregtechTools;
+import net.minecraft.item.ItemStack;
+
+public class ProcessingElectricSnips implements Interface_OreRecipeRegistrator, Runnable {
+	public ProcessingElectricSnips() {
+		GregtechOrePrefixes.toolElectricSnips.add(this);
+	}
+
+	@Override
+	public void registerOre(final GregtechOrePrefixes aPrefix, final Materials aMaterial, final String aOreDictName,
+			final String aModName, final ItemStack aStack) {
+		if ((aMaterial != Materials.Stone) && (aMaterial != Materials.Flint)) {
+			if (aMaterial != Materials.Rubber) {
+				if ((!aMaterial.contains(SubTag.WOOD)) && (!aMaterial.contains(SubTag.BOUNCY))
+						&& (!aMaterial.contains(SubTag.NO_SMASHING))) {
+					
+				}
+			}
+		}
+	}
+
+	@Override
+	public void registerOre(final GregtechOrePrefixes aPrefix, final GT_Materials aMaterial, final String aOreDictName,
+			final String aModName, final ItemStack aStack) {
+		// TODO Auto-generated method stub
+
+	}
+
+	public void materialsLoops() {
+		final Materials[] i = Materials.values();
+		final int size = i.length;
+		Logger.MATERIALS("Materials to attempt tool gen. with: " + size);
+		int used = 0;
+		Materials aMaterial = null;
+		for (int r = 0; r < size; r++) {
+			aMaterial = i[r];
+			if ((aMaterial != Materials.Stone) && (aMaterial != Materials.Flint) && (aMaterial != Materials.Rubber)
+					&& (aMaterial != Materials._NULL)) {
+				if ((!aMaterial.contains(SubTag.WOOD)) && (!aMaterial.contains(SubTag.BOUNCY))
+						&& (!aMaterial.contains(SubTag.NO_SMASHING)) && (!aMaterial.contains(SubTag.TRANSPARENT))
+						&& (!aMaterial.contains(SubTag.FLAMMABLE)) && (!aMaterial.contains(SubTag.MAGICAL))
+						&& (!aMaterial.contains(SubTag.NO_SMELTING))) {
+					Logger.MATERIALS("Generating Electric Snips from "+MaterialUtils.getMaterialName(aMaterial));
+					// Input 1
+					
+
+					final ItemStack plate = GT_OreDictUnificator.get(OrePrefixes.plate, aMaterial, 1L);
+
+					if ((null != plate)) {						
+					     addRecipe(aMaterial, 1600000L, 3, ItemList.Battery_RE_HV_Lithium.get(1));
+					     addRecipe(aMaterial, 1200000L, 3, ItemList.Battery_RE_HV_Cadmium.get(1));
+					     addRecipe(aMaterial, 800000L, 3, ItemList.Battery_RE_HV_Sodium.get(1));						
+						used++;
+					} else {
+						Logger.MATERIALS("Unable to generate Electric Snips from "+MaterialUtils.getMaterialName(aMaterial)+", Plate or Long Rod may be invalid. Invalid | Plate? "+(plate == null) +" | Rod? "+" |");
+					}
+					// GT_ModHandler.addCraftingRecipe(,
+					// GT_ModHandler.RecipeBits.DO_NOT_CHECK_FOR_COLLISIONS |
+					// GT_ModHandler.RecipeBits.BUFFERED, new Object[]{"P H", "PIP", " I ",
+					// Character.valueOf('I'), OrePrefixes.ingot.get(aMaterial),
+					// Character.valueOf('P'), OrePrefixes.plate.get(aMaterial),
+					// Character.valueOf('H'), OrePrefixes.toolHeadHammer.get(aMaterial)});
+				} else {
+					Logger.MATERIALS("Unable to generate Electric Snips from "+MaterialUtils.getMaterialName(aMaterial));
+				}
+			} else {
+				Logger.MATERIALS("Unable to generate Electric Snips from "+MaterialUtils.getMaterialName(aMaterial));
+			}
+
+		}
+
+		Logger.INFO("Materials used for tool gen: " + used);
+	}
+
+	@Override
+	public void run() {
+		Logger.INFO("Generating Electric Snips for all valid GT Materials.");
+		this.materialsLoops();
+	}
+	
+	public boolean addRecipe(Materials aMaterial, long aBatteryStorage, int aVoltageTier, ItemStack aBattery) {
+		
+		ItemStack aOutputStack = MetaGeneratedGregtechTools.INSTANCE.getToolWithStats(
+				 MetaGeneratedGregtechTools.ELECTRIC_SNIPS,
+				 1,
+				 aMaterial,
+				 Materials.Titanium, 
+				 new long[]{aBatteryStorage, GT_Values.V[aVoltageTier], 3L, -1L});
+		
+		ItemStack aInputCutter = GT_MetaGenerated_Tool_01.INSTANCE.getToolWithStats(
+				GT_MetaGenerated_Tool_01.WIRECUTTER,
+				 1,
+				 aMaterial,
+				 aMaterial, 
+				 null);
+
+		long aDura = MetaGeneratedGregtechTools.getToolMaxDamage(aOutputStack);	
+		if (aDura <= 32000) {
+			Logger.MATERIALS("Unable to generate Electric Snips from "+MaterialUtils.getMaterialName(aMaterial)+", Durability: "+aDura);
+			return false;
+		}
+		return RecipeUtils.addShapedRecipe(
+				OrePrefixes.wireFine.get(Materials.Electrum), aInputCutter, OrePrefixes.wireFine.get(Materials.Electrum),
+				ELEMENT.STANDALONE.WHITE_METAL.getGear(1), CI.getElectricMotor(aVoltageTier, 1), ELEMENT.STANDALONE.WHITE_METAL.getGear(1), 
+				OrePrefixes.plate.get(aMaterial), aBattery, OrePrefixes.plate.get(aMaterial), 
+				aOutputStack);
+		    
+	}
+
+}
\ No newline at end of file
diff --git a/src/main/java/gtPlusPlus/xmod/gregtech/loaders/ProcessingToolHeadChoocher.java b/src/main/java/gtPlusPlus/xmod/gregtech/loaders/ProcessingToolHeadChoocher.java
new file mode 100644
index 0000000000..e4858f8cd1
--- /dev/null
+++ b/src/main/java/gtPlusPlus/xmod/gregtech/loaders/ProcessingToolHeadChoocher.java
@@ -0,0 +1,92 @@
+package gtPlusPlus.xmod.gregtech.loaders;
+
+import net.minecraft.item.ItemStack;
+
+import gregtech.api.enums.*;
+import gregtech.api.util.GT_ModHandler;
+import gregtech.api.util.GT_OreDictUnificator;
+
+import gtPlusPlus.api.objects.Logger;
+import gtPlusPlus.core.util.minecraft.RecipeUtils;
+import gtPlusPlus.xmod.gregtech.api.enums.GregtechOrePrefixes;
+import gtPlusPlus.xmod.gregtech.api.enums.GregtechOrePrefixes.GT_Materials;
+import gtPlusPlus.xmod.gregtech.api.interfaces.internal.Interface_OreRecipeRegistrator;
+import gtPlusPlus.xmod.gregtech.common.items.MetaGeneratedGregtechTools;
+
+public class ProcessingToolHeadChoocher implements Interface_OreRecipeRegistrator, Runnable {
+	public ProcessingToolHeadChoocher() {
+		GregtechOrePrefixes.toolSkookumChoocher.add(this);
+	}
+
+	@Override
+	public void registerOre(final GregtechOrePrefixes aPrefix, final Materials aMaterial, final String aOreDictName, final String aModName, final ItemStack aStack) {
+		if ((aMaterial != Materials.Stone) && (aMaterial != Materials.Flint)) {
+			if (aMaterial != Materials.Rubber) {
+				if ((!aMaterial.contains(SubTag.WOOD)) && (!aMaterial.contains(SubTag.BOUNCY)) && (!aMaterial.contains(SubTag.NO_SMASHING))) {
+					GT_ModHandler.addCraftingRecipe(MetaGeneratedGregtechTools.INSTANCE.getToolWithStats(16, 1, aMaterial, aMaterial, null), GT_ModHandler.RecipeBits.DO_NOT_CHECK_FOR_COLLISIONS | GT_ModHandler.RecipeBits.BUFFERED, new Object[]{"IhI", "III", " I ", Character.valueOf('I'), OrePrefixes.ingot.get(aMaterial)});
+				}
+			}
+		}
+	}
+
+	@Override
+	public void registerOre(final GregtechOrePrefixes aPrefix,
+			final GT_Materials aMaterial, final String aOreDictName, final String aModName,
+			final ItemStack aStack) {
+		// TODO Auto-generated method stub
+
+	}
+
+	public void materialsLoops(){
+		final Materials[] i = Materials.values();
+		final int size = i.length;
+		Logger.WARNING("Materials to attempt tool gen. with: "+size);
+		int used = 0;
+		Materials aMaterial = null;
+		for (int r=0;r<size;r++){
+			aMaterial = i[r];
+			if ((aMaterial != Materials.Stone) && (aMaterial != Materials.Flint) && (aMaterial != Materials.Rubber) && (aMaterial != Materials._NULL)) {
+				if ((!aMaterial.contains(SubTag.WOOD)) && (!aMaterial.contains(SubTag.BOUNCY)) && (!aMaterial.contains(SubTag.NO_SMASHING))&& (!aMaterial.contains(SubTag.TRANSPARENT))&& (!aMaterial.contains(SubTag.FLAMMABLE))&& (!aMaterial.contains(SubTag.MAGICAL))&& (!aMaterial.contains(SubTag.NO_SMELTING))) {
+					Logger.WARNING("Found "+aMaterial.name()+" as a valid Skookum Choocher Material.");
+					//Input 1
+					final ItemStack plate = GT_OreDictUnificator.get(OrePrefixes.plate, aMaterial, 1L);
+					final ItemStack ingot = GT_OreDictUnificator.get(OrePrefixes.ingot, aMaterial, 1L);
+					final ItemStack screw = GT_OreDictUnificator.get(OrePrefixes.screw, aMaterial, 1L);
+					final ItemStack longrod = GT_OreDictUnificator.get(OrePrefixes.stickLong, aMaterial, 1L);
+					final ItemStack hammerhead = GT_OreDictUnificator.get(OrePrefixes.toolHeadHammer, aMaterial, 1L);
+
+					if ((null != plate) && (null != ingot) && (null != hammerhead) && (null != longrod) && (null != screw)){
+						RecipeUtils.addShapedRecipe(
+								hammerhead, ToolDictNames.craftingToolScrewdriver.name(), plate,
+								ingot, plate, plate,
+								longrod, screw, null,
+								MetaGeneratedGregtechTools.INSTANCE.getToolWithStats(MetaGeneratedGregtechTools.SKOOKUM_CHOOCHER, 1, aMaterial, null, null));
+						used++;
+					}
+					else {
+						Logger.WARNING(""+aMaterial.name()+" could not be used for all input compoenents. [3x"+aMaterial.name()+" plates, 2x"+aMaterial.name()+" ingots, 1x"+aMaterial.name()+" Hard Hammer Head.");
+					}
+					//GT_ModHandler.addCraftingRecipe(, GT_ModHandler.RecipeBits.DO_NOT_CHECK_FOR_COLLISIONS | GT_ModHandler.RecipeBits.BUFFERED, new Object[]{"P H", "PIP", " I ", Character.valueOf('I'), OrePrefixes.ingot.get(aMaterial), Character.valueOf('P'), OrePrefixes.plate.get(aMaterial), Character.valueOf('H'), OrePrefixes.toolHeadHammer.get(aMaterial)});
+				}
+				else {
+					Logger.WARNING(""+aMaterial.name()+" was not a valid Skookum Choocher Material.");
+				}
+			}
+			else {
+				Logger.WARNING(""+aMaterial.name()+" was not a valid Skookum Choocher Material.");
+			}
+
+
+		}
+
+		Logger.INFO("Materials used for tool gen: "+used);
+	}
+
+	@Override
+	public void run() {
+		Logger.INFO("Generating Skookum Choochers of all GT Materials.");
+		this.materialsLoops();
+	}
+
+
+}
\ No newline at end of file
diff --git a/src/main/java/gtPlusPlus/xmod/gregtech/loaders/Processing_Textures_Items.java b/src/main/java/gtPlusPlus/xmod/gregtech/loaders/Processing_Textures_Items.java
new file mode 100644
index 0000000000..ae559db232
--- /dev/null
+++ b/src/main/java/gtPlusPlus/xmod/gregtech/loaders/Processing_Textures_Items.java
@@ -0,0 +1,11 @@
+package gtPlusPlus.xmod.gregtech.loaders;
+
+import gtPlusPlus.xmod.gregtech.api.enums.GregtechTextures.ItemIcons.CustomIcon;
+
+public class Processing_Textures_Items {
+
+	public static final CustomIcon itemSkookumChoocher = new CustomIcon("iconsets/SKOOKUMCHOOCHER");
+	public static final CustomIcon itemElectricPump = new CustomIcon("iconsets/PUMP");
+
+}
+
diff --git a/src/main/java/gtPlusPlus/xmod/gregtech/loaders/RecipeGen_AlloySmelter.java b/src/main/java/gtPlusPlus/xmod/gregtech/loaders/RecipeGen_AlloySmelter.java
new file mode 100644
index 0000000000..7754d039cf
--- /dev/null
+++ b/src/main/java/gtPlusPlus/xmod/gregtech/loaders/RecipeGen_AlloySmelter.java
@@ -0,0 +1,66 @@
+package gtPlusPlus.xmod.gregtech.loaders;
+
+import java.util.HashSet;
+import java.util.Set;
+
+import gregtech.api.enums.GT_Values;
+import gregtech.api.enums.ItemList;
+
+import gtPlusPlus.api.interfaces.RunnableWithInfo;
+import gtPlusPlus.core.material.Material;
+import gtPlusPlus.core.material.MaterialGenerator;
+import gtPlusPlus.core.util.minecraft.ItemUtils;
+
+public class RecipeGen_AlloySmelter extends RecipeGen_Base {
+
+	public final static Set<RunnableWithInfo<Material>> mRecipeGenMap = new HashSet<RunnableWithInfo<Material>>();
+	static {
+		MaterialGenerator.mRecipeMapsToGenerate.put(mRecipeGenMap);
+	}
+
+	public RecipeGen_AlloySmelter(final Material M){
+		this.toGenerate = M;
+		mRecipeGenMap.add(this);
+	}
+
+	@Override
+	public void run() {
+		generateRecipes(this.toGenerate);
+	}
+
+	private void generateRecipes(final Material material){
+		final int tVoltageMultiplier = material.vVoltageMultiplier;
+
+		
+		
+		//Nuggets
+		if (ItemUtils.checkForInvalidItems(material.getIngot(1)) && ItemUtils.checkForInvalidItems(material.getNugget(1)))
+		GT_Values.RA.addAlloySmelterRecipe(
+				material.getIngot(1),
+				ItemList.Shape_Mold_Nugget.get(0),
+				material.getNugget(9),
+				(int) Math.max(material.getMass() * 2L, 1L),
+				tVoltageMultiplier);
+
+		//Gears
+		if (ItemUtils.checkForInvalidItems(material.getIngot(1)) && ItemUtils.checkForInvalidItems(material.getGear(1)))
+		GT_Values.RA.addAlloySmelterRecipe(
+				material.getIngot(8),
+				ItemList.Shape_Mold_Gear.get(0),
+				material.getGear(1),
+				(int) Math.max(material.getMass() * 2L, 1L),
+				tVoltageMultiplier);
+		
+		//Ingot
+		if (ItemUtils.checkForInvalidItems(material.getIngot(1)) && ItemUtils.checkForInvalidItems(material.getNugget(1)))
+		GT_Values.RA.addAlloySmelterRecipe(
+				material.getNugget(9),
+				ItemList.Shape_Mold_Ingot.get(0),
+				material.getIngot(1),
+				(int) Math.max(material.getMass() * 2L, 1L),
+				tVoltageMultiplier);
+
+	}
+
+}
+
diff --git a/src/main/java/gtPlusPlus/xmod/gregtech/loaders/RecipeGen_Assembler.java b/src/main/java/gtPlusPlus/xmod/gregtech/loaders/RecipeGen_Assembler.java
new file mode 100644
index 0000000000..d7244919d8
--- /dev/null
+++ b/src/main/java/gtPlusPlus/xmod/gregtech/loaders/RecipeGen_Assembler.java
@@ -0,0 +1,81 @@
+package gtPlusPlus.xmod.gregtech.loaders;
+
+import java.util.HashSet;
+import java.util.Set;
+
+import net.minecraft.item.ItemStack;
+
+import gregtech.api.enums.GT_Values;
+
+import gtPlusPlus.api.interfaces.RunnableWithInfo;
+import gtPlusPlus.core.material.Material;
+import gtPlusPlus.core.material.MaterialGenerator;
+import gtPlusPlus.core.util.minecraft.FluidUtils;
+import gtPlusPlus.core.util.minecraft.ItemUtils;
+
+public class RecipeGen_Assembler extends RecipeGen_Base {
+
+	public final static Set<RunnableWithInfo<Material>> mRecipeGenMap = new HashSet<RunnableWithInfo<Material>>();
+	static {
+		MaterialGenerator.mRecipeMapsToGenerate.put(mRecipeGenMap);
+	}
+
+	public RecipeGen_Assembler(final Material M){
+		this.toGenerate = M;
+		mRecipeGenMap.add(this);
+	}
+
+	@Override
+	public void run() {
+		generateRecipes(this.toGenerate);
+	}
+
+	private void generateRecipes(final Material material){
+
+		//Frame Box
+		if (ItemUtils.checkForInvalidItems(new ItemStack[] {material.getRod(1), material.getFrameBox(1)}))
+		GT_Values.RA.addAssemblerRecipe(
+				material.getRod(4),
+				ItemUtils.getGregtechCircuit(4),
+				material.getFrameBox(1),
+				60,
+				material.vVoltageMultiplier);
+
+		//Rotor
+		if (ItemUtils.checkForInvalidItems(new ItemStack[] {material.getPlate(1), material.getRing(1), material.getRotor(1)}))
+		addAssemblerRecipe(
+				material.getPlate(4),
+				material.getRing(1),
+				material.getRotor(1),
+				240,
+				material.vVoltageMultiplier);
+
+	}
+
+	private static void addAssemblerRecipe(final ItemStack input1, final ItemStack input2, final ItemStack output1, final int seconds, final int euCost){
+		GT_Values.RA.addAssemblerRecipe(
+				input1,
+				input2,
+				FluidUtils.getFluidStack("molten.solderingalloy", 16),
+				output1,
+				seconds,
+				euCost);
+		GT_Values.RA.addAssemblerRecipe(
+				input1,
+				input2,
+				FluidUtils.getFluidStack("molten.tin", 32),
+				output1,
+				seconds,
+				euCost);
+		GT_Values.RA.addAssemblerRecipe(
+				input1,
+				input2,
+				FluidUtils.getFluidStack("molten.lead", 48),
+				output1,
+				seconds,
+				euCost);
+	}
+
+
+}
+
diff --git a/src/main/java/gtPlusPlus/xmod/gregtech/loaders/RecipeGen_Base.java b/src/main/java/gtPlusPlus/xmod/gregtech/loaders/RecipeGen_Base.java
new file mode 100644
index 0000000000..7e9153679f
--- /dev/null
+++ b/src/main/java/gtPlusPlus/xmod/gregtech/loaders/RecipeGen_Base.java
@@ -0,0 +1,16 @@
+package gtPlusPlus.xmod.gregtech.loaders;
+
+import gtPlusPlus.api.interfaces.RunnableWithInfo;
+import gtPlusPlus.core.material.Material;
+
+public abstract class RecipeGen_Base implements RunnableWithInfo<Material>{
+
+	protected Material toGenerate;
+	protected boolean disableOptional;
+	
+	@Override
+	public Material getInfoData() {
+		return toGenerate;
+	}
+
+}
diff --git a/src/main/java/gtPlusPlus/xmod/gregtech/loaders/RecipeGen_BlastSmelter.java b/src/main/java/gtPlusPlus/xmod/gregtech/loaders/RecipeGen_BlastSmelter.java
new file mode 100644
index 0000000000..9e58d486d3
--- /dev/null
+++ b/src/main/java/gtPlusPlus/xmod/gregtech/loaders/RecipeGen_BlastSmelter.java
@@ -0,0 +1,280 @@
+package gtPlusPlus.xmod.gregtech.loaders;
+
+import java.util.ArrayList;
+import java.util.HashSet;
+import java.util.Set;
+
+import gregtech.api.enums.GT_Values;
+import gregtech.api.enums.ItemList;
+import gtPlusPlus.api.interfaces.RunnableWithInfo;
+import gtPlusPlus.api.objects.Logger;
+import gtPlusPlus.core.lib.CORE;
+import gtPlusPlus.core.material.ALLOY;
+import gtPlusPlus.core.material.Material;
+import gtPlusPlus.core.material.MaterialGenerator;
+import gtPlusPlus.core.material.MaterialStack;
+import gtPlusPlus.core.material.nuclear.FLUORIDES;
+import gtPlusPlus.core.material.nuclear.NUCLIDE;
+import gtPlusPlus.core.material.state.MaterialState;
+import gtPlusPlus.core.util.minecraft.FluidUtils;
+import gtPlusPlus.core.util.minecraft.ItemUtils;
+import gtPlusPlus.core.util.minecraft.MaterialUtils;
+import net.minecraft.item.ItemStack;
+import net.minecraftforge.fluids.FluidStack;
+
+public class RecipeGen_BlastSmelter extends RecipeGen_Base {
+
+	public final static Set<RunnableWithInfo<Material>> mRecipeGenMap = new HashSet<RunnableWithInfo<Material>>();
+	static {
+		MaterialGenerator.mRecipeMapsToGenerate.put(mRecipeGenMap);
+	}
+
+	public RecipeGen_BlastSmelter(final Material M){
+		this.toGenerate = M;
+		mRecipeGenMap.add(this);
+	}
+
+	@Override
+	public void run() {
+		generateARecipe(this.toGenerate);
+	}
+
+	private void generateARecipe(final Material M){
+
+		//Add a Blast Smelting Recipe, Let's go!
+		ItemStack tStack;
+		if (null != (tStack = M.getDust(1))) {
+
+			final Material[] badMaterials = {
+					FLUORIDES.THORIUM_HEXAFLUORIDE,
+					FLUORIDES.THORIUM_TETRAFLUORIDE,
+					ALLOY.BLOODSTEEL,
+					NUCLIDE.LiFBeF2ThF4UF4,
+					NUCLIDE.LiFBeF2ZrF4UF4,
+					NUCLIDE.LiFBeF2ZrF4U235
+			};
+			for (final Material R : badMaterials){
+				if (M == R){
+					return;
+				}
+			}
+
+			//Prepare some Variables
+			ItemStack[] components;
+			ArrayList<MaterialStack> tMaterial = new ArrayList<>();
+			int inputStackCount=0;
+			int fluidAmount=0;
+			final boolean doTest = true;
+			tMaterial = M.getComposites();
+
+			//This Bad boy here is what dictates unique recipes. Fuck life, right?
+			ItemStack circuitGT = ItemUtils.getGregtechCircuit(0);
+
+
+			//Set a duration - OLD
+			/*int duration = 0;
+			if (M.getMeltingPointK() > 150){
+				duration = (int) Math.max(M.getMass() / 50L, 1L) * M.getMeltingPointK();
+			}
+			else {
+				duration = (int) Math.max(M.getMass() / 50L, 1L) * 150;
+			}*/
+						
+			long aVoltage = MaterialUtils.getVoltageForTier(M.vTier);
+			
+			
+			//Set a duration - NEW
+			int duration = 120*M.vTier*10;
+
+			if (M.vTier <= 4){
+				duration = 20*M.vTier*10;
+			}
+
+			int mMaterialListSize=0;
+			
+			int mTotalPartsCounter = M.smallestStackSizeWhenProcessing;
+			
+			if (M.getComposites() != null){
+				for (final gtPlusPlus.core.material.MaterialStack ternkfsdf : M.getComposites()){
+					if (ternkfsdf != null) {
+						mMaterialListSize++;
+						//mTotalPartsCounter += ternkfsdf.getSmallestStackSizes()[0];
+					}
+				}
+			}
+			else {
+				mMaterialListSize = 1;
+			}
+
+			if (duration <= 0){
+				final int second = 20;
+				duration = 14*second*mMaterialListSize*8;
+			}
+
+			Logger.WARNING("[BAS] Size: "+mMaterialListSize);
+
+
+			//Make a simple one Material Materialstack[] and log it for validity.
+			circuitGT = ItemUtils.getGregtechCircuit(1);
+			final ItemStack[] tItemStackTest = new ItemStack[]{circuitGT, tStack};
+			inputStackCount = 1;
+			fluidAmount = 144*inputStackCount;
+			Logger.WARNING("[BAS] Adding an Alloy Blast Smelter Recipe for "+M.getLocalizedName()+". Gives "+fluidAmount+"L of molten metal.");
+			for (int das=0;das<tItemStackTest.length;das++){
+				if (tItemStackTest[das] != null) {
+					Logger.WARNING("[BAS] tMaterial["+das+"]: "+tItemStackTest[das].getDisplayName()+" Meta: "+tItemStackTest[das].getItemDamage()+", Amount: "+tItemStackTest[das].stackSize);
+				}
+			}
+
+			final boolean hasMoreInputThanACircuit = (tItemStackTest.length > 1);
+
+			//Generate Recipes for all singular materials that can be made molten.
+			if (hasMoreInputThanACircuit){
+				if (M.requiresBlastFurnace()) {
+					if (CORE.RA.addBlastSmelterRecipe(tItemStackTest, M.getFluidStack(fluidAmount), 100, (duration/(mTotalPartsCounter > 0 ? mTotalPartsCounter : 1)), (int) aVoltage)){
+						Logger.WARNING("[BAS] Success.");
+						Logger.WARNING("[BAS] Success, Also added a Fluid solidifier recipe.");
+						if (GT_Values.RA.addFluidExtractionRecipe(M.getIngot(1), null, M.getFluidStack(144), 100, duration, 120)){
+							Logger.WARNING("[BAS] Success, Also added a Fluid Extractor recipe.");
+						}
+						if (GT_Values.RA.addFluidExtractionRecipe(M.getNugget(1), null, M.getFluidStack(16), 100, duration/9, 120)){
+							Logger.WARNING("[BAS] Success, Also added a Fluid Extractor recipe.");
+						}
+						/*if (GT_Values.RA.addFluidExtractionRecipe(M.getSmallDust(1), null, M.getFluid(36), 100, duration/4, 120)){
+							Logger.WARNING("[BAS] Success, Also added a Fluid Extractor recipe.");
+						}
+						if (GT_Values.RA.addFluidExtractionRecipe(M.getTinyDust(1), null, M.getFluid(16), 100, duration/9, 120)){
+							Logger.WARNING("[BAS] Success, Also added a Fluid Extractor recipe.");
+						}*/
+					}
+				}
+				else {
+					Logger.WARNING("[BAS] Failed.");
+				}
+			}
+			else {
+				if (CORE.RA.addBlastSmelterRecipe(tItemStackTest, M.getFluidStack(fluidAmount), 100, duration/(mTotalPartsCounter > 0 ? mTotalPartsCounter : 1)/2, (int) aVoltage)){
+					Logger.WARNING("[BAS] Success.");
+					if (GT_Values.RA.addFluidSolidifierRecipe(ItemList.Shape_Mold_Ingot.get(0), M.getFluidStack(144), M.getIngot(1), duration/2, 60)){
+						Logger.WARNING("[BAS] Success, Also added a Fluid solidifier recipe.");
+						if (GT_Values.RA.addFluidExtractionRecipe(M.getIngot(1), null, M.getFluidStack(144), 100, duration/2, 60)){
+							Logger.WARNING("[BAS] Success, Also added a Fluid Extractor recipe.");
+						}
+						if (GT_Values.RA.addFluidExtractionRecipe(M.getNugget(1), null, M.getFluidStack(16), 100, duration/2/9, 60)){
+							Logger.WARNING("[BAS] Success, Also added a Fluid Extractor recipe.");
+						}
+						/*if (GT_Values.RA.addFluidExtractionRecipe(M.getSmallDust(1), null, M.getFluid(36), 100, duration/2/4, 60)){
+							Logger.WARNING("[BAS] Success, Also added a Fluid Extractor recipe.");
+						}
+						if (GT_Values.RA.addFluidExtractionRecipe(M.getTinyDust(1), null, M.getFluid(16), 100, duration/2/9, 60)){
+							Logger.WARNING("[BAS] Success, Also added a Fluid Extractor recipe.");
+						}*/
+					}
+				}
+				else {
+					Logger.WARNING("[BAS] Failed.");
+				}
+			}
+
+			if (tMaterial != null){
+				//Reset the Variables for compounds if last recipe was a success.
+				inputStackCount=0;
+				
+				//If this Material has some kind of compound list, proceed
+				if (mMaterialListSize > 1){
+					final gtPlusPlus.core.material.MaterialStack[] tempStack = new gtPlusPlus.core.material.MaterialStack[mMaterialListSize];
+					circuitGT = ItemUtils.getGregtechCircuit(mMaterialListSize);
+					//Just double checking
+					if (tempStack.length > 1){
+
+						//Builds me a MaterialStack[] from the MaterialList of M.
+						int ooo=0;
+						for (final gtPlusPlus.core.material.MaterialStack xMaterial : M.getComposites()){
+							if (xMaterial != null){
+								if (xMaterial.getStackMaterial() != null){
+									Logger.WARNING("[BAS] FOUND: "+xMaterial.getStackMaterial().getLocalizedName());
+									Logger.WARNING("[BAS] ADDING: "+xMaterial.getStackMaterial().getLocalizedName());
+								}
+								tempStack[ooo] = xMaterial;
+							}
+							ooo++;
+						}
+
+						//Builds me an ItemStack[] of the materials. - Without a circuit - this gets a good count for the 144L fluid multiplier
+						components = new ItemStack[9];
+						inputStackCount=0;
+						FluidStack componentsFluid = null;
+						for (int irc=0;irc<M.getComposites().size();irc++){
+							if (M.getComposites().get(irc) != null){
+								final int r = (int) M.vSmallestRatio[irc];
+								inputStackCount = inputStackCount+r;
+								if ((M.getComposites().get(irc).getStackMaterial().getState() != MaterialState.SOLID) || !ItemUtils.checkForInvalidItems(M.getComposites().get(irc).getDustStack(r))){
+									final int xr = r;
+									if ((xr > 0) && (xr <= 100)){
+										final int mathmatics = (r*1000);
+										componentsFluid = FluidUtils.getFluidStack(M.getComposites().get(irc).getStackMaterial().getFluidStack(mathmatics), mathmatics);
+									}
+								}
+								else {
+									components[irc] = M.getComposites().get(irc).getDustStack(r);
+								}
+							}
+						}
+
+
+						//Adds a circuit
+						if ((mMaterialListSize < 9) && (mMaterialListSize != 0)){
+							final ItemStack[] components_NoCircuit = components;
+							//Builds me an ItemStack[] of the materials. - With a circuit
+							components = new ItemStack[components_NoCircuit.length+1];
+							for (int fr=0;fr<components.length;fr++){
+								if (fr==0){
+									components[0] = circuitGT;
+								}
+								else {
+									components[fr] = components_NoCircuit[fr-1];
+								}
+							}
+							Logger.WARNING("[BAS] Should have added a circuit. mMaterialListSize: "+mMaterialListSize+" | circuit: "+components[0].getDisplayName());
+						}
+						else {
+							Logger.WARNING("[BAS] Did not add a circuit. mMaterialListSize: "+mMaterialListSize);
+						}
+
+						//Set Fluid output
+						fluidAmount = 144*inputStackCount;
+
+						Logger.WARNING("[BAS] Adding an Alloy Blast Smelter Recipe for "+M.getLocalizedName()+" using it's compound dusts. This material has "+ inputStackCount+" parts. Gives "+fluidAmount+"L of molten metal.");
+						Logger.WARNING("[BAS] tMaterial.length: "+components.length+".");
+						for (int das=0;das<components.length;das++){
+							if (components[das] != null) {
+								Logger.WARNING("[BAS] tMaterial["+das+"]: "+components[das].getDisplayName()+" Meta: "+components[das].getItemDamage()+", Amount: "+components[das].stackSize);
+							}
+						}
+
+						//Adds Recipe
+						if (M.requiresBlastFurnace()) {
+							if (CORE.RA.addBlastSmelterRecipe(components, componentsFluid, M.getFluidStack(fluidAmount), 100, duration, (int) aVoltage)){
+								Logger.WARNING("[BAS] Success.");
+							}
+							else {
+								Logger.WARNING("[BAS] Failed.");
+							}
+						}
+						else {
+							if (CORE.RA.addBlastSmelterRecipe(components, componentsFluid, M.getFluidStack(fluidAmount), 100, duration, (int) aVoltage/2)){
+								Logger.WARNING("[BAS] Success.");
+							}
+							else {
+								Logger.WARNING("[BAS] Failed.");
+							}
+						}
+					}
+				}
+			}
+			else {
+				Logger.WARNING("[BAS] doTest: "+doTest+" | tMaterial != null: "+(tMaterial != null));
+			}
+		}
+	}
+}
diff --git a/src/main/java/gtPlusPlus/xmod/gregtech/loaders/RecipeGen_BlastSmelterGT_Ex.java b/src/main/java/gtPlusPlus/xmod/gregtech/loaders/RecipeGen_BlastSmelterGT_Ex.java
new file mode 100644
index 0000000000..e76b769ef6
--- /dev/null
+++ b/src/main/java/gtPlusPlus/xmod/gregtech/loaders/RecipeGen_BlastSmelterGT_Ex.java
@@ -0,0 +1,153 @@
+package gtPlusPlus.xmod.gregtech.loaders;
+
+import net.minecraft.item.ItemStack;
+
+import gregtech.api.enums.Materials;
+import gregtech.api.enums.OrePrefixes;
+import gregtech.api.enums.SubTag;
+import gregtech.api.interfaces.IOreRecipeRegistrator;
+import gregtech.api.util.GT_ModHandler;
+import gregtech.api.util.GT_OreDictUnificator;
+import gregtech.api.util.GT_Utility;
+
+import gtPlusPlus.core.lib.CORE;
+import gtPlusPlus.core.util.math.MathUtils;
+import gtPlusPlus.core.util.minecraft.ItemUtils;
+import net.minecraftforge.fluids.FluidStack;
+
+public class RecipeGen_BlastSmelterGT_Ex implements IOreRecipeRegistrator {
+
+	private final OrePrefixes[] mSmeltingPrefixes = {
+			OrePrefixes.crushed,
+			OrePrefixes.ingot,
+			OrePrefixes.crushedPurified,
+			OrePrefixes.crushedCentrifuged,
+			OrePrefixes.dust,
+			OrePrefixes.dustPure,
+			OrePrefixes.dustImpure,
+			OrePrefixes.dustRefined,
+			OrePrefixes.dustSmall,
+			OrePrefixes.dustTiny
+	};
+
+	public RecipeGen_BlastSmelterGT_Ex() {
+		for (OrePrefixes tPrefix : this.mSmeltingPrefixes) tPrefix.add(this);
+	}
+
+	@Override
+	public void registerOre(OrePrefixes aPrefix, Materials aMaterial, String aOreDictName, String aModName, ItemStack aStack) {
+
+		boolean keepHighTempRecipes = !CORE.GTNH;
+
+		switch (aPrefix) {
+		case dust:			
+			ItemStack tDustStack;
+			if (keepHighTempRecipes || aMaterial.mBlastFurnaceTemp <= 3600){
+				if ((null != (tDustStack = GT_OreDictUnificator.get(OrePrefixes.ingot, aMaterial.mSmeltInto, 1L))) && (!aMaterial.contains(SubTag.NO_SMELTING))) {
+					if (aMaterial.mBlastFurnaceRequired) {
+						addBlastRecipe(GT_Utility.copyAmount(1L, new Object[]{aStack}), null, null, null, aMaterial.mBlastFurnaceTemp > 1750 ? GT_OreDictUnificator.get(OrePrefixes.ingotHot, aMaterial.mSmeltInto, tDustStack, 1L) : GT_Utility.copyAmount(1L, new Object[]{tDustStack}), null, (int) Math.max(aMaterial.getMass() / 40L, 1L) * aMaterial.mBlastFurnaceTemp, 120, aMaterial);
+						if (aMaterial.mBlastFurnaceTemp <= 1000) {
+							GT_ModHandler.addRCBlastFurnaceRecipe(GT_Utility.copyAmount(1L, new Object[]{aStack}), GT_Utility.copyAmount(1L, new Object[]{tDustStack}), aMaterial.mBlastFurnaceTemp);
+						}
+					}
+				}
+			}
+		case ingot:
+			if (keepHighTempRecipes || aMaterial.mBlastFurnaceTemp <= 3600){
+				if ((null != (tDustStack = GT_OreDictUnificator.get(OrePrefixes.ingot, aMaterial.mSmeltInto, 1L))) && (!aMaterial.contains(SubTag.NO_SMELTING))) {
+					if (aMaterial.mBlastFurnaceRequired) {
+						addBlastRecipe(GT_Utility.copyAmount(1L, new Object[]{aStack}), null, null, null, aMaterial.mBlastFurnaceTemp > 1750 ? GT_OreDictUnificator.get(OrePrefixes.ingotHot, aMaterial.mSmeltInto, tDustStack, 1L) : GT_Utility.copyAmount(1L, new Object[]{tDustStack}), null, (int) Math.max(aMaterial.getMass() / 40L, 1L) * aMaterial.mBlastFurnaceTemp, 120, aMaterial);
+					}
+				}
+			}
+			break;
+		case dustSmall: 
+			if (keepHighTempRecipes || aMaterial.mBlastFurnaceTemp <= 3600){
+				if (aMaterial.mBlastFurnaceRequired) {
+					addBlastRecipe(GT_Utility.copyAmount(4L, new Object[]{aStack}), null, null, null, aMaterial.mBlastFurnaceTemp > 1750 ? GT_OreDictUnificator.get(OrePrefixes.ingotHot, aMaterial.mSmeltInto, GT_OreDictUnificator.get(OrePrefixes.ingot, aMaterial.mSmeltInto, 1L), 1L) : GT_OreDictUnificator.get(OrePrefixes.ingot, aMaterial.mSmeltInto, 1L), null, (int) Math.max(aMaterial.getMass() / 40L, 1L) * aMaterial.mBlastFurnaceTemp, 120, aMaterial);
+				}
+			}
+			break;
+		case dustTiny:  
+			if (keepHighTempRecipes || aMaterial.mBlastFurnaceTemp <= 3600){
+				if (!aMaterial.contains(gregtech.api.enums.SubTag.NO_SMELTING)) {
+					if (aMaterial.mBlastFurnaceRequired) {
+						addBlastRecipe(GT_Utility.copyAmount(9L, new Object[]{aStack}), null, null, null, aMaterial.mBlastFurnaceTemp > 1750 ? GT_OreDictUnificator.get(OrePrefixes.ingotHot, aMaterial.mSmeltInto, GT_OreDictUnificator.get(OrePrefixes.ingot, aMaterial.mSmeltInto, 1L), 1L) : GT_OreDictUnificator.get(OrePrefixes.ingot, aMaterial.mSmeltInto, 1L), null, (int) Math.max(aMaterial.getMass() / 40L, 1L) * aMaterial.mBlastFurnaceTemp, 120, aMaterial);
+
+					}
+				}
+			}
+			break;
+		default:
+			if (keepHighTempRecipes || aMaterial.mBlastFurnaceTemp <= 3600){
+				if (!aMaterial.contains(SubTag.NO_SMELTING)) {
+					if ((aMaterial.mBlastFurnaceRequired) || (aMaterial.mDirectSmelting.mBlastFurnaceRequired)) {
+						addBlastRecipe(GT_Utility.copyAmount(1L, new Object[]{aStack}), null, null, null, aMaterial.mBlastFurnaceTemp > 1750 ? GT_OreDictUnificator.get(OrePrefixes.ingotHot, aMaterial, GT_OreDictUnificator.get(OrePrefixes.ingot, aMaterial, 1L), 1L) : GT_OreDictUnificator.get(OrePrefixes.ingot, aMaterial, 1L), null, (int) Math.max(aMaterial.getMass() / 4L, 1L) * aMaterial.mBlastFurnaceTemp, 120, aMaterial);
+						if (aMaterial.mBlastFurnaceTemp <= 1000)
+							GT_ModHandler.addRCBlastFurnaceRecipe(GT_Utility.copyAmount(1L, new Object[]{aStack}), GT_OreDictUnificator.get(OrePrefixes.ingot, aMaterial, 1L), aMaterial.mBlastFurnaceTemp * 2);
+					}
+				}
+			}
+			break;
+		}
+	}
+
+	public boolean addBlastRecipe(ItemStack input1, ItemStack input2,
+			FluidStack fluid1, FluidStack fluid2, ItemStack output1,
+			ItemStack output2, int time, int euCost, Materials smeltInto) {
+
+		//Set up variables.
+		ItemStack[] components;
+		int count = 0;
+
+		if (smeltInto == Materials._NULL){
+			//If the material is null then we probably don't want to try.
+			return false;
+		}
+		if (input1 != null && input2 != null){
+			count = 2;
+		}
+		else if (input1 == null && input2 == null){
+			//If both inputs are null, then we don't want to try.
+			return false;
+		}
+		else {
+			count = 1;
+		}
+		//Set up input components.
+		ItemStack configCircuit = ItemUtils.getGregtechCircuit(count);
+		components = new ItemStack[]{configCircuit, input1, input2};
+		if (fluid1 != null || fluid2 != null){
+			//If it uses an input fluid, we cannot handle this. So let's not try. (Annealed copper for example)
+			//return false;
+			if (fluid1 != null && fluid2 != null){
+				//Cannot handle two input fluids
+				return false;
+			}
+
+			FluidStack mInputfluidstack;
+			mInputfluidstack = (fluid1 != null) ? fluid1 : fluid2;
+
+			//Try with new handler
+			//Add Blast Smelter Recipe.
+			return CORE.RA.addBlastSmelterRecipe(
+					components,
+					mInputfluidstack,
+					smeltInto.mSmeltInto.getMolten(144L),
+					100,
+					MathUtils.roundToClosestInt(time*0.8),
+					euCost); // EU Cost
+
+		}
+
+		//Add Blast Smelter Recipe.
+		return CORE.RA.addBlastSmelterRecipe(
+				components,
+				smeltInto.mSmeltInto.getMolten(144L),
+				100,
+				MathUtils.roundToClosestInt(time*0.8),
+				euCost); // EU Cost
+
+	}
+
+}
\ No newline at end of file
diff --git a/src/main/java/gtPlusPlus/xmod/gregtech/loaders/RecipeGen_BlastSmelterGT_GTNH.java b/src/main/java/gtPlusPlus/xmod/gregtech/loaders/RecipeGen_BlastSmelterGT_GTNH.java
new file mode 100644
index 0000000000..63c2d18783
--- /dev/null
+++ b/src/main/java/gtPlusPlus/xmod/gregtech/loaders/RecipeGen_BlastSmelterGT_GTNH.java
@@ -0,0 +1,215 @@
+package gtPlusPlus.xmod.gregtech.loaders;
+
+import gregtech.api.util.*;
+
+import gtPlusPlus.api.objects.Logger;
+import gtPlusPlus.api.objects.minecraft.ItemStackData;
+import gtPlusPlus.core.lib.CORE;
+import gtPlusPlus.core.recipe.common.CI;
+import gtPlusPlus.core.util.math.MathUtils;
+import gtPlusPlus.core.util.minecraft.FluidUtils;
+import net.minecraft.item.ItemStack;
+import net.minecraftforge.fluids.FluidStack;
+import net.minecraftforge.oredict.OreDictionary;
+
+import java.util.HashMap;
+import java.util.Map;
+
+public class RecipeGen_BlastSmelterGT_GTNH {
+
+	private static Map<String, FluidStack> mCachedIngotToFluidRegistry = new HashMap<String, FluidStack>();
+	private static Map<String, String> mCachedHotToColdRegistry = new HashMap<String, String>();
+
+	private synchronized static void setIngotToFluid(final ItemStackData stack, final FluidStack fluid) {
+		if (stack != null && fluid != null) {
+			mCachedIngotToFluidRegistry.put(stack.getUniqueDataIdentifier(), fluid);			
+		}
+	}
+
+	private synchronized static void setHotToCold(final ItemStackData hot, final ItemStackData cold) {
+		if (hot != null && cold != null) {
+			mCachedHotToColdRegistry.put(hot.getUniqueDataIdentifier(), cold.getUniqueDataIdentifier());			
+		}
+	}
+
+	private synchronized static FluidStack getFluidFromIngot(final ItemStackData ingot) {
+		ItemStackData h = ingot;		
+		if (mCachedIngotToFluidRegistry.containsKey(h.getUniqueDataIdentifier())) {
+			Logger.MACHINE_INFO("[ABS] mCachedIngotToFluidRegistry contains Output Ingot.");
+			return mCachedIngotToFluidRegistry.get(h.getUniqueDataIdentifier());
+		}
+		if (mCachedHotToColdRegistry.containsKey(h.getUniqueDataIdentifier())) {
+			Logger.MACHINE_INFO("[ABS] mCachedHotToColdRegistry contains Output Ingot.");
+			return mCachedIngotToFluidRegistry.get(mCachedHotToColdRegistry.get(h.getUniqueDataIdentifier()));				
+		}
+		Logger.MACHINE_INFO("[ABS] Neither Cache contains Output Ingot.");
+		return null;	
+	}
+
+	private static boolean isValid(final ItemStack[] inputs, final ItemStack outputs[], final FluidStack[] fluidIn, final FluidStack fluidOut) {
+		if (inputs != null && outputs != null && fluidIn != null && fluidOut != null && inputs.length > 0 && outputs.length > 0) {
+			return true;
+		}		
+		return false;
+	}
+
+	public synchronized static boolean generateGTNHBlastSmelterRecipesFromEBFList() {
+
+		//Make a counting object
+		int mSuccess = 0;
+
+		Logger.INFO("[ABS] Starting recipe generation based on EBF recipe map.");
+		Logger.INFO("[ABS] Caching Ingots and their Molten fluid..");
+		//First, we make sure that we have a valid recipe map of Ingots/Dusts -> Fluids
+		if (GT_Recipe.GT_Recipe_Map.sFluidExtractionRecipes.mRecipeList.size() > 0) {
+			//So, let's check every recipe
+			for (GT_Recipe x : GT_Recipe.GT_Recipe_Map.sFluidExtractionRecipes.mRecipeList) {
+				ItemStack validInput = null;
+				FluidStack validOutput = null;				
+				//If we the input is an ingot and it and the output are valid, map it to cache.
+				if (x.mInputs[0] != null) {					
+					for(int tag: OreDictionary.getOreIDs(x.mInputs[0])) { 
+						String oreName = OreDictionary.getOreName(tag).toLowerCase();
+						String mType = "dust";
+						if (CORE.GTNH) {
+							mType = "ingot";
+						}
+						if(oreName.startsWith(mType) && !oreName.contains("double") && !oreName.contains("triple") && !oreName.contains("quad") && !oreName.contains("quintuple")) {
+							validInput = x.mInputs[0];
+						}				
+					}
+				}
+				if (x.mFluidOutputs[0] != null) {
+					validOutput = x.mFluidOutputs[0];
+				}				
+				if (validInput != null && validOutput != null) {
+					ItemStackData R = new ItemStackData(validInput);
+					setIngotToFluid(R, validOutput);
+					Logger.MACHINE_INFO("[ABS][I2F] Cached "+validInput.getDisplayName()+" to "+validOutput.getLocalizedName()+". Stored Under ID of "+R.getUniqueDataIdentifier());
+				}				
+			}			
+		}
+
+		Logger.INFO("[ABS] Caching Ingots and their Hot form...");
+		//Second, we make sure that we have a valid recipe map of Hot Ingots -> Cold Ingots
+		if (GT_Recipe.GT_Recipe_Map.sVacuumRecipes.mRecipeList.size() > 0) {
+			//So, let's check every recipe
+			for (GT_Recipe x : GT_Recipe.GT_Recipe_Map.sVacuumRecipes.mRecipeList) {
+				ItemStack validInput = null;
+				ItemStack validOutput = null;				
+				//If we the input is an ingot and it and the output are valid, map it to cache.
+				if (x.mInputs != null && x.mInputs.length > 0 && x.mInputs[0] != null) {
+					validInput = x.mInputs[0];					
+				}
+				if (x.mOutputs != null && x.mOutputs.length > 0 && x.mOutputs[0] != null) {
+					validOutput = x.mOutputs[0];
+				}
+				if (validInput != null && validOutput != null) {
+					ItemStackData R1 = new ItemStackData(validInput);
+					ItemStackData R2 = new ItemStackData(validOutput);
+					setHotToCold(R1, R2);
+					Logger.MACHINE_INFO("[ABS][H2C] Cached "+validInput.getDisplayName()+" to "+validOutput.getDisplayName()+". Stored Under ID of "+R1.getUniqueDataIdentifier()+", links to ID "+R2.getUniqueDataIdentifier());
+				}				
+			}			
+		}
+
+		Logger.INFO("[ABS] Generating recipes based on existing EBF recipes.");
+		//Okay, so now lets Iterate existing EBF recipes.
+		if (GT_Recipe.GT_Recipe_Map.sBlastRecipes.mRecipeList.size() > 0) {
+			for (GT_Recipe x : GT_Recipe.GT_Recipe_Map.sBlastRecipes.mRecipeList) {
+				if (x == null) {
+					continue;
+				}
+				ItemStack[] inputs, outputs;
+				FluidStack[] inputsF;
+				int voltage, time, special;
+				boolean enabled;
+				inputs = x.mInputs;
+				outputs = x.mOutputs;
+				inputsF = x.mFluidInputs;
+				voltage = x.mEUt;
+				time = x.mDuration;
+				enabled = x.mEnabled;
+				special = x.mSpecialValue;
+
+				//Check for GTNH, if it's found, continue to next recipe if the Temp is too high.
+				if (CORE.GTNH && special > 3600) {
+					Logger.MACHINE_INFO("[ABS] Skipping ABS addition for GTNH due to temp.");
+					continue;
+				}
+				else {
+					FluidStack mMoltenStack = null;
+					int mMoltenCount = 0;
+					//If We have a valid Output, let's try use our cached data to get it's molten form.
+					if (x.mOutputs != null && x.mOutputs[0] != null) {
+						mMoltenCount = x.mOutputs[0].stackSize;
+						ItemStackData R = new ItemStackData(x.mOutputs[0]);
+						Logger.MACHINE_INFO("[ABS] Found "+x.mOutputs[0].getDisplayName()+" as valid EBF output, finding it's fluid from the cache. We will require "+(144*mMoltenCount)+"L. Looking for ID "+R.getUniqueDataIdentifier());
+						FluidStack tempFluid = getFluidFromIngot(R);
+						if (tempFluid != null) {
+							//Logger.MACHINE_INFO("[ABS] Got Fluid from Cache.");
+							mMoltenStack = FluidUtils.getFluidStack(tempFluid, mMoltenCount*144);
+						}
+						else {
+							Logger.MACHINE_INFO("[ABS] Failed to get Fluid from Cache.");
+						}
+					}
+					//If this recipe is enabled and we have a valid molten fluidstack, let's try add this recipe.
+					if (enabled && isValid(inputs, outputs, inputsF, mMoltenStack)) {						
+						//Build correct input stack
+						ItemStack[] newInput = new ItemStack[inputs.length+1];						
+						int l = 1;
+						for (ItemStack y : inputs) {
+							newInput[l++] = y;
+						}
+						newInput[0] = CI.getNumberedCircuit(inputs.length);						
+						//Logger.MACHINE_INFO("[ABS] Generating ABS recipe for "+mMoltenStack.getLocalizedName()+".");
+						if (CORE.RA.addBlastSmelterRecipe(newInput, (inputsF.length > 0 ? inputsF[0] : null), mMoltenStack, 100, MathUtils.roundToClosestInt(time*0.8), voltage, special)) {
+							//Logger.MACHINE_INFO("[ABS] Success.");
+							mSuccess++;
+						}
+						else {
+							Logger.MACHINE_INFO("[ABS] Failure.");
+						}
+					}
+					else {
+						if (!enabled) {
+							Logger.MACHINE_INFO("[ABS] Failure. EBF recipe was not enabled.");
+						}
+						else {
+							Logger.MACHINE_INFO("[ABS] Failure. Invalid Inputs or Outputs.");
+							if (inputs == null) {
+								Logger.MACHINE_INFO("[ABS] Inputs were not Valid.");								
+							}
+							else {
+								Logger.MACHINE_INFO("[ABS] inputs size: "+inputs.length);	
+							}
+							if (outputs == null) {
+								Logger.MACHINE_INFO("[ABS] Outputs were not Valid.");	
+							}
+							else {
+								Logger.MACHINE_INFO("[ABS] outputs size: "+outputs.length);	
+							}
+							if (inputsF == null) {
+								Logger.MACHINE_INFO("[ABS] Input Fluids were not Valid.");	
+							}
+							else {
+								Logger.MACHINE_INFO("[ABS] inputsF size: "+inputsF.length);	
+							}
+							if (mMoltenStack == null) {
+								Logger.MACHINE_INFO("[ABS] Output Fluid were not Valid.");	
+							}
+						}
+					}
+				}				
+			}
+		}
+		else {
+			Logger.MACHINE_INFO("[ABS] Failure. Did not find any EBF recipes to iterate.");			
+		}		
+
+		Logger.INFO("[ABS] Processed "+mSuccess+" recipes.");
+		return mSuccess > 0;
+	}
+
+}
diff --git a/src/main/java/gtPlusPlus/xmod/gregtech/loaders/RecipeGen_DustGeneration.java b/src/main/java/gtPlusPlus/xmod/gregtech/loaders/RecipeGen_DustGeneration.java
new file mode 100644
index 0000000000..24c8eb488f
--- /dev/null
+++ b/src/main/java/gtPlusPlus/xmod/gregtech/loaders/RecipeGen_DustGeneration.java
@@ -0,0 +1,444 @@
+package gtPlusPlus.xmod.gregtech.loaders;
+
+import java.util.HashSet;
+import java.util.Set;
+
+import net.minecraft.item.ItemStack;
+
+import gregtech.api.enums.GT_Values;
+import gregtech.api.enums.ItemList;
+import gregtech.api.util.GT_ModHandler;
+import gregtech.api.util.GT_Utility;
+import gtPlusPlus.api.interfaces.RunnableWithInfo;
+import gtPlusPlus.api.objects.Logger;
+import gtPlusPlus.api.objects.data.AutoMap;
+import gtPlusPlus.core.lib.CORE;
+import gtPlusPlus.core.material.Material;
+import gtPlusPlus.core.material.MaterialGenerator;
+import gtPlusPlus.core.material.MaterialStack;
+import gtPlusPlus.core.material.state.MaterialState;
+import gtPlusPlus.core.recipe.common.CI;
+import gtPlusPlus.core.util.math.MathUtils;
+import gtPlusPlus.core.util.minecraft.ItemUtils;
+import gtPlusPlus.core.util.minecraft.RecipeUtils;
+import net.minecraftforge.fluids.FluidStack;
+
+public class RecipeGen_DustGeneration extends RecipeGen_Base {
+
+	public final static Set<RunnableWithInfo<Material>> mRecipeGenMap = new HashSet<RunnableWithInfo<Material>>();
+	static {
+		MaterialGenerator.mRecipeMapsToGenerate.put(mRecipeGenMap);
+	}
+
+	public RecipeGen_DustGeneration(final Material M){
+		this(M, false);
+	}
+
+	public RecipeGen_DustGeneration(final Material M, final boolean O){
+		this.toGenerate = M;		
+		this.disableOptional = O;
+		mRecipeGenMap.add(this);
+		final ItemStack normalDust = M.getDust(1);
+		final ItemStack smallDust = M.getSmallDust(1);
+		final ItemStack tinyDust = M.getTinyDust(1);
+		if (tinyDust != null && normalDust != null) {
+			if (RecipeUtils.addShapedRecipe(
+					tinyDust, tinyDust, tinyDust,
+					tinyDust, tinyDust, tinyDust,
+					tinyDust, tinyDust, tinyDust,
+					normalDust)){
+				Logger.INFO("9 Tiny dust to 1 Dust Recipe: "+M.getLocalizedName()+" - Success");
+			}
+			else {
+				Logger.INFO("9 Tiny dust to 1 Dust Recipe: "+M.getLocalizedName()+" - Failed");
+			}
+
+			if (RecipeUtils.addShapedRecipe(
+					normalDust, null, null,
+					null, null, null,
+					null, null, null,
+					M.getTinyDust(9))){
+				Logger.INFO("9 Tiny dust from 1 Recipe: "+M.getLocalizedName()+" - Success");
+			}
+			else {
+				Logger.INFO("9 Tiny dust from 1 Recipe: "+M.getLocalizedName()+" - Failed");
+			}
+		}
+
+		if (smallDust != null && normalDust != null) {
+			if (RecipeUtils.addShapedRecipe(
+					smallDust, smallDust, null,
+					smallDust, smallDust, null,
+					null, null, null,
+					normalDust)){
+				Logger.INFO("4 Small dust to 1 Dust Recipe: "+M.getLocalizedName()+" - Success");
+			}
+			else {
+				Logger.INFO("4 Small dust to 1 Dust Recipe: "+M.getLocalizedName()+" - Failed");
+			}
+			if (RecipeUtils.addShapedRecipe(
+					null, normalDust, null,
+					null, null, null,
+					null, null, null,
+					M.getSmallDust(4))){
+				Logger.INFO("4 Small dust from 1 Dust Recipe: "+M.getLocalizedName()+" - Success");
+			}
+			else {
+				Logger.INFO("4 Small dust from 1 Dust Recipe: "+M.getLocalizedName()+" - Failed");
+			}
+		}
+	}
+
+	@Override
+	public void run() {
+		generateRecipes(this.toGenerate, this.disableOptional);
+	}
+
+	private void generateRecipes(final Material material, final boolean disableOptional){
+
+		Logger.INFO("Generating Shaped Crafting recipes for "+material.getLocalizedName());
+
+		final ItemStack normalDust = material.getDust(1);
+		final ItemStack smallDust = material.getSmallDust(1);
+		final ItemStack tinyDust = material.getTinyDust(1);
+
+		final ItemStack[] inputStacks = material.getMaterialComposites();
+		final ItemStack outputStacks = material.getDust(material.smallestStackSizeWhenProcessing);
+
+		//Macerate blocks back to dusts.
+		final ItemStack materialBlock = material.getBlock(1);
+		final ItemStack materialFrameBox = material.getFrameBox(1);
+
+		if (ItemUtils.checkForInvalidItems(materialBlock)) {
+			GT_ModHandler.addPulverisationRecipe(materialBlock, material.getDust(9));
+		}
+
+		if (ItemUtils.checkForInvalidItems(materialFrameBox)) {
+			GT_ModHandler.addPulverisationRecipe(materialFrameBox, material.getDust(2));
+		}
+
+		if (ItemUtils.checkForInvalidItems(smallDust) && ItemUtils.checkForInvalidItems(tinyDust)) {
+			generatePackagerRecipes(material);
+		}
+
+		ItemStack ingot = material.getIngot(1);
+		if (ItemUtils.checkForInvalidItems(normalDust) && ItemUtils.checkForInvalidItems(ingot)) {
+			addFurnaceRecipe(material);
+			addMacerationRecipe(material);
+		}
+
+		//Is this a composite?
+		if ((inputStacks != null) && !disableOptional){
+			//Is this a composite?
+			Logger.WARNING("mixer length: "+inputStacks.length);
+			if ((inputStacks.length != 0) && (inputStacks.length <= 4)){
+				//Log Input items
+				Logger.WARNING(ItemUtils.getArrayStackNames(inputStacks));
+				final long[] inputStackSize = material.vSmallestRatio;
+				Logger.WARNING("mixer is stacksizeVar null? "+(inputStackSize != null));
+				//Is smallest ratio invalid?
+				if (inputStackSize != null){
+					//set stack sizes on an input ItemStack[]
+					for (short x=0;x<inputStacks.length;x++){
+						if ((inputStacks[x] != null) && (inputStackSize[x] != 0)){
+							inputStacks[x].stackSize = (int) inputStackSize[x];
+						}
+					}
+					//Relog input values, with stack sizes
+					Logger.WARNING(ItemUtils.getArrayStackNames(inputStacks));
+
+					//Get us four ItemStacks to input into the mixer
+					ItemStack[] input = new ItemStack[4];
+
+					input[0] = (inputStacks.length >= 1) ? ((inputStacks[0] == null) ? null : inputStacks[0]) : null;
+					input[1] = (inputStacks.length >= 2) ? ((inputStacks[1] == null) ? null : inputStacks[1]) : null;
+					input[2] = (inputStacks.length >= 3) ? ((inputStacks[2] == null) ? null : inputStacks[2]) : null;
+					input[3] = (inputStacks.length >= 4) ? ((inputStacks[3] == null) ? null : inputStacks[3]) : null;
+
+
+					if (inputStacks.length == 1) {
+						input[1] = input[0];
+						input[0] = CI.getNumberedCircuit(inputStacks.length+10);
+					}
+					else if (inputStacks.length == 2) {
+						input[2] = input[1];
+						input[1] = input[0];
+						input[0] = CI.getNumberedCircuit(inputStacks.length+10);
+
+					}
+					else if (inputStacks.length == 3) {
+						input[3] = input[2];
+						input[2] = input[1];
+						input[1] = input[0];
+						input[0] = CI.getNumberedCircuit(inputStacks.length+10);
+					}
+
+
+					/*for (int g = 0; g<4; g++) {						
+						if(inputStacks.length > g) {
+							input[g] = inputStacks[g] != null ? inputStacks[g] : null;							
+						}
+						else {
+							input[g] = CI.getNumberedCircuit(g+10);
+							break;
+						}												
+					}*/					
+
+					//Add mixer Recipe
+					FluidStack oxygen = GT_Values.NF;
+					if (material.getComposites() != null){
+						for (final MaterialStack x : material.getComposites()){
+							if (!material.getComposites().isEmpty()){
+								if (x != null){
+									if (x.getStackMaterial() != null){
+										if (x.getStackMaterial().getDust(1) == null){
+											if (x.getStackMaterial().getState() != MaterialState.SOLID && x.getStackMaterial().getState() != MaterialState.ORE && x.getStackMaterial().getState() != MaterialState.PLASMA){
+												oxygen = x.getStackMaterial().getFluidStack(1000);
+												break;
+											}
+										}
+									}
+								}
+							}
+						}
+					}
+					
+					input = ItemUtils.cleanItemStackArray(input);
+
+					//Add mixer Recipe
+					if (GT_Values.RA.addMixerRecipe(
+							input[0], input[1],
+							input[2], input[3],
+							oxygen,
+							null,
+							outputStacks,
+							(int) Math.max(material.getMass() * 2L * 1, 1),
+							material.vVoltageMultiplier)) //Was 6, but let's try 2. This makes Potin LV, for example.
+					{
+						Logger.WARNING("Dust Mixer Recipe: "+material.getLocalizedName()+" - Success");
+					}
+					else {
+						Logger.WARNING("Dust Mixer Recipe: "+material.getLocalizedName()+" - Failed");
+					}
+
+					//Add Shapeless recipe for low tier alloys.
+					/*if (tVoltageMultiplier <= 30){
+						if (RecipeUtils.addShapedGregtechRecipe(inputStacks, outputStacks)){
+							Logger.WARNING("Dust Shapeless Recipe: "+material.getLocalizedName()+" - Success");
+						}
+						else {
+							Logger.WARNING("Dust Shapeless Recipe: "+material.getLocalizedName()+" - Failed");
+						}
+					}*/
+				}
+			}
+		}
+
+
+
+
+
+
+	}
+
+	public static boolean addMixerRecipe_Standalone(final Material material){
+		final ItemStack[] inputStacks = material.getMaterialComposites();
+		final ItemStack outputStacks = material.getDust(material.smallestStackSizeWhenProcessing);
+		//Is this a composite?
+		if ((inputStacks != null)){
+			//Is this a composite?
+			Logger.WARNING("mixer length: "+inputStacks.length);
+			if ((inputStacks.length >= 1) && (inputStacks.length <= 4)){
+				//Log Input items
+				Logger.WARNING(ItemUtils.getArrayStackNames(inputStacks));
+				final long[] inputStackSize = material.vSmallestRatio;
+				Logger.WARNING("mixer is stacksizeVar not null? "+(inputStackSize != null));
+				//Is smallest ratio invalid?
+				if (inputStackSize != null){
+					//set stack sizes on an input ItemStack[]
+					for (short x=0;x<inputStacks.length;x++){
+						if ((inputStacks[x] != null) && (inputStackSize[x] != 0)){
+							inputStacks[x].stackSize = (int) inputStackSize[x];
+						}
+					}
+					//Relog input values, with stack sizes
+					Logger.WARNING(ItemUtils.getArrayStackNames(inputStacks));
+
+					//Get us four ItemStacks to input into the mixer
+					ItemStack input1, input2, input3, input4;
+					input1 = inputStacks[0];
+					input2 = (inputStacks.length >= 2) ? (input2 = (inputStacks[1] == null) ? null : inputStacks[1]) : null;
+					input3 = (inputStacks.length >= 3) ? (input3 = (inputStacks[2] == null) ? null : inputStacks[2]) : null;
+					input4 = (inputStacks.length >= 4) ? (input4 = (inputStacks[3] == null) ? null : inputStacks[3]) : null;
+
+					if (inputStacks.length == 1) {
+						input2 = input1;
+						input1 = CI.getNumberedCircuit(20);
+					}
+					else if (inputStacks.length == 2) {
+						input3 = input2;
+						input2 = input1;
+						input1 = CI.getNumberedCircuit(20);
+
+					}
+					else if (inputStacks.length == 3) {
+						input4 = input3;
+						input3 = input2;
+						input2 = input1;
+						input1 = CI.getNumberedCircuit(20);
+					}
+
+					//Add mixer Recipe
+					FluidStack oxygen = GT_Values.NF;
+					if (material.getComposites() != null){
+						int compSlot = 0;
+						for (final MaterialStack x : material.getComposites()){
+							if (!material.getComposites().isEmpty()){
+								if (x != null){
+									if (x.getStackMaterial() != null){
+										if (x.getStackMaterial().getDust(1) == null){
+											MaterialState f = x.getStackMaterial().getState();
+											if (f == MaterialState.GAS || f == MaterialState.LIQUID || f == MaterialState.PURE_LIQUID || f == MaterialState.PURE_GAS){
+												oxygen = x.getStackMaterial().getFluidStack((int) (material.vSmallestRatio[compSlot] * 1000));
+											}
+										}
+									}
+								}
+							}
+							compSlot++;
+						}
+
+					}
+
+					//Add mixer Recipe
+					try {
+						if (GT_Values.RA.addMixerRecipe(
+								input1, input2,
+								input3, input4,
+								oxygen,
+								null,
+								outputStacks,
+								(int) Math.max(material.getMass() * 2L * 1, 1),
+								material.vVoltageMultiplier)) //Was 6, but let's try 2. This makes Potin LV, for example.
+						{
+							Logger.WARNING("Dust Mixer Recipe: "+material.getLocalizedName()+" - Success");
+							return true;
+						}
+						else {
+							Logger.WARNING("Dust Mixer Recipe: "+material.getLocalizedName()+" - Failed");
+							return false;
+						}
+					}
+					catch (Throwable t) {
+						t.printStackTrace();
+					}
+				}
+				else {
+					Logger.WARNING("inputStackSize == NUll - "+material.getLocalizedName());
+				}
+			}
+			else {
+				Logger.WARNING("InputStacks is out range 1-4 - "+material.getLocalizedName());
+			}
+		}
+		else {
+			Logger.WARNING("InputStacks == NUll - "+material.getLocalizedName());
+		}
+		return false;
+	}
+
+	public static boolean generatePackagerRecipes(Material aMatInfo) {
+		AutoMap<Boolean> aResults = new AutoMap<Boolean>();
+		//Small Dust
+		aResults.put(GT_Values.RA.addBoxingRecipe(GT_Utility.copyAmount(4L, new Object[]{aMatInfo.getSmallDust(4)}), ItemList.Schematic_Dust.get(0L, new Object[0]), aMatInfo.getDust(1), 100, 4));
+		//Tiny Dust
+		aResults.put(GT_Values.RA.addBoxingRecipe(GT_Utility.copyAmount(9L, new Object[]{aMatInfo.getTinyDust(9)}), ItemList.Schematic_Dust.get(0L, new Object[0]), aMatInfo.getDust(1), 100, 4));
+
+		for (boolean b : aResults) {
+			if (!b) {
+				return false;
+			}
+		}		
+		return true;
+	}
+
+	private void addMacerationRecipe(Material aMatInfo){
+		try {
+			Logger.MATERIALS("Adding Maceration recipe for "+aMatInfo.getLocalizedName()+" Ingot -> Dusts");
+			final int chance = (aMatInfo.vTier*10)/MathUtils.randInt(10, 20);
+			GT_ModHandler.addPulverisationRecipe(aMatInfo.getIngot(1), aMatInfo.getDust(1), null, chance);
+		}
+		catch (Throwable t) {
+			t.printStackTrace();
+		}
+	}
+
+	private void addFurnaceRecipe(Material aMatInfo){
+
+		ItemStack aDust = aMatInfo.getDust(1);
+		ItemStack aOutput;
+		try {
+			if (aMatInfo.requiresBlastFurnace()) {
+				aOutput = aMatInfo.getHotIngot(1);		
+				if (ItemUtils.checkForInvalidItems(aOutput)) {	
+					if (addBlastFurnaceRecipe(aMatInfo, aDust, null, aOutput, null, aMatInfo.getMeltingPointK())){
+						Logger.MATERIALS("Successfully added a blast furnace recipe for "+aMatInfo.getLocalizedName());
+					}
+					else {
+						Logger.MATERIALS("Failed to add a blast furnace recipe for "+aMatInfo.getLocalizedName());
+					}
+				}
+				else {
+					Logger.MATERIALS("Failed to add a blast furnace recipe for "+aMatInfo.getLocalizedName());
+				}
+			}
+			else {
+				aOutput = aMatInfo.getIngot(1);
+				if (ItemUtils.checkForInvalidItems(aOutput)) {
+					if (CORE.RA.addSmeltingAndAlloySmeltingRecipe(aDust, aOutput)){
+						Logger.MATERIALS("Successfully added a furnace recipe for "+aMatInfo.getLocalizedName());
+					}
+					else {
+						Logger.MATERIALS("Failed to add a furnace recipe for "+aMatInfo.getLocalizedName());
+					}
+				}				
+			}		
+		}
+		catch (Throwable t) {
+			t.printStackTrace();
+		}
+
+	}
+
+	private boolean addBlastFurnaceRecipe(Material aMatInfo, final ItemStack input1, final ItemStack input2, final ItemStack output1, final ItemStack output2, final int tempRequired){
+
+		try {
+			int timeTaken = 125*aMatInfo.vTier*10;
+
+			if (aMatInfo.vTier <= 4){
+				timeTaken = 25*aMatInfo.vTier*10;
+			}
+			int aSlot = aMatInfo.vTier;
+			if (aSlot < 2) {
+				aSlot = 2;
+			}
+			long aVoltage = aMatInfo.vVoltageMultiplier;
+
+			return GT_Values.RA.addBlastRecipe(
+					input1,
+					input2,
+					GT_Values.NF, GT_Values.NF,
+					output1,
+					output2,
+					timeTaken,
+					(int) aVoltage,
+					tempRequired);
+		}
+		catch (Throwable t) {
+			t.printStackTrace();
+			return false;
+		}
+	}
+
+}
+
diff --git a/src/main/java/gtPlusPlus/xmod/gregtech/loaders/RecipeGen_Extruder.java b/src/main/java/gtPlusPlus/xmod/gregtech/loaders/RecipeGen_Extruder.java
new file mode 100644
index 0000000000..cd43d6201c
--- /dev/null
+++ b/src/main/java/gtPlusPlus/xmod/gregtech/loaders/RecipeGen_Extruder.java
@@ -0,0 +1,176 @@
+package gtPlusPlus.xmod.gregtech.loaders;
+
+import java.util.HashSet;
+import java.util.Set;
+
+import net.minecraft.item.ItemStack;
+
+import gregtech.api.GregTech_API;
+import gregtech.api.enums.ItemList;
+import gregtech.api.util.GT_Recipe;
+
+import gtPlusPlus.api.interfaces.RunnableWithInfo;
+import gtPlusPlus.api.objects.Logger;
+import gtPlusPlus.core.material.Material;
+import gtPlusPlus.core.material.MaterialGenerator;
+import gtPlusPlus.core.util.minecraft.ItemUtils;
+
+public class RecipeGen_Extruder extends RecipeGen_Base {
+
+	public final static Set<RunnableWithInfo<Material>> mRecipeGenMap = new HashSet<RunnableWithInfo<Material>>();
+	static {
+		MaterialGenerator.mRecipeMapsToGenerate.put(mRecipeGenMap);
+	}
+
+	public RecipeGen_Extruder(final Material M){
+		this.toGenerate = M;
+		mRecipeGenMap.add(this);
+	}
+
+	@Override
+	public void run() {
+		generateRecipes(this.toGenerate);
+	}
+
+	private void generateRecipes(final Material material){
+
+		final ItemStack itemIngot = material.getIngot(1);
+		final ItemStack itemPlate = material.getPlate(1);
+		final ItemStack itemGear = material.getGear(1);
+
+		final ItemStack shape_Plate = ItemList.Shape_Extruder_Plate.get(0);
+		final ItemStack shape_Ring = ItemList.Shape_Extruder_Ring.get(0);
+		final ItemStack shape_Gear = ItemList.Shape_Extruder_Gear.get(0);
+		final ItemStack shape_Rod = ItemList.Shape_Extruder_Rod.get(0);
+		final ItemStack shape_Bolt = ItemList.Shape_Extruder_Bolt.get(0);
+		final ItemStack shape_Block = ItemList.Shape_Extruder_Block.get(0);
+		final ItemStack shape_Ingot = ItemList.Shape_Extruder_Ingot.get(0);
+
+		Logger.WARNING("Generating Extruder recipes for "+material.getLocalizedName());
+
+		
+		if (ItemUtils.checkForInvalidItems(material.getIngot(1)) && ItemUtils.checkForInvalidItems(material.getBlock(1))) {
+			//Ingot Recipe
+			if (addExtruderRecipe(
+					material.getBlock(1),
+					shape_Ingot,
+					material.getIngot(9),
+					(int) Math.max(material.getMass() * 2L * 1, 1),
+					material.vVoltageMultiplier)){
+				Logger.WARNING("Extruder Ingot Recipe: "+material.getLocalizedName()+" - Success");
+			}
+			else {
+				Logger.WARNING("Extruder Ingot Recipe: "+material.getLocalizedName()+" - Failed");
+			}
+
+			//Block Recipe
+			if (addExtruderRecipe(
+					material.getIngot(9),
+					shape_Block,
+					material.getBlock(1),
+					(int) Math.max(material.getMass() * 2L * 1, 1),
+					material.vVoltageMultiplier)){
+				Logger.WARNING("Extruder Block Recipe: "+material.getLocalizedName()+" - Success");
+			}
+			else {
+				Logger.WARNING("Extruder Block Recipe: "+material.getLocalizedName()+" - Failed");
+			}
+		}
+
+
+		//Plate Recipe
+		if (ItemUtils.checkForInvalidItems(material.getIngot(1)) && ItemUtils.checkForInvalidItems(material.getPlate(1)))
+		if (addExtruderRecipe(
+				itemIngot,
+				shape_Plate,
+				itemPlate,
+				10, 
+				material.vVoltageMultiplier)){
+			Logger.WARNING("Extruder Plate Recipe: "+material.getLocalizedName()+" - Success");
+		}
+		else {
+			Logger.WARNING("Extruder Plate Recipe: "+material.getLocalizedName()+" - Failed");
+		}
+
+		//Ring Recipe
+		if (ItemUtils.checkForInvalidItems(material.getIngot(1)) && ItemUtils.checkForInvalidItems(material.getRing(1)))
+		if (!material.isRadioactive){
+			if (addExtruderRecipe(
+					itemIngot,
+					shape_Ring,
+					material.getRing(4),
+					(int) Math.max(material.getMass() * 2L * 1, 1),
+					material.vVoltageMultiplier)){
+				Logger.WARNING("Extruder Ring Recipe: "+material.getLocalizedName()+" - Success");
+			}
+			else {
+				Logger.WARNING("Extruder Ring Recipe: "+material.getLocalizedName()+" - Failed");
+			}
+		}
+
+
+		//Gear Recipe
+		if (ItemUtils.checkForInvalidItems(material.getIngot(1)) && ItemUtils.checkForInvalidItems(material.getGear(1)))
+		if (!material.isRadioactive){
+			if (addExtruderRecipe(
+					material.getIngot(4),
+					shape_Gear,
+					itemGear,
+					(int) Math.max(material.getMass() * 5L, 1),
+					material.vVoltageMultiplier)){
+				Logger.WARNING("Extruder Gear Recipe: "+material.getLocalizedName()+" - Success");
+			}
+			else {
+				Logger.WARNING("Extruder Gear Recipe: "+material.getLocalizedName()+" - Failed");
+			}
+		}
+
+
+		//Rod Recipe
+		if (ItemUtils.checkForInvalidItems(material.getIngot(1)) && ItemUtils.checkForInvalidItems(material.getRod(1)))
+		if (addExtruderRecipe(
+				itemIngot,
+				shape_Rod,
+				material.getRod(2),
+				(int) Math.max(material.getMass() * 2L * 1, 1),
+				material.vVoltageMultiplier)){
+			Logger.WARNING("Extruder Rod Recipe: "+material.getLocalizedName()+" - Success");
+		}
+		else {
+			Logger.WARNING("Extruder Rod Recipe: "+material.getLocalizedName()+" - Failed");
+		}
+
+
+		//Bolt Recipe
+		if (ItemUtils.checkForInvalidItems(material.getIngot(1)) && ItemUtils.checkForInvalidItems(material.getBolt(1)))
+		if (!material.isRadioactive){
+			if (addExtruderRecipe(
+					itemIngot,
+					shape_Bolt,
+					material.getBolt(8),
+					(int) Math.max(material.getMass() * 2L * 1, 1),
+					material.vVoltageMultiplier)){
+				Logger.WARNING("Extruder Bolt Recipe: "+material.getLocalizedName()+" - Success");
+			}
+			else {
+				Logger.WARNING("Extruder Bolt Recipe: "+material.getLocalizedName()+" - Failed");
+			}
+		}
+
+	}
+
+
+	public static boolean addExtruderRecipe(final ItemStack aInput, final ItemStack aShape, final ItemStack aOutput, int aDuration, final int aEUt) {
+		if ((aInput == null) || (aShape == null) || (aOutput == null)) {
+			return false;
+		}
+		if ((aDuration = GregTech_API.sRecipeFile.get("extruder", aOutput, aDuration)) <= 0) {
+			return false;
+		}
+		GT_Recipe.GT_Recipe_Map.sExtruderRecipes.addRecipe(true, new ItemStack[]{aInput, aShape}, new ItemStack[]{aOutput}, null, null, null, aDuration, aEUt, 0);
+		return true;
+	}
+
+
+
+}
diff --git a/src/main/java/gtPlusPlus/xmod/gregtech/loaders/RecipeGen_FluidCanning.java b/src/main/java/gtPlusPlus/xmod/gregtech/loaders/RecipeGen_FluidCanning.java
new file mode 100644
index 0000000000..9fe86985f4
--- /dev/null
+++ b/src/main/java/gtPlusPlus/xmod/gregtech/loaders/RecipeGen_FluidCanning.java
@@ -0,0 +1,230 @@
+package gtPlusPlus.xmod.gregtech.loaders;
+
+import java.util.HashSet;
+
+import gregtech.api.enums.GT_Values;
+import gregtech.api.util.GT_Recipe;
+import gregtech.api.util.GT_Recipe.GT_Recipe_Map;
+import gregtech.api.util.GTPP_Recipe;
+import gtPlusPlus.api.interfaces.RunnableWithInfo;
+import gtPlusPlus.api.objects.Logger;
+import gtPlusPlus.core.lib.CORE;
+import gtPlusPlus.core.util.minecraft.ItemUtils;
+import gtPlusPlus.core.util.reflect.ReflectionUtils;
+import net.minecraft.item.ItemStack;
+import net.minecraftforge.fluids.FluidStack;
+
+public class RecipeGen_FluidCanning implements Runnable {
+	
+	public static void init() {
+		FluidCanningRunnableHandler x = new FluidCanningRunnableHandler();
+		x.run();
+	}
+
+	private static class FluidCanningRunnableHandler implements RunnableWithInfo<String> {
+		
+		@Override
+		public void run() {
+			mHasRun = true;
+			for (RecipeGen_FluidCanning aRecipe : mCache) {
+				aRecipe.run();
+			}			
+		}
+
+		@Override
+		public String getInfoData() {
+			return "Fluid Canning Recipes";
+		}		
+	}
+	
+	private static boolean mHasRun = false;
+	
+	private static HashSet<RecipeGen_FluidCanning> mCache = new HashSet<RecipeGen_FluidCanning>();
+	
+	private static void addRunnableToRecipeCache(RecipeGen_FluidCanning r) {
+		if (mHasRun) {
+			CORE.crash();
+		}
+		mCache.add(r);
+	}
+	
+	protected boolean disableOptional;
+	
+	private final GT_Recipe recipe;
+	private final boolean isValid;
+
+	public boolean valid() {
+		return isValid;
+	}
+	public RecipeGen_FluidCanning(boolean aExtracting, ItemStack aEmpty, ItemStack aFull, FluidStack aFluid) {
+		this(aExtracting, aEmpty, aFull, aFluid, GT_Values.NF, null, null);
+	}
+
+	public RecipeGen_FluidCanning(boolean aExtracting, ItemStack aEmpty, ItemStack aFull, FluidStack aFluidIn, FluidStack aFluidOut) {
+		this(aExtracting, aEmpty, aFull, aFluidIn, aFluidOut, null, null);
+	}
+
+	public RecipeGen_FluidCanning(boolean aExtracting, ItemStack aEmpty, ItemStack aFull, FluidStack aFluid, Integer aDuration, Integer aEUt) {
+		this(aExtracting, aEmpty, aFull, aFluid, GT_Values.NF, aDuration, aEUt);
+	}
+
+	// Alternative Constructor
+	public RecipeGen_FluidCanning(boolean aExtracting, ItemStack aEmpty, ItemStack aFull, FluidStack aFluidIn, FluidStack aFluidOut, Integer aDuration, Integer aEUt) {
+		ItemStack aInput;
+		ItemStack aOutput;
+		FluidStack aFluidInput;
+		FluidStack aFluidOutput;
+
+		// Safety check on the duration
+		if (aDuration == null || aDuration <= 0) {
+			aDuration = (aFluidIn != null) ? (aFluidIn.amount / 62) : ((aFluidOut != null) ? (aFluidOut.amount / 62) : 10);
+		}
+
+		// Safety check on the EU
+		if (aEUt == null || aEUt <= 0) {
+			if (aExtracting) {
+				aEUt = 2;
+			}
+			else {
+				aEUt = 1;
+			}
+		}
+
+		// Set Item stacks correctly, invert if extraction recipe.
+		if (aExtracting) {
+			aInput = aFull;
+			aOutput = aEmpty;
+			aFluidInput = GT_Values.NF;
+			aFluidOutput = aFluidIn;			
+		}
+		else {
+			aInput = aEmpty;
+			aOutput = aFull;		
+			aFluidInput = aFluidIn;
+			aFluidOutput = aFluidOut != null ? aFluidOut : GT_Values.NF;			
+		}
+
+		//Check validity
+
+		GTPP_Recipe aRecipe = new GTPP_Recipe(
+				true,
+				new ItemStack[] { aInput },
+				new ItemStack[] { aOutput },
+				null,
+				new int[] {10000},
+				new FluidStack[] { aFluidInput },
+				new FluidStack[] { aFluidOutput },
+				aDuration,
+				aEUt,
+				0);
+
+
+		// Check Valid		
+		boolean aTempValidityCheck = false;
+		//Logger.INFO("Validity Check.");
+		if (aExtracting) {
+			Logger.INFO("Extracting.");
+			if (aInput != null && aFluidOutput != null) {
+				//Logger.INFO("Pass.");
+				aTempValidityCheck = true;
+			}
+		}
+		else {
+			//Logger.INFO("Canning.");
+			if (aInput != null && aOutput != null && (aFluidInput != null || aFluidOutput != null)) {
+				//Logger.INFO("Pass.");
+				aTempValidityCheck = true;				
+			}
+		}		
+
+
+		if (aTempValidityCheck) {
+			// Valid Recipe
+			recipe = aRecipe;
+			disableOptional = aExtracting;
+			isValid = true;	
+			//Logger.INFO("Passed Validity Check. Hash: "+recipe.hashCode());
+			//Logger.INFO("Mapped as: "+(disableOptional ? "Extracting" : "Canning"));
+			addRunnableToRecipeCache(this);		
+		}
+		else {
+			//Logger.INFO("Failed Validity Check.");
+			isValid = false;
+			disableOptional = aExtracting;
+			aRecipe.mEnabled = false;
+			aRecipe.mHidden = true;
+			recipe = null;
+		}
+	}
+
+	@Override
+	public void run() {
+		Logger.INFO("Processing Recipe with Hash: "+recipe.hashCode());
+		generateRecipes();
+	}
+
+	private void generateRecipes() {
+		if (isValid && recipe != null) {
+			//Logger.INFO("Processing "+(disableOptional ? "Extracting" : "Canning")+" Recipe.");
+			if (this.disableOptional) {
+				addFluidExtractionRecipe(recipe);	
+			}
+			else {
+				addFluidCannerRecipe(recipe);
+			}
+		}
+	}
+
+	private final boolean addFluidExtractionRecipe(GT_Recipe aRecipe) {
+		boolean result = false;	
+		int aCount1 = GT_Recipe_Map.sFluidExtractionRecipes.mRecipeList.size();
+		int aCount2 = aCount1;
+		GT_Recipe_Map.sFluidExtractionRecipes.addRecipe(aRecipe);
+		aCount1 = GT_Recipe_Map.sFluidExtractionRecipes.mRecipeList.size();
+		result = aCount1 > aCount2;
+		if (result) {
+			//Logger.INFO("[FIND] Added Extraction recipe for "+ItemUtils.getArrayStackNames(aRecipe.mInputs)+", "+ItemUtils.getArrayStackNames(aRecipe.mOutputs)+", "+ItemUtils.getArrayStackNames(aRecipe.mFluidInputs)+", "+ItemUtils.getArrayStackNames(aRecipe.mFluidOutputs));
+		}
+		else {
+			Logger.INFO("[ERROR] Failed adding Extraction recipe for "+ItemUtils.getArrayStackNames(aRecipe.mInputs)+", "+ItemUtils.getArrayStackNames(aRecipe.mOutputs)+", "+ItemUtils.getArrayStackNames(aRecipe.mFluidInputs)+", "+ItemUtils.getArrayStackNames(aRecipe.mFluidOutputs));
+			//dumpStack();
+		}
+		return result;
+	}
+
+	private final boolean addFluidCannerRecipe(GT_Recipe aRecipe) {
+		boolean result = false;
+		int aCount1 = GT_Recipe_Map.sFluidCannerRecipes.mRecipeList.size();
+		int aCount2 = aCount1;
+		GT_Recipe_Map.sFluidCannerRecipes.addRecipe(aRecipe);
+		aCount1 = GT_Recipe_Map.sFluidCannerRecipes.mRecipeList.size();
+		result = aCount1 > aCount2;
+		if (result) {
+			//Logger.INFO("[FIND] Added Canning recipe for "+ItemUtils.getArrayStackNames(aRecipe.mInputs)+", "+ItemUtils.getArrayStackNames(aRecipe.mOutputs)+", "+ItemUtils.getArrayStackNames(aRecipe.mFluidInputs)+", "+ItemUtils.getArrayStackNames(aRecipe.mFluidOutputs));
+		}
+		else {
+			Logger.INFO("[ERROR] Failed adding Canning recipe for "+ItemUtils.getArrayStackNames(aRecipe.mInputs)+", "+ItemUtils.getArrayStackNames(aRecipe.mOutputs)+", "+ItemUtils.getArrayStackNames(aRecipe.mFluidInputs)+", "+ItemUtils.getArrayStackNames(aRecipe.mFluidOutputs));
+			//dumpStack();
+		}
+		return result;
+	}
+
+	private void dumpStack() {
+		int parents = 2;
+		for (int i=0;i<6;i++) {
+			Logger.INFO((disableOptional ? "EXTRACTING" : "CANNING")+" DEBUG | "+(i == 0 ? "Called from: " : "Parent: ")+ReflectionUtils.getMethodName(i+parents));			
+		}
+
+	}
+
+	private String buildLogString() {
+		int solidSize = getMapSize(GT_Recipe_Map.sCannerRecipes);
+		int fluidSize = getMapSize(GT_Recipe_Map.sFluidCannerRecipes);		
+		return (disableOptional ? "EXTRACTING" : "CANNING")+" DEBUG | Solids: "+solidSize+" | Liquids: "+fluidSize+" | ";
+	}
+
+	private final int getMapSize(GT_Recipe_Map aMap) {
+		return aMap.mRecipeList.size();
+	}
+
+}
diff --git a/src/main/java/gtPlusPlus/xmod/gregtech/loaders/RecipeGen_Fluids.java b/src/main/java/gtPlusPlus/xmod/gregtech/loaders/RecipeGen_Fluids.java
new file mode 100644
index 0000000000..e87fc08c90
--- /dev/null
+++ b/src/main/java/gtPlusPlus/xmod/gregtech/loaders/RecipeGen_Fluids.java
@@ -0,0 +1,298 @@
+package gtPlusPlus.xmod.gregtech.loaders;
+
+import java.util.HashSet;
+import java.util.Set;
+
+import gregtech.api.enums.GT_Values;
+import gregtech.api.enums.ItemList;
+import gtPlusPlus.api.interfaces.RunnableWithInfo;
+import gtPlusPlus.api.objects.Logger;
+import gtPlusPlus.core.lib.CORE;
+import gtPlusPlus.core.material.Material;
+import gtPlusPlus.core.material.MaterialGenerator;
+import gtPlusPlus.core.util.minecraft.ItemUtils;
+
+public class RecipeGen_Fluids extends RecipeGen_Base {
+
+	public final static Set<RunnableWithInfo<Material>> mRecipeGenMap = new HashSet<RunnableWithInfo<Material>>();
+	static {
+		MaterialGenerator.mRecipeMapsToGenerate.put(mRecipeGenMap);
+	}
+
+	public RecipeGen_Fluids(final Material M) {
+		this(M, false);
+	}
+
+	public RecipeGen_Fluids(final Material M, final boolean dO) {
+		this.toGenerate = M;
+		this.disableOptional = dO;
+		mRecipeGenMap.add(this);
+	}
+
+	@Override
+	public void run() {
+		generateRecipes(this.toGenerate, this.disableOptional);
+	}
+
+	private void generateRecipes(final Material material, final boolean dO) {
+
+		if (material == null) {
+			return;
+		}
+
+		// Melting Shapes to fluid
+		if (material.getFluidStack(1) != null
+				&& !material.getFluidStack(1).getUnlocalizedName().toLowerCase().contains("plasma")) {
+
+			if (!material.requiresBlastFurnace()) {
+
+				// Ingot
+				if (ItemUtils.checkForInvalidItems(material.getIngot(1)))
+					if (CORE.RA.addFluidExtractionRecipe(
+							material.getIngot(1), // Input
+							material.getFluidStack(144), // Fluid Output
+							1 * 20, // Duration
+							material.vVoltageMultiplier // Eu Tick
+					)) {
+						Logger.WARNING("144l fluid extractor from 1 ingot Recipe: " + material.getLocalizedName()
+								+ " - Success");
+					} else {
+						Logger.WARNING("144l fluid extractor from 1 ingot Recipe: " + material.getLocalizedName()
+								+ " - Failed");
+					}
+
+				// Plate
+				if (ItemUtils.checkForInvalidItems(material.getPlate(1)))
+					if (CORE.RA.addFluidExtractionRecipe(
+							material.getPlate(1), // Input
+							material.getFluidStack(144), // Fluid Output
+							1 * 20, // Duration
+							material.vVoltageMultiplier // Eu Tick
+					)) {
+						Logger.WARNING("144l fluid extractor from 1 plate Recipe: " + material.getLocalizedName()
+								+ " - Success");
+					} else {
+						Logger.WARNING("144l fluid extractor from 1 plate Recipe: " + material.getLocalizedName()
+								+ " - Failed");
+					}
+
+				// Double Plate
+				if (ItemUtils.checkForInvalidItems(material.getPlateDouble(1)))
+					if (CORE.RA.addFluidExtractionRecipe(
+							material.getPlateDouble(1), // Input
+							material.getFluidStack(288), // Fluid Output
+							1 * 20, // Duration
+							material.vVoltageMultiplier // Eu Tick
+					)) {
+						Logger.WARNING("144l fluid extractor from 1 double plate Recipe: " + material.getLocalizedName()
+								+ " - Success");
+					} else {
+						Logger.WARNING("144l fluid extractor from 1 double plate Recipe: " + material.getLocalizedName()
+								+ " - Failed");
+					}
+
+				// Nugget
+				if (ItemUtils.checkForInvalidItems(material.getNugget(1)))
+					if (CORE.RA.addFluidExtractionRecipe(
+							material.getNugget(1), // Input
+							material.getFluidStack(16), // Fluid Output
+							16, // Duration
+							material.vVoltageMultiplier // Eu Tick
+					)) {
+						Logger.WARNING("16l fluid extractor from 1 nugget Recipe: " + material.getLocalizedName()
+								+ " - Success");
+					} else {
+						Logger.WARNING("16l fluid extractor from 1 nugget Recipe: " + material.getLocalizedName()
+								+ " - Failed");
+					}
+
+				// Block
+				if (ItemUtils.checkForInvalidItems(material.getBlock(1)))
+					if (CORE.RA.addFluidExtractionRecipe(
+							material.getBlock(1), // Input
+							material.getFluidStack(144 * 9), // Fluid Output
+							288, // Duration
+							material.vVoltageMultiplier // Eu Tick
+					)) {
+						Logger.WARNING((144 * 9) + "l fluid extractor from 1 block Recipe: "
+								+ material.getLocalizedName() + " - Success");
+					} else {
+						Logger.WARNING((144 * 9) + "l fluid extractor from 1 block Recipe: "
+								+ material.getLocalizedName() + " - Failed");
+					}
+
+			}
+
+			// Making Shapes from fluid
+
+			// Ingot
+			if (ItemUtils.checkForInvalidItems(material.getIngot(1)))
+				if (GT_Values.RA.addFluidSolidifierRecipe(ItemList.Shape_Mold_Ingot.get(0), // Item Shape
+						material.getFluidStack(144), // Fluid Input
+						material.getIngot(1), // output
+						32, // Duration
+						material.vVoltageMultiplier // Eu Tick
+				)) {
+					Logger.WARNING(
+							"144l fluid molder for 1 ingot Recipe: " + material.getLocalizedName() + " - Success");
+				} else {
+					Logger.WARNING(
+							"144l fluid molder for 1 ingot Recipe: " + material.getLocalizedName() + " - Failed");
+				}
+
+			// Plate
+			if (ItemUtils.checkForInvalidItems(material.getPlate(1)))
+				if (GT_Values.RA.addFluidSolidifierRecipe(ItemList.Shape_Mold_Plate.get(0), // Item Shape
+						material.getFluidStack(144), // Fluid Input
+						material.getPlate(1), // output
+						32, // Duration
+						material.vVoltageMultiplier // Eu Tick
+				)) {
+					Logger.WARNING(
+							"144l fluid molder for 1 plate Recipe: " + material.getLocalizedName() + " - Success");
+				} else {
+					Logger.WARNING(
+							"144l fluid molder for 1 plate Recipe: " + material.getLocalizedName() + " - Failed");
+				}
+
+			// Nugget
+			if (ItemUtils.checkForInvalidItems(material.getNugget(1)))
+				if (GT_Values.RA.addFluidSolidifierRecipe(ItemList.Shape_Mold_Nugget.get(0), // Item Shape
+						material.getFluidStack(16), // Fluid Input
+						material.getNugget(1), // output
+						16, // Duration
+						material.vVoltageMultiplier // Eu Tick
+				)) {
+					Logger.WARNING(
+							"16l fluid molder for 1 nugget Recipe: " + material.getLocalizedName() + " - Success");
+				} else {
+					Logger.WARNING(
+							"16l fluid molder for 1 nugget Recipe: " + material.getLocalizedName() + " - Failed");
+				}
+
+			// Gears
+			if (ItemUtils.checkForInvalidItems(material.getGear(1)))
+				if (GT_Values.RA.addFluidSolidifierRecipe(ItemList.Shape_Mold_Gear.get(0), // Item Shape
+						material.getFluidStack(576), // Fluid Input
+						material.getGear(1), // output
+						128, // Duration
+						material.vVoltageMultiplier // Eu Tick
+				)) {
+					Logger.WARNING(
+							"576l fluid molder for 1 gear Recipe: " + material.getLocalizedName() + " - Success");
+				} else {
+					Logger.WARNING("576l fluid molder for 1 gear Recipe: " + material.getLocalizedName() + " - Failed");
+				}
+
+			// Blocks
+			if (ItemUtils.checkForInvalidItems(material.getBlock(1)))
+				if (GT_Values.RA.addFluidSolidifierRecipe(ItemList.Shape_Mold_Block.get(0), // Item Shape
+						material.getFluidStack(144 * 9), // Fluid Input
+						material.getBlock(1), // output
+						288, // Duration
+						material.vVoltageMultiplier // Eu Tick
+				)) {
+					Logger.WARNING((144 * 9) + "l fluid molder from 1 block Recipe: " + material.getLocalizedName()
+							+ " - Success");
+				} else {
+					Logger.WARNING((144 * 9) + "l fluid molder from 1 block Recipe: " + material.getLocalizedName()
+							+ " - Failed");
+				}
+
+			if (CORE.GTNH) {
+
+				// GTNH
+
+				// Shape_Mold_Rod
+				// Shape_Mold_Rod_Long
+				// Shape_Mold_Bolt,
+				// Shape_Mold_Screw,
+				// Shape_Mold_Ring,
+
+				
+				ItemList mold_Rod = ItemUtils.getValueOfItemList("Shape_Mold_Rod", null);
+				ItemList mold_Rod_Long = ItemUtils.getValueOfItemList("Shape_Mold_Rod_Long", null);
+				ItemList mold_Bolt = ItemUtils.getValueOfItemList("Shape_Mold_Bolt", null);
+				ItemList mold_Screw = ItemUtils.getValueOfItemList("Shape_Mold_Screw", null);
+				ItemList mold_Ring = ItemUtils.getValueOfItemList("Shape_Mold_Ring", null);
+
+				// Rod
+				if (ItemUtils.checkForInvalidItems(material.getRod(1)))
+					if (mold_Rod != null && GT_Values.RA.addFluidSolidifierRecipe(mold_Rod.get(0), // Item Shape
+							material.getFluidStack(72), // Fluid Input
+							material.getRod(1), // output
+							150, // Duration
+							material.vVoltageMultiplier // Eu Tick
+					)) {
+						Logger.WARNING((144 * 9) + "l fluid molder from 1 rod Recipe: " + material.getLocalizedName()
+								+ " - Success");
+					} else {
+						Logger.WARNING((144 * 9) + "l fluid molder from 1 rod Recipe: " + material.getLocalizedName()
+								+ " - Failed");
+					}
+
+				// Rod Long
+				if (ItemUtils.checkForInvalidItems(material.getLongRod(1)))
+					if (mold_Rod_Long != null && GT_Values.RA.addFluidSolidifierRecipe(mold_Rod_Long.get(0), // Item
+																												// Shape
+							material.getFluidStack(144), // Fluid Input
+							material.getLongRod(1), // output
+							300, // Duration
+							material.vVoltageMultiplier // Eu Tick
+					)) {
+						Logger.WARNING((144 * 9) + "l fluid molder from 1 rod long Recipe: "
+								+ material.getLocalizedName() + " - Success");
+					} else {
+						Logger.WARNING((144 * 9) + "l fluid molder from 1 rod long Recipe: "
+								+ material.getLocalizedName() + " - Failed");
+					}
+
+				// Bolt
+				if (ItemUtils.checkForInvalidItems(material.getBolt(1)))
+					if (mold_Bolt != null && GT_Values.RA.addFluidSolidifierRecipe(mold_Bolt.get(0), // Item Shape
+							material.getFluidStack(18), // Fluid Input
+							material.getBolt(1), // output
+							50, // Duration
+							material.vVoltageMultiplier // Eu Tick
+					)) {
+						Logger.WARNING((144 * 9) + "l fluid molder from 1 bolt Recipe: " + material.getLocalizedName()
+								+ " - Success");
+					} else {
+						Logger.WARNING((144 * 9) + "l fluid molder from 1 bolt Recipe: " + material.getLocalizedName()
+								+ " - Failed");
+					}
+
+				// Screw
+				if (ItemUtils.checkForInvalidItems(material.getScrew(1)))
+					if (mold_Screw != null && GT_Values.RA.addFluidSolidifierRecipe(mold_Screw.get(0), // Item Shape
+							material.getFluidStack(18), // Fluid Input
+							material.getScrew(1), // output
+							50, // Duration
+							material.vVoltageMultiplier // Eu Tick
+					)) {
+						Logger.WARNING((144 * 9) + "l fluid molder from 1 screw Recipe: " + material.getLocalizedName()
+								+ " - Success");
+					} else {
+						Logger.WARNING((144 * 9) + "l fluid molder from 1 screw Recipe: " + material.getLocalizedName()
+								+ " - Failed");
+					}
+
+				// Ring
+				if (ItemUtils.checkForInvalidItems(material.getRing(1)))
+					if (mold_Ring != null && GT_Values.RA.addFluidSolidifierRecipe(mold_Ring.get(0), // Item Shape
+							material.getFluidStack(36), // Fluid Input
+							material.getRing(1), // output
+							100, // Duration
+							material.vVoltageMultiplier // Eu Tick
+					)) {
+						Logger.WARNING((144 * 9) + "l fluid molder from 1 ring Recipe: " + material.getLocalizedName()
+								+ " - Success");
+					} else {
+						Logger.WARNING((144 * 9) + "l fluid molder from 1 ring Recipe: " + material.getLocalizedName()
+								+ " - Failed");
+					}
+
+			}
+		}
+	}
+}
diff --git a/src/main/java/gtPlusPlus/xmod/gregtech/loaders/RecipeGen_MaterialProcessing.java b/src/main/java/gtPlusPlus/xmod/gregtech/loaders/RecipeGen_MaterialProcessing.java
new file mode 100644
index 0000000000..f8108852f4
--- /dev/null
+++ b/src/main/java/gtPlusPlus/xmod/gregtech/loaders/RecipeGen_MaterialProcessing.java
@@ -0,0 +1,274 @@
+package gtPlusPlus.xmod.gregtech.loaders;
+
+import java.util.HashSet;
+import java.util.Set;
+
+import net.minecraft.item.ItemStack;
+
+import gregtech.api.GregTech_API;
+import gregtech.api.enums.GT_Values;
+import gregtech.api.util.GT_Recipe;
+
+import gtPlusPlus.api.interfaces.RunnableWithInfo;
+import gtPlusPlus.api.objects.Logger;
+import gtPlusPlus.api.objects.data.AutoMap;
+import gtPlusPlus.api.objects.data.Pair;
+import gtPlusPlus.core.lib.CORE;
+import gtPlusPlus.core.material.Material;
+import gtPlusPlus.core.material.MaterialGenerator;
+import gtPlusPlus.core.material.MaterialStack;
+import gtPlusPlus.core.material.state.MaterialState;
+import gtPlusPlus.core.recipe.common.CI;
+import gtPlusPlus.core.util.minecraft.ItemUtils;
+import net.minecraftforge.fluids.FluidStack;
+
+public class RecipeGen_MaterialProcessing extends RecipeGen_Base {
+
+	public final static Set<RunnableWithInfo<Material>> mRecipeGenMap = new HashSet<RunnableWithInfo<Material>>();
+	static {
+		MaterialGenerator.mRecipeMapsToGenerate.put(mRecipeGenMap);
+	}
+
+	public RecipeGen_MaterialProcessing(final Material M){
+		this.toGenerate = M;
+		mRecipeGenMap.add(this);
+	}
+
+	@Override
+	public void run() {
+		generateRecipes(this.toGenerate);
+	}
+
+	private void generateRecipes(final Material material){
+
+		if (material.getMaterialComposites().length > 1){
+			Logger.MATERIALS("[Recipe Generator Debug] ["+material.getLocalizedName()+"]");
+			final int tVoltageMultiplier = material.vVoltageMultiplier;	
+			int[] partSizes = new int[99];
+			if (material.vSmallestRatio != null) {
+				partSizes = new int[material.vSmallestRatio.length];
+				for (int hu=0;hu<material.vSmallestRatio.length;hu++){
+					partSizes[hu] = (int) material.vSmallestRatio[hu];
+				}
+			}			
+			AutoMap<Pair<Integer, Material>> componentMap = new AutoMap<Pair<Integer, Material>>();
+			int alnsnfds = 0;
+			for (MaterialStack r : material.getComposites()){
+				if (r != null){
+					componentMap.put(new Pair<Integer, Material>(partSizes[alnsnfds], r.getStackMaterial()));
+				}
+				alnsnfds++;
+			}
+			
+
+			
+
+
+			/**
+			 * Electrolyzer
+			 */
+
+			//Process Dust
+			if (componentMap.size() > 0 && componentMap.size() <= 6){
+				ItemStack mInternalOutputs[] = new ItemStack[6];
+				int mChances[] = new int[6];
+				int mCellCount = 0;
+
+				int mTotalCount = 0;
+
+				int mCounter = 0;
+				for (Pair<Integer, Material> f : componentMap){
+					if (f.getValue().getState() != MaterialState.SOLID){
+						Logger.MATERIALS("[Electrolyzer] Found Fluid Component, adding "+f.getKey()+" cells of "+f.getValue().getLocalizedName()+".");
+						mInternalOutputs[mCounter++] = f.getValue().getCell(f.getKey());
+						mCellCount += f.getKey();
+						mTotalCount += f.getKey();
+						Logger.MATERIALS("[Electrolyzer] In total, adding "+mCellCount+" cells for "+material.getLocalizedName()+" processing.");
+					}
+					else {
+						Logger.MATERIALS("[Electrolyzer] Found Solid Component, adding "+f.getKey()+" dusts of "+f.getValue().getLocalizedName()+".");
+						mInternalOutputs[mCounter++] = f.getValue().getDust(f.getKey());
+						mTotalCount += f.getKey();
+					}
+				}				
+
+				//Build Output Array
+				for (int g=0;g<mInternalOutputs.length;g++){
+					Logger.MATERIALS("[Electrolyzer] Is output["+g+"] valid with a chance? "+(mInternalOutputs[g] != null ? 10000 : 0));
+					mChances[g] = (mInternalOutputs[g] != null ? 10000 : 0);
+				}
+
+				ItemStack emptyCell = null;
+				if (mCellCount > 0){
+					emptyCell = ItemUtils.getItemStackOfAmountFromOreDict("cellEmpty", mCellCount);
+					Logger.MATERIALS("[Electrolyzer] Recipe now requires "+mCellCount+" empty cells as input.");
+				}
+
+				ItemStack mainDust = material.getDust(material.smallestStackSizeWhenProcessing);
+				if (mainDust != null){
+					Logger.MATERIALS("[Electrolyzer] Recipe now requires "+material.smallestStackSizeWhenProcessing+"x "+mainDust.getDisplayName()+" as input.");					
+				}
+				else {
+					mainDust = material.getDust(mTotalCount);
+					Logger.MATERIALS("[Electrolyzer] Could not find valid input dust, trying alternative.");	
+					if (mainDust != null){
+						Logger.MATERIALS("[Electrolyzer] Recipe now requires "+mTotalCount+"x "+mainDust.getDisplayName()+" as input.");					
+					}
+					else {
+						Logger.MATERIALS("[Electrolyzer] Could not find valid input dust, exiting.");					
+					}
+				}
+
+				for (int j=0;j<mInternalOutputs.length;j++){
+					if (mInternalOutputs[j] == null){
+						mInternalOutputs[j] = GT_Values.NI;
+						Logger.MATERIALS("[Electrolyzer] Set slot "+j+"  to null.");
+					}
+					else {
+						Logger.MATERIALS("[Electrolyzer] Set slot "+j+" to "+mInternalOutputs[j].getDisplayName()+".");						
+					}
+				}
+
+				try{
+					if (addCentrifgeRecipe(
+							mainDust,
+							emptyCell, //input 2
+							null, //Input fluid 1
+							null, //Output fluid 1
+							mInternalOutputs[0],
+							mInternalOutputs[1], 
+							mInternalOutputs[2], 
+							mInternalOutputs[3],
+							mInternalOutputs[4],
+							mInternalOutputs[5],
+							mChances, 
+							20*1*(tVoltageMultiplier/10), 
+							tVoltageMultiplier)){
+						Logger.MATERIALS("[Electrolyzer] Generated Electrolyzer recipe for "+material.getDust(1).getDisplayName());
+					}
+					else {
+						Logger.MATERIALS("[Electrolyzer] Failed to generate Electrolyzer recipe for "+material.getDust(1).getDisplayName());					
+					}
+				}
+				catch(Throwable t){
+					t.printStackTrace();
+				}
+			}
+			else if (componentMap.size() > 6 && componentMap.size() <= 9){
+				Logger.MATERIALS("[Issue][Electrolyzer] "+material.getLocalizedName()+" is composed of over 6 materials, so an electrolyzer recipe for processing cannot be generated. Trying to create one for the Dehydrator instead.");
+
+				ItemStack mInternalOutputs[] = new ItemStack[9];
+				int mChances[] = new int[9];
+				int mCellCount = 0;
+
+				int mTotalCount = 0;
+
+				int mCounter = 0;
+				for (Pair<Integer, Material> f : componentMap){
+					if (f.getValue().getState() != MaterialState.SOLID){
+						Logger.MATERIALS("[Dehydrator] Found Fluid Component, adding "+f.getKey()+" cells of "+f.getValue().getLocalizedName()+".");
+						mInternalOutputs[mCounter++] = f.getValue().getCell(f.getKey());
+						mCellCount += f.getKey();
+						mTotalCount += f.getKey();
+						Logger.MATERIALS("[Dehydrator] In total, adding "+mCellCount+" cells for "+material.getLocalizedName()+" processing.");
+					}
+					else {
+						Logger.MATERIALS("[Dehydrator] Found Solid Component, adding "+f.getKey()+" dusts of "+f.getValue().getLocalizedName()+".");
+						mInternalOutputs[mCounter++] = f.getValue().getDust(f.getKey());
+						mTotalCount += f.getKey();
+					}
+				}				
+
+				//Build Output Array
+				for (int g=0;g<mInternalOutputs.length;g++){
+					Logger.MATERIALS("[Dehydrator] Is output["+g+"] valid with a chance? "+(mInternalOutputs[g] != null ? 10000 : 0));
+					mChances[g] = (mInternalOutputs[g] != null ? 10000 : 0);
+				}
+
+				ItemStack emptyCell = null;
+				if (mCellCount > 0){
+					emptyCell = CI.emptyCells(mCellCount);
+					Logger.MATERIALS("[Dehydrator] Recipe now requires "+mCellCount+" empty cells as input.");
+				}
+
+				ItemStack mainDust = material.getDust(material.smallestStackSizeWhenProcessing);
+				if (mainDust != null){
+					Logger.MATERIALS("[Dehydrator] Recipe now requires "+material.smallestStackSizeWhenProcessing+"x "+mainDust.getDisplayName()+" as input.");					
+				}
+				else {
+					mainDust = material.getDust(mTotalCount);
+					Logger.MATERIALS("[Dehydrator] Could not find valid input dust, trying alternative.");	
+					if (mainDust != null){
+						Logger.MATERIALS("[Dehydrator] Recipe now requires "+mTotalCount+"x "+mainDust.getDisplayName()+" as input.");					
+					}
+					else {
+						Logger.MATERIALS("[Dehydrator] Could not find valid input dust, exiting.");					
+					}
+				}
+
+				for (int j=0;j<mInternalOutputs.length;j++){
+					if (mInternalOutputs[j] == null){
+						mInternalOutputs[j] = GT_Values.NI;
+						Logger.MATERIALS("[Dehydrator] Set slot "+j+"  to null.");
+					}
+					else {
+						Logger.MATERIALS("[Dehydrator] Set slot "+j+" to "+mInternalOutputs[j].getDisplayName()+".");						
+					}
+				}
+
+				try{		
+
+
+					if (CORE.RA.addDehydratorRecipe(
+							new ItemStack[]{mainDust, emptyCell},
+							null,
+							null,
+							mInternalOutputs,
+							mChances,
+							20*1*(tVoltageMultiplier/10),
+							tVoltageMultiplier)){
+						Logger.MATERIALS("[Dehydrator] Generated Dehydrator recipe for "+material.getDust(1).getDisplayName());
+					}
+					else {
+						Logger.MATERIALS("[Dehydrator] Failed to generate Dehydrator recipe for "+material.getDust(1).getDisplayName());					
+					}
+				}
+				catch(Throwable t){
+					t.printStackTrace();
+				}
+
+
+			}
+
+
+			
+
+
+
+
+		}
+	}
+
+	public static boolean addCentrifgeRecipe(ItemStack aInput1, ItemStack aInput2, FluidStack aFluidInput, FluidStack aFluidOutput, ItemStack aOutput1, ItemStack aOutput2, ItemStack aOutput3, ItemStack aOutput4, ItemStack aOutput5, ItemStack aOutput6, int[] aChances, int aDuration, int aEUt) {
+		return GT_Values.RA.addCentrifugeRecipe(aInput1, aInput2, aFluidInput, aFluidOutput, aOutput1, aOutput2, aOutput3, aOutput4, aOutput5, aOutput6, aChances, aDuration, aEUt);
+	}
+
+	public static boolean addElectrolyzerRecipe(ItemStack aInput1, ItemStack aInput2, FluidStack aFluidInput, FluidStack aFluidOutput, ItemStack aOutput1, ItemStack aOutput2, ItemStack aOutput3, ItemStack aOutput4, ItemStack aOutput5, ItemStack aOutput6, int[] aChances, int aDuration, int aEUt) {
+		if (((aInput1 == null) && (aFluidInput == null)) || ((aOutput1 == null) && (aFluidOutput == null))) {
+			Logger.MATERIALS("[Electrolyzer] Either both inputs or outputs are null.");
+			return false;
+		}
+		if ((aInput1 != null) && ((aDuration = GregTech_API.sRecipeFile.get("electrolyzer", aInput1, aDuration)) <= 0)) {
+			Logger.MATERIALS("[Electrolyzer] Fail 1.");
+			return false;
+		}
+		if ((aFluidInput != null) && ((aDuration = GregTech_API.sRecipeFile.get("electrolyzer", aFluidInput.getFluid().getName(), aDuration)) <= 0)) {
+			Logger.MATERIALS("[Electrolyzer] Fail 2.");
+			return false;
+		}
+		GT_Recipe.GT_Recipe_Map.sElectrolyzerRecipes.addRecipe(true, new ItemStack[]{aInput1, aInput2}, new ItemStack[]{aOutput1, aOutput2, aOutput3, aOutput4, aOutput5, aOutput6}, null, aChances, new FluidStack[]{aFluidInput}, new FluidStack[]{aFluidOutput}, aDuration, aEUt, 0);
+		Logger.MATERIALS("[Electrolyzer] Recipe added.");
+		return true;
+	}
+
+}
diff --git a/src/main/java/gtPlusPlus/xmod/gregtech/loaders/RecipeGen_MetalRecipe.java b/src/main/java/gtPlusPlus/xmod/gregtech/loaders/RecipeGen_MetalRecipe.java
new file mode 100644
index 0000000000..830fae78ab
--- /dev/null
+++ b/src/main/java/gtPlusPlus/xmod/gregtech/loaders/RecipeGen_MetalRecipe.java
@@ -0,0 +1,119 @@
+package gtPlusPlus.xmod.gregtech.loaders;
+
+import gregtech.api.enums.GT_Values;
+import gregtech.api.util.GT_ModHandler;
+import gtPlusPlus.api.interfaces.RunnableWithInfo;
+import gtPlusPlus.api.objects.Logger;
+import gtPlusPlus.core.lib.CORE;
+import gtPlusPlus.core.material.Material;
+import gtPlusPlus.core.material.MaterialGenerator;
+import gtPlusPlus.core.util.minecraft.ItemUtils;
+
+import java.util.HashSet;
+import java.util.Set;
+
+public class RecipeGen_MetalRecipe extends RecipeGen_Base {
+
+    public final static Set<RunnableWithInfo<Material>> mRecipeGenMap = new HashSet<RunnableWithInfo<Material>>();
+    static {
+        MaterialGenerator.mRecipeMapsToGenerate.put(mRecipeGenMap);
+    }
+
+    public RecipeGen_MetalRecipe(final Material M){
+        this.toGenerate = M;
+        mRecipeGenMap.add(this);
+    }
+
+    @Override
+    public void run() {
+        generateRecipes(this.toGenerate);
+    }
+
+    private void generateRecipes(final Material material) {
+
+        Logger.WARNING("Generating Metal recipes for "+material.getLocalizedName());
+        if (ItemUtils.checkForInvalidItems(material.getIngot(1)) && ItemUtils.checkForInvalidItems(material.getBlock(1)))
+            if (GT_ModHandler.addCompressionRecipe(
+                    material.getIngot(9),
+                    material.getBlock(1)
+            )){
+                Logger.WARNING("Compress Block Recipe: "+material.getLocalizedName()+" - Success");
+            }
+            else {
+                Logger.WARNING("Compress Block Recipe: "+material.getLocalizedName()+" - Failed");
+            }
+
+        if (ItemUtils.checkForInvalidItems(material.getIngot(1)) && ItemUtils.checkForInvalidItems(material.getRod(1)))
+            if (GT_Values.RA.addLatheRecipe(
+                    material.getIngot(1),
+                    material.getRod(1),
+                    material.getSmallDust(2),
+                    (int) Math.max(material.getMass() / 8L, 1L),
+                    material.vVoltageMultiplier)){
+                Logger.WARNING("Lathe Rod Recipe: "+material.getLocalizedName()+" - Success");
+            }
+            else {
+                Logger.WARNING("Lathe Rod Recipe: "+material.getLocalizedName()+" - Failed");
+            }
+
+        if (ItemUtils.checkForInvalidItems(material.getRod(1)) && ItemUtils.checkForInvalidItems(material.getBolt(1)))
+            if (GT_Values.RA.addCutterRecipe(
+                    material.getRod(1),
+                    material.getBolt(4),
+                    null,
+                    (int) Math.max(material.getMass() * 2L, 1L),
+                    material.vVoltageMultiplier)){
+                Logger.WARNING("Cut Bolt Recipe: "+material.getLocalizedName()+" - Success");
+            }
+            else {
+                Logger.WARNING("Cut Bolt Recipe: "+material.getLocalizedName()+" - Failed");
+            }
+
+        if (ItemUtils.checkForInvalidItems(material.getIngot(1)) && ItemUtils.checkForInvalidItems(material.getHotIngot(1)))
+            if (CORE.RA.addVacuumFreezerRecipe(
+            		material.getHotIngot(1),
+            		material.getIngot(1), 
+            		(int) Math.max(material.getMass() * 3L, 1L), 
+            		material.vVoltageMultiplier)
+        	){
+                Logger.WARNING("Cool Hot Ingot Recipe: "+material.getLocalizedName()+" - Success");
+            }
+            else {
+                Logger.WARNING("Cool Hot Ingot Recipe: "+material.getLocalizedName()+" - Failed");
+            }
+
+        if (ItemUtils.checkForInvalidItems(material.getRod(1)) && ItemUtils.checkForInvalidItems(material.getLongRod(1))) {
+            if (GT_Values.RA.addForgeHammerRecipe(
+                    material.getRod(2),
+                    material.getLongRod(1),
+                    (int) Math.max(material.getMass(), 1L),
+                    16)){
+                Logger.WARNING("Hammer Long Rod Recipe: "+material.getLocalizedName()+" - Success");
+            }
+            else {
+                Logger.WARNING("Hammer Long Rod Recipe: "+material.getLocalizedName()+" - Failed");
+            }
+
+            GT_Values.RA.addCutterRecipe(
+                    material.getLongRod(1),
+                    material.getRod(2),
+                    null,
+                    (int) Math.max(material.getMass(), 1L),
+                    4);
+        }
+
+        if (ItemUtils.checkForInvalidItems(material.getBolt(1)) && ItemUtils.checkForInvalidItems(material.getScrew(1)))
+            if (GT_Values.RA.addLatheRecipe(
+                    material.getBolt(1),
+                    material.getScrew(1),
+                    null,
+                    (int) Math.max(material.getMass() / 8L, 1L),
+                    4)){
+                Logger.WARNING("Lathe Screw Recipe: "+material.getLocalizedName()+" - Success");
+            }
+            else {
+                Logger.WARNING("Lathe Screw Recipe: "+material.getLocalizedName()+" - Failed");
+            }
+
+    }
+}
\ No newline at end of file
diff --git a/src/main/java/gtPlusPlus/xmod/gregtech/loaders/RecipeGen_MultisUsingFluidInsteadOfCells.java b/src/main/java/gtPlusPlus/xmod/gregtech/loaders/RecipeGen_MultisUsingFluidInsteadOfCells.java
new file mode 100644
index 0000000000..a76322e4f4
--- /dev/null
+++ b/src/main/java/gtPlusPlus/xmod/gregtech/loaders/RecipeGen_MultisUsingFluidInsteadOfCells.java
@@ -0,0 +1,187 @@
+package gtPlusPlus.xmod.gregtech.loaders;
+
+import gregtech.api.util.GTPP_Recipe;
+import gregtech.api.util.GTPP_Recipe.GTPP_Recipe_Map_Internal;
+import gregtech.api.util.GT_Recipe;
+import gregtech.api.util.GT_Recipe.GT_Recipe_Map;
+import gregtech.api.util.GT_Utility;
+import gtPlusPlus.api.objects.Logger;
+import gtPlusPlus.api.objects.data.AutoMap;
+import gtPlusPlus.core.recipe.common.CI;
+import gtPlusPlus.core.util.minecraft.ItemUtils;
+import net.minecraft.item.ItemStack;
+import net.minecraftforge.fluids.FluidStack;
+
+public class RecipeGen_MultisUsingFluidInsteadOfCells {
+
+
+	private static ItemStack mEmptyCell;
+	private static AutoMap<ItemStack> mItemsToIgnore = new AutoMap<ItemStack>();
+	private static boolean mInit = false;
+
+	private static void init() {
+		if (!mInit) {
+			mInit = true;
+			mItemsToIgnore.add(ItemUtils.simpleMetaStack(CI.emptyCells(1).getItem(), 8, 1));
+
+
+		}		
+	}
+
+	private static boolean doesItemMatchIgnoringStackSize(ItemStack a, ItemStack b) {
+		if (a == null || b == null) {
+			return false;
+		}
+		if (a.getItem() == b.getItem()) {
+			if (a.getItemDamage() == b.getItemDamage()) {
+				return true;
+			}
+		}
+		return false;
+	}
+
+	private static boolean isEmptyCell(ItemStack aCell) {
+		if (aCell == null) {
+			return false;
+		}
+		if (mEmptyCell == null) {
+			mEmptyCell = CI.emptyCells(1);
+		}
+		if (mEmptyCell != null) {
+			ItemStack aTempStack = mEmptyCell.copy();
+			aTempStack.stackSize = aCell.stackSize;
+			if (GT_Utility.areStacksEqual(aTempStack, aCell)) {
+				return true;
+			}
+		}		
+		return false;
+	}
+
+	private synchronized static FluidStack getFluidFromItemStack(final ItemStack ingot) {
+		if (ingot == null) {
+			return null;
+		}
+		FluidStack aFluid = GT_Utility.getFluidForFilledItem(ingot, true);
+		if (aFluid != null) {
+			return aFluid;
+		}
+		return null;	
+	}
+
+	public synchronized static int generateRecipesNotUsingCells(GT_Recipe_Map aInputs, GTPP_Recipe_Map_Internal aOutputs) {
+		init();
+		int aRecipesHandled = 0;
+		int aInvalidRecipesToConvert = 0;		
+		int aOriginalCount = aInputs.mRecipeList.size();
+
+		recipe : for (GT_Recipe x : aInputs.mRecipeList) {
+			if (x != null) {
+
+				ItemStack[] aInputItems = x.mInputs.clone();
+				ItemStack[] aOutputItems = x.mOutputs.clone();
+				FluidStack[] aInputFluids = x.mFluidInputs.clone();
+				FluidStack[] aOutputFluids = x.mFluidOutputs.clone();
+
+				AutoMap<ItemStack> aInputItemsMap = new AutoMap<ItemStack>();
+				AutoMap<ItemStack> aOutputItemsMap = new AutoMap<ItemStack>();
+				AutoMap<FluidStack> aInputFluidsMap = new AutoMap<FluidStack>();
+				AutoMap<FluidStack> aOutputFluidsMap = new AutoMap<FluidStack>();
+
+				// Iterate Inputs, Convert valid items into fluids
+				inputs : for (ItemStack aInputStack : aInputItems) {
+					FluidStack aFoundFluid = getFluidFromItemStack(aInputStack);
+					if (aFoundFluid == null) {
+						for (ItemStack aBadStack : mItemsToIgnore) {
+							if (doesItemMatchIgnoringStackSize(aInputStack, aBadStack)) {
+									continue recipe; // Skip this recipe entirely if we find an item we don't like
+							}
+						}
+						if (!isEmptyCell(aInputStack)) {
+							aInputItemsMap.add(aInputStack);
+						}
+					}
+					else {
+						aFoundFluid.amount = aFoundFluid.amount * aInputStack.stackSize;
+						aInputFluidsMap.add(aFoundFluid);
+					}
+				}
+				// Iterate Outputs, Convert valid items into fluids
+				outputs: for (ItemStack aOutputStack : aOutputItems) {
+					FluidStack aFoundFluid = getFluidFromItemStack(aOutputStack);
+					if (aFoundFluid == null) {
+						for (ItemStack aBadStack : mItemsToIgnore) {
+							if (doesItemMatchIgnoringStackSize(aOutputStack, aBadStack)) {
+								continue recipe; // Skip this recipe entirely if we find an item we don't like
+							}
+						}
+						if (!isEmptyCell(aOutputStack)) {
+							aOutputItemsMap.add(aOutputStack);
+						}
+					}
+					else {
+						aFoundFluid.amount = aFoundFluid.amount * aOutputStack.stackSize;
+						aOutputFluidsMap.add(aFoundFluid);
+					}
+				}
+				// Add Input fluids second
+				for (FluidStack aInputFluid : aInputFluids) {
+					aInputFluidsMap.add(aInputFluid);					
+				}
+				// Add Output fluids second
+				for (FluidStack aOutputFluid : aOutputFluids) {
+					aOutputFluidsMap.add(aOutputFluid);					
+				}
+
+				// Make some new Arrays
+				ItemStack[] aNewItemInputs = new ItemStack[aInputItemsMap.size()];
+				ItemStack[] aNewItemOutputs = new ItemStack[aOutputItemsMap.size()];
+				FluidStack[] aNewFluidInputs = new FluidStack[aInputFluidsMap.size()];
+				FluidStack[] aNewFluidOutputs = new FluidStack[aOutputFluidsMap.size()];
+
+				// Add AutoMap contents to Arrays
+				for (int i = 0; i < aInputItemsMap.size(); i++) {
+					aNewItemInputs[i] = aInputItemsMap.get(i);
+				}
+				for (int i = 0; i < aOutputItemsMap.size(); i++) {
+					aNewItemOutputs[i] = aOutputItemsMap.get(i);
+				}
+				for (int i = 0; i < aInputFluidsMap.size(); i++) {
+					aNewFluidInputs[i] = aInputFluidsMap.get(i);
+				}
+				for (int i = 0; i < aOutputFluidsMap.size(); i++) {
+					aNewFluidOutputs[i] = aOutputFluidsMap.get(i);
+				}
+				
+				if (!ItemUtils.checkForInvalidItems(aNewItemInputs, aNewItemOutputs)) {
+					aInvalidRecipesToConvert++;
+					continue recipe; // Skip this recipe entirely if we find an item we don't like
+				}
+
+				// Add Recipe to map
+				GT_Recipe aNewRecipe = new GTPP_Recipe(
+						false,
+						aNewItemInputs,
+						aNewItemOutputs,
+						x.mSpecialItems,
+						x.mChances,
+						aNewFluidInputs,
+						aNewFluidOutputs,
+						x.mDuration,
+						x.mEUt,
+						x.mSpecialValue);    	
+				aOutputs.add(aNewRecipe);
+				aRecipesHandled++;
+			}
+			else {
+				aInvalidRecipesToConvert++;
+			}
+		}		
+
+		Logger.INFO("Generated Recipes for "+aOutputs.mNEIName);
+		Logger.INFO("Original Map contains "+aOriginalCount+" recipes.");
+		Logger.INFO("Output Map contains "+aRecipesHandled+" recipes.");
+		Logger.INFO("There were "+aInvalidRecipesToConvert+" invalid recipes.");
+		return aRecipesHandled;
+	}
+
+}
diff --git a/src/main/java/gtPlusPlus/xmod/gregtech/loaders/RecipeGen_Ore.java b/src/main/java/gtPlusPlus/xmod/gregtech/loaders/RecipeGen_Ore.java
new file mode 100644
index 0000000000..b7043b5983
--- /dev/null
+++ b/src/main/java/gtPlusPlus/xmod/gregtech/loaders/RecipeGen_Ore.java
@@ -0,0 +1,573 @@
+package gtPlusPlus.xmod.gregtech.loaders;
+
+import net.minecraft.item.ItemStack;
+
+import java.util.ArrayList;
+import java.util.HashSet;
+import java.util.Set;
+
+import gregtech.api.GregTech_API;
+import gregtech.api.enums.GT_Values;
+import gregtech.api.enums.Materials;
+import gregtech.api.util.GT_ModHandler;
+import gregtech.api.util.GT_Recipe;
+import gtPlusPlus.api.interfaces.RunnableWithInfo;
+import gtPlusPlus.api.objects.Logger;
+import gtPlusPlus.api.objects.data.AutoMap;
+import gtPlusPlus.api.objects.data.Pair;
+import gtPlusPlus.core.lib.CORE;
+import gtPlusPlus.core.material.Material;
+import gtPlusPlus.core.material.MaterialGenerator;
+import gtPlusPlus.core.material.MaterialStack;
+import gtPlusPlus.core.material.state.MaterialState;
+import gtPlusPlus.core.recipe.common.CI;
+import gtPlusPlus.core.util.minecraft.ItemUtils;
+import gtPlusPlus.core.util.minecraft.MaterialUtils;
+import gtPlusPlus.core.util.minecraft.RecipeUtils;
+import net.minecraftforge.fluids.FluidStack;
+
+public class RecipeGen_Ore extends RecipeGen_Base {
+
+	public final static Set<RunnableWithInfo<Material>> mRecipeGenMap = new HashSet<RunnableWithInfo<Material>>();
+	
+	static {
+		MaterialGenerator.mRecipeMapsToGenerate.put(mRecipeGenMap);
+	}	
+
+	public RecipeGen_Ore(final Material M){
+		this.toGenerate = M;
+		mRecipeGenMap.add(this);
+	}
+
+	@Override
+	public void run() {
+		generateRecipes(this.toGenerate);
+	}
+
+	private static Material mStone;
+
+	public static void generateRecipes(final Material material){
+
+		if (mStone == null) {
+			mStone = MaterialUtils.generateMaterialFromGtENUM(Materials.Stone);
+		}
+
+		//if (material.getMaterialComposites().length > 1){
+		Logger.MATERIALS("[Recipe Generator Debug] ["+material.getLocalizedName()+"]");
+		int tVoltageMultiplier = MaterialUtils.getVoltageForTier(material.vTier);
+
+		final ItemStack dustStone = ItemUtils.getItemStackOfAmountFromOreDict("dustStone", 1);
+		Material bonusA = null; //Ni
+		Material bonusB = null; //Tin
+
+		if (material.getComposites().size() >= 1 && material.getComposites().get(0) != null){
+			bonusA = material.getComposites().get(0).getStackMaterial();
+		}
+		else {
+			bonusA = material;
+		}
+
+		boolean allFailed = false;
+
+
+		//Setup Bonuses
+		ArrayList<Material> aMatComp = new ArrayList<Material>();		
+		for (Material j : MaterialUtils.getCompoundMaterialsRecursively(material)) {
+			aMatComp.add(j);
+		}
+
+		if (aMatComp.size() < 3) {
+			while (aMatComp.size() < 3) {
+				aMatComp.add(material);
+			}
+		}
+
+		AutoMap<Material> amJ = new AutoMap<Material>();
+		int aIndexCounter = 0;
+		for (Material g : aMatComp) {
+			if (g.hasSolidForm()) {
+				if (getDust(g) != null && getTinyDust(g) != null) {					
+					amJ.put(g);
+				}				
+			}			
+		}
+
+		if (amJ.size() < 2) {
+			if (material.getComposites().size() >= 2 && material.getComposites().get(1) != null){
+				bonusB = material.getComposites().get(1).getStackMaterial();
+				//If Secondary Output has no solid output, try the third (If it exists)
+				if (!bonusB.hasSolidForm() && material.getComposites().size() >= 3 && material.getComposites().get(2) != null) {
+					bonusB = material.getComposites().get(2).getStackMaterial();
+					//If Third Output has no solid output, try the Fourth (If it exists)
+					if (!bonusB.hasSolidForm() && material.getComposites().size() >= 4 && material.getComposites().get(3) != null) {
+						bonusB = material.getComposites().get(3).getStackMaterial();
+						//If Fourth Output has no solid output, try the Fifth (If it exists)
+						if (!bonusB.hasSolidForm() && material.getComposites().size() >= 5 && material.getComposites().get(4) != null) {
+							bonusB = material.getComposites().get(4).getStackMaterial();
+							//If Fifth Output has no solid output, default out to Stone dust.
+							if (!bonusB.hasSolidForm()) {
+								allFailed = true;
+								bonusB = mStone;
+							}
+						}
+					}
+				}
+			}
+			else {
+				allFailed = true;
+			}
+		}
+		else {
+			bonusA = amJ.get(0);
+			bonusB = amJ.get(1);
+		}
+
+		//Default out if it's made of fluids or some shit.
+		if (bonusA == null) {
+			bonusA = tVoltageMultiplier > 100 ? material : mStone;
+		}
+		//Default out if it's made of fluids or some shit.
+		if (allFailed || bonusB == null) {
+			bonusB = tVoltageMultiplier > 100 ? material : mStone;
+		}
+
+		AutoMap<Pair<Integer, Material>> componentMap = new AutoMap<Pair<Integer, Material>>();
+		for (MaterialStack r : material.getComposites()){
+			if (r != null){
+				componentMap.put(new Pair<Integer, Material>(r.getPartsPerOneHundred(), r.getStackMaterial()));
+			}
+		}
+
+		//Need two valid outputs
+		if (bonusA == null || bonusB == null || !bonusA.hasSolidForm() || !bonusB.hasSolidForm()) {
+			if (bonusA == null) {
+				bonusA = mStone;
+			}
+			if (bonusB == null) {
+				bonusB = mStone;
+			}
+			if (!bonusA.hasSolidForm()) {
+				bonusA = mStone;
+			}
+			if (!bonusB.hasSolidForm()) {
+				bonusB = mStone;
+			}				
+		}
+
+		ItemStack tinyDustA = getTinyDust(bonusA);
+		ItemStack tinyDustB = getTinyDust(bonusB);
+		ItemStack matDust = getDust(material);
+		ItemStack matDustA = getDust(bonusA);
+		ItemStack matDustB = getDust(bonusB);
+
+		/**
+		 * Package
+		 */
+		//Allow ore dusts to be packaged
+		if (ItemUtils.checkForInvalidItems(material.getSmallDust(1)) && ItemUtils.checkForInvalidItems(material.getTinyDust(1))) {
+			RecipeGen_DustGeneration.generatePackagerRecipes(material);
+		}
+		
+		
+		/**
+		 * Macerate
+		 */
+		//Macerate ore to Crushed
+		if (GT_Values.RA.addPulveriserRecipe(material.getOre(1), new ItemStack[]{material.getCrushed(2)}, new int[]{10000}, 20*20, tVoltageMultiplier/2)){
+			Logger.MATERIALS("[Macerator] Added Recipe: 'Macerate ore to Crushed ore'");
+		}
+		//Macerate Crushed to Impure Dust
+		if (GT_Values.RA.addPulveriserRecipe(material.getCrushed(1), new ItemStack[]{material.getDustImpure(1), matDustA}, new int[]{10000, 1000}, 20*20, tVoltageMultiplier/2)){
+			Logger.MATERIALS("[Macerator] Added Recipe: 'Macerate Crushed ore to Impure Dust'");
+		}
+		//Macerate Washed to Purified Dust
+		if (GT_Values.RA.addPulveriserRecipe(material.getCrushedPurified(1), new ItemStack[]{material.getDustPurified(1), matDustA}, new int[]{10000, 1000}, 20*20, tVoltageMultiplier/2)){
+			Logger.MATERIALS("[Macerator] Added Recipe: 'Macerate Washed ore to Purified Dust'");
+		}
+		//Macerate Centrifuged to Pure Dust
+		if (GT_Values.RA.addPulveriserRecipe(material.getCrushedCentrifuged(1), new ItemStack[]{matDust, matDustA}, new int[]{10000, 1000}, 20*20, tVoltageMultiplier/2)){
+			Logger.MATERIALS("[Macerator] Added Recipe: 'Macerate Centrifuged ore to Pure Dust'");
+		}
+
+		/**
+		 * Wash
+		 */		
+		//Wash into Purified Crushed
+		/*if (GT_Values.RA.addOreWasherRecipe(material.getCrushed(1), material.getCrushedPurified(1), bonusA.getTinyDust(1), dustStone, FluidUtils.getWater(1000), 25*20, 16)){
+				Logger.MATERIALS("[OreWasher] Added Recipe: 'Wash Crushed ore into Purified Crushed ore'");
+			}*/
+		//.08 compat method
+		if (GT_ModHandler.addOreWasherRecipe(material.getCrushed(1), 1000, material.getCrushedPurified(1), tinyDustA, dustStone)){
+			Logger.MATERIALS("[OreWasher] Added Recipe: 'Wash Crushed ore into Purified Crushed ore'");
+		}
+
+
+
+
+
+		/**
+		 * Thermal Centrifuge
+		 */			
+		/*//Crushed ore to Centrifuged Ore
+			if (GT_Values.RA.addThermalCentrifugeRecipe(material.getCrushed(1), material.getCrushedCentrifuged(1), tinyDustB, dustStone, 25*20, 24)){
+				Logger.MATERIALS("[ThermalCentrifuge] Added Recipe: 'Crushed ore to Centrifuged Ore'");
+			}
+			//Washed ore to Centrifuged Ore
+			if (GT_Values.RA.addThermalCentrifugeRecipe(material.getCrushedPurified(1), material.getCrushedCentrifuged(1), bonusA.getTinyDust(1), dustStone, 25*20, 24)){
+				Logger.MATERIALS("[ThermalCentrifuge] Added Recipe: 'Washed ore to Centrifuged Ore'");
+			}*/
+
+		Logger.MATERIALS("material.getCrushed(1): "+(material.getCrushed(1) != null));
+		Logger.MATERIALS("material.getCrushedPurified(1): "+(material.getCrushedPurified(1) != null));
+
+		Logger.MATERIALS("material.getTinyDust(1): "+(ItemUtils.getItemName(bonusA.getCrushed(1))));
+		Logger.MATERIALS("material.getTinyDust(1): "+(ItemUtils.getItemName(bonusB.getCrushed(1))));
+		
+		try {
+			//.08 compat
+			if (GT_ModHandler.addThermalCentrifugeRecipe(material.getCrushed(1), 200, material.getCrushedCentrifuged(1), tinyDustB, dustStone)){
+				Logger.MATERIALS("[ThermalCentrifuge] Added Recipe: 'Crushed ore to Centrifuged Ore' | Input: "+material.getCrushed(1).getDisplayName()+" | Outputs: "+material.getCrushedCentrifuged(1).getDisplayName()+", "+tinyDustB.getDisplayName()+", "+dustStone.getDisplayName()+".");
+			}
+		}
+		catch (Throwable t) {}
+		try {
+			if (GT_ModHandler.addThermalCentrifugeRecipe(material.getCrushedPurified(1), 200, material.getCrushedCentrifuged(1), tinyDustA, dustStone)){
+				Logger.MATERIALS("[ThermalCentrifuge] Added Recipe: 'Washed ore to Centrifuged Ore' | Input: "+material.getCrushedPurified(1).getDisplayName()+" | Outputs: "+material.getCrushedCentrifuged(1).getDisplayName()+", "+tinyDustA.getDisplayName()+", "+dustStone.getDisplayName()+".");
+			}
+		}
+		catch (Throwable t) {}
+
+
+		/**
+		 * Forge Hammer
+		 */			
+		if (GT_Values.RA.addForgeHammerRecipe(material.getCrushedCentrifuged(1), matDust, 10, tVoltageMultiplier/4)){
+			Logger.MATERIALS("[ForgeHammer] Added Recipe: 'Crushed Centrifuged to Pure Dust'");
+		}
+		if (GT_Values.RA.addForgeHammerRecipe(material.getCrushedPurified(1), material.getDustPurified(1), 10, tVoltageMultiplier/4)){
+			Logger.MATERIALS("[ForgeHammer] Added Recipe: 'Crushed Purified to Purified Dust'");
+		}
+		if (GT_Values.RA.addForgeHammerRecipe(material.getOre(1), material.getCrushed(1), 10, tVoltageMultiplier/4)){
+			Logger.MATERIALS("[ForgeHammer] Added Recipe: 'Ore to Crushed'");
+		}
+
+		/**
+		 * Centrifuge
+		 */
+		//Purified Dust to Clean
+		if (GT_Values.RA.addCentrifugeRecipe(
+				material.getDustPurified(1), null,
+				null, //In Fluid
+				null, //Out Fluid
+				matDust, tinyDustA,null, 
+				null, null,null, 
+				new int[]{10000, 10000}, //Chances
+				5*20, //Time
+				tVoltageMultiplier/2)){ //Eu
+			Logger.MATERIALS("[Centrifuge] Added Recipe: Purified Dust to Clean Dust");
+		}
+
+		//Impure Dust to Clean
+		if (GT_Values.RA.addCentrifugeRecipe(
+				material.getDustImpure(1), null,
+				null, //In Fluid
+				null, //Out Fluid
+				matDust, tinyDustB,null, 
+				null, null,null, 
+				new int[]{10000, 10000}, //Chances
+				5*20, //Time
+				tVoltageMultiplier/2)){ //Eu
+			Logger.MATERIALS("[Centrifuge] Added Recipe: Inpure Dust to Clean Dust");
+		}
+
+
+		/**
+		 * Electrolyzer
+		 */
+
+		//Process Dust
+		if (componentMap.size() > 0 && componentMap.size() <= 6){
+
+			ItemStack mInternalOutputs[] = new ItemStack[6];
+			int mChances[] = new int[6];
+			int mCellCount = 0;
+
+			int mTotalCount = 0;
+
+			int mCounter = 0;
+			for (Pair<Integer, Material> f : componentMap){
+				if (f.getValue().getState() != MaterialState.SOLID){
+					Logger.MATERIALS("[Electrolyzer] Found Fluid Component, adding "+f.getKey()+" cells of "+f.getValue().getLocalizedName()+".");
+					mInternalOutputs[mCounter++] = f.getValue().getCell(f.getKey());
+					mCellCount += f.getKey();
+					mTotalCount += f.getKey();
+					Logger.MATERIALS("[Electrolyzer] In total, adding "+mCellCount+" cells for "+material.getLocalizedName()+" processing.");
+				}
+				else {
+					Logger.MATERIALS("[Electrolyzer] Found Solid Component, adding "+f.getKey()+" dusts of "+f.getValue().getLocalizedName()+".");
+					mInternalOutputs[mCounter++] = f.getValue().getDust(f.getKey());
+					mTotalCount += f.getKey();
+				}
+			}				
+
+			//Build Output Array
+			for (int g=0;g<mInternalOutputs.length;g++){
+				Logger.MATERIALS("[Electrolyzer] Is output["+g+"] valid with a chance? "+(mInternalOutputs[g] != null ? 10000 : 0));
+				mChances[g] = (mInternalOutputs[g] != null ? 10000 : 0);
+			}
+
+			ItemStack emptyCell = null;
+			if (mCellCount > 0){
+				emptyCell = ItemUtils.getItemStackOfAmountFromOreDict("cellEmpty", mCellCount);
+				Logger.MATERIALS("[Electrolyzer] Recipe now requires "+mCellCount+" empty cells as input.");
+			}
+
+			ItemStack mainDust = material.getDust(material.smallestStackSizeWhenProcessing);
+			if (mainDust != null){
+				Logger.MATERIALS("[Electrolyzer] Recipe now requires "+material.smallestStackSizeWhenProcessing+"x "+mainDust.getDisplayName()+" as input.");					
+			}
+			else {
+				mainDust = material.getDust(mTotalCount);
+				Logger.MATERIALS("[Electrolyzer] Could not find valid input dust, trying alternative.");	
+				if (mainDust != null){
+					Logger.MATERIALS("[Electrolyzer] Recipe now requires "+mTotalCount+"x "+mainDust.getDisplayName()+" as input.");					
+				}
+				else {
+					Logger.MATERIALS("[Electrolyzer] Could not find valid input dust, exiting.");					
+				}
+			}
+
+			for (int j=0;j<mInternalOutputs.length;j++){
+				if (mInternalOutputs[j] == null){
+					mInternalOutputs[j] = GT_Values.NI;
+					Logger.MATERIALS("[Electrolyzer] Set slot "+j+"  to null.");
+				}
+				else {
+					Logger.MATERIALS("[Electrolyzer] Set slot "+j+" to "+mInternalOutputs[j].getDisplayName()+".");						
+				}
+			}
+
+			try{
+				if (addElectrolyzerRecipe(
+						mainDust,
+						emptyCell, //input 2
+						null, //Input fluid 1
+						null, //Output fluid 1
+						mInternalOutputs[0],
+						mInternalOutputs[1], 
+						mInternalOutputs[2], 
+						mInternalOutputs[3],
+						mInternalOutputs[4],
+						mInternalOutputs[5],
+						mChances, 
+						(int) Math.max(material.getMass() * 3L * 1, 1), 
+						tVoltageMultiplier)){
+					Logger.MATERIALS("[Electrolyzer] Generated Electrolyzer recipe for "+matDust.getDisplayName());
+				}
+				else {
+					Logger.MATERIALS("[Electrolyzer] Failed to generate Electrolyzer recipe for "+matDust.getDisplayName());					
+				}
+			}
+			catch(Throwable t){
+				t.printStackTrace();
+			}
+		}
+		else if (componentMap.size() > 6 && componentMap.size() <= 9){
+			Logger.MATERIALS("[Issue][Electrolyzer] "+material.getLocalizedName()+" is composed of over 6 materials, so an electrolyzer recipe for processing cannot be generated. Trying to create one for the Dehydrator instead.");
+
+			ItemStack mInternalOutputs[] = new ItemStack[9];
+			int mChances[] = new int[9];
+			int mCellCount = 0;
+
+			int mTotalCount = 0;
+
+			int mCounter = 0;
+			for (Pair<Integer, Material> f : componentMap){
+				if (f.getValue().getState() != MaterialState.SOLID && f.getValue().getState() != MaterialState.ORE){
+					Logger.MATERIALS("[Dehydrator] Found Fluid Component, adding "+f.getKey()+" cells of "+f.getValue().getLocalizedName()+".");
+					mInternalOutputs[mCounter++] = f.getValue().getCell(f.getKey());
+					mCellCount += f.getKey();
+					mTotalCount += f.getKey();
+					Logger.MATERIALS("[Dehydrator] In total, adding "+mCellCount+" cells for "+material.getLocalizedName()+" processing.");
+				}
+				else {
+					Logger.MATERIALS("[Dehydrator] Found Solid Component, adding "+f.getKey()+" dusts of "+f.getValue().getLocalizedName()+".");
+					mInternalOutputs[mCounter++] = f.getValue().getDust(f.getKey());
+					mTotalCount += f.getKey();
+				}
+			}				
+
+			//Build Output Array
+			for (int g=0;g<mInternalOutputs.length;g++){
+				Logger.MATERIALS("[Dehydrator] Is output["+g+"] valid with a chance? "+(mInternalOutputs[g] != null ? 10000 : 0));
+				mChances[g] = (mInternalOutputs[g] != null ? 10000 : 0);
+			}
+
+			ItemStack emptyCell = null;
+			if (mCellCount > 0){
+				emptyCell = ItemUtils.getItemStackOfAmountFromOreDict("cellEmpty", mCellCount);
+				Logger.MATERIALS("[Dehydrator] Recipe now requires "+mCellCount+" empty cells as input.");
+			}
+
+			ItemStack mainDust = material.getDust(material.smallestStackSizeWhenProcessing);
+			if (mainDust != null){
+				Logger.MATERIALS("[Dehydrator] Recipe now requires "+material.smallestStackSizeWhenProcessing+"x "+mainDust.getDisplayName()+" as input.");					
+			}
+			else {
+				mainDust = material.getDust(mTotalCount);
+				Logger.MATERIALS("[Dehydrator] Could not find valid input dust, trying alternative.");	
+				if (mainDust != null){
+					Logger.MATERIALS("[Dehydrator] Recipe now requires "+mTotalCount+"x "+mainDust.getDisplayName()+" as input.");					
+				}
+				else {
+					Logger.MATERIALS("[Dehydrator] Could not find valid input dust, exiting.");					
+				}
+			}
+
+			for (int j=0;j<mInternalOutputs.length;j++){
+				if (mInternalOutputs[j] == null){
+					mInternalOutputs[j] = GT_Values.NI;
+					Logger.MATERIALS("[Dehydrator] Set slot "+j+"  to null.");
+				}
+				else {
+					Logger.MATERIALS("[Dehydrator] Set slot "+j+" to "+mInternalOutputs[j].getDisplayName()+".");						
+				}
+			}
+
+			try{		
+
+
+				if (CORE.RA.addDehydratorRecipe(
+						new ItemStack[]{mainDust, emptyCell},
+						null,
+						null,
+						mInternalOutputs,
+						mChances,
+						(int) Math.max(material.getMass() * 4L * 1, 1),
+						tVoltageMultiplier)){
+					Logger.MATERIALS("[Dehydrator] Generated Dehydrator recipe for "+matDust.getDisplayName());
+				}
+				else {
+					Logger.MATERIALS("[Dehydrator] Failed to generate Dehydrator recipe for "+matDust.getDisplayName());					
+				}
+			}
+			catch(Throwable t){
+				t.printStackTrace();
+			}
+
+
+		}
+
+
+		/**
+		 * Shaped Crafting
+		 */			
+		RecipeUtils.addShapedRecipe(
+				CI.craftingToolHammer_Hard, null, null,
+				material.getCrushedPurified(1), null, null,
+				null, null, null,
+				material.getDustPurified(1));
+
+		RecipeUtils.addShapedRecipe(
+				CI.craftingToolHammer_Hard, null, null,
+				material.getCrushed(1), null, null,
+				null, null, null,
+				material.getDustImpure(1));
+
+		RecipeUtils.addShapedRecipe(
+				CI.craftingToolHammer_Hard, null, null,
+				material.getCrushedCentrifuged(1), null, null,
+				null, null, null,
+				matDust);
+
+
+
+		final ItemStack normalDust = matDust;
+		final ItemStack smallDust = material.getSmallDust(1);
+		final ItemStack tinyDust = material.getTinyDust(1);
+
+		if (RecipeUtils.addShapedRecipe(
+				tinyDust,	tinyDust, tinyDust,
+				tinyDust, tinyDust, tinyDust,
+				tinyDust, tinyDust, tinyDust,
+				normalDust)){
+			Logger.WARNING("9 Tiny dust to 1 Dust Recipe: "+material.getLocalizedName()+" - Success");
+		}
+		else {
+			Logger.WARNING("9 Tiny dust to 1 Dust Recipe: "+material.getLocalizedName()+" - Failed");
+		}
+
+		if (RecipeUtils.addShapedRecipe(
+				normalDust, null, null,
+				null, null, null,
+				null, null, null,
+				material.getTinyDust(9))){
+			Logger.WARNING("9 Tiny dust from 1 Recipe: "+material.getLocalizedName()+" - Success");
+		}
+		else {
+			Logger.WARNING("9 Tiny dust from 1 Recipe: "+material.getLocalizedName()+" - Failed");
+		}
+
+
+		if (RecipeUtils.addShapedRecipe(
+				smallDust, smallDust, null,
+				smallDust, smallDust, null,
+				null, null, null,
+				normalDust)){
+			Logger.WARNING("4 Small dust to 1 Dust Recipe: "+material.getLocalizedName()+" - Success");
+		}
+		else {
+			Logger.WARNING("4 Small dust to 1 Dust Recipe: "+material.getLocalizedName()+" - Failed");
+		}
+
+
+		if (RecipeUtils.addShapedRecipe(
+				null, normalDust, null,
+				null, null, null,
+				null, null, null,
+				material.getSmallDust(4))){
+			Logger.WARNING("4 Small dust from 1 Dust Recipe: "+material.getLocalizedName()+" - Success");
+		}
+		else {
+			Logger.WARNING("4 Small dust from 1 Dust Recipe: "+material.getLocalizedName()+" - Failed");
+		}
+
+		//}
+	}
+
+
+	public static boolean addElectrolyzerRecipe(ItemStack aInput1, ItemStack aInput2, FluidStack aFluidInput, FluidStack aFluidOutput, ItemStack aOutput1, ItemStack aOutput2, ItemStack aOutput3, ItemStack aOutput4, ItemStack aOutput5, ItemStack aOutput6, int[] aChances, int aDuration, int aEUt) {
+		if (((aInput1 == null) && (aFluidInput == null)) || ((aOutput1 == null) && (aFluidOutput == null))) {
+			Logger.MATERIALS("[Electrolyzer] Either both inputs or outputs are null.");
+			return false;
+		}
+		if ((aInput1 != null) && ((aDuration = GregTech_API.sRecipeFile.get("electrolyzer", aInput1, aDuration)) <= 0)) {
+			Logger.MATERIALS("[Electrolyzer] Fail 1.");
+			return false;
+		}
+		if ((aFluidInput != null) && ((aDuration = GregTech_API.sRecipeFile.get("electrolyzer", aFluidInput.getFluid().getName(), aDuration)) <= 0)) {
+			Logger.MATERIALS("[Electrolyzer] Fail 2.");
+			return false;
+		}
+		GT_Recipe.GT_Recipe_Map.sElectrolyzerRecipes.addRecipe(true, new ItemStack[]{aInput1, aInput2}, new ItemStack[]{aOutput1, aOutput2, aOutput3, aOutput4, aOutput5, aOutput6}, null, aChances, new FluidStack[]{aFluidInput}, new FluidStack[]{aFluidOutput}, aDuration, aEUt, 0);
+		Logger.MATERIALS("[Electrolyzer] Recipe added.");
+		return true;
+	}
+
+	public static ItemStack getTinyDust(Material m) {
+		ItemStack x = m.getTinyDust(1);
+		if (x == null) {
+			x = mStone.getDust(1);
+		}
+		return x;
+	}
+
+	public static ItemStack getDust(Material m) {
+		ItemStack x = m.getDust(1);
+		if (x == null) {
+			x = mStone.getDust(1);
+		}
+		return x;
+	}
+
+}
diff --git a/src/main/java/gtPlusPlus/xmod/gregtech/loaders/RecipeGen_Plasma.java b/src/main/java/gtPlusPlus/xmod/gregtech/loaders/RecipeGen_Plasma.java
new file mode 100644
index 0000000000..5f53defc2f
--- /dev/null
+++ b/src/main/java/gtPlusPlus/xmod/gregtech/loaders/RecipeGen_Plasma.java
@@ -0,0 +1,42 @@
+package gtPlusPlus.xmod.gregtech.loaders;
+
+import java.util.HashSet;
+import java.util.Set;
+
+import gregtech.api.enums.GT_Values;
+import gregtech.api.util.GT_Utility;
+import gtPlusPlus.api.interfaces.RunnableWithInfo;
+import gtPlusPlus.core.material.Material;
+import gtPlusPlus.core.material.MaterialGenerator;
+import net.minecraft.item.ItemStack;
+
+public class RecipeGen_Plasma extends RecipeGen_Base {
+
+	public final static Set<RunnableWithInfo<Material>> mRecipeGenMap = new HashSet<RunnableWithInfo<Material>>();
+	static {
+		MaterialGenerator.mRecipeMapsToGenerate.put(mRecipeGenMap);
+	}
+
+	public RecipeGen_Plasma(final Material M){
+		this.toGenerate = M;
+		mRecipeGenMap.add(this);
+	}
+
+	@Override
+	public void run() {
+		generateRecipes(this.toGenerate);
+	}
+
+	private void generateRecipes(final Material material) {		
+		// Cool Plasma
+		ItemStack aPlasmaCell = material.getPlasmaCell(1);
+		ItemStack aCell = material.getCell(1);
+		if (material.getPlasmaCell(1) != null){
+			GT_Values.RA.addFuel(GT_Utility.copyAmount(1L, aPlasmaCell), GT_Utility.getFluidForFilledItem(aPlasmaCell, true) == null ? GT_Utility.getContainerItem(aPlasmaCell, true) : null, (int) Math.max(1024L, 1024L * material.getMass()), 4);
+        }
+		if (material.getCell(1) != null && material.getPlasmaCell(1) != null){
+			 GT_Values.RA.addVacuumFreezerRecipe(aPlasmaCell, aCell, (int) Math.max(material.getMass() * 2L, 1L));
+		}
+	}
+
+}
diff --git a/src/main/java/gtPlusPlus/xmod/gregtech/loaders/RecipeGen_Plates.java b/src/main/java/gtPlusPlus/xmod/gregtech/loaders/RecipeGen_Plates.java
new file mode 100644
index 0000000000..56d11520d0
--- /dev/null
+++ b/src/main/java/gtPlusPlus/xmod/gregtech/loaders/RecipeGen_Plates.java
@@ -0,0 +1,154 @@
+package gtPlusPlus.xmod.gregtech.loaders;
+
+import java.util.HashSet;
+import java.util.Set;
+
+import gregtech.api.GregTech_API;
+import gregtech.api.enums.GT_Values;
+import gregtech.api.enums.ItemList;
+import gregtech.api.util.GT_Recipe;
+import gtPlusPlus.api.interfaces.RunnableWithInfo;
+import gtPlusPlus.api.objects.Logger;
+import gtPlusPlus.core.material.Material;
+import gtPlusPlus.core.material.MaterialGenerator;
+import gtPlusPlus.core.util.minecraft.ItemUtils;
+import net.minecraft.item.ItemStack;
+
+public class RecipeGen_Plates extends RecipeGen_Base {
+
+	public final static Set<RunnableWithInfo<Material>> mRecipeGenMap = new HashSet<RunnableWithInfo<Material>>();
+	static {
+		MaterialGenerator.mRecipeMapsToGenerate.put(mRecipeGenMap);
+	}
+
+	public RecipeGen_Plates(final Material M){
+		this.toGenerate = M;
+		mRecipeGenMap.add(this);
+	}
+
+	@Override
+	public void run() {
+		generateRecipes(this.toGenerate);
+	}
+
+	private void generateRecipes(final Material material){
+
+		final int tVoltageMultiplier = material.getMeltingPointK() >= 2800 ? 60 : 15;
+		final ItemStack ingotStackOne = material.getIngot(1);
+		final ItemStack ingotStackTwo = material.getIngot(2);
+		final ItemStack shape_Mold = ItemList.Shape_Mold_Plate.get(0);
+		final ItemStack plate_Single = material.getPlate(1);
+		final ItemStack plate_SingleTwo = material.getPlate(2);
+		final ItemStack plate_SingleNine = material.getPlate(9);
+		final ItemStack plate_Double = material.getPlateDouble(1);
+		final ItemStack block = material.getBlock(1);
+
+		Logger.WARNING("Generating Plate recipes for "+material.getLocalizedName());
+
+		//Forge Hammer
+		if (ItemUtils.checkForInvalidItems(ingotStackTwo) && ItemUtils.checkForInvalidItems(plate_Single))
+		if (addForgeHammerRecipe(
+				ingotStackTwo,
+				plate_Single,
+				(int) Math.max(material.getMass(), 1L),
+				material.vVoltageMultiplier)){
+			Logger.WARNING("Forge Hammer Recipe: "+material.getLocalizedName()+" - Success");
+		}
+		else {
+			Logger.WARNING("Forge Hammer Recipe: "+material.getLocalizedName()+" - Failed");
+		}
+		//Bender
+		if (ItemUtils.checkForInvalidItems(ingotStackOne) && ItemUtils.checkForInvalidItems(plate_Single))
+		if (addBenderRecipe(
+				ingotStackOne,
+				plate_Single,
+				(int) Math.max(material.getMass() * 1L, 1L),
+				material.vVoltageMultiplier)){
+			Logger.WARNING("Bender Recipe: "+material.getLocalizedName()+" - Success");
+		}
+		else {
+			Logger.WARNING("Bender Recipe: "+material.getLocalizedName()+" - Failed");
+		}
+		//Alloy Smelter
+		if (ItemUtils.checkForInvalidItems(ingotStackTwo) && ItemUtils.checkForInvalidItems(plate_Single))
+		if (GT_Values.RA.addAlloySmelterRecipe(
+				ingotStackTwo,
+				shape_Mold,
+				plate_Single,
+				(int) Math.max(material.getMass() * 2L, 1L),
+				material.vVoltageMultiplier)){
+			Logger.WARNING("Alloy Smelter Recipe: "+material.getLocalizedName()+" - Success");
+		}
+		else {
+			Logger.WARNING("Alloy Smelter Recipe: "+material.getLocalizedName()+" - Failed");
+		}
+		//Cutting Machine
+		if (ItemUtils.checkForInvalidItems(block) && ItemUtils.checkForInvalidItems(plate_Single))
+		if (GT_Values.RA.addCutterRecipe(
+				block,
+				null,
+				plate_SingleNine,
+				(int) Math.max(material.getMass() * 10L, 1L),
+				material.vVoltageMultiplier)){
+			Logger.WARNING("Cutting Machine Recipe: "+material.getLocalizedName()+" - Success");
+		}
+		else {
+			Logger.WARNING("ACutting Machine Recipe: "+material.getLocalizedName()+" - Failed");
+		}
+
+
+		//Making Double Plates
+		if (ItemUtils.checkForInvalidItems(ingotStackTwo) && ItemUtils.checkForInvalidItems(plate_Double))
+		if (addBenderRecipe(
+				ingotStackTwo,
+				plate_Double,
+				(int) Math.max(material.getMass() * 2L, 1L),
+				material.vVoltageMultiplier)){
+			Logger.WARNING("Bender Recipe: "+material.getLocalizedName()+" - Success");
+		}
+		else {
+			Logger.WARNING("Bender Recipe: "+material.getLocalizedName()+" - Failed");
+		}
+		
+		if (ItemUtils.checkForInvalidItems(plate_SingleTwo) && ItemUtils.checkForInvalidItems(plate_Double))
+		if (addBenderRecipe(
+				plate_SingleTwo,
+				plate_Double,
+				(int) Math.max(material.getMass() * 2L, 1L),
+				material.vVoltageMultiplier)){
+			Logger.WARNING("Bender Recipe: "+material.getLocalizedName()+" - Success");
+		}
+		else {
+			Logger.WARNING("Bender Recipe: "+material.getLocalizedName()+" - Failed");
+		}
+	}
+
+	public static boolean addBenderRecipe(final ItemStack aInput1, final ItemStack aOutput1, int aDuration, final int aEUt) {
+		return GT_Values.RA.addBenderRecipe(aInput1, aOutput1, aDuration, aEUt);
+	}
+
+	public static boolean addExtruderRecipe(final ItemStack aInput, final ItemStack aShape, final ItemStack aOutput, int aDuration, final int aEUt) {
+		if ((aInput == null) || (aShape == null) || (aOutput == null)) {
+			return false;
+		}
+		if ((aDuration = GregTech_API.sRecipeFile.get("extruder", aOutput, aDuration)) <= 0) {
+			return false;
+		}
+		GT_Recipe.GT_Recipe_Map.sExtruderRecipes.addRecipe(true, new ItemStack[]{aInput, aShape}, new ItemStack[]{aOutput}, null, null, null, aDuration, aEUt, 0);
+		return true;
+	}
+
+	public static boolean addForgeHammerRecipe(final ItemStack aInput1, final ItemStack aOutput1, final int aDuration, final int aEUt) {
+		if ((aInput1 == null) || (aOutput1 == null)) {
+			return false;
+		}
+		if (!GregTech_API.sRecipeFile.get("forgehammer", aOutput1, true)) {
+			return false;
+		}
+		GT_Recipe.GT_Recipe_Map.sHammerRecipes.addRecipe(true, new ItemStack[]{aInput1}, new ItemStack[]{aOutput1}, null, null, null, aDuration, aEUt, 0);
+		return true;
+	}
+
+
+
+}
diff --git a/src/main/java/gtPlusPlus/xmod/gregtech/loaders/RecipeGen_Recycling.java b/src/main/java/gtPlusPlus/xmod/gregtech/loaders/RecipeGen_Recycling.java
new file mode 100644
index 0000000000..acb7e5fe02
--- /dev/null
+++ b/src/main/java/gtPlusPlus/xmod/gregtech/loaders/RecipeGen_Recycling.java
@@ -0,0 +1,373 @@
+package gtPlusPlus.xmod.gregtech.loaders;
+
+import static gregtech.api.enums.GT_Values.M;
+
+import java.util.ArrayList;
+import java.util.Map;
+
+import org.apache.commons.lang3.reflect.FieldUtils;
+
+import gregtech.api.enums.Materials;
+import gregtech.api.enums.OrePrefixes;
+import gregtech.api.util.GT_ModHandler;
+import gregtech.api.util.GT_OreDictUnificator;
+import gregtech.api.util.GT_Utility;
+import gtPlusPlus.api.objects.Logger;
+import gtPlusPlus.api.objects.data.AutoMap;
+import gtPlusPlus.api.objects.data.Pair;
+import gtPlusPlus.core.lib.CORE;
+import gtPlusPlus.core.material.Material;
+import gtPlusPlus.core.material.state.MaterialState;
+import gtPlusPlus.core.util.Utils;
+import gtPlusPlus.core.util.minecraft.ItemUtils;
+import gtPlusPlus.core.util.reflect.ReflectionUtils;
+import net.minecraft.init.Items;
+import net.minecraft.item.ItemStack;
+import net.minecraftforge.oredict.OreDictionary;
+
+public class RecipeGen_Recycling implements Runnable {
+
+	public static AutoMap<Runnable> mQueuedRecyclingGenerators = new AutoMap<Runnable>();
+	
+	public static void executeGenerators() {
+		if (mQueuedRecyclingGenerators.size() > 0) {
+			for (Runnable R : mQueuedRecyclingGenerators.values()) {
+				R.run();
+			}
+		}
+	}
+	
+	final Material toGenerate;
+	public static Map<String, ItemStack> mNameMap;
+
+	public RecipeGen_Recycling(final Material M) {
+		this.toGenerate = M;
+		if (mNameMap == null){
+			mNameMap = this.getNameMap();			
+		}
+		mQueuedRecyclingGenerators.put(this);
+	}
+
+	@Override
+	public void run() {
+		if (mNameMap != null){
+			generateRecipes(this.toGenerate);		
+		}
+	}
+
+	public static void generateRecipes(final Material material) {
+
+		if (material != null)
+		Logger.WARNING("Generating Recycling recipes for " + material.getLocalizedName());
+
+		final OrePrefixes[] mValidPrefixesAsString = { OrePrefixes.ingot, OrePrefixes.ingotHot, OrePrefixes.nugget,
+				OrePrefixes.plate, OrePrefixes.plateDense, OrePrefixes.plateDouble, OrePrefixes.plateTriple,
+				OrePrefixes.plateQuadruple, OrePrefixes.plateQuintuple, OrePrefixes.stick, OrePrefixes.stickLong,
+				OrePrefixes.bolt, OrePrefixes.screw, OrePrefixes.ring, OrePrefixes.rotor, OrePrefixes.gearGt,
+				OrePrefixes.gearGtSmall, OrePrefixes.gear, OrePrefixes.block, OrePrefixes.cableGt01, OrePrefixes.cableGt02,
+				OrePrefixes.cableGt04, OrePrefixes.cableGt08, OrePrefixes.cableGt12, OrePrefixes.wireFine, OrePrefixes.wireGt01,
+				OrePrefixes.wireGt02, OrePrefixes.wireGt04, OrePrefixes.wireGt08, OrePrefixes.wireGt12, OrePrefixes.wireGt16,
+				OrePrefixes.foil, OrePrefixes.frameGt, OrePrefixes.pipeHuge, OrePrefixes.pipeLarge, OrePrefixes.pipeMedium, OrePrefixes.pipeSmall, OrePrefixes.pipeTiny,
+				};
+
+		int mSlotIndex = 0;		
+		Pair<OrePrefixes, ItemStack>[] mValidPairs = new Pair[mValidPrefixesAsString.length];
+		
+		for (int r=0;r<mValidPairs.length;r++){
+			ItemStack temp = getItemStackOfAmountFromOreDictNoBroken(mValidPrefixesAsString[r].name()+Utils.sanitizeString(material.getLocalizedName()), 1);
+			if (temp != null){
+				mValidPairs[mSlotIndex++] = new Pair<OrePrefixes, ItemStack>(mValidPrefixesAsString[r], temp.copy());
+			}
+		}
+		
+		if (mValidPairs.length > 0){
+			int validCounter = 0;
+			Pair<OrePrefixes, ItemStack>[] temp = mValidPairs;
+			for (Pair<OrePrefixes, ItemStack> temp2 : mValidPairs){
+				if (temp2 != null){
+					Logger.WARNING("Valid: "+temp2.getValue().getDisplayName());
+					validCounter++;
+				}
+			}
+			Pair<OrePrefixes, ItemStack> temp3[] = new Pair[validCounter];
+			int temp4 = 0;
+			for (Pair<OrePrefixes, ItemStack> r : mValidPairs){
+				if (r != null){
+					temp3[temp4++] = r;					
+				}
+			}
+			if (temp3.length > 0){
+				mValidPairs = temp3.clone();
+			}
+		}
+		
+		if (mValidPrefixesAsString.length >= 1) {
+			for (final Pair<OrePrefixes, ItemStack> validPrefix : mValidPairs) {
+				try {
+					
+					if (material == null || validPrefix == null || material.getState() != MaterialState.SOLID || validPrefix.getKey() == OrePrefixes.ingotHot) {
+						continue;
+					}
+					
+					final ItemStack tempStack = validPrefix.getValue();
+					final ItemStack mDust = getDust(material, validPrefix.getKey());
+					final Pair<OrePrefixes, ItemStack> mData = getDustData(material, validPrefix.getKey());					
+					int mFluidAmount = (int) GT_Utility.translateMaterialToFluidAmount(validPrefix.getKey().mMaterialAmount, true);
+							
+					//Maceration
+					if (ItemUtils.checkForInvalidItems(tempStack)) {
+						// mValidItems[mSlotIndex++] = tempStack;
+						if ((mDust != null) && GT_ModHandler.addPulverisationRecipe(tempStack, mDust)) {
+							Logger.WARNING("Recycle Recipe: " + material.getLocalizedName() + " - Success - Recycle "
+									+ tempStack.getDisplayName() + " and obtain " + mDust.getDisplayName());
+						}
+						else {
+							Logger.WARNING("Recycle Recipe: " + material.getLocalizedName() + " - Failed");
+							if (mDust == null) {
+								Logger.WARNING("Invalid Dust output.");
+							}
+						}
+					}
+					
+					//Arc Furnace
+					if (ItemUtils.checkForInvalidItems(tempStack)) {
+						
+					}					
+					
+					//Fluid Extractor
+					if (ItemUtils.checkForInvalidItems(tempStack)) {
+						// mValidItems[mSlotIndex++] = tempStack;
+						if ((mDust != null) && CORE.RA.addFluidExtractionRecipe(tempStack, material.getFluidStack(mFluidAmount), 30, material.vVoltageMultiplier)) {
+							Logger.WARNING("Fluid Recycle Recipe: " + material.getLocalizedName() + " - Success - Recycle "
+									+ tempStack.getDisplayName() + " and obtain " + mFluidAmount+"mb of "+material.getFluidStack(1).getLocalizedName()+".");
+						}
+						else {
+							Logger.WARNING("Fluid Recycle Recipe: " + material.getLocalizedName() + " - Failed");
+							if (mDust == null) {
+								Logger.WARNING("Invalid Dust output.");
+							}
+						}
+					}
+					
+				}
+				catch (final Throwable t) {
+					t.printStackTrace();
+					// Utils.LOG_WARNING("Returning Null. Throwable Info:
+					// "+t.getMessage());
+					// Utils.LOG_WARNING("Throwable Info: "+t.toString());
+					// Utils.LOG_WARNING("Throwable Info:
+					// "+t.getCause().toString());
+				}
+
+			}
+		}
+	}
+
+	public static Pair<OrePrefixes, ItemStack> getDustData(final Material aMaterial, final OrePrefixes aPrefix) {
+		return getDustData(aMaterial, aPrefix.mMaterialAmount);
+	}
+	
+	public static Pair<OrePrefixes, ItemStack> getDustData(final Material aMaterial, final long aMaterialAmount) {
+		ItemStack mDust = null;
+		OrePrefixes mPrefix = null;
+		
+		if (aMaterial == null || aMaterialAmount <= 0) {
+			return null;
+		}
+		if ((((aMaterialAmount % M) == 0) || (aMaterialAmount >= (M * 16)))) {
+			mDust = get(OrePrefixes.dust, aMaterial, aMaterialAmount / M);
+			mPrefix = OrePrefixes.dust;
+		}
+		if ((mDust == null) && ((((aMaterialAmount * 4) % M) == 0) || (aMaterialAmount >= (M * 8)))) {
+			mDust = get(OrePrefixes.dustSmall, aMaterial, (aMaterialAmount * 4) / M);
+			mPrefix = OrePrefixes.dustSmall;
+		}
+		if ((mDust == null) && (((aMaterialAmount * 9) >= M))) {
+			mDust = get(OrePrefixes.dustTiny, aMaterial, (aMaterialAmount * 9) / M);
+			mPrefix = OrePrefixes.dustTiny;
+		}
+		
+		if (mPrefix != null && mDust != null){
+			Logger.WARNING("Built valid dust pair.");
+			return new Pair<OrePrefixes, ItemStack>(mPrefix, mDust);
+		}
+		else {
+			Logger.WARNING("mPrefix: "+(mPrefix!=null));
+			Logger.WARNING("mDust: "+(mDust!=null));
+		}
+		Logger.WARNING("Failed to build valid dust pair.");
+		return null;		
+	}
+	
+	public static ItemStack getDust(final Material aMaterial, final OrePrefixes aPrefix) {
+		return aMaterial == null ? null : getDust(aMaterial, aPrefix.mMaterialAmount);
+	}
+	
+	public static ItemStack getDust(final Material aMaterial, final long aMaterialAmount) {
+		if (aMaterialAmount <= 0) {
+			return null;
+		}
+		ItemStack rStack = null;
+		if ((((aMaterialAmount % M) == 0) || (aMaterialAmount >= (M * 16)))) {
+			Logger.WARNING("Trying to get a Dust");
+			rStack = get(OrePrefixes.dust, aMaterial, aMaterialAmount / M);
+		}
+		if ((rStack == null) && ((((aMaterialAmount * 4) % M) == 0) || (aMaterialAmount >= (M * 8)))) {
+			Logger.WARNING("Trying to get a Small Dust");
+			rStack = get(OrePrefixes.dustSmall, aMaterial, (aMaterialAmount * 4) / M);
+		}
+		if ((rStack == null) && (((aMaterialAmount * 9) >= M))) {
+			Logger.WARNING("Trying to get a Tiny Dust");
+			rStack = get(OrePrefixes.dustTiny, aMaterial, (aMaterialAmount * 9) / M);
+		}
+		return rStack;
+	}
+
+	public static ItemStack get(final Object aName, final long aAmount) {
+		return get(aName, null, aAmount, true, true);
+	}
+
+	public static ItemStack get(final Object aName, final ItemStack aReplacement, final long aAmount) {
+		return get(aName, aReplacement, aAmount, true, true);
+	}
+
+	public static ItemStack get(final OrePrefixes aPrefix, final Material aMaterial, final long aAmount) {
+		return get(aPrefix, aMaterial, null, aAmount);
+	}
+
+	public static ItemStack get(final OrePrefixes aPrefix, final Material aMaterial, final ItemStack aReplacement,
+			final long aAmount) {
+		return get(aPrefix.name()+Utils.sanitizeString(aMaterial.getLocalizedName()), aReplacement, aAmount, false, true);
+	}
+
+	public static ItemStack get(final Object aName, final ItemStack aReplacement, final long aAmount,
+			final boolean aMentionPossibleTypos, final boolean aNoInvalidAmounts) {
+		if (aNoInvalidAmounts && (aAmount < 1L)) {
+			Logger.WARNING("Returning Null. Method: " + ReflectionUtils.getMethodName(0));
+			Logger.WARNING("Called from method: " + ReflectionUtils.getMethodName(1));
+			Logger.WARNING("Called from method: " + ReflectionUtils.getMethodName(2));
+			Logger.WARNING("Called from method: " + ReflectionUtils.getMethodName(3));
+			Logger.WARNING("Called from method: " + ReflectionUtils.getMethodName(4));
+			return null;
+		}
+		if (!mNameMap.containsKey(aName.toString()) && aMentionPossibleTypos) {
+			Logger.WARNING("Unknown Key for Unification, Typo? " + aName);
+		}
+		return GT_Utility.copyAmount(aAmount,
+				new Object[] { mNameMap.get(aName.toString()), getFirstOre(aName, aAmount), aReplacement });
+	}
+
+	public static ItemStack getFirstOre(final Object aName, final long aAmount) {
+		if (GT_Utility.isStringInvalid(aName)) {
+			Logger.WARNING("Returning Null. Method: " + ReflectionUtils.getMethodName(0));
+			Logger.WARNING("Called from method: " + ReflectionUtils.getMethodName(1));
+			Logger.WARNING("Called from method: " + ReflectionUtils.getMethodName(2));
+			Logger.WARNING("Called from method: " + ReflectionUtils.getMethodName(3));
+			Logger.WARNING("Called from method: " + ReflectionUtils.getMethodName(4));
+			return null;
+		}
+		final ItemStack tStack = mNameMap.get(aName.toString());
+		if (GT_Utility.isStackValid(tStack)) {
+			Logger.WARNING("Found valid stack.");
+			return GT_Utility.copyAmount(aAmount, new Object[] { tStack });
+		}
+		return GT_Utility.copyAmount(aAmount, getOres(aName).toArray());
+	}
+
+	public static ArrayList<ItemStack> getOres(final Object aOreName) {
+		final String aName = (aOreName == null) ? "" : aOreName.toString();
+		final ArrayList<ItemStack> rList = new ArrayList<ItemStack>();
+		if (GT_Utility.isStringValid(aName)) {
+			Logger.WARNING("Making a list of all OreDict entries for "+aOreName+".");
+			if (rList.addAll(OreDictionary.getOres(aName))){
+				Logger.WARNING("Added "+rList.size()+" elements to list.");
+			}
+			else {
+				Logger.WARNING("Failed to Add Collection from oreDictionary, forcing an entry.");
+				rList.add(ItemUtils.getItemStackOfAmountFromOreDict((String) aOreName, 1));
+			}
+		}
+		return rList;
+	}
+
+	@SuppressWarnings("unchecked")
+	public Map<String, ItemStack> getNameMap() {
+		Map<String, ItemStack> tempMap;
+		try {
+			tempMap = (Map<String, ItemStack>) FieldUtils.readStaticField(GT_OreDictUnificator.class, "sName2StackMap",
+					true);
+			if (tempMap != null) {
+				Logger.WARNING("Found 'sName2StackMap' in GT_OreDictUnificator.class.");
+				return tempMap;
+			}
+		}
+		catch (final IllegalAccessException e) {
+			e.printStackTrace();
+		}
+		Logger.WARNING("Invalid map stored in GT_OreDictUnificator.class, unable to find sName2StackMap field.");
+		return null;
+	}
+	
+	public static ItemStack getItemStackOfAmountFromOreDictNoBroken(String oredictName, final int amount) {
+
+		try {
+
+			if (oredictName.contains("-") || oredictName.contains("_")) {
+				oredictName = Utils.sanitizeString(oredictName, new char[] {'-', '_'});			
+			}
+			else {
+				oredictName = Utils.sanitizeString(oredictName);			
+			}
+
+			// Adds a check to grab dusts using GT methodology if possible.
+			ItemStack returnValue = null;
+			if (oredictName.toLowerCase().contains("dust")) {
+				final String MaterialName = oredictName.toLowerCase().replace("dust", "");
+				final Materials m = Materials.get(MaterialName);
+				if (m != null && m != Materials._NULL) {
+					returnValue = ItemUtils.getGregtechDust(m, amount);
+					if (ItemUtils.checkForInvalidItems(returnValue)) {
+						return returnValue;
+					}
+				}
+			}
+			if (returnValue == null) {
+				returnValue = getItemStackOfAmountFromOreDict(oredictName, amount);				
+				if (ItemUtils.checkForInvalidItems(returnValue)) {
+					return returnValue.copy();					
+				}
+			}			
+			return null;
+		} catch (final Throwable t) {
+			return null;
+		}
+	}
+	
+	public static ItemStack getItemStackOfAmountFromOreDict(String oredictName, final int amount) {
+		String mTemp = oredictName;
+
+		// Banned Materials and replacements for GT5.8 compat.
+
+		if (oredictName.toLowerCase().contains("ingotclay")) {
+			return ItemUtils.getSimpleStack(Items.clay_ball, amount);
+		}
+
+		if (!CORE.MAIN_GREGTECH_5U_EXPERIMENTAL_FORK) {
+			if (oredictName.toLowerCase().contains("rutile")) {
+				mTemp = oredictName.replace("Rutile", "Titanium");
+			}
+			if (oredictName.toLowerCase().contains("vanadiumsteel")) {
+				mTemp = oredictName.replace("VanadiumSteel", "StainlessSteel");
+			}
+		}
+		final ArrayList<ItemStack> oreDictList = OreDictionary.getOres(mTemp);
+		if (!oreDictList.isEmpty()) {
+			final ItemStack returnValue = oreDictList.get(0).copy();
+			returnValue.stackSize = amount;
+			return returnValue;
+		}
+		return null;
+		//return getItemStackOfAmountFromOreDictNoBroken(mTemp, amount);
+	}
+
+}
diff --git a/src/main/java/gtPlusPlus/xmod/gregtech/loaders/RecipeGen_ShapedCrafting.java b/src/main/java/gtPlusPlus/xmod/gregtech/loaders/RecipeGen_ShapedCrafting.java
new file mode 100644
index 0000000000..ea129a2b0e
--- /dev/null
+++ b/src/main/java/gtPlusPlus/xmod/gregtech/loaders/RecipeGen_ShapedCrafting.java
@@ -0,0 +1,264 @@
+package gtPlusPlus.xmod.gregtech.loaders;
+
+import java.util.HashSet;
+import java.util.Set;
+
+import gregtech.api.util.GT_ModHandler;
+import gtPlusPlus.api.interfaces.RunnableWithInfo;
+import gtPlusPlus.api.objects.Logger;
+import gtPlusPlus.core.lib.CORE;
+import gtPlusPlus.core.material.Material;
+import gtPlusPlus.core.material.MaterialGenerator;
+import gtPlusPlus.core.util.minecraft.ItemUtils;
+import gtPlusPlus.core.util.minecraft.RecipeUtils;
+import net.minecraft.item.ItemStack;
+
+public class RecipeGen_ShapedCrafting extends RecipeGen_Base {
+
+	public final static Set<RunnableWithInfo<Material>> mRecipeGenMap = new HashSet<RunnableWithInfo<Material>>();
+	static {
+		MaterialGenerator.mRecipeMapsToGenerate.put(mRecipeGenMap);
+	}
+
+	public RecipeGen_ShapedCrafting(final Material M){
+		this.toGenerate = M;
+		mRecipeGenMap.add(this);
+	}
+
+	@Override
+	public void run() {
+		generateRecipes(this.toGenerate);
+	}
+
+	private void generateRecipes(final Material material){
+		Logger.WARNING("Generating Shaped Crafting recipes for "+material.getLocalizedName()); //TODO
+				
+		if (!CORE.GTNH) {
+			//Nuggets
+			if (ItemUtils.checkForInvalidItems(material.getNugget(1)) && ItemUtils.checkForInvalidItems(material.getIngot(1)))
+				GT_ModHandler.addShapelessCraftingRecipe(
+						material.getIngot(1),
+						new Object[]{
+								material.getNugget(1),
+								material.getNugget(1),
+								material.getNugget(1),
+								material.getNugget(1),
+								material.getNugget(1),
+								material.getNugget(1),
+								material.getNugget(1),
+								material.getNugget(1),
+								material.getNugget(1)
+						});
+		}
+
+		//Plates
+
+		//Single Plate Shaped/Shapeless
+		if (ItemUtils.checkForInvalidItems(material.getPlate(1)) && ItemUtils.checkForInvalidItems(material.getIngot(1)))
+			if (material.getPlate(1) != null && material.getIngot(1) != null)
+				GT_ModHandler.addCraftingRecipe(
+						material.getPlate(1),
+						gregtech.api.util.GT_ModHandler.RecipeBits.DO_NOT_CHECK_FOR_COLLISIONS | gregtech.api.util.GT_ModHandler.RecipeBits.BUFFERED,
+						new Object[]{"h", "B", "I",
+								Character.valueOf('I'),
+								material.getIngot(1),
+								Character.valueOf('B'),
+								material.getIngot(1)});
+
+		if (ItemUtils.checkForInvalidItems(material.getPlate(1)) && ItemUtils.checkForInvalidItems(material.getIngot(1)))
+			GT_ModHandler.addShapelessCraftingRecipe(
+					material.getPlate(1),
+					new Object[]{gregtech.api.enums.ToolDictNames.craftingToolForgeHammer,
+							material.getIngot(1),
+							material.getIngot(1)});
+
+		//Double Plate Shaped/Shapeless
+		if (ItemUtils.checkForInvalidItems(material.getPlateDouble(1)) && ItemUtils.checkForInvalidItems(material.getPlate(1)))
+			GT_ModHandler.addCraftingRecipe(
+					material.getPlateDouble(1),
+					gregtech.api.util.GT_ModHandler.RecipeBits.DO_NOT_CHECK_FOR_COLLISIONS | gregtech.api.util.GT_ModHandler.RecipeBits.BUFFERED,
+					new Object[]{"I", "B", "h",
+							Character.valueOf('I'),
+							material.getPlate(1),
+							Character.valueOf('B'),
+							material.getPlate(1)});
+
+		if (ItemUtils.checkForInvalidItems(material.getPlateDouble(1)) && ItemUtils.checkForInvalidItems(material.getPlate(1)))
+			GT_ModHandler.addShapelessCraftingRecipe(
+					material.getPlateDouble(1),
+					new Object[]{gregtech.api.enums.ToolDictNames.craftingToolForgeHammer,
+							material.getPlate(1),
+							material.getPlate(1)});
+
+		//Ring Recipe
+		if (!material.isRadioactive && ItemUtils.checkForInvalidItems(material.getRing(1)) && ItemUtils.checkForInvalidItems(material.getRod(1))) {
+			if (CORE.GTNH){
+				if (RecipeUtils.addShapedRecipe(
+						"craftingToolHardHammer", null, null,
+						"craftingToolFile", material.getRod(1), null,
+						null, null, null,
+						material.getRing(1))){
+					Logger.WARNING("GT:NH Ring Recipe: "+material.getLocalizedName()+" - Success");
+				}
+				else {
+					Logger.WARNING("GT:NH Ring Recipe: "+material.getLocalizedName()+" - Failed");
+				}
+			}
+			else {
+				if (RecipeUtils.addShapedRecipe(
+						"craftingToolHardHammer", null, null,
+						null, material.getRod(1), null,
+						null, null, null,
+						material.getRing(1))){
+					Logger.WARNING("Ring Recipe: "+material.getLocalizedName()+" - Success");
+				}
+				else {
+					Logger.WARNING("Ring Recipe: "+material.getLocalizedName()+" - Failed");
+				}
+			}
+		}
+
+
+		//Framebox Recipe
+		if (!material.isRadioactive && ItemUtils.checkForInvalidItems(material.getFrameBox(1)) && ItemUtils.checkForInvalidItems(material.getRod(1))) {
+			final ItemStack stackStick = material.getRod(1);
+			if (RecipeUtils.addShapedRecipe(
+					stackStick, stackStick, stackStick,
+					stackStick, "craftingToolWrench", stackStick,
+					stackStick, stackStick, stackStick,
+					material.getFrameBox(2))){
+				Logger.WARNING("Framebox Recipe: "+material.getLocalizedName()+" - Success");
+			}
+			else {
+				Logger.WARNING("Framebox Recipe: "+material.getLocalizedName()+" - Failed");
+			}
+		}
+
+
+		/*final int tVoltageMultiplier = material.getMeltingPointK() >= 1600 ? 60 : 15;
+
+
+		//Add a shapeless recipe for each dust this way - Compat mode.
+		ItemStack[] inputStacks = material.getMaterialComposites();
+		ItemStack outputStacks = material.getDust(material.smallestStackSizeWhenProcessing);
+
+		if (inputStacks.length > 0 && tVoltageMultiplier == 15){
+			Utils.LOG_WARNING(ItemUtils.getArrayStackNames(inputStacks));
+			long[] inputStackSize = material.vSmallestRatio;
+			if (inputStackSize != null){
+				for (short x=0;x<inputStacks.length;x++){
+					if (inputStacks[x] != null && inputStackSize[x] != 0)
+					inputStacks[x].stackSize = (int) inputStackSize[x];
+				}
+				Utils.LOG_WARNING(ItemUtils.getArrayStackNames(inputStacks));
+				if (RecipeUtils.buildShapelessRecipe(
+						outputStacks,
+						inputStacks
+						)){
+					Utils.LOG_WARNING("Shapeless Crafting Recipe: "+material.getLocalizedName()+" - Success");
+				}
+				else {
+					Utils.LOG_WARNING("Shapeless Crafting Recipe: "+material.getLocalizedName()+" - Failed");
+				}
+			}
+		}	*/
+
+
+		//Shaped Recipe - Bolts
+		if (!material.isRadioactive && ItemUtils.checkForInvalidItems(material.getBolt(1)) && ItemUtils.checkForInvalidItems(material.getRod(1))) {
+			if (RecipeUtils.addShapedRecipe(
+					"craftingToolSaw", null, null,
+					null, material.getRod(1), null,
+					null, null, null,
+					material.getBolt(2))){
+				Logger.WARNING("Bolt Recipe: "+material.getLocalizedName()+" - Success");
+			}
+			else {
+				Logger.WARNING("Bolt Recipe: "+material.getLocalizedName()+" - Failed");
+			}
+		}
+
+
+		//Shaped Recipe - Ingot to Rod
+		if (ItemUtils.checkForInvalidItems(material.getRod(1)) && ItemUtils.checkForInvalidItems(material.getIngot(1)))
+			if (RecipeUtils.addShapedRecipe(
+					"craftingToolFile", null, null,
+					null, material.getIngot(1), null,
+					null, null, null,
+					material.getRod(1))){
+				Logger.WARNING("Rod Recipe: "+material.getLocalizedName()+" - Success");
+			}
+			else {
+				Logger.WARNING("Rod Recipe: "+material.getLocalizedName()+" - Failed");
+			}
+
+
+		//Shaped Recipe - Long Rod to two smalls
+		if (ItemUtils.checkForInvalidItems(material.getRod(1)) && ItemUtils.checkForInvalidItems(material.getLongRod(1)))
+			if (RecipeUtils.addShapedRecipe(
+					"craftingToolSaw", null, null,
+					material.getLongRod(1), null, null,
+					null, null, null,
+					material.getRod(2))){
+				Logger.WARNING("Rod Recipe: "+material.getLocalizedName()+" - Success");
+			}
+			else {
+				Logger.WARNING("Rod Recipe: "+material.getLocalizedName()+" - Failed");
+			}
+
+		//Two small to long rod
+		if (ItemUtils.checkForInvalidItems(material.getLongRod(1)) && ItemUtils.checkForInvalidItems(material.getRod(1)))
+			if (RecipeUtils.addShapedRecipe(
+					material.getRod(1), "craftingToolHardHammer", material.getRod(1),
+					null, null, null,
+					null, null, null,
+					material.getLongRod(1))){
+				Logger.WARNING("Long Rod Recipe: "+material.getLocalizedName()+" - Success");
+			}
+			else {
+				Logger.WARNING("Long Rod Recipe: "+material.getLocalizedName()+" - Failed");
+			}
+
+		//Rotor Recipe
+		if (!material.isRadioactive && ItemUtils.checkForInvalidItems(material.getRotor(1)) && ItemUtils.checkForInvalidItems(material.getRing(1)) && !material.isRadioactive && ItemUtils.checkForInvalidItems(material.getPlate(1)) && ItemUtils.checkForInvalidItems(material.getScrew(1))) {
+			if (RecipeUtils.addShapedRecipe(
+					material.getPlate(1), "craftingToolHardHammer", material.getPlate(1),
+					material.getScrew(1), material.getRing(1), "craftingToolFile",
+					material.getPlate(1), "craftingToolScrewdriver", material.getPlate(1),
+					material.getRotor(1))){
+				Logger.WARNING("Rotor Recipe: "+material.getLocalizedName()+" - Success");
+			}
+			else {
+				Logger.WARNING("Rotor Recipe: "+material.getLocalizedName()+" - Failed");
+			}
+		}
+
+		//Gear Recipe
+		if (!material.isRadioactive && ItemUtils.checkForInvalidItems(material.getGear(1)) && ItemUtils.checkForInvalidItems(material.getPlate(1)) && ItemUtils.checkForInvalidItems(material.getRod(1))) {
+			if (RecipeUtils.addShapedRecipe(
+					material.getRod(1), material.getPlate(1), material.getRod(1),
+					material.getPlate(1), "craftingToolWrench", material.getPlate(1),
+					material.getRod(1), material.getPlate(1), material.getRod(1),
+					material.getGear(1))){
+				Logger.WARNING("Gear Recipe: "+material.getLocalizedName()+" - Success");
+			}
+			else {
+				Logger.WARNING("Gear Recipe: "+material.getLocalizedName()+" - Failed");
+			}
+		}
+
+		//Screws
+		if (!material.isRadioactive && ItemUtils.checkForInvalidItems(material.getScrew(1)) && ItemUtils.checkForInvalidItems(material.getBolt(1))) {
+			if (RecipeUtils.addShapedRecipe(
+					"craftingToolFile", material.getBolt(1), null,
+					material.getBolt(1), null, null,
+					null, null, null,
+					material.getScrew(1))){
+				Logger.WARNING("Screw Recipe: "+material.getLocalizedName()+" - Success");
+			}
+			else {
+				Logger.WARNING("Screw Recipe: "+material.getLocalizedName()+" - Failed");
+			}
+		}
+	}
+}
diff --git a/src/main/java/gtPlusPlus/xmod/gregtech/loaders/misc/AddCustomMachineToPA.java b/src/main/java/gtPlusPlus/xmod/gregtech/loaders/misc/AddCustomMachineToPA.java
new file mode 100644
index 0000000000..e84ce73a47
--- /dev/null
+++ b/src/main/java/gtPlusPlus/xmod/gregtech/loaders/misc/AddCustomMachineToPA.java
@@ -0,0 +1,51 @@
+package gtPlusPlus.xmod.gregtech.loaders.misc;
+
+import java.lang.reflect.Method;
+
+import gregtech.api.util.GTPP_Recipe;
+import gregtech.api.util.GT_Recipe.GT_Recipe_Map;
+import gtPlusPlus.core.util.reflect.ReflectionUtils;
+
+public class AddCustomMachineToPA {
+
+	private static final boolean sDoesPatchExist;
+	private static final Class sManagerPA;
+	private static final Method sRegisterRecipeMapForMeta;
+
+	static {
+		sDoesPatchExist = ReflectionUtils.doesClassExist("gregtech.api.util.GT_ProcessingArray_Manager");
+		if (sDoesPatchExist) {
+			sManagerPA = ReflectionUtils.getClass("gregtech.api.util.GT_ProcessingArray_Manager");
+			sRegisterRecipeMapForMeta = ReflectionUtils.getMethod(sManagerPA, "registerRecipeMapForMeta", int.class, GT_Recipe_Map.class);
+		}
+		else {
+			sManagerPA = null;
+			sRegisterRecipeMapForMeta = null;
+		}
+	}
+
+	public static final void registerRecipeMapForID(int aID, GT_Recipe_Map aMap) {
+		if (sDoesPatchExist) {
+			ReflectionUtils.invokeNonBool(null, sRegisterRecipeMapForMeta, new Object[] {aID, aMap});
+		}
+
+	}
+
+	public static final void registerRecipeMapBetweenRangeOfIDs(int aMin, int aMax, GT_Recipe_Map aMap) {
+		if (sDoesPatchExist) {
+			for (int i=aMin; i<=aMax;i++) {
+				ReflectionUtils.invokeNonBool(null, sRegisterRecipeMapForMeta, new Object[] {i, aMap});
+				//GT_ProcessingArray_Manager.registerRecipeMapForMeta(i, aMap);
+			}
+		}		
+	}
+
+	public static void register() {
+		
+		// Simple Washers
+		registerRecipeMapForID(767, GTPP_Recipe.GTPP_Recipe_Map.sSimpleWasherRecipes);
+		registerRecipeMapBetweenRangeOfIDs(31017, 31020, GTPP_Recipe.GTPP_Recipe_Map.sSimpleWasherRecipes);
+		
+	}
+
+}
diff --git a/src/main/java/gtPlusPlus/xmod/gregtech/loaders/misc/AssLineAchievements.java b/src/main/java/gtPlusPlus/xmod/gregtech/loaders/misc/AssLineAchievements.java
new file mode 100644
index 0000000000..351a4cc546
--- /dev/null
+++ b/src/main/java/gtPlusPlus/xmod/gregtech/loaders/misc/AssLineAchievements.java
@@ -0,0 +1,180 @@
+package gtPlusPlus.xmod.gregtech.loaders.misc;
+
+import java.util.concurrent.ConcurrentHashMap;
+
+import cpw.mods.fml.common.eventhandler.SubscribeEvent;
+import gregtech.GT_Mod;
+import gregtech.api.util.GT_Log;
+import gregtech.api.util.GT_Recipe;
+import gtPlusPlus.api.objects.Logger;
+import gtPlusPlus.core.lib.CORE;
+import gtPlusPlus.core.util.Utils;
+import gtPlusPlus.core.util.minecraft.ItemUtils;
+import gtPlusPlus.xmod.gregtech.common.StaticFields59;
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.item.ItemStack;
+import net.minecraft.stats.Achievement;
+import net.minecraft.stats.AchievementList;
+import net.minecraft.stats.StatBase;
+import net.minecraftforge.common.AchievementPage;
+import net.minecraftforge.event.entity.player.EntityItemPickupEvent;
+
+public class AssLineAchievements {
+
+	public static int assReg = -1;
+	public static ConcurrentHashMap<String, Achievement> mAchievementMap;
+	public static ConcurrentHashMap<String, Boolean> mIssuedAchievementMap;
+	public static int adjX = 5;
+	public static int adjY = 9;
+	private static boolean active = true;
+
+	public AssLineAchievements() {
+		Logger.INFO(active ? "Loading custom achievement page for Assembly Line recipes."
+				: "Achievements are disabled.");	
+		Utils.registerEvent(this);
+	}
+	
+	private static boolean ready = false;
+	private static int recipeTotal = 0;
+	private static int recipeCount = 0;
+	private static void init() {		
+		if (!ready) {
+			active = GT_Mod.gregtechproxy.mAchievements;
+			try {
+				recipeTotal = ((GT_Recipe.GT_Recipe_Map) StaticFields59.mAssLineVisualMapNEI.get(null)).mRecipeList.size();
+			} catch (IllegalArgumentException | IllegalAccessException e) {
+				recipeTotal = 0;
+			}
+			mAchievementMap = new ConcurrentHashMap<String, Achievement>();
+			mIssuedAchievementMap = new ConcurrentHashMap<String, Boolean>();	
+			ready = true;
+		}		
+		
+	}
+	
+	public static void registerAchievements() {		
+		if (active && mAchievementMap.size() > 0) {
+			AchievementPage.registerAchievementPage(new AchievementPage("GT Assembly Line",
+					(Achievement[]) mAchievementMap.values().toArray(new Achievement[mAchievementMap.size()])));			
+		}
+		else if (active) {
+			Logger.INFO("Unable to register custom achievement page for Assembly Line recipes.");
+		}
+	}
+
+	public static Achievement registerAssAchievement(GT_Recipe recipe) {
+		init();
+		String aSafeUnlocalName;
+		// Debugging
+		if (recipe == null) {
+			Logger.INFO(
+					"Someone tried to register an achievement for an invalid recipe. Please report this to Alkalus.");
+			return null;
+		}
+		if (recipe.getOutput(0) == null) {
+			Logger.INFO(
+					"Someone tried to register an achievement for a recipe with null output. Please report this to Alkalus.");
+			return null;
+		}
+		ItemStack aStack = recipe.getOutput(0);
+		try {
+			aSafeUnlocalName = aStack.getUnlocalizedName();
+		} catch (Throwable t) {
+			aSafeUnlocalName = ItemUtils.getUnlocalizedItemName(aStack);
+		}
+		
+		Achievement aYouDidSomethingInGT;
+		if (mAchievementMap.get(aSafeUnlocalName) == null) {
+			assReg++;
+			recipeCount++;
+			aYouDidSomethingInGT = registerAchievement(aSafeUnlocalName, -(11 + assReg % 5), ((assReg) / 5) - 8,
+					recipe.getOutput(0), AchievementList.openInventory, false);
+		}
+		else {
+			aYouDidSomethingInGT = null;
+		}
+		if (recipeCount >= recipeTotal) {
+			Logger.INFO("Critical mass achieved. ["+recipeCount+"]");
+			registerAchievements();
+		}
+		
+		return aYouDidSomethingInGT;
+	}
+
+	public static Achievement registerAchievement(String textId, int x, int y, ItemStack icon,
+			Achievement requirement, boolean special) {
+		if (!GT_Mod.gregtechproxy.mAchievements) {
+			return null;
+		}
+		Achievement achievement = new Achievement(textId, textId, adjX + x, adjY + y, icon, requirement);
+		if (special) {
+			achievement.setSpecial();
+		}
+		achievement.registerStat();
+		if (CORE.DEVENV) {
+			GT_Log.out.println("achievement." + textId + "=");
+			GT_Log.out.println("achievement." + textId + ".desc=");
+		}
+		mAchievementMap.put(textId, achievement);
+		return achievement;
+	}
+
+	public static void issueAchievement(EntityPlayer entityplayer, String textId) {
+		if (entityplayer == null || !GT_Mod.gregtechproxy.mAchievements) {
+			return;
+		}
+		
+		entityplayer.triggerAchievement((StatBase) getAchievement(textId));
+	}
+
+	public static Achievement getAchievement(String textId) {
+		if (mAchievementMap.containsKey(textId)) {
+			Logger.INFO("Found Achivement: "+textId);
+			return (Achievement) mAchievementMap.get(textId);
+		}
+		return null;
+	}
+
+	@SubscribeEvent
+	public void onItemPickup(EntityItemPickupEvent event) {
+		EntityPlayer player = event.entityPlayer;
+		ItemStack stack = event.item.getEntityItem();
+		String aPickupUnlocalSafe = ItemUtils.getUnlocalizedItemName(stack);
+		if (player == null || stack == null) {
+			return;
+		}
+		
+		if (StaticFields59.sAssemblylineVisualRecipes == null) {
+			return;
+		}
+		
+		Logger.INFO("Trying to check for achievements");
+		// Debug scanner unlocks all AL recipes in creative
+		if (player.capabilities.isCreativeMode && aPickupUnlocalSafe.equals("gt.metaitem.01.32761")) {
+			for (GT_Recipe recipe : StaticFields59.sAssemblylineVisualRecipes.mRecipeList) {
+				issueAchievement(player, recipe.getOutput(0).getUnlocalizedName());
+				recipe.mHidden = false;
+			}
+		}
+		for (GT_Recipe recipe : StaticFields59.sAssemblylineVisualRecipes.mRecipeList) {
+			
+			String aSafeUnlocalName;
+			if (recipe.getOutput(0) == null) {
+				Logger.INFO(
+						"Someone tried to register an achievement for a recipe with null output. Please report this to Alkalus.");
+				continue;
+			}
+			ItemStack aStack = recipe.getOutput(0);
+			aSafeUnlocalName = ItemUtils.getUnlocalizedItemName(aStack);			
+			if (aSafeUnlocalName.equals(aPickupUnlocalSafe)) {
+				issueAchievement(player, aSafeUnlocalName);
+				recipe.mHidden = false;
+				Logger.INFO("FOUND: " + aSafeUnlocalName + " | " + aPickupUnlocalSafe);
+			}
+			else {
+				//Logger.INFO(aSafeUnlocalName + " | " + aPickupUnlocalSafe);
+			}
+		}
+	}
+
+}
diff --git a/src/main/java/gtPlusPlus/xmod/gregtech/loaders/recipe/RecipeLoader_AlgaeFarm.java b/src/main/java/gtPlusPlus/xmod/gregtech/loaders/recipe/RecipeLoader_AlgaeFarm.java
new file mode 100644
index 0000000000..053c71c89d
--- /dev/null
+++ b/src/main/java/gtPlusPlus/xmod/gregtech/loaders/recipe/RecipeLoader_AlgaeFarm.java
@@ -0,0 +1,207 @@
+package gtPlusPlus.xmod.gregtech.loaders.recipe;
+
+import java.util.HashMap;
+
+import gregtech.api.enums.GT_Values;
+import gregtech.api.util.GT_Recipe;
+import gregtech.api.util.GTPP_Recipe;
+import gtPlusPlus.api.objects.Logger;
+import gtPlusPlus.api.objects.data.AutoMap;
+import gtPlusPlus.api.objects.data.WeightedCollection;
+import gtPlusPlus.core.item.chemistry.AgriculturalChem;
+import gtPlusPlus.core.util.math.MathUtils;
+import gtPlusPlus.core.util.minecraft.ItemUtils;
+import net.minecraft.item.ItemStack;
+import net.minecraftforge.fluids.FluidStack;
+
+public class RecipeLoader_AlgaeFarm {
+
+	private static final HashMap<Integer, AutoMap<GT_Recipe>> mRecipeCache = new HashMap<Integer, AutoMap<GT_Recipe>>();
+	private static final HashMap<Integer, AutoMap<GT_Recipe>> mRecipeCompostCache = new HashMap<Integer, AutoMap<GT_Recipe>>();
+
+	public static final void generateRecipes() {
+		for (int i=0;i<10;i++) {
+			getTieredRecipeFromCache(i, false);
+		}
+		for (int i=0;i<10;i++) {
+			getTieredRecipeFromCache(i, true);
+		}
+	}	
+
+	public static GT_Recipe getTieredRecipeFromCache(int aTier, boolean aCompost) {
+		HashMap<Integer, AutoMap<GT_Recipe>> aMap = aCompost ? mRecipeCompostCache : mRecipeCache;
+		String aComp = aCompost ? "(Compost)" : "";
+
+		AutoMap<GT_Recipe> aTemp = aMap.get(aTier);
+		if (aTemp == null || aTemp.isEmpty()) {
+			aTemp = new AutoMap<GT_Recipe>();
+			aMap.put(aTier, aTemp);	
+			Logger.INFO("Tier "+aTier+aComp+" had no recipes, initialising new map.");
+		}		
+		if (aTemp.size() < 500) {
+			Logger.INFO("Tier "+aTier+aComp+" has less than 500 recipes, generating "+(500 - aTemp.size())+".");
+			for (int i=aTemp.size();i<500;i++) {
+				aTemp.put(generateBaseRecipe(aCompost, aTier));
+			}
+		}		
+		int aIndex = MathUtils.randInt(0, aTemp.isEmpty() ? 1 : aTemp.size());
+		Logger.INFO("Using recipe with index of "+aIndex+". "+aComp);
+		return aTemp.get(aIndex);
+	}
+
+	private static GT_Recipe generateBaseRecipe(boolean aUsingCompost, int aTier) {
+
+		// Type Safety
+		if (aTier < 0) {
+			return null;
+		}
+
+		WeightedCollection<Float> aOutputTimeMulti = new WeightedCollection<Float>();
+		for (int i=100;i> 0;i--) {
+			float aValue = 0;
+			if (i < 10) {
+				aValue = 3f;
+			}
+			else if (i < 20) {
+				aValue = 2f;
+			}
+			else {
+				aValue = 1f;				
+			}
+			aOutputTimeMulti.put(i, aValue);			
+		}
+
+		final int[] aDurations = new int[] {
+				432000,					
+				378000,				
+				216000, 
+				162000,				
+				108000,
+				81000,				
+				54000,
+				40500,				
+				27000,
+				20250,
+				13500, 
+				6750, 
+				3375,
+				1686,
+				843, 
+				421
+		};
+
+		ItemStack[] aInputs = new ItemStack[] {};	
+
+		if (aUsingCompost) {
+			// Make it use 4 compost per tier if we have some available
+			ItemStack aCompost = ItemUtils.getSimpleStack(AgriculturalChem.mCompost, aTier * 4);
+			aInputs = new ItemStack[] {aCompost};
+			// Boost Tier by one if using compost so it gets a speed boost
+			aTier++;
+		}
+
+		// We set these elsewhere
+		ItemStack[] aOutputs = getOutputsForTier(aTier);
+
+		GT_Recipe tRecipe = new GTPP_Recipe(
+				false, 
+				aInputs,
+				aOutputs,
+				(Object) null, 
+				new int[] {}, 
+				new FluidStack[] {GT_Values.NF},
+				new FluidStack[] {GT_Values.NF},
+				(int) (aDurations[aTier] * aOutputTimeMulti.get() / 2), // Time
+				0,
+				0);
+		
+		tRecipe.mSpecialValue = tRecipe.hashCode();
+
+		return tRecipe;
+	}
+	
+	private static ItemStack[] getOutputsForTier(int aTier) {
+		
+		// Create an Automap to dump contents into
+		AutoMap<ItemStack> aOutputMap = new AutoMap<ItemStack>();
+		
+		// Buff output by yielding 6-8 times more.
+		for (int i=0;i<MathUtils.randInt(4, 8);i++) {
+			// Add loot relevant to tier and also add any from lower tiers.
+			if (aTier >= 0) {
+				aOutputMap.put(ItemUtils.getSimpleStack(AgriculturalChem.mAlgaeBiosmass, MathUtils.randInt(16, 32)));
+				aOutputMap.put(ItemUtils.getSimpleStack(AgriculturalChem.mAlgaeBiosmass, MathUtils.randInt(32, 64)));			
+				if (MathUtils.randInt(0, 10) > 9) {
+					aOutputMap.put(ItemUtils.getSimpleStack(AgriculturalChem.mGreenAlgaeBiosmass, MathUtils.randInt(8, 16)));				
+				}
+			}
+			if (aTier >= 1) {
+				aOutputMap.put(ItemUtils.getSimpleStack(AgriculturalChem.mAlgaeBiosmass, MathUtils.randInt(16, 32)));
+				aOutputMap.put(ItemUtils.getSimpleStack(AgriculturalChem.mGreenAlgaeBiosmass, MathUtils.randInt(16, 32)));			
+				if (MathUtils.randInt(0, 10) > 9) {
+					aOutputMap.put(ItemUtils.getSimpleStack(AgriculturalChem.mGreenAlgaeBiosmass, MathUtils.randInt(4, 8)));				
+				}
+			}
+			if (aTier >= 2) {
+				aOutputMap.put(ItemUtils.getSimpleStack(AgriculturalChem.mGreenAlgaeBiosmass, MathUtils.randInt(8, 16)));
+				aOutputMap.put(ItemUtils.getSimpleStack(AgriculturalChem.mGreenAlgaeBiosmass, MathUtils.randInt(16, 32)));			
+				if (MathUtils.randInt(0, 10) > 9) {
+					aOutputMap.put(ItemUtils.getSimpleStack(AgriculturalChem.mGreenAlgaeBiosmass, MathUtils.randInt(4, 8)));				
+				}
+			}
+			if (aTier >= 3) {
+				aOutputMap.put(ItemUtils.getSimpleStack(AgriculturalChem.mGreenAlgaeBiosmass, MathUtils.randInt(16, 32)));
+				aOutputMap.put(ItemUtils.getSimpleStack(AgriculturalChem.mBrownAlgaeBiosmass, MathUtils.randInt(2, 8)));			
+				if (MathUtils.randInt(0, 10) > 9) {
+					aOutputMap.put(ItemUtils.getSimpleStack(AgriculturalChem.mBrownAlgaeBiosmass, MathUtils.randInt(8, 16)));				
+				}
+			}
+			if (aTier >= 4) {
+				aOutputMap.put(ItemUtils.getSimpleStack(AgriculturalChem.mBrownAlgaeBiosmass, MathUtils.randInt(16, 32)));
+				aOutputMap.put(ItemUtils.getSimpleStack(AgriculturalChem.mBrownAlgaeBiosmass, MathUtils.randInt(32, 64)));			
+				if (MathUtils.randInt(0, 10) > 9) {
+					aOutputMap.put(ItemUtils.getSimpleStack(AgriculturalChem.mGoldenBrownAlgaeBiosmass, MathUtils.randInt(4, 8)));				
+				}
+			}
+			if (aTier >= 5) {
+				aOutputMap.put(ItemUtils.getSimpleStack(AgriculturalChem.mBrownAlgaeBiosmass, MathUtils.randInt(16, 32)));
+				aOutputMap.put(ItemUtils.getSimpleStack(AgriculturalChem.mGoldenBrownAlgaeBiosmass, MathUtils.randInt(16, 32)));			
+				if (MathUtils.randInt(0, 10) > 9) {
+					aOutputMap.put(ItemUtils.getSimpleStack(AgriculturalChem.mRedAlgaeBiosmass, MathUtils.randInt(1, 2)));				
+				}
+			}
+			// Tier 6 is Highest for outputs
+			if (aTier >= 6) {
+				aOutputMap.put(ItemUtils.getSimpleStack(AgriculturalChem.mGoldenBrownAlgaeBiosmass, MathUtils.randInt(16, 32)));
+				aOutputMap.put(ItemUtils.getSimpleStack(AgriculturalChem.mRedAlgaeBiosmass, MathUtils.randInt(8, 16)));			
+				if (MathUtils.randInt(0, 10) > 9) {
+					aOutputMap.put(ItemUtils.getSimpleStack(AgriculturalChem.mRedAlgaeBiosmass, MathUtils.randInt(8, 16)));				
+				}
+			}
+			
+			// Iterate a special loop at higher tiers to provide more Red/Gold Algae.
+			for (int i2=0;i2<(9-aTier);i2++) {
+				if (aTier >= (6+i2)) {
+					int aMulti = i2 + 1;
+					aOutputMap.put(ItemUtils.getSimpleStack(AgriculturalChem.mGoldenBrownAlgaeBiosmass, MathUtils.randInt(4, 8*aMulti)));
+					aOutputMap.put(ItemUtils.getSimpleStack(AgriculturalChem.mRedAlgaeBiosmass, MathUtils.randInt(4, 8*aMulti)));			
+					if (MathUtils.randInt(0, 10) > 8) {
+						aOutputMap.put(ItemUtils.getSimpleStack(AgriculturalChem.mRedAlgaeBiosmass, MathUtils.randInt(8, 16*aMulti)));				
+					}
+				}
+			}
+		}
+		
+		
+		
+		// Map the AutoMap contents to an Itemstack Array.
+		ItemStack[] aOutputs = new ItemStack[aOutputMap.size()];
+		for (int i=0;i<aOutputMap.size();i++) {
+			aOutputs[i] = aOutputMap.get(i);
+		}	
+		
+		// Return filled ItemStack Array.
+		return aOutputs;
+	}
+	
+}
diff --git a/src/main/java/gtPlusPlus/xmod/gregtech/loaders/recipe/RecipeLoader_GTNH.java b/src/main/java/gtPlusPlus/xmod/gregtech/loaders/recipe/RecipeLoader_GTNH.java
new file mode 100644
index 0000000000..0197142e96
--- /dev/null
+++ b/src/main/java/gtPlusPlus/xmod/gregtech/loaders/recipe/RecipeLoader_GTNH.java
@@ -0,0 +1,22 @@
+package gtPlusPlus.xmod.gregtech.loaders.recipe;
+
+import gregtech.api.enums.GT_Values;
+import gregtech.api.enums.ItemList;
+import gregtech.api.enums.Materials;
+import gtPlusPlus.core.material.ELEMENT;
+import net.minecraft.init.Items;
+import net.minecraft.item.ItemStack;
+import net.minecraftforge.fluids.FluidRegistry;
+import net.minecraftforge.fluids.FluidStack;
+
+public class RecipeLoader_GTNH {
+
+	public static void generate() {
+		GT_Values.RA.addFluidSolidifierRecipe(ItemList.Shape_Mold_Ball.get(0L), new FluidStack(FluidRegistry.getFluid("ender"), 250), new ItemStack(Items.ender_pearl, 1, 0), 100, 30);
+        //MK4
+        GT_Values.RA.addFusionReactorRecipe(Materials.Plutonium241.getMolten(144), Materials.Helium.getGas(1000), ELEMENT.getInstance().CURIUM.getFluidStack(144), 96, 98304, 500000000);
+        GT_Values.RA.addFusionReactorRecipe(ELEMENT.getInstance().CURIUM.getFluidStack(144), Materials.Helium.getPlasma(144), ELEMENT.getInstance().CALIFORNIUM.getFluidStack(144), 128, 196608, 750000000);
+        GT_Values.RA.addFusionReactorRecipe(Materials.Plutonium241.getMolten(144), Materials.Calcium.getPlasma(144), Materials.Flerovium.getMolten(144), 160, 196608, 1000000000);
+	}
+	
+}
diff --git a/src/main/java/gtPlusPlus/xmod/gregtech/loaders/recipe/RecipeLoader_LFTR.java b/src/main/java/gtPlusPlus/xmod/gregtech/loaders/recipe/RecipeLoader_LFTR.java
new file mode 100644
index 0000000000..a09cbcce0d
--- /dev/null
+++ b/src/main/java/gtPlusPlus/xmod/gregtech/loaders/recipe/RecipeLoader_LFTR.java
@@ -0,0 +1,173 @@
+package gtPlusPlus.xmod.gregtech.loaders.recipe;
+
+import gregtech.api.enums.Materials;
+import gregtech.api.util.GTPP_Recipe;
+import gregtech.api.util.GT_Recipe;
+import gregtech.api.util.GasSpargingRecipeMap;
+import gtPlusPlus.api.objects.data.AutoMap;
+import gtPlusPlus.core.material.ELEMENT;
+import gtPlusPlus.core.material.nuclear.FLUORIDES;
+import gtPlusPlus.core.material.nuclear.NUCLIDE;
+import net.minecraft.item.ItemStack;
+import net.minecraftforge.fluids.Fluid;
+import net.minecraftforge.fluids.FluidStack;
+
+public class RecipeLoader_LFTR {	
+
+	private static AutoMap<Fluid> mNobleGases;
+	private static AutoMap<Fluid> mFluorideGases;
+	private static AutoMap<Fluid> mSpargeGases;
+
+	private static void configureSparging() {
+		if (mSpargeGases == null) {
+			mSpargeGases = new AutoMap<Fluid>();
+			mSpargeGases.add(Materials.Helium.getGas(1).getFluid());
+			mSpargeGases.add(Materials.Fluorine.getGas(1).getFluid());
+		}
+		if (mNobleGases == null) {
+			mNobleGases = new AutoMap<Fluid>();
+			mNobleGases.add(mSpargeGases.get(0));
+			mNobleGases.add(ELEMENT.getInstance().XENON.getFluid());
+			mNobleGases.add(ELEMENT.getInstance().NEON.getFluid());
+			mNobleGases.add(ELEMENT.getInstance().ARGON.getFluid());
+			mNobleGases.add(ELEMENT.getInstance().KRYPTON.getFluid());
+			mNobleGases.add(ELEMENT.getInstance().RADON.getFluid());
+		}
+		if (mFluorideGases == null) {
+			mFluorideGases = new AutoMap<Fluid>();
+			mFluorideGases.add(mSpargeGases.get(1));
+			mFluorideGases.add(FLUORIDES.LITHIUM_FLUORIDE.getFluid());
+			mFluorideGases.add(FLUORIDES.NEPTUNIUM_HEXAFLUORIDE.getFluid());
+			mFluorideGases.add(FLUORIDES.TECHNETIUM_HEXAFLUORIDE.getFluid());
+			mFluorideGases.add(FLUORIDES.SELENIUM_HEXAFLUORIDE.getFluid());
+			mFluorideGases.add(FLUORIDES.THORIUM_TETRAFLUORIDE.getFluid());
+		}
+	}
+
+	public static void generate() {
+		// Fli2BeF4 + Thorium TetraFluoride = Uranium233
+		//72k Ticks/hr
+		//1l/4t = 1000l/hr
+		//1l/40t = 1000l/10hr (Probably better) LiFBeF2ThF4UF4
+		//1l/20t= 1000l/2.5hr LiFBeF2ZrF4UF4
+		//1l/10t= 1000l/2.5hr LiFBeF2ZrF4U235
+
+		configureSparging();
+		FluidStack Li2BeF4 = NUCLIDE.Li2BeF4.getFluidStack(200);
+
+		//LiFBeF2ThF4UF4 - T3
+		GT_Recipe LFTR1 = new GTPP_Recipe(
+				false, 
+				new ItemStack[] {},
+				new ItemStack[] {},
+				null, new int[] {10000, 10000, 5000, 2500},
+				new FluidStack[] {
+						NUCLIDE.LiFBeF2ThF4UF4.getFluidStack(100),
+						Li2BeF4
+				},
+				new FluidStack[] {
+						NUCLIDE.LiFBeF2UF4FP.getFluidStack(100),
+						NUCLIDE.LiFBeF2ThF4.getFluidStack(200),
+						FLUORIDES.URANIUM_HEXAFLUORIDE.getFluidStack(20),
+						FLUORIDES.URANIUM_HEXAFLUORIDE.getFluidStack(10)
+				},
+				400 * 20,//time
+				0,//cost
+				8192*4//fuel value
+				);
+
+		//LiFBeF2ZrF4UF4 - T2
+		GT_Recipe LFTR2 = new GTPP_Recipe(
+				false, 
+				new ItemStack[] {},
+				new ItemStack[] {},
+				null, new int[] {10000, 10000, 2500, 1250},
+				new FluidStack[] {
+						NUCLIDE.LiFBeF2ZrF4UF4.getFluidStack(100),
+						Li2BeF4
+				},
+				new FluidStack[] {
+						NUCLIDE.LiFBeF2UF4FP.getFluidStack(50),
+						NUCLIDE.LiFBeF2ThF4.getFluidStack(100),
+						FLUORIDES.URANIUM_HEXAFLUORIDE.getFluidStack(10),
+						FLUORIDES.URANIUM_HEXAFLUORIDE.getFluidStack(5)						
+				},
+				400 * 20,//time
+				0,//cost
+				8192//fuel value
+				);
+
+		//LiFBeF2ZrF4U235 - T1
+		GT_Recipe LFTR3 = new GTPP_Recipe(
+				false, 
+				new ItemStack[] {},
+				new ItemStack[] {},
+				null, new int[] {10000, 10000, 1000, 500},
+				new FluidStack[] {
+						NUCLIDE.LiFBeF2ZrF4U235.getFluidStack(100),
+						Li2BeF4
+				},
+				new FluidStack[] {
+						NUCLIDE.LiFBeF2UF4FP.getFluidStack(25),
+						NUCLIDE.LiFThF4.getFluidStack(50),
+						FLUORIDES.URANIUM_HEXAFLUORIDE.getFluidStack(4),
+						FLUORIDES.URANIUM_HEXAFLUORIDE.getFluidStack(2)
+				},
+				100 *20,//time
+				0,//cost
+				8192//fuel value
+				);
+
+		// Sparging NEI Recipes
+		GasSpargingRecipeMap.addRecipe(
+				new FluidStack(mSpargeGases.get(0), 50),
+				NUCLIDE.LiFBeF2UF4FP.getFluidStack(50),
+				NUCLIDE.Sparged_LiFBeF2UF4FP.getFluidStack(50),
+				new FluidStack[] {
+						new FluidStack(mNobleGases.get(1), 10),
+						new FluidStack(mNobleGases.get(2), 10),
+						new FluidStack(mNobleGases.get(3), 10),
+						new FluidStack(mNobleGases.get(4), 10),
+						new FluidStack(mNobleGases.get(5), 10)
+				},
+				new int[] {
+						1000, 1000, 1000, 1000, 1000
+				});
+
+		GasSpargingRecipeMap.addRecipe(
+				new FluidStack(mSpargeGases.get(1), 50),
+				NUCLIDE.LiFThF4.getFluidStack(50),
+				NUCLIDE.Sparged_LiFThF4.getFluidStack(50),
+				new FluidStack[] {
+						new FluidStack(mFluorideGases.get(1), 5),
+						new FluidStack(mFluorideGases.get(2), 5),
+						new FluidStack(mFluorideGases.get(3), 5),
+						new FluidStack(mFluorideGases.get(4), 5),
+						new FluidStack(mFluorideGases.get(5), 5)
+				},
+				new int[] {
+						500, 500, 500, 500, 500
+				});
+
+		GasSpargingRecipeMap.addRecipe(
+				new FluidStack(mSpargeGases.get(1), 50),
+				NUCLIDE.LiFBeF2ThF4.getFluidStack(50),
+				NUCLIDE.Sparged_LiFBeF2ThF4.getFluidStack(50),
+				new FluidStack[] {
+						new FluidStack(mFluorideGases.get(1), 10),
+						new FluidStack(mFluorideGases.get(2), 10),
+						new FluidStack(mFluorideGases.get(3), 10),
+						new FluidStack(mFluorideGases.get(4), 10),
+						new FluidStack(mFluorideGases.get(5), 10)
+				},
+				new int[] {
+						1000, 1000, 1000, 1000, 1000
+				});
+	
+		GTPP_Recipe.GTPP_Recipe_Map.sLiquidFluorineThoriumReactorRecipes.add(LFTR1);
+		GTPP_Recipe.GTPP_Recipe_Map.sLiquidFluorineThoriumReactorRecipes.add(LFTR2);
+		GTPP_Recipe.GTPP_Recipe_Map.sLiquidFluorineThoriumReactorRecipes.add(LFTR3);
+
+
+	}
+}
diff --git a/src/main/java/gtPlusPlus/xmod/gregtech/loaders/recipe/RecipeLoader_Nuclear.java b/src/main/java/gtPlusPlus/xmod/gregtech/loaders/recipe/RecipeLoader_Nuclear.java
new file mode 100644
index 0000000000..330d507115
--- /dev/null
+++ b/src/main/java/gtPlusPlus/xmod/gregtech/loaders/recipe/RecipeLoader_Nuclear.java
@@ -0,0 +1,695 @@
+package gtPlusPlus.xmod.gregtech.loaders.recipe;
+
+import static gtPlusPlus.core.lib.CORE.GTNH;
+
+import gregtech.api.enums.GT_Values;
+import gregtech.api.enums.ItemList;
+import gregtech.api.util.GT_ModHandler;
+import gtPlusPlus.api.objects.Logger;
+import gtPlusPlus.core.item.chemistry.GenericChem;
+import gtPlusPlus.core.lib.CORE;
+import gtPlusPlus.core.lib.LoadedMods;
+import gtPlusPlus.core.material.ELEMENT;
+import gtPlusPlus.core.material.MISC_MATERIALS;
+import gtPlusPlus.core.material.nuclear.FLUORIDES;
+import gtPlusPlus.core.material.nuclear.NUCLIDE;
+import gtPlusPlus.core.recipe.common.CI;
+import gtPlusPlus.core.util.Utils;
+import gtPlusPlus.core.util.minecraft.FluidUtils;
+import gtPlusPlus.core.util.minecraft.ItemUtils;
+import net.minecraft.item.ItemStack;
+import net.minecraftforge.fluids.FluidStack;
+
+public class RecipeLoader_Nuclear {
+
+
+
+	public static void generate() {
+		createRecipes();
+		RecipeLoader_LFTR.generate();
+		RecipeLoader_NuclearFuelProcessing.generate();	
+	}
+
+	private static void createRecipes() {
+		autoclave();		
+		blastFurnace();
+		centrifugeRecipes();
+		chemicalBathRecipes();
+		chemicalReactorRecipes();
+		dehydratorRecipes();
+		electroMagneticSeperator();
+		fluidExtractorRecipes();
+		fluidHeater();
+		macerator();
+		mixerRecipes();		
+		sifter();
+	}
+
+	private static void autoclave() {	
+
+		GT_Values.RA.addAutoclaveRecipe(
+				ItemUtils.getItemStackOfAmountFromOreDict("dustZirconium", 9),
+				FluidUtils.getFluidStack("chlorine", 9 * 4 * 144),
+				ItemUtils.getItemStackOfAmountFromOreDict("pelletZirconium", 9),
+				0, 
+				120 * 20, 
+				30);
+
+	}
+
+	private static void blastFurnace() {
+
+		GT_Values.RA.addBlastRecipe(
+				FLUORIDES.LITHIUM_FLUORIDE.getDust(2),
+				FLUORIDES.BERYLLIUM_FLUORIDE.getDust(1),
+				GT_Values.NF, 
+				GT_Values.NF,
+				NUCLIDE.Li2BeF4.getDust(3),
+				null, 
+				60 * 20, 2000, 
+				3000);
+
+		GT_Values.RA.addBlastRecipe(
+				ItemUtils.getItemStackOfAmountFromOreDict("dustZrCl4", 1),
+				null, 
+				GT_Values.NF,
+				GT_Values.NF, 
+				ItemUtils.getItemStackOfAmountFromOreDict("dustCookedZrCl4", 1),
+				null,
+				60 * 20,
+				340, 
+				300);
+
+	}
+
+
+	private static void centrifugeRecipes() {				
+
+		//Process Used Fuel Rods for Krypton
+
+		//Uranium
+		GT_Values.RA.addCentrifugeRecipe(
+				CI.getNumberedCircuit(20),
+				ItemUtils.getItemStackFromFQRN("IC2:reactorUraniumSimpledepleted", 8),
+				GT_Values.NF,
+				ELEMENT.getInstance().KRYPTON.getFluidStack(60),
+				ItemList.IC2_Fuel_Rod_Empty.get(8),
+				ELEMENT.getInstance().URANIUM238.getDust(2),
+				ELEMENT.getInstance().URANIUM232.getSmallDust(1),
+				ELEMENT.getInstance().URANIUM233.getSmallDust(1),
+				ELEMENT.getInstance().URANIUM235.getSmallDust(1),
+				ELEMENT.getInstance().PLUTONIUM239.getTinyDust(1),
+				new int[] { 0, 0, 1000, 1000, 1000, 500 }, 500 * 20, 4000);
+		//Mox
+		GT_Values.RA.addCentrifugeRecipe(
+				CI.getNumberedCircuit(20),
+				ItemUtils.getItemStackFromFQRN("IC2:reactorMOXSimpledepleted", 8),
+				GT_Values.NF,
+				ELEMENT.getInstance().KRYPTON.getFluidStack(90),
+				ItemList.IC2_Fuel_Rod_Empty.get(8),
+				ELEMENT.getInstance().PLUTONIUM244.getDust(2),
+				ELEMENT.getInstance().PLUTONIUM241.getTinyDust(1),
+				ELEMENT.getInstance().PLUTONIUM239.getTinyDust(1),
+				ELEMENT.getInstance().PLUTONIUM238.getTinyDust(1),
+				ELEMENT.getInstance().PLUTONIUM239.getTinyDust(1),
+				new int[] { 0, 0, 500, 500, 500, 500 }, 750 * 20, 4000);
+
+		//Thorium
+		GT_Values.RA.addCentrifugeRecipe(
+				CI.getNumberedCircuit(20),
+				ItemList.Depleted_Thorium_1.get(8),
+				GT_Values.NF,
+				ELEMENT.getInstance().KRYPTON.getFluidStack(30),
+				ItemList.IC2_Fuel_Rod_Empty.get(8),
+				ELEMENT.getInstance().THORIUM.getDust(2),
+				ELEMENT.getInstance().THORIUM232.getDust(1),
+				ELEMENT.getInstance().LUTETIUM.getSmallDust(1),
+				ELEMENT.getInstance().POLONIUM.getSmallDust(1),
+				ELEMENT.getInstance().THALLIUM.getTinyDust(1),
+				new int[] { 0, 0, 5000, 5000, 5000, 2500 }, 250 * 20, 4000);
+
+	}
+
+
+	private static void chemicalBathRecipes() {
+
+		int[] chances = {9000, 6000, 3000};
+		GT_Values.RA.addChemicalBathRecipe(ItemUtils.getItemStackOfAmountFromOreDict("dustTin", 12),
+				FluidUtils.getFluidStack("chlorine", 2400),
+				ItemUtils.getItemStackOfAmountFromOreDict("dustZirconium", 3),
+				ItemUtils.getItemStackOfAmountFromOreDict("dustZirconium", 4),
+				ItemUtils.getItemStackOfAmountFromOreDict("dustZirconium", 5), 
+				chances, 
+				30 * 20, 
+				480);
+
+		chances = new int[]{9000, 3000, 1000};		
+		GT_Values.RA.addChemicalBathRecipe(ItemUtils.getItemStackOfAmountFromOreDict("dustRutile", 5),
+				FluidUtils.getFluidStack("chlorine", 4000),
+				ItemUtils.getItemStackOfAmountFromOreDict("dustZirconium", 3),
+				ItemUtils.getItemStackOfAmountFromOreDict("dustTitanium", 1),
+				ItemUtils.getItemStackOfAmountFromOreDict("dustHafnium", 1),
+				chances, 
+				30 * 20, 
+				1024);
+
+		GT_Values.RA.addChemicalBathRecipe(
+				ItemUtils.getItemStackOfAmountFromOreDict("dustLithiumCarbonate", 10),
+				FluidUtils.getFluidStack("hydrofluoricacid", 10 * 144),
+				ItemUtils.getItemStackOfAmountFromOreDict("dustLithiumFluoride", 10), 
+				null, 
+				null,
+				new int[] {},
+				90 * 20,
+				500);
+
+	}
+
+
+	private static void chemicalReactorRecipes() {
+
+		ItemStack aGtHydrofluoricAcid = ItemUtils.getItemStackOfAmountFromOreDictNoBroken("cellHydrofluoricAcid_GT5U", 2);
+
+		GT_Values.RA.addChemicalRecipe(
+				ItemUtils.getItemStackOfAmountFromOreDict("dustLithiumCarbonate", 5), // Input
+				ItemUtils.getItemStackOfAmountFromOreDict("dustCalciumHydroxide", 5), // Input
+				null, // Fluid Input
+				null, // Fluid Output
+				ItemUtils.getItemStackOfAmountFromOreDict("dustLi2CO3CaOH2", 10),
+				600 * 20);
+
+		GT_Values.RA.addChemicalRecipe(
+				ItemUtils.getItemStackOfAmountFromOreDict("dustLithiumHydroxide", 5), // Input
+				null, // Input Stack 2
+				FluidUtils.getFluidStack("hydrofluoricacid", 5 * 144),
+				FluidUtils.getFluidStack("water", 5 * 144), // Fluid Output
+				ItemUtils.getItemStackOfAmountFromOreDict("dustLithiumFluoride", 5),
+				600 * 20);
+
+		GT_Values.RA.addChemicalRecipe(
+				ItemUtils.getItemStackOfAmountFromOreDict("dustLithium7", 1), null,
+				FluidUtils.getFluidStack("sulfuricacid", 144 * 8),
+				FluidUtils.getFluidStack("sulfuriclithium", 144 * 2),
+				ItemUtils.getItemStackOfAmountFromOreDict("dustSmallLithium7", 1),
+				20 * 20);
+
+		GT_Values.RA.addChemicalRecipe(
+				ItemUtils.getItemStackOfAmountFromOreDict("cellOxygen", 1),
+				ItemUtils.getItemStackOfAmountFromOreDict("dustLithium7", 16), 
+				FluidUtils.getFluidStack("water", 1000),
+				FluidUtils.getFluidStack("lithiumhydroxide", 144 * 4),
+				CI.emptyCells(1), 
+				300 * 20);
+
+		// LFTR Fuel Related Compounds
+		if (GTNH) {
+			// Hydroxide
+			GT_Values.RA.addChemicalRecipe(
+					ItemUtils.getGregtechCircuit(3),
+					ELEMENT.getInstance().OXYGEN.getCell(1), 
+					ELEMENT.getInstance().HYDROGEN.getFluidStack(1000),
+					MISC_MATERIALS.HYDROXIDE.getFluidStack(2000),
+					CI.emptyCells(2), 
+					GT_Values.NI, 
+					8 * 20, 
+					30);
+			// Beryllium Hydroxide
+			GT_Values.RA.addChemicalRecipe(
+					ItemUtils.getGregtechCircuit(3),
+					ELEMENT.getInstance().BERYLLIUM.getDust(7),
+					MISC_MATERIALS.HYDROXIDE.getFluidStack(1000),
+					FLUORIDES.BERYLLIUM_HYDROXIDE.getFluidStack(2000),
+					GT_Values.NI,
+					8 * 20,
+					30);
+			// Ammonium Bifluoride
+			GT_Values.RA.addChemicalRecipe(
+					ItemUtils.getGregtechCircuit(3),
+					ItemUtils.getItemStackOfAmountFromOreDict("cellHydrofluoricAcid", 1),
+					MISC_MATERIALS.AMMONIUM.getFluidStack(1000),
+					FLUORIDES.AMMONIUM_BIFLUORIDE.getFluidStack(2000),
+					CI.emptyCells(1),
+					20 * 20,
+					30);
+			if (aGtHydrofluoricAcid != null) {
+				// Ammonium Bifluoride
+				GT_Values.RA.addChemicalRecipe(
+						ItemUtils.getGregtechCircuit(3),
+						aGtHydrofluoricAcid,
+						MISC_MATERIALS.AMMONIUM.getFluidStack(1000),
+						FLUORIDES.AMMONIUM_BIFLUORIDE.getFluidStack(2000),
+						CI.emptyCells(2),
+						40 * 20,
+						30);
+			}
+			// Ammonium
+			GT_Values.RA.addChemicalRecipe(
+					ItemUtils.getGregtechCircuit(3),
+					ELEMENT.getInstance().HYDROGEN.getCell(1),
+					MISC_MATERIALS.AMMONIA.getFluidStack(1000),
+					MISC_MATERIALS.AMMONIUM.getFluidStack(2000),
+					CI.emptyCells(1), 
+					GT_Values.NI, 
+					20 * 20, 
+					30);
+		}
+
+		if (!GTNH) {
+			// Hydroxide
+			GT_Values.RA.addChemicalRecipe(
+					ItemUtils.getGregtechCircuit(3),
+					ELEMENT.getInstance().OXYGEN.getCell(1), 
+					ELEMENT.getInstance().HYDROGEN.getFluidStack(1000),
+					MISC_MATERIALS.HYDROXIDE.getFluidStack(2000),
+					CI.emptyCells(2), 
+					GT_Values.NI, 
+					8 * 20, 
+					30);
+			// Beryllium Hydroxide
+			GT_Values.RA.addChemicalRecipe(
+					ItemUtils.getGregtechCircuit(3),
+					ELEMENT.getInstance().BERYLLIUM.getDust(7),
+					MISC_MATERIALS.HYDROXIDE.getFluidStack(1000),
+					FLUORIDES.BERYLLIUM_HYDROXIDE.getFluidStack(2000),
+					GT_Values.NI,
+					8 * 20,
+					30);
+			// Ammonium Bifluoride
+			GT_Values.RA.addChemicalRecipe(
+					ItemUtils.getGregtechCircuit(3),
+					ItemUtils.getItemStackOfAmountFromOreDict("cellHydrofluoricAcid", 1),
+					MISC_MATERIALS.AMMONIUM.getFluidStack(1000),
+					FLUORIDES.AMMONIUM_BIFLUORIDE.getFluidStack(3000),
+					CI.emptyCells(1),
+					20 * 20,
+					30);
+
+			if (aGtHydrofluoricAcid != null) {
+				// Ammonium Bifluoride
+				GT_Values.RA.addChemicalRecipe(
+						ItemUtils.getGregtechCircuit(3),
+						aGtHydrofluoricAcid,
+						MISC_MATERIALS.AMMONIUM.getFluidStack(1000),
+						FLUORIDES.AMMONIUM_BIFLUORIDE.getFluidStack(2000),
+						CI.emptyCells(2),
+						40 * 20,
+						30);
+			}
+
+			// Ammonium
+			GT_Values.RA.addChemicalRecipe(
+					ItemUtils.getGregtechCircuit(3),
+					ELEMENT.getInstance().HYDROGEN.getCell(1),
+					MISC_MATERIALS.AMMONIA.getFluidStack(1000),
+					MISC_MATERIALS.AMMONIUM.getFluidStack(2000),
+					CI.emptyCells(1), 
+					GT_Values.NI, 
+					20 * 20, 
+					30);
+			// Ammonia
+			GT_Values.RA.addChemicalRecipe(
+					ItemUtils.getItemStackOfAmountFromOreDict("cellHydrogen", 3),
+					ItemUtils.getItemStackOfAmountFromOreDict("dustMagnetite", 0),
+					FluidUtils.getFluidStack("nitrogen", 1000),
+					FluidUtils.getFluidStack("ammonia", 1000),
+					CI.emptyCells(3),
+					14 * 20);
+		}
+
+
+		//Technetium
+		GT_Values.RA.addChemicalRecipe(
+				CI.getNumberedAdvancedCircuit(22),
+				ItemUtils.getItemStackOfAmountFromOreDict("dustTechnetium99", 1), 
+				FluidUtils.getFluidStack("sulfuricacid", 1000), 
+				FluidUtils.getFluidStack("sulfuricacid", 144 * 2),
+				ItemUtils.getItemStackOfAmountFromOreDict("dustTechnetium", 1),
+				100 * 20);
+		
+		// Sodium Hydroxide
+		GT_Values.RA.addChemicalRecipe(
+				CI.getNumberedBioCircuit(15),
+				ItemUtils.getItemStackOfAmountFromOreDict("dustSodiumHydroxide", 1), 
+				FluidUtils.getFluidStack("hydrofluoricacid", 500),
+				FluidUtils.getWater(1000),
+				FLUORIDES.SODIUM_FLUORIDE.getDust(1),
+				60 * 20);
+		
+		if (FluidUtils.doesFluidExist("hydrofluoricacid_gt5u")) {
+			GT_Values.RA.addChemicalRecipe(
+					CI.getNumberedBioCircuit(15),
+					ItemUtils.getItemStackOfAmountFromOreDict("dustSodiumHydroxide", 1), 
+					FluidUtils.getFluidStack("hydrofluoricacid_gt5u", 1000),
+					FluidUtils.getWater(1000),
+					FLUORIDES.SODIUM_FLUORIDE.getDust(1),
+					60 * 20);
+		}
+
+	}
+
+	private static void dehydratorRecipes() {
+
+		// Makes 7-Lithium
+		CORE.RA.addDehydratorRecipe(
+				new ItemStack[] {
+						CI.getNumberedAdvancedCircuit(14),
+						ItemUtils.getItemStackOfAmountFromOreDict("cellSulfuricLithium", 1)
+				}, 
+				FluidUtils.getFluidStack("sulfuriclithium", 440), 
+				null, 
+				new ItemStack[] {
+						CI.emptyCells(1),
+						ItemUtils.getItemStackOfAmountFromOreDict("dustSulfur", 3),
+						ItemUtils.getItemStackOfAmountFromOreDict("dustCopper", 1),
+						ItemUtils.getItemStackOfAmountFromOreDict("dustSodium", 1),
+						ItemUtils.getItemStackOfAmountFromOreDict("dustCarbon", 1),
+						ItemUtils.getItemStackOfAmountFromOreDict("dustLithium7", 4)						
+				},
+				new int[] {10000, 10000, 10000, 10000, 10000}, 
+				30 * 20,
+				30);
+
+		// Makes Lithium Carbonate	
+		CORE.RA.addDehydratorRecipe(
+				new ItemStack[] { 
+						CI.emptyCells(12), 
+						ItemUtils.getItemStackOfAmountFromOreDict("dustLepidolite", 20) 
+				}, // Item input (Array, up to 2)
+				FluidUtils.getFluidStack("sulfuricacid", 10000), 
+				FluidUtils.getFluidStack("sulfuriclithium", 10000),
+				new ItemStack[] { 
+						ItemUtils.getItemStackOfAmountFromOreDict("dustPotassium", 1),
+						ItemUtils.getItemStackOfAmountFromOreDict("dustAluminium", 4),
+						ItemUtils.getItemStackOfAmountFromOreDict("cellOxygen", 10),
+						ItemUtils.getItemStackOfAmountFromOreDict("cellFluorine", 2),
+						ItemUtils.getItemStackOfAmountFromOreDict("dustLithiumCarbonate", 3), // LithiumCarbonate
+				}, // Output Array of Items - Upto 9,
+				new int[] { 10000, 10000, 10000, 10000, 10000 },
+				75 * 20, // Time in ticks
+				1000); // EU
+
+		// Calcium Hydroxide
+		if ((ItemUtils.checkForInvalidItems(ItemUtils.getItemStackOfAmountFromOreDict("dustQuicklime", 1)))	|| LoadedMods.IHL) {
+			CORE.RA.addDehydratorRecipe(
+					new ItemStack[] { 
+							CI.getNumberedBioCircuit(20),
+							ItemUtils.getItemStackOfAmountFromOreDict("dustQuicklime", 10) 
+					},
+					FluidUtils.getFluidStack("water", 10000),
+					null, // Fluid output (slot 2)
+					new ItemStack[] { 
+							ItemUtils.getItemStackOfAmountFromOreDict("dustCalciumHydroxide", 20) 
+					}, // Output
+					new int[] { 10000 }, 
+					120 * 20, // Time in ticks
+					120); // EU	
+		}
+		else {			
+			Logger.INFO("[dustCalciumHydroxide] FAILED TO LOAD RECIPE");
+			if (!ItemUtils.checkForInvalidItems(ItemUtils.getItemStackOfAmountFromOreDict("dustQuicklime", 1))) {
+				Logger.INFO("Could not find dustQuicklime, cannot make dustCalciumHydroxide.");
+			}
+			else if (!LoadedMods.IHL) {
+				Logger.INFO("IHL not loaded.");					
+			}
+		}
+
+		// 2 LiOH + CaCO3
+		CORE.RA.addDehydratorRecipe(
+				new ItemStack[] {
+						CI.getNumberedAdvancedCircuit(20),
+						ItemUtils.getItemStackOfAmountFromOreDict("dustLi2CO3CaOH2", 5)
+				}, // Item
+				null, // Fluid input (slot 1)
+				null, // Fluid output (slot 2)
+				new ItemStack[] {						
+						ItemUtils.getItemStackOfAmountFromOreDict("dustLithiumHydroxide", 2),
+						ItemUtils.getItemStackOfAmountFromOreDict("dustCalciumCarbonate", 3) 
+				}, // Output
+				new int[] { 10000, 10000 },
+				120 * 20, // Time in ticks
+				1000); // EU
+
+		// LiOH Liquid to Dust
+		CORE.RA.addDehydratorRecipe(
+				new ItemStack[] {
+						CI.getNumberedAdvancedCircuit(22)
+				},
+				FluidUtils.getFluidStack("lithiumhydroxide", 144),
+				null,
+				new ItemStack[] { 
+						ItemUtils.getItemStackOfAmountFromOreDict("dustLithiumHydroxide", 1)
+				},
+				new int[] { 10000 },
+				1 * 20, // Time in ticks
+				64); // EU
+
+		// Zirconium Chloride -> TetraFluoride
+		FluidStack aHydrogenChloride = new FluidStack(GenericChem.HydrochloricAcid, 9000);
+		CORE.RA.addDehydratorRecipe(
+				new ItemStack[] { 
+						CI.getNumberedAdvancedCircuit(11),
+						ItemUtils.getItemStackOfAmountFromOreDict("dustCookedZrCl4", 9),
+				}, // Item
+				FluidUtils.getFluidStack("hydrofluoricacid", 9 * 144), 
+				aHydrogenChloride, 
+				new ItemStack[] {
+						FLUORIDES.ZIRCONIUM_TETRAFLUORIDE.getDust(9)
+				},
+				new int[] { 10000 }, 
+				120 * 20, // Time in ticks
+				500); // EU
+
+		// Zirconium Chloride -> TetraFluoride
+		FluidStack aGregtechHydro = FluidUtils.getFluidStack("hydrofluoricacid_gt5u", 1);
+		if (aGregtechHydro != null || Utils.getGregtechVersionAsInt() >= 50929) {
+			CORE.RA.addDehydratorRecipe(
+					new ItemStack[] { 
+							CI.getNumberedAdvancedCircuit(10),
+							ItemUtils.getItemStackOfAmountFromOreDict("dustCookedZrCl4", 9)
+					},
+					FluidUtils.getFluidStack("hydrofluoricacid_gt5u", 18 * 144),
+					aHydrogenChloride,
+					new ItemStack[] { 
+							FLUORIDES.ZIRCONIUM_TETRAFLUORIDE.getDust(9) 
+					},						
+					new int[] { 10000 },
+					240 * 20, // Time in ticks
+					500); // EU
+		}
+
+		// Be(OH)2 + 2 (NH4)HF2 → (NH4)2BeF4 + 2 H2O
+		CORE.RA.addDehydratorRecipe(
+				new ItemStack[] {
+						CI.getNumberedAdvancedCircuit(6),
+						FLUORIDES.AMMONIUM_BIFLUORIDE.getCell(4)
+				}, 
+				FLUORIDES.BERYLLIUM_HYDROXIDE.getFluidStack(2000), // Fluid input (slot 1)
+				FLUORIDES.AMMONIUM_TETRAFLUOROBERYLLATE.getFluidStack(6000), 
+				new ItemStack[] {
+						ItemUtils.getItemStackOfAmountFromOreDict("cellWater", 4)
+				}, 
+				new int[] { 10000}, 
+				32 * 20, // Time in ticks
+				64); // EU
+
+		// (NH4)2BeF4 → 2 NH3 + 2 HF + BeF2
+		CORE.RA.addDehydratorRecipe(
+				new ItemStack[] {
+						CI.getNumberedAdvancedCircuit(17),
+						CI.emptyCells(5)
+				}, 
+				FLUORIDES.AMMONIUM_TETRAFLUOROBERYLLATE.getFluidStack(5000), 
+				null, 
+				new ItemStack[] {
+						MISC_MATERIALS.AMMONIA.getCell(2),
+						ItemUtils.getItemStackOfAmountFromOreDict("cellHydrofluoricAcid", 2),
+						FLUORIDES.BERYLLIUM_FLUORIDE.getCell(1)					
+				},
+				new int[] {10000, 10000, 10000}, 
+				5 * 60 * 20,
+				120);
+
+	}
+
+	private static void electroMagneticSeperator() {
+
+		// Zirconium
+		GT_Values.RA.addElectromagneticSeparatorRecipe(
+				ItemUtils.getItemStackOfAmountFromOreDict("crushedPurifiedBauxite", 1),
+				ItemUtils.getItemStackOfAmountFromOreDict("dustBauxite", 1),
+				ItemUtils.getItemStackOfAmountFromOreDict("dustSmallRutile", 1),
+				ItemUtils.getItemStackOfAmountFromOreDict("nuggetZirconium", 1), 
+				new int[] { 10000, 2500, 4000 },
+				20 * 20, 
+				24);
+
+		// Zircon
+		GT_Values.RA.addElectromagneticSeparatorRecipe(
+				ItemUtils.getItemStackOfAmountFromOreDict("crushedPurifiedMagnetite", 1),
+				ItemUtils.getItemStackOfAmountFromOreDict("dustMagnetite", 1),
+				ItemUtils.getItemStackOfAmountFromOreDict("dustSmallZircon", 1),
+				ItemUtils.getItemStackOfAmountFromOreDict("dustTinyZircon", 1), 
+				new int[] { 10000, 1250, 2500 },
+				20 * 20, 
+				24);
+		GT_Values.RA.addElectromagneticSeparatorRecipe(
+				ItemUtils.getItemStackOfAmountFromOreDict("crushedPurifiedCassiterite", 1),
+				ItemUtils.getItemStackOfAmountFromOreDict("dustCassiterite", 1),
+				ItemUtils.getItemStackOfAmountFromOreDict("dustSmallZircon", 1),
+				ItemUtils.getItemStackOfAmountFromOreDict("dustTinyZircon", 1), 
+				new int[] { 10000, 1250, 2500 },
+				20 * 20, 
+				24);
+
+	}
+
+	private static void fluidExtractorRecipes() {
+
+		//FLiBe fuel
+		CORE.RA.addFluidExtractionRecipe(
+				NUCLIDE.Li2BeF4.getDust(1),
+				NUCLIDE.Li2BeF4.getFluidStack(144),
+				100,
+				500);
+		//LFTR Fuel 1
+		CORE.RA.addFluidExtractionRecipe(
+				NUCLIDE.LiFBeF2ZrF4U235.getDust(1),
+				NUCLIDE.LiFBeF2ZrF4U235.getFluidStack(144),
+				250, 
+				1000);
+		CORE.RA.addFluidExtractionRecipe(
+				NUCLIDE.LiFBeF2ZrF4UF4.getDust(1),
+				NUCLIDE.LiFBeF2ZrF4UF4.getFluidStack(144),
+				150, 
+				1500);
+		CORE.RA.addFluidExtractionRecipe(
+				NUCLIDE.LiFBeF2ThF4UF4.getDust(1),
+				NUCLIDE.LiFBeF2ThF4UF4.getFluidStack(144),
+				150, 
+				2000);
+
+		//ZIRCONIUM_TETRAFLUORIDE
+		CORE.RA.addFluidExtractionRecipe(
+				FLUORIDES.ZIRCONIUM_TETRAFLUORIDE.getDust(1),
+				FLUORIDES.ZIRCONIUM_TETRAFLUORIDE.getFluidStack(144),
+				200, 
+				512+256);
+
+	}
+
+	private static void macerator() {	
+
+		GT_ModHandler.addPulverisationRecipe(
+				ItemUtils.getItemStackOfAmountFromOreDict("pelletZirconium", 1),
+				ItemUtils.getItemStackOfAmountFromOreDict("dustZrCl4", 1));
+
+	}
+
+	private static void mixerRecipes() {		
+
+		GT_Values.RA.addMixerRecipe(
+				ItemUtils.getItemStackOfAmountFromOreDict("dustUranium233", 4),
+				ItemUtils.getItemStackOfAmountFromOreDict("dustUranium235", 1),
+				null, 
+				null,
+				FluidUtils.getFluidStack("hydrofluoricacid", 5000),
+				FLUORIDES.URANIUM_TETRAFLUORIDE.getFluidStack(5000),
+				null,
+				3000, 
+				500);
+
+	}
+
+
+	private static void sifter() {		
+
+		// Zirconium
+		GT_Values.RA.addSifterRecipe(
+				ItemUtils.getItemStackOfAmountFromOreDict("crushedPurifiedIlmenite", 1),
+				new ItemStack[] { 
+						ItemUtils.getItemStackOfAmountFromOreDict("dustIron", 1),
+						ItemUtils.getItemStackOfAmountFromOreDict("dustTinyWroughtIron", 1),
+						ItemUtils.getItemStackOfAmountFromOreDict("dustZirconium", 1),
+						ItemUtils.getItemStackOfAmountFromOreDict("dustZirconium", 1),
+						ItemUtils.getItemStackOfAmountFromOreDict("dustHafnium", 1),
+						ItemUtils.getItemStackOfAmountFromOreDict("dustHafnium", 1) },
+				new int[] { 5000, 2500, 1000, 1000, 300, 300 }, 
+				20 * 30, 
+				500);
+		GT_Values.RA.addSifterRecipe(
+				ItemUtils.getItemStackOfAmountFromOreDict("crushedPurifiedTin", 1),
+				new ItemStack[] { 
+						ItemUtils.getItemStackOfAmountFromOreDict("dustTin", 1),
+						ItemUtils.getItemStackOfAmountFromOreDict("dustTinyZinc", 1),
+						ItemUtils.getItemStackOfAmountFromOreDict("dustZirconium", 1),
+						ItemUtils.getItemStackOfAmountFromOreDict("dustZirconium", 1),
+						ItemUtils.getItemStackOfAmountFromOreDict("dustZirconium", 1),
+						ItemUtils.getItemStackOfAmountFromOreDict("dustZirconium", 1) },
+				new int[] { 10000, 5000, 1500, 1000, 500, 500 }, 
+				20 * 30, 
+				500);
+		GT_Values.RA.addSifterRecipe(
+				ItemUtils.getItemStackOfAmountFromOreDict("crushedPurifiedCassiterite", 1),
+				new ItemStack[] { 
+						ItemUtils.getItemStackOfAmountFromOreDict("dustCassiterite", 1),
+						ItemUtils.getItemStackOfAmountFromOreDict("dustTinyTin", 1),
+						ItemUtils.getItemStackOfAmountFromOreDict("dustZirconium", 1),
+						ItemUtils.getItemStackOfAmountFromOreDict("dustZirconium", 1),
+						ItemUtils.getItemStackOfAmountFromOreDict("dustZirconium", 1),
+						ItemUtils.getItemStackOfAmountFromOreDict("dustZirconium", 1) },
+				new int[] { 10000, 5000, 1500, 1000, 500, 500 }, 
+				20 * 30, 
+				500);
+
+		// Radium
+		GT_Values.RA.addSifterRecipe(
+				ItemUtils.getItemStackOfAmountFromOreDict("crushedPurifiedUranium", 1),
+				new ItemStack[] { 
+						ItemUtils.getItemStackOfAmountFromOreDict("dustUranium", 1),
+						ItemUtils.getItemStackOfAmountFromOreDict("dustTinyLead", 1),
+						ItemUtils.getItemStackOfAmountFromOreDict("dustRadium226", 1),
+						ItemUtils.getItemStackOfAmountFromOreDict("dustRadium226", 1),
+						ItemUtils.getItemStackOfAmountFromOreDict("dustRadium226", 1),
+						ItemUtils.getItemStackOfAmountFromOreDict("dustRadium226", 1) },
+				new int[] { 10000, 5000, 1000, 500, 500, 500 }, 
+				20 * 30, 
+				500);
+		GT_Values.RA.addSifterRecipe(
+				ItemUtils.getItemStackOfAmountFromOreDict("crushedPurifiedUraninite", 1),
+				new ItemStack[] { 
+						ItemUtils.getItemStackOfAmountFromOreDict("dustUraninite", 1),
+						ItemUtils.getItemStackOfAmountFromOreDict("dustTinyUranium", 1),
+						ItemUtils.getItemStackOfAmountFromOreDict("dustRadium226", 1),
+						ItemUtils.getItemStackOfAmountFromOreDict("dustRadium226", 1),
+						ItemUtils.getItemStackOfAmountFromOreDict("dustRadium226", 1),
+						ItemUtils.getItemStackOfAmountFromOreDict("dustRadium226", 1) },
+				new int[] { 10000, 5000, 500, 250, 250, 250 }, 
+				20 * 30, 
+				500);
+		GT_Values.RA.addSifterRecipe(
+				ItemUtils.getItemStackOfAmountFromOreDict("crushedPurifiedPitchblende", 1),
+				new ItemStack[] { 
+						ItemUtils.getItemStackOfAmountFromOreDict("dustPitchblende", 1),
+						ItemUtils.getItemStackOfAmountFromOreDict("dustTinyLead", 1),
+						ItemUtils.getItemStackOfAmountFromOreDict("dustRadium226", 1),
+						ItemUtils.getItemStackOfAmountFromOreDict("dustRadium226", 1),
+						ItemUtils.getItemStackOfAmountFromOreDict("dustRadium226", 1),
+						ItemUtils.getItemStackOfAmountFromOreDict("dustRadium226", 1) },
+				new int[] { 10000, 5000, 500, 250, 250, 250 }, 
+				20 * 30, 
+				500);
+	}
+	
+	private static void fluidHeater() {
+		
+		CORE.RA.addFluidHeaterRecipe(
+				FLUORIDES.SODIUM_FLUORIDE.getDust(1),
+				null,
+				FLUORIDES.SODIUM_FLUORIDE.getFluidStack(144),
+				20 * 30, 
+				500);
+		
+	}
+
+}
diff --git a/src/main/java/gtPlusPlus/xmod/gregtech/loaders/recipe/RecipeLoader_NuclearFuelProcessing.java b/src/main/java/gtPlusPlus/xmod/gregtech/loaders/recipe/RecipeLoader_NuclearFuelProcessing.java
new file mode 100644
index 0000000000..c2c8c01f45
--- /dev/null
+++ b/src/main/java/gtPlusPlus/xmod/gregtech/loaders/recipe/RecipeLoader_NuclearFuelProcessing.java
@@ -0,0 +1,372 @@
+package gtPlusPlus.xmod.gregtech.loaders.recipe;
+
+import gregtech.api.enums.GT_Values;
+import gtPlusPlus.core.item.ModItems;
+import gtPlusPlus.core.item.chemistry.NuclearChem;
+import gtPlusPlus.core.lib.CORE;
+import gtPlusPlus.core.material.ELEMENT;
+import gtPlusPlus.core.material.nuclear.FLUORIDES;
+import gtPlusPlus.core.material.nuclear.NUCLIDE;
+import gtPlusPlus.core.recipe.common.CI;
+import gtPlusPlus.core.util.minecraft.FluidUtils;
+import gtPlusPlus.core.util.minecraft.ItemUtils;
+import gtPlusPlus.core.util.minecraft.MaterialUtils;
+import net.minecraft.item.ItemStack;
+import net.minecraftforge.fluids.FluidStack;
+
+public class RecipeLoader_NuclearFuelProcessing {	
+
+	public static void generate() {
+
+		// Create Fuels
+
+		final FluidStack aLithiumFluoride = FLUORIDES.LITHIUM_FLUORIDE.getFluidStack(100);
+		final FluidStack aBerylliumFluoride = FLUORIDES.BERYLLIUM_FLUORIDE.getFluidStack(100);
+		final FluidStack aThoriumFluoride = FLUORIDES.THORIUM_TETRAFLUORIDE.getFluidStack(100);
+		final FluidStack aZirconiumFluoride = FLUORIDES.ZIRCONIUM_TETRAFLUORIDE.getFluidStack(100);
+		final FluidStack aUraniumTetraFluoride = FLUORIDES.URANIUM_TETRAFLUORIDE.getFluidStack(100);
+		final FluidStack aUranium235 = ELEMENT.getInstance().URANIUM235.getFluidStack(1000);
+		final FluidStack aLiFBeF2ZrF4U235 = NUCLIDE.LiFBeF2ZrF4U235.getFluidStack(100);
+		final FluidStack aLiFBeF2ZrF4UF4 = NUCLIDE.LiFBeF2ZrF4UF4.getFluidStack(100);	
+		final FluidStack aLiFBeF2ThF4UF4 = NUCLIDE.LiFBeF2ThF4UF4.getFluidStack(100);	
+
+		// 7LiF - BeF2 - ZrF4 - U235 - 590C
+		CORE.RA.addFissionFuel(
+				FluidUtils.getFluidStack(aLithiumFluoride, 550),
+				FluidUtils.getFluidStack(aBerylliumFluoride, 150),
+				FluidUtils.getFluidStack(aZirconiumFluoride, 60),
+				FluidUtils.getFluidStack(aUranium235, 240),
+				null, null, null, null, null, // Extra 5 inputs
+				FluidUtils.getFluidStack(aLiFBeF2ZrF4U235, 1000),
+				null,
+				90 * 60 * 20, // Duration
+				MaterialUtils.getVoltageForTier(4)
+				);
+
+		// 7LiF - BeF2 - ZrF4 - UF4 - 650C
+		CORE.RA.addFissionFuel(
+				FluidUtils.getFluidStack(aLithiumFluoride, 600),
+				FluidUtils.getFluidStack(aBerylliumFluoride, 250),
+				FluidUtils.getFluidStack(aZirconiumFluoride, 80),
+				FluidUtils.getFluidStack(aUraniumTetraFluoride, 70),
+				null, null, null, null, null, // Extra 5 inputs
+				FluidUtils.getFluidStack(aLiFBeF2ZrF4UF4, 1000),
+				null,
+				120 * 60 * 20,
+				MaterialUtils.getVoltageForTier(5)
+				);
+
+		// 7liF - BeF2 - ThF4 - UF4 - 566C
+		CORE.RA.addFissionFuel(
+				FluidUtils.getFluidStack(aLithiumFluoride, 580),
+				FluidUtils.getFluidStack(aBerylliumFluoride, 270),
+				FluidUtils.getFluidStack(aThoriumFluoride, 80),
+				FluidUtils.getFluidStack(aUraniumTetraFluoride, 70),
+				null, null, null, null, null, // Extra 5 inputs
+				FluidUtils.getFluidStack(aLiFBeF2ThF4UF4, 1000),
+				null,
+				150 * 60 * 20, // Duration
+				MaterialUtils.getVoltageForTier(5)
+				);
+
+
+		// Reprocess Fuels
+
+
+		// Reactor Blanket step 1 - Fluorination
+		CORE.RA.addReactorProcessingUnitRecipe(
+				CI.getNumberedAdvancedCircuit(17),
+				ELEMENT.getInstance().FLUORINE.getCell(6),
+				NUCLIDE.LiFThF4.getFluidStack(10000),
+				new ItemStack[] {
+						CI.emptyCells(5),
+						FLUORIDES.LITHIUM_FLUORIDE.getCell(1),
+						ItemUtils.getSimpleStack(ModItems.dustProtactinium233),
+						ItemUtils.getSimpleStack(ModItems.dustProtactinium233),
+						ItemUtils.getSimpleStack(ModItems.dustProtactinium233),
+						ItemUtils.getSimpleStack(ModItems.dustProtactinium233),
+						ItemUtils.getSimpleStack(ModItems.dustProtactinium233),
+						ItemUtils.getSimpleStack(ModItems.dustProtactinium233)
+				},
+				new int[] {10000, 10000, 500, 500, 500, 250, 250, 250},
+				NUCLIDE.UF6F2.getFluidStack(1500),
+				20 * 60 * 10,
+				MaterialUtils.getVoltageForTier(5));		
+		CORE.RA.addReactorProcessingUnitRecipe(
+				CI.getNumberedAdvancedCircuit(18),
+				ELEMENT.getInstance().FLUORINE.getCell(6),
+				NUCLIDE.LiFBeF2ThF4.getFluidStack(10000),
+				new ItemStack[] {
+						CI.emptyCells(4),
+						FLUORIDES.LITHIUM_FLUORIDE.getCell(1),
+						FLUORIDES.BERYLLIUM_FLUORIDE.getCell(1),
+						ItemUtils.getSimpleStack(ModItems.dustProtactinium233),
+						ItemUtils.getSimpleStack(ModItems.dustProtactinium233),
+						ItemUtils.getSimpleStack(ModItems.dustProtactinium233),
+						ItemUtils.getSimpleStack(ModItems.dustProtactinium233),
+						ItemUtils.getSimpleStack(ModItems.dustProtactinium233),
+						ItemUtils.getSimpleStack(ModItems.dustProtactinium233)
+				},
+				new int[] {10000, 10000, 10000, 1000, 1000, 1000, 500, 500, 500},
+				NUCLIDE.UF6F2.getFluidStack(3000),
+				20 * 60 * 10,
+				MaterialUtils.getVoltageForTier(5));
+		
+		// Reactor Blanket step 1 - Fluorination
+		CORE.RA.addReactorProcessingUnitRecipe(
+				CI.getNumberedAdvancedCircuit(7),
+				ELEMENT.getInstance().FLUORINE.getCell(6),
+				NUCLIDE.Sparged_LiFThF4.getFluidStack(10000),
+				new ItemStack[] {
+						CI.emptyCells(4),
+						FLUORIDES.LITHIUM_FLUORIDE.getCell(2),
+						ItemUtils.getSimpleStack(ModItems.dustProtactinium233),
+						ItemUtils.getSimpleStack(ModItems.dustProtactinium233),
+						ItemUtils.getSimpleStack(ModItems.dustProtactinium233),
+						ItemUtils.getSimpleStack(ModItems.dustProtactinium233),
+						ItemUtils.getSimpleStack(ModItems.dustProtactinium233),
+						ItemUtils.getSimpleStack(ModItems.dustProtactinium233)
+				},
+				new int[] {10000, 10000, 1000, 1000, 1000, 1000, 1000, 1000},
+				NUCLIDE.UF6F2.getFluidStack(3000),
+				20 * 60 * 5,
+				MaterialUtils.getVoltageForTier(5));		
+		CORE.RA.addReactorProcessingUnitRecipe(
+				CI.getNumberedAdvancedCircuit(8),
+				ELEMENT.getInstance().FLUORINE.getCell(6),
+				NUCLIDE.Sparged_LiFBeF2ThF4.getFluidStack(10000),
+				new ItemStack[] {
+						CI.emptyCells(2),
+						FLUORIDES.LITHIUM_FLUORIDE.getCell(2),
+						FLUORIDES.BERYLLIUM_FLUORIDE.getCell(2),
+						ItemUtils.getSimpleStack(ModItems.dustProtactinium233),
+						ItemUtils.getSimpleStack(ModItems.dustProtactinium233),
+						ItemUtils.getSimpleStack(ModItems.dustProtactinium233),
+						ItemUtils.getSimpleStack(ModItems.dustProtactinium233),
+						ItemUtils.getSimpleStack(ModItems.dustProtactinium233),
+						ItemUtils.getSimpleStack(ModItems.dustProtactinium233)
+				},
+				new int[] {10000, 10000, 10000, 2000, 2000, 2000, 2000, 2000, 2000},
+				NUCLIDE.UF6F2.getFluidStack(6000),
+				20 * 60 * 5,
+				MaterialUtils.getVoltageForTier(5));
+
+
+		// Reactor Blanket step 2 - Sorption + Cold Trap
+		CORE.RA.addColdTrapRecipe(
+				8,
+				FLUORIDES.SODIUM_FLUORIDE.getCell(4),
+				NUCLIDE.UF6F2.getFluidStack(3000),
+				new ItemStack[] {
+						ELEMENT.getInstance().FLUORINE.getCell(2),
+						FLUORIDES.URANIUM_HEXAFLUORIDE.getCell(2),
+						ELEMENT.getInstance().URANIUM233.getDust(1),
+						ELEMENT.getInstance().URANIUM233.getDust(1),
+						ELEMENT.getInstance().URANIUM233.getDust(1)
+				},
+				new int[] {10000, 10000, 3000, 2000, 1000},
+				FLUORIDES.SODIUM_FLUORIDE.getFluidStack(2000),
+				20 * 60 * 10,
+				MaterialUtils.getVoltageForTier(3));
+
+
+
+
+		// Reactor Core step 0 - Process Burnt Salt
+		// Tier 1 Fuel - Gives back FLIBE and breeds U233
+		/*		CORE.RA.addReactorProcessingUnitRecipe(
+						CI.getNumberedAdvancedCircuit(1),
+						CI.emptyCells(2),
+						new FluidStack(NuclearChem.Burnt_LiFBeF2ZrF4U235, 4000),
+						new ItemStack[] {
+								FLUORIDES.LITHIUM_FLUORIDE.getCell(1),
+								ELEMENT.getInstance().URANIUM233.getCell(1)
+						},
+						new int[] {10000, 10000},
+						NUCLIDE.LiFBeF2.getFluidStack(2000),
+						20 * 60 * 60,
+						MaterialUtils.getVoltageForTier(3));*/
+
+
+
+		// LiBeF2UF4FP + F2 = LiFBeF2 & UF6F2FP
+		// Reactor Core step 1 - Process Burnt Salt
+		CORE.RA.addReactorProcessingUnitRecipe(
+				CI.getNumberedAdvancedCircuit(1),
+				ELEMENT.getInstance().FLUORINE.getCell(1),
+				NUCLIDE.LiFBeF2UF4FP.getFluidStack(1000),
+				new ItemStack[] {
+						NUCLIDE.UF6F2FP.getCell(1)
+				},
+				new int[] {10000},
+				FluidUtils.getFluidStack(NuclearChem.Impure_LiFBeF2, 1000),
+				20 * 60 * 120,
+				MaterialUtils.getVoltageForTier(3));
+		
+		// LiBeF2UF4FP + F2 = LiFBeF2 & UF6F2FP
+		// Reactor Core step 1 - Process Burnt Salt
+		CORE.RA.addReactorProcessingUnitRecipe(
+				CI.getNumberedAdvancedCircuit(1),
+				ELEMENT.getInstance().FLUORINE.getCell(3),
+				NUCLIDE.Sparged_LiFBeF2UF4FP.getFluidStack(1000),
+				new ItemStack[] {
+						CI.emptyCells(1),
+						NUCLIDE.UF6F2FP.getCell(2)
+				},
+				new int[] {10000},
+				FluidUtils.getFluidStack(NuclearChem.Impure_LiFBeF2, 2000),
+				20 * 60 * 60,
+				MaterialUtils.getVoltageForTier(3));
+
+		
+
+		// Reactor Core step 2A - Sorption + Cold Trap
+		CORE.RA.addColdTrapRecipe(
+				8,
+				FLUORIDES.SODIUM_FLUORIDE.getCell(3),
+				NUCLIDE.UF6F2FP.getFluidStack(2000),
+				new ItemStack[] {
+						ELEMENT.getInstance().FLUORINE.getCell(1),
+						FLUORIDES.URANIUM_HEXAFLUORIDE.getCell(2),
+						ELEMENT.getInstance().PHOSPHORUS.getDust(1),
+						ELEMENT.getInstance().PHOSPHORUS.getDust(1),
+						ELEMENT.getInstance().PHOSPHORUS.getDust(1),
+						ELEMENT.getInstance().PHOSPHORUS.getDust(1),
+						ELEMENT.getInstance().PHOSPHORUS.getDust(1),
+						ELEMENT.getInstance().PHOSPHORUS.getDust(1),
+						ELEMENT.getInstance().PHOSPHORUS.getDust(1)
+				},
+				new int[] {10000, 10000, 5000, 5000, 5000, 5000, 5000, 5000, 5000},
+				FLUORIDES.SODIUM_FLUORIDE.getFluidStack(2000),
+				20 * 60 * 10,
+				MaterialUtils.getVoltageForTier(4));
+
+
+		// Reactor Core step 2B - Distillation
+		GT_Values.RA.addDistillationTowerRecipe(
+				FluidUtils.getFluidStack(NuclearChem.Impure_LiFBeF2, 1000), 
+				new FluidStack[] {
+						NUCLIDE.LiFBeF2.getFluidStack(250)
+				}, 
+				null, 
+				120 * 60 * 20, 
+				MaterialUtils.getVoltageForTier(3));
+
+
+		// UF6 -> UF4 reduction
+		// UF6 + LiFBeF2 + H2 -> LiFBeF2UF4 + HF		
+		CORE.RA.addBlastRecipe(
+				new ItemStack[] {
+						FLUORIDES.URANIUM_HEXAFLUORIDE.getCell(1),
+						NUCLIDE.LiFBeF2.getCell(1)
+				},
+				new FluidStack[] {
+						ELEMENT.getInstance().HYDROGEN.getFluidStack(2000)
+				},
+				new ItemStack[] {
+						ItemUtils.getItemStackOfAmountFromOreDict("cellHydrofluoricAcid", 2),
+						CI.emptyCells(1)
+				},
+				new FluidStack[] {
+						NUCLIDE.LiFBeF2UF4.getFluidStack(3000)
+				}, 
+				20 * 60 * 10, 
+				MaterialUtils.getVoltageForTier(4), 
+				6500);
+
+
+
+
+		// LiFBeF2ZrF4U235 - We can't add both ZrF4 and U235 here, so best we leave this disabled.
+		/*CORE.RA.addReactorProcessingUnitRecipe(
+				CI.getNumberedAdvancedCircuit(8),
+				NUCLIDE.LiFBeF2UF4.getCell(9),
+				ELEMENT.getInstance().URANIUM235.getFluidStack(1000),
+				new ItemStack[] {
+						CI.emptyCells(9)
+						},
+				new int[] {10000},
+				NUCLIDE.LiFBeF2ZrF4U235.getFluidStack(10000),
+				20 * 60 * 5,
+				MaterialUtils.getVoltageForTier(4));*/
+
+		// LiFBeF2ZrF4UF4
+		/*CORE.RA.addReactorProcessingUnitRecipe(
+				CI.getNumberedAdvancedCircuit(9),
+				NUCLIDE.LiFBeF2UF4.getCell(9),
+				FLUORIDES.ZIRCONIUM_TETRAFLUORIDE.getFluidStack(1000),
+				new ItemStack[] {
+						CI.emptyCells(9)
+				},
+				new int[] {10000},
+				NUCLIDE.LiFBeF2ZrF4UF4.getFluidStack(10000),
+				20 * 60 * 5,
+				MaterialUtils.getVoltageForTier(5));
+		
+		CORE.RA.addReactorProcessingUnitRecipe(
+				CI.getNumberedAdvancedCircuit(9),
+				FLUORIDES.ZIRCONIUM_TETRAFLUORIDE.getCell(1),
+				NUCLIDE.LiFBeF2UF4.getFluidStack(9000),
+				new ItemStack[] {
+						CI.emptyCells(1)
+				},
+				new int[] {10000},
+				NUCLIDE.LiFBeF2ZrF4UF4.getFluidStack(10000),
+				20 * 60 * 5,
+				MaterialUtils.getVoltageForTier(5));*/
+		
+		CORE.RA.addFissionFuel(
+				FLUORIDES.ZIRCONIUM_TETRAFLUORIDE.getFluidStack(1000),
+				NUCLIDE.LiFBeF2UF4.getFluidStack(9000),
+				null,
+				null,
+				null, null, null, null, null,
+				NUCLIDE.LiFBeF2ZrF4UF4.getFluidStack(10000),
+				null,
+				20 * 60 * 120, // Duration
+				MaterialUtils.getVoltageForTier(5)
+				);
+
+		// LiFBeF2ThF4UF4
+		/*CORE.RA.addReactorProcessingUnitRecipe(
+				CI.getNumberedAdvancedCircuit(10),
+				NUCLIDE.LiFBeF2UF4.getCell(9),
+				FLUORIDES.THORIUM_TETRAFLUORIDE.getFluidStack(1000),
+				new ItemStack[] {
+						CI.emptyCells(9)
+				},
+				new int[] {10000},
+				NUCLIDE.LiFBeF2ThF4UF4.getFluidStack(10000),
+				20 * 60 * 5,
+				MaterialUtils.getVoltageForTier(5));
+		
+		CORE.RA.addReactorProcessingUnitRecipe(
+				CI.getNumberedAdvancedCircuit(10),
+				FLUORIDES.THORIUM_TETRAFLUORIDE.getCell(1),
+				NUCLIDE.LiFBeF2UF4.getFluidStack(9000),
+				new ItemStack[] {
+						CI.emptyCells(1)
+				},
+				new int[] {10000},
+				NUCLIDE.LiFBeF2ThF4UF4.getFluidStack(10000),
+				20 * 60 * 5,
+				MaterialUtils.getVoltageForTier(5));*/
+
+
+		CORE.RA.addFissionFuel(
+				FLUORIDES.THORIUM_TETRAFLUORIDE.getFluidStack(1000),
+				NUCLIDE.LiFBeF2UF4.getFluidStack(9000),
+				null,
+				null,
+				null, null, null, null, null,
+				NUCLIDE.LiFBeF2ThF4UF4.getFluidStack(10000),
+				null,
+				20 * 60 * 150, // Duration
+				MaterialUtils.getVoltageForTier(5)
+				);
+
+
+
+
+	}
+}