diff --git a/examples/deferred/main.rs b/examples/deferred/main.rs
index 549ab6e4d30..c35b6dc8530 100644
--- a/examples/deferred/main.rs
+++ b/examples/deferred/main.rs
@@ -101,7 +101,7 @@ struct LightParams {
     #[name = "u_Transform"]
     transform: [[f32; 4]; 4],
     #[name = "u_LightPosBlock"]
-    light_pos_buf: gfx::RawBufferHandle,
+    light_pos_buf: gfx::RawBufferHandle<gfx::GlResources>,
     #[name = "u_Radius"]
     radius: f32,
     #[name = "u_CameraPos"]
@@ -121,7 +121,7 @@ struct EmitterParams {
     #[name = "u_Transform"]
     transform: [[f32; 4]; 4],
     #[name = "u_LightPosBlock"]
-    light_pos_buf: gfx::RawBufferHandle,
+    light_pos_buf: gfx::RawBufferHandle<gfx::GlResources>,
     #[name = "u_Radius"]
     radius: f32,
 }
@@ -307,7 +307,9 @@ fn calculate_color(height: f32) -> [f32; 3] {
     }
 }
 
-fn create_g_buffer(width: u16, height: u16, device: &mut gfx::GlDevice) -> (gfx::Frame, TextureHandle, TextureHandle, TextureHandle, TextureHandle) {
+fn create_g_buffer(width: u16, height: u16, device: &mut gfx::GlDevice)
+        -> (gfx::Frame, TextureHandle<gfx::GlResources>, TextureHandle<gfx::GlResources>,
+            TextureHandle<gfx::GlResources>, TextureHandle<gfx::GlResources>) {
     let mut frame = gfx::Frame::new(width, height);
 
     let texture_info_float = gfx::tex::TextureInfo {
@@ -343,7 +345,8 @@ fn create_g_buffer(width: u16, height: u16, device: &mut gfx::GlDevice) -> (gfx:
     (frame, texture_pos, texture_normal, texture_diffuse, texture_depth)
 }
 
-fn create_res_buffer(width: u16, height: u16, device: &mut gfx::GlDevice, texture_depth: TextureHandle) -> (gfx::Frame, TextureHandle, TextureHandle) {
+fn create_res_buffer(width: u16, height: u16, device: &mut gfx::GlDevice, texture_depth: TextureHandle<gfx::GlResources>)
+        -> (gfx::Frame, TextureHandle<gfx::GlResources>, TextureHandle<gfx::GlResources>) {
     let mut frame = gfx::Frame::new(width, height);
 
     let texture_info_float = gfx::tex::TextureInfo {
@@ -567,7 +570,7 @@ fn main() {
         tex: (texture_pos, Some(sampler)),
     };
 
-    let mut debug_buf: Option<TextureHandle> = None;
+    let mut debug_buf: Option<TextureHandle<gfx::GlResources>> = None;
 
     let mut light_pos_vec: Vec<[f32; 4]> = (0 ..NUM_LIGHTS).map(|_| {
         [0.0, 0.0, 0.0, 0.0]
diff --git a/src/device/draw.rs b/src/device/draw.rs
index 8348e8bc8ee..3b9063c10fd 100644
--- a/src/device/draw.rs
+++ b/src/device/draw.rs
@@ -19,6 +19,7 @@ use back;
 use shade;
 use target;
 use tex;
+use Resources;
 
 type Offset = u32;
 type Size = u32;
@@ -77,6 +78,8 @@ impl DataBuffer {
 /// An interface of the abstract command buffer. It collects commands in an
 /// efficient API-specific manner, to be ready for execution on the device.
 pub trait CommandBuffer {
+    type Resources: Resources;
+
     /// An empty constructor
     fn new() -> Self;
     /// Clear the command buffer contents, retain the allocated storage
@@ -105,7 +108,7 @@ pub trait CommandBuffer {
     fn bind_uniform(&mut self, shade::Location, shade::UniformValue);
     /// Bind a texture
     fn bind_texture(&mut self, ::TextureSlot, tex::TextureKind, back::Texture,
-                    Option<::SamplerHandle>);
+                    Option<::SamplerHandle<back::GlResources>>);
     /// Select, which color buffers are going to be targetted by the shader
     fn set_draw_color_buffers(&mut self, usize);
     /// Set primitive topology
diff --git a/src/device/gl_device/draw.rs b/src/device/gl_device/draw.rs
index c489d456d71..420e28ae98d 100644
--- a/src/device/gl_device/draw.rs
+++ b/src/device/gl_device/draw.rs
@@ -14,22 +14,58 @@
 
 //! OpenGL implementation of the Command Buffer
 
-use Command;
 use std::slice;
 
-pub struct GlCommandBuffer {
-    buf: Vec<::Command>,
+use {attrib, back, draw, target, tex, shade, state};
+use {AttributeSlot, IndexType, InstanceCount, PrimitiveType, TextureSlot, UniformBlockIndex, UniformBufferSlot, VertexCount};
+use super::{ArrayBuffer, Buffer, FrameBuffer, Program, Surface, Texture};
+
+/// Serialized device command.
+#[derive(Copy, Debug)]
+pub enum Command {
+    BindProgram(Program),
+    BindArrayBuffer(ArrayBuffer),
+    BindAttribute(AttributeSlot, Buffer, attrib::Format),
+    BindIndex(Buffer),
+    BindFrameBuffer(target::Access, FrameBuffer),
+    UnbindTarget(target::Access, target::Target),
+    BindTargetSurface(target::Access, target::Target, Surface),
+    BindTargetTexture(target::Access, target::Target, Texture, target::Level, Option<target::Layer>),
+    BindUniformBlock(Program, UniformBufferSlot, UniformBlockIndex, Buffer),
+    BindUniform(shade::Location, shade::UniformValue),
+    BindTexture(TextureSlot, tex::TextureKind, Texture, Option<::SamplerHandle<back::GlResources>>),
+    SetDrawColorBuffers(usize),
+    SetPrimitiveState(state::Primitive),
+    SetViewport(target::Rect),
+    SetMultiSampleState(Option<state::MultiSample>),
+    SetScissor(Option<target::Rect>),
+    SetDepthStencilState(Option<state::Depth>, Option<state::Stencil>, state::CullMode),
+    SetBlendState(Option<state::Blend>),
+    SetColorMask(state::ColorMask),
+    UpdateBuffer(Buffer, draw::DataPointer, usize),
+    UpdateTexture(tex::TextureKind, Texture, tex::ImageInfo, draw::DataPointer),
+    // drawing
+    Clear(target::ClearData, target::Mask),
+    Draw(PrimitiveType, VertexCount, VertexCount, Option<(InstanceCount, VertexCount)>),
+    DrawIndexed(PrimitiveType, IndexType, VertexCount, VertexCount, VertexCount, Option<(InstanceCount, VertexCount)>),
+    Blit(target::Rect, target::Rect, target::Mirror, target::Mask),
 }
 
-impl GlCommandBuffer {
-    pub fn iter<'a>(&'a self) -> slice::Iter<'a, ::Command> {
+pub struct CommandBuffer {
+    buf: Vec<Command>,
+}
+
+impl CommandBuffer {
+    pub fn iter<'a>(&'a self) -> slice::Iter<'a, Command> {
         self.buf.iter()
     }
 }
 
-impl ::draw::CommandBuffer for GlCommandBuffer {
-    fn new() -> GlCommandBuffer {
-        GlCommandBuffer {
+impl draw::CommandBuffer for CommandBuffer {
+    type Resources = super::GlResources;
+
+    fn new() -> CommandBuffer {
+        CommandBuffer {
             buf: Vec::new(),
         }
     }
@@ -38,44 +74,44 @@ impl ::draw::CommandBuffer for GlCommandBuffer {
         self.buf.clear();
     }
 
-    fn bind_program(&mut self, prog: super::Program) {
+    fn bind_program(&mut self, prog: Program) {
         self.buf.push(Command::BindProgram(prog));
     }
 
-    fn bind_array_buffer(&mut self, vao: super::ArrayBuffer) {
+    fn bind_array_buffer(&mut self, vao: ArrayBuffer) {
         self.buf.push(Command::BindArrayBuffer(vao));
     }
 
-    fn bind_attribute(&mut self, slot: ::AttributeSlot, buf: super::Buffer,
+    fn bind_attribute(&mut self, slot: ::AttributeSlot, buf: Buffer,
                       format: ::attrib::Format) {
         self.buf.push(Command::BindAttribute(slot, buf, format));
     }
 
-    fn bind_index(&mut self, buf: super::Buffer) {
+    fn bind_index(&mut self, buf: Buffer) {
         self.buf.push(Command::BindIndex(buf));
     }
 
-    fn bind_frame_buffer(&mut self, access: ::target::Access, fbo: super::FrameBuffer) {
+    fn bind_frame_buffer(&mut self, access: target::Access, fbo: FrameBuffer) {
         self.buf.push(Command::BindFrameBuffer(access, fbo));
     }
 
-    fn unbind_target(&mut self, access: ::target::Access, tar: ::target::Target) {
+    fn unbind_target(&mut self, access: target::Access, tar: target::Target) {
         self.buf.push(Command::UnbindTarget(access, tar));
     }
 
-    fn bind_target_surface(&mut self, access: ::target::Access,
-                           tar: ::target::Target, suf: super::Surface) {
+    fn bind_target_surface(&mut self, access: target::Access,
+                           tar: target::Target, suf: Surface) {
         self.buf.push(Command::BindTargetSurface(access, tar, suf));
     }
 
-    fn bind_target_texture(&mut self, access: ::target::Access,
-                           tar: ::target::Target, tex: super::Texture,
-                           level: ::target::Level, layer: Option<::target::Layer>) {
+    fn bind_target_texture(&mut self, access: target::Access,
+                           tar: target::Target, tex: Texture,
+                           level: target::Level, layer: Option<target::Layer>) {
         self.buf.push(Command::BindTargetTexture(access, tar, tex, level, layer));
     }
 
-    fn bind_uniform_block(&mut self, prog: super::Program, slot: ::UniformBufferSlot,
-                          index: ::UniformBlockIndex, buf: super::Buffer) {
+    fn bind_uniform_block(&mut self, prog: Program, slot: ::UniformBufferSlot,
+                          index: ::UniformBlockIndex, buf: Buffer) {
         self.buf.push(Command::BindUniformBlock(prog, slot, index, buf));
     }
 
@@ -83,7 +119,7 @@ impl ::draw::CommandBuffer for GlCommandBuffer {
         self.buf.push(Command::BindUniform(loc, value));
     }
     fn bind_texture(&mut self, slot: ::TextureSlot, kind: ::tex::TextureKind,
-                    tex: super::Texture, sampler: Option<::SamplerHandle>) {
+                    tex: Texture, sampler: Option<::SamplerHandle<back::GlResources>>) {
         self.buf.push(Command::BindTexture(slot, kind, tex, sampler));
     }
 
@@ -91,46 +127,46 @@ impl ::draw::CommandBuffer for GlCommandBuffer {
         self.buf.push(Command::SetDrawColorBuffers(num));
     }
 
-    fn set_primitive(&mut self, prim: ::state::Primitive) {
+    fn set_primitive(&mut self, prim: state::Primitive) {
         self.buf.push(Command::SetPrimitiveState(prim));
     }
 
-    fn set_viewport(&mut self, view: ::target::Rect) {
+    fn set_viewport(&mut self, view: target::Rect) {
         self.buf.push(Command::SetViewport(view));
     }
 
-    fn set_multi_sample(&mut self, ms: Option<::state::MultiSample>) {
+    fn set_multi_sample(&mut self, ms: Option<state::MultiSample>) {
         self.buf.push(Command::SetMultiSampleState(ms));
     }
 
-    fn set_scissor(&mut self, rect: Option<::target::Rect>) {
+    fn set_scissor(&mut self, rect: Option<target::Rect>) {
         self.buf.push(Command::SetScissor(rect));
     }
 
-    fn set_depth_stencil(&mut self, depth: Option<::state::Depth>,
-                         stencil: Option<::state::Stencil>, cull: ::state::CullMode) {
+    fn set_depth_stencil(&mut self, depth: Option<state::Depth>,
+                         stencil: Option<state::Stencil>, cull: state::CullMode) {
         self.buf.push(Command::SetDepthStencilState(depth, stencil, cull));
     }
 
-    fn set_blend(&mut self, blend: Option<::state::Blend>) {
+    fn set_blend(&mut self, blend: Option<state::Blend>) {
         self.buf.push(Command::SetBlendState(blend));
     }
 
-    fn set_color_mask(&mut self, mask: ::state::ColorMask) {
+    fn set_color_mask(&mut self, mask: state::ColorMask) {
         self.buf.push(Command::SetColorMask(mask));
     }
 
-    fn update_buffer(&mut self, buf: super::Buffer, data: ::draw::DataPointer,
+    fn update_buffer(&mut self, buf: Buffer, data: draw::DataPointer,
                         offset_bytes: usize) {
         self.buf.push(Command::UpdateBuffer(buf, data, offset_bytes));
     }
 
-    fn update_texture(&mut self, kind: ::tex::TextureKind, tex: super::Texture,
-                      info: ::tex::ImageInfo, data: ::draw::DataPointer) {
+    fn update_texture(&mut self, kind: ::tex::TextureKind, tex: Texture,
+                      info: ::tex::ImageInfo, data: draw::DataPointer) {
         self.buf.push(Command::UpdateTexture(kind, tex, info, data));
     }
 
-    fn call_clear(&mut self, data: ::target::ClearData, mask: ::target::Mask) {
+    fn call_clear(&mut self, data: target::ClearData, mask: target::Mask) {
         self.buf.push(Command::Clear(data, mask));
     }
 
@@ -145,8 +181,8 @@ impl ::draw::CommandBuffer for GlCommandBuffer {
         self.buf.push(Command::DrawIndexed(ptype, itype, start, count, base, instances));
     }
 
-    fn call_blit(&mut self, s_rect: ::target::Rect, d_rect: ::target::Rect,
-                 mirror: ::target::Mirror, mask: ::target::Mask) {
+    fn call_blit(&mut self, s_rect: target::Rect, d_rect: target::Rect,
+                 mirror: target::Mirror, mask: target::Mask) {
         self.buf.push(Command::Blit(s_rect, d_rect, mirror, mask));
     }
 }
diff --git a/src/device/gl_device/lib.rs b/src/device/gl_device/lib.rs
index 33049245347..72cbf4691f0 100644
--- a/src/device/gl_device/lib.rs
+++ b/src/device/gl_device/lib.rs
@@ -28,11 +28,9 @@ use state::{CullMode, RasterMethod, WindingOrder};
 use target::{Access, Target};
 
 use BufferUsage;
-use Command;
-use Device;
+use {Device, Resources};
 use {MapAccess, ReadableMapping, WritableMapping, RWMapping, BufferHandle, PrimitiveType};
-
-pub use self::draw::GlCommandBuffer;
+use self::draw::{Command, CommandBuffer};
 pub use self::info::{Info, PlatformName, Version};
 
 mod draw;
@@ -57,6 +55,20 @@ pub type Surface        = gl::types::GLuint;
 pub type Sampler        = gl::types::GLuint;
 pub type Texture        = gl::types::GLuint;
 
+#[derive(Copy)]
+pub enum GlResources {}
+
+impl Resources for GlResources {
+    type Buffer         = Buffer;
+    type ArrayBuffer    = ArrayBuffer;
+    type Shader         = Shader;
+    type Program        = Program;
+    type FrameBuffer    = FrameBuffer;
+    type Surface        = Surface;
+    type Texture        = Texture;
+    type Sampler        = Sampler;
+}
+
 #[derive(Copy, Eq, PartialEq, Debug)]
 pub enum GlError {
     NoError,
@@ -82,17 +94,17 @@ impl GlError {
     }
 }
 
-static RESET_CB: &'static [Command] = &[
+const RESET_CB: [Command; 11] = [
     Command::BindProgram(0),
     Command::BindArrayBuffer(0),
-    //BindAttribute
+    // BindAttribute
     Command::BindIndex(0),
     Command::BindFrameBuffer(Access::Draw, 0),
     Command::BindFrameBuffer(Access::Read, 0),
-    //UnbindTarget
-    //BindUniformBlock
-    //BindUniform
-    //BindTexture
+    // UnbindTarget
+    // BindUniformBlock
+    // BindUniform
+    // BindTexture
     Command::SetPrimitiveState(::state::Primitive {
         front_face: WindingOrder::CounterClockwise,
         method: RasterMethod::Fill(CullMode::Back),
@@ -170,7 +182,7 @@ impl GlDevice {
     }
 
     /// Fails during a debug build if the implementation's error flag was set.
-    fn check(&mut self, cmd: &::Command) {
+    fn check(&mut self, cmd: &Command) {
         if cfg!(not(ndebug)) {
             let err = GlError::from_error_code(unsafe { self.gl.GetError() });
             if err != GlError::NoError {
@@ -221,7 +233,7 @@ impl GlDevice {
         }
     }
 
-    fn process(&mut self, cmd: &::Command, data_buf: &::draw::DataBuffer) {
+    fn process(&mut self, cmd: &Command, data_buf: &::draw::DataBuffer) {
         match *cmd {
             Command::Clear(ref data, mask) => {
                 let mut flags = 0;
@@ -567,7 +579,8 @@ impl GlDevice {
 }
 
 impl Device for GlDevice {
-    type CommandBuffer = GlCommandBuffer;
+    type Resources = GlResources;
+    type CommandBuffer  = CommandBuffer;
 
     fn get_capabilities<'a>(&'a self) -> &'a ::Capabilities {
         &self.caps
@@ -580,14 +593,14 @@ impl Device for GlDevice {
         }
     }
 
-    fn submit(&mut self, (cb, db): (&GlCommandBuffer, &::draw::DataBuffer)) {
+    fn submit(&mut self, (cb, db): (&CommandBuffer, &::draw::DataBuffer)) {
         self.reset_state();
         for com in cb.iter() {
             self.process(com, db);
         }
     }
 
-    fn create_buffer_raw(&mut self, size: usize, usage: BufferUsage) -> ::BufferHandle<()> {
+    fn create_buffer_raw(&mut self, size: usize, usage: BufferUsage) -> ::BufferHandle<GlResources, ()> {
         let name = self.create_buffer_internal();
         let info = ::BufferInfo {
             usage: usage,
@@ -597,7 +610,7 @@ impl Device for GlDevice {
         ::BufferHandle::from_raw(::Handle(name, info))
     }
 
-    fn create_buffer_static_raw(&mut self, data: &[u8]) -> ::BufferHandle<()> {
+    fn create_buffer_static_raw(&mut self, data: &[u8]) -> ::BufferHandle<GlResources, ()> {
         let name = self.create_buffer_internal();
 
         let info = ::BufferInfo {
@@ -609,7 +622,7 @@ impl Device for GlDevice {
         ::BufferHandle::from_raw(::Handle(name, info))
     }
 
-    fn create_array_buffer(&mut self) -> Result<::ArrayBufferHandle, ()> {
+    fn create_array_buffer(&mut self) -> Result<::ArrayBufferHandle<GlResources>, ()> {
         if self.caps.array_buffer_supported {
             let mut name = 0 as ArrayBuffer;
             unsafe {
@@ -624,7 +637,7 @@ impl Device for GlDevice {
     }
 
     fn create_shader(&mut self, stage: ::shade::Stage, code: &[u8])
-                     -> Result<::ShaderHandle, ::shade::CreateShaderError> {
+                     -> Result<::ShaderHandle<GlResources>, ::shade::CreateShaderError> {
         let (name, info) = shade::create_shader(&self.gl, stage, code);
         info.map(|info| {
             let level = if name.is_err() { LogLevel::Error } else { LogLevel::Warn };
@@ -633,7 +646,7 @@ impl Device for GlDevice {
         name.map(|sh| ::Handle(sh, stage))
     }
 
-    fn create_program(&mut self, shaders: &[::ShaderHandle], targets: Option<&[&str]>) -> Result<::ProgramHandle, ()> {
+    fn create_program(&mut self, shaders: &[::ShaderHandle<GlResources>], targets: Option<&[&str]>) -> Result<::ProgramHandle<GlResources>, ()> {
         let (prog, log) = shade::create_program(&self.gl, &self.caps, shaders, targets);
         log.map(|log| {
             let level = if prog.is_err() { LogLevel::Error } else { LogLevel::Warn };
@@ -642,7 +655,7 @@ impl Device for GlDevice {
         prog
     }
 
-    fn create_frame_buffer(&mut self) -> ::FrameBufferHandle {
+    fn create_frame_buffer(&mut self) -> ::FrameBufferHandle<GlResources> {
         if !self.caps.render_targets_supported {
             panic!("No framebuffer objects, can't make a new one!");
         }
@@ -656,12 +669,12 @@ impl Device for GlDevice {
     }
 
     fn create_surface(&mut self, info: ::tex::SurfaceInfo) ->
-                      Result<::SurfaceHandle, ::tex::SurfaceError> {
+                      Result<::SurfaceHandle<GlResources>, ::tex::SurfaceError> {
         tex::make_surface(&self.gl, &info).map(|suf| ::Handle(suf, info))
     }
 
     fn create_texture(&mut self, info: ::tex::TextureInfo) ->
-                      Result<::TextureHandle, ::tex::TextureError> {
+                      Result<::TextureHandle<GlResources>, ::tex::TextureError> {
         if info.width == 0 || info.height == 0 || info.levels == 0 {
             return Err(::tex::TextureError::InvalidTextureInfo(info))
         }
@@ -674,7 +687,7 @@ impl Device for GlDevice {
         name.map(|tex| ::Handle(tex, info))
     }
 
-    fn create_sampler(&mut self, info: ::tex::SamplerInfo) -> ::SamplerHandle {
+    fn create_sampler(&mut self, info: ::tex::SamplerInfo) -> ::SamplerHandle<GlResources> {
         let sam = if self.caps.sampler_objects_supported {
             tex::make_sampler(&self.gl, &info)
         } else {
@@ -683,61 +696,61 @@ impl Device for GlDevice {
         ::Handle(sam, info)
     }
 
-    fn delete_buffer_raw(&mut self, handle: ::BufferHandle<()>) {
+    fn delete_buffer_raw(&mut self, handle: ::BufferHandle<GlResources, ()>) {
         let name = handle.get_name();
         unsafe {
             self.gl.DeleteBuffers(1, &name);
         }
     }
 
-    fn delete_shader(&mut self, handle: ::ShaderHandle) {
+    fn delete_shader(&mut self, handle: ::ShaderHandle<GlResources>) {
         unsafe { self.gl.DeleteShader(handle.get_name()) };
     }
 
-    fn delete_program(&mut self, handle: ::ProgramHandle) {
+    fn delete_program(&mut self, handle: ::ProgramHandle<GlResources>) {
         unsafe { self.gl.DeleteProgram(handle.get_name()) };
     }
 
-    fn delete_surface(&mut self, handle: ::SurfaceHandle) {
+    fn delete_surface(&mut self, handle: ::SurfaceHandle<GlResources>) {
         let name = handle.get_name();
         unsafe {
             self.gl.DeleteRenderbuffers(1, &name);
         }
     }
 
-    fn delete_texture(&mut self, handle: ::TextureHandle) {
+    fn delete_texture(&mut self, handle: ::TextureHandle<GlResources>) {
         let name = handle.get_name();
         unsafe {
             self.gl.DeleteTextures(1, &name);
         }
     }
 
-    fn delete_sampler(&mut self, handle: ::SamplerHandle) {
+    fn delete_sampler(&mut self, handle: ::SamplerHandle<GlResources>) {
         let name = handle.get_name();
         unsafe {
             self.gl.DeleteSamplers(1, &name);
         }
     }
 
-    fn update_buffer_raw(&mut self, buffer: ::BufferHandle<()>, data: &[u8],
+    fn update_buffer_raw(&mut self, buffer: ::BufferHandle<GlResources, ()>, data: &[u8],
                          offset_bytes: usize) {
         debug_assert!(offset_bytes + data.len() <= buffer.get_info().size);
         self.update_sub_buffer(buffer.get_name(), data.as_ptr(), data.len(),
                                offset_bytes)
     }
 
-    fn update_texture_raw(&mut self, texture: &::TextureHandle,
+    fn update_texture_raw(&mut self, texture: &::TextureHandle<GlResources>,
                           img: &::tex::ImageInfo, data: &[u8])
                           -> Result<(), ::tex::TextureError> {
         tex::update_texture(&self.gl, texture.get_info().kind,
                             texture.get_name(), img, data.as_ptr(), data.len())
     }
 
-    fn generate_mipmap(&mut self, texture: &::TextureHandle) {
+    fn generate_mipmap(&mut self, texture: &::TextureHandle<GlResources>) {
         tex::generate_mipmap(&self.gl, texture.get_info().kind, texture.get_name());
     }
 
-    fn map_buffer_raw(&mut self, buf: BufferHandle<()>, access: MapAccess) -> RawMapping {
+    fn map_buffer_raw(&mut self, buf: BufferHandle<GlResources, ()>, access: MapAccess) -> RawMapping {
         let ptr;
         unsafe { self.gl.BindBuffer(gl::ARRAY_BUFFER, buf.get_name()) };
         ptr = unsafe { self.gl.MapBuffer(gl::ARRAY_BUFFER, match access {
@@ -755,7 +768,7 @@ impl Device for GlDevice {
         unsafe { self.gl.UnmapBuffer(map.target) };
     }
 
-    fn map_buffer_readable<T: Copy>(&mut self, buf: BufferHandle<T>) -> ReadableMapping<T, GlDevice> {
+    fn map_buffer_readable<T: Copy>(&mut self, buf: BufferHandle<GlResources, T>) -> ReadableMapping<T, GlDevice> {
         let map = self.map_buffer_raw(buf.cast(), MapAccess::Readable);
         ReadableMapping {
             raw: map,
@@ -764,7 +777,7 @@ impl Device for GlDevice {
         }
     }
 
-    fn map_buffer_writable<T: Copy>(&mut self, buf: BufferHandle<T>) -> WritableMapping<T, GlDevice> {
+    fn map_buffer_writable<T: Copy>(&mut self, buf: BufferHandle<GlResources, T>) -> WritableMapping<T, GlDevice> {
         let map = self.map_buffer_raw(buf.cast(), MapAccess::Writable);
         WritableMapping {
             raw: map,
@@ -773,7 +786,7 @@ impl Device for GlDevice {
         }
     }
 
-    fn map_buffer_rw<T: Copy>(&mut self, buf: BufferHandle<T>) -> RWMapping<T, GlDevice> {
+    fn map_buffer_rw<T: Copy>(&mut self, buf: BufferHandle<GlResources, T>) -> RWMapping<T, GlDevice> {
         let map = self.map_buffer_raw(buf.cast(), MapAccess::RW);
         RWMapping {
             raw: map,
diff --git a/src/device/gl_device/shade.rs b/src/device/gl_device/shade.rs
index 7400326658f..5d7e0cf5f0e 100644
--- a/src/device/gl_device/shade.rs
+++ b/src/device/gl_device/shade.rs
@@ -279,8 +279,8 @@ fn query_parameters(gl: &gl::Gl, caps: &::Capabilities, prog: super::Program) ->
     (uniforms, textures)
 }
 
-pub fn create_program(gl: &gl::Gl, caps: &::Capabilities, shaders: &[::ShaderHandle], targets: Option<&[&str]>)
-        -> (Result<::ProgramHandle, ()>, Option<String>) {
+pub fn create_program(gl: &gl::Gl, caps: &::Capabilities, shaders: &[::ShaderHandle<super::GlResources>], targets: Option<&[&str]>)
+        -> (Result<::ProgramHandle<super::GlResources>, ()>, Option<String>) {
     let name = unsafe { gl.CreateProgram() };
     for sh in shaders.iter() {
         unsafe { gl.AttachShader(name, sh.get_name()) };
diff --git a/src/device/lib.rs b/src/device/lib.rs
index 99eb719245e..cc1c71640bc 100644
--- a/src/device/lib.rs
+++ b/src/device/lib.rs
@@ -26,6 +26,7 @@ extern crate libc;
 // TODO: Remove these exports once `gl_device` becomes a separate crate.
 pub use self::gl_device as back;
 
+use std::fmt;
 use std::mem;
 use std::slice;
 use std::ops::{Deref, DerefMut};
@@ -149,7 +150,9 @@ impl<T: Copy, I> Handle<T, I> {
         let Handle(name, _) = *self;
         name
     }
+}
 
+impl<T, I> Handle<T, I> {
     /// Get the info reference
     pub fn get_info(&self) -> &I {
         let Handle(_, ref info) = *self;
@@ -158,39 +161,59 @@ impl<T: Copy, I> Handle<T, I> {
 }
 
 /// Type-safe buffer handle
-#[derive(Copy, Debug, PartialEq, Clone)]
-pub struct BufferHandle<T> {
-    raw: RawBufferHandle,
+pub struct BufferHandle<R: Resources, T> {
+    raw: RawBufferHandle<R>,
+}
+
+impl<R: Resources, T> Copy for BufferHandle<R, T> {}
+
+impl<R: Resources, T> Clone for BufferHandle<R, T> {
+    fn clone(&self) -> BufferHandle<R, T> {
+        BufferHandle { raw: self.raw }
+    }
+}
+
+impl<R: Resources, T> PartialEq for BufferHandle<R, T> {
+    fn eq(&self, other: &BufferHandle<R, T>) -> bool {
+        self.raw == other.raw
+    }
+}
+
+impl<R: Resources, T> fmt::Debug for BufferHandle<R, T> {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        write!(f, "BufferHandle {{ raw: {:?} }}", self.raw)
+    }
 }
 
-impl<T> BufferHandle<T> {
+impl<R: Resources, T> BufferHandle<R, T> {
     /// Create a type-safe BufferHandle from a RawBufferHandle
-    pub fn from_raw(handle: RawBufferHandle) -> BufferHandle<T> {
+    pub fn from_raw(handle: RawBufferHandle<R>) -> BufferHandle<R, T> {
         BufferHandle {
             raw: handle,
         }
     }
 
     /// Cast the type this BufferHandle references
-    pub fn cast<U>(self) -> BufferHandle<U> {
+    pub fn cast<U>(self) -> BufferHandle<R, U> {
         BufferHandle::from_raw(self.raw)
     }
 
-    /// Get the underlying GL name for this BufferHandle
-    pub fn get_name(&self) -> back::Buffer {
+    /// Get the underlying name for this BufferHandle
+    pub fn get_name(&self) -> <R as Resources>::Buffer {
         self.raw.get_name()
     }
 
-    /// Get the associated information about the buffer
-    pub fn get_info(&self) -> &BufferInfo {
-        self.raw.get_info()
-    }
-
     /// Get the underlying raw Handle
-    pub fn raw(&self) -> RawBufferHandle {
+    pub fn raw(&self) -> RawBufferHandle<R> {
         self.raw
     }
 
+    /// Get the associated information about the buffer
+    pub fn get_info(&self) -> &BufferInfo {
+        let Handle(_, ref info) = self.raw;
+        info
+    }
+
     /// Get the number of elements in the buffer.
     ///
     /// Fails if `T` is zero-sized.
@@ -201,25 +224,25 @@ impl<T> BufferHandle<T> {
 }
 
 /// Raw (untyped) Buffer Handle
-pub type RawBufferHandle = Handle<back::Buffer, BufferInfo>;
+pub type RawBufferHandle<R: Resources> = Handle<<R as Resources>::Buffer, BufferInfo>;
 /// Array Buffer Handle
-pub type ArrayBufferHandle = Handle<back::ArrayBuffer, ()>;
+pub type ArrayBufferHandle<R: Resources> = Handle<<R as Resources>::ArrayBuffer, ()>;
 /// Shader Handle
-pub type ShaderHandle  = Handle<back::Shader, shade::Stage>;
+pub type ShaderHandle<R: Resources>  = Handle<<R as Resources>::Shader, shade::Stage>;
 /// Program Handle
-pub type ProgramHandle = Handle<back::Program, shade::ProgramInfo>;
+pub type ProgramHandle<R: Resources> = Handle<<R as Resources>::Program, shade::ProgramInfo>;
 /// Frame Buffer Handle
-pub type FrameBufferHandle = Handle<back::FrameBuffer, ()>;
+pub type FrameBufferHandle<R: Resources> = Handle<<R as Resources>::FrameBuffer, ()>;
 /// Surface Handle
-pub type SurfaceHandle = Handle<back::Surface, tex::SurfaceInfo>;
+pub type SurfaceHandle<R: Resources> = Handle<<R as Resources>::Surface, tex::SurfaceInfo>;
 /// Texture Handle
-pub type TextureHandle = Handle<back::Texture, tex::TextureInfo>;
+pub type TextureHandle<R: Resources> = Handle<<R as Resources>::Texture, tex::TextureInfo>;
 /// Sampler Handle
-pub type SamplerHandle = Handle<back::Sampler, tex::SamplerInfo>;
+pub type SamplerHandle<R: Resources> = Handle<<R as Resources>::Sampler, tex::SamplerInfo>;
 
 /// A helper method to test `#[vertex_format]` without GL context
 //#[cfg(test)]
-pub fn make_fake_buffer<T>() -> BufferHandle<T> {
+pub fn make_fake_buffer<T>() -> BufferHandle<back::GlResources, T> {
     let info = BufferInfo {
         usage: BufferUsage::Static,
         size: 0,
@@ -228,7 +251,7 @@ pub fn make_fake_buffer<T>() -> BufferHandle<T> {
 }
 
 /// Return the framebuffer handle for the screen.
-pub fn get_main_frame_buffer() -> FrameBufferHandle {
+pub fn get_main_frame_buffer() -> FrameBufferHandle<back::GlResources> {
     Handle(0, ())
 }
 
@@ -315,50 +338,23 @@ pub struct BufferInfo {
     pub size: usize,
 }
 
-/// Serialized device command.
-/// While this is supposed to be an internal detail of a device,
-/// this particular representation may be used by different backends,
-/// such as OpenGL (prior to GLNG) and DirectX (prior to DX12)
-#[allow(missing_docs)]
-#[derive(Copy, Debug)]
-pub enum Command {
-    BindProgram(back::Program),
-    BindArrayBuffer(back::ArrayBuffer),
-    BindAttribute(AttributeSlot, back::Buffer, attrib::Format),
-    BindIndex(back::Buffer),
-    BindFrameBuffer(target::Access, back::FrameBuffer),
-    /// Unbind any surface from the specified target slot
-    UnbindTarget(target::Access, target::Target),
-    /// Bind a surface to the specified target slot
-    BindTargetSurface(target::Access, target::Target, back::Surface),
-    /// Bind a level of the texture to the specified target slot
-    BindTargetTexture(target::Access, target::Target, back::Texture,
-                      target::Level, Option<target::Layer>),
-    BindUniformBlock(back::Program, UniformBufferSlot, UniformBlockIndex, back::Buffer),
-    BindUniform(shade::Location, shade::UniformValue),
-    BindTexture(TextureSlot, tex::TextureKind, back::Texture, Option<SamplerHandle>),
-    SetDrawColorBuffers(usize),
-    SetPrimitiveState(state::Primitive),
-    SetViewport(target::Rect),
-    SetMultiSampleState(Option<state::MultiSample>),
-    SetScissor(Option<target::Rect>),
-    SetDepthStencilState(Option<state::Depth>, Option<state::Stencil>, state::CullMode),
-    SetBlendState(Option<state::Blend>),
-    SetColorMask(state::ColorMask),
-    UpdateBuffer(back::Buffer, draw::DataPointer, usize),
-    UpdateTexture(tex::TextureKind, back::Texture, tex::ImageInfo, draw::DataPointer),
-    // drawing
-    Clear(target::ClearData, target::Mask),
-    Draw(PrimitiveType, VertexCount, VertexCount, Option<(InstanceCount, VertexCount)>),
-    DrawIndexed(PrimitiveType, IndexType, VertexCount, VertexCount, VertexCount, Option<(InstanceCount, VertexCount)>),
-    Blit(target::Rect, target::Rect, target::Mirror, target::Mask),
+/// Resources pertaining to a specific API
+pub trait Resources {
+    type Buffer:        Copy + Clone + fmt::Debug + PartialEq + Send + Sync;
+    type ArrayBuffer:   Copy + Clone + fmt::Debug + PartialEq + Send + Sync;
+    type Shader:        Copy + Clone + fmt::Debug + PartialEq + Send + Sync;
+    type Program:       Copy + Clone + fmt::Debug + PartialEq + Send + Sync;
+    type FrameBuffer:   Copy + Clone + fmt::Debug + PartialEq + Send + Sync;
+    type Surface:       Copy + Clone + fmt::Debug + PartialEq + Send + Sync;
+    type Texture:       Copy + Clone + fmt::Debug + PartialEq + Send + Sync;
+    type Sampler:       Copy + Clone + fmt::Debug + PartialEq + Send + Sync;
 }
 
 /// An interface for performing draw calls using a specific graphics API
 #[allow(missing_docs)]
 pub trait Device {
-
-    type CommandBuffer: draw::CommandBuffer;
+    type Resources: Resources;
+    type CommandBuffer: draw::CommandBuffer<Resources = Self::Resources>;
 
     /// Returns the capabilities available to the specific API implementation
     fn get_capabilities<'a>(&'a self) -> &'a Capabilities;
@@ -368,56 +364,56 @@ pub trait Device {
     fn submit(&mut self, buffer: (&Self::CommandBuffer, &draw::DataBuffer));
 
     // resource creation
-    fn create_buffer_raw(&mut self, size: usize, usage: BufferUsage) -> BufferHandle<()>;
-    fn create_buffer<T>(&mut self, num: usize, usage: BufferUsage) -> BufferHandle<T> {
+    fn create_buffer_raw(&mut self, size: usize, usage: BufferUsage) -> BufferHandle<back::GlResources, ()>;
+    fn create_buffer<T>(&mut self, num: usize, usage: BufferUsage) -> BufferHandle<back::GlResources, T> {
         self.create_buffer_raw(num * mem::size_of::<T>(), usage).cast()
     }
-    fn create_buffer_static_raw(&mut self, data: &[u8]) -> BufferHandle<()>;
-    fn create_buffer_static<T: Copy>(&mut self, data: &[T]) -> BufferHandle<T> {
+    fn create_buffer_static_raw(&mut self, data: &[u8]) -> BufferHandle<back::GlResources, ()>;
+    fn create_buffer_static<T: Copy>(&mut self, data: &[T]) -> BufferHandle<back::GlResources, T> {
         self.create_buffer_static_raw(as_byte_slice(data)).cast()
     }
-    fn create_array_buffer(&mut self) -> Result<ArrayBufferHandle, ()>;
+    fn create_array_buffer(&mut self) -> Result<ArrayBufferHandle<back::GlResources>, ()>;
     fn create_shader(&mut self, stage: shade::Stage, code: &[u8]) ->
-                     Result<ShaderHandle, shade::CreateShaderError>;
-    fn create_program(&mut self, shaders: &[ShaderHandle], targets: Option<&[&str]>) -> Result<ProgramHandle, ()>;
-    fn create_frame_buffer(&mut self) -> FrameBufferHandle;
-    fn create_surface(&mut self, info: tex::SurfaceInfo) -> Result<SurfaceHandle, tex::SurfaceError>;
-    fn create_texture(&mut self, info: tex::TextureInfo) -> Result<TextureHandle, tex::TextureError>;
-    fn create_sampler(&mut self, info: tex::SamplerInfo) -> SamplerHandle;
+                     Result<ShaderHandle<back::GlResources>, shade::CreateShaderError>;
+    fn create_program(&mut self, shaders: &[ShaderHandle<back::GlResources>], targets: Option<&[&str]>) -> Result<ProgramHandle<back::GlResources>, ()>;
+    fn create_frame_buffer(&mut self) -> FrameBufferHandle<back::GlResources>;
+    fn create_surface(&mut self, info: tex::SurfaceInfo) -> Result<SurfaceHandle<back::GlResources>, tex::SurfaceError>;
+    fn create_texture(&mut self, info: tex::TextureInfo) -> Result<TextureHandle<back::GlResources>, tex::TextureError>;
+    fn create_sampler(&mut self, info: tex::SamplerInfo) -> SamplerHandle<back::GlResources>;
 
     // resource deletion
-    fn delete_buffer_raw(&mut self, buf: BufferHandle<()>);
-    fn delete_buffer<T>(&mut self, buf: BufferHandle<T>) {
+    fn delete_buffer_raw(&mut self, buf: BufferHandle<back::GlResources, ()>);
+    fn delete_buffer<T>(&mut self, buf: BufferHandle<back::GlResources, T>) {
         self.delete_buffer_raw(buf.cast());
     }
-    fn delete_shader(&mut self, ShaderHandle);
-    fn delete_program(&mut self, ProgramHandle);
-    fn delete_surface(&mut self, SurfaceHandle);
-    fn delete_texture(&mut self, TextureHandle);
-    fn delete_sampler(&mut self, SamplerHandle);
+    fn delete_shader(&mut self, ShaderHandle<back::GlResources>);
+    fn delete_program(&mut self, ProgramHandle<back::GlResources>);
+    fn delete_surface(&mut self, SurfaceHandle<back::GlResources>);
+    fn delete_texture(&mut self, TextureHandle<back::GlResources>);
+    fn delete_sampler(&mut self, SamplerHandle<back::GlResources>);
 
     /// Update the information stored in a specific buffer
-    fn update_buffer_raw(&mut self, buf: BufferHandle<()>, data: &[u8],
+    fn update_buffer_raw(&mut self, buf: BufferHandle<back::GlResources, ()>, data: &[u8],
                          offset_bytes: usize);
-    fn update_buffer<T: Copy>(&mut self, buf: BufferHandle<T>, data: &[T],
+    fn update_buffer<T: Copy>(&mut self, buf: BufferHandle<back::GlResources, T>, data: &[T],
                      offset_elements: usize) {
         self.update_buffer_raw(buf.cast(), as_byte_slice(data), mem::size_of::<T>() * offset_elements)
     }
-    fn map_buffer_raw(&mut self, buf: BufferHandle<()>, access: MapAccess) -> back::RawMapping;
+    fn map_buffer_raw(&mut self, buf: BufferHandle<back::GlResources, ()>, access: MapAccess) -> back::RawMapping;
     fn unmap_buffer_raw(&mut self, map: back::RawMapping);
-    fn map_buffer_readable<T: Copy>(&mut self, buf: BufferHandle<T>) -> ReadableMapping<T, Self>;
-    fn map_buffer_writable<T: Copy>(&mut self, buf: BufferHandle<T>) -> WritableMapping<T, Self>;
-    fn map_buffer_rw<T: Copy>(&mut self, buf: BufferHandle<T>) -> RWMapping<T, Self>;
+    fn map_buffer_readable<T: Copy>(&mut self, buf: BufferHandle<back::GlResources, T>) -> ReadableMapping<T, Self>;
+    fn map_buffer_writable<T: Copy>(&mut self, buf: BufferHandle<back::GlResources, T>) -> WritableMapping<T, Self>;
+    fn map_buffer_rw<T: Copy>(&mut self, buf: BufferHandle<back::GlResources, T>) -> RWMapping<T, Self>;
 
     /// Update the information stored in a texture
-    fn update_texture_raw(&mut self, tex: &TextureHandle, img: &tex::ImageInfo,
+    fn update_texture_raw(&mut self, tex: &TextureHandle<back::GlResources>, img: &tex::ImageInfo,
                           data: &[u8]) -> Result<(), tex::TextureError>;
-    fn update_texture<T: Copy>(&mut self, tex: &TextureHandle,
+    fn update_texture<T: Copy>(&mut self, tex: &TextureHandle<back::GlResources>,
                       img: &tex::ImageInfo, data: &[T])
                       -> Result<(), tex::TextureError> {
         self.update_texture_raw(tex, img, as_byte_slice(data))
     }
-    fn generate_mipmap(&mut self, tex: &TextureHandle);
+    fn generate_mipmap(&mut self, tex: &TextureHandle<back::GlResources>);
 }
 
 #[cfg(test)]
@@ -425,8 +421,9 @@ mod test {
     use std::mem;
     use super::{BufferHandle, Handle};
     use super::{BufferInfo, BufferUsage};
+    use super::back;
 
-    fn mock_buffer<T>(usage: BufferUsage, len: usize) -> BufferHandle<T> {
+    fn mock_buffer<T>(usage: BufferUsage, len: usize) -> BufferHandle<back::GlResources, T> {
         BufferHandle {
             raw: Handle(
                 0,
diff --git a/src/gfx/lib.rs b/src/gfx/lib.rs
index 8ae1069c2eb..cd8cc4459f7 100644
--- a/src/gfx/lib.rs
+++ b/src/gfx/lib.rs
@@ -46,7 +46,7 @@ pub use device::shade::{ProgramInfo, UniformValue};
 pub use device::target::*;
 
 // TODO: Remove this re-export once `gl_device` becomes a separate crate.
-pub use device::gl_device::{GlDevice, GlCommandBuffer};
+pub use device::gl_device::{GlDevice, GlResources};
 
 #[path = "../render/lib.rs"] pub mod render;
 
@@ -55,7 +55,7 @@ pub struct Graphics<D: device::Device> {
     /// Graphics device.
     pub device: D,
     /// Renderer front-end.
-    pub renderer: Renderer<<D as device::Device>::CommandBuffer>,
+    pub renderer: Renderer<D>,
     /// Hidden batch context.
     context: batch::Context,
 }
@@ -73,7 +73,7 @@ impl<D: device::Device> Graphics<D> {
 
     /// Create a new ref batch.
     pub fn make_batch<T: shade::ShaderParam>(&mut self,
-                      program: &ProgramHandle,
+                      program: &ProgramHandle<GlResources>,
                       mesh: &Mesh,
                       slice: Slice,
                       state: &DrawState)
diff --git a/src/gfx_macros/vertex_format.rs b/src/gfx_macros/vertex_format.rs
index 915b8f26274..4fbd8f4b780 100644
--- a/src/gfx_macros/vertex_format.rs
+++ b/src/gfx_macros/vertex_format.rs
@@ -258,9 +258,13 @@ impl ItemDecorator for VertexFormat {
                             params: vec![box generic::ty::Self_],
                             global: false,
                         }),
-                        generic::ty::Literal(generic::ty::Path::new(
-                            vec![super::EXTERN_CRATE_HACK, "gfx", "RawBufferHandle"]
-                        )),
+                        generic::ty::Literal(generic::ty::Path {
+                            path: vec![super::EXTERN_CRATE_HACK, "gfx", "RawBufferHandle"],
+                            lifetime: None,
+                            params: vec![box generic::ty::Literal(generic::ty::Path::new(
+                                             vec![super::EXTERN_CRATE_HACK, "gfx", "GlResources"]))],
+                            global: false,
+                        }),
                     ],
                     ret_ty: generic::ty::Literal(
                         generic::ty::Path {
diff --git a/src/render/batch.rs b/src/render/batch.rs
index fabe4430769..0751ced1900 100644
--- a/src/render/batch.rs
+++ b/src/render/batch.rs
@@ -19,6 +19,7 @@
 use std::fmt;
 use std::num::from_uint;
 use std::cmp::Ordering;
+use device::back;
 use device::{PrimitiveType, ProgramHandle};
 use device::shade::ProgramInfo;
 use render::mesh;
@@ -78,11 +79,11 @@ pub trait Batch {
     fn get_data(&self) -> Result<BatchData, Self::Error>;
     /// Fill shader parameter values
     fn fill_params(&self, ::shade::ParamValues)
-                   -> Result<&ProgramHandle, Self::Error>;
+                   -> Result<&ProgramHandle<back::GlResources>, Self::Error>;
 }
 
 impl<'a, T: ShaderParam> Batch for (&'a mesh::Mesh, mesh::Slice,
-                                    &'a ProgramHandle, &'a T, &'a DrawState) {
+                                    &'a ProgramHandle<back::GlResources>, &'a T, &'a DrawState) {
     type Error = BatchError;
 
     fn get_data(&self) -> Result<BatchData, BatchError> {
@@ -94,7 +95,7 @@ impl<'a, T: ShaderParam> Batch for (&'a mesh::Mesh, mesh::Slice,
     }
 
     fn fill_params(&self, values: ::shade::ParamValues)
-                   -> Result<&ProgramHandle, BatchError> {
+                   -> Result<&ProgramHandle<back::GlResources>, BatchError> {
         let (_, _, program, params, _) = *self;
         match ShaderParam::create_link(None::<&T>, program.get_info()) {
             Ok(link) => {
@@ -114,7 +115,7 @@ pub struct OwnedBatch<T: ShaderParam> {
     pub slice: mesh::Slice,
     /// Parameter data.
     pub param: T,
-    program: ProgramHandle,
+    program: ProgramHandle<back::GlResources>,
     param_link: T::Link,
     /// Draw state
     pub state: DrawState,
@@ -122,7 +123,7 @@ pub struct OwnedBatch<T: ShaderParam> {
 
 impl<T: ShaderParam> OwnedBatch<T> {
     /// Create a new owned batch
-    pub fn new(mesh: mesh::Mesh, program: ProgramHandle, param: T)
+    pub fn new(mesh: mesh::Mesh, program: ProgramHandle<back::GlResources>, param: T)
            -> Result<OwnedBatch<T>, BatchError> {
         let slice = mesh.to_slice(PrimitiveType::TriangleList);
         let mesh_link = match link_mesh(&mesh, program.get_info()) {
@@ -153,7 +154,7 @@ impl<T: ShaderParam> Batch for OwnedBatch<T> {
     }
 
     fn fill_params(&self, values: ::shade::ParamValues)
-                   -> Result<&ProgramHandle, ()> {
+                   -> Result<&ProgramHandle<back::GlResources>, ()> {
         self.param.fill_params(&self.param_link, values);
         Ok(&self.program)
     }
@@ -250,7 +251,7 @@ pub struct RefBatch<T: ShaderParam> {
     mesh_link: mesh::Link,
     /// Mesh slice
     pub slice: mesh::Slice,
-    program_id: Id<ProgramHandle>,
+    program_id: Id<ProgramHandle<back::GlResources>>,
     param_link: T::Link,
     state_id: Id<DrawState>,
 }
@@ -290,7 +291,7 @@ impl<T> Ord for RefBatch<T> {
 /// Factory of ref batches, required to always be used with them.
 pub struct Context {
     meshes: Array<mesh::Mesh>,
-    programs: Array<ProgramHandle>,
+    programs: Array<ProgramHandle<back::GlResources>>,
     states: Array<DrawState>,
 }
 
@@ -308,7 +309,7 @@ impl Context {
 impl Context {
     /// Produce a new ref batch
     pub fn make_batch<T: ShaderParam>(&mut self,
-                      program: &ProgramHandle,
+                      program: &ProgramHandle<back::GlResources>,
                       mesh: &mesh::Mesh,
                       slice: mesh::Slice,
                       state: &DrawState)
@@ -358,7 +359,7 @@ impl<'a, T: ShaderParam> Batch for (&'a RefBatch<T>, &'a T, &'a Context) {
     }
 
     fn fill_params(&self, values: ::shade::ParamValues)
-                   -> Result<&ProgramHandle, OutOfBounds> {
+                   -> Result<&ProgramHandle<back::GlResources>, OutOfBounds> {
         let (b, data, ctx) = *self;
         data.fill_params(&b.param_link, values);
         ctx.programs.get(b.program_id)
diff --git a/src/render/device_ext.rs b/src/render/device_ext.rs
index 3af3ab9266e..b530f9240ae 100644
--- a/src/render/device_ext.rs
+++ b/src/render/device_ext.rs
@@ -1,4 +1,5 @@
 use device;
+use device::back;
 use device::shade::{Stage, CreateShaderError, ShaderModel};
 use super::mesh::{Mesh, VertexFormat};
 
@@ -59,21 +60,21 @@ impl<'a> ShaderSource<'a> {
 /// Backend extension trait for convenience methods
 pub trait DeviceExt: device::Device {
     /// Create a new renderer
-    fn create_renderer(&mut self) -> ::Renderer<<Self as device::Device>::CommandBuffer>;
+    fn create_renderer(&mut self) -> ::Renderer<Self>;
     /// Create a new mesh from the given vertex data.
     /// Convenience function around `create_buffer` and `Mesh::from_format`.
     fn create_mesh<T: VertexFormat + Copy>(&mut self, data: &[T]) -> Mesh;
     /// Create a simple program given a vertex shader with a fragment one.
     fn link_program(&mut self, vs_code: &[u8], fs_code: &[u8])
-                    -> Result<device::ProgramHandle, ProgramError>;
+                    -> Result<device::ProgramHandle<back::GlResources>, ProgramError>;
     /// Create a simple program given `ShaderSource` versions of vertex and
     /// fragment shaders, chooss the matching versions for the device.
     fn link_program_source(&mut self, vs_src: ShaderSource, fs_src: ShaderSource)
-                           -> Result<device::ProgramHandle, ProgramError>;
+                           -> Result<device::ProgramHandle<back::GlResources>, ProgramError>;
 }
 
 impl<D: device::Device> DeviceExt for D {
-    fn create_renderer(&mut self) -> ::Renderer<D::CommandBuffer> {
+    fn create_renderer(&mut self) -> ::Renderer<D> {
         ::Renderer {
             command_buffer: device::draw::CommandBuffer::new(),
             data_buffer: device::draw::DataBuffer::new(),
@@ -98,7 +99,7 @@ impl<D: device::Device> DeviceExt for D {
     }
 
     fn link_program(&mut self, vs_code: &[u8], fs_code: &[u8])
-                    -> Result<device::ProgramHandle, ProgramError> {
+                    -> Result<device::ProgramHandle<back::GlResources>, ProgramError> {
         let vs = match self.create_shader(Stage::Vertex, vs_code) {
             Ok(s) => s,
             Err(e) => return Err(ProgramError::Vertex(e)),
@@ -113,7 +114,7 @@ impl<D: device::Device> DeviceExt for D {
     }
 
     fn link_program_source(&mut self, vs_src: ShaderSource, fs_src: ShaderSource)
-                           -> Result<device::ProgramHandle, ProgramError> {
+                           -> Result<device::ProgramHandle<back::GlResources>, ProgramError> {
         let model = self.get_capabilities().shader_model;
         let err_model = CreateShaderError::ModelNotSupported;
 
diff --git a/src/render/lib.rs b/src/render/lib.rs
index 3bdcdccb374..e4636fc6e7a 100644
--- a/src/render/lib.rs
+++ b/src/render/lib.rs
@@ -22,8 +22,10 @@ extern crate "gfx_device_gl" as device;
 
 use std::mem;
 
+use device::Device;
 use device::attrib;
 use device::attrib::IntSize;
+use device::back;
 use device::draw::CommandBuffer;
 use device::shade::{ProgramInfo, UniformValue};
 use device::target::{Rect, ClearData, Mirror, Mask, Access, Target};
@@ -45,7 +47,7 @@ pub mod target;
 
 
 const TRACKED_ATTRIBUTES: usize = 8;
-type CachedAttribute = (device::RawBufferHandle, attrib::Format);
+type CachedAttribute = (device::RawBufferHandle<back::GlResources>, attrib::Format);
 type Instancing = (device::InstanceCount, device::VertexCount);
 
 /// The internal state of the renderer.
@@ -55,7 +57,7 @@ struct RenderState {
     frame: target::Frame,
     is_array_buffer_set: bool,
     program_name: device::back::Program,
-    index: Option<device::RawBufferHandle>,
+    index: Option<device::RawBufferHandle<back::GlResources>>,
     attributes: [Option<CachedAttribute>; TRACKED_ATTRIBUTES],
     draw: state::DrawState,
 }
@@ -78,7 +80,7 @@ impl RenderState {
 /// Temporary parameter storage, used for shader activation.
 struct ParamStorage {
     uniforms: Vec<UniformValue>,
-    blocks  : Vec<device::RawBufferHandle>,
+    blocks  : Vec<device::RawBufferHandle<back::GlResources>>,
     textures: Vec<shade::TextureParam>,
 }
 
@@ -104,14 +106,14 @@ impl ParamStorage{
     }
 }
 
-/// Helper routines for the command buffer
+/// Extension methods for the command buffer.
 /// Useful when Renderer is borrowed, and we need to issue commands.
-trait CommandBufferHelper {
+trait CommandBufferExt {
     /// Bind a plane to some target
     fn bind_target(&mut self, Access, Target, Option<&target::Plane>);
 }
 
-impl<C: CommandBuffer> CommandBufferHelper for C {
+impl<C: CommandBuffer> CommandBufferExt for C {
     fn bind_target(&mut self, access: Access, to: Target,
                    plane: Option<&target::Plane>) {
         match plane {
@@ -141,18 +143,18 @@ pub enum DrawError<E> {
 }
 
 /// Renderer front-end
-pub struct Renderer<C: CommandBuffer> {
-    command_buffer: C,
+pub struct Renderer<D: Device> {
+    command_buffer: D::CommandBuffer,
     data_buffer: device::draw::DataBuffer,
-    common_array_buffer: Result<device::ArrayBufferHandle, ()>,
-    draw_frame_buffer: device::FrameBufferHandle,
-    read_frame_buffer: device::FrameBufferHandle,
-    default_frame_buffer: device::FrameBufferHandle,
+    common_array_buffer: Result<device::ArrayBufferHandle<back::GlResources>, ()>,
+    draw_frame_buffer: device::FrameBufferHandle<back::GlResources>,
+    read_frame_buffer: device::FrameBufferHandle<back::GlResources>,
+    default_frame_buffer: device::FrameBufferHandle<back::GlResources>,
     render_state: RenderState,
     parameters: ParamStorage,
 }
 
-impl<C: CommandBuffer> Renderer<C> {
+impl<D: Device> Renderer<D> {
     /// Reset all commands for the command buffer re-usal.
     pub fn reset(&mut self) {
         self.command_buffer.clear();
@@ -161,12 +163,12 @@ impl<C: CommandBuffer> Renderer<C> {
     }
 
     /// Get command and data buffers to be submitted to the device.
-    pub fn as_buffer(&self) -> (&C, &device::draw::DataBuffer) {
+    pub fn as_buffer(&self) -> (&D::CommandBuffer, &device::draw::DataBuffer) {
         (&self.command_buffer, &self.data_buffer)
     }
 
     /// Clone the renderer shared data but ignore the commands.
-    pub fn clone_empty(&self) -> Renderer<C> {
+    pub fn clone_empty(&self) -> Renderer<D> {
         Renderer {
             command_buffer: CommandBuffer::new(),
             data_buffer: device::draw::DataBuffer::new(),
@@ -246,7 +248,7 @@ impl<C: CommandBuffer> Renderer<C> {
     }
 
     /// Update a buffer with data from a vector.
-    pub fn update_buffer_vec<T: Copy>(&mut self, buf: device::BufferHandle<T>,
+    pub fn update_buffer_vec<T: Copy>(&mut self, buf: device::BufferHandle<back::GlResources, T>,
                              data: &[T], offset_elements: usize) {
         let esize = mem::size_of::<T>();
         let offset_bytes = esize * offset_elements;
@@ -257,14 +259,14 @@ impl<C: CommandBuffer> Renderer<C> {
 
     /// Update a buffer with data from a single type.
     pub fn update_buffer_struct<U, T: Copy>(&mut self,
-                                buf: device::BufferHandle<U>, data: &T) {
+                                buf: device::BufferHandle<back::GlResources, U>, data: &T) {
         debug_assert!(mem::size_of::<T>() <= buf.get_info().size);
         let pointer = self.data_buffer.add_struct(data);
         self.command_buffer.update_buffer(buf.get_name(), pointer, 0);
     }
 
     /// Update the contents of a texture.
-    pub fn update_texture<T: Copy>(&mut self, tex: device::TextureHandle,
+    pub fn update_texture<T: Copy>(&mut self, tex: device::TextureHandle<back::GlResources>,
                           img: device::tex::ImageInfo, data: &[T]) {
         debug_assert!(tex.get_info().contains(&img));
         let pointer = self.data_buffer.add_vec(data);
@@ -367,7 +369,7 @@ impl<C: CommandBuffer> Renderer<C> {
     }
 
     fn bind_program<'a, B: Batch>(&mut self, batch: &'a B)
-                    -> Result<&'a device::ProgramHandle, B::Error> {
+                    -> Result<&'a device::ProgramHandle<back::GlResources>, B::Error> {
         let program = match batch.fill_params(self.parameters.get_mut()) {
             Ok(p) => p,
             Err(e) => return Err(e),
@@ -381,7 +383,7 @@ impl<C: CommandBuffer> Renderer<C> {
         Ok(program)
     }
 
-    fn upload_parameters(&mut self, program: &device::ProgramHandle) {
+    fn upload_parameters(&mut self, program: &device::ProgramHandle<back::GlResources>) {
         let info = program.get_info();
         if self.parameters.uniforms.len() != info.uniforms.len() ||
             self.parameters.blocks.len() != info.blocks.len() ||
@@ -447,7 +449,7 @@ impl<C: CommandBuffer> Renderer<C> {
         }
     }
 
-    fn bind_index<T>(&mut self, buf: device::BufferHandle<T>) {
+    fn bind_index<T>(&mut self, buf: device::BufferHandle<back::GlResources, T>) {
         if self.render_state.index != Some(buf.raw()) {
             self.command_buffer.bind_index(buf.get_name());
             self.render_state.index = Some(buf.raw());
diff --git a/src/render/mesh.rs b/src/render/mesh.rs
index 331ba84d9de..2f71eb19906 100644
--- a/src/render/mesh.rs
+++ b/src/render/mesh.rs
@@ -22,7 +22,7 @@
 
 use device;
 use device::{PrimitiveType, BufferHandle, VertexCount};
-use device::attrib;
+use device::{attrib, back};
 
 /// Describes a single attribute of a vertex buffer, including its type, name, etc.
 #[derive(Clone, PartialEq, Debug)]
@@ -30,7 +30,7 @@ pub struct Attribute {
     /// A name to match the shader input
     pub name: String,
     /// Vertex buffer to contain the data
-    pub buffer: device::RawBufferHandle,
+    pub buffer: device::RawBufferHandle<back::GlResources>,
     /// Format of the attribute
     pub format: attrib::Format,
 }
@@ -39,7 +39,7 @@ pub struct Attribute {
 /// `#[vertex_format] attribute
 pub trait VertexFormat {
     /// Create the attributes for this type, using the given buffer.
-    fn generate(Option<Self>, buffer: device::RawBufferHandle) -> Vec<Attribute>;
+    fn generate(Option<Self>, buffer: device::RawBufferHandle<back::GlResources>) -> Vec<Attribute>;
 }
 
 /// Describes geometry to render.
@@ -61,7 +61,7 @@ impl Mesh {
     }
 
     /// Create a new `Mesh` from a struct that implements `VertexFormat` and a buffer.
-    pub fn from_format<V: VertexFormat>(buf: device::BufferHandle<V>, nv: device::VertexCount) -> Mesh {
+    pub fn from_format<V: VertexFormat>(buf: device::BufferHandle<back::GlResources, V>, nv: device::VertexCount) -> Mesh {
         Mesh {
             num_vertices: nv,
             attributes: VertexFormat::generate(None::<V>, buf.raw()),
@@ -70,8 +70,8 @@ impl Mesh {
 
     /// Create a new intanced `Mesh` given a vertex buffer and an instance buffer.
     pub fn from_format_instanced<V: VertexFormat, U: VertexFormat>(
-                                 buf: device::BufferHandle<V>, nv: device::VertexCount,
-                                 inst: device::BufferHandle<U>) -> Mesh {
+                                 buf: device::BufferHandle<back::GlResources, V>, nv: device::VertexCount,
+                                 inst: device::BufferHandle<back::GlResources, U>) -> Mesh {
         let per_vertex   = VertexFormat::generate(None::<V>, buf.raw());
         let per_instance = VertexFormat::generate(None::<U>, inst.raw());
 
@@ -122,11 +122,11 @@ pub enum SliceKind {
     /// the vertices will be identical, wasting space for the duplicated
     /// attributes.  Instead, the `Mesh` can store 4 vertices and an
     /// `Index8` can be used instead.
-    Index8(BufferHandle<u8>, VertexCount),
+    Index8(BufferHandle<back::GlResources, u8>, VertexCount),
     /// As `Index8` but with `u16` indices
-    Index16(BufferHandle<u16>, VertexCount),
+    Index16(BufferHandle<back::GlResources, u16>, VertexCount),
     /// As `Index8` but with `u32` indices
-    Index32(BufferHandle<u32>, VertexCount),
+    Index32(BufferHandle<back::GlResources, u32>, VertexCount),
 }
 
 /// Helper methods for cleanly getting the slice of a type.
@@ -147,7 +147,7 @@ impl ToSlice for Mesh {
     }
 }
 
-impl ToSlice for BufferHandle<u8> {
+impl ToSlice for BufferHandle<back::GlResources, u8> {
     /// Return an index slice of the whole buffer.
     fn to_slice(&self, ty: PrimitiveType) -> Slice {
         Slice {
@@ -159,7 +159,7 @@ impl ToSlice for BufferHandle<u8> {
     }
 }
 
-impl ToSlice for BufferHandle<u16> {
+impl ToSlice for BufferHandle<back::GlResources, u16> {
     /// Return an index slice of the whole buffer.
     fn to_slice(&self, ty: PrimitiveType) -> Slice {
         Slice {
@@ -171,7 +171,7 @@ impl ToSlice for BufferHandle<u16> {
     }
 }
 
-impl ToSlice for BufferHandle<u32> {
+impl ToSlice for BufferHandle<back::GlResources, u32> {
     /// Return an index slice of the whole buffer.
     fn to_slice(&self, ty: PrimitiveType) -> Slice {
         Slice {
diff --git a/src/render/shade.rs b/src/render/shade.rs
index 893d200ffcf..0f754a817a7 100644
--- a/src/render/shade.rs
+++ b/src/render/shade.rs
@@ -15,7 +15,7 @@
 //! Shader parameter handling.
 
 use std::cell::Cell;
-use device::shade;
+use device::{back, shade};
 use device::shade::UniformValue;
 use device::{RawBufferHandle, TextureHandle, SamplerHandle};
 
@@ -62,7 +62,7 @@ pub type VarBlock = u8;
 pub type VarTexture = u8;
 
 /// A texture parameter: consists of a texture handle with an optional sampler.
-pub type TextureParam = (TextureHandle, Option<SamplerHandle>);
+pub type TextureParam = (TextureHandle<back::GlResources>, Option<SamplerHandle<back::GlResources>>);
 
 /// A borrowed mutable storage for shader parameter values.
 // Not sure if it's the best data structure to represent it.
@@ -70,7 +70,7 @@ pub struct ParamValues<'a> {
     /// uniform values to be provided
     pub uniforms: &'a mut Vec<UniformValue>,
     /// uniform buffers to be provided
-    pub blocks  : &'a mut Vec<RawBufferHandle>,
+    pub blocks  : &'a mut Vec<RawBufferHandle<back::GlResources>>,
     /// textures to be provided
     pub textures: &'a mut Vec<TextureParam>,
 }
@@ -135,7 +135,7 @@ pub struct ParamDictionary {
     /// Uniform dictionary
     pub uniforms: Vec<NamedCell<shade::UniformValue>>,
     /// Block dictionary
-    pub blocks: Vec<NamedCell<RawBufferHandle>>,
+    pub blocks: Vec<NamedCell<RawBufferHandle<back::GlResources>>>,
     /// Texture dictionary
     pub textures: Vec<NamedCell<TextureParam>>,
 }
diff --git a/src/render/target.rs b/src/render/target.rs
index 616413d63f2..5caf2835437 100644
--- a/src/render/target.rs
+++ b/src/render/target.rs
@@ -15,16 +15,17 @@
 //! Render target specification.
 
 use device;
+use device::back;
 use device::target::{Level, Layer, Mask};
 
 #[derive(Copy, Clone, PartialEq, Debug)]
 /// A single buffer that can be bound to a render target.
 pub enum Plane {
     /// Render to a `Surface` (corresponds to a renderbuffer in GL).
-    Surface(device::SurfaceHandle),
+    Surface(device::SurfaceHandle<back::GlResources>),
     /// Render to a texture at a specific mipmap level
     /// If `Layer` is set, it is selecting a single 2D slice of a given 3D texture
-    Texture(device::TextureHandle, Level, Option<Layer>),
+    Texture(device::TextureHandle<back::GlResources>, Level, Option<Layer>),
 }
 
 impl Plane {
diff --git a/tests/shader_param.rs b/tests/shader_param.rs
index 2bdb1d29d1d..0d0632792d0 100644
--- a/tests/shader_param.rs
+++ b/tests/shader_param.rs
@@ -26,7 +26,7 @@ struct TestParam {
     a: i32,
     b: [f32; 4],
     c: gfx::shade::TextureParam,
-    d: gfx::RawBufferHandle,
+    d: gfx::RawBufferHandle<gfx::GlResources>,
     e: f32,
     #[name = "a_f"]
     f: [f32; 4],