diff --git a/driver.h b/driver.h
index a6a926a174..0738fb8228 100644
--- a/driver.h
+++ b/driver.h
@@ -205,7 +205,6 @@ typedef struct driver
    void *camera_data;
    void *location_data;
    void *recording_data;
-   void *video_shader_data;
    void *netplay_data;
    void *ui_companion_data;
 
diff --git a/gfx/drivers/gl.c b/gfx/drivers/gl.c
index f41791af86..bc8885004a 100644
--- a/gfx/drivers/gl.c
+++ b/gfx/drivers/gl.c
@@ -1117,7 +1117,7 @@ static void gl_frame_fbo(gl_t *gl, uint64_t 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, &gl->coords);
+      video_shader_driver_set_coords(gl->shader, NULL, &gl->coords);
       video_shader_driver_set_mvp(gl->shader, gl, &gl->mvp);
       glDrawArrays(GL_TRIANGLE_STRIP, 0, 4);
    }
@@ -1166,7 +1166,7 @@ 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, &gl->coords);
+   video_shader_driver_set_coords(gl->shader, NULL, &gl->coords);
    video_shader_driver_set_mvp(gl->shader, gl, &gl->mvp);
    glDrawArrays(GL_TRIANGLE_STRIP, 0, 4);
 
@@ -1605,7 +1605,7 @@ static INLINE void gl_draw_texture(gl_t *gl)
 
    video_shader_driver_use(gl->shader, gl, GL_SHADER_STOCK_BLEND);
    gl->coords.vertices  = 4;
-   video_shader_driver_set_coords(gl->shader, &gl->coords);
+   video_shader_driver_set_coords(gl->shader, NULL, &gl->coords);
    video_shader_driver_set_mvp(gl->shader, gl, &gl->mvp_no_rot);
 
    glEnable(GL_BLEND);
@@ -1774,7 +1774,7 @@ static bool gl_frame(void *data, const void *frame,
          NULL, 0);
 
    gl->coords.vertices = 4;
-   video_shader_driver_set_coords(gl->shader, &gl->coords);
+   video_shader_driver_set_coords(gl->shader, NULL, &gl->coords);
    video_shader_driver_set_mvp(gl->shader, gl, &gl->mvp);
    glDrawArrays(GL_TRIANGLE_STRIP, 0, 4);
 
@@ -3247,7 +3247,7 @@ static void gl_render_overlay(void *data)
    gl->coords.color     = gl->overlay_color_coord;
    gl->coords.vertices  = 4 * gl->overlays;
 
-   video_shader_driver_set_coords(gl->shader, &gl->coords);
+   video_shader_driver_set_coords(gl->shader, NULL, &gl->coords);
    video_shader_driver_set_mvp(gl->shader, gl, &gl->mvp_no_rot);
 
    for (i = 0; i < gl->overlays; i++)
diff --git a/gfx/drivers_font/gl_raster_font.c b/gfx/drivers_font/gl_raster_font.c
index 33e830baca..11aeac6857 100644
--- a/gfx/drivers_font/gl_raster_font.c
+++ b/gfx/drivers_font/gl_raster_font.c
@@ -228,8 +228,8 @@ static void gl_raster_font_draw_vertices(gl_t *gl, const gfx_coords_t *coords)
    if (!gl)
       return;
 
-   gl->shader->set_coords(coords);
-   gl->shader->set_mvp(gl, &gl->mvp_no_rot);
+   video_shader_driver_set_coords(gl->shader, NULL, coords);
+   video_shader_driver_set_mvp(gl->shader, gl, &gl->mvp_no_rot);
 
    glDrawArrays(GL_TRIANGLES, 0, coords->vertices);
 }
@@ -367,10 +367,7 @@ 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->gl;
-
-   if (!gl)
-      return;
+   gl_t *gl = font ? font->gl : NULL;
 
    video_driver_get_size(&width, &height);
 
@@ -382,8 +379,7 @@ static void gl_raster_font_setup_viewport(gl_raster_t *font, bool full_screen)
 
    glBindTexture(GL_TEXTURE_2D, font->tex);
 
-   if (gl->shader && gl->shader->use)
-      gl->shader->use(gl, GL_SHADER_STOCK_BLEND);
+   video_shader_driver_use(gl->shader, NULL, GL_SHADER_STOCK_BLEND);
 }
 
 static void gl_raster_font_restore_viewport(gl_t *gl)
diff --git a/gfx/drivers_shader/shader_gl_cg.c b/gfx/drivers_shader/shader_gl_cg.c
index 40a44dd462..02e95e95fa 100644
--- a/gfx/drivers_shader/shader_gl_cg.c
+++ b/gfx/drivers_shader/shader_gl_cg.c
@@ -156,11 +156,10 @@ typedef struct cg_shader_data
    CGcontext cgCtx;
 } cg_shader_data_t;
 
-static cg_shader_data_t *cg_data;
-
-static void gl_cg_reset_attrib(void)
+static void gl_cg_reset_attrib(void *data)
 {
    unsigned i;
+   cg_shader_data_t *cg_data = (cg_shader_data_t*)data;
 
    /* Add sanity check that we did not overflow. */
    retro_assert(cg_data->cg_attrib_idx <= ARRAY_SIZE(cg_data->cg_attribs));
@@ -170,8 +169,9 @@ static void gl_cg_reset_attrib(void)
    cg_data->cg_attrib_idx = 0;
 }
 
-static bool gl_cg_set_mvp(void *data, const math_matrix_4x4 *mat)
+static bool gl_cg_set_mvp(void *data, void *shader_data, const math_matrix_4x4 *mat)
 {
+   cg_shader_data_t *cg_data = (cg_shader_data_t*)shader_data;
    if (cg_data && cg_data->prg[cg_data->active_idx].mvp)
    {
       cgGLSetMatrixParameterfc(cg_data->prg[cg_data->active_idx].mvp, mat->data);
@@ -191,9 +191,10 @@ static bool gl_cg_set_mvp(void *data, const math_matrix_4x4 *mat)
    } \
 } while(0)
 
