diff --git a/include/CL_Wrapper.h b/include/CL_Wrapper.h
index 08b8f5e..682f10b 100644
--- a/include/CL_Wrapper.h
+++ b/include/CL_Wrapper.h
@@ -22,11 +22,11 @@
 #endif
 
 struct device {
-    cl_device_id id;
-    cl_device_type type;
-    cl_uint clock_frequency;
-    char version[128];
-    cl_platform_id platform;
+	cl_device_id id;
+	cl_device_type type;
+	cl_uint clock_frequency;
+	char version[128];
+	cl_platform_id platform;
 	cl_uint comp_units;
 };
 
diff --git a/include/Hardware_Caster.h b/include/Hardware_Caster.h
new file mode 100644
index 0000000..6db4c76
--- /dev/null
+++ b/include/Hardware_Caster.h
@@ -0,0 +1,104 @@
+#pragma once
+#include <RayCaster.h>
+#include <vector>
+#include <iostream>
+#include "util.hpp"
+#include <map>
+#include <string.h>
+
+#ifdef linux
+#include <CL/cl.h>
+#include <CL/opencl.h>
+#include <GL/glx.h>
+
+#elif defined _WIN32
+#include <CL/cl_gl.h>
+#include <CL/cl.h>
+#include <CL/opencl.h>
+#include <GL/GL.h>
+#include <windows.h>
+
+#elif defined TARGET_OS_MAC
+# include <OpenGL/OpenGL.h>
+# include <OpenCL/opencl.h>
+
+#endif
+
+struct device {
+	cl_device_id id;
+	cl_device_type type;
+	cl_uint clock_frequency;
+	char version[128];
+	cl_platform_id platform;
+	cl_uint comp_units;
+};
+
+class Hardware_Caster : public RayCaster
+{
+public:
+	Hardware_Caster();
+
+	virtual ~Hardware_Caster();
+
+	int init();
+
+	// In interop mode, this will create a gl texture that we share
+	// Otherwise, it will create the pixel buffer and pass that in as an image, retreiving it each draw
+	// Both will create the view matrix, view res buffer
+	void create_viewport(int width, int height, float v_fov, float h_fov);
+
+	void assign_light(Light light);
+	void assign_map(Old_Map *map);
+	void assign_camera(Camera *camera);
+
+	// draw will abstract the gl sharing and software rendering
+	// methods of retrieving the screen buffer
+	void draw(sf::RenderWindow* window) = 0;
+
+private:
+
+
+	int acquire_platform_and_device();
+
+	int create_shared_context();
+
+	int create_command_queue();
+
+	int check_cl_khr_gl_sharing();
+
+	int create_image_buffer(std::string buffer_name, cl_uint size, void* data);
+	int create_buffer(std::string buffer_name, cl_uint size, void* data);
+	int create_buffer(std::string buffer_name, cl_uint size, void* data, cl_mem_flags flags);
+	int store_buffer(cl_mem, std::string buffer_name);
+	int release_buffer(std::string buffer_name);
+	
+	int compile_kernel(std::string kernel_source, bool is_path, std::string kernel_name);
+
+	int set_kernel_arg(std::string kernel_name, int index, std::string buffer_name);
+
+	int run_kernel(std::string kernel_name, const int work_size);
+
+	bool assert(int error_code, std::string function_name);
+
+	cl_device_id getDeviceID();
+	cl_platform_id getPlatformID();
+	cl_context getContext();
+	cl_kernel getKernel(std::string kernel_name);
+	cl_command_queue getCommandQueue();
+
+	bool was_init_valid();
+
+	int error = 0;
+	bool initialized = false;
+	bool cl_khr_gl_sharing_fallback = false;
+	bool cl_supported = false;
+
+	cl_platform_id platform_id;
+	cl_device_id device_id;
+	cl_context context;
+	cl_command_queue command_queue;
+
+	std::map<std::string, cl_kernel> kernel_map;
+	std::map<std::string, cl_mem> buffer_map;
+};
+
diff --git a/include/Old_map.h b/include/Old_map.h
index 4740b2c..bbb9069 100644
--- a/include/Old_map.h
+++ b/include/Old_map.h
@@ -18,7 +18,6 @@ public:
 	Old_Map(sf::Vector3i dim);
 	~Old_Map();
 
-	void generate_from_data(char* dat, int len);
 	void generate_terrain();
 
 	sf::Vector3i getDimensions();
diff --git a/include/RayCaster.h b/include/RayCaster.h
index eb9dc78..a627107 100644
--- a/include/RayCaster.h
+++ b/include/RayCaster.h
@@ -3,30 +3,40 @@
 #include <SFML/System/Vector2.hpp>
 #include <Map.h>
 #include "Old_map.h"
