diff --git a/Core/CwCheat.h b/Core/CwCheat.h
new file mode 100644
index 0000000000..e04945da71
--- /dev/null
+++ b/Core/CwCheat.h
@@ -0,0 +1,494 @@
+
+#include <string>
+#include <vector>
+#include <map>
+#include <iostream>
+#include <sstream>
+
+#include "Core\MemMap.h"
+
+using namespace std;
+class CheatsThread;
+class CheatsGUI;
+vector<string> makeCodeParts(string l);
+void trim2(string& str);
+static long parseLong(string s);
+static long parseHexLong(string s);
+
+
+class CheatsGUI {
+private:
+	
+	static long const serialVersionUID = 6791588139795694296L;
+	static long const int cheatsThreadSleepMillis = 5;
+	bool cheatsOn;
+	CheatsThread cheatsThread;
+public:
+	CheatsGUI();
+	string String();
+	void addCheatLine(string& line);
+	void onCheatsThreadEnded();
+	void dispose();
+	vector<string> getCodesList();
+};
+class CheatsThread {
+	private:
+		std::vector<std::string> codes;
+		int currentCode;
+		CheatsGUI cheats;
+		bool exit2;
+		void skipCodes(int count);
+		void skipAllCodes();
+		int getAddress(int value);
+
+
+	public:
+		CheatsThread(CheatsGUI cheats);
+		void exit();
+		void run();
+		string getNextCode();
+};
+
+CheatsThread::CheatsThread(CheatsGUI cheats){
+	this->cheats = cheats;
+}
+
+void CheatsThread::exit() {
+	exit2 = true;
+}
+
+string CheatsThread::getNextCode() {
+	string code;
+	string modifier = "_L";
+	while (true)  {
+		if (currentCode >= codes.size()) {
+			code.clear();
+			break;
+		}
+
+		code = codes[currentCode++];
+		trim2(code);
+
+		if (code.substr(0,2) == modifier) {
+			code = code.substr(3,21);
+		}
+		else if (code[0] == '0') {
+			break;
+		}
+	}
+	return code;
+}
+
+void CheatsThread::skipCodes(int count) {
+	for (int i = 0; i < count; i ++) {
+		if (getNextCode() == "") {
+			break;
+		}
+	}
+}
+	
+void CheatsThread::skipAllCodes() {
+	currentCode = codes.size();
+}
+
+int CheatsThread::getAddress(int value) {
+	// The User space base address has to be added to given value
+	return (value + 0x08800000) & 0x3FFFFFFF;
+}
+
+void CheatsThread::run() {
+	while (!exit2) {
+		codes = cheats.getCodesList(); //UI Member
+		currentCode = 0;
+		
+		while (true) {
+			string code = getNextCode();
+			vector<string>parts = makeCodeParts(code);
+			int value;
+			trim2(parts[0]);
+			trim2(parts[1]);
+			int comm = (int)parseHexLong(parts[0]);
+			int arg = (int)parseHexLong(parts[1]);
+			int addr = getAddress(comm & 0x0FFFFFFF);
+
+			switch (comm >> 28) {
+			case 0: // 8-bit write.
+				if (Memory::IsValidAddress(addr)){
+					Memory::Write_U8((u8) arg, addr);
+				}
+				break;
+			case 0x1: // 16-bit write
+				if (Memory::IsValidAddress(addr)){
+					Memory::Write_U16((u16) arg, addr);
+				}
+				break;
+			case 0x2: // 32-bit write
+				if (Memory::IsValidAddress(addr)){
+					Memory::Write_U32((u32) arg, addr);
+				}
+				break;
+			case 0x3: // Increment/Decrement
+				{
+				addr = getAddress(arg);
+				value = 0;
+				int increment = 0;
+				// Read value from memory
+				switch ((comm >> 20) & 0xF) {
+				case 1:
+				case 2: // 8-bit
+					value = Memory::Read_U8(addr);
+					increment = comm & 0xFF;
+					break;
+				case 3:
+				case 4: // 16-bit
+					value = Memory::Read_U16(addr);
+					increment = comm & 0xFFFF;
+					break;
+				case 5:
+				case 6: // 32-bit
+					value = Memory::Read_U32(addr);
+					code = getNextCode();
+					parts = makeCodeParts(code);
+					trim2(parts[0]);
+					if ( parts[0] != "") {
+						increment = (int) parseHexLong(parts[0]);
+					}
+					break;
+				}
+				// Increment/Decrement value
+				switch ((comm >> 20) & 0xF) {
+				case 1:
+				case 3:
+				case 5: // increment
+					value += increment;
+					break;
+				case 2:
+				case 4:
+				case 6: // Decrement
+					value -= increment;
+					break;
+				}
+				// Write value back to memory
+				switch ((comm >> 20) & 0xF) {
+				case 1:
+				case 2: // 8-bit
+					Memory::Write_U8((u8) value, addr);
+					break;
+				case 3:
+				case 4: // 16-bit
+					Memory::Write_U16((u16) value, addr);
+					break;
+				case 5:
+				case 6: // 32-bit
+					Memory::Write_U32((u32) value, addr);
+					break;
+				}
+				break; }
+			case 0x4: // 32-bit patch code
+				code = getNextCode();
+				parts = makeCodeParts(code);
+				trim2(parts[0]);
+				trim2(parts[1]);
+				if (parts[0] != "") {
+					int data = (int) parseHexLong(parts[0]);
+					int dataAdd = (int) parseHexLong(parts[1]);
+
+					int maxAddr = (arg >> 16) & 0xFFFF;
+					int stepAddr = (arg & 0xFFFF) * 4;
+					for (int a  = 0; a < maxAddr; a++) {
+						if (Memory::IsValidAddress(addr)) {
+							Memory::Write_U32((u32) data, addr);
+						}
+						addr += stepAddr;
+						data += dataAdd;
+					}
+				}
+				break;
+			case 0x5: // Memcpy command
+				code = getNextCode();
+				parts = makeCodeParts(code);
+				trim2(parts[0]);
+				trim2(parts[1]);
+				if (parts[0] != "") {
+					int destAddr = (int) parseHexLong(parts[0]);
+					if (Memory::IsValidAddress(addr) && Memory::IsValidAddress(destAddr)) {
+						Memory::Memcpy(destAddr, Memory::GetPointer(addr), arg);
+					}
+				}
+				break;
+			case 0x6: // Pointer commands
+				code = getNextCode();
+				parts = makeCodeParts(code);
+				trim2(parts[0]);
+				trim2(parts[1]);
+				if (parts[0] != "") {
+					int arg2 = (int) parseHexLong(parts[0]);
+					int offset = (int) parseHexLong(parts[1]);
+					int baseOffset = (arg2 >> 20) * 4;
+					int base = Memory::Read_U32(addr + baseOffset);
+					int count = arg2 & 0xFFFF;
+					int type = (arg2 >> 16) & 0xF;
+					for (int i = 1; i < count; i ++ ) {
+						if (i+1 < count) {
+							code = getNextCode();
+							parts = makeCodeParts(code);
+							trim2(parts[0]);
+							trim2(parts[1]);
+							int arg3 = (int) parseHexLong(parts[0]);
+							int arg4 = (int) parseHexLong(parts[1]);
+							int comm3 = arg3 >> 28;
+							switch (comm3) {
+							case 0x1: // type copy byte
+								{
+								int srcAddr = Memory::Read_U32(addr) + offset;
+								int dstAddr = Memory::Read_U16(addr + baseOffset) + (arg3 & 0x0FFFFFFF);
+								Memory::Memcpy(dstAddr, Memory::GetPointer(srcAddr), arg);
+								type = -1; //Done
+								break; }
+							case 0x2:
+							case 0x3: // type pointer walk
+								{
+								int walkOffset = arg3 & 0x0FFFFFFF;
+								if (comm3 == 0x3) {
+									walkOffset = -walkOffset;
+								}
+								base = Memory::Read_U32(base + walkOffset);
+								int comm4 = arg4 >> 28;
+								switch (comm4) {
+								case 0x2:
+								case 0x3: // type pointer walk
+									walkOffset = arg4 & 0x0FFFFFFF;
+									if (comm4 == 0x3) {
+										walkOffset = -walkOffset;
+									}
+									base = Memory::Read_U32(base + walkOffset);
+									break;
+								}
+								break; }
+							case 0x9: // type multi address write
+								base += arg3 & 0x0FFFFFFF;
+								arg += arg4;
+								break;
+							}
+						}
+					}
+				
+				switch (type) {
+				case 0: // 8 bit write
+					Memory::Write_U8((u8) arg, base + offset);
+					break;
+				case 1: // 16-bit write
+					Memory::Write_U16((u16) arg, base + offset);
+					break;
+				case 2: // 32-bit write
+					Memory::Write_U32((u32) arg, base + offset);
+					break;
+				case 3: // 8 bit inverse write
+					Memory::Write_U8((u8) arg, base - offset);
+					break;
+				case 4: // 16-bit inverse write
+					Memory::Write_U16((u16) arg, base - offset);
+					break;
+				case 5: // 32-bit inverse write
+					Memory::Write_U32((u32) arg, base - offset);
+					break;
+				case -1: // Operation already performed, nothing to do
+					break;
+				}
+				}
+				break;
+			case 0x7: // Boolean commands.
+				switch (arg >> 16) {
+				case 0x0000: // 8-bit OR.
+					if (Memory::IsValidAddress(addr)) {
+						int val1 = (int) (arg & 0xFF);
+						int val2 = (int) Memory::Read_U8(addr);
+						Memory::Write_U8((u8) (val1 | val2), addr);
+					}
+					break;
+				case 0x0002: // 8-bit AND.
+					if (Memory::IsValidAddress(addr)) {
+						int val1 = (int) (arg & 0xFF);
+						int val2 = (int) Memory::Read_U8(addr);
+						Memory::Write_U8((u8) (val1 & val2), addr);
+					}
+					break;
+				case 0x0004: // 8-bit XOR.
+					if (Memory::IsValidAddress(addr)) {
+						int val1 = (int) (arg & 0xFF);
+						int val2 = (int) Memory::Read_U8(addr);
+						Memory::Write_U8((u8) (val1 ^ val2), addr);
+					}
+					break;
+				case 0x0001: // 16-bit OR.
+					if (Memory::IsValidAddress(addr)) {
+						short val1 = (short) (arg & 0xFFFF);
+						short val2 = (short) Memory::Read_U16(addr);
+						Memory::Write_U16((u16) (val1 | val2), addr);
+					}
+					break;
+				case 0x0003: // 16-bit AND.
+					if (Memory::IsValidAddress(addr)) {
+						short val1 = (short) (arg & 0xFFFF);
+						short val2 = (short) Memory::Read_U16(addr);
+						Memory::Write_U16((u16) (val1 & val2), addr);
+					}
+					break;
+				case 0x0005: // 16-bit OR.
+					if (Memory::IsValidAddress(addr)) {
+						short val1 = (short) (arg & 0xFFFF);
+						short val2 = (short) Memory::Read_U16(addr);
+						Memory::Write_U16((u16) (val1 ^ val2), addr);
+					}
+					break;
+				}
+				break;
+			case 0x8: // 8-bit and 16-bit patch code
+				code = getNextCode();
+				parts = makeCodeParts(code);
+				trim2(parts[0]);
+				trim2(parts[1]);
+				if (parts[0] != "") {
+					int data = (int) parseHexLong(parts[0]);
+					int dataAdd = (int) parseHexLong(parts[1]);
+
+					bool is8Bit = (data >> 16) == 0x0000;
+					int maxAddr = (arg >> 16) & 0xFFFF;
+					int stepAddr = (arg & 0xFFFF) * (is8Bit ? 1 : 2);
+					for (int a = 0; a < maxAddr; a++) {
+						if (Memory::IsValidAddress(addr)) {
+							if (is8Bit) {
+								 Memory::Write_U8((u8) (data & 0xFF), addr);
+							}
+							else {
+								 Memory::Write_U16((u16) (data & 0xFFFF), addr);
+							}
+						}
+						addr += stepAddr;
+						data += dataAdd;
+					}
+				}
+				break;
+			case 0xB: // Time command (not sure what to do?)
+				break;
+			case 0xC: // Code stopper
+				if (Memory::IsValidAddress(addr)) { 
+					value = Memory::Read_U32(addr);
+					if (value != arg) {
+						skipAllCodes();
+					}
+				}
+				break;
+			case 0xD: // Test commands & Jocker codes ( Someone will have to help me with these)
+				break;
+			case 0xE: // Test commands, multiple skip
+				bool is8Bit = (comm >> 24) == 0x1;
+				addr = getAddress(arg & 0x0FFFFFFF);
+				if (Memory::IsValidAddress(addr)) {
+					int memoryValue = is8Bit ? Memory::Read_U8(addr) : Memory::Read_U16(addr);
+					int testValue = comm & (is8Bit ? 0xFF : 0xFFFF);
+					bool executeNextLines = false;
+					switch ( arg >> 28) {
+					case 0x0: // Equal
+						executeNextLines = memoryValue == testValue;
+						break;
+					case 0x1: // Not Equal
+						executeNextLines = memoryValue != testValue;
+						break;
+					case 0x2: // Less Than
+						executeNextLines = memoryValue < testValue;
+						break;
+					case 0x3: // Greater Than
+						executeNextLines = memoryValue > testValue;
+						break;
+					}
+					if (!executeNextLines) {
+						int skip = (comm >> 16) & (is8Bit ? 0xFF : 0xFFF);
+						skipCodes(skip);
+					}
+				}
+				break;
+				}
+				}
+				}
+				// exiting...
+				cheats.onCheatsThreadEnded();
+				}
+				
+CheatsGUI::CheatsGUI() {
+}
+
+void CheatsGUI::addCheatLine(string& line) {
+		//Need GUI text area here
+		string cheatCodes;
+		if (cheatCodes.length() <= 0) {
+			cheatCodes = line;
+		} else {
+			cheatCodes += "/n" + line;
+		}
+	}
+
+
+static long parseHexLong(string s) {
+         long value = 0;
+
+         if (s.substr(0,2) == "0x") {
+             s = s.substr(2);
+         }
+         value = strtol(s.c_str(),NULL, 16);
+         return value;
+     }
+static long parseLong(string s) {
+         long value = 0;
+         if (s.substr(0,2) == "0x") {
+			 s = s.substr(2);
+             value = strtol(s.c_str(),NULL, 16);
+         } else {
+             value = strtol(s.c_str(),NULL, 10);
+         }
+         return value;
+     }
+
+
+void trim2(string& str)
+{
+  string::size_type pos = str.find_last_not_of(' ');
+  if(pos != string::npos) {
+    str.erase(pos + 1);
+    pos = str.find_first_not_of(' ');
+    if(pos != string::npos) str.erase(0, pos);
+  }
+  else str.erase(str.begin(), str.end());
+}
+
+vector<string> makeCodeParts(string l) {
+	vector<string> parts;
+	char split_char = '/n';
+	char empty = ' ';
+	
+	for (int i=0; i < l.length(); i++) {
+		if (l[i] == empty) {
+			l[i] = '\n';
+		}
+	}
+	trim2(l);
+	istringstream iss (l);
+	for (std::string each; std::getline(iss, each, split_char);parts.push_back(each))
+	{}
+	return parts;
+}
+
+vector<string> CheatsGUI::getCodesList() {
+	string text = "0x203BFA00 0x3B9AC9FF";
+	vector<string> codes;
+	trim2(text);
+	codes = makeCodeParts(text);
+	return codes;
+}
+
+void CheatsGUI::onCheatsThreadEnded() {
+        cheatsThread = NULL;
+    }
+void CheatsGUI::dispose() {
+}
+