diff --git a/gfx/d3d/d3d.h b/gfx/d3d/d3d.h
index fb01dd9d82..72fbc4cebd 100644
--- a/gfx/d3d/d3d.h
+++ b/gfx/d3d/d3d.h
@@ -110,9 +110,7 @@ typedef struct d3d_video
    std::string shader_path;
 
 #if defined(HAVE_CG) || defined(HAVE_HLSL) || defined(HAVE_GLSL)
-#ifdef _XBOX
-   const shader_backend_t *shader;
-#else
+#ifndef _XBOX
    struct video_shader shader;
 #endif
 #endif
diff --git a/gfx/d3d/render_chain_xdk.cpp b/gfx/d3d/render_chain_xdk.cpp
index d0a340c4ec..7e2b0af202 100644
--- a/gfx/d3d/render_chain_xdk.cpp
+++ b/gfx/d3d/render_chain_xdk.cpp
@@ -45,7 +45,7 @@ static void renderchain_set_mvp(void *data, unsigned vp_width,
 
 #if defined(_XBOX360) && defined(HAVE_HLSL)
    hlsl_set_proj_matrix(XMMatrixRotationZ(rotation * (M_PI / 2.0)));
-   video_shader_driver_set_mvp(d3d->shader, d3d, NULL);
+   video_shader_driver_set_mvp(d3d, NULL);
 #elif defined(HAVE_D3D8)
    D3DXMATRIX p_out, p_rotate, mat;
    D3DXMatrixOrthoOffCenterLH(&mat, 0, vp_width,  vp_height, 0, 0.0f, 1.0f);
@@ -209,15 +209,12 @@ static void renderchain_set_vertices(void *data, unsigned pass,
 
 #if defined(HAVE_CG) || defined(HAVE_GLSL) || defined(HAVE_HLSL)
 #ifdef _XBOX
-   if (d3d->shader)
-   {
-      renderchain_set_mvp(d3d, width, height, d3d->dev_rotation);
-      video_shader_driver_use(d3d->shader, d3d, pass);
-      video_shader_driver_set_params(
-         d3d->shader, d3d, vert_width, vert_height, chain->tex_w,
-               chain->tex_h, width, height, frame_count,
-               NULL, NULL, NULL, NULL, 0);
-   }
+   renderchain_set_mvp(d3d, width, height, d3d->dev_rotation);
+   video_shader_driver_use(d3d, pass);
+   video_shader_driver_set_params(
+         d3d, vert_width, vert_height, chain->tex_w,
+         chain->tex_h, width, height, frame_count,
+         NULL, NULL, NULL, NULL, 0);
 #endif
 #endif
 }
@@ -302,9 +299,9 @@ static bool xdk_renderchain_init_shader(void *data, void *renderchain_data)
 #if defined(HAVE_HLSL)
    RARCH_LOG("D3D]: Using HLSL shader backend.\n");
    shader_path = settings->video.shader_path;
-   d3d->shader = &hlsl_backend;
+   const shader_backend_t *shader = &hlsl_backend;
 
-   return video_shader_driver_init(d3d->shader, d3d, shader_path); 
+   return video_shader_driver_init(hlsl_backend, d3d, shader_path); 
 #endif
 
    return true;
diff --git a/gfx/drivers/gl.c b/gfx/drivers/gl.c
index 47c2dcc72c..eedd69d41d 100644
--- a/gfx/drivers/gl.c
+++ b/gfx/drivers/gl.c
@@ -278,14 +278,12 @@ static bool gl_shader_init(gl_t *gl)
 #endif
 #endif
 
-   gl->shader = backend;
-
-   ret = video_shader_driver_init(gl->shader, gl, shader_path);
+   ret = video_shader_driver_init(backend, gl, shader_path);
 
    if (!ret)
    {
       RARCH_ERR("[GL]: Failed to initialize shader, falling back to stock.\n");
-      ret = video_shader_driver_init(gl->shader, gl, NULL);
+      ret = video_shader_driver_init(backend, gl, NULL);
    }
 
    return ret;
@@ -293,8 +291,7 @@ static bool gl_shader_init(gl_t *gl)
 
 static void gl_shader_deinit(gl_t *gl)
 {
-   video_shader_driver_deinit(gl->shader);
-   gl->shader = NULL;
+   video_shader_driver_deinit();
 }
 
 #ifndef NO_GL_FF_VERTEX
@@ -441,10 +438,10 @@ static void gl_create_fbo_texture(gl_t *gl, unsigned i, GLuint texture)
 
    glBindTexture(GL_TEXTURE_2D, texture);
 
-   mipmapped  = video_shader_driver_mipmap_input(gl->shader, i + 2);
+   mipmapped  = video_shader_driver_mipmap_input(i + 2);
    min_filter = mipmapped ? base_mip_filt : base_filt;
 
-   if (video_shader_driver_filter_type(gl->shader, i + 2, &smooth))
+   if (video_shader_driver_filter_type(i + 2, &smooth))
    {
       min_filter = mipmapped ? (smooth ? 
             GL_LINEAR_MIPMAP_LINEAR : GL_NEAREST_MIPMAP_NEAREST)
@@ -453,7 +450,7 @@ static void gl_create_fbo_texture(gl_t *gl, unsigned i, GLuint texture)
 
    mag_filter = min_filter_to_mag(min_filter);
 
-   wrap      = video_shader_driver_wrap_type(gl->shader, i + 2);
+   wrap      = video_shader_driver_wrap_type(i + 2);
    wrap_enum = gl_wrap_type_to_enum(wrap);
 
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, mag_filter);
@@ -626,16 +623,16 @@ static void gl_init_fbo(gl_t *gl, unsigned fbo_width, unsigned fbo_height)
    unsigned width, height;
    struct gfx_fbo_scale scale, scale_last;
 
-   if (!gl || video_shader_driver_num_shaders(gl->shader) == 0)
+   if (!gl || video_shader_driver_num_shaders() == 0)
       return;
 
    video_driver_get_size(&width, &height);
 
-   video_shader_scale(1, gl->shader, &scale);
-   video_shader_scale(video_shader_driver_num_shaders(gl->shader), gl->shader, &scale_last);
+   video_shader_driver_scale(1, &scale);
+   video_shader_driver_scale(video_shader_driver_num_shaders(), &scale_last);
 
    /* we always want FBO to be at least initialized on startup for consoles */
-   if (video_shader_driver_num_shaders(gl->shader) == 1 && !scale.valid)
+   if (video_shader_driver_num_shaders() == 1 && !scale.valid)
       return;
 
    if (!gl_check_fbo_proc(gl))
@@ -644,7 +641,7 @@ static void gl_init_fbo(gl_t *gl, unsigned fbo_width, unsigned fbo_height)
       return;
    }
 