+#include "Camera.h"
 
 
-// What about a parent, child relationship between the raycaster and it's two
-// different modes? Raycaster -> ClCaster, SoftwareCaster
-class Camera;
-
 class RayCaster {
 public:
 
+	enum ERROR_CODES {
+		SHARING_NOT_SUPPORTED = 800,
+		OPENCL_NOT_SUPPORTED = 801,
+		OPENCL_ERROR = 802,
+		ERROR = 803
+	};
+
 	RayCaster();
-	~RayCaster();
+	virtual ~RayCaster();
+
+	virtual int init() = 0;
 
 	virtual void assign_map(Old_Map *map) = 0;
 	virtual void assign_camera(Camera *camera) = 0;
-	virtual void assign_viewport(int width, int height, float v_fov, float h_fov) = 0;
+	virtual void create_viewport(int width, int height, float v_fov, float h_fov) = 0;
 	virtual void assign_light(Light light) = 0;
 
 	// draw will abstract the gl sharing and software rendering
 	// methods of retrieving the screen buffer
 	virtual void draw(sf::RenderWindow* window) = 0;
 
-private:
+protected:
 
-	sf::Vector3<int> map_dimensions;
+	sf::Sprite viewport_sprite;
+	sf::Texture viewport_texture;
+	
+
+	// A reference to the map
 	Old_Map *map;
 
 	// The XY resolution of the viewport
@@ -38,7 +48,6 @@ private:
 	// The direction of the camera in POLAR coordinates
 	sf::Vector3<float> camera_direction;
 
-
 	// Convert the polar coordinates to CARTESIAN
 	sf::Vector3<float> camera_direction_cartesian;
 
diff --git a/include/Renderer.cpp b/include/Renderer.cpp
index 0545cc4..7f119da 100644
--- a/include/Renderer.cpp
+++ b/include/Renderer.cpp
@@ -9,12 +9,12 @@ Renderer::Renderer() {
 	}
 }
 