-static bool gl_cg_set_coords(const void *data)
+static bool gl_cg_set_coords(void *handle_data, void *shader_data, const void *data)
 {
    const struct gfx_coords *coords = (const struct gfx_coords*)data;
+   cg_shader_data_t *cg_data = (cg_shader_data_t*)shader_data;
 
    if (!cg_data || !coords)
       goto fallback;
@@ -214,8 +215,10 @@ fallback:
 #define set_param_1f(param, x) \
    if (param) cgGLSetParameter1f(param, x)
 
-static void gl_cg_set_texture_info(const struct cg_fbo_params *params, const struct gfx_tex_info *info)
+static void gl_cg_set_texture_info(void *data, 
+      const struct cg_fbo_params *params, const struct gfx_tex_info *info)
 {
+   cg_shader_data_t *cg_data = (cg_shader_data_t*)data;
    CGparameter param = params->tex;
    if (param)
    {
@@ -241,7 +244,8 @@ static void gl_cg_set_texture_info(const struct cg_fbo_params *params, const str
    }
 }
 
-static void gl_cg_set_params(void *data, unsigned width, unsigned height, 
+static void gl_cg_set_params(void *data, void *shader_data,
+      unsigned width, unsigned height, 
       unsigned tex_width, unsigned tex_height,
       unsigned out_width, unsigned out_height,
       unsigned frame_count,
@@ -256,8 +260,8 @@ static void gl_cg_set_params(void *data, unsigned width, unsigned height,
    const struct gfx_tex_info *prev_info = (const struct gfx_tex_info*)_prev_info;
    const struct gfx_tex_info *feedback_info = (const struct gfx_tex_info*)_feedback_info;
    const struct gfx_tex_info *fbo_info = (const struct gfx_tex_info*)_fbo_info;
+   cg_shader_data_t *cg_data = (cg_shader_data_t*)shader_data;
 
-   (void)data;
    if (!cg_data || (cg_data->active_idx == 0) ||
          (cg_data->active_idx == GL_SHADER_STOCK_BLEND))
       return;
@@ -286,14 +290,14 @@ static void gl_cg_set_params(void *data, unsigned width, unsigned height,
    }
 
    /* Set orig texture. */
-   gl_cg_set_texture_info(&cg_data->prg[cg_data->active_idx].orig, info);
+   gl_cg_set_texture_info(cg_data, &cg_data->prg[cg_data->active_idx].orig, info);
 
    /* Set feedback texture. */
-   gl_cg_set_texture_info(&cg_data->prg[cg_data->active_idx].feedback, feedback_info);
+   gl_cg_set_texture_info(cg_data, &cg_data->prg[cg_data->active_idx].feedback, feedback_info);
 
    /* Set prev textures. */
    for (i = 0; i < PREV_TEXTURES; i++)
-      gl_cg_set_texture_info(&cg_data->prg[cg_data->active_idx].prev[i], &prev_info[i]);
+      gl_cg_set_texture_info(cg_data, &cg_data->prg[cg_data->active_idx].prev[i], &prev_info[i]);
 
    /* Set lookup textures. */
    for (i = 0; i < cg_data->shader->luts; i++)
@@ -322,7 +326,7 @@ static void gl_cg_set_params(void *data, unsigned width, unsigned height,
    if (cg_data->active_idx)
    {
       for (i = 0; i < fbo_info_cnt; i++)
-         gl_cg_set_texture_info(&cg_data->prg[cg_data->active_idx].fbo[i], &fbo_info[i]);
+         gl_cg_set_texture_info(cg_data, &cg_data->prg[cg_data->active_idx].fbo[i], &fbo_info[i]);
    }
 
    /* #pragma parameters. */
@@ -359,9 +363,10 @@ static void gl_cg_set_params(void *data, unsigned width, unsigned height,
    }
 }
 
-static void gl_cg_deinit_progs()
+static void gl_cg_deinit_progs(void *data)
 {
    unsigned i;
+   cg_shader_data_t *cg_data = (cg_shader_data_t*)data;
 
    if (!cg_data)
       return;
@@ -387,14 +392,15 @@ static void gl_cg_deinit_progs()
    memset(cg_data->prg, 0, sizeof(cg_data->prg));
 }
 
-static void gl_cg_destroy_resources()
+static void gl_cg_destroy_resources(void *data)
 {
+   cg_shader_data_t *cg_data = (cg_shader_data_t*)data;
    if (!cg_data)
       return;
 
-   gl_cg_reset_attrib();
+   gl_cg_reset_attrib(data);
 
-   gl_cg_deinit_progs();
+   gl_cg_deinit_progs(data);
 
    if (cg_data->shader && cg_data->shader->luts)
    {
@@ -413,8 +419,9 @@ static void gl_cg_destroy_resources()
 }
 
 /* Final deinit. */
-static void gl_cg_deinit_context_state(void)
+static void gl_cg_deinit_context_state(void *data)
 {
+   cg_shader_data_t *cg_data = (cg_shader_data_t*)data;
    if (cg_data->cgCtx)
    {
       RARCH_LOG("CG: Destroying context.\n");
@@ -424,16 +431,16 @@ static void gl_cg_deinit_context_state(void)
 }
 
 /* Full deinit. */
-static void gl_cg_deinit(void)
+static void gl_cg_deinit(void *data)
 {
+   cg_shader_data_t *cg_data = (cg_shader_data_t*)data;
    if (!cg_data)
       return;
 
-   gl_cg_destroy_resources();
-   gl_cg_deinit_context_state();
+   gl_cg_destroy_resources(cg_data);
+   gl_cg_deinit_context_state(cg_data);
 
    free(cg_data);
-   cg_data = NULL;
 }
 
 #define SET_LISTING(cg_data, type) \
@@ -443,13 +450,14 @@ static void gl_cg_deinit(void)
       listing_##type = strdup(list); \
 }
 
-static bool load_program(unsigned idx, const char *prog, bool path_is_file)
+static bool load_program(void *data, unsigned idx, const char *prog, bool path_is_file)
 {
    const char *argv[2 + GFX_MAX_SHADERS];
    bool ret         = true;
    char *listing_f  = NULL;
    char *listing_v  = NULL;
    unsigned i, argc = 0;
+   cg_shader_data_t *cg_data = (cg_shader_data_t*)data;
 
    argv[argc++] = "-DPARAMETER_UNIFORM";
    for (i = 0; i < GFX_MAX_SHADERS; i++)
@@ -499,24 +507,25 @@ end:
    return ret;
 }
 
-static void set_program_base_attrib(unsigned i);
+static void set_program_base_attrib(void *data, unsigned i);
 
-static bool load_stock(void)
+static bool load_stock(void *data)
 {
-   if (!load_program(0, stock_cg_program, false))
+   if (!load_program(data, 0, stock_cg_program, false))
    {
       RARCH_ERR("Failed to compile passthrough shader, is something wrong with your environment?\n");
       return false;
    }
 
-   set_program_base_attrib(0);
+   set_program_base_attrib(data, 0);
 
    return true;
 }
 
-static bool load_plain(const char *path)
+static bool load_plain(void *data, const char *path)
 {
-   if (!load_stock())
+   cg_shader_data_t *cg_data = (cg_shader_data_t*)data;
+   if (!load_stock(cg_data))
       return false;
 
    cg_data->shader = (struct video_shader*)calloc(1, sizeof(*cg_data->shader));
@@ -530,7 +539,7 @@ static bool load_plain(const char *path)
       RARCH_LOG("Loading Cg file: %s\n", path);
       strlcpy(cg_data->shader->pass[0].source.path, path,
             sizeof(cg_data->shader->pass[0].source.path));
-      if (!load_program(1, path, true))
+      if (!load_program(data, 1, path, true))
          return false;
    }
    else
@@ -543,10 +552,11 @@ static bool load_plain(const char *path)
    return true;
 }
 
-static bool gl_cg_load_imports(void)
+static bool gl_cg_load_imports(void *data)
 {
    unsigned i;
    struct state_tracker_info tracker_info = {0};
+   cg_shader_data_t *cg_data = (cg_shader_data_t*)data;
 
    if (!cg_data->shader->variables)
       return true;
@@ -595,24 +605,27 @@ static bool gl_cg_load_imports(void)
    return true;
 }
 
-static bool load_shader(unsigned i)
+static bool load_shader(void *data, unsigned i)
 {
+   cg_shader_data_t *cg_data = (cg_shader_data_t*)data;
+
    RARCH_LOG("Loading Cg shader: \"%s\".\n",
          cg_data->shader->pass[i].source.path);
 
-   if (!load_program(i + 1,
+   if (!load_program(data, i + 1,
             cg_data->shader->pass[i].source.path, true))
       return false;
 
    return true;
 }
 
-static bool load_preset(const char *path)
+static bool load_preset(void *data, const char *path)
 {
    unsigned i;
    config_file_t *conf = NULL;
+   cg_shader_data_t *cg_data = (cg_shader_data_t*)data;
 
-   if (!load_stock())
+   if (!load_stock(cg_data))
       return false;
 
    RARCH_LOG("Loading Cg meta-shader: %s\n", path);
@@ -657,7 +670,7 @@ static bool load_preset(const char *path)
 
    for (i = 0; i < cg_data->shader->passes; i++)
    {
-      if (!load_shader(i))
+      if (!load_shader(cg_data, i))
       {
          RARCH_ERR("Failed to load shaders ...\n");
          return false;
@@ -670,7 +683,7 @@ static bool load_preset(const char *path)
       return false;
    }
 
-   if (!gl_cg_load_imports())
+   if (!gl_cg_load_imports(cg_data))
    {
       RARCH_ERR("Failed to load imports ...\n");
       return false;
@@ -686,9 +699,11 @@ static bool load_preset(const char *path)
 #define SEMANTIC_COLOR0       0xa9e93e54U
 #define SEMANTIC_POSITION     0xd87309baU
 
-static void set_program_base_attrib(unsigned i)
+static void set_program_base_attrib(void *data, unsigned i)
 {
-   CGparameter param = cgGetFirstParameter(cg_data->prg[i].vprg, CG_PROGRAM);
+   cg_shader_data_t *cg_data = (cg_shader_data_t*)data;
+   CGparameter         param = cgGetFirstParameter(cg_data->prg[i].vprg, CG_PROGRAM);
+
    for (; param; param = cgGetNextParameter(param))
    {
       uint32_t semantic_hash;
@@ -760,9 +775,10 @@ static void set_pass_attrib(struct cg_program *program, struct cg_fbo_params *fb
       fbo->coord = cgGetNamedParameter(program->vprg, attr_buf);
 }
 
-static void set_program_attributes(unsigned i)
+static void set_program_attributes(void *data, unsigned i)
 {
    unsigned j;
+   cg_shader_data_t *cg_data = (cg_shader_data_t*)data;
 
    if (!cg_data)
       return;
@@ -770,7 +786,7 @@ static void set_program_attributes(unsigned i)
    cgGLBindProgram(cg_data->prg[i].fprg);
    cgGLBindProgram(cg_data->prg[i].vprg);
 
-   set_program_base_attrib(i);
+   set_program_base_attrib(cg_data, i);
 
    cg_data->prg[i].vid_size_f = cgGetNamedParameter (cg_data->prg[i].fprg, "IN.video_size");
    cg_data->prg[i].tex_size_f = cgGetNamedParameter (cg_data->prg[i].fprg, "IN.texture_size");
@@ -863,13 +879,14 @@ static void set_program_attributes(unsigned i)
    }
 }
 
-static bool gl_cg_init(void *data, const char *path)
+static void *gl_cg_init(void *data, const char *path)
 {
    unsigned i;
-   cg_data = (cg_shader_data_t*)calloc(1, sizeof(cg_shader_data_t));
+   cg_shader_data_t *cg_data = (cg_shader_data_t*)
+      calloc(1, sizeof(cg_shader_data_t));
 
    if (!cg_data)
-      return false;
+      return NULL;
 
 #ifdef HAVE_CG_RUNTIME_COMPILER
    cgRTCgcInit();
@@ -880,9 +897,7 @@ static bool gl_cg_init(void *data, const char *path)
    if (!cg_data->cgCtx)
    {
       RARCH_ERR("Failed to create Cg context\n");
-      free(cg_data);
-      cg_data = NULL;
-      return false;
+      goto error;
    }
 
 #ifdef RARCH_CG_DEBUG
@@ -914,18 +929,18 @@ static bool gl_cg_init(void *data, const char *path)
 
    if (path && !strcmp(path_get_extension(path), "cgp"))
    {
-      if (!load_preset(path))
+      if (!load_preset(cg_data, path))
          goto error;
    }
    else
    {
-      if (!load_plain(path))
+      if (!load_plain(cg_data, path))
          goto error;
    }
 
    cg_data->prg[0].mvp = cgGetNamedParameter(cg_data->prg[0].vprg, "IN.mvp_matrix");
    for (i = 1; i <= cg_data->shader->passes; i++)
-      set_program_attributes(i);
+      set_program_attributes(cg_data, i);
 
    /* If we aren't using last pass non-FBO shader, 
     * this shader will be assumed to be "fixed-function".
@@ -940,21 +955,21 @@ static bool gl_cg_init(void *data, const char *path)
    cgGLBindProgram(cg_data->prg[1].fprg);
    cgGLBindProgram(cg_data->prg[1].vprg);
 
-   return true;
+   return cg_data;
 
 error:
-   gl_cg_destroy_resources();
+   gl_cg_destroy_resources(cg_data);
    if (!cg_data)
       free(cg_data);
-   cg_data = NULL;
-   return false;
+   return NULL;
 }
 
-static void gl_cg_use(void *data, unsigned idx)
+static void gl_cg_use(void *data, void *shader_data, unsigned idx)
 {
+   cg_shader_data_t *cg_data = (cg_shader_data_t*)shader_data;
    if (cg_data && cg_data->prg[idx].vprg && cg_data->prg[idx].fprg)
    {
-      gl_cg_reset_attrib();
+      gl_cg_reset_attrib(cg_data);
 
       cg_data->active_idx = idx;
       cgGLBindProgram(cg_data->prg[idx].vprg);
@@ -962,15 +977,17 @@ static void gl_cg_use(void *data, unsigned idx)
    }
 }
 
-static unsigned gl_cg_num(void)
+static unsigned gl_cg_num(void *data)
 {
+   cg_shader_data_t *cg_data = (cg_shader_data_t*)data;
    if (!cg_data)
       return 0;
    return cg_data->shader->passes;
 }
 
-static bool gl_cg_filter_type(unsigned idx, bool *smooth)
+static bool gl_cg_filter_type(void *data, unsigned idx, bool *smooth)
 {
+   cg_shader_data_t *cg_data = (cg_shader_data_t*)data;
    if (cg_data && idx &&
          (cg_data->shader->pass[idx - 1].filter != RARCH_FILTER_UNSPEC)
       )
@@ -982,25 +999,28 @@ static bool gl_cg_filter_type(unsigned idx, bool *smooth)
    return false;
 }
 
-static enum gfx_wrap_type gl_cg_wrap_type(unsigned idx)
+static enum gfx_wrap_type gl_cg_wrap_type(void *data, unsigned idx)
 {
+   cg_shader_data_t *cg_data = (cg_shader_data_t*)data;
    if (cg_data && idx)
       return cg_data->shader->pass[idx - 1].wrap;
    return RARCH_WRAP_BORDER;
 }
 
-static void gl_cg_shader_scale(unsigned idx, struct gfx_fbo_scale *scale)
+static void gl_cg_shader_scale(void *data, unsigned idx, struct gfx_fbo_scale *scale)
 {
+   cg_shader_data_t *cg_data = (cg_shader_data_t*)data;
    if (cg_data && idx)
       *scale = cg_data->shader->pass[idx - 1].fbo;
    else
       scale->valid = false;
 }
 
-static unsigned gl_cg_get_prev_textures(void)
+static unsigned gl_cg_get_prev_textures(void *data)
 {
    unsigned i, j;
    unsigned max_prev = 0;
+   cg_shader_data_t *cg_data = (cg_shader_data_t*)data;
 
    if (!cg_data)
       return 0;
@@ -1013,8 +1033,9 @@ static unsigned gl_cg_get_prev_textures(void)
    return max_prev;
 }
 
-static bool gl_cg_get_feedback_pass(unsigned *pass)
+static bool gl_cg_get_feedback_pass(void *data, unsigned *pass)
 {
+   cg_shader_data_t *cg_data = (cg_shader_data_t*)data;
    if (!cg_data || cg_data->shader->feedback_pass < 0)
       return false;
 
@@ -1022,15 +1043,17 @@ static bool gl_cg_get_feedback_pass(unsigned *pass)
    return true;
 }
 
-static bool gl_cg_mipmap_input(unsigned idx)
+static bool gl_cg_mipmap_input(void *data, unsigned idx)
 {
+   cg_shader_data_t *cg_data = (cg_shader_data_t*)data;
    if (cg_data && idx)
       return cg_data->shader->pass[idx - 1].mipmap;
    return false;
 }
 
-static struct video_shader *gl_cg_get_current_shader(void)
+static struct video_shader *gl_cg_get_current_shader(void *data)
 {
+   cg_shader_data_t *cg_data = (cg_shader_data_t*)data;
    if (!cg_data)
       return NULL;
    return cg_data->shader;
diff --git a/gfx/drivers_shader/shader_glsl.c b/gfx/drivers_shader/shader_glsl.c
index c9750181d3..be7fbf77e3 100644
--- a/gfx/drivers_shader/shader_glsl.c
+++ b/gfx/drivers_shader/shader_glsl.c
@@ -707,36 +707,27 @@ static void gl_glsl_destroy_resources(glsl_shader_data_t *glsl)
    memset(&glsl->glsl_vbo, 0, sizeof(glsl->glsl_vbo));
 }
 
-static void gl_glsl_deinit(void)
+static void gl_glsl_deinit(void *data)
 {
-   driver_t *driver = driver_get_ptr();
-   glsl_shader_data_t *glsl = (glsl_shader_data_t*)driver->video_shader_data;
+   glsl_shader_data_t *glsl = (glsl_shader_data_t*)data;
 
    if (!glsl)
       return;
 
    gl_glsl_destroy_resources(glsl);
-
-   if (driver->video_shader_data)
-      free(driver->video_shader_data);
-   driver->video_shader_data = NULL;
 }
 
-static bool gl_glsl_init(void *data, const char *path)
+static void *gl_glsl_init(void *data, const char *path)
 {
    unsigned i;
    config_file_t *conf        = NULL;
-   glsl_shader_data_t *glsl   = NULL;
    const char *stock_vertex   = NULL;
    const char *stock_fragment = NULL;
-   driver_t *driver           = driver_get_ptr();
-
-   (void)data;
-
-   glsl = (glsl_shader_data_t*)calloc(1, sizeof(glsl_shader_data_t));
+   glsl_shader_data_t *glsl = (glsl_shader_data_t*)
+      calloc(1, sizeof(glsl_shader_data_t));
 
    if (!glsl)
-      return false;
+      return NULL;
 
 #ifndef HAVE_OPENGLES2
    RARCH_LOG("Checking GLSL shader support ...\n");
@@ -756,17 +747,13 @@ static bool gl_glsl_init(void *data, const char *path)
    if (!shader_support)
    {
       RARCH_ERR("GLSL shaders aren't supported by your OpenGL driver.\n");
-      free(glsl);
-      return false;
+      goto error;
    }
 #endif
 
    glsl->shader = (struct video_shader*)calloc(1, sizeof(*glsl->shader));
    if (!glsl->shader)
-   {
-      free(glsl);
-      return false;
-   }
+      goto error;
 
    if (path)
    {
@@ -798,9 +785,7 @@ static bool gl_glsl_init(void *data, const char *path)
       if (!ret)
       {
          RARCH_ERR("[GL]: Failed to parse GLSL shader.\n");
-         free(glsl->shader);
-         free(glsl);
-         return false;
+         goto error;
       }
    }
    else
@@ -934,9 +919,7 @@ static bool gl_glsl_init(void *data, const char *path)
       glGenBuffers(1, &glsl->glsl_vbo[i].vbo_secondary);
    }
 
-   driver->video_shader_data = glsl;
-
-   return true;
+   return glsl;
 
 error:
    gl_glsl_destroy_resources(glsl);
@@ -944,10 +927,11 @@ error:
    if (glsl)
       free(glsl);
 
-   return false;
+   return NULL;
 }
 
-static void gl_glsl_set_params(void *data, unsigned width, unsigned height, 
+static void gl_glsl_set_params(void *data, void *shader_data,
+      unsigned width, unsigned height, 
       unsigned tex_width, unsigned tex_height, 
       unsigned out_width, unsigned out_height,
       unsigned frame_count,
@@ -967,8 +951,7 @@ static void gl_glsl_set_params(void *data, unsigned width, unsigned height,
    const struct gfx_tex_info *feedback_info = (const struct gfx_tex_info*)_feedback_info;
    const struct gfx_tex_info *fbo_info = (const struct gfx_tex_info*)_fbo_info;
    struct glsl_attrib *attr = (struct glsl_attrib*)attribs;
-   driver_t *driver = driver_get_ptr();
-   glsl_shader_data_t *glsl = (glsl_shader_data_t*)driver->video_shader_data;
+   glsl_shader_data_t *glsl = (glsl_shader_data_t*)shader_data;
 
    if (!glsl)
       return;
@@ -1182,11 +1165,10 @@ static void gl_glsl_set_params(void *data, unsigned width, unsigned height,
    }
 }
 
-static bool gl_glsl_set_mvp(void *data, const math_matrix_4x4 *mat)
+static bool gl_glsl_set_mvp(void *data, void *shader_data, const math_matrix_4x4 *mat)
 {
    int loc;
-   driver_t *driver = driver_get_ptr();
-   glsl_shader_data_t *glsl = (glsl_shader_data_t*)driver->video_shader_data;
+   glsl_shader_data_t *glsl = (glsl_shader_data_t*)shader_data;
 
    (void)data;
 
@@ -1203,7 +1185,7 @@ static bool gl_glsl_set_mvp(void *data, const math_matrix_4x4 *mat)
    return true;
 }
 
-static bool gl_glsl_set_coords(const void *data)
+static bool gl_glsl_set_coords(void *handle_data, void *shader_data, const void *data)
 {
    /* Avoid hitting malloc on every single regular quad draw. */
    GLfloat short_buffer[4 * (2 + 2 + 4 + 2)];
@@ -1213,8 +1195,7 @@ static bool gl_glsl_set_coords(const void *data)
    struct glsl_attrib *attr = NULL;
    const struct shader_uniforms *uni = NULL;
    const struct gfx_coords *coords = (const struct gfx_coords*)data;
-   driver_t *driver = driver_get_ptr();
-   glsl_shader_data_t *glsl = (glsl_shader_data_t*)driver->video_shader_data;
+   glsl_shader_data_t *glsl = (glsl_shader_data_t*)shader_data;
 
    if (!glsl || !glsl->shader->modern || !coords)
    {
@@ -1304,10 +1285,9 @@ static bool gl_glsl_set_coords(const void *data)
    return true;
 }
 
-static void gl_glsl_use(void *data, unsigned idx)
+static void gl_glsl_use(void *data, void *shader_data, unsigned idx)
 {
-   driver_t *driver = driver_get_ptr();
-   glsl_shader_data_t *glsl = (glsl_shader_data_t*)driver->video_shader_data;
+   glsl_shader_data_t *glsl = (glsl_shader_data_t*)shader_data;
 
    (void)data;
 
@@ -1320,19 +1300,17 @@ static void gl_glsl_use(void *data, unsigned idx)
    glUseProgram(glsl->gl_program[idx]);
 }
 
-static unsigned gl_glsl_num(void)
+static unsigned gl_glsl_num(void *data)
 {
-   driver_t *driver = driver_get_ptr();
-   glsl_shader_data_t *glsl = (glsl_shader_data_t*)driver->video_shader_data;
+   glsl_shader_data_t *glsl = (glsl_shader_data_t*)data;
    if (glsl && glsl->shader)
       return glsl->shader->passes;
    return 0;
 }
 
-static bool gl_glsl_filter_type(unsigned idx, bool *smooth)
+static bool gl_glsl_filter_type(void *data, unsigned idx, bool *smooth)
 {
-   driver_t *driver = driver_get_ptr();
-   glsl_shader_data_t *glsl = (glsl_shader_data_t*)driver->video_shader_data;
+   glsl_shader_data_t *glsl = (glsl_shader_data_t*)data;
    if (glsl && idx 
          && (glsl->shader->pass[idx - 1].filter != RARCH_FILTER_UNSPEC)
       )
@@ -1343,31 +1321,28 @@ static bool gl_glsl_filter_type(unsigned idx, bool *smooth)
    return false;
 }
 
-static enum gfx_wrap_type gl_glsl_wrap_type(unsigned idx)
+static enum gfx_wrap_type gl_glsl_wrap_type(void *data, unsigned idx)
 {
-   driver_t *driver = driver_get_ptr();
-   glsl_shader_data_t *glsl = (glsl_shader_data_t*)driver->video_shader_data;
+   glsl_shader_data_t *glsl = (glsl_shader_data_t*)data;
    if (glsl && idx)
       return glsl->shader->pass[idx - 1].wrap;
    return RARCH_WRAP_BORDER;
 }
 
-static void gl_glsl_shader_scale(unsigned idx, struct gfx_fbo_scale *scale)
+static void gl_glsl_shader_scale(void *data, unsigned idx, struct gfx_fbo_scale *scale)
 {
-   driver_t *driver = driver_get_ptr();
-   glsl_shader_data_t *glsl = (glsl_shader_data_t*)driver->video_shader_data;
+   glsl_shader_data_t *glsl = (glsl_shader_data_t*)data;
    if (glsl && idx)
       *scale = glsl->shader->pass[idx - 1].fbo;
    else
       scale->valid = false;
 }
 
-static unsigned gl_glsl_get_prev_textures(void)
+static unsigned gl_glsl_get_prev_textures(void *data)
 {
    unsigned i, j;
    unsigned max_prev = 0;
-   driver_t *driver = driver_get_ptr();
-   glsl_shader_data_t *glsl = (glsl_shader_data_t*)driver->video_shader_data;
+   glsl_shader_data_t *glsl = (glsl_shader_data_t*)data;
 
    if (!glsl)
       return 0;
@@ -1380,19 +1355,17 @@ static unsigned gl_glsl_get_prev_textures(void)
    return max_prev;
 }
 
-static bool gl_glsl_mipmap_input(unsigned idx)
+static bool gl_glsl_mipmap_input(void *data, unsigned idx)
 {
-   driver_t *driver = driver_get_ptr();
-   glsl_shader_data_t *glsl = (glsl_shader_data_t*)driver->video_shader_data;
+   glsl_shader_data_t *glsl = (glsl_shader_data_t*)data;
    if (glsl && idx)
       return glsl->shader->pass[idx - 1].mipmap;
    return false;
 }
 
-static bool gl_glsl_get_feedback_pass(unsigned *index)
+static bool gl_glsl_get_feedback_pass(void *data, unsigned *index)
 {
-   driver_t *driver = driver_get_ptr();
-   glsl_shader_data_t *glsl = (glsl_shader_data_t*)driver->video_shader_data;
+   glsl_shader_data_t *glsl = (glsl_shader_data_t*)data;
    if (!glsl || glsl->shader->feedback_pass < 0)
       return false;
 
@@ -1400,10 +1373,9 @@ static bool gl_glsl_get_feedback_pass(unsigned *index)
    return true;
 }
 
-static struct video_shader *gl_glsl_get_current_shader(void)
+static struct video_shader *gl_glsl_get_current_shader(void *data)
 {
-   driver_t *driver = driver_get_ptr();
-   glsl_shader_data_t *glsl = (glsl_shader_data_t*)driver->video_shader_data;
+   glsl_shader_data_t *glsl = (glsl_shader_data_t*)data;
    if (!glsl)
       return NULL;
    return glsl->shader;
diff --git a/gfx/drivers_shader/shader_hlsl.c b/gfx/drivers_shader/shader_hlsl.c
index 589a98aa88..0a09a19c1d 100644
--- a/gfx/drivers_shader/shader_hlsl.c
+++ b/gfx/drivers_shader/shader_hlsl.c
@@ -82,17 +82,18 @@ struct hlsl_program
    XMMATRIX mvp_val;   /* TODO: Move to D3DXMATRIX here */
 };
 
-typedef struct hlsl_shader_data
+typedef struct hlsl_shader_data hlsl_shader_data_t;
+
+struct hlsl_shader_data
 {
    struct hlsl_program prg[RARCH_HLSL_MAX_SHADERS];
    unsigned active_idx;
    struct video_shader *cg_shader;
-} hlsl_shader_data_t;
+};
 
-static hlsl_shader_data_t *hlsl_data;
-
-void hlsl_set_proj_matrix(XMMATRIX rotation_value)
+void hlsl_set_proj_matrix(void *data, XMMATRIX rotation_value)
 {
+   hlsl_shader_data_t *hlsl = (hlsl_shader_data_t*)data;
    if (hlsl_data)
       hlsl_data->prg[hlsl_data->active_idx].mvp_val = rotation_value;
 }
@@ -102,7 +103,8 @@ void hlsl_set_proj_matrix(XMMATRIX rotation_value)
 #define set_param_1f(param, x, constanttable) \
    if (param) constanttable->SetFloat(d3d_device_ptr, param, x)
 
-static void hlsl_set_params(void *data, unsigned width, unsigned height,
+static void hlsl_set_params(void *data, void *shader_data,
+      unsigned width, unsigned height,
       unsigned tex_width, unsigned tex_height,
       unsigned out_width, unsigned out_height,
       unsigned frame_counter,
@@ -117,7 +119,7 @@ static void hlsl_set_params(void *data, unsigned width, unsigned height,
    const struct gfx_tex_info *prev_info = (const struct gfx_tex_info*)_prev_info;
    (void)_feedback_info;
    const struct gfx_tex_info *fbo_info = (const struct gfx_tex_info*)_fbo_info;
-   hlsl_shader_data_t *hlsl = hlsl_data;
+   hlsl_shader_data_t *hlsl = (hlsl_shader_data_t*)shader_data;
 
    if (!hlsl)
       return;
@@ -352,14 +354,15 @@ static bool hlsl_load_preset(hlsl_shader_data_t *hlsl, void *data, const char *p
    return true;
 }
 
-static bool hlsl_init(void *data, const char *path)
+static void *hlsl_init(void *data, const char *path)
 {
    unsigned i;
    d3d_video_t *d3d = (d3d_video_t*)data;
-   hlsl_data = (hlsl_shader_data_t*)calloc(1, sizeof(hlsl_shader_data_t));
+   hlsl_shader_data_t *hlsl_data = (hlsl_shader_data_t*)
+      calloc(1, sizeof(hlsl_shader_data_t));
 
    if (!hlsl_data)
-	   return false;
+	   return NULL;
 
    if (path && !strcmp(path_get_extension(path), ".cgp"))
    {
@@ -378,27 +381,28 @@ static bool hlsl_init(void *data, const char *path)
    d3d_set_vertex_shader(d3d->dev, 1, hlsl_data->prg[1].vprg);
    d3d->dev->SetPixelShader(hlsl_data->prg[1].fprg);
 
-   return true;
+   return hlsl_data;
 
 error:
    if (hlsl_data)
 	   free(hlsl_data);
-   hlsl_data = NULL;
-   return false;
+   return NULL;
 }
 
-static void hlsl_deinit(void)
+static void hlsl_deinit(void *data)
 {
+   hlsl_shader_data_t *hlsl_data = (hlsl_shader_data_t*)data;
+
    hlsl_deinit_state(hlsl_data);
 
    if (hlsl_data)
       free(hlsl_data);
-   hlsl_data = NULL;
 }
 
-static void hlsl_use(void *data, unsigned idx)
+static void hlsl_use(void *data, void *shader_data, unsigned idx)
 {
    d3d_video_t *d3d = (d3d_video_t*)data;
+   hlsl_shader_data_t *hlsl_data = (hlsl_shader_data_t*)shader_data;
    LPDIRECT3DDEVICE d3dr = (LPDIRECT3DDEVICE)d3d->dev;
 
    if (hlsl_data && hlsl_data->prg[idx].vprg && hlsl_data->prg[idx].fprg)
@@ -413,15 +417,17 @@ static void hlsl_use(void *data, unsigned idx)
    }
 }
 
-static unsigned hlsl_num(void)
+static unsigned hlsl_num(void *data)
 {
+   hlsl_shader_data_t *hlsl_data = (hlsl_shader_data_t*)data;
    if (hlsl_data)
       return hlsl_data->cg_shader->passes;
    return 0;
 }
 
-static bool hlsl_filter_type(unsigned idx, bool *smooth)
+static bool hlsl_filter_type(void *data, unsigned idx, bool *smooth)
 {
+   hlsl_shader_data_t *hlsl_data = (hlsl_shader_data_t*)data;
    if (hlsl_data && idx
          && (hlsl_data->cg_shader->pass[idx - 1].filter != RARCH_FILTER_UNSPEC))
    {
@@ -431,18 +437,20 @@ static bool hlsl_filter_type(unsigned idx, bool *smooth)
    return false;
 }
 
-static void hlsl_shader_scale(unsigned idx, struct gfx_fbo_scale *scale)
+static void hlsl_shader_scale(void *data, unsigned idx, struct gfx_fbo_scale *scale)
 {
+   hlsl_shader_data_t *hlsl_data = (hlsl_shader_data_t*)data;
    if (hlsl_data && idx)
       *scale = hlsl_data->cg_shader->pass[idx - 1].fbo;
    else
       scale->valid = false;
 }
 
-static bool hlsl_set_mvp(void *data, const math_matrix_4x4 *mat)
+static bool hlsl_set_mvp(void *data, void *shader_data, const math_matrix_4x4 *mat)
 {
    d3d_video_t *d3d = (d3d_video_t*)data;
    LPDIRECT3DDEVICE d3d_device_ptr = (LPDIRECT3DDEVICE)d3d->dev;
+   hlsl_shader_data_t *hlsl_data = (hlsl_shader_data_t*)shader_data;
 
    if(hlsl_data && hlsl_data->prg[hlsl_data->active_idx].mvp)
    {
@@ -454,19 +462,19 @@ static bool hlsl_set_mvp(void *data, const math_matrix_4x4 *mat)
    return false;
 }
 
-static bool hlsl_mipmap_input(unsigned idx)
+static bool hlsl_mipmap_input(void *data, unsigned idx)
 {
    (void)idx;
    return false;
 }
 
-static bool hlsl_get_feedback_pass(unsigned *idx)
+static bool hlsl_get_feedback_pass(void *data, unsigned *idx)
 {
    (void)idx;
    return false;
 }
 
-static struct video_shader *hlsl_get_current_shader(void)
+static struct video_shader *hlsl_get_current_shader(void *data)
 {
    return NULL;
 }
diff --git a/gfx/drivers_shader/shader_hlsl.h b/gfx/drivers_shader/shader_hlsl.h
index ec8ffb578d..821b35da23 100644
--- a/gfx/drivers_shader/shader_hlsl.h
+++ b/gfx/drivers_shader/shader_hlsl.h
@@ -21,7 +21,7 @@
 #include "../video_shader_driver.h"
 #include <stdint.h>
 
-void hlsl_set_proj_matrix(XMMATRIX rotation_value);
+void hlsl_set_proj_matrix(void *data, XMMATRIX rotation_value);
 
 #define RARCH_HLSL_MAX_SHADERS 16
 
diff --git a/gfx/drivers_shader/shader_null.c b/gfx/drivers_shader/shader_null.c
index 8e66a74f0d..f97b8c51b2 100644
--- a/gfx/drivers_shader/shader_null.c
+++ b/gfx/drivers_shader/shader_null.c
@@ -36,10 +36,33 @@
 
 #include "../video_shader_driver.h"
 
-static void shader_null_deinit(void) { }
-static bool shader_null_init(void *data, const char *path) { return true; }
+typedef struct null_shader_data
+{
+   void *empty;
+} null_shader_data_t;
 
-static void shader_null_set_params(void *data, unsigned width, unsigned height, 
+static void shader_null_deinit(void *data)
+{
+   null_shader_data_t *null_shader = (null_shader_data_t*)data;
+   if (!null_shader)
+      return;
+
+   free(null_shader);
+}
+
+static void *shader_null_init(void *data, const char *path)
+{
+   null_shader_data_t *null_shader = (null_shader_data_t*)
+      calloc(1, sizeof(*null_shader));
+
+   if (!null_shader)
+      return NULL;
+
+   return null_shader;
+}
+
+static void shader_null_set_params(void *data, void *shader_data,
+      unsigned width, unsigned height, 
       unsigned tex_width, unsigned tex_height, 
       unsigned out_width, unsigned out_height,
       unsigned frame_count,
@@ -50,7 +73,7 @@ static void shader_null_set_params(void *data, unsigned width, unsigned height,
 {
 }
 
-static bool shader_null_set_mvp(void *data, const math_matrix_4x4 *mat)
+static bool shader_null_set_mvp(void *data, void *shader_data, const math_matrix_4x4 *mat)
 {
 #ifdef HAVE_OPENGL
 #ifndef NO_GL_FF_MATRIX
@@ -61,7 +84,7 @@ static bool shader_null_set_mvp(void *data, const math_matrix_4x4 *mat)
    return false;
 }
 
-static bool shader_null_set_coords(const void *data)
+static bool shader_null_set_coords(void *handle_data, void *shader_data, const void *data)
 {
 #ifdef HAVE_OPENGL
 #ifndef NO_GL_FF_VERTEX
@@ -75,55 +98,55 @@ static bool shader_null_set_coords(const void *data)
    return false;
 }
 
-static void shader_null_use(void *data, unsigned idx)
+static void shader_null_use(void *data, void *shader_data, unsigned idx)
 {
    (void)data;
    (void)idx;
 }
 
-static unsigned shader_null_num(void)
+static unsigned shader_null_num(void *data)
 {
    return 0;
 }
 
-static bool shader_null_filter_type(unsigned idx, bool *smooth)
+static bool shader_null_filter_type(void *data, unsigned idx, bool *smooth)
 {
    (void)idx;
    (void)smooth;
    return false;
 }
 
-static enum gfx_wrap_type shader_null_wrap_type(unsigned idx)
+static enum gfx_wrap_type shader_null_wrap_type(void *data, unsigned idx)
 {
    (void)idx;
    return RARCH_WRAP_BORDER;
 }
 
-static void shader_null_shader_scale(unsigned idx,
-      struct gfx_fbo_scale *scale)
+static void shader_null_shader_scale(void *data,
+      unsigned idx, struct gfx_fbo_scale *scale)
 {
    (void)idx;
    (void)scale;
 }
 
-static unsigned shader_null_get_prev_textures(void)
+static unsigned shader_null_get_prev_textures(void *data)
 {
    return 0;
 }
 
-static bool shader_null_mipmap_input(unsigned idx)
+static bool shader_null_mipmap_input(void *data, unsigned idx)
 {
    (void)idx;
    return false;
 }
 
-static bool shader_null_get_feedback_pass(unsigned *idx)
+static bool shader_null_get_feedback_pass(void *data, unsigned *idx)
 {
    (void)idx;
    return false;
 }
 
-static struct video_shader *shader_null_get_current_shader(void)
+static struct video_shader *shader_null_get_current_shader(void *data)
 {
    return NULL;
 }
diff --git a/gfx/video_shader_driver.c b/gfx/video_shader_driver.c
index 725fc0585a..bffd839329 100644
--- a/gfx/video_shader_driver.c
+++ b/gfx/video_shader_driver.c
@@ -32,6 +32,8 @@ static const shader_backend_t *shader_ctx_drivers[] = {
    NULL
 };
 
+static void *shader_data;
+
 /**
  * shader_ctx_find_driver:
  * @ident                   : Identifier of shader context driver to find.
@@ -72,13 +74,12 @@ const shader_backend_t *shader_ctx_init_first(void)
 
 struct video_shader *video_shader_driver_get_current_shader(void)
 {
-   void                       *video_driver = video_driver_get_ptr(true);
    const video_poke_interface_t *video_poke = video_driver_get_poke();
-   if (!video_poke || !video_driver)
+   if (!video_poke)
       return NULL;
    if (!video_poke->get_current_shader)
       return NULL;
-   return video_poke->get_current_shader(video_driver);
+   return video_poke->get_current_shader(shader_data);
 }
 
 void video_shader_scale(unsigned idx,
@@ -90,28 +91,41 @@ void video_shader_scale(unsigned idx,
    scale->valid = false;
 
    if (shader->shader_scale)
-      shader->shader_scale(idx, scale);
+      shader->shader_scale(shader_data, idx, scale);
 }
 
 bool video_shader_driver_init(const shader_backend_t *shader, void *data, const char *path)
 {
+   void *tmp = NULL;
+
    if (!shader || !shader->init)
       return false;
-   return shader->init(data, path);
+
+   tmp = shader->init(data, path);
+
+   if (!tmp)
+      return false;
+
+   shader_data = tmp;
+
+   return true;
 }
 
 void video_shader_driver_deinit(const shader_backend_t *shader)
 {
    if (!shader)
       return;
-   shader->deinit();
+
+   shader->deinit(shader_data);
+
+   shader_data = NULL;
 }
 
 void video_shader_driver_use(const shader_backend_t *shader, void *data, unsigned index)
 {
    if (!shader)
       return;
-   shader->use(data, index);
+   shader->use(data, shader_data, index);
 }
 
 const char *video_shader_driver_get_ident(const shader_backend_t *shader)
@@ -125,61 +139,61 @@ bool video_shader_driver_mipmap_input(const shader_backend_t *shader, unsigned i
 {
    if (!shader)
       return false;
-   return shader->mipmap_input(index);
+   return shader->mipmap_input(shader_data, index);
 }
 
 unsigned video_shader_driver_num_shaders(const shader_backend_t *shader)
 {
    if (!shader)
       return 0;
-   return shader->num_shaders();
+   return shader->num_shaders(shader_data);
 }
 
 unsigned video_shader_driver_get_prev_textures(const shader_backend_t *shader)
 {
    if (!shader)
       return 0;
-   return shader->get_prev_textures();
+   return shader->get_prev_textures(shader_data);
 }
 
-bool video_shader_driver_set_coords(const shader_backend_t *shader, const void *data)
+bool video_shader_driver_set_coords(const shader_backend_t *shader, void *handle_data, const void *data)
 {
    if (!shader || !shader->set_coords)
       return false;
-   return shader->set_coords(data);
+   return 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)
 {
    if (!shader || !shader->set_mvp)
       return false;
-   return shader->set_mvp(data, mat);
+   return shader->set_mvp(data, shader_data, mat);
 }
 
 bool video_shader_driver_filter_type(const shader_backend_t *shader, unsigned index, bool *smooth)
 {
    if (!shader || !shader->filter_type)
       return false;
-   return shader->filter_type(index, smooth);
+   return shader->filter_type(shader_data, index, smooth);
 }
 
 enum gfx_wrap_type video_shader_driver_wrap_type(const shader_backend_t *shader, unsigned index)
 {
-   return shader->wrap_type(index);
+   return shader->wrap_type(shader_data, index);
 }
 
 bool video_shader_driver_get_feedback_pass(const shader_backend_t *shader, unsigned *pass)
 {
    if (!shader || !shader->get_feedback_pass)
       return false;
-   return shader->get_feedback_pass(pass);
+   return shader->get_feedback_pass(shader_data, pass);
 }
 
 struct video_shader *video_shader_driver_direct_get_current_shader(const shader_backend_t *shader)
 {
    if (!shader || !shader->get_current_shader)
       return NULL;
-   return shader->get_current_shader();
+   return shader->get_current_shader(shader_data);
 }
 
 void video_shader_driver_set_params(const shader_backend_t *shader, 
@@ -193,8 +207,9 @@ void video_shader_driver_set_params(const shader_backend_t *shader,
       const void *fbo_info, unsigned fbo_info_cnt)
 {
    if (!shader || !shader->set_params)
-      return NULL;
-   return shader->set_params(data, width, height, tex_width, tex_height,
+      return;
+   return 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 ed6cee7cc2..0a16dcbedf 100644
--- a/gfx/video_shader_driver.h
+++ b/gfx/video_shader_driver.h
@@ -32,9 +32,10 @@ extern "C" {
 
 typedef struct shader_backend
 {
-   bool (*init)(void *data, const char *path);
-   void (*deinit)(void);
-   void (*set_params)(void *data, unsigned width, unsigned height, 
+   void *(*init)(void *data, const char *path);
+   void (*deinit)(void *data);
+   void (*set_params)(void *data, void *shader_data,
+         unsigned width, unsigned height, 
          unsigned tex_width, unsigned tex_height, 
          unsigned out_width, unsigned out_height,
          unsigned frame_counter,
@@ -43,18 +44,18 @@ typedef struct shader_backend
          const void *feedback_info,
          const void *fbo_info, unsigned fbo_info_cnt);
 
-   void (*use)(void *data, unsigned index);
-   unsigned (*num_shaders)(void);
-   bool (*filter_type)(unsigned index, bool *smooth);
-   enum gfx_wrap_type (*wrap_type)(unsigned index);
-   void (*shader_scale)(unsigned index, struct gfx_fbo_scale *scale);
-   bool (*set_coords)(const void *data);
-   bool (*set_mvp)(void *data, const math_matrix_4x4 *mat);
-   unsigned (*get_prev_textures)(void);
-   bool (*get_feedback_pass)(unsigned *pass);
-   bool (*mipmap_input)(unsigned index);
+   void (*use)(void *data, void *shader_data, unsigned index);
+   unsigned (*num_shaders)(void *data);
+   bool (*filter_type)(void *data, unsigned index, bool *smooth);
+   enum gfx_wrap_type (*wrap_type)(void *data, unsigned index);
+   void (*shader_scale)(void *data, unsigned index, struct gfx_fbo_scale *scale);
+   bool (*set_coords)(void *handle_data, void *shader_data, const void *data);
+   bool (*set_mvp)(void *data, void *shader_data, const math_matrix_4x4 *mat);
+   unsigned (*get_prev_textures)(void *data);
+   bool (*get_feedback_pass)(void *data, unsigned *pass);
+   bool (*mipmap_input)(void *data, unsigned index);
 
-   struct video_shader *(*get_current_shader)(void);
+   struct video_shader *(*get_current_shader)(void *data);
 
    enum rarch_shader_type type;
 
@@ -127,7 +128,7 @@ bool video_shader_driver_mipmap_input(const shader_backend_t *shader, unsigned i
 
 unsigned video_shader_driver_num_shaders(const shader_backend_t *shader);
 
-bool video_shader_driver_set_coords(const shader_backend_t *shader, const void *data);
+bool video_shader_driver_set_coords(const shader_backend_t *shader, void *handle_data, const void *data);
 
 bool video_shader_driver_set_mvp(const shader_backend_t *shader, void *data, const math_matrix_4x4 *mat);
 
diff --git a/menu/drivers_display/menu_display_gl.c b/menu/drivers_display/menu_display_gl.c
index 27ad9eb4de..9db1ed9365 100644
--- a/menu/drivers_display/menu_display_gl.c
+++ b/menu/drivers_display/menu_display_gl.c
@@ -82,8 +82,7 @@ static void menu_display_gl_blend_begin(void)
    glEnable(GL_BLEND);
    glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
 
-   if (gl->shader && gl->shader->use)
-      gl->shader->use(gl, GL_SHADER_STOCK_BLEND);
+   video_shader_driver_use(gl->shader, NULL, GL_SHADER_STOCK_BLEND);
 }
 
 static void menu_display_gl_blend_end(void)
@@ -122,8 +121,8 @@ static void menu_display_gl_draw(
    glViewport(x, y, width, height);
    glBindTexture(GL_TEXTURE_2D, (GLuint)texture);
 
-   gl->shader->set_coords(coords);
-   gl->shader->set_mvp(video_driver_get_ptr(false), mat);
+   video_shader_driver_set_coords(gl->shader, gl, coords);
+   video_shader_driver_set_mvp(gl->shader, video_driver_get_ptr(false), mat);
 
    glDrawArrays(menu_display_prim_to_gl_enum(prim_type), 0, coords->vertices);