-   gl->fbo_pass = video_shader_driver_num_shaders(gl->shader) - 1;
+   gl->fbo_pass = video_shader_driver_num_shaders() - 1;
    if (scale_last.valid)
       gl->fbo_pass++;
 
@@ -660,7 +657,7 @@ static void gl_init_fbo(gl_t *gl, unsigned fbo_width, unsigned fbo_height)
 
    for (i = 1; i < gl->fbo_pass; i++)
    {
-      video_shader_scale(i + 1, gl->shader, &gl->fbo_scale[i]);
+      video_shader_driver_scale(i + 1, &gl->fbo_scale[i]);
 
       if (!gl->fbo_scale[i].valid)
       {
@@ -681,7 +678,7 @@ static void gl_init_fbo(gl_t *gl, unsigned fbo_width, unsigned fbo_height)
             gl->fbo_rect[i].width, gl->fbo_rect[i].height);
    }
 
-   gl->fbo_feedback_enable = video_shader_driver_get_feedback_pass(gl->shader, &gl->fbo_feedback_pass);
+   gl->fbo_feedback_enable = video_shader_driver_get_feedback_pass(&gl->fbo_feedback_pass);
 
    if (gl->fbo_feedback_enable && gl->fbo_feedback_pass < (unsigned)gl->fbo_pass)
    {
@@ -1106,24 +1103,24 @@ static void gl_frame_fbo(gl_t *gl, uint64_t frame_count,
 
       glBindFramebuffer(RARCH_GL_FRAMEBUFFER, gl->fbo[i]);
 
-      video_shader_driver_use(gl->shader, gl, i + 1);
+      video_shader_driver_use(gl, i + 1);
       glBindTexture(GL_TEXTURE_2D, gl->fbo_texture[i - 1]);
 
-      if (video_shader_driver_mipmap_input(gl->shader, i + 1))
+      if (video_shader_driver_mipmap_input(i + 1))
          glGenerateMipmap(GL_TEXTURE_2D);
 
       glClear(GL_COLOR_BUFFER_BIT);
 
       /* Render to FBO with certain size. */
       gl_set_viewport(gl, rect->img_width, rect->img_height, true, false);
-      video_shader_driver_set_params(gl->shader, gl, prev_rect->img_width, prev_rect->img_height, 
+      video_shader_driver_set_params(gl, prev_rect->img_width, prev_rect->img_height, 
             prev_rect->width, prev_rect->height, 
             gl->vp.width, gl->vp.height, (unsigned int)frame_count, 
             tex_info, gl->prev_info, feedback_info, fbo_tex_info, fbo_tex_info_cnt);
 
       gl->coords.vertices = 4;
-      video_shader_driver_set_coords(gl->shader, NULL, &gl->coords);
-      video_shader_driver_set_mvp(gl->shader, gl, &gl->mvp);
+      video_shader_driver_set_coords(NULL, &gl->coords);
+      video_shader_driver_set_mvp(gl, &gl->mvp);
       glDrawArrays(GL_TRIANGLE_STRIP, 0, 4);
    }
 
@@ -1152,17 +1149,17 @@ static void gl_frame_fbo(gl_t *gl, uint64_t frame_count,
 
    /* Render our FBO texture to back buffer. */
    gl_bind_backbuffer();
-   video_shader_driver_use(gl->shader, gl, gl->fbo_pass + 1);
+   video_shader_driver_use(gl, gl->fbo_pass + 1);
 
    glBindTexture(GL_TEXTURE_2D, gl->fbo_texture[gl->fbo_pass - 1]);
 
-   if (video_shader_driver_mipmap_input(gl->shader, gl->fbo_pass + 1))
+   if (video_shader_driver_mipmap_input(gl->fbo_pass + 1))
       glGenerateMipmap(GL_TEXTURE_2D);
 
    glClear(GL_COLOR_BUFFER_BIT);
    gl_set_viewport(gl, width, height, false, true);
 
-   video_shader_driver_set_params(gl->shader, gl,
+   video_shader_driver_set_params(gl,
          prev_rect->img_width, prev_rect->img_height, 
          prev_rect->width, prev_rect->height, 
          gl->vp.width, gl->vp.height, (unsigned int)frame_count, 
@@ -1171,8 +1168,8 @@ static void gl_frame_fbo(gl_t *gl, uint64_t frame_count,
    gl->coords.vertex = gl->vertex_ptr;
 
    gl->coords.vertices = 4;
-   video_shader_driver_set_coords(gl->shader, NULL, &gl->coords);
-   video_shader_driver_set_mvp(gl->shader, gl, &gl->mvp);
+   video_shader_driver_set_coords(NULL, &gl->coords);
+   video_shader_driver_set_mvp(gl, &gl->mvp);
    glDrawArrays(GL_TRIANGLE_STRIP, 0, 4);
 
    gl->coords.tex_coord = gl->tex_info.coord;
@@ -1536,7 +1533,7 @@ static INLINE void gl_set_shader_viewport(gl_t *gl, unsigned shader)
 
    video_driver_get_size(&width, &height);
 
-   video_shader_driver_use(gl->shader, gl, shader);
+   video_shader_driver_use(gl, shader);
    gl_set_viewport(gl, width, height, false, true);
 }
 
@@ -1608,10 +1605,10 @@ static INLINE void gl_draw_texture(gl_t *gl)
    gl->coords.color     = color;
    glBindTexture(GL_TEXTURE_2D, gl->menu_texture);
 
-   video_shader_driver_use(gl->shader, gl, GL_SHADER_STOCK_BLEND);
+   video_shader_driver_use(gl, GL_SHADER_STOCK_BLEND);
    gl->coords.vertices  = 4;
-   video_shader_driver_set_coords(gl->shader, NULL, &gl->coords);
-   video_shader_driver_set_mvp(gl->shader, gl, &gl->mvp_no_rot);
+   video_shader_driver_set_coords(NULL, &gl->coords);
+   video_shader_driver_set_mvp(gl, &gl->mvp_no_rot);
 
    glEnable(GL_BLEND);
 
@@ -1656,7 +1653,7 @@ static bool gl_frame(void *data, const void *frame,
       glBindVertexArray(gl->vao);
 #endif
 
-   video_shader_driver_use(gl->shader, gl, 1);
+   video_shader_driver_use(gl, 1);
 
 #ifdef IOS
    /* Apparently the viewport is lost each frame, thanks Apple. */
@@ -1768,7 +1765,7 @@ static bool gl_frame(void *data, const void *frame,
 
    glClear(GL_COLOR_BUFFER_BIT);
 
-   video_shader_driver_set_params(gl->shader, gl,
+   video_shader_driver_set_params(gl,
          frame_width, frame_height,
          gl->tex_w, gl->tex_h,
          gl->vp.width, gl->vp.height,
@@ -1777,8 +1774,8 @@ static bool gl_frame(void *data, const void *frame,
          NULL, 0);
 
    gl->coords.vertices = 4;
-   video_shader_driver_set_coords(gl->shader, NULL, &gl->coords);
-   video_shader_driver_set_mvp(gl->shader, gl, &gl->mvp);
+   video_shader_driver_set_coords(NULL, &gl->coords);
+   video_shader_driver_set_mvp(gl, &gl->mvp);
    glDrawArrays(GL_TRIANGLE_STRIP, 0, 4);
 
 #ifdef HAVE_FBO
@@ -1814,7 +1811,7 @@ static bool gl_frame(void *data, const void *frame,
    /* Reset state which could easily mess up libretro core. */
    if (gl->hw_render_fbo_init)
    {
-      video_shader_driver_use(gl->shader, gl, 0);
+      video_shader_driver_use(gl, 0);
       glBindTexture(GL_TEXTURE_2D, 0);
 #ifndef NO_GL_FF_VERTEX
       gl_disable_client_arrays(gl);
@@ -2557,12 +2554,10 @@ static void *gl_init(const video_info_t *video, const input_driver_t **input, vo
          hw_render->version_major, hw_render->version_minor);
 #endif
 
-   gl->shader      = (const shader_backend_t*)shader_ctx_init_first();
+   if (!shader_driver_ctx_init_first())
+      goto error;
 
-   if (gl->shader)
-   {
-      RARCH_LOG("[GL]: Default shader backend found: %s.\n", video_shader_driver_get_ident(gl->shader));
-   }
+   RARCH_LOG("[GL]: Default shader backend found: %s.\n", video_shader_driver_get_ident());
 
    if (!gl_shader_init(gl))
    {
@@ -2570,14 +2565,13 @@ static void *gl_init(const video_info_t *video, const input_driver_t **input, vo
       goto error;
    }
 
-   if (gl->shader)
    {
-      unsigned minimum = video_shader_driver_get_prev_textures(gl->shader);
+      unsigned minimum = video_shader_driver_get_prev_textures();
       gl->textures     = max(minimum + 1, gl->textures);
    }
 
    RARCH_LOG("[GL]: Using %u textures.\n", gl->textures);
-   RARCH_LOG("[GL]: Loaded %u program(s).\n", video_shader_driver_num_shaders(gl->shader));
+   RARCH_LOG("[GL]: Loaded %u program(s).\n", video_shader_driver_num_shaders());
 
    gl->tex_w = gl->tex_h = (RARCH_SCALE_BASE * video->input_scale);
    gl->keep_aspect     = video->force_aspect;
@@ -2587,9 +2581,9 @@ static void *gl_init(const video_info_t *video, const input_driver_t **input, vo
    gl_set_shader_viewport(gl, 0);
    gl_set_shader_viewport(gl, 1);
 
-   gl->tex_mipmap      = video_shader_driver_mipmap_input(gl->shader, 1);
+   gl->tex_mipmap      = video_shader_driver_mipmap_input(1);
 
-   if (video_shader_driver_filter_type(gl->shader, 1, &force_smooth))
+   if (video_shader_driver_filter_type(1, &force_smooth))
       gl->tex_min_filter = gl->tex_mipmap ? (force_smooth ? 
             GL_LINEAR_MIPMAP_LINEAR : GL_NEAREST_MIPMAP_NEAREST) 
          : (force_smooth ? GL_LINEAR : GL_NEAREST);
@@ -2599,7 +2593,7 @@ static void *gl_init(const video_info_t *video, const input_driver_t **input, vo
          : (video->smooth ? GL_LINEAR : GL_NEAREST);
    
    gl->tex_mag_filter = min_filter_to_mag(gl->tex_min_filter);
-   gl->wrap_mode      = gl_wrap_type_to_enum(video_shader_driver_wrap_type(gl->shader, 1));
+   gl->wrap_mode      = gl_wrap_type_to_enum(video_shader_driver_wrap_type(1));
 
    gl_set_texture_fmts(gl, video->rgb32);
 
@@ -2722,11 +2716,11 @@ static void gl_update_tex_filter_frame(gl_t *gl)
 
    context_bind_hw_render(gl, false);
 
-   if (!video_shader_driver_filter_type(gl->shader, 1, &smooth))
+   if (!video_shader_driver_filter_type(1, &smooth))
       smooth = settings->video.smooth;
 
-   wrap_mode             = gl_wrap_type_to_enum(video_shader_driver_wrap_type(gl->shader, 1));
-   gl->tex_mipmap        = video_shader_driver_mipmap_input(gl->shader, 1);
+   wrap_mode             = gl_wrap_type_to_enum(video_shader_driver_wrap_type(1));
+   gl->tex_mipmap        = video_shader_driver_mipmap_input(1);
 
    gl->video_info.smooth = smooth;
    new_filt = gl->tex_mipmap ? (smooth ? 
@@ -2760,6 +2754,7 @@ static bool gl_set_shader(void *data,
       enum rarch_shader_type type, const char *path)
 {
 #if defined(HAVE_GLSL) || defined(HAVE_CG)
+   const shader_backend_t *shader = NULL;
    gl_t *gl = (gl_t*)data;
 
    if (!gl)
@@ -2776,13 +2771,13 @@ static bool gl_set_shader(void *data,
    {
 #ifdef HAVE_GLSL
       case RARCH_SHADER_GLSL:
-         gl->shader = &gl_glsl_backend;
+         shader = &gl_glsl_backend;
          break;
 #endif
 
 #ifdef HAVE_CG
       case RARCH_SHADER_CG:
-         gl->shader = &gl_cg_backend;
+         shader = &gl_cg_backend;
          break;
 #endif
 
@@ -2790,7 +2785,7 @@ static bool gl_set_shader(void *data,
          break;
    }
 
-   if (!gl->shader)
+   if (!shader)
    {
       RARCH_ERR("[GL]: Cannot find shader core for path: %s.\n", path);
       context_bind_hw_render(gl, true);
@@ -2802,23 +2797,21 @@ static bool gl_set_shader(void *data,
    glBindTexture(GL_TEXTURE_2D, gl->texture[gl->tex_index]);
 #endif
 
-   if (!video_shader_driver_init(gl->shader, gl, path))
+   if (!video_shader_driver_init(shader, gl, path))
    {
-      bool ret = video_shader_driver_init(gl->shader, gl, NULL);
+      bool ret = video_shader_driver_init(shader, gl, NULL);
 
       RARCH_WARN("[GL]: Failed to set multipass shader. Falling back to stock.\n");
 
-      if (!ret)
-         gl->shader = NULL;
       context_bind_hw_render(gl, true);
       return false;
    }
 
    gl_update_tex_filter_frame(gl);
 
-   if (gl->shader)
+   if (shader)
    {
-      unsigned textures = video_shader_driver_get_prev_textures(gl->shader) + 1;
+      unsigned textures = video_shader_driver_get_prev_textures() + 1;
 
       if (textures > gl->textures) /* Have to reinit a bit. */
       {
@@ -3235,15 +3228,15 @@ static void gl_render_overlay(void *data)
       glViewport(0, 0, width, height);
 
    /* Ensure that we reset the attrib array. */
-   video_shader_driver_use(gl->shader, gl, GL_SHADER_STOCK_BLEND);
+   video_shader_driver_use(gl, GL_SHADER_STOCK_BLEND);
 
    gl->coords.vertex    = gl->overlay_vertex_coord;
    gl->coords.tex_coord = gl->overlay_tex_coord;
    gl->coords.color     = gl->overlay_color_coord;
    gl->coords.vertices  = 4 * gl->overlays;
 
-   video_shader_driver_set_coords(gl->shader, NULL, &gl->coords);
-   video_shader_driver_set_mvp(gl->shader, gl, &gl->mvp_no_rot);
+   video_shader_driver_set_coords(NULL, &gl->coords);
+   video_shader_driver_set_mvp(gl, &gl->mvp_no_rot);
 
    for (i = 0; i < gl->overlays; i++)
    {
@@ -3387,10 +3380,7 @@ static void gl_show_mouse(void *data, bool state)
 
 static struct video_shader *gl_get_current_shader(void *data)
 {
-   gl_t *gl = (gl_t*)data;
-   if (!gl)
-      return NULL;
-   return video_shader_driver_direct_get_current_shader(gl->shader);
+   return video_shader_driver_direct_get_current_shader();
 }
 #endif
 
diff --git a/gfx/drivers_font/gl_raster_font.c b/gfx/drivers_font/gl_raster_font.c
index 67c37cf9a3..48118e9d8f 100644
--- a/gfx/drivers_font/gl_raster_font.c
+++ b/gfx/drivers_font/gl_raster_font.c
@@ -225,11 +225,8 @@ static int gl_get_message_width(void *data, const char *msg, unsigned msg_len_fu
 
 static void gl_raster_font_draw_vertices(gl_t *gl, const gfx_coords_t *coords)
 {
-   if (!gl)
-      return;
-
-   video_shader_driver_set_coords(gl->shader, NULL, coords);
-   video_shader_driver_set_mvp(gl->shader, gl, &gl->mvp_no_rot);
+   video_shader_driver_set_coords(NULL, coords);
+   video_shader_driver_set_mvp(gl, &gl->mvp_no_rot);
 
    glDrawArrays(GL_TRIANGLES, 0, coords->vertices);
 }
@@ -367,7 +364,6 @@ static void gl_raster_font_render_message(
 static void gl_raster_font_setup_viewport(gl_raster_t *font, bool full_screen)
 {
    unsigned width, height;
-   gl_t *gl = font ? font->gl : NULL;
 
    video_driver_get_size(&width, &height);
 
@@ -379,7 +375,7 @@ static void gl_raster_font_setup_viewport(gl_raster_t *font, bool full_screen)
 
    glBindTexture(GL_TEXTURE_2D, font->tex);
 
-   video_shader_driver_use(gl->shader, NULL, GL_SHADER_STOCK_BLEND);
+   video_shader_driver_use(NULL, GL_SHADER_STOCK_BLEND);
 }
 
 static void gl_raster_font_restore_viewport(gl_t *gl)
diff --git a/gfx/video_shader_driver.c b/gfx/video_shader_driver.c
index 4af40e572e..b331d506e9 100644
--- a/gfx/video_shader_driver.c
+++ b/gfx/video_shader_driver.c
@@ -32,6 +32,7 @@ static const shader_backend_t *shader_ctx_drivers[] = {
    NULL
 };
 
+static const shader_backend_t *current_shader;
 static void *shader_data;
 
 /**
@@ -56,20 +57,23 @@ const shader_backend_t *shader_ctx_find_driver(const char *ident)
 }
 
 /**
- * shader_ctx_init_first:
+ * shader_driver_ctx_init_first:
  *
- * Finds first suitable shader context driver and initializes.
+ * Finds first suitable shader context driver.
  *
- * Returns: shader context driver if found, otherwise NULL.
+ * Returns: true (1) if found, otherwise false (0).
  **/
-const shader_backend_t *shader_ctx_init_first(void)
+bool shader_driver_ctx_init_first(void)
 {
    unsigned i;
 
    for (i = 0; shader_ctx_drivers[i]; i++)
-      return shader_ctx_drivers[i];
+   {
+      current_shader = shader_ctx_drivers[i];
+      return true;
+   }
 
-   return NULL;
+   return false;
 }
 
 struct video_shader *video_shader_driver_get_current_shader(void)
@@ -83,16 +87,15 @@ struct video_shader *video_shader_driver_get_current_shader(void)
    return video_poke->get_current_shader(video_driver);
 }
 
-void video_shader_scale(unsigned idx,
-      const shader_backend_t *shader,  struct gfx_fbo_scale *scale)
+void video_shader_driver_scale(unsigned idx, struct gfx_fbo_scale *scale)
 {
-   if (!scale || !shader)
+   if (!scale || !current_shader)
       return;
 
    scale->valid = false;
 
-   if (shader->shader_scale)
-      shader->shader_scale(shader_data, idx, scale);
+   if (current_shader->shader_scale)
+      current_shader->shader_scale(shader_data, idx, scale);
 }
 
 bool video_shader_driver_init(const shader_backend_t *shader, void *data, const char *path)
@@ -107,98 +110,100 @@ bool video_shader_driver_init(const shader_backend_t *shader, void *data, const
    if (!tmp)
       return false;
 
-   shader_data = tmp;
+   shader_data    = tmp;
+   current_shader = shader;
 
    return true;
 }
 
-void video_shader_driver_deinit(const shader_backend_t *shader)
+void video_shader_driver_deinit(void)
 {
-   if (!shader)
+   if (!current_shader)
       return;
 
-   if (shader->deinit)
-      shader->deinit(shader_data);
+   if (current_shader->deinit)
+      current_shader->deinit(shader_data);
 
-   shader_data = NULL;
+   shader_data    = NULL;
+   current_shader = NULL;
 }
 
-void video_shader_driver_use(const shader_backend_t *shader, void *data, unsigned index)
+void video_shader_driver_use(void *data, unsigned index)
 {
-   if (!shader)
+   if (!current_shader)
       return;
-   shader->use(data, shader_data, index);
+   current_shader->use(data, shader_data, index);
 }
 
-const char *video_shader_driver_get_ident(const shader_backend_t *shader)
+const char *video_shader_driver_get_ident(void)
 {
-   if (!shader)
+   if (!current_shader)
       return NULL;
-   return shader->ident;
+   return current_shader->ident;
 }
 
-bool video_shader_driver_mipmap_input(const shader_backend_t *shader, unsigned index)
+bool video_shader_driver_mipmap_input(unsigned index)
 {
-   if (!shader)
+   if (!current_shader)
       return false;
-   return shader->mipmap_input(shader_data, index);
+   return current_shader->mipmap_input(shader_data, index);
 }
 
-unsigned video_shader_driver_num_shaders(const shader_backend_t *shader)
+unsigned video_shader_driver_num_shaders(void)
 {
-   if (!shader)
+   if (!current_shader)
       return 0;
-   return shader->num_shaders(shader_data);
+   return current_shader->num_shaders(shader_data);
 }
 
-unsigned video_shader_driver_get_prev_textures(const shader_backend_t *shader)
+unsigned video_shader_driver_get_prev_textures(void)
 {
-   if (!shader)
+   if (!current_shader)
       return 0;
-   return shader->get_prev_textures(shader_data);
+   return current_shader->get_prev_textures(shader_data);
 }
 
-bool video_shader_driver_set_coords(const shader_backend_t *shader, void *handle_data, const void *data)
+bool video_shader_driver_set_coords(void *handle_data, const void *data)
 {
-   if (!shader || !shader->set_coords)
+   if (!current_shader || !current_shader->set_coords)
       return false;
-   return shader->set_coords(handle_data, shader_data, data);
+   return current_shader->set_coords(handle_data, shader_data, data);
 }
 
-bool video_shader_driver_set_mvp(const shader_backend_t *shader, void *data, const math_matrix_4x4 *mat)
+bool video_shader_driver_set_mvp(void *data, const math_matrix_4x4 *mat)
 {
-   if (!shader || !shader->set_mvp)
+   if (!current_shader || !current_shader->set_mvp)
       return false;
-   return shader->set_mvp(data, shader_data, mat);
+   return current_shader->set_mvp(data, shader_data, mat);
 }
 
-bool video_shader_driver_filter_type(const shader_backend_t *shader, unsigned index, bool *smooth)
+bool video_shader_driver_filter_type(unsigned index, bool *smooth)
 {
-   if (!shader || !shader->filter_type)
+   if (!current_shader || !current_shader->filter_type)
       return false;
-   return shader->filter_type(shader_data, index, smooth);
+   return current_shader->filter_type(shader_data, index, smooth);
 }
 
-enum gfx_wrap_type video_shader_driver_wrap_type(const shader_backend_t *shader, unsigned index)
+enum gfx_wrap_type video_shader_driver_wrap_type(unsigned index)
 {
-   return shader->wrap_type(shader_data, index);
+   return current_shader->wrap_type(shader_data, index);
 }
 
-bool video_shader_driver_get_feedback_pass(const shader_backend_t *shader, unsigned *pass)
+bool video_shader_driver_get_feedback_pass(unsigned *pass)
 {
-   if (!shader || !shader->get_feedback_pass)
+   if (!current_shader || !current_shader->get_feedback_pass)
       return false;
-   return shader->get_feedback_pass(shader_data, pass);
+   return current_shader->get_feedback_pass(shader_data, pass);
 }
 
-struct video_shader *video_shader_driver_direct_get_current_shader(const shader_backend_t *shader)
+struct video_shader *video_shader_driver_direct_get_current_shader(void)
 {
-   if (!shader || !shader->get_current_shader)
+   if (!current_shader || !current_shader->get_current_shader)
       return NULL;
-   return shader->get_current_shader(shader_data);
+   return current_shader->get_current_shader(shader_data);
 }
 
-void video_shader_driver_set_params(const shader_backend_t *shader, 
+void video_shader_driver_set_params( 
       void *data, unsigned width, unsigned height, 
       unsigned tex_width, unsigned tex_height, 
       unsigned out_width, unsigned out_height,
@@ -208,9 +213,9 @@ void video_shader_driver_set_params(const shader_backend_t *shader,
       const void *feedback_info,
       const void *fbo_info, unsigned fbo_info_cnt)
 {
-   if (!shader || !shader->set_params)
+   if (!current_shader || !current_shader->set_params)
       return;
-   return shader->set_params(data, shader_data,
+   return current_shader->set_params(data, shader_data,
          width, height, tex_width, tex_height,
          out_width, out_height, frame_counter, info, prev_info, feedback_info,
          fbo_info, fbo_info_cnt);
diff --git a/gfx/video_shader_driver.h b/gfx/video_shader_driver.h
index 0a16dcbedf..c7fb2bf36f 100644
--- a/gfx/video_shader_driver.h
+++ b/gfx/video_shader_driver.h
@@ -92,8 +92,7 @@ extern const shader_backend_t shader_null_backend;
 
 #endif
 
-void video_shader_scale(unsigned idx,
-      const shader_backend_t *shader,  struct gfx_fbo_scale *scale);
+void video_shader_driver_scale(unsigned idx, struct gfx_fbo_scale *scale);
 
 /**
  * shader_ctx_find_driver:
@@ -106,43 +105,43 @@ void video_shader_scale(unsigned idx,
 const shader_backend_t *shader_ctx_find_driver(const char *ident);
 
 /**
- * shader_ctx_init_first:
+ * shader_driver_ctx_init_first:
  *
- * Finds first suitable shader context driver and initializes.
+ * Finds first suitable shader context driver.
  *
  * Returns: shader context driver if found, otherwise NULL.
  **/
-const shader_backend_t *shader_ctx_init_first(void);
+bool shader_driver_ctx_init_first(void);
 
 struct video_shader *video_shader_driver_get_current_shader(void);
 
 bool video_shader_driver_init(const shader_backend_t *shader, void *data, const char *path);
 
-void video_shader_driver_deinit(const shader_backend_t *shader);
+void video_shader_driver_deinit(void);
 
-void video_shader_driver_use(const shader_backend_t *shader, void *data, unsigned index);
+void video_shader_driver_use(void *data, unsigned index);
 
-const char *video_shader_driver_get_ident(const shader_backend_t *shader);
+const char *video_shader_driver_get_ident(void);
 
-bool video_shader_driver_mipmap_input(const shader_backend_t *shader, unsigned index);
+bool video_shader_driver_mipmap_input(unsigned index);
 
-unsigned video_shader_driver_num_shaders(const shader_backend_t *shader);
+unsigned video_shader_driver_num_shaders(void);
 
-bool video_shader_driver_set_coords(const shader_backend_t *shader, void *handle_data, const void *data);
+bool video_shader_driver_set_coords(void *handle_data, const void *data);
 
-bool video_shader_driver_set_mvp(const shader_backend_t *shader, void *data, const math_matrix_4x4 *mat);
+bool video_shader_driver_set_mvp(void *data, const math_matrix_4x4 *mat);
 
-unsigned video_shader_driver_get_prev_textures(const shader_backend_t *shader);
+unsigned video_shader_driver_get_prev_textures(void);
 
-bool video_shader_driver_filter_type(const shader_backend_t *shader, unsigned index, bool *smooth);
+bool video_shader_driver_filter_type(unsigned index, bool *smooth);
 
-enum gfx_wrap_type video_shader_driver_wrap_type(const shader_backend_t *shader, unsigned index);
+enum gfx_wrap_type video_shader_driver_wrap_type(unsigned index);
 
-bool video_shader_driver_get_feedback_pass(const shader_backend_t *shader, unsigned *pass);
+bool video_shader_driver_get_feedback_pass(unsigned *pass);
 
-struct video_shader *video_shader_driver_direct_get_current_shader(const shader_backend_t *shader);
+struct video_shader *video_shader_driver_direct_get_current_shader(void);
 
-void video_shader_driver_set_params(const shader_backend_t *shader, 
+void video_shader_driver_set_params( 
       void *data, unsigned width, unsigned height, 
       unsigned tex_width, unsigned tex_height, 
       unsigned out_width, unsigned out_height,
diff --git a/menu/drivers_display/menu_display_d3d.cpp b/menu/drivers_display/menu_display_d3d.cpp
index d4c209fa52..4e4f9cec64 100644
--- a/menu/drivers_display/menu_display_d3d.cpp
+++ b/menu/drivers_display/menu_display_d3d.cpp
@@ -83,11 +83,6 @@ static void menu_display_d3d_blend_begin(void)
       return;
 
    d3d_enable_blend_func(d3d->dev);
-
-#if 0
-   if (gl->shader && gl->shader->use)
-      gl->shader->use(gl, GL_SHADER_STOCK_BLEND);
-#endif
 }
 
 static void menu_display_d3d_blend_end(void)
diff --git a/menu/drivers_display/menu_display_gl.c b/menu/drivers_display/menu_display_gl.c
index 8602c988cc..2d1ec6db21 100644
--- a/menu/drivers_display/menu_display_gl.c
+++ b/menu/drivers_display/menu_display_gl.c
@@ -73,15 +73,10 @@ static GLenum menu_display_prim_to_gl_enum(enum menu_display_prim_type prim_type
 
 static void menu_display_gl_blend_begin(void)
 {
-   gl_t *gl = gl_get_ptr();
-
-   if (!gl)
-      return;
-
    glEnable(GL_BLEND);
    glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
 
-   video_shader_driver_use(gl->shader, NULL, GL_SHADER_STOCK_BLEND);
+   video_shader_driver_use(NULL, GL_SHADER_STOCK_BLEND);
 }
 
 static void menu_display_gl_blend_end(void)
@@ -120,8 +115,8 @@ static void menu_display_gl_draw(
    glViewport(x, y, width, height);
    glBindTexture(GL_TEXTURE_2D, (GLuint)texture);
 
-   video_shader_driver_set_coords(gl->shader, gl, coords);
-   video_shader_driver_set_mvp(gl->shader, video_driver_get_ptr(false), mat);
+   video_shader_driver_set_coords(gl, coords);
+   video_shader_driver_set_mvp(video_driver_get_ptr(false), mat);
 
    glDrawArrays(menu_display_prim_to_gl_enum(prim_type), 0, coords->vertices);