-void Renderer::register_camera(Camera *camera)
-{
-
+void Renderer::register_camera(Camera *camera) {
+	this->camera = camera;
 }
 
-void Renderer::draw()
-{
+void Renderer::draw() {
 
 }
+
+
diff --git a/include/Renderer.h b/include/Renderer.h
index b7fb543..6b1773f 100644
--- a/include/Renderer.h
+++ b/include/Renderer.h
@@ -35,7 +35,7 @@ public:
 	void register_map(Old_Map* map);
 	void register_lights();
 	void create_viewport(float v_fov, float h_fov, int height, int width);
-	void register_light(light l);
+	void register_light(Light l);
 
     void draw();
     sf::RenderWindow* get_window();
@@ -51,7 +51,7 @@ private:
 	sf::Uint8 *drawing_surface;
     sf::RenderWindow* window;
 
-	std::vector<light> lights;
+	std::vector<Light> lights;
 	Old_Map* map;
 	Camera* camera;
 	sf::Uint8 *view_matrix;
diff --git a/src/CL_Wrapper.cpp b/src/CL_Wrapper.cpp
index af2cf84..3790f3b 100644
--- a/src/CL_Wrapper.cpp
+++ b/src/CL_Wrapper.cpp
@@ -5,9 +5,10 @@ CL_Wrapper::CL_Wrapper() {
 	// Check to see if acquiring the platform failed out
 	// This also catches when there are general errors,
 	// falling back to the known good software renderer
+
 	if (acquire_platform_and_device() == -1) {
 		std::cout << "Falling back to the software renderer" << std::endl;
-		return;
+		
 	}
 	
 	cl_supported = true;
@@ -390,6 +391,9 @@ bool CL_Wrapper::assert(int error_code, std::string function_name){
 
         case CL_SUCCESS:
             return false;
+		
+		case 1:
+			return false;
 
         case CL_DEVICE_NOT_FOUND:
             err_msg += "CL_DEVICE_NOT_FOUND";
diff --git a/src/Hardware_Caster.cpp b/src/Hardware_Caster.cpp
new file mode 100644
index 0000000..7aabbd6
--- /dev/null
+++ b/src/Hardware_Caster.cpp
@@ -0,0 +1,733 @@
+#include "Hardware_Caster.h"
+
+
+
+Hardware_Caster::Hardware_Caster() {
+	
+}
+
+
+Hardware_Caster::~Hardware_Caster() {
+}
+
+int Hardware_Caster::init() {
+
+	// Initialize opencl up to the point where we start assigning buffers
+
+	int error = 0;
+
+	error = acquire_platform_and_device();
+	if(assert(error, "aquire_platform_and_device"))
+		return error;
+
+	error = check_cl_khr_gl_sharing();
+	if(assert(error, "check_cl_khr_gl_sharing"))
+		return error;
+
+	error = create_shared_context();
+	if (assert(error, "create_shared_context"))
+		return error;
+
+	error = create_command_queue();
+	if (assert(error, "create_command_queue"))
+		return error;
+
+	error = compile_kernel("../kernels/ray_caster_kernel.cl", true, "min_kern");
+	if (assert(error, "compile_kernel")) {
+		std::cin.get(); // hang the output window so we can read the error
+		return error;
+	}
+
+	return 1;
+
+}
+
+void Hardware_Caster::assign_map(Old_Map *map) {
+
+	auto dimensions = map->getDimensions();
+	
+	create_buffer("map_buffer", sizeof(char) * dimensions.x * dimensions.y * dimensions.z, map->get_voxel_data());
+	create_buffer("dim_buffer", sizeof(int) * 3, &dimensions);
+
+}
+
+void Hardware_Caster::assign_camera(Camera *camera) {
+
+	create_buffer("cam_dir_buffer", sizeof(float) * 4, (void*)camera->get_direction_pointer(), CL_MEM_READ_ONLY | CL_MEM_USE_HOST_PTR);
+	create_buffer("cam_pos_buffer", sizeof(float) * 4, (void*)camera->get_position_pointer(), CL_MEM_READ_ONLY | CL_MEM_USE_HOST_PTR);
+}
+
+// There is a possibility that I would want to move this over to be all inside it's own
+// container to make it so it can be changed via CL_MEM_USE_HOST_PTR. But I doubt it
+// would ever be called enough to warrent that
+void Hardware_Caster::create_viewport(int width, int height, float v_fov, float h_fov) {
+	
+	// CL needs the screen resolution
+	sf::Vector2i view_res(width, height);
+	create_buffer("res_buffer", sizeof(int) * 2, &view_res);
+
+	// And an array of vectors describing the way the "lens" of our
+	// camera works
+
+	// This could be modified to make some odd looking camera lenses
+
+	double y_increment_radians = DegreesToRadians(v_fov / view_res.y);
+	double x_increment_radians = DegreesToRadians(h_fov / view_res.x);
+
+	sf::Vector4f* view_matrix = new sf::Vector4f[width * height * 4];
+
+	for (int y = -view_res.y / 2; y < view_res.y / 2; y++) {
+		for (int x = -view_res.x / 2; x < view_res.x / 2; x++) {
+
+			// The base ray direction to slew from
+			sf::Vector3f ray(1, 0, 0);
+
+			// Y axis, pitch
+			ray = sf::Vector3f(
+				static_cast<float>(ray.z * sin(y_increment_radians * y) + ray.x * cos(y_increment_radians * y)),
+				static_cast<float>(ray.y),
+				static_cast<float>(ray.z * cos(y_increment_radians * y) - ray.x * sin(y_increment_radians * y))
+			);
+
+
+			// Z axis, yaw
+			ray = sf::Vector3f(
+				static_cast<float>(ray.x * cos(x_increment_radians * x) - ray.y * sin(x_increment_radians * x)),
+				static_cast<float>(ray.x * sin(x_increment_radians * x) + ray.y * cos(x_increment_radians * x)),
+				static_cast<float>(ray.z)
+			);
+
+			int index = (x + view_res.x / 2) + view_res.x * (y + view_res.y / 2);
+			ray = Normalize(ray);
+
+			view_matrix[index] = sf::Vector4f(
+				ray.x,
+				ray.y,
+				ray.z,
+				0
+			);
+		}
+	}
+
+	create_buffer("view_matrix_buffer", sizeof(float) * 4 * view_res.x * view_res.y, view_matrix);
+
+	// Create the image that opencl's rays write to
+	unsigned char* pixel_array = new sf::Uint8[width * height * 4];
+
+	for (int i = 0; i < width * height * 4; i += 4) {
+
+		pixel_array[i] = 255;     // R
+		pixel_array[i + 1] = 255; // G
+		pixel_array[i + 2] = 255; // B
+		pixel_array[i + 3] = 100; // A
+	}
+
+	// Interop lets us keep a reference to it as a texture
+	viewport_texture.create(width, height);
+	viewport_texture.update(pixel_array);
+	viewport_sprite.setTexture(viewport_texture);
+
+	// Pass the buffer to opencl
+	create_image_buffer("image_buffer", sizeof(sf::Uint8) * width * height * 4, pixel_array);
+
+}
+
+void Hardware_Caster::assign_light(Light light) {
+
+}
+
+void Hardware_Caster::draw(sf::RenderWindow* window) {
+
+}
+
+int Hardware_Caster::acquire_platform_and_device() {
+
+	// Get the number of platforms
+	cl_uint plt_cnt = 0;
+	clGetPlatformIDs(0, nullptr, &plt_cnt);
+
+	// Fetch the platforms
+	std::map<cl_platform_id, std::vector<device>> plt_ids;
+
+	// buffer before map init
+	std::vector<cl_platform_id> plt_buf(plt_cnt);
+	clGetPlatformIDs(plt_cnt, plt_buf.data(), nullptr);
+
+	// Map init
+	for (auto id : plt_buf) {
+		plt_ids.emplace(std::make_pair(id, std::vector<device>()));
+	}
+
+	// For each platform, populate its devices
+	for (unsigned int i = 0; i < plt_cnt; i++) {
+
+		cl_uint deviceIdCount = 0;
+		error = clGetDeviceIDs(plt_buf[i], CL_DEVICE_TYPE_ALL, 0, nullptr, &deviceIdCount);
+
+		// Check to see if we even have opencl on this machine
+		if (deviceIdCount == 0) {
+			cl_supported = false;
+			std::cout << "There appears to be no platforms supporting opencl" << std::endl;
+			return OPENCL_NOT_SUPPORTED;
+		}
+
+		// Get the device ids
+		std::vector<cl_device_id> deviceIds(deviceIdCount);
+		error = clGetDeviceIDs(plt_buf[i], CL_DEVICE_TYPE_ALL, deviceIdCount, deviceIds.data(), NULL);
+
+		if (assert(error, "clGetDeviceIDs"))
+			return OPENCL_ERROR;
+
+		for (int q = 0; q < deviceIdCount; q++) {
+
+			device d;
+
+			d.id = deviceIds[q];
+
+			clGetDeviceInfo(d.id, CL_DEVICE_PLATFORM, sizeof(cl_platform_id), &d.platform, NULL);
+			clGetDeviceInfo(d.id, CL_DEVICE_VERSION, sizeof(char) * 128, &d.version, NULL);
+			clGetDeviceInfo(d.id, CL_DEVICE_TYPE, sizeof(cl_device_type), &d.type, NULL);
+			clGetDeviceInfo(d.id, CL_DEVICE_MAX_CLOCK_FREQUENCY, sizeof(cl_uint), &d.clock_frequency, NULL);
+			clGetDeviceInfo(d.id, CL_DEVICE_MAX_COMPUTE_UNITS, sizeof(cl_uint), &d.comp_units, NULL);
+
+			plt_ids.at(d.platform).push_back(d);
+		}
+	}
+
+
+	// The devices how now been queried we want to shoot for a gpu with the fastest clock,
+	// falling back to the cpu with the fastest clock if we weren't able to find one
+
+	device current_best_device;
+	current_best_device.type = 0; // Set this to 0 so the first run always selects a new device
+	current_best_device.clock_frequency = 0;
+	current_best_device.comp_units = 0;
+
+
+	for (auto kvp : plt_ids) {
+
+		for (auto device : kvp.second) {
+
+			// Gonna just split this up into cases. There are so many devices I cant test with
+			// that opencl supports. I'm not going to waste my time making a generic implimentation
+
+			// Upon success of a condition, set the current best device values
+
+			if (device.type == CL_DEVICE_TYPE_GPU && current_best_device.type != CL_DEVICE_TYPE_GPU) {
+				current_best_device = device;
+			}
+			else if (device.comp_units > current_best_device.comp_units) {
+				current_best_device = device;
+			}
+			else if (current_best_device.type != CL_DEVICE_TYPE_GPU && device.clock_frequency > current_best_device.clock_frequency) {
+				current_best_device = device;
+			}
+		}
+	}
+
+	platform_id = current_best_device.platform;
+	device_id = current_best_device.id;
+
+	return 1;
+};
+
+int Hardware_Caster::create_shared_context() {
+
+	// Hurray for standards!
+	// Setup the context properties to grab the current GL context
+
+#ifdef linux
+
+	cl_context_properties context_properties[] = {
+		CL_GL_CONTEXT_KHR, (cl_context_properties)glXGetCurrentContext(),
+		CL_GLX_DISPLAY_KHR, (cl_context_properties)glXGetCurrentDisplay(),
+		CL_CONTEXT_PLATFORM, (cl_context_properties)platform_id,
+		0
+	};
+
+#elif defined _WIN32
+
+	HGLRC hGLRC = wglGetCurrentContext();
+	HDC hDC = wglGetCurrentDC();
+	cl_context_properties context_properties[] = {
+		CL_CONTEXT_PLATFORM, (cl_context_properties)platform_id,
+		CL_GL_CONTEXT_KHR, (cl_context_properties)hGLRC,
+		CL_WGL_HDC_KHR, (cl_context_properties)hDC,
+		0
+	};
+
+
+#elif defined TARGET_OS_MAC
+
+	CGLContextObj glContext = CGLGetCurrentContext();
+	CGLShareGroupObj shareGroup = CGLGetShareGroup(glContext);
+	cl_context_properties context_properties[] = {
+		CL_CONTEXT_PROPERTY_USE_CGL_SHAREGROUP_APPLE,
+		(cl_context_properties)shareGroup,
+		0
+	};
+
+#endif
+
+	// Create our shared context
+	context = clCreateContext(
+		context_properties,
+		1,
+		&device_id,
+		nullptr, nullptr,
+		&error
+		);
+
+	if (assert(error, "clCreateContext"))
+		return OPENCL_ERROR;
+
+	return 1;
+}
+
+int Hardware_Caster::create_command_queue() {
+
+	if (context && device_id) {
+		// And the cl command queue
+		command_queue = clCreateCommandQueue(context, device_id, 0, &error);
+
+		if (assert(error, "clCreateCommandQueue"))
+			return OPENCL_ERROR;
+
+		return 1;
+	}
+	else {
+		std::cout << "Failed creating the command queue. Context or device_id not initialized";
+		return OPENCL_ERROR;
+	}
+}
+
+int Hardware_Caster::check_cl_khr_gl_sharing() {
+
+	// Test for sharing
+	size_t ext_str_size = 1024;
+	char *ext_str = new char[ext_str_size];
+	clGetDeviceInfo(device_id, CL_DEVICE_EXTENSIONS, ext_str_size, ext_str, &ext_str_size);
+
+	if (std::string(ext_str).find("cl_khr_gl_sharing") == std::string::npos) {
+		std::cout << "No support for the cl_khr_gl_sharing extension";
+		delete ext_str;
+		return RayCaster::SHARING_NOT_SUPPORTED;
+	}
+
+	delete ext_str;
+	return 1;
+}
+
+int Hardware_Caster::compile_kernel(std::string kernel_source, bool is_path, std::string kernel_name) {
+
+	const char* source;
+	std::string tmp;
+
+	if (is_path) {
+		//Load in the kernel, and c stringify it
+		tmp = read_file(kernel_source);
+		source = tmp.c_str();
+	}
+	else {
+		source = kernel_source.c_str();
+	}
+
+	size_t kernel_source_size = strlen(source);
+
+	// Load the source into CL's data structure
+	cl_program program = clCreateProgramWithSource(
+		context, 1,
+		&source,
+		&kernel_source_size, &error
+		);
+
+	// This is not for compilation, it only loads the source
+	if (assert(error, "clCreateProgramWithSource"))
+		return OPENCL_ERROR;
+
+
+	// Try and build the program
+	error = clBuildProgram(program, 1, &device_id, NULL, NULL, NULL);
+
+	// Check to see if it errored out
+	if (assert(error, "clBuildProgram")) {
+
+		// Get the size of the queued log
+		size_t log_size;
+		clGetProgramBuildInfo(program, device_id, CL_PROGRAM_BUILD_LOG, 0, NULL, &log_size);
+		char *log = new char[log_size];
+
+		// Grab the log
+		clGetProgramBuildInfo(program, device_id, CL_PROGRAM_BUILD_LOG, log_size, log, NULL);
+
+		std::cout << log;
+		return OPENCL_ERROR;
+	}
+
+	// Done initializing the kernel
+	cl_kernel kernel = clCreateKernel(program, kernel_name.c_str(), &error);
+
+	if (assert(error, "clCreateKernel"))
+		return OPENCL_ERROR;
+
+	kernel_map.emplace(std::make_pair(kernel_name, kernel));
+
+	return 1;
+}
+
+int Hardware_Caster::set_kernel_arg(
+	std::string kernel_name,
+	int index,
+	std::string buffer_name) {
+
+	error = clSetKernelArg(
+		kernel_map.at(kernel_name),
+		index,
+		sizeof(cl_mem),
+		(void *)&buffer_map.at(buffer_name));
+
+	if (assert(error, "clSetKernelArg"))
+		return OPENCL_ERROR;
+
+	return 0;
+
+}
+
+int Hardware_Caster::create_image_buffer(std::string buffer_name, cl_uint size, void* data) {
+
+	// I can imagine overwriting buffers will be common, so I think
+	// this is safe to overwrite / release old buffers quietly
+	if (buffer_map.count(buffer_name) > 0) {
+		release_buffer(buffer_name);
+	}
+
+	int error;
+	cl_mem buff = clCreateFromGLTexture(
+		getContext(), CL_MEM_WRITE_ONLY, GL_TEXTURE_2D,
+		0, viewport_texture.getNativeHandle(), &error);
+
+	if (assert(error, "clCreateFromGLTexture"))
+		return OPENCL_ERROR;
+
+	store_buffer(buff, buffer_name);
+
+	return 1;
+}
+
+int Hardware_Caster::create_buffer(std::string buffer_name, cl_uint size, void* data, cl_mem_flags flags) {
+
+	// I can imagine overwriting buffers will be common, so I think
+	// this is safe to overwrite / release old buffers quietly
+	if (buffer_map.count(buffer_name) > 0) {
+		release_buffer(buffer_name);
+	}
+
+	cl_mem buff = clCreateBuffer(
+		getContext(), flags,
+		size, data, &error
+		);
+
+	if (assert(error, "clCreateBuffer"))
+		return OPENCL_ERROR;
+
+	store_buffer(buff, buffer_name);
+
+	return 1;
+
+}
+
+int Hardware_Caster::create_buffer(std::string buffer_name, cl_uint size, void* data) {
+	
+	// I can imagine overwriting buffers will be common, so I think
+	// this is safe to overwrite / release old buffers quietly
+	if (buffer_map.count(buffer_name) > 0) {
+		release_buffer(buffer_name);
+	}
+
+	cl_mem buff = clCreateBuffer(
+		getContext(), CL_MEM_READ_ONLY | CL_MEM_COPY_HOST_PTR,
+		size, data, &error
+		);
+
+	if (assert(error, "clCreateBuffer"))
+		return OPENCL_ERROR;
+
+	store_buffer(buff, buffer_name);
+
+	return 1;
+
+}
+
+int Hardware_Caster::release_buffer(std::string buffer_name) {
+
+	if (buffer_map.count(buffer_name) > 0) {
+		
+		int error = clReleaseMemObject(buffer_map.at(buffer_name));
+		
+		if (assert(error, "clReleaseMemObject")) {
+			std::cout << "Error releasing buffer : " << buffer_name;
+			std::cout << "Buffer not removed";
+			return -1;
+
+		} else {
+			buffer_map.erase(buffer_name);
+		}
+
+	} else {
+		std::cout << "Error releasing buffer : " << buffer_name;
+		std::cout << "Buffer not found";
+		return -1;
+	}
+
+	return 1;
+
+}
+
+int Hardware_Caster::store_buffer(cl_mem buffer, std::string buffer_name) {
+	buffer_map.emplace(std::make_pair(buffer_name, buffer));
+	return 1;
+}
+
+int Hardware_Caster::run_kernel(std::string kernel_name, const int work_size) {
+
+	size_t global_work_size[1] = { static_cast<size_t>(work_size) };
+
+	cl_kernel kernel = kernel_map.at(kernel_name);
+
+	error = clEnqueueAcquireGLObjects(getCommandQueue(), 1, &buffer_map.at("image_buffer"), 0, 0, 0);
+	if (assert(error, "clEnqueueAcquireGLObjects"))
+		return OPENCL_ERROR;
+
+	//error = clEnqueueTask(command_queue, kernel, 0, NULL, NULL);
+	error = clEnqueueNDRangeKernel(
+		command_queue, kernel,
+		1, NULL, global_work_size,
+		NULL, 0, NULL, NULL);
+
+	if (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_buffer"), 0, NULL, NULL);
+	if (assert(error, "clEnqueueReleaseGLObjects"))
+		return OPENCL_ERROR;
+
+	return 1;
+}
+
+cl_device_id Hardware_Caster::getDeviceID() { return device_id; };
+cl_platform_id Hardware_Caster::getPlatformID() { return platform_id; };
+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::was_init_valid() {
+	return cl_supported;
+}
+
+bool Hardware_Caster::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 : ";
+
+	switch (error_code) {
+
+	case CL_SUCCESS:
+		return false;
+
+	case 1:
+		return false;
+
+	case CL_DEVICE_NOT_FOUND:
+		err_msg += "CL_DEVICE_NOT_FOUND";
+		break;
+	case CL_DEVICE_NOT_AVAILABLE:
+		err_msg = "CL_DEVICE_NOT_AVAILABLE";
+		break;
+	case CL_COMPILER_NOT_AVAILABLE:
+		err_msg = "CL_COMPILER_NOT_AVAILABLE";
+		break;
+	case CL_MEM_OBJECT_ALLOCATION_FAILURE:
+		err_msg = "CL_MEM_OBJECT_ALLOCATION_FAILURE";
+		break;
+	case CL_OUT_OF_RESOURCES:
+		err_msg = "CL_OUT_OF_RESOURCES";
+		break;
+	case CL_OUT_OF_HOST_MEMORY:
+		err_msg = "CL_OUT_OF_HOST_MEMORY";
+		break;
+	case CL_PROFILING_INFO_NOT_AVAILABLE:
+		err_msg = "CL_PROFILING_INFO_NOT_AVAILABLE";
+		break;
+	case CL_MEM_COPY_OVERLAP:
+		err_msg = "CL_MEM_COPY_OVERLAP";
+		break;
+	case CL_IMAGE_FORMAT_MISMATCH:
+		err_msg = "CL_IMAGE_FORMAT_MISMATCH";
+		break;
+	case CL_IMAGE_FORMAT_NOT_SUPPORTED:
+		err_msg = "CL_IMAGE_FORMAT_NOT_SUPPORTED";
+		break;
+	case CL_BUILD_PROGRAM_FAILURE:
+		err_msg = "CL_BUILD_PROGRAM_FAILURE";
+		break;
+	case CL_MAP_FAILURE:
+		err_msg = "CL_MAP_FAILURE";
+		break;
+	case CL_MISALIGNED_SUB_BUFFER_OFFSET:
+		err_msg = "CL_MISALIGNED_SUB_BUFFER_OFFSET";
+		break;
+	case CL_EXEC_STATUS_ERROR_FOR_EVENTS_IN_WAIT_LIST:
+		err_msg = "CL_EXEC_STATUS_ERROR_FOR_EVENTS_IN_WAIT_LIST";
+		break;
+	case CL_COMPILE_PROGRAM_FAILURE:
+		err_msg = "CL_COMPILE_PROGRAM_FAILURE";
+		break;
+	case CL_LINKER_NOT_AVAILABLE:
+		err_msg = "CL_LINKER_NOT_AVAILABLE";
+		break;
+	case CL_LINK_PROGRAM_FAILURE:
+		err_msg = "CL_LINK_PROGRAM_FAILURE";
+		break;
+	case CL_DEVICE_PARTITION_FAILED:
+		err_msg = "CL_DEVICE_PARTITION_FAILED";
+		break;
+	case CL_KERNEL_ARG_INFO_NOT_AVAILABLE:
+		err_msg = "CL_KERNEL_ARG_INFO_NOT_AVAILABLE";
+		break;
+	case CL_INVALID_VALUE:
+		err_msg = "CL_INVALID_VALUE";
+		break;
+	case CL_INVALID_DEVICE_TYPE:
+		err_msg = "CL_INVALID_DEVICE_TYPE";
+		break;
+	case CL_INVALID_PLATFORM:
+		err_msg = "CL_INVALID_PLATFORM";
+		break;
+	case CL_INVALID_DEVICE:
+		err_msg = "CL_INVALID_DEVICE";
+		break;
+	case CL_INVALID_CONTEXT:
+		err_msg = "CL_INVALID_CONTEXT";
+		break;
+	case CL_INVALID_QUEUE_PROPERTIES:
+		err_msg = "CL_INVALID_QUEUE_PROPERTIES";
+		break;
+	case CL_INVALID_COMMAND_QUEUE:
+		err_msg = "CL_INVALID_COMMAND_QUEUE";
+		break;
+	case CL_INVALID_HOST_PTR:
+		err_msg = "CL_INVALID_HOST_PTR";
+		break;
+	case CL_INVALID_MEM_OBJECT:
+		err_msg = "CL_INVALID_MEM_OBJECT";
+		break;
+	case CL_INVALID_IMAGE_FORMAT_DESCRIPTOR:
+		err_msg = "CL_INVALID_IMAGE_FORMAT_DESCRIPTOR";
+		break;
+	case CL_INVALID_IMAGE_SIZE:
+		err_msg = "CL_INVALID_IMAGE_SIZE";
+		break;
+	case CL_INVALID_SAMPLER:
+		err_msg = "CL_INVALID_SAMPLER";
+		break;
+	case CL_INVALID_BINARY:
+		err_msg = "CL_INVALID_BINARY";
+		break;
+	case CL_INVALID_BUILD_OPTIONS:
+		err_msg = "CL_INVALID_BUILD_OPTIONS";
+		break;
+	case CL_INVALID_PROGRAM:
+		err_msg = "CL_INVALID_PROGRAM";
+		break;
+	case CL_INVALID_PROGRAM_EXECUTABLE:
+		err_msg = "CL_INVALID_PROGRAM_EXECUTABLE";
+		break;
+	case CL_INVALID_KERNEL_NAME:
+		err_msg = "CL_INVALID_KERNEL_NAME";
+		break;
+	case CL_INVALID_KERNEL_DEFINITION:
+		err_msg = "CL_INVALID_KERNEL_DEFINITION";
+		break;
+	case CL_INVALID_KERNEL:
+		err_msg = "CL_INVALID_KERNEL";
+		break;
+	case CL_INVALID_ARG_INDEX:
+		err_msg = "CL_INVALID_ARG_INDEX";
+		break;
+	case CL_INVALID_ARG_VALUE:
+		err_msg = "CL_INVALID_ARG_VALUE";
+		break;
+	case CL_INVALID_ARG_SIZE:
+		err_msg = "CL_INVALID_ARG_SIZE";
+		break;
+	case CL_INVALID_KERNEL_ARGS:
+		err_msg = "CL_INVALID_KERNEL_ARGS";
+		break;
+	case CL_INVALID_WORK_DIMENSION:
+		err_msg = "CL_INVALID_WORK_DIMENSION";
+		break;
+	case CL_INVALID_WORK_GROUP_SIZE:
+		err_msg = "CL_INVALID_WORK_GROUP_SIZE";
+		break;
+	case CL_INVALID_WORK_ITEM_SIZE:
+		err_msg = "CL_INVALID_WORK_ITEM_SIZE";
+		break;
+	case CL_INVALID_GLOBAL_OFFSET:
+		err_msg = "CL_INVALID_GLOBAL_OFFSET";
+		break;
+	case CL_INVALID_EVENT_WAIT_LIST:
+		err_msg = "CL_INVALID_EVENT_WAIT_LIST";
+		break;
+	case CL_INVALID_EVENT:
+		err_msg = "CL_INVALID_EVENT";
+		break;
+	case CL_INVALID_OPERATION:
+		err_msg = "CL_INVALID_OPERATION";
+		break;
+	case CL_INVALID_GL_OBJECT:
+		err_msg = "CL_INVALID_GL_OBJECT";
+		break;
+	case CL_INVALID_BUFFER_SIZE:
+		err_msg = "CL_INVALID_BUFFER_SIZE";
+		break;
+	case CL_INVALID_MIP_LEVEL:
+		err_msg = "CL_INVALID_MIP_LEVEL";
+		break;
+	case CL_INVALID_GLOBAL_WORK_SIZE:
+		err_msg = "CL_INVALID_GLOBAL_WORK_SIZE";
+		break;
+	case CL_INVALID_PROPERTY:
+		err_msg = "CL_INVALID_PROPERTY";
+		break;
+	case CL_INVALID_IMAGE_DESCRIPTOR:
+		err_msg = "CL_INVALID_IMAGE_DESCRIPTOR";
+		break;
+	case CL_INVALID_COMPILER_OPTIONS:
+		err_msg = "CL_INVALID_COMPILER_OPTIONS";
+		break;
+	case CL_INVALID_LINKER_OPTIONS:
+		err_msg = "CL_INVALID_LINKER_OPTIONS";
+		break;
+	case CL_INVALID_DEVICE_PARTITION_COUNT:
+		err_msg = "CL_INVALID_DEVICE_PARTITION_COUNT";
+		break;
+	case RayCaster::SHARING_NOT_SUPPORTED:
+		err_msg = "SHARING_NOT_SUPPORTED";
+		break;
+	case RayCaster::OPENCL_NOT_SUPPORTED:
+		err_msg = "OPENCL_NOT_SUPPORTED";
+		break;
+	case RayCaster::OPENCL_ERROR:
+		err_msg = "OPENCL_ERROR";
+		break;
+	case RayCaster::ERROR:
+		err_msg = "ERROR";
+		break;
+	}
+
+	std::cout << err_msg << "  =at=  " << function_name << std::endl;
+	return true;
+}
\ No newline at end of file
diff --git a/src/main.cpp b/src/main.cpp
index 1cf11e0..778c49c 100644
--- a/src/main.cpp
+++ b/src/main.cpp
@@ -30,6 +30,7 @@
 #include "Curses.h"
 #include "util.hpp"
 #include "RayCaster.h"
+#include "Hardware_Caster.h"
 #include "CL_Wrapper.h"
 #include "Vector4.hpp"
 #include <Camera.h>
@@ -67,6 +68,7 @@ int main() {
 
 	sf::RenderWindow window(sf::VideoMode(WINDOW_X, WINDOW_Y), "SFML");
 
+	RayCaster rc = new Hardware_Caster()
 	CL_Wrapper c;
 
 	if (c.compile_kernel("../kernels/ray_caster_kernel.cl", true, "min_kern") < 0) {