diff --git a/imgui.ini b/imgui.ini
index 67a5e37..609a38b 100644
--- a/imgui.ini
+++ b/imgui.ini
@@ -9,7 +9,7 @@ Size=894,195
 Collapsed=0
 
 [Window][Debug Utils]
-Pos=58,19
-Size=791,379
+Pos=26,12
+Size=688,343
 Collapsed=0
 
diff --git a/src/Controller.cpp b/src/Controller.cpp
index e986f24..e3e3926 100644
--- a/src/Controller.cpp
+++ b/src/Controller.cpp
@@ -210,7 +210,7 @@ void Controller::updateExposure(ShaderProgram *shaderProgram)
     shaderProgram->unbind();
 }
 
-ShaderProgram* Controller::getShaderProgramByName(const char *name)
+ShaderProgram* Controller::getShaderProgramByName(const std::string& name)
 {
     for (auto it = shaderPrograms.begin(); it != shaderPrograms.end(); it++) {
         if((*it)->getUniqueName() == name) {
@@ -221,7 +221,7 @@ ShaderProgram* Controller::getShaderProgramByName(const char *name)
     return nullptr;
 }
 
-ShaderProgram* Controller::getShaderProgramByName(std::vector<ShaderProgram*> shaderPrograms, const char *name)
+ShaderProgram* Controller::getShaderProgramByName(std::vector<ShaderProgram*> shaderPrograms, const std::string& name)
 {
     for (auto it = shaderPrograms.begin(); it != shaderPrograms.end(); it++) {
         if((*it)->getUniqueName() == name) {
@@ -237,7 +237,6 @@ void Controller::setMaxFps(uint16_t fps)
     MAX_FPS = fps;
 }
 
-
 #ifdef _DEBUG
 void Controller::renderImGui(World *world, PointLight *pointLight, glm::vec3 *lightColor, bool *rotateEntity, bool *rotateLightSource, ShaderProgram *postProcessingProgram, float *intensity, bool *drawShadows)
 {
diff --git a/src/Controller.h b/src/Controller.h
index 73dabc4..d3c0f6f 100644
--- a/src/Controller.h
+++ b/src/Controller.h
@@ -24,7 +24,7 @@ public:
 
     void setMaxFps(uint16_t fps);
 
-    static ShaderProgram* getShaderProgramByName(std::vector<ShaderProgram*> shaderPrograms, const char *name);
+    static ShaderProgram* getShaderProgramByName(std::vector<ShaderProgram*> shaderPrograms, const std::string& name);
 
 private:
     void limit_framerate();
@@ -32,7 +32,7 @@ private:
     void updateWindowDimensions();
     void updateExposure(ShaderProgram *shaderProgram);
 
-    ShaderProgram* getShaderProgramByName(const char *name);
+    ShaderProgram* getShaderProgramByName(const std::string& name);
 
     void renderImGui(World *world, PointLight *pointLight, glm::vec3 *lightColor, bool *rotateEntity, bool *rotateLightSource, ShaderProgram *postProcessingProgram, float *intensity, bool *drawShadows);
 
diff --git a/src/Menu.cpp b/src/Menu.cpp
index d52e410..d016950 100644
--- a/src/Menu.cpp
+++ b/src/Menu.cpp
@@ -20,31 +20,34 @@ Menu::~Menu()
     }
 }
 
-Screen *Menu::getScreenByName(const std::string& unique_name)
+Screen *Menu::getScreenByName(const std::string& name) const
 {
-    for (auto it = screens.begin(); it != screens.end(); it++) {
-        if((*it)->getUniqueName() == unique_name) {
-            return *it;
+    if (m_screen_name_cache.find(name) != m_screen_name_cache.end())
+        return m_screen_name_cache[name];
+
+    for (auto it : screens) {
+        if(it->getUniqueName() == name) {
+            m_screen_name_cache[name] = it;
+            return it;
         }
     }
+
     return nullptr;
 }
 
-Screen *Menu::getActiveScreen()
+Screen *Menu::getActiveScreen() const
 {
     return activeScreen;
 }
 
-void Menu::showScreenByName (const std::string& unique_name)
+void Menu::showScreenByName(const std::string& name)
 {
-    auto it = screens.begin();
-    for (; it != screens.end(); it++) {
-        if((*it)->getUniqueName() == unique_name) {
-            (*it)->draw();
-            break;
-        }
-    }
-    activeScreen = *it;
+    Screen* screen = getScreenByName(name);
+
+    if (!screen) return;
+
+    screen->draw();
+    activeScreen = screen;
 }
 
 void Menu::resetActiveScreen()
@@ -58,7 +61,7 @@ void Menu::handleMouseButtonActionRegister(bool *mouseButtonActionRegister, Wind
         auto widgets = activeScreen->getWidgets();
         for (auto it = widgets.begin(); it != widgets.end(); it++) {
             if ((*it)->isHovered(window)) {
-                std::cout << (*it)->getUniqueName() << " clicked!" << std::endl;
+                // std::cout << (*it)->getUniqueName() << " clicked!" << std::endl;
                 if((*it)->getCallbackId() == 1)
                     resetActiveScreen();
                 if((*it)->getCallbackId() == 2)
diff --git a/src/Menu.h b/src/Menu.h
index f61bba1..077484e 100644
--- a/src/Menu.h
+++ b/src/Menu.h
@@ -1,6 +1,7 @@
 #pragma once
 
 #include <string>
+#include <unordered_map>
 
 #include "Screen.h"
 #include "Framebuffer.h"
@@ -13,10 +14,10 @@ public:
     Menu(Framebuffer *p_framebuffer, ShaderProgram *p_shaderProgram);
     ~Menu();
 
-    Screen *getScreenByName(const std::string& unique_name);
-    void showScreenByName(const std::string& unique_name);
+    Screen *getScreenByName(const std::string& name) const;
+    void showScreenByName(const std::string& name);
 
-    Screen *getActiveScreen();
+    Screen *getActiveScreen() const;
     void writeWindowActions(bool *windowActionRegister);
 
     void resetActiveScreen();
@@ -38,4 +39,6 @@ private:
     Screen *mainMenuScreen;
     Screen *optionMenuScreen;
     Screen *pauseMenuScreen;*/
+
+    mutable std::unordered_map<std::string, Screen*> m_screen_name_cache;
 };
diff --git a/src/Model.cpp b/src/Model.cpp
index cbc2651..5afd3f7 100644
--- a/src/Model.cpp
+++ b/src/Model.cpp
@@ -30,8 +30,8 @@ void Model::draw(ShaderProgram *shaderProgram)
     }
 
     // Iterate through every mesh and call the draw function
-    for (auto it = meshes.begin(); it != meshes.end(); it++) {
-        (*it)->draw(shaderProgram);
+    for (auto mesh : meshes) {
+        mesh->draw(shaderProgram);
     }
 }
 
@@ -43,8 +43,8 @@ void Model::drawWithoutTextures()
     }
 
     // Iterate through every mesh and call the draw function
-    for (auto it = meshes.begin(); it != meshes.end(); it++) {
-        (*it)->drawWithoutTextures();
+    for (auto mesh : meshes) {
+        mesh->drawWithoutTextures();
     }
 }
 
@@ -53,7 +53,7 @@ void Model::loadModel(const std::string &pathToModel)
     std::ifstream input(pathToModel, std::ios::in | std::ios::binary);
 
     if (!input.is_open()) {
-        std::cout << "Could not find model file " << pathToModel << std::endl;
+        std::cerr << "Could not find model file " << pathToModel << std::endl;
         return;
     }
 
diff --git a/src/Screen.cpp b/src/Screen.cpp
index 26b5947..2f97879 100644
--- a/src/Screen.cpp
+++ b/src/Screen.cpp
@@ -1,8 +1,9 @@
 #include "Screen.h"
+#include "helper.h"
 
 uint32_t Screen::id_counter = 0;
 
-Screen::Screen(std::string &name, std::vector<Widget*> widgets, Framebuffer *framebuffer, ShaderProgram *shaderProgram) :
+Screen::Screen(const std::string &name, std::vector<Widget*> widgets, Framebuffer *framebuffer, ShaderProgram *shaderProgram) :
     unique_name(name),
     framebuffer(framebuffer),
     shaderProgram(shaderProgram),
@@ -22,21 +23,26 @@ Screen::~Screen()
     }
 }
 
-const std::string& Screen::getUniqueName()
+const std::string& Screen::getUniqueName() const
 {
     return unique_name;
 }
 
-std::vector<Widget*> Screen::getWidgets()
+std::vector<Widget*> Screen::getWidgets() const
 {
     return widgets;
 }
 
-Widget *Screen::getWidgetByName(const char* name)
+Widget *Screen::getWidgetByName(const std::string& name) const
 {
-    for (auto it = widgets.begin(); it != widgets.end(); it++) {
-        if((*it)->getUniqueName() == name)
-            return *it;
+    if (m_widget_name_cache.find(name) != m_widget_name_cache.end())
+        return m_widget_name_cache[name];
+
+    for (auto it : widgets) {
+        if(it->getUniqueName() == name) {
+            m_widget_name_cache[name] = it;
+            return it;
+        }
     }
     return nullptr;
 }
@@ -46,7 +52,7 @@ void Screen::addWidget(Widget *widget)
     widgets.push_back(widget);
 }
 
-void Screen::draw()
+void Screen::draw() const
 {
     framebuffer->setExposureCorrection(false);
     framebuffer->bind();
diff --git a/src/Screen.h b/src/Screen.h
index 31d00bb..d304b75 100644
--- a/src/Screen.h
+++ b/src/Screen.h
@@ -1,5 +1,7 @@
 #pragma once
 
+#include <unordered_map>
+
 #include "ShaderProgram.h"
 #include "Framebuffer.h"
 #include "Widget.h"
@@ -9,15 +11,15 @@ class Menu;
 class Screen
 {
 public:
-    Screen(std::string &name, std::vector<Widget*> widgets, Framebuffer *framebuffer, ShaderProgram *shaderProgram);
+    Screen(const std::string& name, std::vector<Widget*> widgets, Framebuffer* framebuffer, ShaderProgram* shaderProgram);
     ~Screen();
     
     void addWidget(Widget *widget);
-    void draw();
+    void draw() const;
 
-    const std::string& getUniqueName();
-    std::vector<Widget*> getWidgets();
-    Widget *getWidgetByName(const char* name);
+    const std::string& getUniqueName() const;
+    std::vector<Widget*> getWidgets() const;
+    Widget *getWidgetByName(const std::string& name) const;
     
 private:
     uint32_t id;
@@ -29,4 +31,6 @@ private:
     
     std::vector<Texture*> textures;
     std::vector<Widget*> widgets;
+
+    mutable std::unordered_map<std::string, Widget*> m_widget_name_cache;
 };
diff --git a/src/ShaderProgram.cpp b/src/ShaderProgram.cpp
index cef509a..827fde1 100644
--- a/src/ShaderProgram.cpp
+++ b/src/ShaderProgram.cpp
@@ -1,11 +1,12 @@
 #include <iostream>
+#include <fstream>
 #include <string>
 #include <glm/glm.hpp>
 #include <glm/gtc/type_ptr.hpp>
 
 #include "ShaderProgram.h"
 
-ShaderProgram::ShaderProgram(std::string &name, std::string &vertexShaderPath, std::string &fragmentShaderPath) :
+ShaderProgram::ShaderProgram(const std::string &name, const std::string &vertexShaderPath, const std::string &fragmentShaderPath) :
     unique_name(name)
 {
     std::string vertexShaderSource = parse(vertexShaderPath.c_str());
@@ -35,7 +36,7 @@ ShaderProgram::ShaderProgram(std::string &name, std::string &vertexShaderPath, s
 #endif
 }
 
-ShaderProgram::ShaderProgram(std::string &name, std::string &vertexShaderPath, std::string &geometryShaderPath, std::string &fragmentShaderPath) :
+ShaderProgram::ShaderProgram(const std::string &name, const std::string &vertexShaderPath, const std::string &geometryShaderPath, const std::string &fragmentShaderPath) :
     unique_name(name)
 {
     std::string vertexShaderSource = parse(vertexShaderPath.c_str());
@@ -85,28 +86,22 @@ void ShaderProgram::unbind()
     glUseProgram(0);
 }
 
-std::string ShaderProgram::parse(const char *filename)
+std::string ShaderProgram::parse(const std::string& filename)
 {
-    FILE *file;
-    file = fopen(filename, "rb");
-    if (!file) {
-        std::cout << "Shader " << filename << " not found!" << std::endl;
+    std::fstream shaderfile;
+    shaderfile.open(filename, std::ios::in);
+
+    if (!shaderfile.is_open()) {
+        std::cerr << "Shader " << filename << " not found!" << std::endl;
         exit(-1);
     }
 
-    std::string contents;
-    fseek(file, 0, SEEK_END);
-    size_t filesize = ftell(file);
-    rewind(file);
-    contents.resize(filesize);
-
-    fread(&contents[0], 1, filesize, file);
-    fclose(file);
+    std::string contents((std::istreambuf_iterator<char>(shaderfile)), (std::istreambuf_iterator<char>()));
 
     return contents;
 }
 
-GLuint ShaderProgram::compile(std::string shaderSource, GLenum type)
+GLuint ShaderProgram::compile(const std::string& shaderSource, GLenum type)
 {
     GLuint shaderId = glCreateShader(type);
     const char *src = shaderSource.c_str();
@@ -127,39 +122,49 @@ GLuint ShaderProgram::compile(std::string shaderSource, GLenum type)
     return shaderId;
 }
 
-void ShaderProgram::setUniform(const char *name, bool value) const
+GLint ShaderProgram::retrieveUniformLocation(const std::string& name) const {
+    if (uniformLocationCache.find(name) != uniformLocationCache.end())
+        return uniformLocationCache[name];
+
+    GLint location = glGetUniformLocation(shaderProgramId, name.c_str());
+    uniformLocationCache[name] = location;
+
+    return location;
+}
+
+void ShaderProgram::setUniform(const std::string& name, bool value) const
 {
-    GLint location = glGetUniformLocation(shaderProgramId, name);
+    GLint location = retrieveUniformLocation(name);
     glUniform1i(location, (int)value);
 }
 
-void ShaderProgram::setUniform(const char *name, int value) const
+void ShaderProgram::setUniform(const std::string& name, int value) const
 {
-    GLint location = glGetUniformLocation(shaderProgramId, name);
+    GLint location = retrieveUniformLocation(name);
     glUniform1i(location, value);
 }
 
-void ShaderProgram::setUniform(const char *name, float value) const
+void ShaderProgram::setUniform(const std::string& name, float value) const
 {
-    GLint location = glGetUniformLocation(shaderProgramId, name);
+    GLint location = retrieveUniformLocation(name);
     glUniform1f(location, value);
 }
 
-void ShaderProgram::setUniform(const char *name, glm::vec3 vector) const
+void ShaderProgram::setUniform(const std::string& name, glm::vec3 vector) const
 {
-    GLint location = glGetUniformLocation(shaderProgramId, name);
+    GLint location = retrieveUniformLocation(name);
     glUniform3f(location, vector.x, vector.y, vector.z);
 }
 
-void ShaderProgram::setUniform(const char *name, glm::mat3 matrix) const
+void ShaderProgram::setUniform(const std::string& name, glm::mat3 matrix) const
 {
-    GLint location = glGetUniformLocation(shaderProgramId, name);
+    GLint location = retrieveUniformLocation(name);
     glUniformMatrix3fv(location, 1, GL_FALSE, glm::value_ptr(matrix));
 }
 
-void ShaderProgram::setUniform(const char *name, glm::mat4 matrix) const
+void ShaderProgram::setUniform(const std::string& name, glm::mat4 matrix) const
 {
-    GLint location = glGetUniformLocation(shaderProgramId, name);
+    GLint location = retrieveUniformLocation(name);
     glUniformMatrix4fv(location, 1, GL_FALSE, glm::value_ptr(matrix));
 }
 
diff --git a/src/ShaderProgram.h b/src/ShaderProgram.h
index edd9c7b..5b01922 100644
--- a/src/ShaderProgram.h
+++ b/src/ShaderProgram.h
@@ -2,35 +2,38 @@
 
 #include <glad/glad.h>
 #include <glm/glm.hpp>
+#include <unordered_map>
 #include <string>
 
 class ShaderProgram
 {
 public:
-    ShaderProgram(std::string &name, std::string &vertexShaderPath, std::string &fragmentShaderPath);
-    ShaderProgram(std::string &name, std::string &vertexShaderPath, std::string &geometryShaderPath, std::string &fragmentShaderPath);
+    ShaderProgram(const std::string &name, const std::string &vertexShaderPath, const std::string &fragmentShaderPath);
+    ShaderProgram(const std::string &name, const std::string &vertexShaderPath, const std::string &geometryShaderPath, const std::string &fragmentShaderPath);
     ~ShaderProgram();
 
     void bind();
     void unbind();
 
+    GLint retrieveUniformLocation(const std::string& name) const;
     // May be rewritten...
-    void setUniform(const char *name, bool value) const;
-    void setUniform(const char *name, int value) const;
-    void setUniform(const char *name, float value) const;
-    void setUniform(const char *name, glm::vec3 vector) const;
-    void setUniform(const char *name, glm::mat3 matrix) const;
-    void setUniform(const char *name, glm::mat4 matrix) const;
+    void setUniform(const std::string& name, bool value) const;
+    void setUniform(const std::string& name, int value) const;
+    void setUniform(const std::string& name, float value) const;
+    void setUniform(const std::string& name, glm::vec3 vector) const;
+    void setUniform(const std::string& name, glm::mat3 matrix) const;
+    void setUniform(const std::string& name, glm::mat4 matrix) const;
 
 public:
     GLuint getShaderProgramId();
     std::string getUniqueName();
 
 private:
-    std::string parse(const char *filename);
-    GLuint compile(std::string shaderSource, GLenum type);
+    std::string parse(const std::string& filename);
+    GLuint compile(const std::string& shaderSource, GLenum type);
 
 private:
     GLuint shaderProgramId;
     std::string unique_name;
+    mutable std::unordered_map<std::string, GLint> uniformLocationCache;
 };
diff --git a/src/helper.h b/src/helper.h
index c95c26d..3623cd8 100644
--- a/src/helper.h
+++ b/src/helper.h
@@ -4,6 +4,7 @@
 #include <iostream>
 #include <string>
 #include <algorithm>
+#include <chrono>
 #include <GLFW/glfw3.h>
 
 #ifdef __linux__
@@ -135,4 +136,24 @@ static void gl_debug_callback(GLenum source, GLenum type, GLuint id, GLenum seve
             << std::endl;
 }
 
+class Timer {
+public:
+    Timer(const std::string& name) : name(name) {
+        start = std::chrono::high_resolution_clock::now();
+    }
+
+    ~Timer() {
+        end = std::chrono::high_resolution_clock::now();
+
+        duration = end - start;
+        float ms = duration.count() * 1000.0f;
+
+        std::cout << "Timer " << name << " took " << ms << "ms!" << std::endl;
+    }
+private:
+    std::string name;
+    std::chrono::high_resolution_clock::time_point start, end;
+    std::chrono::duration<float> duration;
+};
+
 }