diff --git a/include/graphics/fbo.hpp b/include/graphics/fbo.hpp
index 76e3435..38c3606 100644
--- a/include/graphics/fbo.hpp
+++ b/include/graphics/fbo.hpp
@@ -30,8 +30,6 @@ namespace gfx{
 	{
 	private:
 		GLuint m_buffer;
-		frame_buffer_accessor m_draw;
-		frame_buffer_accessor m_read;
 
 	public:
 		fbo();
@@ -50,12 +48,6 @@ namespace gfx{
 
 		bool bind()const;
 		bool bind(gl_frame_buffer_manager& b)const;
-		bool bind_lock(gl_frame_buffer_manager& b)const;
-		void bind_unlock(gl_frame_buffer_manager& b)const;
-		void unbind()const;
-
-		gl_frame_buffer_manager* get_bound_buffer()const;
-		GLenum get_bound_id()const;
 	};
 
 }
diff --git a/include/graphics/texture.hpp b/include/graphics/texture.hpp
index e1a5b16..cf53c37 100644
--- a/include/graphics/texture.hpp
+++ b/include/graphics/texture.hpp
@@ -101,7 +101,7 @@ namespace gfx{
 		//bind to GL_TEXTURE_2D
 		void bind()const;
 		//bind to given texture unit and load into given program uniform location
-		void use(GLuint tunit, GLint uloc)const;
+		void bind_unit(GLuint tunit)const;
 	};
 
 }
diff --git a/include/graphics/vao.hpp b/include/graphics/vao.hpp
index c76c9dc..14a8e6c 100644
--- a/include/graphics/vao.hpp
+++ b/include/graphics/vao.hpp
@@ -21,6 +21,7 @@
 
 #include "gl_include.hpp"
 #include "math/math.hpp"
