diff --git a/command.c b/command.c
index d12d085336..10568c26f5 100755
--- a/command.c
+++ b/command.c
@@ -1302,9 +1302,8 @@ static bool command_event_init_core(enum rarch_core_type *data)
          rarch_ctl(RARCH_CTL_UNSET_OVERRIDES_ACTIVE, NULL);
    }
 
-   /* Auto-shaders: apply shader preset files */
-   if(settings->bools.auto_shaders_enable)
-      config_load_shader_preset();
+   /* Load auto-shaders on the next occasion */
+   retroarch_shader_presets_set_need_reload();
 
    /* reset video format to libretro's default */
    video_driver_set_pixel_format(RETRO_PIXEL_FORMAT_0RGB1555);
diff --git a/configuration.c b/configuration.c
index 7b77816231..fb4b73931d 100644
--- a/configuration.c
+++ b/configuration.c
@@ -3520,119 +3520,6 @@ success:
    return true;
 }
 
-static bool config_load_shader_preset_internal(
-      const char *shader_directory,
-      const char *core_name,
-      const char *special_name)
-{
-   unsigned idx;
-   size_t path_size        = PATH_MAX_LENGTH * sizeof(char);
-   char *shader_path       = (char*)malloc(path_size);
-   
-   shader_path[0]          = '\0';
-
-   for (idx = FILE_PATH_CGP_EXTENSION; idx <= FILE_PATH_SLANGP_EXTENSION; idx++)
-   {
-      /* Concatenate strings into full paths */
-      fill_pathname_join_special_ext(shader_path,
-            shader_directory, core_name,
-            special_name,
-            file_path_str((enum file_path_enum)(idx)),
-            path_size);
-
-      if (!config_file_exists(shader_path))
-         continue;
-
-      /* Shader preset exists, load it. */
-      RARCH_LOG("[Shaders]: Specific shader preset found at %s.\n",
-            shader_path);
-      retroarch_set_shader_preset(shader_path);
-      free(shader_path);
-      return true;
-   }
-
-   free(shader_path);
-
-   return false;
-}
-
-/**
- * config_load_shader_preset:
- *
- * Tries to append game-specific and core-specific shader presets.
- *
- * This function only has an effect if a game-specific or core-specific
- * configuration file exists at respective locations.
- *
- * core-specific: $SHADER_DIR/presets/$CORE_NAME/$CORE_NAME.cfg
- * game-specific: $SHADER_DIR/presets/$CORE_NAME/$GAME_NAME.cfg
- *
- * Returns: false if there was an error or no action was performed.
- */
-bool config_load_shader_preset(void)
-{
-   size_t path_size                       = PATH_MAX_LENGTH * sizeof(char);
-   settings_t *settings                   = config_get_ptr();
-   rarch_system_info_t *system            = runloop_get_system_info();
-   const char *core_name                  = system
-      ? system->info.library_name : NULL;
-   const char *rarch_path_basename        = path_get(RARCH_PATH_BASENAME);
-   const char *game_name                  = path_basename(rarch_path_basename);
-   const char *video_shader_directory     = settings->paths.directory_video_shader;
-   char *shader_directory                 = NULL;
-
-   if (     string_is_empty(core_name) 
-         || string_is_empty(game_name)
-         || string_is_empty(video_shader_directory)
-         )
-      return false;
-
-   shader_directory                       = (char*)
-      malloc(PATH_MAX_LENGTH * sizeof(char));
-   shader_directory[0]                    =   '\0';
-
-   fill_pathname_join (shader_directory,
-         video_shader_directory,
-         "presets", path_size);
-
-   RARCH_LOG("[Shaders]: preset directory: %s\n", shader_directory);
-
-   if (config_load_shader_preset_internal(shader_directory, core_name,
-            game_name))
-   {
-      RARCH_LOG("[Shaders]: game-specific shader preset found.\n");
-      goto success;
-   }
-
-   {
-      char content_dir_name[PATH_MAX_LENGTH];
-      if (!string_is_empty(rarch_path_basename))
-         fill_pathname_parent_dir_name(content_dir_name,
-               rarch_path_basename, sizeof(content_dir_name));
-
-      if (config_load_shader_preset_internal(shader_directory, core_name,
-               content_dir_name))
-      {
-         RARCH_LOG("[Shaders]: content dir-specific shader preset found.\n");
-         goto success;
-      }
-   }
-
-   if (config_load_shader_preset_internal(shader_directory, core_name,
-            core_name))
-   {
-      RARCH_LOG("[Shaders]: core-specific shader preset found.\n");
-      goto success;
-   }
-
-   free(shader_directory);
-   return false;
-
-success:
-   free(shader_directory);
-   return true;
-}
-
 static void parse_config_file(void)
 {
    const char *config_path = path_get(RARCH_PATH_CONFIG);
@@ -4056,12 +3943,12 @@ bool config_save_overrides(int override_type)
    if (string_is_empty(core_name) || string_is_empty(game_name))
       return false;
 
-   settings                                    = (settings_t*)calloc(1, sizeof(settings_t));
-   config_directory                            = (char*)malloc(PATH_MAX_LENGTH * sizeof(char));
-   override_directory                          = (char*)malloc(PATH_MAX_LENGTH * sizeof(char));
-   core_path                                   = (char*)malloc(PATH_MAX_LENGTH * sizeof(char));
-   game_path                                   = (char*)malloc(PATH_MAX_LENGTH * sizeof(char));
-   content_path                                = (char*)malloc(PATH_MAX_LENGTH * sizeof(char));
+   settings           = (settings_t*)calloc(1, sizeof(settings_t));
+   config_directory   = (char*)malloc(PATH_MAX_LENGTH);
+   override_directory = (char*)malloc(PATH_MAX_LENGTH);
+   core_path          = (char*)malloc(PATH_MAX_LENGTH);
+   game_path          = (char*)malloc(PATH_MAX_LENGTH);
+   content_path       = (char*)malloc(PATH_MAX_LENGTH);
 
    config_directory[0] = override_directory[0] = core_path[0] = game_path[0] = '\0';
 
diff --git a/configuration.h b/configuration.h
index 33c54ed90a..de693f0834 100644
--- a/configuration.h
+++ b/configuration.h
@@ -780,16 +780,6 @@ bool config_unload_override(void);
  */
 bool config_load_remap(void);
 
-/**
- * config_load_shader_preset:
- *
- * Tries to append game-specific and core-specific shader presets.
- *
- * Returns: false if there was an error or no action was performed.
- *
- */
-bool config_load_shader_preset(void);
-
 /**
  * config_save_autoconf_profile:
  * @path            : Path that shall be written to.
diff --git a/gfx/drivers/d3d10.c b/gfx/drivers/d3d10.c
index 92ee57a319..83984c10a1 100644
--- a/gfx/drivers/d3d10.c
+++ b/gfx/drivers/d3d10.c
@@ -948,9 +948,11 @@ d3d10_gfx_init(const video_info_t* video,
 
    font_driver_init_osd(d3d10, false, video->is_threaded, FONT_DRIVER_RENDER_D3D10_API);
 
-   const char *shader_preset   = retroarch_get_shader_preset();
-   enum rarch_shader_type type = video_shader_parse_type(shader_preset);
-   d3d10_gfx_set_shader(d3d10, type, shader_preset);
+   {
+      const char *shader_preset   = retroarch_get_shader_preset();
+      enum rarch_shader_type type = video_shader_parse_type(shader_preset);
+      d3d10_gfx_set_shader(d3d10, type, shader_preset);
+   }
 
 #if 0
    if (video_driver_get_hw_context()->context_type == RETRO_HW_CONTEXT_DIRECT3D &&
@@ -1667,12 +1669,9 @@ d3d10_get_hw_render_interface(void* data, const struct retro_hw_render_interface
 
 static uint32_t d3d10_get_flags(void *data)
 {
-   uint32_t             flags = 0;
+   uint32_t flags = 0;
 
    BIT32_SET(flags, GFX_CTX_FLAGS_MENU_FRAME_FILTERING);
-#if defined(HAVE_SLANG) && defined(HAVE_SPIRV_CROSS)
-   BIT32_SET(flags, GFX_CTX_FLAGS_SHADERS_SLANG);
-#endif
 
    return flags;
 }
diff --git a/gfx/drivers/d3d11.c b/gfx/drivers/d3d11.c
index ccf41fe71a..33d2437c49 100644
--- a/gfx/drivers/d3d11.c
+++ b/gfx/drivers/d3d11.c
@@ -1024,9 +1024,11 @@ d3d11_gfx_init(const video_info_t* video, const input_driver_t** input, void** i
 
    font_driver_init_osd(d3d11, false, video->is_threaded, FONT_DRIVER_RENDER_D3D11_API);
 
-   const char *shader_preset   = retroarch_get_shader_preset();
-   enum rarch_shader_type type = video_shader_parse_type(shader_preset);
-   d3d11_gfx_set_shader(d3d11, type, shader_preset);
+   {
+      const char *shader_preset   = retroarch_get_shader_preset();
+      enum rarch_shader_type type = video_shader_parse_type(shader_preset);
+      d3d11_gfx_set_shader(d3d11, type, shader_preset);
+   }
 
    if (video_driver_get_hw_context()->context_type == RETRO_HW_CONTEXT_DIRECT3D &&
          video_driver_get_hw_context()->version_major == 11)
@@ -1735,12 +1737,9 @@ d3d11_get_hw_render_interface(void* data, const struct retro_hw_render_interface
 
 static uint32_t d3d11_get_flags(void *data)
 {
-   uint32_t             flags = 0;
+   uint32_t flags = 0;
 
    BIT32_SET(flags, GFX_CTX_FLAGS_MENU_FRAME_FILTERING);
-#if defined(HAVE_SLANG) && defined(HAVE_SPIRV_CROSS)
-   BIT32_SET(flags, GFX_CTX_FLAGS_SHADERS_SLANG);
-#endif
 
    return flags;
 }
diff --git a/gfx/drivers/d3d12.c b/gfx/drivers/d3d12.c
index d731b332ef..f49ccd7eca 100644
--- a/gfx/drivers/d3d12.c
+++ b/gfx/drivers/d3d12.c
@@ -996,9 +996,11 @@ d3d12_gfx_init(const video_info_t* video, const input_driver_t** input, void** i
 
    font_driver_init_osd(d3d12, false, video->is_threaded, FONT_DRIVER_RENDER_D3D12_API);
 
-   const char *shader_preset   = retroarch_get_shader_preset();
-   enum rarch_shader_type type = video_shader_parse_type(shader_preset);
-   d3d12_gfx_set_shader(d3d12, type, shader_preset);
+   {
+      const char *shader_preset   = retroarch_get_shader_preset();
+      enum rarch_shader_type type = video_shader_parse_type(shader_preset);
+      d3d12_gfx_set_shader(d3d12, type, shader_preset);
+   }
 
    return d3d12;
 
@@ -1781,12 +1783,9 @@ static void d3d12_gfx_unload_texture(void* data, uintptr_t handle)
 
 static uint32_t d3d12_get_flags(void *data)
 {
-   uint32_t             flags = 0;
+   uint32_t flags = 0;
 
    BIT32_SET(flags, GFX_CTX_FLAGS_MENU_FRAME_FILTERING);
-#if defined(HAVE_SLANG) && defined(HAVE_SPIRV_CROSS)
-   BIT32_SET(flags, GFX_CTX_FLAGS_SHADERS_SLANG);
-#endif
 
    return flags;
 }
diff --git a/gfx/drivers/gl.c b/gfx/drivers/gl.c
index e407a307d6..24b908b2c1 100644
--- a/gfx/drivers/gl.c
+++ b/gfx/drivers/gl.c
@@ -2016,9 +2016,6 @@ static enum rarch_shader_type gl2_get_fallback_shader_type(enum rarch_shader_typ
 {
 #if defined(HAVE_GLSL) || defined(HAVE_CG)
    unsigned i;
-   gfx_ctx_flags_t flags;
-   flags.flags = 0;
-   video_context_driver_get_flags(&flags);
 
    if (type != RARCH_SHADER_CG && type != RARCH_SHADER_GLSL)
    {
@@ -2034,16 +2031,16 @@ static enum rarch_shader_type gl2_get_fallback_shader_type(enum rarch_shader_typ
       {
          case RARCH_SHADER_CG:
 #ifdef HAVE_CG
-            if (BIT32_GET(flags.flags, GFX_CTX_FLAGS_SHADERS_CG))
-               return RARCH_SHADER_CG;
+            if (video_shader_is_supported(type))
+               return type;
 #endif
             type = RARCH_SHADER_GLSL;
             break;
 
          case RARCH_SHADER_GLSL:
 #ifdef HAVE_GLSL
-            if (BIT32_GET(flags.flags, GFX_CTX_FLAGS_SHADERS_GLSL))
-               return RARCH_SHADER_GLSL;
+            if (video_shader_is_supported(type))
+               return type;
 #endif
             type = RARCH_SHADER_CG;
             break;
diff --git a/gfx/drivers/gl_core.c b/gfx/drivers/gl_core.c
index 3724882035..74c0c2d8f1 100644
--- a/gfx/drivers/gl_core.c
+++ b/gfx/drivers/gl_core.c
@@ -1752,7 +1752,6 @@ static uint32_t gl_core_get_flags(void *data)
    BIT32_SET(flags, GFX_CTX_FLAGS_HARD_SYNC);
    BIT32_SET(flags, GFX_CTX_FLAGS_BLACK_FRAME_INSERTION);
    BIT32_SET(flags, GFX_CTX_FLAGS_MENU_FRAME_FILTERING);
-   BIT32_SET(flags, GFX_CTX_FLAGS_SHADERS_SLANG);
    BIT32_SET(flags, GFX_CTX_FLAGS_SCREENSHOTS_SUPPORTED);
 
    return flags;
diff --git a/gfx/drivers/gx2_gfx.c b/gfx/drivers/gx2_gfx.c
index d85e86f1b3..29df0ce29b 100644
--- a/gfx/drivers/gx2_gfx.c
+++ b/gfx/drivers/gx2_gfx.c
@@ -1716,7 +1716,6 @@ static uint32_t wiiu_gfx_get_flags(void *data)
 {
    uint32_t flags = 0;
 
-   BIT32_SET(flags, GFX_CTX_FLAGS_SHADERS_SLANG);
    BIT32_SET(flags, GFX_CTX_FLAGS_SCREENSHOTS_SUPPORTED);
 
    return flags;
diff --git a/gfx/drivers/metal.m b/gfx/drivers/metal.m
index 57f536ca06..acac96f07c 100644
--- a/gfx/drivers/metal.m
+++ b/gfx/drivers/metal.m
@@ -315,9 +315,6 @@ static uint32_t metal_get_flags(void *data)
    BIT32_SET(flags, GFX_CTX_FLAGS_CUSTOMIZABLE_SWAPCHAIN_IMAGES);
    BIT32_SET(flags, GFX_CTX_FLAGS_BLACK_FRAME_INSERTION);
    BIT32_SET(flags, GFX_CTX_FLAGS_MENU_FRAME_FILTERING);
-#if defined(HAVE_SLANG) && defined(HAVE_SPIRV_CROSS)
-   BIT32_SET(flags, GFX_CTX_FLAGS_SHADERS_SLANG);
-#endif
    BIT32_SET(flags, GFX_CTX_FLAGS_SCREENSHOTS_SUPPORTED);
 
    return flags;
diff --git a/gfx/drivers/vulkan.c b/gfx/drivers/vulkan.c
index 1a66d65472..0576ee45ee 100644
--- a/gfx/drivers/vulkan.c
+++ b/gfx/drivers/vulkan.c
@@ -2396,12 +2396,11 @@ static float vulkan_get_refresh_rate(void *data)
 
 static uint32_t vulkan_get_flags(void *data)
 {
-   uint32_t             flags = 0;
+   uint32_t flags = 0;
 
    BIT32_SET(flags, GFX_CTX_FLAGS_CUSTOMIZABLE_SWAPCHAIN_IMAGES);
    BIT32_SET(flags, GFX_CTX_FLAGS_BLACK_FRAME_INSERTION);
    BIT32_SET(flags, GFX_CTX_FLAGS_MENU_FRAME_FILTERING);
-   BIT32_SET(flags, GFX_CTX_FLAGS_SHADERS_SLANG);
    BIT32_SET(flags, GFX_CTX_FLAGS_SCREENSHOTS_SUPPORTED);
 
    return flags;
diff --git a/gfx/drivers_context/android_ctx.c b/gfx/drivers_context/android_ctx.c
index 62b008f6ab..a0ea15f602 100644
--- a/gfx/drivers_context/android_ctx.c
+++ b/gfx/drivers_context/android_ctx.c
@@ -588,7 +588,6 @@ static void *android_gfx_ctx_get_context_data(void *data)
 static uint32_t android_gfx_ctx_get_flags(void *data)
 {
    uint32_t flags = 0;
-   BIT32_SET(flags, GFX_CTX_FLAGS_NONE);
 
    switch (android_api)
    {
@@ -599,7 +598,7 @@ static uint32_t android_gfx_ctx_get_flags(void *data)
 #endif
          break;
       case GFX_CTX_VULKAN_API:
-#ifdef HAVE_SLANG
+#if defined(HAVE_SLANG) && defined(HAVE_SPIRV_CROSS)
          BIT32_SET(flags, GFX_CTX_FLAGS_SHADERS_SLANG);
 #endif
          break;
diff --git a/gfx/drivers_context/cgl_ctx.c b/gfx/drivers_context/cgl_ctx.c
index aa58b430dc..2013902962 100644
--- a/gfx/drivers_context/cgl_ctx.c
+++ b/gfx/drivers_context/cgl_ctx.c
@@ -326,7 +326,18 @@ error:
 static uint32_t gfx_ctx_cgl_get_flags(void *data)
 {
    uint32_t flags = 0;
-   BIT32_SET(flags, GFX_CTX_FLAGS_SHADERS_GLSL);
+
+   if (string_is_equal(video_driver_get_ident(), "glcore"))
+   {
+#if defined(HAVE_SLANG) && defined(HAVE_SPIRV_CROSS)
+      BIT32_SET(flags, GFX_CTX_FLAGS_SHADERS_SLANG);
+#endif
+   }
+   else
+   {
+      BIT32_SET(flags, GFX_CTX_FLAGS_SHADERS_GLSL);
+   }
+
    return flags;
 }
 
diff --git a/gfx/drivers_context/cocoa_gl_ctx.m b/gfx/drivers_context/cocoa_gl_ctx.m
index a2a415d2c0..75dac08ddf 100644
--- a/gfx/drivers_context/cocoa_gl_ctx.m
+++ b/gfx/drivers_context/cocoa_gl_ctx.m
@@ -108,8 +108,6 @@ static uint32_t cocoagl_gfx_ctx_get_flags(void *data)
    uint32_t flags                 = 0;
    cocoa_ctx_data_t    *cocoa_ctx = (cocoa_ctx_data_t*)data;
 
-   BIT32_SET(flags, GFX_CTX_FLAGS_NONE);
-
    if (cocoa_ctx->core_hw_context_enable)
       BIT32_SET(flags, GFX_CTX_FLAGS_GL_CORE_CONTEXT);
 
@@ -122,7 +120,12 @@ static uint32_t cocoagl_gfx_ctx_get_flags(void *data)
          break;
       case GFX_CTX_OPENGL_API:
          if (string_is_equal(video_driver_get_ident(), "gl1")) { }
-         else if (string_is_equal(video_driver_get_ident(), "glcore")) { }
+         else if (string_is_equal(video_driver_get_ident(), "glcore"))
+         {
+#if defined(HAVE_SLANG) && defined(HAVE_SPIRV_CROSS)
+            BIT32_SET(flags, GFX_CTX_FLAGS_SHADERS_SLANG);
+#endif
+         }
          else
          {
 #ifdef HAVE_GLSL
@@ -131,6 +134,9 @@ static uint32_t cocoagl_gfx_ctx_get_flags(void *data)
          }
          break;
       case GFX_CTX_VULKAN_API:
+#if defined(HAVE_SLANG) && defined(HAVE_SPIRV_CROSS)
+         BIT32_SET(flags, GFX_CTX_FLAGS_SHADERS_SLANG);
+#endif
          break;
       default:
          break;
diff --git a/gfx/drivers_context/drm_ctx.c b/gfx/drivers_context/drm_ctx.c
index b4ca18da1f..b935d9cfb0 100644
--- a/gfx/drivers_context/drm_ctx.c
+++ b/gfx/drivers_context/drm_ctx.c
@@ -911,7 +911,7 @@ static uint32_t gfx_ctx_drm_get_flags(void *data)
 
    if (string_is_equal(video_driver_get_ident(), "glcore"))
    {
-#ifdef HAVE_SLANG
+#if defined(HAVE_SLANG) && defined(HAVE_SPIRV_CROSS)
       BIT32_SET(flags, GFX_CTX_FLAGS_SHADERS_SLANG);
 #endif
    }
diff --git a/gfx/drivers_context/gdi_ctx.c b/gfx/drivers_context/gdi_ctx.c
index 2dc25e79bc..2ae6704412 100644
--- a/gfx/drivers_context/gdi_ctx.c
+++ b/gfx/drivers_context/gdi_ctx.c
@@ -341,7 +341,7 @@ static void gfx_ctx_gdi_set_flags(void *data, uint32_t flags)
 static uint32_t gfx_ctx_gdi_get_flags(void *data)
 {
    uint32_t flags = 0;
-   BIT32_SET(flags, GFX_CTX_FLAGS_NONE);
+
    return flags;
 }
 
diff --git a/gfx/drivers_context/gfx_null_ctx.c b/gfx/drivers_context/gfx_null_ctx.c
index 9b950126c3..f9b898c870 100644
--- a/gfx/drivers_context/gfx_null_ctx.c
+++ b/gfx/drivers_context/gfx_null_ctx.c
@@ -123,7 +123,6 @@ static void *gfx_ctx_null_init(video_frame_info_t *video_info, void *video_drive
 static uint32_t gfx_ctx_null_get_flags(void *data)
 {
    uint32_t flags = 0;
-   BIT32_SET(flags, GFX_CTX_FLAGS_NONE);
 
    return flags;
 }
diff --git a/gfx/drivers_context/khr_display_ctx.c b/gfx/drivers_context/khr_display_ctx.c
index f82656225d..bf99de8ac4 100644
--- a/gfx/drivers_context/khr_display_ctx.c
+++ b/gfx/drivers_context/khr_display_ctx.c
@@ -257,10 +257,11 @@ static gfx_ctx_proc_t gfx_ctx_khr_display_get_proc_address(const char *symbol)
 static uint32_t gfx_ctx_khr_display_get_flags(void *data)
 {
    uint32_t flags = 0;
-   BIT32_SET(flags, GFX_CTX_FLAGS_NONE);
-#ifdef HAVE_SLANG
+
+#if defined(HAVE_SLANG) && defined(HAVE_SPIRV_CROSS)
    BIT32_SET(flags, GFX_CTX_FLAGS_SHADERS_SLANG);
 #endif
+
    return flags;
 }
 
diff --git a/gfx/drivers_context/mali_fbdev_ctx.c b/gfx/drivers_context/mali_fbdev_ctx.c
index f82c0a2067..ddb0ef845e 100644
--- a/gfx/drivers_context/mali_fbdev_ctx.c
+++ b/gfx/drivers_context/mali_fbdev_ctx.c
@@ -287,7 +287,7 @@ static void gfx_ctx_mali_fbdev_bind_hw_render(void *data, bool enable)
 static uint32_t gfx_ctx_mali_fbdev_get_flags(void *data)
 {
    uint32_t flags = 0;
-   BIT32_SET(flags, GFX_CTX_FLAGS_NONE);
+
    BIT32_SET(flags, GFX_CTX_FLAGS_SHADERS_GLSL);
 
    return flags;
diff --git a/gfx/drivers_context/opendingux_fbdev_ctx.c b/gfx/drivers_context/opendingux_fbdev_ctx.c
index 6e2034d762..86bb3b6775 100644
--- a/gfx/drivers_context/opendingux_fbdev_ctx.c
+++ b/gfx/drivers_context/opendingux_fbdev_ctx.c
@@ -254,8 +254,9 @@ static void gfx_ctx_opendingux_bind_hw_render(void *data, bool enable)
 static uint32_t gfx_ctx_opendingux_get_flags(void *data)
 {
    uint32_t flags = 0;
-   BIT32_SET(flags, GFX_CTX_FLAGS_NONE);
+
    BIT32_SET(flags, GFX_CTX_FLAGS_SHADERS_GLSL);
+
    return flags;
 }
 
diff --git a/gfx/drivers_context/orbis_ctx.c b/gfx/drivers_context/orbis_ctx.c
index 973bbb6135..89266e6221 100644
--- a/gfx/drivers_context/orbis_ctx.c
+++ b/gfx/drivers_context/orbis_ctx.c
@@ -259,11 +259,20 @@ static void orbis_ctx_bind_hw_render(void *data, bool enable)
 
 static uint32_t orbis_ctx_get_flags(void *data)
 {
-    uint32_t flags = 0;
-    BIT32_SET(flags, GFX_CTX_FLAGS_NONE);
-   BIT32_SET(flags, GFX_CTX_FLAGS_SHADERS_GLSL);
+   uint32_t flags = 0;
 
-    return flags;
+   if (string_is_equal(video_driver_get_ident(), "glcore"))
+   {
+#if defined(HAVE_SLANG) && defined(HAVE_SPIRV_CROSS)
+      BIT32_SET(flags, GFX_CTX_FLAGS_SHADERS_SLANG);
+#endif
+   }
+   else
+   {
+      BIT32_SET(flags, GFX_CTX_FLAGS_SHADERS_GLSL);
+   }
+
+   return flags;
 }
 
 static void orbis_ctx_set_flags(void *data, uint32_t flags)
diff --git a/gfx/drivers_context/osmesa_ctx.c b/gfx/drivers_context/osmesa_ctx.c
index 951c389770..76c18e9d36 100644
--- a/gfx/drivers_context/osmesa_ctx.c
+++ b/gfx/drivers_context/osmesa_ctx.c
@@ -379,8 +379,9 @@ static void osmesa_ctx_show_mouse(void *data, bool state)
 static uint32_t osmesa_ctx_get_flags(void *data)
 {
    uint32_t flags = 0;
-   BIT32_SET(flags, GFX_CTX_FLAGS_NONE);
+
    BIT32_SET(flags, GFX_CTX_FLAGS_SHADERS_GLSL);
+
    return flags;
 }
 
diff --git a/gfx/drivers_context/ps3_ctx.c b/gfx/drivers_context/ps3_ctx.c
index ed03e298fa..9437f65b9b 100644
--- a/gfx/drivers_context/ps3_ctx.c
+++ b/gfx/drivers_context/ps3_ctx.c
@@ -405,10 +405,11 @@ static void gfx_ctx_ps3_get_video_output_next(void *data)
 static uint32_t gfx_ctx_ps3_get_flags(void *data)
 {
    uint32_t flags = 0;
-   BIT32_SET(flags, GFX_CTX_FLAGS_NONE);
+
 #ifdef HAVE_CG
    BIT32_SET(flags, GFX_CTX_FLAGS_SHADERS_CG);
 #endif
+
    return flags;
 }
 
diff --git a/gfx/drivers_context/qnx_ctx.c b/gfx/drivers_context/qnx_ctx.c
index 616670af38..e2c749fa6f 100644
--- a/gfx/drivers_context/qnx_ctx.c
+++ b/gfx/drivers_context/qnx_ctx.c
@@ -452,8 +452,9 @@ static gfx_ctx_proc_t gfx_ctx_qnx_get_proc_address(const char *symbol)
 static uint32_t gfx_ctx_qnx_get_flags(void *data)
 {
    uint32_t flags = 0;
-   BIT32_SET(flags, GFX_CTX_FLAGS_NONE);
+
    BIT32_SET(flags, GFX_CTX_FLAGS_SHADERS_GLSL);
+
    return flags;
 }
 
diff --git a/gfx/drivers_context/sdl_gl_ctx.c b/gfx/drivers_context/sdl_gl_ctx.c
index 302fab28f0..42a926ca1e 100644
--- a/gfx/drivers_context/sdl_gl_ctx.c
+++ b/gfx/drivers_context/sdl_gl_ctx.c
@@ -405,7 +405,7 @@ static void sdl_ctx_show_mouse(void *data, bool state)
 static uint32_t sdl_ctx_get_flags(void *data)
 {
    uint32_t flags = 0;
-   BIT32_SET(flags, GFX_CTX_FLAGS_NONE);
+
    return flags;
 }
 
diff --git a/gfx/drivers_context/sixel_ctx.c b/gfx/drivers_context/sixel_ctx.c
index 21bb0f9b69..6fe9ecebe1 100644
--- a/gfx/drivers_context/sixel_ctx.c
+++ b/gfx/drivers_context/sixel_ctx.c
@@ -181,7 +181,7 @@ static void gfx_ctx_sixel_set_flags(void *data, uint32_t flags)
 static uint32_t gfx_ctx_sixel_get_flags(void *data)
 {
    uint32_t flags = 0;
-   BIT32_SET(flags, GFX_CTX_FLAGS_NONE);
+
    return flags;
 }
 
diff --git a/gfx/drivers_context/switch_ctx.c b/gfx/drivers_context/switch_ctx.c
index 423bfc2813..37a1517400 100644
--- a/gfx/drivers_context/switch_ctx.c
+++ b/gfx/drivers_context/switch_ctx.c
@@ -267,10 +267,19 @@ static void switch_ctx_bind_hw_render(void *data, bool enable)
 static uint32_t switch_ctx_get_flags(void *data)
 {
     uint32_t flags = 0;
-    BIT32_SET(flags, GFX_CTX_FLAGS_NONE);
-#ifdef HAVE_GLSL
-    BIT32_SET(flags, GFX_CTX_FLAGS_SHADERS_GLSL);
+
+   if (string_is_equal(video_driver_get_ident(), "glcore"))
+   {
+#if defined(HAVE_SLANG) && defined(HAVE_SPIRV_CROSS)
+      BIT32_SET(flags, GFX_CTX_FLAGS_SHADERS_SLANG);
 #endif
+   }
+   else
+   {
+#ifdef HAVE_GLSL
+      BIT32_SET(flags, GFX_CTX_FLAGS_SHADERS_GLSL);
+#endif
+   }
 
     return flags;
 }
diff --git a/gfx/drivers_context/vivante_fbdev_ctx.c b/gfx/drivers_context/vivante_fbdev_ctx.c
index e559601b2f..b32521eda5 100644
--- a/gfx/drivers_context/vivante_fbdev_ctx.c
+++ b/gfx/drivers_context/vivante_fbdev_ctx.c
@@ -261,8 +261,9 @@ static void gfx_ctx_vivante_bind_hw_render(void *data, bool enable)
 static uint32_t gfx_ctx_vivante_get_flags(void *data)
 {
    uint32_t flags = 0;
-   BIT32_SET(flags, GFX_CTX_FLAGS_NONE);
+
    BIT32_SET(flags, GFX_CTX_FLAGS_SHADERS_GLSL);
+
    return flags;
 }
 
diff --git a/gfx/drivers_context/wayland_ctx.c b/gfx/drivers_context/wayland_ctx.c
index ca44b9f3a6..fd0d48efea 100644
--- a/gfx/drivers_context/wayland_ctx.c
+++ b/gfx/drivers_context/wayland_ctx.c
@@ -1965,11 +1965,7 @@ static uint32_t gfx_ctx_wl_get_flags(void *data)
    gfx_ctx_wayland_data_t *wl = (gfx_ctx_wayland_data_t*)data;
 
    if (wl->core_hw_context_enable)
-   {
       BIT32_SET(flags, GFX_CTX_FLAGS_GL_CORE_CONTEXT);
-   }
-   else
-      BIT32_SET(flags, GFX_CTX_FLAGS_NONE);
 
    switch (wl_api)
    {
@@ -1977,7 +1973,7 @@ static uint32_t gfx_ctx_wl_get_flags(void *data)
       case GFX_CTX_OPENGL_ES_API:
          if (string_is_equal(video_driver_get_ident(), "glcore"))
          {
-#ifdef HAVE_SLANG
+#if defined(HAVE_SLANG) && defined(HAVE_SPIRV_CROSS)
             BIT32_SET(flags, GFX_CTX_FLAGS_SHADERS_SLANG);
 #endif
          }
@@ -1989,7 +1985,7 @@ static uint32_t gfx_ctx_wl_get_flags(void *data)
          }
          break;
       case GFX_CTX_VULKAN_API:
-#ifdef HAVE_SLANG
+#if defined(HAVE_SLANG) && defined(HAVE_SPIRV_CROSS)
          BIT32_SET(flags, GFX_CTX_FLAGS_SHADERS_SLANG);
 #endif
          break;
diff --git a/gfx/drivers_context/wgl_ctx.c b/gfx/drivers_context/wgl_ctx.c
index 0f7b98e961..0b7fae942d 100644
--- a/gfx/drivers_context/wgl_ctx.c
+++ b/gfx/drivers_context/wgl_ctx.c
@@ -798,28 +798,22 @@ static void *gfx_ctx_wgl_get_context_data(void *data)
 
 static uint32_t gfx_ctx_wgl_get_flags(void *data)
 {
-   uint32_t          flags = 0;
-
-   BIT32_SET(flags, GFX_CTX_FLAGS_NONE);
+   uint32_t flags = 0;
 
    switch (win32_api)
    {
       case GFX_CTX_OPENGL_API:
          if (wgl_adaptive_vsync)
-         {
             BIT32_SET(flags, GFX_CTX_FLAGS_ADAPTIVE_VSYNC);
-         }
 
          if (win32_core_hw_context_enable)
-         {
             BIT32_SET(flags, GFX_CTX_FLAGS_GL_CORE_CONTEXT);
-         }
 
          if (string_is_equal(video_driver_get_ident(), "gl1")) { }
          else if (string_is_equal(video_driver_get_ident(), "glcore"))
          {
-#ifdef HAVE_SLANG
-         BIT32_SET(flags, GFX_CTX_FLAGS_SHADERS_SLANG);
+#if defined(HAVE_SLANG) && defined(HAVE_SPIRV_CROSS)
+            BIT32_SET(flags, GFX_CTX_FLAGS_SHADERS_SLANG);
 #endif
          }
          else
@@ -835,7 +829,7 @@ static uint32_t gfx_ctx_wgl_get_flags(void *data)
 
          break;
       case GFX_CTX_VULKAN_API:
-#ifdef HAVE_SLANG
+#if defined(HAVE_SLANG) && defined(HAVE_SPIRV_CROSS)
          BIT32_SET(flags, GFX_CTX_FLAGS_SHADERS_SLANG);
 #endif
          break;
diff --git a/gfx/drivers_context/x_ctx.c b/gfx/drivers_context/x_ctx.c
index 8627ca3f37..42ab36d838 100644
--- a/gfx/drivers_context/x_ctx.c
+++ b/gfx/drivers_context/x_ctx.c
@@ -1150,29 +1150,23 @@ static uint32_t gfx_ctx_x_get_flags(void *data)
    uint32_t      flags = 0;
    gfx_ctx_x_data_t *x = (gfx_ctx_x_data_t*)data;
 
-   BIT32_SET(flags, GFX_CTX_FLAGS_NONE);
-
    switch (x_api)
    {
       case GFX_CTX_OPENGL_API:
       case GFX_CTX_OPENGL_ES_API:
          if (x_adaptive_vsync)
-         {
             BIT32_SET(flags, GFX_CTX_FLAGS_ADAPTIVE_VSYNC);
-         }
 
          if (x->core_hw_context_enable || x->g_core_es)
-         {
             BIT32_SET(flags, GFX_CTX_FLAGS_GL_CORE_CONTEXT);
-         }
+
          if (x_enable_msaa)
-         {
             BIT32_SET(flags, GFX_CTX_FLAGS_MULTISAMPLING);
-         }
+
          if (string_is_equal(video_driver_get_ident(), "gl1")) { }
          else if (string_is_equal(video_driver_get_ident(), "glcore"))
          {
-#ifdef HAVE_SLANG
+#if defined(HAVE_SLANG) && defined(HAVE_SPIRV_CROSS)
             BIT32_SET(flags, GFX_CTX_FLAGS_SHADERS_SLANG);
 #endif
          }
@@ -1188,7 +1182,7 @@ static uint32_t gfx_ctx_x_get_flags(void *data)
          }
          break;
       case GFX_CTX_VULKAN_API:
-#ifdef HAVE_SLANG
+#if defined(HAVE_SLANG) && defined(HAVE_SPIRV_CROSS)
          BIT32_SET(flags, GFX_CTX_FLAGS_SHADERS_SLANG);
 #endif
          break;
diff --git a/gfx/drivers_context/xegl_ctx.c b/gfx/drivers_context/xegl_ctx.c
index 3437f7d4d4..c24b5a1fb9 100644
--- a/gfx/drivers_context/xegl_ctx.c
+++ b/gfx/drivers_context/xegl_ctx.c
@@ -603,8 +603,18 @@ static gfx_ctx_proc_t gfx_ctx_xegl_get_proc_address(const char *symbol)
 static uint32_t gfx_ctx_xegl_get_flags(void *data)
 {
    uint32_t flags = 0;
-   BIT32_SET(flags, GFX_CTX_FLAGS_NONE);
-   BIT32_SET(flags, GFX_CTX_FLAGS_SHADERS_GLSL);
+
+   if (string_is_equal(video_driver_get_ident(), "glcore"))
+   {
+#if defined(HAVE_SLANG) && defined(HAVE_SPIRV_CROSS)
+      BIT32_SET(flags, GFX_CTX_FLAGS_SHADERS_SLANG);
+#endif
+   }
+   else
+   {
+      BIT32_SET(flags, GFX_CTX_FLAGS_SHADERS_GLSL);
+   }
+
    return flags;
 }
 
diff --git a/gfx/video_shader_parse.c b/gfx/video_shader_parse.c
index bc35299649..d51645d1ec 100644
--- a/gfx/video_shader_parse.c
+++ b/gfx/video_shader_parse.c
@@ -36,6 +36,7 @@
 #include "../verbosity.h"
 #include "../frontend/frontend_driver.h"
 #include "../command.h"
+#include "../file_path_special.h"
 #include "video_shader_parse.h"
 
 #if defined(HAVE_SLANG) && defined(HAVE_SPIRV_CROSS)
@@ -1150,30 +1151,56 @@ const char *video_shader_to_str(enum rarch_shader_type type)
    return "???";
 }
 
+/**
+ * video_shader_is_supported:
+ * Tests if a shader type is supported.
+ * This is only accurate once the context driver was initialized.
+ **/
 bool video_shader_is_supported(enum rarch_shader_type type)
 {
-   enum display_flags flag = GFX_CTX_FLAGS_NONE;
+   gfx_ctx_flags_t flags;
+   enum display_flags testflag;
 
    switch (type)
    {
       case RARCH_SHADER_SLANG:
-         flag = GFX_CTX_FLAGS_SHADERS_SLANG;
+         testflag = GFX_CTX_FLAGS_SHADERS_SLANG;
          break;
       case RARCH_SHADER_GLSL:
-         flag = GFX_CTX_FLAGS_SHADERS_GLSL;
+         testflag = GFX_CTX_FLAGS_SHADERS_GLSL;
          break;
       case RARCH_SHADER_CG:
-         flag = GFX_CTX_FLAGS_SHADERS_CG;
+         testflag = GFX_CTX_FLAGS_SHADERS_CG;
          break;
       case RARCH_SHADER_HLSL:
-         flag = GFX_CTX_FLAGS_SHADERS_HLSL;
+         testflag = GFX_CTX_FLAGS_SHADERS_HLSL;
          break;
       case RARCH_SHADER_NONE:
       default:
          return false;
    }
 
-   return video_driver_test_all_flags(flag);
+   video_context_driver_get_flags(&flags);
+
+   return BIT32_GET(flags.flags, testflag);
+}
+
+const char *video_shader_get_preset_extension(enum rarch_shader_type type)
+{
+   switch (type)
+   {
+      case RARCH_SHADER_GLSL:
+         return file_path_str(FILE_PATH_GLSLP_EXTENSION);
+      case RARCH_SHADER_SLANG:
+         return file_path_str(FILE_PATH_SLANGP_EXTENSION);
+      case RARCH_SHADER_HLSL:
+      case RARCH_SHADER_CG:
+         return file_path_str(FILE_PATH_CGP_EXTENSION);
+      default:
+         break;
+   }
+
+   return NULL;
 }
 
 bool video_shader_any_supported(void)
diff --git a/gfx/video_shader_parse.h b/gfx/video_shader_parse.h
index aca13746d6..c4920c6cec 100644
--- a/gfx/video_shader_parse.h
+++ b/gfx/video_shader_parse.h
@@ -250,6 +250,8 @@ bool video_shader_check_for_changes(void);
 
 const char *video_shader_to_str(enum rarch_shader_type type);
 
+const char *video_shader_get_preset_extension(enum rarch_shader_type type);
+
 RETRO_END_DECLS
 
 #endif
diff --git a/list_special.c b/list_special.c
index 8360ea1a79..70b5406cdc 100644
--- a/list_special.c
+++ b/list_special.c
@@ -98,19 +98,19 @@ struct string_list *dir_list_new_special(const char *input_dir,
 
             attr.i = 0;
 
-            if (video_driver_test_all_flags(GFX_CTX_FLAGS_SHADERS_CG))
+            if (video_shader_is_supported(RARCH_SHADER_CG))
             {
                string_list_append(str_list, "cgp", attr);
                string_list_append(str_list, "cg", attr);
             }
 
-            if (video_driver_test_all_flags(GFX_CTX_FLAGS_SHADERS_GLSL))
+            if (video_shader_is_supported(RARCH_SHADER_GLSL))
             {
                string_list_append(str_list, "glslp", attr);
                string_list_append(str_list, "glsl", attr);
             }
 
-            if (video_driver_test_all_flags(GFX_CTX_FLAGS_SHADERS_SLANG))
+            if (video_shader_is_supported(RARCH_SHADER_SLANG))
             {
                string_list_append(str_list, "slangp", attr);
                string_list_append(str_list, "slang", attr);
diff --git a/menu/menu_displaylist.c b/menu/menu_displaylist.c
index bf3ffdea3d..f76287368e 100644
--- a/menu/menu_displaylist.c
+++ b/menu/menu_displaylist.c
@@ -6804,7 +6804,7 @@ bool menu_displaylist_ctl(enum menu_displaylist_ctl_state type,
                      MENU_SETTING_ACTION, 0, 0))
                count++;
 
-            if (video_driver_test_all_flags(GFX_CTX_FLAGS_SHADERS_CG))
+            if (video_shader_is_supported(RARCH_SHADER_CG))
             {
                if (menu_entries_append_enum(info->list,
                      msg_hash_to_str(MENU_ENUM_LABEL_VALUE_UPDATE_CG_SHADERS),
@@ -6814,7 +6814,7 @@ bool menu_displaylist_ctl(enum menu_displaylist_ctl_state type,
                   count++;
             }
 
-            if (video_driver_test_all_flags(GFX_CTX_FLAGS_SHADERS_GLSL))
+            if (video_shader_is_supported(RARCH_SHADER_GLSL))
             {
                if (menu_entries_append_enum(info->list,
                         msg_hash_to_str(MENU_ENUM_LABEL_VALUE_UPDATE_GLSL_SHADERS),
@@ -6824,7 +6824,7 @@ bool menu_displaylist_ctl(enum menu_displaylist_ctl_state type,
                   count++;
             }
 
-            if (video_driver_test_all_flags(GFX_CTX_FLAGS_SHADERS_SLANG))
+            if (video_shader_is_supported(RARCH_SHADER_SLANG))
             {
                if (menu_entries_append_enum(info->list,
                         msg_hash_to_str(MENU_ENUM_LABEL_VALUE_UPDATE_SLANG_SHADERS),
@@ -7464,7 +7464,7 @@ bool menu_displaylist_ctl(enum menu_displaylist_ctl_state type,
             else if (type == DISPLAYLIST_SHADER_PASS)
                info->type_default = FILE_TYPE_SHADER;
 
-            if (video_driver_test_all_flags(GFX_CTX_FLAGS_SHADERS_CG))
+            if (video_shader_is_supported(RARCH_SHADER_CG))
             {
                if (type == DISPLAYLIST_SHADER_PRESET)
                   string_list_append(str_list, "cgp", attr);
@@ -7472,7 +7472,7 @@ bool menu_displaylist_ctl(enum menu_displaylist_ctl_state type,
                   string_list_append(str_list, "cg", attr);
             }
           
-            if (video_driver_test_all_flags(GFX_CTX_FLAGS_SHADERS_GLSL))
+            if (video_shader_is_supported(RARCH_SHADER_GLSL))
             {
                if (type == DISPLAYLIST_SHADER_PRESET)
                   string_list_append(str_list, "glslp", attr);
@@ -7480,7 +7480,7 @@ bool menu_displaylist_ctl(enum menu_displaylist_ctl_state type,
                   string_list_append(str_list, "glsl", attr);
             }
           
-            if (video_driver_test_all_flags(GFX_CTX_FLAGS_SHADERS_SLANG))
+            if (video_shader_is_supported(RARCH_SHADER_SLANG))
             {
                if (type == DISPLAYLIST_SHADER_PRESET)
                   string_list_append(str_list, "slangp", attr);
diff --git a/menu/menu_shader.c b/menu/menu_shader.c
index 143aa9a758..4e58e25b78 100644
--- a/menu/menu_shader.c
+++ b/menu/menu_shader.c
@@ -195,22 +195,6 @@ bool menu_shader_manager_set_preset(void *data,
    return true;
 }
 
-static const char *shader_get_preset_extension(unsigned type)
-{
-   switch (type)
-   {
-      case RARCH_SHADER_GLSL:
-         return file_path_str(FILE_PATH_GLSLP_EXTENSION);
-      case RARCH_SHADER_SLANG:
-         return file_path_str(FILE_PATH_SLANGP_EXTENSION);
-      case RARCH_SHADER_HLSL:
-      case RARCH_SHADER_CG:
-         return file_path_str(FILE_PATH_CGP_EXTENSION);
-   }
-
-   return NULL;
-}
-
 /**
  * menu_shader_manager_save_preset:
  * @basename                 : basename of preset
@@ -255,7 +239,7 @@ bool menu_shader_manager_save_preset(
             && !strstr(basename,
                file_path_str(FILE_PATH_SLANGP_EXTENSION)))
       {
-         const char *preset_ext = shader_get_preset_extension(type);
+         const char *preset_ext = video_shader_get_preset_extension(type);
          if (!string_is_empty(preset_ext))
             strlcat(buffer, preset_ext, sizeof(buffer));
       }
@@ -271,7 +255,7 @@ bool menu_shader_manager_save_preset(
          const char *config_path     = path_get(RARCH_PATH_CONFIG);
          /* In a multi-config setting, we can't have
           * conflicts on menu.cgp/menu.glslp. */
-         const char *preset_ext      = shader_get_preset_extension(type);
+         const char *preset_ext      = video_shader_get_preset_extension(type);
 
          if (!string_is_empty(preset_ext))
          {
diff --git a/retroarch.c b/retroarch.c
index a862b3e4f5..b1846d9ece 100644
--- a/retroarch.c
+++ b/retroarch.c
@@ -242,6 +242,7 @@ static enum rarch_core_type current_core_type                   = CORE_TYPE_PLAI
 static enum rarch_core_type explicit_current_core_type          = CORE_TYPE_PLAIN;
 static char error_string[255]                                   = {0};
 static char runtime_shader_preset[255]                          = {0};
+static bool shader_presets_need_reload                          = true;
 
 #ifdef HAVE_THREAD_STORAGE
 static sthread_tls_t rarch_tls;
@@ -13760,6 +13761,131 @@ void retroarch_unset_shader_preset(void)
    runtime_shader_preset[0] = '\0';
 }
 
+static bool retroarch_load_shader_preset_internal(
+      const char *shader_directory,
+      const char *core_name,
+      const char *special_name)
+{
+   unsigned i;
+   char *shader_path = (char*)malloc(PATH_MAX_LENGTH);
+
+   static enum rarch_shader_type types[] =
+   {
+      /* Shader preset priority, highest to lowest
+       * only important for video drivers with multiple shader backends */
+      RARCH_SHADER_GLSL, RARCH_SHADER_SLANG, RARCH_SHADER_CG, RARCH_SHADER_HLSL
+   };
+
+   for (i = 0; i < ARRAY_SIZE(types); i++)
+   {
+      if (!video_shader_is_supported(types[i]))
+         continue;
+
+      /* Concatenate strings into full paths */
+      fill_pathname_join_special_ext(shader_path,
+            shader_directory, core_name,
+            special_name,
+            video_shader_get_preset_extension(types[i]),
+            PATH_MAX_LENGTH);
+
+      if (!config_file_exists(shader_path))
+         continue;
+
+      /* Shader preset exists, load it. */
+      RARCH_LOG("[Shaders]: Specific shader preset found at %s.\n",
+            shader_path);
+      retroarch_set_shader_preset(shader_path);
+      free(shader_path);
+      return true;
+   }
+
+   free(shader_path);
+   return false;
+}
+
+/**
+ * retroarch_load_shader_preset:
+ *
+ * Tries to load a supported core-, game- or folder-specific shader preset
+ * from its respective location:
+ *
+ * core-specific:   $SHADER_DIR/presets/$CORE_NAME/$CORE_NAME.$PRESET_EXT
+ * folder-specific: $SHADER_DIR/presets/$CORE_NAME/$FOLDER_NAME.$PRESET_EXT
+ * game-specific:   $SHADER_DIR/presets/$CORE_NAME/$GAME_NAME.$PRESET_EXT
+ *
+ * Note: Uses video_shader_is_supported() which only works after
+ *       context driver initialization.
+ *
+ * Returns: false if there was an error or no action was performed.
+ */
+static bool retroarch_load_shader_preset(void)
+{
+   const settings_t *settings         = config_get_ptr();
+   const rarch_system_info_t *system  = runloop_get_system_info();
+   const char *video_shader_directory = settings->paths.directory_video_shader;
+   const char *core_name              = system ? system->info.library_name : NULL;
+   const char *rarch_path_basename    = path_get(RARCH_PATH_BASENAME);
+
+   const char *game_name              = path_basename(rarch_path_basename);
+   char *shader_directory;
+
+   if (!settings->bools.auto_shaders_enable)
+      return false;
+
+   if (string_is_empty(video_shader_directory) ||
+         string_is_empty(core_name) ||
+         string_is_empty(game_name))
+      return false;
+
+   shader_directory = (char*)malloc(PATH_MAX_LENGTH);
+
+   fill_pathname_join(shader_directory,
+         video_shader_directory,
+         "presets", PATH_MAX_LENGTH);
+
+   RARCH_LOG("[Shaders]: preset directory: %s\n", shader_directory);
+
+   if (retroarch_load_shader_preset_internal(shader_directory, core_name,
+            game_name))
+   {
+      RARCH_LOG("[Shaders]: game-specific shader preset found.\n");
+      goto success;
+   }
+
+   {
+      char content_dir_name[PATH_MAX_LENGTH];
+      if (!string_is_empty(rarch_path_basename))
+         fill_pathname_parent_dir_name(content_dir_name,
+               rarch_path_basename, sizeof(content_dir_name));
+
+      if (retroarch_load_shader_preset_internal(shader_directory, core_name,
+               content_dir_name))
+      {
+         RARCH_LOG("[Shaders]: folder-specific shader preset found.\n");
+         goto success;
+      }
+   }
+
+   if (retroarch_load_shader_preset_internal(shader_directory, core_name,
+            core_name))
+   {
+      RARCH_LOG("[Shaders]: core-specific shader preset found.\n");
+      goto success;
+   }
+
+   free(shader_directory);
+   return false;
+
+success:
+   free(shader_directory);
+   return true;
+}
+
+void retroarch_shader_presets_set_need_reload()
+{
+   shader_presets_need_reload = true;
+}
+
 /* get the name of the current shader preset */
 char* retroarch_get_shader_preset(void)
 {
@@ -13767,10 +13893,18 @@ char* retroarch_get_shader_preset(void)
    if (!settings->bools.video_shader_enable)
       return NULL;
 
+   if (shader_presets_need_reload)
+   {
+      retroarch_load_shader_preset();
+      shader_presets_need_reload = false;
+   }
+
    if (!string_is_empty(runtime_shader_preset))
       return runtime_shader_preset;
-   else if (!string_is_empty(settings->paths.path_shader))
+
+   if (!string_is_empty(settings->paths.path_shader))
       return settings->paths.path_shader;
+
    return NULL;
 }
 
diff --git a/retroarch.h b/retroarch.h
index 30f056a7fb..b83a6a901b 100644
--- a/retroarch.h
+++ b/retroarch.h
@@ -357,6 +357,8 @@ void retroarch_unset_shader_preset(void);
 
 char* retroarch_get_shader_preset(void);
 
+void retroarch_shader_presets_set_need_reload(void);
+
 bool retroarch_is_switching_display_mode(void);
 
 void retroarch_set_switching_display_mode(void);
@@ -949,8 +951,7 @@ enum display_metric_types
 
 enum display_flags
 {
-   GFX_CTX_FLAGS_NONE = 0,
-   GFX_CTX_FLAGS_GL_CORE_CONTEXT,
+   GFX_CTX_FLAGS_GL_CORE_CONTEXT = 0,
    GFX_CTX_FLAGS_MULTISAMPLING,
    GFX_CTX_FLAGS_CUSTOMIZABLE_SWAPCHAIN_IMAGES,
    GFX_CTX_FLAGS_HARD_SYNC,
diff --git a/ui/drivers/qt/shaderparamsdialog.cpp b/ui/drivers/qt/shaderparamsdialog.cpp
index 2dbc5a6602..cb57546c6b 100644
--- a/ui/drivers/qt/shaderparamsdialog.cpp
+++ b/ui/drivers/qt/shaderparamsdialog.cpp
@@ -484,13 +484,13 @@ void ShaderParamsDialog::onShaderLoadPresetClicked()
    filter = "Shader Preset (";
 
    /* NOTE: Maybe we should have a way to get a list of all shader types instead of hard-coding this? */
-   if (video_driver_test_all_flags(GFX_CTX_FLAGS_SHADERS_CG))
+   if (video_shader_is_supported(RARCH_SHADER_CG))
       filter += QLatin1Literal(" *") + file_path_str(FILE_PATH_CGP_EXTENSION);
 
-   if (video_driver_test_all_flags(GFX_CTX_FLAGS_SHADERS_GLSL))
+   if (video_shader_is_supported(RARCH_SHADER_GLSL))
       filter += QLatin1Literal(" *") + file_path_str(FILE_PATH_GLSLP_EXTENSION);
 
-   if (video_driver_test_all_flags(GFX_CTX_FLAGS_SHADERS_SLANG))
+   if (video_shader_is_supported(RARCH_SHADER_SLANG))
       filter += QLatin1Literal(" *") + file_path_str(FILE_PATH_SLANGP_EXTENSION);
 
    filter += ")";
@@ -617,13 +617,13 @@ void ShaderParamsDialog::onShaderAddPassClicked()
    filter = "Shader (";
 
    /* NOTE: Maybe we should have a way to get a list of all shader types instead of hard-coding this? */
-   if (video_driver_test_all_flags(GFX_CTX_FLAGS_SHADERS_CG))
+   if (video_shader_is_supported(RARCH_SHADER_CG))
       filter += QLatin1Literal(" *.cg");
 
-   if (video_driver_test_all_flags(GFX_CTX_FLAGS_SHADERS_GLSL))
+   if (video_shader_is_supported(RARCH_SHADER_GLSL))
       filter += QLatin1Literal(" *.glsl");
 
-   if (video_driver_test_all_flags(GFX_CTX_FLAGS_SHADERS_SLANG))
+   if (video_shader_is_supported(RARCH_SHADER_SLANG))
       filter += QLatin1Literal(" *.slang");
 
    filter += ")";