diff --git a/gfx/shader_cg.c b/gfx/shader_cg.c
index 65586c9b0e..2ab2f2d7de 100644
--- a/gfx/shader_cg.c
+++ b/gfx/shader_cg.c
@@ -810,7 +810,7 @@ bool gl_cg_init(const char *path)
    cgGLEnableProfile(cgFProf);
    cgGLEnableProfile(cgVProf);
 
-   if (path && strstr(path, ".cgp"))
+   if (path && strcmp(path_get_extension(path), "cgp") == 0)
    {
       if (!load_preset(path))
          return false;
diff --git a/gfx/shader_glsl.c b/gfx/shader_glsl.c
index 89c8113ca8..cd0380edce 100644
--- a/gfx/shader_glsl.c
+++ b/gfx/shader_glsl.c
@@ -342,9 +342,10 @@ static void print_linker_log(GLuint obj)
    free(info_log);
 }
 
-static bool compile_shader(GLuint shader, const char *program)
+static bool compile_shader(GLuint shader, const char *define, const char *program)
 {
-   pglShaderSource(shader, 1, &program, 0);
+   const char *source[] = { define, program };
+   pglShaderSource(shader, ARRAY_SIZE(source), source, NULL);
    pglCompileShader(shader);
 
    GLint status;
@@ -381,7 +382,7 @@ static GLuint compile_program(const char *vertex, const char *fragment, unsigned
    {
       RARCH_LOG("Found GLSL vertex shader.\n");
       GLuint shader = pglCreateShader(GL_VERTEX_SHADER);
-      if (!compile_shader(shader, vertex))
+      if (!compile_shader(shader, "#define VERTEX\n", vertex))
       {
          RARCH_ERR("Failed to compile vertex shader #%u\n", i);
          return false;
@@ -394,7 +395,7 @@ static GLuint compile_program(const char *vertex, const char *fragment, unsigned
    {
       RARCH_LOG("Found GLSL fragment shader.\n");
       GLuint shader = pglCreateShader(GL_FRAGMENT_SHADER);
-      if (!compile_shader(shader, fragment))
+      if (!compile_shader(shader, "#define FRAGMENT\n", fragment))
       {
          RARCH_ERR("Failed to compile fragment shader #%u\n", i);
          return false;
@@ -421,12 +422,36 @@ static GLuint compile_program(const char *vertex, const char *fragment, unsigned
    return prog;
 }
 
-static bool compile_programs(GLuint *gl_prog)
+static bool load_source_path(struct gfx_shader_pass *pass, const char *base, const char *path)
+{
+   char fullpath[PATH_MAX];
+   fill_pathname_resolve_relative(fullpath, base, path, sizeof(fullpath));
+   if (read_file(fullpath, (void**)&pass->source.xml.vertex) <= 0)
+      return false;
+
+   pass->source.xml.fragment = strdup(pass->source.xml.vertex);
+   return pass->source.xml.fragment && pass->source.xml.vertex;
+}
+
+static bool compile_programs(const char *base, GLuint *gl_prog)
 {
    for (unsigned i = 0; i < glsl_shader->passes; i++)
    {
-      const char *vertex   = glsl_shader->pass[i].source.xml.vertex;
-      const char *fragment = glsl_shader->pass[i].source.xml.fragment;
+      struct gfx_shader_pass *pass = &glsl_shader->pass[i];
+
+      // If we load from GLSLP (CGP),
+      // load the file here, and pretend
+      // we were really using XML all along.
+      if (*pass->source.cg && !load_source_path(pass, base, pass->source.cg))
+      {
+         RARCH_ERR("Failed to load GLSL shader: %s.\n", pass->source.cg);
+         return false;
+      }
+      *pass->source.cg = '\0';
+
+      const char *vertex   = pass->source.xml.vertex;
+      const char *fragment = pass->source.xml.fragment;
+
       gl_prog[i] = compile_program(vertex, fragment, i);
 
       if (!gl_prog[i])
@@ -595,9 +620,32 @@ bool gl_glsl_init(const char *path)
 
    if (path)
    {
-      if (!gfx_shader_read_xml(path, glsl_shader))
+      bool ret;
+      if (strcmp(path_get_extension(path), "glsl") == 0)
       {
-         RARCH_ERR("[GL]: Failed to parse XML shader.\n");
+         strlcpy(glsl_shader->pass[0].source.cg, path, sizeof(glsl_shader->pass[0].source.cg));
+         glsl_shader->passes = 1;
+         glsl_shader->modern = true;
+         ret = true;
+      }
+      else if (strcmp(path_get_extension(path), "glslp") == 0)
+      {
+         config_file_t *conf = config_file_new(path);
+         if (conf)
+         {
+            ret = gfx_shader_read_conf_cgp(conf, glsl_shader);
+            glsl_shader->modern = true;
+            config_file_free(conf);
+         }
+         else
+            ret = false;
+      }
+      else
+         ret = gfx_shader_read_xml(path, glsl_shader);
+
+      if (!ret)
+      {
+         RARCH_ERR("[GL]: Failed to parse GLSL shader.\n");
          return false;
       }
    }
@@ -630,7 +678,7 @@ bool gl_glsl_init(const char *path)
       return false;
    }
 
-   if (!compile_programs(&gl_program[1]))
+   if (!compile_programs(path, &gl_program[1]))
    {
       gl_glsl_free_shader();
       return false;
diff --git a/gfx/shader_parse.c b/gfx/shader_parse.c
index f16643eac5..9e900ab1cc 100644
--- a/gfx/shader_parse.c
+++ b/gfx/shader_parse.c
@@ -1063,7 +1063,7 @@ enum rarch_shader_type gfx_shader_parse_type(const char *path, enum rarch_shader
 
    if (strcmp(ext, "cg") == 0 || strcmp(ext, "cgp") == 0)
       return RARCH_SHADER_CG;
-   else if (strcmp(ext, "shader") == 0)
+   else if (strcmp(ext, "shader") == 0 || strcmp(ext, "glslp") == 0 || strcmp(ext, "glsl") == 0)
       return RARCH_SHADER_GLSL;
 
    return fallback;