+#include "vbo.hpp"
 
 namespace gfx{
 	using namespace math;
@@ -45,6 +46,9 @@ namespace gfx{
 
 		GLuint raw()const;
 
+		void bind_buffer(const vbo& buffer, GLuint index, GLuint offset, GLuint stride);
+		void bind_element_buffer(const vbo& buffer);
+
 		//Get access to a generic vertex attribute within this vao
 		vertex_attribute get_attribute(int index);
 
@@ -72,60 +76,22 @@ namespace gfx{
 		constexpr vertex_attribute& operator=(vertex_attribute&&) = default;
 
 		//enable use as an array attribute (most likely what is desired)
-		void enable_array_mode();
+		void enable();
 		//disable use as an array attribute. used for static data in attributes during rendering
-		void disable_array_mode();
+		void disable();
 
+
+		void associate_with(GLuint buffer_binding);
 		//setters for use in array mode. Same arguments as glVertexAttribPointer but these take arguments
 		//as object counts rather than bytes. a valid vbo must be bound to buffers::array_buffer before these are called.
-		void set_float_pointer(GLint size, GLsizei stride, GLsizei offset);
-		void set_double_pointer(GLint size, GLsizei stride, GLsizei offset);
-		void set_byte_pointer(GLint size, GLsizei stride, GLsizei offset);
-		void set_ubyte_pointer(GLint size, GLsizei stride, GLsizei offset);
-		void set_short_pointer(GLint size, GLsizei stride, GLsizei offset);
-		void set_ushort_pointer(GLint size, GLsizei stride, GLsizei offset);
-		void set_int_pointer(GLint size, GLsizei stride, GLsizei offset);
-		void set_uint_pointer(GLint size, GLsizei stride, GLsizei offset);
-
-		//setters for use in non array mode
-		void set(GLfloat);
-		void set(GLshort);
-		void set(GLdouble);
-		void set(GLint);
-		void set(GLuint);
-		void set(GLfloat, GLfloat);
-		void set(GLshort, GLshort);
-		void set(GLdouble, GLdouble);
-		void set(GLint, GLint);
-		void set(GLuint, GLuint);
-		void set(GLfloat, GLfloat, GLfloat);
-		void set(GLshort, GLshort, GLshort);
-		void set(GLdouble, GLdouble, GLdouble);
-		void set(GLint, GLint, GLint);
-		void set(GLuint, GLuint, GLuint);
-		void set(GLfloat, GLfloat, GLfloat, GLfloat);
-		void set(GLshort, GLshort, GLshort, GLshort);
-		void set(GLdouble, GLdouble, GLdouble, GLdouble);
-		void set(GLint, GLint, GLint, GLint);
-		void set(GLuint, GLuint, GLuint, GLuint);
-		void set(const vec2<GLfloat>&);
-		void set(const vec2<GLshort>&);
-		void set(const vec2<GLdouble>&);
-		void set(const vec2<GLint>&);
-		void set(const vec2<GLuint>&);
-		void set(const vec3<GLfloat>&);
-		void set(const vec3<GLshort>&);
-		void set(const vec3<GLdouble>&);
-		void set(const vec3<GLint>&);
-		void set(const vec3<GLuint>&);
-		void set(const vec4<GLfloat>&);
-		void set(const vec4<GLshort>&);
-		void set(const vec4<GLdouble>&);
-		void set(const vec4<GLint>&);
-		void set(const vec4<GLuint>&);
-		void set(const vec4<GLbyte>&);
-		void set(const vec4<GLubyte>&);
-		void set(const vec4<GLushort>&);
+		void set_float_array(GLint size, GLsizei offset);
+		void set_double_array(GLint size, GLsizei offset);
+		void set_byte_array(GLint size, GLsizei offset);
+		void set_ubyte_array(GLint size, GLsizei offset);
+		void set_short_array(GLint size, GLsizei offset);
+		void set_ushort_array(GLint size, GLsizei offset);
+		void set_int_array(GLint size, GLsizei offset);
+		void set_uint_array(GLint size, GLsizei offset);
 	};
 
 }
diff --git a/include/graphics/vbo.hpp b/include/graphics/vbo.hpp
index 8ad7c23..ae4302c 100644
--- a/include/graphics/vbo.hpp
+++ b/include/graphics/vbo.hpp
@@ -21,8 +21,6 @@
 
 #include "gl_include.hpp"
 #include "gl_buffers.hpp"
-#include "scoped_buffer_bind.hpp"
-
 #include <cstdlib> //size_t, ptrdiff_t
 #include <utility> //exchange, swap
 
@@ -56,7 +54,6 @@ namespace gfx{
 	private:
 		GLuint m_buffer;        //handle to vbo
 		size_t m_buffer_size;   //amount of buffer currently in use
-		buffer_accessor m_bi;      //interface with gl_buffer stuff
 
 	public:
 		//create a buffer with given capacity with predicted usage case 't'
@@ -70,12 +67,6 @@ namespace gfx{
 
 		//attempt binding to given gl_buffer_manager. returns true on success
 		bool bind(gl_buffer_manager& b)const;
-		//attempt binding to given gl_buffer_manager and locking that buffer. returns true on success
-		bool bind_lock(gl_buffer_manager& b)const;
-		//unlock associated gl_buffer_manager but don't unbind
-		void bind_unlock()const;
-		//unbind and unlock associated gl_buffer_manager
-		void unbind()const;
 		//add data to the end of this buffer (starts loading at data+get_size())
 		bool buffer(const void* data, size_t datasize);
 		//change capacity of buffer
@@ -84,7 +75,7 @@ namespace gfx{
 		GLuint raw()const;
 
 		//glMapBuffer to given target with map style 'm'
-		scoped_vbo_map<void> map(gl_buffer_manager& target, maptype m)const;
+		scoped_vbo_map<void> map(maptype m)const;
 
 		//emties the buffer. does not clear contents, just sets size to 0.
 		void clear();
@@ -92,9 +83,6 @@ namespace gfx{
 		size_t get_cap()const;
 		usage get_usage()const;
 
-		//check the currently bound buffer target
-		gl_buffer_manager* get_bound_buffer()const;
-		GLenum get_bound_id()const;
 	private:
 		static bool copy_buffer(vbo& dest, const vbo& src);
 	};
@@ -114,12 +102,11 @@ namespace gfx{
 
 	private:
 		pointer m_data = nullptr; //pointer to the mapped region
-		scoped_buffer_bind<buffer_accessor> m_bind;
-
+		GLuint m_buffer;
 
 	public:
 		//create a mapping for 'v' on 'targ' with map style 'm'
-		explicit scoped_vbo_map(const buffer_accessor& ba, gl_buffer_manager& bm, GLuint bid, vbo::maptype m);
+		explicit scoped_vbo_map(GLuint bid, vbo::maptype m);
 		scoped_vbo_map(const scoped_vbo_map&) = delete;
 		scoped_vbo_map(scoped_vbo_map&&);
 		~scoped_vbo_map();
@@ -161,10 +148,10 @@ namespace gfx{
 
 	private:
 		pointer m_data = nullptr;
-		scoped_buffer_bind<buffer_accessor> m_bind;
+		GLuint m_buffer;
 
 	public:
-		explicit scoped_vbo_map(const buffer_accessor& ba, gl_buffer_manager& bm, GLuint bid, vbo::maptype m);
+		explicit scoped_vbo_map(GLuint bid, vbo::maptype m);
 		scoped_vbo_map(const scoped_vbo_map&) = delete;
 		scoped_vbo_map(scoped_vbo_map&&);
 		~scoped_vbo_map();
@@ -184,37 +171,36 @@ namespace gfx{
 	};
 
 	template<typename T>
-	scoped_vbo_map<T>::scoped_vbo_map(const buffer_accessor& ba, gl_buffer_manager& bm, GLuint bid, vbo::maptype m):
-		m_bind(ba, bm, bid)
+	scoped_vbo_map<T>::scoped_vbo_map(GLuint bid, vbo::maptype m):
+		m_buffer(bid)
 	{
-		if(!m_bind.valid())
-			return;
-		m_data = reinterpret_cast<pointer>(glMapBuffer(m_bind.get_bound_id(), static_cast<GLenum>(m)));
+		m_data = reinterpret_cast<pointer>(glMapNamedBuffer(m_buffer, static_cast<GLenum>(m)));
 	}
 	template<typename T>
 	scoped_vbo_map<T>::scoped_vbo_map(scoped_vbo_map&& m):
 		m_data(std::exchange(m.m_data, nullptr)),
-		m_bind(std::move(m.m_bind)){}
+		m_buffer(std::exchange(m.m_buffer, 0)){}
 	template<typename T>
 	scoped_vbo_map<T>::~scoped_vbo_map(){
 		if(m_data){
-			glUnmapBuffer(m_bind.get_bound_id());
+			glUnmapNamedBuffer(m_buffer);
 		}
 	}
 	template<typename T>
 	scoped_vbo_map<T>& scoped_vbo_map<T>::operator=(scoped_vbo_map&& m){
 		std::swap(m_data, m.m_data);
-		m_bind = std::move(m.m_bind);
+		std::swap(m_buffer, m.m_buffer);
 		return *this;
 	}
 	template<typename T>
 	auto scoped_vbo_map<T>::length()const -> size_type{
 		GLint64 retval;
-		glGetBufferParameteri64v(m_bind.get_bound_id(), GL_BUFFER_MAP_LENGTH, &retval);
+		glGetNamedBufferParameteri64v(m_buffer, GL_BUFFER_MAP_LENGTH, &retval);
 		return retval;
 	}
 	template<typename T>
 	auto scoped_vbo_map<T>::release() -> pointer{
+		m_buffer = 0;
 		return std::exchange(m_data, nullptr);
 	}
 	template<typename T>
diff --git a/src/graphics/fbo.cpp b/src/graphics/fbo.cpp
index 3d781d4..54525c0 100644
--- a/src/graphics/fbo.cpp
+++ b/src/graphics/fbo.cpp
@@ -23,14 +23,10 @@
 namespace gfx{
 
 	fbo::fbo(){
-		glGenFramebuffers(1, &m_buffer);
-		m_draw.set_buffer_id(m_buffer);
-		m_read.set_buffer_id(m_buffer);
+		glCreateFramebuffers(1, &m_buffer);
 	}
 	fbo::fbo(fbo&& f):
-		m_buffer(std::exchange(f.m_buffer, 0)),
-		m_draw(std::move(f.m_draw)),
-		m_read(std::move(f.m_read)){}
+		m_buffer(std::exchange(f.m_buffer, 0)){}
 	fbo::~fbo(){
 		if(m_buffer)
 			glDeleteFramebuffers(1, &m_buffer);
@@ -46,72 +42,25 @@ namespace gfx{
 	}
 
 	bool fbo::detach(GLenum point){
-		scoped_buffer_bind draw_bind(m_draw, buffer::fb_draw);
-		if(!draw_bind.valid())
-			return false;
-		glFramebufferRenderbuffer(m_draw.get_bound_id(), point, GL_RENDERBUFFER, 0);
+		glNamedFramebufferRenderbuffer(m_buffer, point, GL_RENDERBUFFER, 0);
 		return true;
 	}
 	bool fbo::attach(const texture& tex, GLenum point){
-		scoped_buffer_bind draw_bind(m_draw, buffer::fb_draw);
-		if(!draw_bind.valid())
-			return false;
-		tex.bind();
-		glFramebufferTexture2D(m_draw.get_bound_id(), point, GL_TEXTURE_2D, tex.raw(), 0);
+		glNamedFramebufferTexture(m_buffer, point, tex.raw(), 0);
 		return true;
 	}
 	bool fbo::attach(const rbo& r, GLenum point){
-		scoped_buffer_bind draw_bind(m_draw, buffer::fb_draw);
-		if(!draw_bind.valid())
-			return false;
-		r.bind();
-		glFramebufferRenderbuffer(m_draw.get_bound_id(), point, GL_RENDERBUFFER, r.raw());
+		glNamedFramebufferRenderbuffer(m_buffer, point, GL_RENDERBUFFER, r.raw());
 		return true;
 	}
 
 	bool fbo::bind()const{
-		return (bind(buffer::fb_draw) && bind(buffer::fb_read));
+		glBindFramebuffer(GL_FRAMEBUFFER, m_buffer);
+		return true;
 	}
 	bool fbo::bind(gl_frame_buffer_manager& b)const{
-		if(GL_DRAW_FRAMEBUFFER == b.get_buffer_id()){
-			if(!m_draw.bind(b))
-				return false;
-		}else{
-			if(!m_read.bind(b))
-				return false;
-		}
+		glBindFramebuffer(b.get_buffer_id(), m_buffer);
 		return true;
 	}
-	bool fbo::bind_lock(gl_frame_buffer_manager& b)const{
-		if(GL_DRAW_FRAMEBUFFER == b.get_buffer_id()){
-			if(!m_draw.bind_lock(b))
-				return false;
-		}else{
-			if(!m_read.bind_lock(b))
-				return false;
-		}
-		return true;
-	}
-	void fbo::bind_unlock(gl_frame_buffer_manager& b)const{
-		if(GL_DRAW_FRAMEBUFFER == b.get_buffer_id()){
-			m_draw.unlock();
-		}else{
-			m_read.unlock();
-		}
-	}
-	void fbo::unbind()const{
-		m_draw.unbind();
-		m_read.unbind();
-	}
-	GLenum fbo::get_bound_id()const{
-		if(m_read.get_bound_buffer() && m_draw.get_bound_buffer())
-			return GL_FRAMEBUFFER;
-		if(m_read.get_bound_buffer())
-			return m_read.get_bound_id();
-		if(m_draw.get_bound_buffer())
-			return m_draw.get_bound_id();
-		return 0;
-	}
-
 
 }
diff --git a/src/graphics/shader_program.cpp b/src/graphics/shader_program.cpp
index efff514..068552c 100644
--- a/src/graphics/shader_program.cpp
+++ b/src/graphics/shader_program.cpp
@@ -425,20 +425,16 @@ namespace gfx{
 		set_uniform(get_uniform_loc(name), f1, f2, f3, f4);
 	}
 	void shader_program::set_uniform(GLuint loc, GLfloat f){
-		use();
-		glUniform1f(loc, f);
+		glProgramUniform1f(m_shader_id, loc, f);
 	}
 	void shader_program::set_uniform(GLuint loc, GLfloat f1, GLfloat f2){
-		use();
-		glUniform2f(loc, f1, f2);
+		glProgramUniform2f(m_shader_id, loc, f1, f2);
 	}
 	void shader_program::set_uniform(GLuint loc, GLfloat f1, GLfloat f2, GLfloat f3){
-		use();
-		glUniform3f(loc, f1, f2, f3);
+		glProgramUniform3f(m_shader_id, loc, f1, f2, f3);
 	}
 	void shader_program::set_uniform(GLuint loc, GLfloat f1, GLfloat f2, GLfloat f3, GLfloat f4){
-		use();
-		glUniform4f(loc, f1, f2, f3, f4);
+		glProgramUniform4f(m_shader_id, loc, f1, f2, f3, f4);
 	}
 
 	void shader_program::set_uniform(const char* name, GLint i){
@@ -454,20 +450,16 @@ namespace gfx{
 		set_uniform(get_uniform_loc(name), i1, i2, i3, i4);
 	}
 	void shader_program::set_uniform(GLuint loc, GLint i){
-		use();
-		glUniform1i(loc, i);
+		glProgramUniform1i(m_shader_id, loc, i);
 	}
 	void shader_program::set_uniform(GLuint loc, GLint i1, GLint i2){
-		use();
-		glUniform2i(loc, i1, i2);
+		glProgramUniform2i(m_shader_id, loc, i1, i2);
 	}
 	void shader_program::set_uniform(GLuint loc, GLint i1, GLint i2, GLint i3){
-		use();
-		glUniform3i(loc, i1, i2, i3);
+		glProgramUniform3i(m_shader_id, loc, i1, i2, i3);
 	}
 	void shader_program::set_uniform(GLuint loc, GLint i1, GLint i2, GLint i3, GLint i4){
-		use();
-		glUniform4i(loc, i1, i2, i3, i4);
+		glProgramUniform4i(m_shader_id, loc, i1, i2, i3, i4);
 	}
 
 	void shader_program::set_uniform(const char* name, GLuint i){
@@ -483,28 +475,24 @@ namespace gfx{
 		set_uniform(get_uniform_loc(name), i1, i2, i3, i4);
 	}
 	void shader_program::set_uniform(GLuint loc, GLuint i){
-		use();
-		glUniform1ui(loc, i);
+		glProgramUniform1ui(m_shader_id, loc, i);
 	}
 	void shader_program::set_uniform(GLuint loc, GLuint i1, GLuint i2){
-		use();
-		glUniform2ui(loc, i1, i2);
+		glProgramUniform2ui(m_shader_id, loc, i1, i2);
 	}
 	void shader_program::set_uniform(GLuint loc, GLuint i1, GLuint i2, GLuint i3){
-		use();
-		glUniform3ui(loc, i1, i2, i3);
+		glProgramUniform3ui(m_shader_id, loc, i1, i2, i3);
 	}
 	void shader_program::set_uniform(GLuint loc, GLuint i1, GLuint i2, GLuint i3, GLuint i4){
-		use();
-		glUniform4ui(loc, i1, i2, i3, i4);
+		glProgramUniform4ui(m_shader_id, loc, i1, i2, i3, i4);
 	}
 
 	void shader_program::set_uniform(const char* name, const texture& t, GLuint tex_unit){
 		set_uniform(get_uniform_loc(name), t, tex_unit);
 	}
 	void shader_program::set_uniform(GLuint loc, const texture& t, GLuint tex_unit){
-		use();
-		t.use(tex_unit, loc);
+		t.bind_unit(tex_unit);
+		glProgramUniform1i(m_shader_id, loc, tex_unit);
 	}
 
 	void shader_program::set_uniform(const char* name, const vec2<GLfloat>& v){
@@ -517,41 +505,36 @@ namespace gfx{
 		set_uniform(get_uniform_loc(name), v);
 	}
 	void shader_program::set_uniform(GLuint loc, const vec2<GLfloat>& v){
-		use();
-		glUniform2fv(loc, 1, v);
+		glProgramUniform2fv(m_shader_id, loc, 1, v);
 	}
 	void shader_program::set_uniform(GLuint loc, const vec3<GLfloat>& v){
-		use();
-		glUniform3fv(loc, 1, v);
+		glProgramUniform3fv(m_shader_id, loc, 1, v);
 	}
 	void shader_program::set_uniform(GLuint loc, const vec4<GLfloat>& v){
-		use();
-		glUniform4fv(loc, 1, v);
+		glProgramUniform4fv(m_shader_id, loc, 1, v);
 	}
 
 	void shader_program::set_uniform(const char* name, GLsizei count, const vec2<GLfloat>* v_arr){
 		set_uniform(get_uniform_loc(name), count, v_arr);
 	}
 	void shader_program::set_uniform(GLuint loc, GLsizei count, const vec2<GLfloat>* v_arr){
-		use();
 		if constexpr(sizeof(v_arr[0]) == sizeof(GLfloat[2])){
-			glUniform2fv(loc, count, reinterpret_cast<const GLfloat*>(v_arr));
+			glProgramUniform2fv(m_shader_id, loc, count, reinterpret_cast<const GLfloat*>(v_arr));
 		}else{
 			std::unique_ptr<GLfloat[]> arr(new GLfloat[count * 2]);
 			for(GLsizei i = 0; i < count; ++i){
 				arr[i]     = v_arr[i].get(0);
 				arr[i + 1] = v_arr[i].get(1);
 			}
-			glUniform2fv(loc, count, arr.get());
+			glProgramUniform2fv(m_shader_id, loc, count, arr.get());
 		}
 	}
 	void shader_program::set_uniform(const char* name, GLsizei count, const vec3<GLfloat>* v_arr){
 		set_uniform(get_uniform_loc(name), count, v_arr);
 	}
 	void shader_program::set_uniform(GLuint loc, GLsizei count, const vec3<GLfloat>* v_arr){
-		use();
 		if constexpr(sizeof(v_arr[0]) == sizeof(GLfloat[3])){
-			glUniform3fv(loc, count, reinterpret_cast<const GLfloat*>(v_arr));
+			glProgramUniform3fv(m_shader_id, loc, count, reinterpret_cast<const GLfloat*>(v_arr));
 		}else{
 			std::unique_ptr<GLfloat[]> arr(new GLfloat[count * 3]);
 			for(GLsizei i = 0; i < count; ++i){
@@ -559,16 +542,15 @@ namespace gfx{
 				arr[i + 1] = v_arr[i].get(1);
 				arr[i + 2] = v_arr[i].get(2);
 			}
-			glUniform3fv(loc, count, arr.get());
+			glProgramUniform3fv(m_shader_id, loc, count, arr.get());
 		}
 	}
 	void shader_program::set_uniform(const char* name, GLsizei count, const vec4<GLfloat>* v_arr){
 		set_uniform(get_uniform_loc(name), count, v_arr);
 	}
 	void shader_program::set_uniform(GLuint loc, GLsizei count, const vec4<GLfloat>* v_arr){
-		use();
 		if constexpr(sizeof(v_arr[0]) == sizeof(GLfloat[4])){
-			glUniform4fv(loc, count, reinterpret_cast<const GLfloat*>(v_arr));
+			glProgramUniform4fv(m_shader_id, loc, count, reinterpret_cast<const GLfloat*>(v_arr));
 		}else{
 			std::unique_ptr<GLfloat[]> arr(new GLfloat[count * 4]);
 			for(GLsizei i = 0; i < count; ++i){
@@ -577,7 +559,7 @@ namespace gfx{
 				arr[i + 2] = v_arr[i].get(2);
 				arr[i + 3] = v_arr[i].get(3);
 			}
-			glUniform4fv(loc, count, arr.get());
+			glProgramUniform4fv(m_shader_id, loc, count, arr.get());
 		}
 	}
 
@@ -594,20 +576,16 @@ namespace gfx{
 		set_uniform_4(get_uniform_loc(name), count, v_arr);
 	}
 	void shader_program::set_uniform_1(GLuint loc, GLsizei count, const GLfloat* v_arr){
-		use();
-		glUniform1fv(loc, count, v_arr);
+		glProgramUniform1fv(m_shader_id, loc, count, v_arr);
 	}
 	void shader_program::set_uniform_2(GLuint loc, GLsizei count, const GLfloat* v_arr){
-		use();
-		glUniform2fv(loc, count, v_arr);
+		glProgramUniform2fv(m_shader_id, loc, count, v_arr);
 	}
 	void shader_program::set_uniform_3(GLuint loc, GLsizei count, const GLfloat* v_arr){
-		use();
-		glUniform3fv(loc, count, v_arr);
+		glProgramUniform3fv(m_shader_id, loc, count, v_arr);
 	}
 	void shader_program::set_uniform_4(GLuint loc, GLsizei count, const GLfloat* v_arr){
-		use();
-		glUniform4fv(loc, count, v_arr);
+		glProgramUniform4fv(m_shader_id, loc, count, v_arr);
 	}
 
 	void shader_program::set_uniform(const char* name, const vec2<GLint>& v){
@@ -620,41 +598,36 @@ namespace gfx{
 		set_uniform(get_uniform_loc(name), v);
 	}
 	void shader_program::set_uniform(GLuint loc, const vec2<GLint>& v){
-		use();
-		glUniform2iv(loc, 1, v);
+		glProgramUniform2iv(m_shader_id, loc, 1, v);
 	}
 	void shader_program::set_uniform(GLuint loc, const vec3<GLint>& v){
-		use();
-		glUniform3iv(loc, 1, v);
+		glProgramUniform3iv(m_shader_id, loc, 1, v);
 	}
 	void shader_program::set_uniform(GLuint loc, const vec4<GLint>& v){
-		use();
-		glUniform4iv(loc, 1, v);
+		glProgramUniform4iv(m_shader_id, loc, 1, v);
 	}
 
 	void shader_program::set_uniform(const char* name, GLsizei count, const vec2<GLint>* v_arr){
 		set_uniform(get_uniform_loc(name), count, v_arr);
 	}
 	void shader_program::set_uniform(GLuint loc, GLsizei count, const vec2<GLint>* v_arr){
-		use();
 		if constexpr(sizeof(v_arr[0]) == sizeof(GLint[2])){
-			glUniform2iv(loc, count, reinterpret_cast<const GLint*>(v_arr));
+			glProgramUniform2iv(m_shader_id, loc, count, reinterpret_cast<const GLint*>(v_arr));
 		}else{
 			std::unique_ptr<GLint[]> arr(new GLint[count * 2]);
 			for(GLsizei i = 0; i < count; ++i){
 				arr[i]     = v_arr[i].get(0);
 				arr[i + 1] = v_arr[i].get(1);
 			}
-			glUniform2iv(loc, count, arr.get());
+			glProgramUniform2iv(m_shader_id, loc, count, arr.get());
 		}
 	}
 	void shader_program::set_uniform(const char* name, GLsizei count, const vec3<GLint>* v_arr){
 		set_uniform(get_uniform_loc(name), count, v_arr);
 	}
 	void shader_program::set_uniform(GLuint loc, GLsizei count, const vec3<GLint>* v_arr){
-		use();
 		if constexpr(sizeof(v_arr[0]) == sizeof(GLint[3])){
-			glUniform3iv(loc, count, reinterpret_cast<const GLint*>(v_arr));
+			glProgramUniform3iv(m_shader_id, loc, count, reinterpret_cast<const GLint*>(v_arr));
 		}else{
 			std::unique_ptr<GLint[]> arr(new GLint[count * 3]);
 			for(GLsizei i = 0; i < count; ++i){
@@ -662,16 +635,15 @@ namespace gfx{
 				arr[i + 1] = v_arr[i].get(1);
 				arr[i + 2] = v_arr[i].get(2);
 			}
-			glUniform3iv(loc, count, arr.get());
+			glProgramUniform3iv(m_shader_id, loc, count, arr.get());
 		}
 	}
 	void shader_program::set_uniform(const char* name, GLsizei count, const vec4<GLint>* v_arr){
 		set_uniform(get_uniform_loc(name), count, v_arr);
 	}
 	void shader_program::set_uniform(GLuint loc, GLsizei count, const vec4<GLint>* v_arr){
-		use();
 		if constexpr(sizeof(v_arr[0]) == sizeof(GLint[4])){
-			glUniform4iv(loc, count, reinterpret_cast<const GLint*>(v_arr));
+			glProgramUniform4iv(m_shader_id, loc, count, reinterpret_cast<const GLint*>(v_arr));
 		}else{
 			std::unique_ptr<GLint[]> arr(new GLint[count * 4]);
 			for(GLsizei i = 0; i < count; ++i){
@@ -680,7 +652,7 @@ namespace gfx{
 				arr[i + 2] = v_arr[i].get(2);
 				arr[i + 3] = v_arr[i].get(3);
 			}
-			glUniform4iv(loc, count, arr.get());
+			glProgramUniform4iv(m_shader_id, loc, count, arr.get());
 		}
 	}
 
@@ -697,20 +669,16 @@ namespace gfx{
 		set_uniform_4(get_uniform_loc(name), count, v_arr);
 	}
 	void shader_program::set_uniform_1(GLuint loc, GLsizei count, const GLint* v_arr){
-		use();
-		glUniform1iv(loc, count, v_arr);
+		glProgramUniform1iv(m_shader_id, loc, count, v_arr);
 	}
 	void shader_program::set_uniform_2(GLuint loc, GLsizei count, const GLint* v_arr){
-		use();
-		glUniform2iv(loc, count, v_arr);
+		glProgramUniform2iv(m_shader_id, loc, count, v_arr);
 	}
 	void shader_program::set_uniform_3(GLuint loc, GLsizei count, const GLint* v_arr){
-		use();
-		glUniform3iv(loc, count, v_arr);
+		glProgramUniform3iv(m_shader_id, loc, count, v_arr);
 	}
 	void shader_program::set_uniform_4(GLuint loc, GLsizei count, const GLint* v_arr){
-		use();
-		glUniform4iv(loc, count, v_arr);
+		glProgramUniform4iv(m_shader_id, loc, count, v_arr);
 	}
 
 	void shader_program::set_uniform(const char* name, const vec2<GLuint>& v){
@@ -723,41 +691,36 @@ namespace gfx{
 		set_uniform(get_uniform_loc(name), v);
 	}
 	void shader_program::set_uniform(GLuint loc, const vec2<GLuint>& v){
-		use();
-		glUniform2uiv(loc, 1, v);
+		glProgramUniform2uiv(m_shader_id, loc, 1, v);
 	}
 	void shader_program::set_uniform(GLuint loc, const vec3<GLuint>& v){
-		use();
-		glUniform3uiv(loc, 1, v);
+		glProgramUniform3uiv(m_shader_id, loc, 1, v);
 	}
 	void shader_program::set_uniform(GLuint loc, const vec4<GLuint>& v){
-		use();
-		glUniform4uiv(loc, 1, v);
+		glProgramUniform4uiv(m_shader_id, loc, 1, v);
 	}
 
 	void shader_program::set_uniform(const char* name, GLsizei count, const vec2<GLuint>* v_arr){
 		set_uniform(get_uniform_loc(name), count, v_arr);
 	}
 	void shader_program::set_uniform(GLuint loc, GLsizei count, const vec2<GLuint>* v_arr){
-		use();
 		if constexpr(sizeof(v_arr[0]) == sizeof(GLuint[2])){
-			glUniform2uiv(loc, count, reinterpret_cast<const GLuint*>(v_arr));
+			glProgramUniform2uiv(m_shader_id, loc, count, reinterpret_cast<const GLuint*>(v_arr));
 		}else{
 			std::unique_ptr<GLuint[]> arr(new GLuint[count * 2]);
 			for(GLsizei i = 0; i < count; ++i){
 				arr[i]     = v_arr[i].get(0);
 				arr[i + 1] = v_arr[i].get(1);
 			}
-			glUniform2uiv(loc, count, arr.get());
+			glProgramUniform2uiv(m_shader_id, loc, count, arr.get());
 		}
 	}
 	void shader_program::set_uniform(const char* name, GLsizei count, const vec3<GLuint>* v_arr){
 		set_uniform(get_uniform_loc(name), count, v_arr);
 	}
 	void shader_program::set_uniform(GLuint loc, GLsizei count, const vec3<GLuint>* v_arr){
-		use();
 		if constexpr(sizeof(v_arr[0]) == sizeof(GLuint[3])){
-			glUniform3uiv(loc, count, reinterpret_cast<const GLuint*>(v_arr));
+			glProgramUniform3uiv(m_shader_id, loc, count, reinterpret_cast<const GLuint*>(v_arr));
 		}else{
 			std::unique_ptr<GLuint[]> arr(new GLuint[count * 3]);
 			for(GLsizei i = 0; i < count; ++i){
@@ -765,16 +728,15 @@ namespace gfx{
 				arr[i + 1] = v_arr[i].get(1);
 				arr[i + 2] = v_arr[i].get(2);
 			}
-			glUniform3uiv(loc, count, arr.get());
+			glProgramUniform3uiv(m_shader_id, loc, count, arr.get());
 		}
 	}
 	void shader_program::set_uniform(const char* name, GLsizei count, const vec4<GLuint>* v_arr){
 		set_uniform(get_uniform_loc(name), count, v_arr);
 	}
 	void shader_program::set_uniform(GLuint loc, GLsizei count, const vec4<GLuint>* v_arr){
-		use();
 		if constexpr(sizeof(v_arr[0]) == sizeof(GLuint[4])){
-			glUniform4uiv(loc, count, reinterpret_cast<const GLuint*>(v_arr));
+			glProgramUniform4uiv(m_shader_id, loc, count, reinterpret_cast<const GLuint*>(v_arr));
 		}else{
 			std::unique_ptr<GLuint[]> arr(new GLuint[count * 4]);
 			for(GLsizei i = 0; i < count; ++i){
@@ -783,7 +745,7 @@ namespace gfx{
 				arr[i + 2] = v_arr[i].get(2);
 				arr[i + 3] = v_arr[i].get(3);
 			}
-			glUniform4uiv(loc, count, arr.get());
+			glProgramUniform4uiv(m_shader_id, loc, count, arr.get());
 		}
 	}
 
@@ -800,20 +762,16 @@ namespace gfx{
 		set_uniform_4(get_uniform_loc(name), count, v_arr);
 	}
 	void shader_program::set_uniform_1(GLuint loc, GLsizei count, const GLuint* v_arr){
-		use();
-		glUniform1uiv(loc, count, v_arr);
+		glProgramUniform1uiv(m_shader_id, loc, count, v_arr);
 	}
 	void shader_program::set_uniform_2(GLuint loc, GLsizei count, const GLuint* v_arr){
-		use();
-		glUniform2uiv(loc, count, v_arr);
+		glProgramUniform2uiv(m_shader_id, loc, count, v_arr);
 	}
 	void shader_program::set_uniform_3(GLuint loc, GLsizei count, const GLuint* v_arr){
-		use();
-		glUniform3uiv(loc, count, v_arr);
+		glProgramUniform3uiv(m_shader_id, loc, count, v_arr);
 	}
 	void shader_program::set_uniform_4(GLuint loc, GLsizei count, const GLuint* v_arr){
-		use();
-		glUniform4uiv(loc, count, v_arr);
+		glProgramUniform4uiv(m_shader_id, loc, count, v_arr);
 	}
 
 	void shader_program::set_uniform(const char* name, const mat2<GLfloat>& m){
@@ -826,25 +784,21 @@ namespace gfx{
 		set_uniform(get_uniform_loc(name), m);
 	}
 	void shader_program::set_uniform(GLuint loc, const mat2<GLfloat>& m){
-		use();
-		glUniformMatrix2fv(loc, 1, GL_FALSE, m);
+		glProgramUniformMatrix2fv(m_shader_id, loc, 1, GL_FALSE, m);
 	}
 	void shader_program::set_uniform(GLuint loc, const mat3<GLfloat>& m){
-		use();
-		glUniformMatrix3fv(loc, 1, GL_FALSE, m);
+		glProgramUniformMatrix3fv(m_shader_id, loc, 1, GL_FALSE, m);
 	}
 	void shader_program::set_uniform(GLuint loc, const mat4<GLfloat>& m){
-		use();
-		glUniformMatrix4fv(loc, 1, GL_FALSE, m);
+		glProgramUniformMatrix4fv(m_shader_id, loc, 1, GL_FALSE, m);
 	}
 
 	void shader_program::set_uniform(const char* name, GLsizei count, const mat2<GLfloat>* m_arr){
 		set_uniform(get_uniform_loc(name), count, m_arr);
 	}
 	void shader_program::set_uniform(GLuint loc, GLsizei count, const mat2<GLfloat>* m_arr){
-		use();
 		if constexpr(sizeof(m_arr[0]) == sizeof(GLfloat[4])){
-			glUniformMatrix2fv(loc, count, GL_FALSE, reinterpret_cast<const GLfloat*>(m_arr));
+			glProgramUniformMatrix2fv(m_shader_id, loc, count, GL_FALSE, reinterpret_cast<const GLfloat*>(m_arr));
 		}else{
 			std::unique_ptr<GLfloat[]> arr(new GLfloat[count * 4]);
 			for(GLsizei i = 0; i < count; ++i){
@@ -853,16 +807,15 @@ namespace gfx{
 				arr[i + 2] = m_arr[i].get(2);
 				arr[i + 3] = m_arr[i].get(3);
 			}
-			glUniformMatrix2fv(loc, count, GL_FALSE, arr.get());
+			glProgramUniformMatrix2fv(m_shader_id, loc, count, GL_FALSE, arr.get());
 		}
 	}
 	void shader_program::set_uniform(const char* name, GLsizei count, const mat3<GLfloat>* m_arr){
 		set_uniform(get_uniform_loc(name), count, m_arr);
 	}
 	void shader_program::set_uniform(GLuint loc, GLsizei count, const mat3<GLfloat>* m_arr){
-		use();
 		if constexpr(sizeof(m_arr[0]) == sizeof(GLfloat[9])){
-			glUniformMatrix3fv(loc, count, GL_FALSE, reinterpret_cast<const GLfloat*>(m_arr));
+			glProgramUniformMatrix3fv(m_shader_id, loc, count, GL_FALSE, reinterpret_cast<const GLfloat*>(m_arr));
 		}else{
 			std::unique_ptr<GLfloat[]> arr(new GLfloat[count * 9]);
 			for(GLsizei i = 0; i < count; ++i){
@@ -876,16 +829,15 @@ namespace gfx{
 				arr[i + 7] = m_arr[i].get(7);
 				arr[i + 8] = m_arr[i].get(8);
 			}
-			glUniformMatrix3fv(loc, count, GL_FALSE, arr.get());
+			glProgramUniformMatrix3fv(m_shader_id, loc, count, GL_FALSE, arr.get());
 		}
 	}
 	void shader_program::set_uniform(const char* name, GLsizei count, const mat4<GLfloat>* m_arr){
 		set_uniform(get_uniform_loc(name), count, m_arr);
 	}
 	void shader_program::set_uniform(GLuint loc, GLsizei count, const mat4<GLfloat>* m_arr){
-		use();
 		if constexpr(sizeof(m_arr[0]) == sizeof(GLfloat[16])){
-			glUniformMatrix4fv(loc, count, GL_FALSE, reinterpret_cast<const GLfloat*>(m_arr));
+			glProgramUniformMatrix4fv(m_shader_id, loc, count, GL_FALSE, reinterpret_cast<const GLfloat*>(m_arr));
 		}else{
 			std::unique_ptr<GLfloat[]> arr(new GLfloat[count * 16]);
 			for(GLsizei i = 0; i < count; ++i){
@@ -906,7 +858,7 @@ namespace gfx{
 				arr[i + 14] = m_arr[i].get(14);
 				arr[i + 15] = m_arr[i].get(15);
 			}
-			glUniformMatrix4fv(loc, count, GL_FALSE, arr.get());
+			glProgramUniformMatrix4fv(m_shader_id, loc, count, GL_FALSE, arr.get());
 		}
 	}
 
@@ -938,39 +890,30 @@ namespace gfx{
 		set_uniform_mat4x3(get_uniform_loc(name), count, m_arr);
 	}
 	void shader_program::set_uniform_mat2(GLuint loc, GLsizei count, const GLfloat* m_arr){
-		use();
-		glUniformMatrix2fv(loc, count, GL_FALSE, m_arr);
+		glProgramUniformMatrix2fv(m_shader_id, loc, count, GL_FALSE, m_arr);
 	}
 	void shader_program::set_uniform_mat3(GLuint loc, GLsizei count, const GLfloat* m_arr){
-		use();
-		glUniformMatrix3fv(loc, count, GL_FALSE, m_arr);
+		glProgramUniformMatrix3fv(m_shader_id, loc, count, GL_FALSE, m_arr);
 	}
 	void shader_program::set_uniform_mat4(GLuint loc, GLsizei count, const GLfloat* m_arr){
-		use();
-		glUniformMatrix4fv(loc, count, GL_FALSE, m_arr);
+		glProgramUniformMatrix4fv(m_shader_id, loc, count, GL_FALSE, m_arr);
 	}
 	void shader_program::set_uniform_mat2x3(GLuint loc, GLsizei count, const GLfloat* m_arr){
-		use();
-		glUniformMatrix2x3fv(loc, count, GL_FALSE, m_arr);
+		glProgramUniformMatrix2x3fv(m_shader_id, loc, count, GL_FALSE, m_arr);
 	}
 	void shader_program::set_uniform_mat3x2(GLuint loc, GLsizei count, const GLfloat* m_arr){
-		use();
-		glUniformMatrix3x2fv(loc, count, GL_FALSE, m_arr);
+		glProgramUniformMatrix3x2fv(m_shader_id, loc, count, GL_FALSE, m_arr);
 	}
 	void shader_program::set_uniform_mat2x4(GLuint loc, GLsizei count, const GLfloat* m_arr){
-		use();
-		glUniformMatrix2x4fv(loc, count, GL_FALSE, m_arr);
+		glProgramUniformMatrix2x4fv(m_shader_id, loc, count, GL_FALSE, m_arr);
 	}
 	void shader_program::set_uniform_mat4x2(GLuint loc, GLsizei count, const GLfloat* m_arr){
-		use();
-		glUniformMatrix4x2fv(loc, count, GL_FALSE, m_arr);
+		glProgramUniformMatrix4x2fv(m_shader_id, loc, count, GL_FALSE, m_arr);
 	}
 	void shader_program::set_uniform_mat3x4(GLuint loc, GLsizei count, const GLfloat* m_arr){
-		use();
-		glUniformMatrix3x4fv(loc, count, GL_FALSE, m_arr);
+		glProgramUniformMatrix3x4fv(m_shader_id, loc, count, GL_FALSE, m_arr);
 	}
 	void shader_program::set_uniform_mat4x3(GLuint loc, GLsizei count, const GLfloat* m_arr){
-		use();
-		glUniformMatrix4x3fv(loc, count, GL_FALSE, m_arr);
+		glProgramUniformMatrix4x3fv(m_shader_id, loc, count, GL_FALSE, m_arr);
 	}
 }
diff --git a/src/graphics/texture.cpp b/src/graphics/texture.cpp
index dbb1439..96d2a39 100644
--- a/src/graphics/texture.cpp
+++ b/src/graphics/texture.cpp
@@ -23,12 +23,12 @@
 namespace gfx{
 
 	texture::texture(){
-		glGenTextures(1, &m_tex_id);
+		glCreateTextures(GL_TEXTURE_2D, 1, &m_tex_id);
 	}
 	texture::texture(GLenum format, GLsizei w, GLsizei h, GLenum type):
 		m_width(w), m_height(h)
 	{
-		glGenTextures(1, &m_tex_id);
+		glCreateTextures(GL_TEXTURE_2D, 1, &m_tex_id);
 		resize(format, w, h, type);
 	}
 	texture::texture(const image& i):
@@ -55,33 +55,49 @@ namespace gfx{
 			return false;
 
 		if(!m_tex_id)
-			glGenTextures(1, &m_tex_id);
+			glCreateTextures(GL_TEXTURE_2D, 1, &m_tex_id);
 		m_width = i.get_width();
 		m_height = i.get_height();
-		bind();
 		switch(i.get_channels()){
 			case 1:
-				glTexImage2D(GL_TEXTURE_2D, 0, GL_RED, m_width, m_height, 0, GL_RED, GL_UNSIGNED_BYTE, i.data());
+				glTextureStorage2D(m_tex_id, 1, GL_R8, m_width, m_height);
+				glTextureSubImage2D(m_tex_id, 0, 0, 0, m_width, m_height, GL_RED, GL_UNSIGNED_BYTE, i.data());
 				break;
 			case 2:
-				glTexImage2D(GL_TEXTURE_2D, 0, GL_RG, m_width, m_height, 0, GL_RG, GL_UNSIGNED_BYTE, i.data());
+				glTextureStorage2D(m_tex_id, 1, GL_RG8, m_width, m_height);
+				glTextureSubImage2D(m_tex_id, 0, 0, 0, m_width, m_height, GL_RG, GL_UNSIGNED_BYTE, i.data());
 				break;
 			case 3:
-				glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, m_width, m_height, 0, GL_RGB, GL_UNSIGNED_BYTE, i.data());
+				glTextureStorage2D(m_tex_id, 1, GL_RGB8, m_width, m_height);
+				glTextureSubImage2D(m_tex_id, 0, 0, 0, m_width, m_height, GL_RGB, GL_UNSIGNED_BYTE, i.data());
 				break;
 			case 4:
-				glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, m_width, m_height, 0, GL_RGBA, GL_UNSIGNED_BYTE, i.data());
+				glTextureStorage2D(m_tex_id, 1, GL_RGBA8, m_width, m_height);
+				glTextureSubImage2D(m_tex_id, 0, 0, 0, m_width, m_height, GL_RGBA, GL_UNSIGNED_BYTE, i.data());
 				break;
 			default:
 				return false;
 		}
-		glGenerateMipmap(GL_TEXTURE_2D);
+		glGenerateTextureMipmap(m_tex_id);
 		return true;
 	}
 	void texture::resize(GLenum format, GLsizei w, GLsizei h, GLenum type){
-		bind();
-		glTexImage2D(GL_TEXTURE_2D, 0, format, w, h, 0, format, type, NULL);
-		glGenerateMipmap(GL_TEXTURE_2D);
+		switch(format){
+			case GL_RED:
+				glTextureStorage2D(m_tex_id, 1, GL_R8, w, h);
+				break;
+			case GL_RG:
+				glTextureStorage2D(m_tex_id, 1, GL_RG8, w, h);
+				break;
+			case GL_RGB:
+				glTextureStorage2D(m_tex_id, 1, GL_RGB8, w, h);
+				break;
+			case GL_RGBA:
+				glTextureStorage2D(m_tex_id, 1, GL_RGBA8, w, h);
+				break;
+		};
+		glTextureSubImage2D(m_tex_id, 0, 0, 0, w, h, format, type, NULL);
+		glGenerateTextureMipmap(m_tex_id);
 	}
 
 	void texture::set_width(int w){
@@ -96,41 +112,33 @@ namespace gfx{
 	}
 
 	void texture::set_wrap_mode(wrap w){
-		bind();
-		glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, static_cast<GLint>(w));
-		glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, static_cast<GLint>(w));
+		glTextureParameteri(m_tex_id, GL_TEXTURE_WRAP_S, static_cast<GLint>(w));
+		glTextureParameteri(m_tex_id, GL_TEXTURE_WRAP_T, static_cast<GLint>(w));
 	}
 	void texture::set_wrap_mode(wrap w, wrap h){
-		bind();
-		glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, static_cast<GLint>(w));
-		glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, static_cast<GLint>(h));
+		glTextureParameteri(m_tex_id, GL_TEXTURE_WRAP_S, static_cast<GLint>(w));
+		glTextureParameteri(m_tex_id, GL_TEXTURE_WRAP_T, static_cast<GLint>(h));
 	}
 	void texture::set_wrap_x(wrap w){
-		bind();
-		glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, static_cast<GLint>(w));
+		glTexParameteri(m_tex_id, GL_TEXTURE_WRAP_S, static_cast<GLint>(w));
 	}
 	void texture::set_wrap_y(wrap h){
-		bind();
-		glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, static_cast<GLint>(h));
+		glTextureParameteri(m_tex_id, GL_TEXTURE_WRAP_T, static_cast<GLint>(h));
 	}
 
 	void texture::set_border_color(GLfloat r, GLfloat g, GLfloat b, GLfloat a){
 		GLfloat arr[4] = {r, g, b, a};
-		bind();
-		glTexParameterfv(GL_TEXTURE_2D, GL_TEXTURE_BORDER_COLOR, arr);
+		glTextureParameterfv(m_tex_id, GL_TEXTURE_BORDER_COLOR, arr);
 	}
 	void texture::set_filter(minfilter min, magfilter mag){
-		bind();
-		glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, static_cast<GLint>(min));
-		glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, static_cast<GLint>(mag));
+		glTextureParameteri(m_tex_id, GL_TEXTURE_MIN_FILTER, static_cast<GLint>(min));
+		glTextureParameteri(m_tex_id, GL_TEXTURE_MAG_FILTER, static_cast<GLint>(mag));
 	}
 	void texture::set_mag_filter(magfilter m){
-		bind();
-		glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, static_cast<GLint>(m));
+		glTextureParameteri(m_tex_id, GL_TEXTURE_MAG_FILTER, static_cast<GLint>(m));
 	}
 	void texture::set_min_filter(minfilter m){
-		bind();
-		glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, static_cast<GLint>(m));
+		glTextureParameteri(m_tex_id, GL_TEXTURE_MIN_FILTER, static_cast<GLint>(m));
 	}
 
 	int texture::get_width()const{
@@ -147,10 +155,8 @@ namespace gfx{
 	void texture::bind()const{
 		glBindTexture(GL_TEXTURE_2D, m_tex_id);
 	}
-	void texture::use(GLuint tunit, GLint uloc)const{
-		glActiveTexture(GL_TEXTURE0 + tunit);
-		bind();
-		glUniform1i(uloc, tunit);
+	void texture::bind_unit(GLuint tunit)const{
+		glBindTextureUnit(tunit, m_tex_id);
 	}
 
 
diff --git a/src/graphics/vao.cpp b/src/graphics/vao.cpp
index f138c0f..77f2a9e 100644
--- a/src/graphics/vao.cpp
+++ b/src/graphics/vao.cpp
@@ -21,202 +21,44 @@
 
 namespace gfx{
 
-	void vertex_attribute::enable_array_mode(){
-		glBindVertexArray(m_vao);
-		glEnableVertexAttribArray(m_index);
+	void vertex_attribute::enable(){
+		glEnableVertexArrayAttrib(m_vao, m_index);
 	}
-	void vertex_attribute::disable_array_mode(){
-		glBindVertexArray(m_vao);
-		glEnableVertexAttribArray(m_index);
+	void vertex_attribute::disable(){
+		glDisableVertexArrayAttrib(m_vao, m_index);
 	}
-	void vertex_attribute::set_float_pointer(GLint size, GLsizei stride, GLsizei offset){
-		glBindVertexArray(m_vao);
-		glVertexAttribPointer(m_index, size, GL_FLOAT, GL_FALSE, sizeof(GLfloat) * stride, (void*)(sizeof(GLfloat) * offset));
+	void vertex_attribute::associate_with(GLuint buffer_binding){
+		glVertexArrayAttribBinding(m_vao, m_index, buffer_binding);
 	}
-	void vertex_attribute::set_double_pointer(GLint size, GLsizei stride, GLsizei offset){
-		glBindVertexArray(m_vao);
-		glVertexAttribPointer(m_index, size, GL_DOUBLE, GL_FALSE, sizeof(GLdouble) * stride, (void*)(sizeof(GLdouble) * offset));
+
+	void vertex_attribute::set_float_array(GLint size, GLsizei offset){
+		glVertexArrayAttribFormat(m_vao, m_index, size, GL_FLOAT, GL_FALSE, sizeof(GLfloat) * offset);
 	}
-	void vertex_attribute::set_byte_pointer(GLint size, GLsizei stride, GLsizei offset){
-		glBindVertexArray(m_vao);
-		glVertexAttribPointer(m_index, size, GL_BYTE, GL_FALSE, sizeof(GLbyte) * stride, (void*)(sizeof(GLbyte) * offset));
+	void vertex_attribute::set_double_array(GLint size, GLsizei offset){
+		glVertexArrayAttribFormat(m_vao, m_index, size, GL_DOUBLE, GL_FALSE, sizeof(GLdouble) * offset);
 	}
-	void vertex_attribute::set_ubyte_pointer(GLint size, GLsizei stride, GLsizei offset){
-		glBindVertexArray(m_vao);
-		glVertexAttribPointer(m_index, size, GL_UNSIGNED_BYTE, GL_FALSE, sizeof(GLubyte) * stride, (void*)(sizeof(GLubyte) * offset));
+	void vertex_attribute::set_byte_array(GLint size, GLsizei offset){
+		glVertexArrayAttribFormat(m_vao, m_index, size, GL_BYTE, GL_FALSE, sizeof(GLbyte) * offset);
 	}
-	void vertex_attribute::set_short_pointer(GLint size, GLsizei stride, GLsizei offset){
-		glBindVertexArray(m_vao);
-		glVertexAttribPointer(m_index, size, GL_SHORT, GL_FALSE, sizeof(GLshort) * stride, (void*)(sizeof(GLshort) * offset));
+	void vertex_attribute::set_ubyte_array(GLint size, GLsizei offset){
+		glVertexArrayAttribFormat(m_vao, m_index, size, GL_UNSIGNED_BYTE, GL_FALSE, sizeof(GLubyte) * offset);
 	}
-	void vertex_attribute::set_ushort_pointer(GLint size, GLsizei stride, GLsizei offset){
-		glBindVertexArray(m_vao);
-		glVertexAttribPointer(m_index, size, GL_UNSIGNED_SHORT, GL_FALSE, sizeof(GLushort) * stride, (void*)(sizeof(GLushort) * offset));
+	void vertex_attribute::set_short_array(GLint size, GLsizei offset){
+		glVertexArrayAttribFormat(m_vao, m_index, size, GL_SHORT, GL_FALSE, sizeof(GLshort) * offset);
 	}
-	void vertex_attribute::set_int_pointer(GLint size, GLsizei stride, GLsizei offset){
-		glBindVertexArray(m_vao);
-		glVertexAttribPointer(m_index, size, GL_INT, GL_FALSE, sizeof(GLint) * stride, (void*)(sizeof(GLint) * offset));
+	void vertex_attribute::set_ushort_array(GLint size, GLsizei offset){
+		glVertexArrayAttribFormat(m_vao, m_index, size, GL_UNSIGNED_SHORT, GL_FALSE, sizeof(GLushort) * offset);
 	}
-	void vertex_attribute::set_uint_pointer(GLint size, GLsizei stride, GLsizei offset){
-		glBindVertexArray(m_vao);
-		glVertexAttribPointer(m_index, size, GL_UNSIGNED_INT, GL_FALSE, sizeof(GLuint) * stride, (void*)(sizeof(GLuint) * offset));
+	void vertex_attribute::set_int_array(GLint size, GLsizei offset){
+		glVertexArrayAttribFormat(m_vao, m_index, size, GL_INT, GL_FALSE, sizeof(GLint) * offset);
 	}
-	void vertex_attribute::set(GLfloat x){
-		glBindVertexArray(m_vao);
-		glVertexAttrib1f(m_index, x);
-	}
-	void vertex_attribute::set(GLshort x){
-		glBindVertexArray(m_vao);
-		glVertexAttrib1s(m_index, x);
-	}
-	void vertex_attribute::set(GLdouble x){
-		glBindVertexArray(m_vao);
-		glVertexAttrib1d(m_index, x);
-	}
-	void vertex_attribute::set(GLint x){
-		glBindVertexArray(m_vao);
-		glVertexAttribI1i(m_index, x);
-	}
-	void vertex_attribute::set(GLuint x){
-		glBindVertexArray(m_vao);
-		glVertexAttribI1ui(m_index, x);
-	}
-	void vertex_attribute::set(GLfloat x, GLfloat y){
-		glBindVertexArray(m_vao);
-		glVertexAttrib2f(m_index, x, y);
-	}
-	void vertex_attribute::set(GLshort x, GLshort y){
-		glBindVertexArray(m_vao);
-		glVertexAttrib2s(m_index, x, y);
-	}
-	void vertex_attribute::set(GLdouble x, GLdouble y){
-		glBindVertexArray(m_vao);
-		glVertexAttrib2d(m_index, x, y);
-	}
-	void vertex_attribute::set(GLint x, GLint y){
-		glBindVertexArray(m_vao);
-		glVertexAttribI2i(m_index, x, y);
-	}
-	void vertex_attribute::set(GLuint x, GLuint y){
-		glBindVertexArray(m_vao);
-		glVertexAttribI2ui(m_index, x, y);
-	}
-	void vertex_attribute::set(GLfloat x, GLfloat y, GLfloat z){
-		glBindVertexArray(m_vao);
-		glVertexAttrib3f(m_index, x, y, z);
-	}
-	void vertex_attribute::set(GLshort x, GLshort y, GLshort z){
-		glBindVertexArray(m_vao);
-		glVertexAttrib3s(m_index, x, y, z);
-	}
-	void vertex_attribute::set(GLdouble x, GLdouble y, GLdouble z){
-		glBindVertexArray(m_vao);
-		glVertexAttrib3d(m_index, x, y, z);
-	}
-	void vertex_attribute::set(GLint x, GLint y, GLint z){
-		glBindVertexArray(m_vao);
-		glVertexAttribI3i(m_index, x, y, z);
-	}
-	void vertex_attribute::set(GLuint x, GLuint y, GLuint z){
-		glBindVertexArray(m_vao);
-		glVertexAttribI3ui(m_index, x, y, z);
-	}
-	void vertex_attribute::set(GLfloat x, GLfloat y, GLfloat z, GLfloat w){
-		glBindVertexArray(m_vao);
-		glVertexAttrib4f(m_index, x, y, z, w);
-	}
-	void vertex_attribute::set(GLshort x, GLshort y, GLshort z, GLshort w){
-		glBindVertexArray(m_vao);
-		glVertexAttrib4s(m_index, x, y, z, w);
-	}
-	void vertex_attribute::set(GLdouble x, GLdouble y, GLdouble z, GLdouble w){
-		glBindVertexArray(m_vao);
-		glVertexAttrib4d(m_index, x, y, z, w);
-	}
-	void vertex_attribute::set(GLint x, GLint y, GLint z, GLint w){
-		glBindVertexArray(m_vao);
-		glVertexAttribI4i(m_index, x, y, z, w);
-	}
-	void vertex_attribute::set(GLuint x, GLuint y, GLuint z, GLuint w){
-		glBindVertexArray(m_vao);
-		glVertexAttribI4ui(m_index, x, y, z, w);
-	}
-	void vertex_attribute::set(const vec2<GLfloat>& v){
-		glBindVertexArray(m_vao);
-		glVertexAttrib2fv(m_index, v);
-	}
-	void vertex_attribute::set(const vec2<GLshort>& v){
-		glBindVertexArray(m_vao);
-		glVertexAttrib2sv(m_index, v);
-	}
-	void vertex_attribute::set(const vec2<GLdouble>& v){
-		glBindVertexArray(m_vao);
-		glVertexAttrib2dv(m_index, v);
-	}
-	void vertex_attribute::set(const vec2<GLint>& v){
-		glBindVertexArray(m_vao);
-		glVertexAttribI2iv(m_index, v);
-	}
-	void vertex_attribute::set(const vec2<GLuint>& v){
-		glBindVertexArray(m_vao);
-		glVertexAttribI2uiv(m_index, v);
-	}
-	void vertex_attribute::set(const vec3<GLfloat>& v){
-		glBindVertexArray(m_vao);
-		glVertexAttrib3fv(m_index, v);
-	}
-	void vertex_attribute::set(const vec3<GLshort>& v){
-		glBindVertexArray(m_vao);
-		glVertexAttrib3sv(m_index, v);
-	}
-	void vertex_attribute::set(const vec3<GLdouble>& v){
-		glBindVertexArray(m_vao);
-		glVertexAttrib3dv(m_index, v);
-	}
-	void vertex_attribute::set(const vec3<GLint>& v){
-		glBindVertexArray(m_vao);
-		glVertexAttribI3iv(m_index, v);
-	}
-	void vertex_attribute::set(const vec3<GLuint>& v){
-		glBindVertexArray(m_vao);
-		glVertexAttribI3uiv(m_index, v);
-	}
-	void vertex_attribute::set(const vec4<GLfloat>& v){
-		glBindVertexArray(m_vao);
-		glVertexAttrib4fv(m_index, v);
-	}
-	void vertex_attribute::set(const vec4<GLshort>& v){
-		glBindVertexArray(m_vao);
-		glVertexAttrib4sv(m_index, v);
-	}
-	void vertex_attribute::set(const vec4<GLdouble>& v){
-		glBindVertexArray(m_vao);
-		glVertexAttrib4dv(m_index, v);
-	}
-	void vertex_attribute::set(const vec4<GLint>& v){
-		glBindVertexArray(m_vao);
-		glVertexAttrib4iv(m_index, v);
-	}
-	void vertex_attribute::set(const vec4<GLuint>& v){
-		glBindVertexArray(m_vao);
-		glVertexAttrib4uiv(m_index, v);
-	}
-	void vertex_attribute::set(const vec4<GLbyte>& v){
-		glBindVertexArray(m_vao);
-		glVertexAttrib4bv(m_index, v);
-	}
-	void vertex_attribute::set(const vec4<GLubyte>& v){
-		glBindVertexArray(m_vao);
-		glVertexAttrib4ubv(m_index, v);
-	}
-	void vertex_attribute::set(const vec4<GLushort>& v){
-		glBindVertexArray(m_vao);
-		glVertexAttrib4usv(m_index, v);
+	void vertex_attribute::set_uint_array(GLint size, GLsizei offset){
+		glVertexArrayAttribFormat(m_vao, m_index, size, GL_UNSIGNED_INT, GL_FALSE, sizeof(GLuint) * offset);
 	}
 
 
 	vao::vao(){
-		glGenVertexArrays(1, &m_buffer);
+		glCreateVertexArrays(1, &m_buffer);
 	}
 	vao::vao(vao&& v):
 		m_buffer(std::exchange(v.m_buffer, 0)){}
@@ -232,6 +74,12 @@ namespace gfx{
 		return m_buffer;
 	}
 
+	void vao::bind_buffer(const vbo& buffer, GLuint bind_point, GLuint offset, GLuint stride){
+		glVertexArrayVertexBuffer(m_buffer, bind_point, buffer.raw(), offset, stride);
+	}
+	void vao::bind_element_buffer(const vbo& buffer){
+		glVertexArrayElementBuffer(m_buffer, buffer.raw());
+	}
 	vertex_attribute vao::get_attribute(int index){
 		return vertex_attribute(m_buffer, index);
 	}
diff --git a/src/graphics/vbo.cpp b/src/graphics/vbo.cpp
index fabdb9a..cafb28f 100644
--- a/src/graphics/vbo.cpp
+++ b/src/graphics/vbo.cpp
@@ -18,7 +18,6 @@
 
 #include "graphics/vbo.hpp"
 #include "util/minmax.hpp"
-#include "graphics/scoped_buffer_bind.hpp"
 
 #include <utility> //exchange, swap, move
 
@@ -27,28 +26,21 @@ namespace gfx{
 	vbo::vbo(size_t size, usage t):
 		m_buffer_size(0)
 	{
-		glGenBuffers(1, &m_buffer);
-		m_bi.set_buffer_id(m_buffer);
-		bind(buffer::copy_write);
-		glBufferData(m_bi.get_bound_id(), size, NULL, static_cast<GLenum>(t));
+		glCreateBuffers(1, &m_buffer);
+		glNamedBufferData(m_buffer, size, NULL, static_cast<GLenum>(t));
 	}
 	vbo::vbo(const vbo& v):
 		m_buffer_size(v.m_buffer_size)
 	{
-		glGenBuffers(1, &m_buffer);
-		m_bi.set_buffer_id(m_buffer);
-		scoped_buffer_bind copy_bind(m_bi, buffer::copy_read);
-		if(!copy_bind.valid())
-			return;
-		scoped_vbo_map<void> data = v.map(buffer::copy_read, maptype::READ);
+		glCreateBuffers(1, &m_buffer);
+		scoped_vbo_map<void> data = v.map(maptype::READ);
 		if(!data)
 			return;
-		glBufferData(m_bi.get_bound_id(), v.get_size(), data, static_cast<GLenum>(v.get_usage()));
+		glNamedBufferData(m_buffer, v.get_size(), data, static_cast<GLenum>(v.get_usage()));
 	}
 	vbo::vbo(vbo&& v):
 		m_buffer(std::exchange(v.m_buffer, 0)),
-		m_buffer_size(v.m_buffer_size),
-		m_bi(std::move(v.m_bi)){}
+		m_buffer_size(v.m_buffer_size){}
 	vbo::~vbo(){
 		if(m_buffer)
 			glDeleteBuffers(1, &m_buffer);
@@ -59,45 +51,20 @@ namespace gfx{
 	}
 	vbo& vbo::operator=(vbo&& v){
 		std::swap(m_buffer, v.m_buffer);
-		m_bi = std::move(v.m_bi);
 		m_buffer_size = v.m_buffer_size;
 		return *this;
 	}
 	bool vbo::bind(gl_buffer_manager& buf)const{
-		if(get_bound_id() == buf.get_buffer_id())
-			return true;
-		if(!m_bi.bind(buf))
-			return false;
+		glBindBuffer(buf.get_buffer_id(), m_buffer);
 		return true;
 	}
-	bool vbo::bind_lock(gl_buffer_manager& buf)const{
-		if(!m_bi.bind_lock(buf))
-			return false;
-		return true;
-	}
-	void vbo::bind_unlock()const{
-		m_bi.unlock();
-	}
-
-	void vbo::unbind()const{
-		m_bi.unbind();
-	}
-	gl_buffer_manager* vbo::get_bound_buffer()const{
-		return m_bi.get_bound_buffer();
-	}
-	GLenum vbo::get_bound_id()const{
-		return m_bi.get_bound_id();
-	}
 
 	bool vbo::buffer(const void* data, size_t datasize){
 		if(datasize + m_buffer_size > get_cap()){
 			if(!resize(util::max(datasize + m_buffer_size, get_cap() * 2)))
 				return false;
 		}
-		scoped_buffer_bind copy_bind(m_bi, buffer::copy_write);
-		if(!copy_bind.valid())
-			return false;
-		glBufferSubData(get_bound_id(), get_size(), datasize, data);
+		glNamedBufferSubData(m_buffer, get_size(), datasize, data);
 		m_buffer_size += datasize;
 		return true;
 	}
@@ -111,8 +78,8 @@ namespace gfx{
 	GLuint vbo::raw()const{
 		return m_buffer;
 	}
-	scoped_vbo_map<void> vbo::map(gl_buffer_manager& target, maptype m)const{
-		return scoped_vbo_map<void>(m_bi, target, m_buffer, m);
+	scoped_vbo_map<void> vbo::map(maptype m)const{
+		return scoped_vbo_map<void>(m_buffer, m);
 	}
 
 	void vbo::clear(){
@@ -122,57 +89,50 @@ namespace gfx{
 		return m_buffer_size;
 	}
 	size_t vbo::get_cap()const{
-		scoped_buffer_bind copy_bind(m_bi, buffer::copy_read);
 		GLint retval;
-		glGetBufferParameteriv(get_bound_id(), GL_BUFFER_SIZE, &retval);
+		glGetNamedBufferParameteriv(m_buffer, GL_BUFFER_SIZE, &retval);
 		return retval;
 	}
 	auto vbo::get_usage()const -> usage{
-		scoped_buffer_bind copy_bind(m_bi, buffer::copy_read);
 		GLint retval;
-		glGetBufferParameteriv(get_bound_id(), GL_BUFFER_USAGE, &retval);
+		glGetNamedBufferParameteriv(m_buffer, GL_BUFFER_USAGE, &retval);
 		return static_cast<usage>(retval);
 	}
 
 	bool vbo::copy_buffer(vbo& dest, const vbo& src){
-		scoped_buffer_bind copy_bind(dest.m_bi, buffer::copy_write);
-		if(!copy_bind.valid())
-			return false;
-
 		size_t bytes = util::min(dest.get_cap(), src.get_size());
-		scoped_vbo_map<void> data(src.m_bi, buffer::copy_read, src.m_buffer, maptype::READ);
+		scoped_vbo_map<void> data(src.m_buffer, maptype::READ);
 		if(!data.valid())
 			return false;
 		return dest.buffer(data, bytes);
 	}
 
 
-	scoped_vbo_map<void>::scoped_vbo_map(const buffer_accessor& ba, gl_buffer_manager& bm, GLuint bid, vbo::maptype m):
-		m_bind(ba, bm, bid)
+	scoped_vbo_map<void>::scoped_vbo_map(GLuint bid, vbo::maptype m):
+		m_buffer(bid)
 	{
-		if(!m_bind.valid())
-			return;
-		m_data = reinterpret_cast<pointer>(glMapBuffer(m_bind.get_bound_id(), static_cast<GLenum>(m)));
+		m_data = reinterpret_cast<pointer>(glMapNamedBuffer(m_buffer, static_cast<GLenum>(m)));
 	}
 	scoped_vbo_map<void>::scoped_vbo_map(scoped_vbo_map&& m):
 		m_data(std::exchange(m.m_data, nullptr)),
-		m_bind(std::move(m.m_bind)){}
+		m_buffer(std::exchange(m.m_buffer, 0)){}
 	scoped_vbo_map<void>::~scoped_vbo_map(){
 		if(m_data){
-			glUnmapBuffer(m_bind.get_bound_id());
+			glUnmapNamedBuffer(m_buffer);
 		}
 	}
 	scoped_vbo_map<void>& scoped_vbo_map<void>::operator=(scoped_vbo_map&& m){
 		std::swap(m_data, m.m_data);
-		m_bind = std::move(m.m_bind);
+		std::swap(m_buffer, m.m_buffer);
 		return *this;
 	}
 	auto scoped_vbo_map<void>::length()const -> size_type{
 		GLint64 retval;
-		glGetBufferParameteri64v(m_bind.get_bound_id(), GL_BUFFER_MAP_LENGTH, &retval);
+		glGetNamedBufferParameteri64v(m_buffer, GL_BUFFER_MAP_LENGTH, &retval);
 		return retval;
 	}
 	auto scoped_vbo_map<void>::release() -> pointer{
+		m_buffer = 0;
 		return std::exchange(m_data, nullptr);
 	}
 	scoped_vbo_map<void>::operator pointer(){
diff --git a/src/main.cpp b/src/main.cpp
index 4318849..5fe95fa 100644
--- a/src/main.cpp
+++ b/src/main.cpp
@@ -320,11 +320,11 @@ int main(){
 	}
 
 	//tell gl how to interpret the data in the vbo
-	normal_vao.bind();
-	normal_vbo.bind(gfx::buffer::array);
+	normal_vao.bind_buffer(normal_vbo, 0, 0, sizeof(GLfloat) * 3);
 	auto attrib = normal_vao.get_attribute(0);
-	attrib.set_float_pointer(3, 3, 0);
-	attrib.enable_array_mode();
+	attrib.set_float_array(3, 0);
+	attrib.associate_with(0);
+	attrib.enable();
 
 	constexpr GLfloat square_coords[] = {
 		-1,  1, 0, 1,
@@ -341,14 +341,16 @@ int main(){
 
 
 	screen_vbo.buffer(square_coords, sizeof(square_coords));
-	screen_vao.bind();
-	screen_vbo.bind(gfx::buffer::array);
+
+	screen_vao.bind_buffer(screen_vbo, 0, 0, sizeof(GLfloat) * 4);
 	attrib = screen_vao.get_attribute(0);
-	attrib.set_float_pointer(2, 4, 0);
-	attrib.enable_array_mode();
+	attrib.set_float_array(2, 0);
+	attrib.associate_with(0);
+	attrib.enable();
 	attrib = screen_vao.get_attribute(1);
-	attrib.set_float_pointer(2, 4, 2);
-	attrib.enable_array_mode();
+	attrib.set_float_array(2, 2);
+	attrib.associate_with(0);
+	attrib.enable();
 
 	while(!manager.should_close()){
 		//render using program 'prog' with data from 'vao'
@@ -358,7 +360,8 @@ int main(){
 		normal_shader.use();
 		normal_vao.bind();
 		glDrawArrays(GL_POINTS, 0, 9);
-		fbo.unbind();
+
+		glBindFramebuffer(GL_FRAMEBUFFER, 0);
 		glDisable(GL_DEPTH_TEST);
 		screen_shader.use();
 		screen_shader.set_uniform("fbtexture", tex, 0);