diff --git a/core/src/com/riiablo/Client.java b/core/src/com/riiablo/Client.java
index 2470a262..fe208fe5 100644
--- a/core/src/com/riiablo/Client.java
+++ b/core/src/com/riiablo/Client.java
@@ -449,6 +449,8 @@ public class Client extends Game {
         .append(Gdx.graphics.getFramesPerSecond())
         .append('\n').append("Ping: ").append(Riiablo.metrics.ping).append(" ms")
         .append('\n').append("RTT: ").append(Riiablo.metrics.rtt).append(" ms")
+        .append('\n').append(String.format("CPU: %.1f ms", Riiablo.metrics.cpu))
+        .append('\n').append(String.format("GPU: %.1f ms", Riiablo.metrics.gpu))
         ;
     fps.setText(font, builder.toString());
     int drawFpsMethod = this.drawFpsMethod;
diff --git a/core/src/com/riiablo/Metrics.java b/core/src/com/riiablo/Metrics.java
index 9703b0f8..aa77a9e8 100644
--- a/core/src/com/riiablo/Metrics.java
+++ b/core/src/com/riiablo/Metrics.java
@@ -1,6 +1,8 @@
 package com.riiablo;
 
 public class Metrics {
+  public float cpu;
+  public float gpu;
   public long ping;
   public long rtt;
 
diff --git a/core/src/com/riiablo/engine/client/LabelManager.java b/core/src/com/riiablo/engine/client/LabelManager.java
index 84375f04..e96a894c 100644
--- a/core/src/com/riiablo/engine/client/LabelManager.java
+++ b/core/src/com/riiablo/engine/client/LabelManager.java
@@ -4,18 +4,22 @@ import com.artemis.ComponentMapper;
 import com.artemis.annotations.All;
 import com.artemis.annotations.Wire;
 import com.artemis.systems.IteratingSystem;
+
 import com.badlogic.gdx.math.MathUtils;
 import com.badlogic.gdx.math.Vector2;
 import com.badlogic.gdx.scenes.scene2d.Actor;
 import com.badlogic.gdx.utils.Align;
 import com.badlogic.gdx.utils.Array;
+
 import com.riiablo.Riiablo;
 import com.riiablo.camera.IsometricCamera;
 import com.riiablo.engine.client.component.Hovered;
 import com.riiablo.engine.client.component.Label;
 import com.riiablo.engine.server.component.Position;
 import com.riiablo.map.RenderSystem;
+import com.riiablo.profiler.GpuSystem;
 
+@GpuSystem
 @All({Hovered.class, Label.class, Position.class})
 public class LabelManager extends IteratingSystem {
   protected ComponentMapper<Label> mLabel;
diff --git a/core/src/com/riiablo/engine/client/MonsterLabelManager.java b/core/src/com/riiablo/engine/client/MonsterLabelManager.java
index f87a1ccd..7730e4d6 100644
--- a/core/src/com/riiablo/engine/client/MonsterLabelManager.java
+++ b/core/src/com/riiablo/engine/client/MonsterLabelManager.java
@@ -6,10 +6,12 @@ import com.artemis.annotations.All;
 import com.artemis.annotations.Exclude;
 import com.artemis.annotations.Wire;
 import com.artemis.utils.IntBag;
+
 import com.badlogic.gdx.Gdx;
 import com.badlogic.gdx.math.Vector2;
 import com.badlogic.gdx.scenes.scene2d.ui.Table;
 import com.badlogic.gdx.utils.Align;
+
 import com.riiablo.Riiablo;
 import com.riiablo.camera.IsometricCamera;
 import com.riiablo.codec.excel.MonStats;
@@ -18,8 +20,10 @@ import com.riiablo.engine.server.component.Monster;
 import com.riiablo.engine.server.component.Position;
 import com.riiablo.graphics.PaletteIndexedBatch;
 import com.riiablo.graphics.PaletteIndexedColorDrawable;
+import com.riiablo.profiler.GpuSystem;
 import com.riiablo.widget.Label;
 
+@GpuSystem
 @All({Monster.class, Hovered.class, Position.class})
 @Exclude(com.riiablo.engine.client.component.Label.class)
 public class MonsterLabelManager extends BaseEntitySystem {
diff --git a/core/src/com/riiablo/engine/client/debug/Box2DDebugger.java b/core/src/com/riiablo/engine/client/debug/Box2DDebugger.java
index 972aaf9c..6424a51a 100644
--- a/core/src/com/riiablo/engine/client/debug/Box2DDebugger.java
+++ b/core/src/com/riiablo/engine/client/debug/Box2DDebugger.java
@@ -2,13 +2,17 @@ package com.riiablo.engine.client.debug;
 
 import com.artemis.BaseSystem;
 import com.artemis.annotations.Wire;
+
 import com.badlogic.gdx.graphics.OrthographicCamera;
 import com.badlogic.gdx.math.Vector3;
 import com.badlogic.gdx.physics.box2d.Box2DDebugRenderer;
+
 import com.riiablo.camera.IsometricCamera;
 import com.riiablo.map.Box2DPhysics;
 import com.riiablo.map.RenderSystem;
+import com.riiablo.profiler.GpuSystem;
 
+@GpuSystem
 public class Box2DDebugger extends BaseSystem {
   private static final float BOX2D_ZOOM_FACTOR = 0.04419419f;
 
diff --git a/core/src/com/riiablo/engine/client/debug/PathDebugger.java b/core/src/com/riiablo/engine/client/debug/PathDebugger.java
index 7be64bdc..54a44a34 100644
--- a/core/src/com/riiablo/engine/client/debug/PathDebugger.java
+++ b/core/src/com/riiablo/engine/client/debug/PathDebugger.java
@@ -4,10 +4,12 @@ import com.artemis.ComponentMapper;
 import com.artemis.annotations.All;
 import com.artemis.annotations.Wire;
 import com.artemis.systems.IteratingSystem;
+
 import com.badlogic.gdx.graphics.Color;
 import com.badlogic.gdx.graphics.glutils.ShapeRenderer;
 import com.badlogic.gdx.math.Vector2;
 import com.badlogic.gdx.utils.Align;
+
 import com.riiablo.Riiablo;
 import com.riiablo.camera.IsometricCamera;
 import com.riiablo.engine.server.component.PathWrapper;
@@ -15,7 +17,9 @@ import com.riiablo.engine.server.component.Position;
 import com.riiablo.graphics.PaletteIndexedBatch;
 import com.riiablo.map.DS1;
 import com.riiablo.map.RenderSystem;
+import com.riiablo.profiler.GpuSystem;
 
+@GpuSystem
 @All({PathWrapper.class, Position.class})
 public class PathDebugger extends IteratingSystem {
   private final float BOX_SIZE = 8;
diff --git a/core/src/com/riiablo/engine/client/debug/PathfindDebugger.java b/core/src/com/riiablo/engine/client/debug/PathfindDebugger.java
index de71d73b..0f8cad5c 100644
--- a/core/src/com/riiablo/engine/client/debug/PathfindDebugger.java
+++ b/core/src/com/riiablo/engine/client/debug/PathfindDebugger.java
@@ -4,10 +4,12 @@ import com.artemis.ComponentMapper;
 import com.artemis.annotations.All;
 import com.artemis.annotations.Wire;
 import com.artemis.systems.IteratingSystem;
+
 import com.badlogic.gdx.graphics.Color;
 import com.badlogic.gdx.graphics.glutils.ShapeRenderer;
 import com.badlogic.gdx.math.Vector2;
 import com.badlogic.gdx.utils.Align;
+
 import com.riiablo.Riiablo;
 import com.riiablo.camera.IsometricCamera;
 import com.riiablo.engine.server.component.Pathfind;
@@ -16,7 +18,9 @@ import com.riiablo.graphics.PaletteIndexedBatch;
 import com.riiablo.map.RenderSystem;
 import com.riiablo.map.pfa.GraphPath;
 import com.riiablo.map.pfa.Point2;
+import com.riiablo.profiler.GpuSystem;
 
+@GpuSystem
 @All({Pathfind.class, Position.class})
 public class PathfindDebugger extends IteratingSystem {
   private final float BOX_SIZE = 8;
diff --git a/core/src/com/riiablo/engine/client/debug/RenderSystemDebugger.java b/core/src/com/riiablo/engine/client/debug/RenderSystemDebugger.java
index 87b85a61..55b38184 100644
--- a/core/src/com/riiablo/engine/client/debug/RenderSystemDebugger.java
+++ b/core/src/com/riiablo/engine/client/debug/RenderSystemDebugger.java
@@ -2,10 +2,14 @@ package com.riiablo.engine.client.debug;
 
 import com.artemis.BaseSystem;
 import com.artemis.annotations.Wire;
+
 import com.badlogic.gdx.graphics.glutils.ShapeRenderer;
+
 import com.riiablo.camera.IsometricCamera;
 import com.riiablo.map.RenderSystem;
+import com.riiablo.profiler.GpuSystem;
 
+@GpuSystem
 public class RenderSystemDebugger extends BaseSystem {
   protected RenderSystem renderer;
 
diff --git a/core/src/com/riiablo/map/RenderSystem.java b/core/src/com/riiablo/map/RenderSystem.java
index 01b69896..cc221ace 100644
--- a/core/src/com/riiablo/map/RenderSystem.java
+++ b/core/src/com/riiablo/map/RenderSystem.java
@@ -1,11 +1,16 @@
 package com.riiablo.map;
 
+import java.util.Arrays;
+import java.util.Comparator;
+import org.apache.commons.lang3.StringUtils;
+
 import com.artemis.Aspect;
 import com.artemis.BaseEntitySystem;
 import com.artemis.ComponentMapper;
 import com.artemis.EntitySubscription;
 import com.artemis.annotations.All;
 import com.artemis.utils.IntBag;
+
 import com.badlogic.gdx.Gdx;
 import com.badlogic.gdx.graphics.Color;
 import com.badlogic.gdx.graphics.Texture;
@@ -20,6 +25,7 @@ import com.badlogic.gdx.utils.Align;
 import com.badlogic.gdx.utils.Array;
 import com.badlogic.gdx.utils.Bits;
 import com.badlogic.gdx.utils.Pools;
+
 import com.riiablo.Riiablo;
 import com.riiablo.camera.IsometricCamera;
 import com.riiablo.codec.Animation;
@@ -41,13 +47,10 @@ import com.riiablo.engine.server.component.Position;
 import com.riiablo.graphics.BlendMode;
 import com.riiablo.graphics.PaletteIndexedBatch;
 import com.riiablo.map.DT1.Tile;
+import com.riiablo.profiler.GpuSystem;
 import com.riiablo.util.DebugUtils;
 
-import org.apache.commons.lang3.StringUtils;
-
-import java.util.Arrays;
-import java.util.Comparator;
-
+@GpuSystem
 @All(AnimationWrapper.class)
 public class RenderSystem extends BaseEntitySystem {
   private static final String TAG = "RenderSystem";
diff --git a/core/src/com/riiablo/profiler/GpuSystem.java b/core/src/com/riiablo/profiler/GpuSystem.java
new file mode 100644
index 00000000..31cd89d6
--- /dev/null
+++ b/core/src/com/riiablo/profiler/GpuSystem.java
@@ -0,0 +1,10 @@
+package com.riiablo.profiler;
+
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+@Target(ElementType.TYPE)
+@Retention(RetentionPolicy.RUNTIME)
+public @interface GpuSystem {}
diff --git a/core/src/com/riiablo/profiler/ProfilerInvocationStrategy.java b/core/src/com/riiablo/profiler/ProfilerInvocationStrategy.java
new file mode 100644
index 00000000..38c277c4
--- /dev/null
+++ b/core/src/com/riiablo/profiler/ProfilerInvocationStrategy.java
@@ -0,0 +1,83 @@
+package com.riiablo.profiler;
+
+import com.artemis.BaseSystem;
+import com.artemis.SystemInvocationStrategy;
+import com.artemis.utils.Bag;
+import com.artemis.utils.ImmutableBag;
+
+/**
+ * {@link SystemInvocationStrategy} that will create a profiler for all systems that don't already
+ * have one Can be used in addition to or instead of {@link com.artemis.annotations.Profile}
+ * annotation
+ * <p>
+ * In addition creates {@link SystemProfiler} with name "Frame" for total frame time It can be
+ * accessed with {@link SystemProfiler#get(String)}
+ *
+ * @author piotr-j
+ * @author Daan van Yperen
+ */
+public class ProfilerInvocationStrategy extends SystemInvocationStrategy {
+  private boolean initialized = false;
+
+  protected SystemProfiler frameProfiler;
+  protected SystemProfiler[] profilers;
+
+  @Override
+  protected void process() {
+
+    if (!initialized) {
+      initialize();
+      initialized = true;
+    }
+
+    frameProfiler.start();
+    processProfileSystems(systems);
+    frameProfiler.stop();
+  }
+
+  private void processProfileSystems(Bag<BaseSystem> systems) {
+    final Object[] systemsData = systems.getData();
+    for (int i = 0, s = systems.size(); s > i; i++) {
+      if (disabled.get(i))
+        continue;
+
+      updateEntityStates();
+      processProfileSystem(profilers[i], (BaseSystem) systemsData[i]);
+    }
+
+    updateEntityStates();
+  }
+
+  private void processProfileSystem(SystemProfiler profiler, BaseSystem system) {
+    if (profiler != null) profiler.start();
+    system.process();
+    if (profiler != null) profiler.stop();
+  }
+
+  @Override
+  protected void initialize() {
+    createFrameProfiler();
+    createSystemProfilers();
+  }
+
+  private void createSystemProfilers() {
+    final ImmutableBag<BaseSystem> systems = world.getSystems();
+    profilers = new SystemProfiler[systems.size()];
+    for (int i = 0; i < systems.size(); i++) {
+      profilers[i] = createSystemProfiler(systems.get(i));
+    }
+  }
+
+  private SystemProfiler createSystemProfiler(BaseSystem system) {
+    SystemProfiler old = SystemProfiler.getFor(system);
+    if (old == null) {
+      old = SystemProfiler.createFor(system, world);
+    }
+    return old;
+  }
+
+  private void createFrameProfiler() {
+    frameProfiler = SystemProfiler.create("Frame");
+    frameProfiler.setColor(1, 1, 1, 1);
+  }
+}
diff --git a/core/src/com/riiablo/profiler/ProfilerPlugin.java b/core/src/com/riiablo/profiler/ProfilerPlugin.java
new file mode 100644
index 00000000..f998edda
--- /dev/null
+++ b/core/src/com/riiablo/profiler/ProfilerPlugin.java
@@ -0,0 +1,26 @@
+package com.riiablo.profiler;
+
+import com.artemis.ArtemisPlugin;
+import com.artemis.WorldConfigurationBuilder;
+
+/**
+ * Artemis system profiler.
+ *
+ * Tracks performance of artemis systems and displays it in a line graph. Overhead is insignificant
+ * while closed.
+ *
+ * Does not require {@see @com.artemis.annotations.Profile} on systems.
+ *
+ * Open/Close with P by default.
+ *
+ * @author piotr-j (Plugin)
+ * @author Daan van Yperen (Integration)
+ */
+public class ProfilerPlugin implements ArtemisPlugin {
+
+  @Override
+  public void setup(WorldConfigurationBuilder b) {
+    b.register(new ProfilerInvocationStrategy());
+    b.dependsOn(WorldConfigurationBuilder.Priority.LOWEST + 1000, ProfilerSystem.class);
+  }
+}
diff --git a/core/src/com/riiablo/profiler/ProfilerSystem.java b/core/src/com/riiablo/profiler/ProfilerSystem.java
new file mode 100644
index 00000000..50c4dd71
--- /dev/null
+++ b/core/src/com/riiablo/profiler/ProfilerSystem.java
@@ -0,0 +1,145 @@
+package com.riiablo.profiler;
+
+import com.artemis.BaseSystem;
+import com.artemis.annotations.Wire;
+
+import com.badlogic.gdx.Gdx;
+import com.badlogic.gdx.Input;
+import com.badlogic.gdx.graphics.Color;
+import com.badlogic.gdx.graphics.OrthographicCamera;
+import com.badlogic.gdx.graphics.glutils.ShapeRenderer;
+import com.badlogic.gdx.scenes.scene2d.Stage;
+import com.badlogic.gdx.scenes.scene2d.ui.Skin;
+
+import com.riiablo.Riiablo;
+
+/**
+ * Example profiling system.
+ *
+ * @author piotr-j
+ * @author Daan van Yperen
+ * @see ProfilerPlugin
+ */
+@Wire
+public class ProfilerSystem extends BaseSystem {
+
+  public static final int DEFAULT_PROFILER_KEY = Input.Keys.P;
+
+  OrthographicCamera camera;
+  ShapeRenderer renderer;
+  Stage stage;
+  Skin skin;
+
+  private int key = DEFAULT_PROFILER_KEY;
+
+  SystemProfilerGUI gui;
+  private boolean f3ButtonDown;
+
+  @Override
+  protected void initialize() {
+    camera = new OrthographicCamera(Gdx.graphics.getWidth(), Gdx.graphics.getHeight());
+    camera.setToOrtho(false);
+    camera.update();
+    renderer = new ShapeRenderer();
+    stage = new Stage();
+    stage.getBatch().setProjectionMatrix(camera.combined);
+    skin = new Skin(Gdx.files.classpath("net/mostlyoriginal/plugin/profiler/skin/uiskin.json"));
+
+    // setup some static config like colors etc
+    SystemProfilerGUI.GRAPH_H_LINE.set(Color.ORANGE);
+    gui = new SystemProfilerGUI(skin, "default");
+    gui.setResizeBorder(8);
+    gui.show(stage);
+    gui.setWidth(Gdx.graphics.getWidth());
+  }
+
+  @Override
+  protected void processSystem() {
+    Riiablo.metrics.cpu = 0;
+    Riiablo.metrics.gpu = 0;
+    if (!isEnabled() || !isConfigured()) {
+      return;
+    }
+
+    final SystemProfiler[] profilers = SystemProfiler.get().items;
+    for (int i = 0, s = SystemProfiler.size(); i < s; i++) {
+      SystemProfiler profiler = profilers[i];
+      if (profiler.system == null || !profiler.system.isEnabled()) continue;
+      if (profiler.gpu) {
+        Riiablo.metrics.gpu += profiler.getMovingAvg();
+      } else {
+        Riiablo.metrics.cpu += profiler.getMovingAvg();
+      }
+    }
+
+    checkActivationButton();
+
+    if (gui.isVisible()) {
+      processInput();
+      render();
+    }
+  }
+
+  private boolean isConfigured() {
+    return gui.getParent() != null;
+  }
+
+  private void render() {
+    stage.act(world.delta);
+    stage.draw();
+    renderer.setProjectionMatrix(camera.combined);
+    renderer.begin(ShapeRenderer.ShapeType.Line);
+    gui.updateAndRender(world.delta, renderer);
+    renderer.end();
+  }
+
+  private void checkActivationButton() {
+    if (Gdx.input.isKeyPressed(key)) {
+      if (!f3ButtonDown) {
+        if (!gui.isVisible()) {
+          gui.setHeight(Gdx.graphics.getHeight() / 2);
+          gui.setVisible(true);
+          SystemProfiler.getFor(this).gpu = true;
+        } else if (gui.getHeight() != Gdx.graphics.getHeight()) {
+          gui.setHeight(Gdx.graphics.getHeight());
+        } else {
+          gui.setVisible(false);
+          SystemProfiler.getFor(this).gpu = false;
+        }
+      }
+      f3ButtonDown = true;
+    } else f3ButtonDown = false;
+  }
+
+  private boolean leftMouseDown;
+
+  /**
+   * Emulate stage input to maintain pre-existing input processor.
+   */
+  private void processInput() {
+    if (Gdx.input.isButtonPressed(Input.Buttons.LEFT)) {
+      if (!leftMouseDown) {
+        leftMouseDown = true;
+        stage.touchDown(Gdx.input.getX(), Gdx.input.getY(), 0, Input.Buttons.LEFT);
+      } else {
+        stage.touchDragged(Gdx.input.getX(), Gdx.input.getY(), 0);
+      }
+    } else if (leftMouseDown) {
+      leftMouseDown = false;
+      stage.touchUp(Gdx.input.getX(), Gdx.input.getY(), 0, Input.Buttons.LEFT);
+    }
+  }
+
+  @Override
+  protected void dispose() {
+    SystemProfiler.dispose();
+  }
+
+  public int getKey() {
+    return key;
+  }
+
+  public void setKey(int key) {
+    this.key = key;
+  }
+}
diff --git a/core/src/com/riiablo/profiler/SystemProfiler.java b/core/src/com/riiablo/profiler/SystemProfiler.java
new file mode 100644
index 00000000..0900cce4
--- /dev/null
+++ b/core/src/com/riiablo/profiler/SystemProfiler.java
@@ -0,0 +1,374 @@
+package com.riiablo.profiler;
+
+import com.artemis.BaseSystem;
+import com.artemis.World;
+import com.artemis.utils.ArtemisProfiler;
+
+import com.badlogic.gdx.graphics.Color;
+import com.badlogic.gdx.utils.Array;
+import com.badlogic.gdx.utils.ObjectMap;
+import com.badlogic.gdx.utils.TimeUtils;
+
+import com.riiablo.util.ClassUtils;
+
+/**
+ * {@link ArtemisProfiler} implementation, {@link SystemProfiler#dispose()} should be called to
+ * clean static references as needed
+ *
+ * @author piotr-j
+ */
+public class SystemProfiler implements ArtemisProfiler {
+  /**
+   * Samples to store per system, only changes before initialization have effect
+   */
+  public static int SAMPLES = 60 * 5;
+  private static boolean RUNNING = true;
+
+  private static Array<SystemProfiler> profilers = new Array<>(SystemProfiler.class);
+  private static ObjectMap<String, SystemProfiler> profilerByName = new ObjectMap<>();
+
+  /**
+   * Add manually created profiler
+   *
+   * @param profiler to add
+   *
+   * @return added profiler
+   */
+  public static SystemProfiler add(SystemProfiler profiler) {
+    if (profiler.added) return profiler;
+    profiler.added = true;
+    profilers.add(profiler);
+    profilerByName.put(profiler.getName(), profiler);
+    return profiler;
+  }
+
+  /**
+   * @param name of the profiler
+   *
+   * @return profiler registered with given name or null
+   */
+  public static SystemProfiler get(String name) {
+    return profilerByName.get(name, null);
+  }
+
+  /**
+   * @param index of profiler to get, no bounds check!
+   *
+   * @return profiler with given index
+   */
+  public static SystemProfiler get(int index) {
+    return profilers.get(index);
+  }
+
+  /**
+   * Get profiler for given system
+   *
+   * @return profiler or null
+   */
+  public static SystemProfiler getFor(BaseSystem system) {
+    Object[] items = profilers.items;
+    for (int i = 0; i < profilers.size; i++) {
+      SystemProfiler profiler = (SystemProfiler) items[i];
+      if (profiler.system == system) {
+        return profiler;
+      }
+    }
+    return null;
+  }
+
+  /**
+   * Create a profiler with given name
+   *
+   * @param name of the profiler
+   */
+  public static SystemProfiler create(String name) {
+    return SystemProfiler.add(new SystemProfiler(name));
+  }
+
+  /**
+   * Create a profiler for given system
+   *
+   * @param system to profiler
+   * @param world  to init profiler with
+   *
+   * @return created profiler
+   */
+  public static SystemProfiler createFor(BaseSystem system, World world) {
+    return SystemProfiler.add(new SystemProfiler(system, world));
+  }
+
+  /**
+   * @return {@link Array} with all registered profilers
+   */
+  public static Array<SystemProfiler> get() {
+    return profilers;
+  }
+
+  /**
+   * @return number of registered profilers
+   */
+  public static int size() {
+    return profilers.size;
+  }
+
+
+  /**
+   * Pause all profilers
+   */
+  public static void pause() {
+    RUNNING = false;
+  }
+
+  /**
+   * Resume all profilers
+   */
+  public static void resume() {
+    RUNNING = true;
+  }
+
+  /**
+   * @return if profilers are running
+   */
+  public static boolean isRunning() {
+    return RUNNING;
+  }
+
+  /**
+   * Clear registered profilers, should be called when {@link World} is disposed
+   */
+  public static void dispose() {
+    profilers.clear();
+    profilerByName.clear();
+  }
+
+  /*
+      If this profiler was already added via SystemProfiler.add()
+   */
+  private boolean added;
+
+  protected long[] times = new long[SAMPLES];
+  protected int index;
+  protected long max;
+  protected int lastMaxCounter;
+  protected long localMax;
+  protected long localMaxIndex;
+  protected int samples;
+
+  protected long total;
+
+  protected Color color;
+  protected String name;
+  protected BaseSystem system;
+  protected boolean gpu;
+
+  public SystemProfiler() {}
+
+  /**
+   * Create not initialized profiler, must be initialized with {@link
+   * SystemProfiler#initialize(BaseSystem, World)}
+   *
+   * @param name of the profiler
+   */
+  public SystemProfiler(String name) {
+    this.name = name;
+  }
+
+  /**
+   * Create profiler with default name and initialize it
+   *
+   * @param system to profiler
+   * @param world  to init with
+   */
+  public SystemProfiler(BaseSystem system, World world) {
+    this(null, system, world);
+  }
+
+  /**
+   * Create profiler with specified name and initialize it
+   *
+   * @param name   of the profiler
+   * @param system to profiler
+   * @param world  to init with
+   */
+  public SystemProfiler(String name, BaseSystem system, World world) {
+    this.name = name;
+    initialize(system, world);
+  }
+
+  @Override
+  public void initialize(BaseSystem baseSystem, World world) {
+    system = baseSystem;
+    gpu = ClassUtils.hasAnnotation(baseSystem.getClass(), GpuSystem.class);
+    if (name == null) {
+      name = toString();
+    }
+    if (color == null) {
+      calculateColor(toString().hashCode(), color = new Color());
+    }
+    SystemProfiler.add(this);
+  }
+
+  private long startTime;
+
+  @Override
+  public void start() {
+    startTime = TimeUtils.nanoTime();
+  }
+
+  @Override
+  public void stop() {
+    long time = TimeUtils.nanoTime() - startTime;
+    if (RUNNING) sample(time);
+  }
+
+  public long getAverage() {
+    return samples == 0 ? 0 : total / Math.min(times.length, samples);
+  }
+
+  public float getMax() {
+    return max / 1000000f;
+  }
+
+  public float getLocalMax() {
+    return localMax / 1000000f;
+  }
+
+  public float getMovingAvg() {
+    return getAverage() / 1000000f;
+  }
+
+  /**
+   * Create a sample with specified time
+   *
+   * @param time in nanoseconds
+   */
+  public void sample(long time) {
+    lastMaxCounter++;
+    if (time > max || lastMaxCounter > 2000) {
+      max = time;
+      lastMaxCounter = 0;
+    }
+
+    if (time > localMax || index == localMaxIndex) {
+      localMax = time;
+      localMaxIndex = index;
+    }
+    total -= times[index];
+    samples++;
+    times[index] = time;
+    total += time;
+    if (++index == times.length) {
+      index = 0;
+    }
+  }
+
+  /**
+   * Add time to current sample
+   *
+   * @param time in nanoseconds
+   */
+  public void add(long time) {
+    times[index] += time;
+    total += time;
+  }
+
+  public int getCurrentSampleIndex() {
+    return index;
+  }
+
+  public int getTotalSamples() {
+    return samples;
+  }
+
+  public long[] getSampleData() {
+    return times;
+  }
+
+  @Override
+  public String toString() {
+    return name != null ? name :
+        system != null ? system.getClass().getSimpleName() : "<dummy>";
+  }
+
+  public String getName() {
+    return name;
+  }
+
+  /**
+   * @return color assigned to this profiler, maybe null if it is not initialized
+   */
+  public Color getColor() {
+    return color;
+  }
+
+  public void setColor(float r, float g, float b, float a) {
+    if (color == null) {
+      color = new Color();
+    }
+    color.set(r, g, b, a);
+  }
+
+  boolean drawGraph = true;
+
+  public boolean getDrawGraph() {
+    return drawGraph;
+  }
+
+  public void setDrawGraph(boolean drawGraph) {
+    this.drawGraph = drawGraph;
+  }
+
+  /**
+   * Calculates semi unique color from given hash
+   */
+  public static Color calculateColor(int hash, Color color) {
+    float hue = (hash % 333) / 333f;
+    float saturation = ((hash % 271) / 271f) * 0.2f + 0.8f;
+    float brightness = ((hash % 577) / 577f) * 0.1f + 0.9f;
+
+    int r = 0, g = 0, b = 0;
+    if (saturation == 0) {
+      r = g = b = (int) (brightness * 255.0f + 0.5f);
+    } else {
+      float h = (hue - (float) Math.floor(hue)) * 6.0f;
+      float f = h - (float) Math.floor(h);
+      float p = brightness * (1.0f - saturation);
+      float q = brightness * (1.0f - saturation * f);
+      float t = brightness * (1.0f - (saturation * (1.0f - f)));
+      switch ((int) h) {
+        case 0:
+          r = (int) (brightness * 255.0f + 0.5f);
+          g = (int) (t * 255.0f + 0.5f);
+          b = (int) (p * 255.0f + 0.5f);
+          break;
+        case 1:
+          r = (int) (q * 255.0f + 0.5f);
+          g = (int) (brightness * 255.0f + 0.5f);
+          b = (int) (p * 255.0f + 0.5f);
+          break;
+        case 2:
+          r = (int) (p * 255.0f + 0.5f);
+          g = (int) (brightness * 255.0f + 0.5f);
+          b = (int) (t * 255.0f + 0.5f);
+          break;
+        case 3:
+          r = (int) (p * 255.0f + 0.5f);
+          g = (int) (q * 255.0f + 0.5f);
+          b = (int) (brightness * 255.0f + 0.5f);
+          break;
+        case 4:
+          r = (int) (t * 255.0f + 0.5f);
+          g = (int) (p * 255.0f + 0.5f);
+          b = (int) (brightness * 255.0f + 0.5f);
+          break;
+        case 5:
+          r = (int) (brightness * 255.0f + 0.5f);
+          g = (int) (p * 255.0f + 0.5f);
+          b = (int) (q * 255.0f + 0.5f);
+          break;
+      }
+    }
+
+    return color.set(r / 255f, g / 255f, b / 255f, 1);
+  }
+}
diff --git a/core/src/com/riiablo/profiler/SystemProfilerGUI.java b/core/src/com/riiablo/profiler/SystemProfilerGUI.java
new file mode 100644
index 00000000..c9d37673
--- /dev/null
+++ b/core/src/com/riiablo/profiler/SystemProfilerGUI.java
@@ -0,0 +1,405 @@
+package com.riiablo.profiler;
+
+import java.util.Comparator;
+
+import com.badlogic.gdx.Gdx;
+import com.badlogic.gdx.graphics.Color;
+import com.badlogic.gdx.graphics.GL20;
+import com.badlogic.gdx.graphics.glutils.ShapeRenderer;
+import com.badlogic.gdx.math.Interpolation;
+import com.badlogic.gdx.math.MathUtils;
+import com.badlogic.gdx.math.Vector2;
+import com.badlogic.gdx.scenes.scene2d.Actor;
+import com.badlogic.gdx.scenes.scene2d.InputEvent;
+import com.badlogic.gdx.scenes.scene2d.Stage;
+import com.badlogic.gdx.scenes.scene2d.actions.Actions;
+import com.badlogic.gdx.scenes.scene2d.ui.CheckBox;
+import com.badlogic.gdx.scenes.scene2d.ui.Label;
+import com.badlogic.gdx.scenes.scene2d.ui.ScrollPane;
+import com.badlogic.gdx.scenes.scene2d.ui.Skin;
+import com.badlogic.gdx.scenes.scene2d.ui.Table;
+import com.badlogic.gdx.scenes.scene2d.ui.TextButton;
+import com.badlogic.gdx.scenes.scene2d.ui.Window;
+import com.badlogic.gdx.scenes.scene2d.utils.ChangeListener;
+import com.badlogic.gdx.scenes.scene2d.utils.ClickListener;
+import com.badlogic.gdx.utils.Align;
+import com.badlogic.gdx.utils.Array;
+import com.badlogic.gdx.utils.Sort;
+
+/**
+ * Gui for SystemProfilers implemented in Scene2d
+ *
+ * Graph must be renderer separately with shape renderer, after stage.draw()
+ *
+ * Certain static values can be changed before creation to modify behaviour
+ *
+ * Dynamic modification of profilers is not supported
+ *
+ * See example implementation of how this class can be used
+ *
+ * @author piotr-j
+ */
+public class SystemProfilerGUI extends Window {
+  public static final Color GRAPH_V_LINE = new Color(0.6f, 0.6f, 0.6f, 1);
+  public static final Color GRAPH_H_LINE = new Color(0.25f, 0.25f, 0.25f, 1);
+  public static float FADE_TIME = 0.3f;
+  public static float PRECISION = 0.01f;
+  public static String FORMAT = "%.2f";
+  public static String STYLE_SMALL = "default";
+  /**
+   * Min width of label with values
+   */
+  public static float MIN_LABEL_WIDTH = 75;
+  public static float GRAPH_MIN_WIDTH = 300;
+  public static float GRAPH_MIN_HEIGHT = 200;
+  /**
+   * How many systems to graph at most
+   */
+  public static int DRAW_MAX_COUNT = 15;
+  /**
+   * How often should text update
+   */
+  public static float REFRESH_RATE = 0.25f;
+
+  protected Skin skin;
+  protected Table profilerLabels;
+  protected Graph graph;
+  protected Table profilersTable;
+  protected Array<ProfilerRow> rows = new Array<>();
+
+  public SystemProfilerGUI(Skin skin, String style) {
+    super("Profiler", skin, style);
+    this.skin = skin;
+
+    setVisible(false);
+    setResizable(true);
+    setResizeBorder(12);
+    TextButton closeButton = new TextButton("X", skin);
+    getTitleTable().add(closeButton).padRight(3);
+    closeButton.addListener(new ClickListener() {
+      @Override
+      public void clicked(InputEvent event, float x, float y) {
+        hide();
+      }
+    });
+
+    Table graphTable = new Table();
+    Table graphLabels = new Table();
+    for (int i = 32; i >= 0; i /= 2) {
+      graphLabels.add(label(Integer.toString(i), skin)).expandY().center().row();
+      if (i == 0) break;
+    }
+    graphTable.add(graphLabels).expandY().fillY();
+
+    graphTable.add(graph = new Graph()).expand().fill();
+
+    profilerLabels = new Table();
+    profilerLabels.add().expandX().fillX();
+    profilerLabels.add(label("max", skin, Align.right)).minWidth(MIN_LABEL_WIDTH);
+    profilerLabels.add(label("lmax", skin, Align.right)).minWidth(MIN_LABEL_WIDTH);
+    profilerLabels.add(label("avg", skin, Align.right)).minWidth(MIN_LABEL_WIDTH);
+
+    for (SystemProfiler profiler : SystemProfiler.get()) {
+      rows.add(new ProfilerRow(profiler, skin));
+    }
+    profilersTable = new Table();
+    // basic once so we can get all profilers and can pack nicely
+    act(0);
+
+    ScrollPane pane = new ScrollPane(profilersTable);
+    pane.setScrollingDisabled(true, false);
+    add(graphTable).expand().fill();
+    add(pane).fillX().pad(0, 10, 10, 10).top()
+        .prefWidth(MIN_LABEL_WIDTH * 7).minWidth(0);
+    pack();
+  }
+
+  private static Label label(String text, Skin skin) {
+    return label(text, skin, Align.left);
+  }
+
+  private static Label label(String text, Skin skin, int align) {
+    Label label = new Label(text, skin, STYLE_SMALL);
+    label.setAlignment(align);
+    return label;
+  }
+
+
+  public void updateAndRender(float delta, ShapeRenderer renderer) {
+    update(delta);
+    renderGraph(renderer);
+  }
+
+  float refreshTimer = REFRESH_RATE;
+  Comparator<ProfilerRow> byAvg = new Comparator<ProfilerRow>() {
+    @Override
+    public int compare(ProfilerRow o1, ProfilerRow o2) {
+      return (int) (o2.getAverage() - o1.getAverage());
+    }
+  };
+
+  /**
+   * Call to update, rate limited by {@link SystemProfilerGUI#REFRESH_RATE}
+   *
+   * This is not in {@link Window#act(float)} to avoid polluting results of actual system with stage
+   * if one exists
+   *
+   * @param delta duration of last frame
+   */
+  public void update(float delta) {
+    refreshTimer += delta;
+    if (refreshTimer < REFRESH_RATE) return;
+    refreshTimer -= REFRESH_RATE;
+
+    if (rows.size != SystemProfiler.size()) {
+      rebuildRows();
+    }
+
+    Sort.instance().sort(rows, byAvg);
+
+    profilersTable.clear();
+    profilersTable.add(profilerLabels).expandX().fillX().right();
+    profilersTable.row();
+
+    for (ProfilerRow row : rows) {
+      row.update();
+      profilersTable.add(row).expandX().fillX().left();
+      profilersTable.row();
+    }
+  }
+
+  private void rebuildRows() {
+    int target = SystemProfiler.size();
+    if (target > rows.size) {
+      for (int i = rows.size; i < target; i++) {
+        rows.add(new ProfilerRow(skin));
+      }
+    } else if (target < rows.size) {
+      rows.removeRange(rows.size - target + 1, rows.size - 1);
+    }
+    for (int i = 0; i < target; i++) {
+      SystemProfiler profiler = SystemProfiler.get(i);
+      rows.get(i).init(profiler);
+    }
+  }
+
+  private Vector2 temp = new Vector2();
+
+  /**
+   * Render graph for profilers, should be called after {@link Stage#draw()} so it is on top of the
+   * gui
+   *
+   * @param renderer {@link ShapeRenderer} to use, must be ready and set to Line type
+   */
+  public void renderGraph(ShapeRenderer renderer) {
+    graph.localToStageCoordinates(temp.setZero());
+    drawGraph(renderer, temp.x, temp.y, graph.getWidth(), graph.getHeight(), getColor().a);
+  }
+
+  /**
+   * Render graph for profilers in a given bounds
+   *
+   * @param renderer {@link ShapeRenderer} to use, must be ready and set to Line type
+   */
+  public static void drawGraph(ShapeRenderer renderer, float x, float y, float width, float height, float alpha) {
+    Gdx.gl.glEnable(GL20.GL_BLEND);
+    // we do this so the logical 0 and top are in the middle of the labels
+    drawGraphAxis(renderer, x, y, width, height, alpha);
+    float sep = height / 7;
+    y += sep / 2;
+    height -= sep;
+    graphProfileTimes(renderer, x, y, width, height, alpha);
+  }
+
+  private static void drawGraphAxis(ShapeRenderer renderer, float x, float y, float width, float height, float alpha) {
+    float sep = height / 7;
+    y += sep / 2;
+    renderer.setColor(GRAPH_V_LINE.r, GRAPH_V_LINE.g, GRAPH_V_LINE.b, alpha);
+    renderer.line(x, y, x, y + height - sep);
+    renderer.line(x + width, y, x + width, y + height - sep);
+
+    renderer.setColor(GRAPH_H_LINE.r, GRAPH_H_LINE.g, GRAPH_H_LINE.b, alpha);
+    for (int i = 0; i < 7; i++) {
+      renderer.line(x, y + i * sep, x + width, y + i * sep);
+    }
+  }
+
+  private static final float NANO_MULTI = 1 / 1000000f;
+
+  static Comparator<SystemProfiler> byLocalMax = new Comparator<SystemProfiler>() {
+    @Override
+    public int compare(SystemProfiler o1, SystemProfiler o2) {
+      return (int) (o2.getLocalMax() - o1.getLocalMax());
+    }
+  };
+
+  private static void graphProfileTimes(ShapeRenderer renderer, float x, float y, float width, float height, float alpha) {
+    Sort.instance().sort(SystemProfiler.get(), byLocalMax);
+    int drawn = 0;
+    for (SystemProfiler profiler : SystemProfiler.get()) {
+      if (!profiler.getDrawGraph())
+        continue;
+      if (drawn++ > DRAW_MAX_COUNT)
+        break;
+
+      renderer.setColor(profiler.getColor());
+      renderer.getColor().a = alpha;
+
+      // distance between 2 point
+      float sampleLen = width / profiler.times.length;
+
+      int current = profiler.getCurrentSampleIndex();
+      int skip = current;
+      long[] times = profiler.getSampleData();
+      float currentPoint = getPoint(times[current] * NANO_MULTI);
+
+      for (int i = times.length - 1; i >= 1; i--) {
+        int prev = current == 0 ? times.length - 1 : current - 1;
+        float prevPoint = getPoint(times[prev] * NANO_MULTI);
+        // we want do skip line between actaul first and last points, as that may result in ugly line at the edge
+        if (current != skip && currentPoint > 0)
+          renderer.line(x + (i - 1) * sampleLen, y + prevPoint * height / 6, x + i * sampleLen, y + currentPoint * height / 6);
+        current = prev;
+        currentPoint = prevPoint;
+      }
+    }
+  }
+
+  private static float getPoint(float sampleValue) {
+    return sampleValue < 1 ? sampleValue : (MathUtils.log2(sampleValue) + 1);
+  }
+
+  /**
+   * Single row for profiler list
+   */
+  private static class ProfilerRow extends Table {
+    SystemProfiler profiler;
+    Label name, max, localMax, avg;
+    CheckBox draw;
+    float lastMax, lastLocalMax, lastAvg;
+    ChangeListener listener;
+
+    public ProfilerRow(Skin skin) {
+      this(null, skin);
+    }
+
+    public ProfilerRow(SystemProfiler profiler, Skin skin) {
+      super();
+      draw = new CheckBox("", skin);
+      name = new Label("", skin, STYLE_SMALL);
+      name.setEllipsis(true);
+      max = label("", skin, Align.right);
+      localMax = label("", skin, Align.right);
+      avg = label("", skin, Align.right);
+      add(draw);
+      add(name).expandX().fillX();
+      ;
+      add(max).minWidth(MIN_LABEL_WIDTH);
+      add(localMax).minWidth(MIN_LABEL_WIDTH);
+      add(avg).minWidth(MIN_LABEL_WIDTH);
+
+      if (profiler != null) init(profiler);
+    }
+
+    public void init(final SystemProfiler profiler) {
+      this.profiler = profiler;
+      if (listener != null) draw.removeListener(listener);
+      draw.setChecked(profiler.getDrawGraph());
+      draw.addListener(listener = new ChangeListener() {
+        @Override
+        public void changed(ChangeEvent event, Actor actor) {
+          profiler.setDrawGraph(!profiler.getDrawGraph());
+          if (profiler.getDrawGraph()) {
+            setChildColor(profiler.getColor());
+          } else {
+            setChildColor(Color.LIGHT_GRAY);
+          }
+        }
+      });
+      name.setText(profiler.getName());
+      setChildColor(profiler.getColor());
+      lastMax = lastLocalMax = lastAvg = -1;
+      invalidateHierarchy();
+      layout();
+    }
+
+    private void setChildColor(Color color) {
+      name.setColor(color);
+      max.setColor(color);
+      localMax.setColor(color);
+      avg.setColor(color);
+    }
+
+    public void update() {
+      // we don't want to update if the change wont affect the representation
+      if (!MathUtils.isEqual(lastMax, profiler.getMax(), PRECISION)) {
+        lastMax = profiler.getMax();
+        max.setText(timingToString(lastMax));
+      }
+      if (!MathUtils.isEqual(lastLocalMax, profiler.getLocalMax(), PRECISION)) {
+        lastLocalMax = profiler.getLocalMax();
+        localMax.setText(timingToString(lastLocalMax));
+      }
+      if (!MathUtils.isEqual(lastAvg, profiler.getMovingAvg(), PRECISION)) {
+        lastAvg = profiler.getMovingAvg();
+        avg.setText(timingToString(lastAvg));
+      }
+    }
+
+    private String timingToString(float var) {
+      int decimals = (int) (var * 100) % 100;
+      return Integer.toString((int) (var)) + (decimals < 10 ? ".0" : ".") + Integer.toString(decimals);
+    }
+
+    public float getAverage() {
+      return profiler.getAverage();
+    }
+
+    public float getLocalMax() {
+      return profiler.getLocalMax();
+    }
+
+    public SystemProfiler getProfiler() {
+      return profiler;
+    }
+
+    public float getMax() {
+      return profiler.getMax();
+    }
+  }
+
+  /**
+   * Simple placeholder for actual graph
+   */
+  private class Graph extends Table {
+    public Graph() {}
+
+    @Override
+    public float getMinWidth() {
+      return GRAPH_MIN_WIDTH;
+    }
+
+    @Override
+    public float getMinHeight() {
+      return GRAPH_MIN_HEIGHT;
+    }
+  }
+
+  /**
+   * Show the profiler window
+   *
+   * @param stage stage to add to
+   */
+  public void show(Stage stage) {
+    stage.addActor(this);
+    setColor(1, 1, 1, 0);
+    addAction(Actions.fadeIn(FADE_TIME, Interpolation.fade));
+  }
+
+  /**
+   * Hide the window and remove from the stage
+   */
+  public void hide() {
+    addAction(Actions.sequence(Actions.fadeOut(FADE_TIME, Interpolation.fade), Actions.removeActor()));
+  }
+}
diff --git a/core/src/com/riiablo/screen/GameScreen.java b/core/src/com/riiablo/screen/GameScreen.java
index ca906eb7..4cb91a9e 100644
--- a/core/src/com/riiablo/screen/GameScreen.java
+++ b/core/src/com/riiablo/screen/GameScreen.java
@@ -6,6 +6,8 @@ import com.artemis.WorldConfiguration;
 import com.artemis.WorldConfigurationBuilder;
 import com.artemis.managers.TagManager;
 import com.artemis.utils.IntBag;
+import net.mostlyoriginal.api.event.common.EventSystem;
+
 import com.badlogic.gdx.Application;
 import com.badlogic.gdx.Gdx;
 import com.badlogic.gdx.Input;
@@ -29,6 +31,7 @@ import com.badlogic.gdx.utils.Array;
 import com.badlogic.gdx.utils.Disposable;
 import com.badlogic.gdx.utils.viewport.ScreenViewport;
 import com.badlogic.gdx.utils.viewport.Viewport;
+
 import com.riiablo.Client;
 import com.riiablo.Cvars;
 import com.riiablo.Keys;
@@ -106,6 +109,7 @@ import com.riiablo.map.Box2DPhysics;
 import com.riiablo.map.Map;
 import com.riiablo.map.MapManager;
 import com.riiablo.map.RenderSystem;
+import com.riiablo.profiler.ProfilerPlugin;
 import com.riiablo.save.CharData;
 import com.riiablo.screen.panel.CharacterPanel;
 import com.riiablo.screen.panel.ControlPanel;
@@ -123,9 +127,6 @@ import com.riiablo.screen.panel.StashPanel;
 import com.riiablo.screen.panel.WaygatePanel;
 import com.riiablo.widget.TextArea;
 
-import net.mostlyoriginal.api.event.common.EventSystem;
-import net.mostlyoriginal.plugin.ProfilerPlugin;
-
 public class GameScreen extends ScreenAdapter implements GameLoadingScreen.Loadable {
   private static final String TAG = "GameScreen";
   private static final boolean DEBUG          = true;