diff --git a/BotUI.java b/BotUI.java
new file mode 100644
index 0000000..7b170da
--- /dev/null
+++ b/BotUI.java
@@ -0,0 +1,314 @@
+package org.parabot.core.ui;
+
+import org.parabot.core.Context;
+import org.parabot.core.ui.components.GamePanel;
+import org.parabot.core.ui.components.VerboseLoader;
+import org.parabot.core.ui.images.Images;
+import org.parabot.core.ui.utils.SwingUtil;
+import org.parabot.environment.OperatingSystem;
+import org.parabot.environment.scripts.Script;
+import org.parabot.environment.scripts.randoms.Random;
+
+import javax.swing.*;
+import java.awt.*;
+import java.awt.event.*;
+import java.io.File;
+import java.util.ArrayList;
+
+/**
+ * The bot user interface
+ *
+ * @author Dane, Everel, Paradox
+ */
+public class BotUI extends JFrame implements ActionListener, ComponentListener, WindowListener {
+
+    private static final long serialVersionUID = -2126184292879805519L;
+    private static BotUI instance;
+    private static JDialog dialog;
+
+    private JMenuItem run, pause, stop, cacheClear;
+    private boolean runScript, pauseScript;
+
+    public BotUI(String username, String password) {
+        if (instance != null) {
+            throw new IllegalStateException("BotUI already created");
+        }
+        instance = this;
+        //WebLookAndFeel.install();
+        JPopupMenu.setDefaultLightWeightPopupEnabled(false);
+
+        setTitle("Parabot");
+        setResizable(false);
+        setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);
+        createMenu();
+
+        setLayout(new BorderLayout());
+        addComponentListener(this);
+        addWindowListener(this);
+
+        add(GamePanel.getInstance());
+        GamePanel.getInstance().add(VerboseLoader.get(username, password), BorderLayout.CENTER);
+        add(Logger.getInstance(), BorderLayout.SOUTH);
+
+        SwingUtil.setParabotIcons(this);
+
+        pack();
+        setLocationRelativeTo(null);
+        BotDialog.getInstance(this);
+
+        if (!OperatingSystem.getOS().equals(OperatingSystem.WINDOWS)) {
+            BotDialog.getInstance().setVisible(false);
+        }
+    }
+
+    public static BotUI getInstance() {
+        return instance;
+    }
+
+    public static boolean deleteDirectory(File directory) {
+        if (directory.exists()) {
+            File[] files = directory.listFiles();
+            if (files != null) {
+                for (int i = 0; i < files.length; i++) {
+                    if (files[i].isDirectory()) {
+                        deleteDirectory(files[i]);
+                    } else {
+                        files[i].delete();
+                    }
+                }
+            }
+        }
+        return (directory.delete());
+    }
+
+    public static void createDirectory(File directory) {
+        if (!directory.exists()) {
+            directory.mkdir();
+        }
+    }
+
+    private void createMenu() {
+        JMenuBar menuBar = new JMenuBar();
+
+        JMenu file = new JMenu("File");
+        JMenu scripts = new JMenu("Script");
+        JMenu features = new JMenu("Features");
+
+        JMenuItem screenshot = new JMenuItem("Create screenshot");
+        JMenuItem proxy = new JMenuItem("Network");
+        JMenuItem randoms = new JMenuItem("Randoms");
+        JMenuItem dialog = new JCheckBoxMenuItem("Disable dialog");
+        JMenuItem logger = new JCheckBoxMenuItem("Logger");
+
+        if (!OperatingSystem.getOS().equals(OperatingSystem.WINDOWS)) {
+            dialog.setSelected(true);
+        }
+
+        JMenuItem explorer = new JMenuItem("Reflection explorer");
+        JMenuItem exit = new JMenuItem("Exit");
+
+        run = new JMenuItem("Run");
+        run.setIcon(new ImageIcon(Images.getResource("/storage/images/run.png")));
+
+        pause = new JMenuItem("Pause");
+        pause.setEnabled(false);
+        pause.setIcon(new ImageIcon(Images.getResource("/storage/images/pause.png")));
+
+        stop = new JMenuItem("Stop");
+        stop.setEnabled(false);
+        stop.setIcon(new ImageIcon(Images.getResource("/storage/images/stop.png")));
+
+        cacheClear = new JMenuItem("Clear cache");
+        cacheClear.setIcon(new ImageIcon(Images.getResource("/storage/images/trash.png")));
+
+        screenshot.addActionListener(this);
+        proxy.addActionListener(this);
+        randoms.addActionListener(this);
+        dialog.addActionListener(this);
+        logger.addActionListener(this);
+        explorer.addActionListener(this);
+        exit.addActionListener(this);
+        cacheClear.addActionListener(this);
+
+        run.addActionListener(this);
+        pause.addActionListener(this);
+        stop.addActionListener(this);
+
+        file.add(screenshot);
+        file.add(proxy);
+        file.add(randoms);
+        file.add(dialog);
+        file.add(logger);
+        file.add(explorer);
+        file.add(exit);
+
+        scripts.add(run);
+        scripts.add(pause);
+        scripts.add(stop);
+
+        features.add(cacheClear);
+
+        menuBar.add(file);
+        menuBar.add(scripts);
+        menuBar.add(features);
+
+
+        setJMenuBar(menuBar);
+    }
+
+    @Override
+    public void actionPerformed(ActionEvent e) {
+        String command = e.getActionCommand();
+
+        switch (command) {
+            case "Create screenshot":
+                JOptionPane.showMessageDialog(this, "We are still working on this...");
+                break;
+            case "Exit":
+                System.exit(0);
+                break;
+            case "Network":
+                NetworkUI.getInstance().setVisible(true);
+                break;
+            case "Randoms":
+                ArrayList<String> randoms = new ArrayList<>();
+                for (Random r : Context.getInstance().getRandomHandler().getRandoms()) {
+                    randoms.add(r.getName());
+                }
+                RandomUI.getInstance().openFrame(randoms);
+                break;
+            case "Reflection explorer":
+                new ReflectUI().setVisible(true);
+                break;
+            case "Run":
+                if (pauseScript) {
+                    pauseScript = false;
+                    pause.setEnabled(true);
+                    run.setEnabled(false);
+                    setScriptState(Script.STATE_RUNNING);
+                    break;
+                }
+                new ScriptSelector().setVisible(true);
+                break;
+            case "Pause":
+                setScriptState(Script.STATE_PAUSE);
+                pause.setEnabled(false);
+                run.setEnabled(true);
+                pauseScript = true;
+                break;
+            case "Stop":
+                setScriptState(Script.STATE_STOPPED);
+                break;
+            case "Logger":
+                Logger.getInstance().setVisible(!Logger.getInstance().isVisible());
+                BotUI.getInstance().pack();
+                BotUI.getInstance().revalidate();
+                if (!Logger.getInstance().isClearable()) {
+                    Logger.getInstance().setClearable();
+                } else if (Logger.getInstance().isClearable() && !Logger.getInstance().isVisible()) {
+                    Logger.clearLogger();
+                    Logger.addMessage("Logger started", false);
+                }
+                break;
+            case "Disable dialog":
+                BotDialog.getInstance().setVisible(!dialog.isVisible());
+                break;
+            case "Clear cache":
+                    deleteDirectory(new File("C:/Users/Eric/Documents/Parabot/cache"));
+                    createDirectory(new File("C:/Users/Eric/Documents/Parabot/cache"));
+                break;
+            default:
+                System.out.println("Invalid command: " + command);
+        }
+    }
+
+    protected void setDialog(JDialog dialog) {
+        BotUI.dialog = dialog;
+    }
+
+    @Override
+    public void componentMoved(ComponentEvent e) {
+        if (dialog == null || !isVisible()) {
+            return;
+        }
+        Point gameLocation = GamePanel.getInstance().getLocationOnScreen();
+        dialog.setLocation(gameLocation.x, gameLocation.y);
+    }
+
+    public void toggleRun() {
+        runScript = !runScript;
+        if (runScript) {
+            scriptRunning();
+        } else {
+            scriptStopped();
+        }
+    }
+
+    private void scriptRunning() {
+        run.setEnabled(false);
+        pause.setEnabled(true);
+        stop.setEnabled(true);
+    }
+
+    private void scriptStopped() {
+        run.setEnabled(true);
+        pause.setEnabled(false);
+        stop.setEnabled(false);
+    }
+
+    private void setScriptState(int state) {
+        if (Context.getInstance().getRunningScript() != null) {
+            Context.getInstance().getRunningScript().setState(state);
+        }
+    }
+
+    @Override
+    public void componentResized(ComponentEvent e) {
+        if (isVisible()) {
+            BotDialog.getInstance().setSize(getSize());
+        }
+    }
+
+    @Override
+    public void componentShown(ComponentEvent e) {
+    }
+
+    @Override
+    public void componentHidden(ComponentEvent e) {
+    }
+
+    @Override
+    public void windowActivated(WindowEvent arg0) {
+    }
+
+    @Override
+    public void windowClosed(WindowEvent arg0) {
+    }
+
+    @Override
+    public void windowClosing(WindowEvent e) {
+    }
+
+    @Override
+    public void windowDeactivated(WindowEvent arg0) {
+
+    }
+
+    @Override
+    public void windowDeiconified(WindowEvent arg0) {
+        if (isVisible()) {
+            BotDialog.getInstance().setVisible(false);
+            BotDialog.getInstance().setVisible(true);
+        }
+    }
+
+    @Override
+    public void windowIconified(WindowEvent arg0) {
+
+    }
+
+    @Override
+    public void windowOpened(WindowEvent arg0) {
+    }
+
+}
diff --git a/Context.java b/Context.java
new file mode 100644
index 0000000..532955c
--- /dev/null
+++ b/Context.java
@@ -0,0 +1,372 @@
+package org.parabot.core;
+
+import org.json.simple.parser.JSONParser;
+import org.parabot.core.asm.ASMClassLoader;
+import org.parabot.core.classpath.ClassPath;
+import org.parabot.core.desc.ServerProviderInfo;
+import org.parabot.core.paint.PaintDebugger;
+import org.parabot.core.parsers.hooks.HookParser;
+import org.parabot.core.ui.BotDialog;
+import org.parabot.core.ui.BotUI;
+import org.parabot.core.ui.components.GamePanel;
+import org.parabot.environment.api.interfaces.Paintable;
+import org.parabot.environment.input.Keyboard;
+import org.parabot.environment.input.Mouse;
+import org.parabot.environment.scripts.Script;
+import org.parabot.environment.scripts.randoms.RandomHandler;
+import org.parabot.environment.scripts.uliratha.UlirathaClient;
+import org.parabot.environment.servers.ServerProvider;
+
+import java.applet.Applet;
+import java.awt.*;
+import java.io.File;
+import java.io.PrintStream;
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.TimerTask;
+
+/**
+ * Game context
+ *
+ * @author Everel, JKetelaar, Matt
+ */
+public class Context {
+    public static final HashMap<ThreadGroup, Context> threadGroups = new HashMap<ThreadGroup, Context>();
+    private static ArrayList<Paintable> paintables = new ArrayList<Paintable>();
+    
+    private static Context instance;
+    private static String username;
+
+    private ASMClassLoader classLoader;
+    private ClassPath classPath;
+    private ServerProvider serverProvider;
+    private Applet gameApplet;
+    private HookParser hookParser;
+    private Script runningScript;
+    private RandomHandler randomHandler;
+    private Object clientInstance;
+    private PaintDebugger paintDebugger;
+    private Mouse mouse;
+    private Keyboard keyboard;
+    private ServerProviderInfo providerInfo;
+    private UlirathaClient ulirathaClient;
+    private JSONParser jsonParser;
+
+    private PrintStream defaultOut;
+    private PrintStream defaultErr = System.err;
+
+    private Context(final ServerProvider serverProvider) {
+        threadGroups.put(Thread.currentThread().getThreadGroup(), this);
+        
+        System.setProperty("sun.java.command", "");
+        this.serverProvider = serverProvider;
+        this.paintDebugger = new PaintDebugger();
+        this.classPath = new ClassPath();
+        this.classLoader = new ASMClassLoader(classPath);
+        this.randomHandler = new RandomHandler();
+
+        this.jsonParser = new JSONParser();
+
+        this.defaultOut = System.out;
+        this.defaultErr = System.err;
+    }
+
+    public static Context getInstance(ServerProvider serverProvider) {
+        return instance == null ? instance = new Context(serverProvider) : instance;
+    }
+    
+    public static Context getInstance() {
+    	return getInstance(null);
+    }
+
+    /**
+     * Sets the main client instance
+     */
+    public void setClientInstance(Object object) {
+        this.clientInstance = object;
+    }
+
+    /**
+     * Sets the hook parser
+     *
+     * @param hookParser
+     */
+    public void setHookParser(final HookParser hookParser) {
+        this.hookParser = hookParser;
+    }
+
+    /**
+     * Sets the mouse
+     *
+     * @param mouse
+     */
+    public void setMouse(final Mouse mouse) {
+        this.mouse = mouse;
+    }
+
+    /**
+     * Gets the mouse
+     *
+     * @return mouse
+     */
+    public Mouse getMouse() {
+        return mouse;
+    }
+
+
+    /**
+     * Sets the keyboard
+     *
+     * @param keyboard
+     */
+    public void setKeyboard(final Keyboard keyboard) {
+        this.keyboard = keyboard;
+    }
+
+    /**
+     * Gets the keyboard
+     *
+     * @return keyboard
+     */
+    public Keyboard getKeyboard() {
+        return keyboard;
+    }
+
+    /**
+     * ClassPath
+     *
+     * @return classpath
+     */
+    public ClassPath getClassPath() {
+        return classPath;
+    }
+
+    /**
+     * Determines if applet has been set
+     *
+     * @return <b>true</b> if set
+     */
+    public boolean appletSet() {
+        return gameApplet != null;
+    }
+
+    /**
+     * Gets game applet
+     *
+     * @return applet
+     */
+    public Applet getApplet() {
+        return gameApplet;
+    }
+
+    /**
+     * Loads the game
+     */
+    public void load() {
+        BotUI.getInstance().getJMenuBar().remove(2);
+        Core.verbose("Parsing server jar...");
+        serverProvider.init();
+        serverProvider.parseJar();
+        Core.verbose("Done.");
+        Core.verbose("Injecting hooks...");
+        serverProvider.injectHooks();
+        Core.verbose("Done.");
+        Core.verbose("Fetching game applet...");
+        if(Core.shouldDump()) {
+        	Core.verbose("Dumping injected client...");
+        	classPath.dump(new File(Directories.getWorkspace(), "dump.jar"));
+        	Core.verbose("Done.");
+        }
+        Applet applet = serverProvider.fetchApplet();
+        // if applet is null the server provider will call setApplet itself
+        if(applet != null) {
+            setApplet(applet);
+        }
+    }
+    
+    /**
+     * Sets the bot target applet
+     * @param applet
+     */
+    public void setApplet(final Applet applet) {
+    	gameApplet = applet;
+    	
+    	if (getClient() == null) {
+            setClientInstance(gameApplet);
+        }
+
+        Core.verbose("Applet fetched.");
+        
+        final GamePanel panel = GamePanel.getInstance();
+        final Dimension appletSize = serverProvider.getGameDimensions();
+        
+        panel.setPreferredSize(appletSize);
+        serverProvider.addMenuItems(BotUI.getInstance().getJMenuBar());
+        BotUI.getInstance().pack();
+        BotUI.getInstance().validate();
+        
+        panel.removeComponents();
+        gameApplet.setSize(appletSize);
+        panel.add(gameApplet);
+        panel.validate();
+
+        gameApplet.init();
+        gameApplet.start();
+
+        java.util.Timer t = new java.util.Timer();
+        t.schedule(new TimerTask() {
+            @Override
+            public void run() {
+                gameApplet.setBounds(0, 0, appletSize.width, appletSize.height);
+            }
+        }, 1000);
+        
+        Core.verbose("Initializing mouse...");
+        serverProvider.initMouse();
+        Core.verbose("Done.");
+        Core.verbose("Initializing keyboard...");
+        serverProvider.initKeyboard();
+        Core.verbose("Done.");
+        
+        BotDialog.getInstance().validate();
+        System.setOut(this.defaultOut);
+        System.setErr(this.defaultErr);
+    }
+
+    /**
+     * Gets the server prodiver belonging to this context
+     *
+     * @return server provider
+     */
+    public ServerProvider getServerProvider() {
+        return serverProvider;
+    }
+    
+    /**
+     * 
+     * Sets provider info of this context
+     * 
+     * @param providerInfo
+     */
+    public void setProviderInfo(ServerProviderInfo providerInfo) {
+    	this.providerInfo = providerInfo;
+    }
+    
+    /**
+     * Gets ServerProvider info
+     * Can be null if this is not a public server provider
+     * @return info about this provider
+     */
+    public ServerProviderInfo getServerProviderInfo() {
+    	return this.providerInfo;
+    }
+
+    /**
+     * Gets class loader of server from this context
+     *
+     * @return class loader
+     */
+    public ASMClassLoader getASMClassLoader() {
+        return classLoader;
+    }
+
+    /**
+     * Adds a paintable instance to the paintables
+     *
+     * @param paintable
+     */
+    public void addPaintable(Paintable paintable) {
+        paintables.add(paintable);
+    }
+
+    /**
+     * Removes a paintable instance from the paintables
+     *
+     * @param paintable
+     */
+    public void removePaintable(Paintable paintable) {
+        paintables.remove(paintable);
+    }
+
+    /**
+     * Gets the paintable instances
+     *
+     * @return array of paintable instances
+     */
+    public Paintable[] getPaintables() {
+        return paintables.toArray(new Paintable[paintables.size()]);
+    }
+
+    /**
+     * The client debug painter
+     *
+     * @return debug painter
+     */
+    public PaintDebugger getPaintDebugger() {
+        return paintDebugger;
+    }
+
+    /**
+     * Gets the main/client instance
+     *
+     * @return instance of the the client
+     */
+    public Object getClient() {
+        return this.clientInstance;
+    }
+
+    /**
+     * Gets the hook parser, may be null if injection is not used or a custom hook parser is used for injecting
+     *
+     * @return hook parser
+     */
+    public HookParser getHookParser() {
+        return hookParser;
+    }
+
+    /**
+     * Sets the current running script, if a script stops it will call this method with a null argument
+     *
+     * @param script
+     */
+    public void setRunningScript(final Script script) {
+        this.runningScript = script;
+    }
+
+    /**
+     * Gets the current running script
+     *
+     * @return script
+     */
+    public Script getRunningScript() {
+        return this.runningScript;
+    }
+    
+    /**
+     * Gets the random handler
+     * @return random handler
+     */
+    public RandomHandler getRandomHandler() {
+    	return this.randomHandler;
+    }
+
+    public static String getUsername() {
+        return username;
+    }
+
+    public UlirathaClient getUlirathaClient() {
+        return ulirathaClient;
+    }
+
+    public void setUlirathaClient(UlirathaClient ulirathaClient) {
+        this.ulirathaClient = ulirathaClient;
+    }
+
+    public static void setUsername(String username) {
+        Context.username = username;
+    }
+
+    public JSONParser getJsonParser() {
+        return jsonParser;
+    }
+}
diff --git a/trash.png b/trash.png
new file mode 100644
index 0000000..53867b6
Binary files /dev/null and b/trash.png differ