diff --git a/include/Camera.h b/include/Camera.h
index cb84706..740f0ac 100644
--- a/include/Camera.h
+++ b/include/Camera.h
@@ -1,7 +1,7 @@
 #pragma once
 #include <SFML/System/Vector3.hpp>
 #include <SFML/System/Vector2.hpp> 
-#include "util.hpp"
+#include "util.cpp"
 #include "Pub_Sub.h"
 
 class Camera : public VrEventSubscriber{
diff --git a/include/GL_Testing.h b/include/GL_Testing.h
index 5aeb8aa..c273574 100644
--- a/include/GL_Testing.h
+++ b/include/GL_Testing.h
@@ -1,6 +1,6 @@
 #pragma once
 #include <string>
-#include <util.hpp>
+#include <util.cpp>
 #include <cstring>
 
 #ifdef _WIN32
diff --git a/include/LightController.h b/include/LightController.h
index 6d7b339..bf524c7 100644
--- a/include/LightController.h
+++ b/include/LightController.h
@@ -1,7 +1,7 @@
 #pragma once
 #include <SFML/System/Vector3.hpp>
 #include <SFML/System/Vector2.hpp> 
-#include "util.hpp"
+#include "util.cpp"
 #include "Pub_Sub.h"
 #include "raycaster/RayCaster.h"
 #include <list>
diff --git a/include/LightHandle.h b/include/LightHandle.h
index 1846c5a..48c6df8 100644
--- a/include/LightHandle.h
+++ b/include/LightHandle.h
@@ -1,6 +1,6 @@
 #pragma once
 #include <SFML/Graphics.hpp>
-#include <util.hpp>
+#include <util.cpp>
 #include <memory>
 #include "Pub_Sub.h"
 
diff --git a/include/Map.h b/include/Map.h
index e31d00b..e4c2d5c 100644
--- a/include/Map.h
+++ b/include/Map.h
@@ -8,7 +8,7 @@
 #include <iostream>
 #include <functional>
 #include <cmath>
-#include "util.hpp"
+#include "util.cpp"
 #include <deque>
 #include <unordered_map>
 #include <bitset>
diff --git a/include/raycaster/Hardware_Caster.h b/include/raycaster/Hardware_Caster.h
index 9c27d02..4a0a9e6 100644
--- a/include/raycaster/Hardware_Caster.h
+++ b/include/raycaster/Hardware_Caster.h
@@ -2,10 +2,9 @@
 #include <raycaster/RayCaster.h>
 #include <vector>
 #include <iostream>
-#include "util.hpp"
 #include <map>
 #include <string.h>
-
+#include "LightController.h"
 
 #ifdef linux
 #include <CL/cl.h>
@@ -95,7 +94,7 @@ private:
 
 	void print_kernel_arguments();
 
-	bool assert(int error_code, std::string function_name);
+	bool vr_assert(int error_code, std::string function_name);
 
 	cl_device_id getDeviceID();
 	cl_platform_id getPlatformID();
diff --git a/include/util.hpp b/include/util.cpp
similarity index 76%
rename from include/util.hpp
rename to include/util.cpp
index fc35ae8..8905dc6 100644
--- a/include/util.hpp
+++ b/include/util.cpp
@@ -1,338 +1,286 @@
-#pragma once
-#include <SFML/Graphics.hpp>
-#include "Vector4.hpp"
-#include <math.h>
-#include <bitset>
-#include <iostream>
-#include <fstream>
-#include <sstream>
-#include <string>
-#include <iterator>
-#include <list>
-#include <algorithm>
-
-
-const double PI = 3.141592653589793238463;
-const float  PI_F = 3.14159265358979f;
-struct fps_counter {
-public:
-	fps_counter() :
-		backdrop(sf::Vector2f(200, 100)), vertex_array(sf::LinesStrip) {
-
-		backdrop.setFillColor(sf::Color(0x0000003F));
-
-		if (!f.loadFromFile("../assets/fonts/Arial.ttf")) {
-			std::cout << "couldn't find the fall back Arial font in ../assets/fonts/" << std::endl;
-		}
-		else {
-			t.setFont(f);
-			t.setCharacterSize(18);
-			t.setColor(sf::Color::White);
-		}
-	}
-
-	void frame(double delta_time) {
-		// Apply 100 units of smoothing
-		if (frame_count == 100) {
-			frame_count = 0;
-			fps_average = 0;
-		}
-		frame_count++;
-		fps_average += (delta_time - fps_average) / frame_count;
-	}
-
-	void flip_units() {
-		if (milliseconds)
-			milliseconds = false;
-		else
-			milliseconds = true;
-	}
-
-	void set_position(sf::Vector2f position) {
-		backdrop.setPosition(position);
-	}
-
-	sf::Vector2f get_position() {
-		return backdrop.getPosition();
-	}
-
-	void draw(sf::RenderWindow *r) {
-
-		// FPS Line graph
-		r->draw(backdrop);
-
-		if (vertex_position == 200)
-			vertex_position = 0;
-
-		sf::Vector2f origin = backdrop.getPosition();
-		sf::Vector2f point = origin + sf::Vector2f(vertex_position, backdrop.getSize().y - (1.0 / fps_average));
-
-		if (vertex_array.getVertexCount() < 200)
-			vertex_array.append(sf::Vertex(point, sf::Color::Red));
-		else
-			vertex_array[vertex_position] = sf::Vertex(point, sf::Color::Red);
-
-		r->draw(vertex_array);
-
-		vertex_position++;
-
-		// FPS Text
-		std::string out;
-
-		if (milliseconds)
-			out = std::to_string(fps_average);
-		else
-			out = std::to_string(floor(1 / fps_average));
-
-		t.setPosition(origin);
-		t.setString(out);
-		r->draw(t);
-	}
-
-private:
-
-	sf::RectangleShape backdrop;
-	sf::VertexArray vertex_array;
-
-	sf::Font f;
-	sf::Text t;
-
-	int frame_count = 0;
-	double fps_average = 0;
-	bool milliseconds = false;
-
-	int vertex_position = 0;
-};
-
-struct debug_text {
-public:
-	debug_text(int slot, int pixel_spacing, void* data_, std::string prefix_) : data(data_), prefix(prefix_) {
-		if (!f.loadFromFile("../assets/fonts/Arial.ttf")) {
-			std::cout << "couldn't find the fall back Arial font in ../assets/fonts/" << std::endl;
-		}
-		else {
-			t.setFont(f);
-			t.setCharacterSize(20);
-			t.setPosition(static_cast<float>(20), static_cast<float>(slot * pixel_spacing));
-		}
-
-	}
-
-	void draw(sf::RenderWindow *r) {
-		t.setString(prefix + std::to_string(*(float*)data));
-		r->draw(t);
-	}
-
-private:
-	void* data;
-	std::string prefix;
-	sf::Font f;
-	sf::Text t;
-
-};
-
-inline sf::Vector3f SphereToCart(sf::Vector2f i) {
-
-	auto r = sf::Vector3f(
-		(1 * sin(i.y) * cos(i.x)),
-		(1 * sin(i.y) * sin(i.x)),
-		(1 * cos(i.y))
-		);
-	return r;
-};
-
-inline sf::Vector3f SphereToCart(sf::Vector3f i) {
-
-	auto r = sf::Vector3f(
-		(i.x * sin(i.z) * cos(i.y)),
-		(i.x * sin(i.z) * sin(i.y)),
-		(i.x * cos(i.z))
-		);
-	return r;
-};
-
-
-inline sf::Vector3f CartToSphere(sf::Vector3f in) {
-
-	auto r = sf::Vector3f(
-		sqrt(in.x * in.x + in.y * in.y + in.z * in.z),
-		atan(in.y / in.x),
-		atan(sqrt(in.x * in.x + in.y * in.y) / in.z)
-		);
-	return r;
-};
-
-inline sf::Vector2f CartToNormalizedSphere(sf::Vector3f in) {
-
-	auto r = sf::Vector2f(
-		atan2(sqrt(in.x * in.x + in.y * in.y), in.z), 
-		atan2(in.y, in.x)
-		);
-	
-	return r;
-}
-
-inline sf::Vector3f FixOrigin(sf::Vector3f base, sf::Vector3f head) {
-	return head - base;
-}
-
-
-inline sf::Vector3f Normalize(sf::Vector3f in) {
-	
-	float multiplier = sqrt(in.x * in.x + in.y * in.y + in.z * in.z);
-	auto r = sf::Vector3f(
-		in.x / multiplier,
-		in.y / multiplier,
-		in.z / multiplier
-	);
-	return r;
-
-}
-
-
-inline float DotProduct(sf::Vector3f a, sf::Vector3f b){
-	return a.x * b.x + a.y * b.y + a.z * b.z;
-}
-
-inline float Magnitude(sf::Vector3f in){
-	return sqrt(in.x * in.x + in.y * in.y + in.z * in.z);
-}
-
-inline float AngleBetweenVectors(sf::Vector3f a, sf::Vector3f b){
-	return acos(DotProduct(a, b) / (Magnitude(a) * Magnitude(b)));
-}
-
-inline float DistanceBetweenPoints(sf::Vector3f a, sf::Vector3f b) {
-	return sqrt(DotProduct(a, b));
-}
-
-inline float DegreesToRadians(float in) {
-	return static_cast<float>(in * PI / 180.0f);
-}
-
-inline float RadiansToDegrees(float in) {
-	return static_cast<float>(in * 180.0f / PI);
-}
-
-inline std::string read_file(std::string file_name){
-	std::ifstream input_file(file_name);
-
-	if (!input_file.is_open()){
-		std::cout << file_name << " could not be opened" << std::endl;
-		return "";
-	}
-
-	std::stringstream buf;
-	buf << input_file.rdbuf();
-	input_file.close();
-	return buf.str();
-}
-
-inline void PrettyPrintUINT64(uint64_t i, std::stringstream* ss) {
-
-	*ss << "[" << std::bitset<15>(i) << "]";
-	*ss << "[" << std::bitset<1>(i >> 15) << "]";
-	*ss << "[" << std::bitset<8>(i >> 16) << "]";
-	*ss << "[" << std::bitset<8>(i >> 24) << "]";
-	*ss << "[" << std::bitset<32>(i >> 32) << "]";
-
-}
-
-inline void PrettyPrintUINT64(uint64_t i) {
-
-	std::cout << "[" << std::bitset<15>(i) << "]";
-	std::cout << "[" << std::bitset<1>(i >> 15) << "]";
-	std::cout << "[" << std::bitset<8>(i >> 16) << "]";
-	std::cout << "[" << std::bitset<8>(i >> 24) << "]";
-	std::cout << "[" << std::bitset<32>(i >> 32) << "]" << std::endl;
-
-}
-
-inline void DumpLog(std::stringstream* ss, std::string file_name) {
-	
-	std::ofstream log_file;
-	log_file.open(file_name);
-
-	log_file << ss->str();
-
-	log_file.close();
-
-}
-
-inline std::string sfml_get_input(sf::RenderWindow *window) {
-	
-	std::stringstream ss;
-
-	sf::Event event;
-	while (window->pollEvent(event)) {
-		if (event.type == sf::Event::TextEntered) {
-			ss << event.text.unicode;
-		} 
-		
-		else if (event.type == sf::Event::KeyPressed) {
-			if (event.key.code == sf::Keyboard::Return) {
-				return ss.str();
-			}
-		}
-	}
-}
-
-inline std::vector<float> sfml_get_float_input(sf::RenderWindow *window) {
-
-	std::stringstream ss;
-
-	sf::Event event;
-	while (true) {
-
-		if (window->pollEvent(event)) {
-
-			if (event.type == sf::Event::TextEntered) {
-				if (event.text.unicode > 47 && event.text.unicode < 58 || event.text.unicode == 32)
-					ss << static_cast<char>(event.text.unicode);
-			}
-
-			else if (event.type == sf::Event::KeyPressed) {
-
-				if (event.key.code == sf::Keyboard::Return) {
-					break;
-				}
-			}
-		}
-	}
-
-	std::istream_iterator<std::string> begin(ss);
-	std::istream_iterator<std::string> end;
-	std::vector<std::string> vstrings(begin, end);
-
-	std::vector<float> ret;
-
-	for (auto i: vstrings) {
-		ret.push_back(std::stof(i));
-	}
-
-	return ret;
-
-}
-
-inline int count_bits(int32_t v) {
-	
-	v = v - ((v >> 1) & 0x55555555);                       // reuse input as temporary
-	v = (v & 0x33333333) + ((v >> 2) & 0x33333333);        // temp
-	return (((v + (v >> 4)) & 0xF0F0F0F) * 0x1010101) >> 24; // count
-}
-
-inline int count_bits(int64_t v) {
-
-	int32_t left = (int32_t)(v);
-	int32_t right = (int32_t)(v >> 32);
-
-	left = left - ((left >> 1) & 0x55555555);                    // reuse input as temporary
-	left = (left & 0x33333333) + ((left >> 2) & 0x33333333);     // temp
-	left = ((left + (left >> 4) & 0xF0F0F0F) * 0x1010101) >> 24; // count
-
-	right = right - ((right >> 1) & 0x55555555);                    // reuse input as temporary
-	right = (right & 0x33333333) + ((right >> 2) & 0x33333333);     // temp
-	right = ((right + (right >> 4) & 0xF0F0F0F) * 0x1010101) >> 24; // count
-
-	return left + right;
+#pragma once
+#include <SFML/Graphics.hpp>
+#include "Vector4.hpp"
+#include <math.h>
+#include <string.h>
+#include <bitset>
+#include <iostream>
+#include <fstream>
+#include <sstream>
+#include <string>
+#include <iterator>
+#include <list>
+#include <algorithm>
+#include <imgui/imgui.h>
+
+const double PI = 3.141592653589793238463;
+const float  PI_F = 3.14159265358979f;
+struct fps_counter {
+public:
+	fps_counter() {};
+
+	void frame(double delta_time) {
+		// Apply 100 units of smoothing
+		if (frame_count == 100) {
+			frame_count = 0;
+			fps_average = 0;
+		}
+		frame_count++;
+		fps_average += (delta_time - fps_average) / frame_count;
+	}
+
+	void draw() {
+
+		if (arr_pos == 200)
+			arr_pos = 0;
+
+		fps_array[arr_pos] = (1.0 / fps_average);
+		arr_pos++;
+
+		ImGui::Begin("Performance");
+		ImGui::PlotLines("FPS", fps_array, 200, 0, std::to_string(1.0 / fps_average).c_str(), 0.0f, 150.0f, ImVec2(0, 80));
+		ImGui::End();
+	}
+
+private:
+
+	float fps_array[200]{60};
+	int arr_pos = 0;
+
+	int frame_count = 0;
+	double fps_average = 0;
+
+};
+
+struct debug_text {
+public:
+	debug_text(int slot, int pixel_spacing, void* data_, std::string prefix_) : data(data_), prefix(prefix_) {
+		if (!f.loadFromFile("../assets/fonts/Arial.ttf")) {
+			std::cout << "couldn't find the fall back Arial font in ../assets/fonts/" << std::endl;
+		}
+		else {
+			t.setFont(f);
+			t.setCharacterSize(20);
+			t.setPosition(static_cast<float>(20), static_cast<float>(slot * pixel_spacing));
+		}
+
+	}
+
+	void draw(sf::RenderWindow *r) {
+		t.setString(prefix + std::to_string(*(float*)data));
+		r->draw(t);
+	}
+
+private:
+	void* data;
+	std::string prefix;
+	sf::Font f;
+	sf::Text t;
+
+};
+
+inline sf::Vector3f SphereToCart(sf::Vector2f i) {
+
+	auto r = sf::Vector3f(
+		(1 * sin(i.y) * cos(i.x)),
+		(1 * sin(i.y) * sin(i.x)),
+		(1 * cos(i.y))
+		);
+	return r;
+};
+
+inline sf::Vector3f SphereToCart(sf::Vector3f i) {
+
+	auto r = sf::Vector3f(
+		(i.x * sin(i.z) * cos(i.y)),
+		(i.x * sin(i.z) * sin(i.y)),
+		(i.x * cos(i.z))
+		);
+	return r;
+};
+
+
+inline sf::Vector3f CartToSphere(sf::Vector3f in) {
+
+	auto r = sf::Vector3f(
+		sqrt(in.x * in.x + in.y * in.y + in.z * in.z),
+		atan(in.y / in.x),
+		atan(sqrt(in.x * in.x + in.y * in.y) / in.z)
+		);
+	return r;
+};
+
+inline sf::Vector2f CartToNormalizedSphere(sf::Vector3f in) {
+
+	auto r = sf::Vector2f(
+		atan2(sqrt(in.x * in.x + in.y * in.y), in.z), 
+		atan2(in.y, in.x)
+		);
+	
+	return r;
+}
+
+inline sf::Vector3f FixOrigin(sf::Vector3f base, sf::Vector3f head) {
+	return head - base;
+}
+
+
+inline sf::Vector3f Normalize(sf::Vector3f in) {
+	
+	float multiplier = sqrt(in.x * in.x + in.y * in.y + in.z * in.z);
+	auto r = sf::Vector3f(
+		in.x / multiplier,
+		in.y / multiplier,
+		in.z / multiplier
+	);
+	return r;
+
+}
+
+
+inline float DotProduct(sf::Vector3f a, sf::Vector3f b){
+	return a.x * b.x + a.y * b.y + a.z * b.z;
+}
+
+inline float Magnitude(sf::Vector3f in){
+	return sqrt(in.x * in.x + in.y * in.y + in.z * in.z);
+}
+
+inline float AngleBetweenVectors(sf::Vector3f a, sf::Vector3f b){
+	return acos(DotProduct(a, b) / (Magnitude(a) * Magnitude(b)));
+}
+
+inline float DistanceBetweenPoints(sf::Vector3f a, sf::Vector3f b) {
+	return sqrt(DotProduct(a, b));
+}
+
+inline float DegreesToRadians(float in) {
+	return static_cast<float>(in * PI / 180.0f);
+}
+
+inline float RadiansToDegrees(float in) {
+	return static_cast<float>(in * 180.0f / PI);
+}
+
+inline std::string read_file(std::string file_name){
+	std::ifstream input_file(file_name);
+
+	if (!input_file.is_open()){
+		std::cout << file_name << " could not be opened" << std::endl;
+		return "";
+	}
+
+	std::stringstream buf;
+	buf << input_file.rdbuf();
+	input_file.close();
+	return buf.str();
+}
+
+inline void PrettyPrintUINT64(uint64_t i, std::stringstream* ss) {
+
+	*ss << "[" << std::bitset<15>(i) << "]";
+	*ss << "[" << std::bitset<1>(i >> 15) << "]";
+	*ss << "[" << std::bitset<8>(i >> 16) << "]";
+	*ss << "[" << std::bitset<8>(i >> 24) << "]";
+	*ss << "[" << std::bitset<32>(i >> 32) << "]";
+
+}
+
+inline void PrettyPrintUINT64(uint64_t i) {
+
+	std::cout << "[" << std::bitset<15>(i) << "]";
+	std::cout << "[" << std::bitset<1>(i >> 15) << "]";
+	std::cout << "[" << std::bitset<8>(i >> 16) << "]";
+	std::cout << "[" << std::bitset<8>(i >> 24) << "]";
+	std::cout << "[" << std::bitset<32>(i >> 32) << "]" << std::endl;
+
+}
+
+inline void DumpLog(std::stringstream* ss, std::string file_name) {
+	
+	std::ofstream log_file;
+	log_file.open(file_name);
+
+	log_file << ss->str();
+
+	log_file.close();
+
+}
+
+inline std::string sfml_get_input(sf::RenderWindow *window) {
+	
+	std::stringstream ss;
+
+	sf::Event event;
+	while (window->pollEvent(event)) {
+		if (event.type == sf::Event::TextEntered) {
+			ss << event.text.unicode;
+		} 
+		
+		else if (event.type == sf::Event::KeyPressed) {
+			if (event.key.code == sf::Keyboard::Return) {
+				return ss.str();
+			}
+		}
+	}
+}
+
+inline std::vector<float> sfml_get_float_input(sf::RenderWindow *window) {
+
+	std::stringstream ss;
+
+	sf::Event event;
+	while (true) {
+
+		if (window->pollEvent(event)) {
+
+			if (event.type == sf::Event::TextEntered) {
+				if (event.text.unicode > 47 && event.text.unicode < 58 || event.text.unicode == 32)
+					ss << static_cast<char>(event.text.unicode);
+			}
+
+			else if (event.type == sf::Event::KeyPressed) {
+
+				if (event.key.code == sf::Keyboard::Return) {
+					break;
+				}
+			}
+		}
+	}
+
+	std::istream_iterator<std::string> begin(ss);
+	std::istream_iterator<std::string> end;
+	std::vector<std::string> vstrings(begin, end);
+
+	std::vector<float> ret;
+
+	for (auto i: vstrings) {
+		ret.push_back(std::stof(i));
+	}
+
+	return ret;
+
+}
+
+inline int count_bits(int32_t v) {
+	
+	v = v - ((v >> 1) & 0x55555555);                       // reuse input as temporary
+	v = (v & 0x33333333) + ((v >> 2) & 0x33333333);        // temp
+	return (((v + (v >> 4)) & 0xF0F0F0F) * 0x1010101) >> 24; // count
+}
+
+inline int count_bits(int64_t v) {
+
+	int32_t left = (int32_t)(v);
+	int32_t right = (int32_t)(v >> 32);
+
+	left = left - ((left >> 1) & 0x55555555);                    // reuse input as temporary
+	left = (left & 0x33333333) + ((left >> 2) & 0x33333333);     // temp
+	left = ((left + (left >> 4) & 0xF0F0F0F) * 0x1010101) >> 24; // count
+
+	right = right - ((right >> 1) & 0x55555555);                    // reuse input as temporary
+	right = (right & 0x33333333) + ((right >> 2) & 0x33333333);     // temp
+	right = ((right + (right >> 4) & 0xF0F0F0F) * 0x1010101) >> 24; // count
+
+	return left + right;
 }
\ No newline at end of file
diff --git a/src/Old_Map.cpp b/src/Old_Map.cpp
index 4d383a5..9ff9b9e 100644
--- a/src/Old_Map.cpp
+++ b/src/Old_Map.cpp
@@ -1,7 +1,7 @@
 #include <iostream>
 #include <SFML/System/Vector3.hpp>
 #include <SFML/System/Vector2.hpp>
-#include "util.hpp"
+#include "util.cpp"
 #include <Old_Map.h>
 #include <algorithm>
 
diff --git a/src/Ray.cpp b/src/Ray.cpp
index 1709da7..31820bc 100644
--- a/src/Ray.cpp
+++ b/src/Ray.cpp
@@ -2,7 +2,7 @@
 #include <iostream>
 #include "Map.h"
 #include <Ray.h>
-#include "util.hpp"
+#include "util.cpp"
 
 Ray::Ray(
         Map *map,
diff --git a/src/main.cpp b/src/main.cpp
index 8c35ab0..32077ec 100644
--- a/src/main.cpp
+++ b/src/main.cpp
@@ -23,12 +23,12 @@
 #endif
 
 #pragma once
+#include "util.cpp"
 #include <iostream>
 #include <chrono>
 #include <SFML/Graphics.hpp>
 #include <SFML/Network.hpp>
 #include "Old_Map.h"
-#include "util.hpp"
 #include "raycaster/RayCaster.h"
 #include "raycaster/Hardware_Caster.h"
 #include "Vector4.hpp"
@@ -41,6 +41,7 @@
 #include "imgui/imgui-SFML.h"
 #include "imgui/imgui.h"
 
+
 const int WINDOW_X = 1440;
 const int WINDOW_Y = 900;
 const int WORK_SIZE = WINDOW_X * WINDOW_Y;
@@ -236,48 +237,23 @@ int main() {
             // ==== DELTA TIME LOCKED ====
         }
 
+		// ==== FPS LOCKED ====
 
 		ImGui::SFML::Update(window, sf_delta_clock.restart());
-
-
-		ImGui::Begin("Sample window"); // begi
-		ImGui::InputText("Window title", "asdfoij", 255);
-
-		float values[] = { 0, 1, 2, 3, 4, 5 };
-		ImGui::PlotLines("graph", values, 6);
-		if (ImGui::Button("Print")) {
-			std::cout << "print" << std::endl;
-		}
-
-		ImGui::End(); // end window
-
-
-        // ==== FPS LOCKED ====
 		camera->update(delta_time);
 		handle->update(delta_time);
 
-		window.clear(sf::Color::Black);
-
 		// Run the raycast
 		raycaster->compute();
-		raycaster->draw(&window);
 
-		ImGui::Render();
 
-		//window.popGLStates();
+		window.clear(sf::Color::Black);
 
-		//glPolygonMode(GL_FRONT_AND_BACK, GL_LINE);
-		//t.rotate(delta_time);
-		//t.transform();
-		//t.draw();
-		
-		//glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
-		
-		//window.pushGLStates();
+		raycaster->draw(&window);
 
 		// Give the frame counter the frame time and draw the average frame time
 		fps.frame(delta_time);
-		fps.draw(&window);
+		fps.draw();
 
 		cam_text_x.draw(&window);
 		cam_text_y.draw(&window);
@@ -286,6 +262,7 @@ int main() {
 		cam_text_pos_y.draw(&window);
 		cam_text_pos_z.draw(&window);
 
+		ImGui::Render();
 		window.display();
 
 	}
diff --git a/src/raycaster/Hardware_Caster.cpp b/src/raycaster/Hardware_Caster.cpp
index 4244d14..d774b1b 100644
--- a/src/raycaster/Hardware_Caster.cpp
+++ b/src/raycaster/Hardware_Caster.cpp
@@ -1,6 +1,4 @@
 #include "raycaster/Hardware_Caster.h"
-#include <raycaster/RayCaster.h>
-#include "LightController.h"
 
 Hardware_Caster::Hardware_Caster() {
 
@@ -15,23 +13,23 @@ int Hardware_Caster::init() {
 	// Initialize opencl up to the point where we start assigning buffers
 
 	error = acquire_platform_and_device();
-	if(assert(error, "aquire_platform_and_device"))
+	if(vr_assert(error, "aquire_platform_and_device"))
 		return error;
 
 	error = check_cl_khr_gl_sharing();
-	if(assert(error, "check_cl_khr_gl_sharing"))
+	if(vr_assert(error, "check_cl_khr_gl_sharing"))
 		return error;
 
 	error = create_shared_context();
-	if (assert(error, "create_shared_context"))
+	if (vr_assert(error, "create_shared_context"))
 		return error;
 
 	error = create_command_queue();
-	if (assert(error, "create_command_queue"))
+	if (vr_assert(error, "create_command_queue"))
 		return error;
 
 	error = compile_kernel("../kernels/ray_caster_kernel.cl", true, "raycaster");
-	if (assert(error, "compile_kernel")) {
+	if (vr_assert(error, "compile_kernel")) {
 		std::cin.get(); // hang the output window so we can read the error
 		return error;
 	}
@@ -216,7 +214,7 @@ void Hardware_Caster::draw(sf::RenderWindow* window) {
 int Hardware_Caster::debug_quick_recompile()
 {
 	int error = compile_kernel("../kernels/ray_caster_kernel.cl", true, "raycaster");
-	if (assert(error, "compile_kernel")) {
+	if (vr_assert(error, "compile_kernel")) {
 		std::cin.get(); // hang the output window so we can read the error
 		return error;
 	}
@@ -306,7 +304,7 @@ int Hardware_Caster::acquire_platform_and_device() {
 		std::vector<cl_device_id> deviceIds(deviceIdCount);
 		error = clGetDeviceIDs(plt_buf[i], CL_DEVICE_TYPE_ALL, deviceIdCount, deviceIds.data(), NULL);
 
-		if (assert(error, "clGetDeviceIDs"))
+		if (vr_assert(error, "clGetDeviceIDs"))
 			return OPENCL_ERROR;
 
 		for (unsigned int q = 0; q < deviceIdCount; q++) {
@@ -409,7 +407,7 @@ int Hardware_Caster::create_shared_context() {
 		&error
 		);
 
-	if (assert(error, "clCreateContext"))
+	if (vr_assert(error, "clCreateContext"))
 		return OPENCL_ERROR;
 
 	return 1;
@@ -422,7 +420,7 @@ int Hardware_Caster::create_command_queue() {
 		
 		command_queue = clCreateCommandQueue(context, device_id, 0, &error);
 
-		if (assert(error, "clCreateCommandQueue"))
+		if (vr_assert(error, "clCreateCommandQueue"))
 			return OPENCL_ERROR;
 
 		return 1;
@@ -477,7 +475,7 @@ int Hardware_Caster::compile_kernel(std::string kernel_source, bool is_path, std
 		);
 
 	// This is not for compilation, it only loads the source
-	if (assert(error, "clCreateProgramWithSource"))
+	if (vr_assert(error, "clCreateProgramWithSource"))
 		return OPENCL_ERROR;
 
 
@@ -485,7 +483,7 @@ int Hardware_Caster::compile_kernel(std::string kernel_source, bool is_path, std
 	error = clBuildProgram(program, 1, &device_id, NULL, NULL, NULL);
 
 	// Check to see if it errored out
-	if (assert(error, "clBuildProgram")) {
+	if (vr_assert(error, "clBuildProgram")) {
 
 		// Get the size of the queued log
 		size_t log_size;
@@ -502,7 +500,7 @@ int Hardware_Caster::compile_kernel(std::string kernel_source, bool is_path, std
 	// Done initializing the kernel
 	cl_kernel kernel = clCreateKernel(program, kernel_name.c_str(), &error);
 
-	if (assert(error, "clCreateKernel"))
+	if (vr_assert(error, "clCreateKernel"))
 		return OPENCL_ERROR;
 
 	// Do I want these to overlap when repeated??
@@ -523,7 +521,7 @@ int Hardware_Caster::set_kernel_arg(
 		sizeof(cl_mem),
 		(void *)&buffer_map.at(buffer_name));
 
-	if (assert(error, "clSetKernelArg")){
+	if (vr_assert(error, "clSetKernelArg")){
 		std::cout << buffer_name << std::endl;
 		std::cout << buffer_map.at(buffer_name) << std::endl;
 		return OPENCL_ERROR;
@@ -545,7 +543,7 @@ int Hardware_Caster::create_image_buffer(std::string buffer_name, cl_uint size,
 		getContext(), access_type, GL_TEXTURE_2D,
 		0, texture->getNativeHandle(), &error);
 
-	if (assert(error, "clCreateFromGLTexture"))
+	if (vr_assert(error, "clCreateFromGLTexture"))
 		return OPENCL_ERROR;
 
 	store_buffer(buff, buffer_name);
@@ -566,7 +564,7 @@ int Hardware_Caster::create_buffer(std::string buffer_name, cl_uint size, void*
 		size, data, &error
 		);
 
-	if (assert(error, "clCreateBuffer"))
+	if (vr_assert(error, "clCreateBuffer"))
 		return OPENCL_ERROR;
 
 	store_buffer(buff, buffer_name);
@@ -588,7 +586,7 @@ int Hardware_Caster::create_buffer(std::string buffer_name, cl_uint size, void*
 		size, data, &error
 		);
 
-	if (assert(error, "clCreateBuffer"))
+	if (vr_assert(error, "clCreateBuffer"))
 		return OPENCL_ERROR;
 
 	store_buffer(buff, buffer_name);
@@ -603,7 +601,7 @@ int Hardware_Caster::release_buffer(std::string buffer_name) {
 		
 		int error = clReleaseMemObject(buffer_map.at(buffer_name));
 		
-		if (assert(error, "clReleaseMemObject")) {
+		if (vr_assert(error, "clReleaseMemObject")) {
 			std::cout << "Error releasing buffer : " << buffer_name;
 			std::cout << "Buffer not removed";
 			return -1;
@@ -634,7 +632,7 @@ int Hardware_Caster::run_kernel(std::string kernel_name, const int work_size) {
 	cl_kernel kernel = kernel_map.at(kernel_name);
 
 	error = clEnqueueAcquireGLObjects(getCommandQueue(), 1, &buffer_map.at("image"), 0, 0, 0);
-	if (assert(error, "clEnqueueAcquireGLObjects"))
+	if (vr_assert(error, "clEnqueueAcquireGLObjects"))
 		return OPENCL_ERROR;
 
 	//error = clEnqueueTask(command_queue, kernel, 0, NULL, NULL);
@@ -643,14 +641,14 @@ int Hardware_Caster::run_kernel(std::string kernel_name, const int work_size) {
 		1, NULL, global_work_size,
 		NULL, 0, NULL, NULL);
 
-	if (assert(error, "clEnqueueNDRangeKernel"))
+	if (vr_assert(error, "clEnqueueNDRangeKernel"))
 		return OPENCL_ERROR;
 
 	clFinish(getCommandQueue());
 
 	// What if errors out and gl objects are never released?
 	error = clEnqueueReleaseGLObjects(getCommandQueue(), 1, &buffer_map.at("image"), 0, NULL, NULL);
-	if (assert(error, "clEnqueueReleaseGLObjects"))
+	if (vr_assert(error, "clEnqueueReleaseGLObjects"))
 		return OPENCL_ERROR;
 
 	return 1;
@@ -678,7 +676,7 @@ cl_context Hardware_Caster::getContext() { return context; };
 cl_kernel Hardware_Caster::getKernel(std::string kernel_name) { return kernel_map.at(kernel_name); };
 cl_command_queue Hardware_Caster::getCommandQueue() { return command_queue; };
 
-bool Hardware_Caster::assert(int error_code, std::string function_name) {
+bool Hardware_Caster::vr_assert(int error_code, std::string function_name) {
 
 	// Just gonna do a little jump table here, just error codes so who cares
 	std::string err_msg = "Error : ";