diff --git a/swgl/build.rs b/swgl/build.rs
index ec5662fec0..82050e6e6c 100644
--- a/swgl/build.rs
+++ b/swgl/build.rs
@@ -8,14 +8,15 @@ extern crate glsl_to_cxx;
 use std::collections::HashSet;
 use std::fmt::Write;
 
-fn write_load_shader(shaders: &[&str]) {
+fn write_load_shader(shader_keys: &[&str]) {
+    let shaders: Vec<_> = shader_keys.iter().map(|s| s.replace(':', "_")).collect();
     let mut load_shader = String::new();
-    for s in shaders {
+    for s in &shaders {
         let _ = write!(load_shader, "#include \"{}.h\"\n", s);
     }
     load_shader.push_str("ProgramLoader load_shader(const char* name) {\n");
-    for s in shaders {
-        let _ = write!(load_shader, "  if (!strcmp(name, \"{}\")) {{ return {}_program::loader; }}\n", s, s);
+    for s in &shaders {
+        let _ = write!(load_shader, "  if (!strcmp(name, \"{0}\")) {{ return {0}_program::loader; }}\n", s);
     }
     load_shader.push_str("  return nullptr;\n}\n");
     std::fs::write(std::env::var("OUT_DIR").unwrap() + "/load_shader.h", load_shader).unwrap();
@@ -42,23 +43,21 @@ fn process_imports(shader_dir: &str, shader: &str, included: &mut HashSet<String
     }
 }
 
-fn translate_shader(shader: &str, shader_dir: &str) {
+fn translate_shader(shader_key: &str, shader_dir: &str) {
     let mut imported = String::new();
     imported.push_str("#define SWGL 1\n");
     imported.push_str("#define WR_MAX_VERTEX_TEXTURE_WIDTH 1024U\n");
-    let basename = if let Some(feature_start) = shader.find(char::is_uppercase) {
-        let feature_end = shader.rfind(char::is_uppercase).unwrap();
-        let features = shader[feature_start .. feature_end + 1].split('.');
-        for feature in features {
-            let _ = write!(imported, "#define WR_FEATURE_{}\n", feature);
-        }
-        &shader[0..feature_start]
-    } else {
-        shader
-    };
+
+    let mut features = shader_key.split(':');
+    let basename = features.next().unwrap();
+    for feature in features {
+        let _ = write!(imported, "#define WR_FEATURE_{}\n", feature);
+    }
 
     process_imports(shader_dir, basename, &mut HashSet::new(), &mut imported);
 
+    let shader = shader_key.replace(':', "_");
+
     let out_dir = std::env::var("OUT_DIR").unwrap();
     let imp_name = format!("{}/{}.c", out_dir, shader);
     std::fs::write(&imp_name, imported).unwrap();
@@ -96,42 +95,42 @@ fn translate_shader(shader: &str, shader_dir: &str) {
 }
 
 const WR_SHADERS: &'static [&'static str] = &[
-    "brush_blendALPHA_PASS",
+    "brush_blend:ALPHA_PASS",
     "brush_blend",
-    "brush_imageALPHA_PASS",
+    "brush_image:ALPHA_PASS",
     "brush_image",
-    "brush_imageREPETITION_ANTIALIASING_ALPHA_PASS",
-    "brush_imageREPETITION_ANTIALIASING",
-    "brush_linear_gradientALPHA_PASS",
-    "brush_linear_gradientDITHERING_ALPHA_PASS",
-    "brush_linear_gradientDITHERING",
+    "brush_image:REPETITION:ANTIALIASING:ALPHA_PASS",
+    "brush_image:REPETITION:ANTIALIASING",
+    "brush_linear_gradient:ALPHA_PASS",
+    "brush_linear_gradient:DITHERING:ALPHA_PASS",
+    "brush_linear_gradient:DITHERING",
     "brush_linear_gradient",
-    "brush_mix_blendALPHA_PASS",
+    "brush_mix_blend:ALPHA_PASS",
     "brush_mix_blend",
-    "brush_opacityALPHA_PASS",
-    "brush_radial_gradientALPHA_PASS",
-    "brush_radial_gradientDITHERING_ALPHA_PASS",
-    "brush_radial_gradientDITHERING",
+    "brush_opacity:ALPHA_PASS",
+    "brush_radial_gradient:ALPHA_PASS",
+    "brush_radial_gradient:DITHERING:ALPHA_PASS",
+    "brush_radial_gradient:DITHERING",
     "brush_radial_gradient",
-    "brush_solidALPHA_PASS",
+    "brush_solid:ALPHA_PASS",
     "brush_solid",
     "brush_yuv_image",
-    "brush_yuv_imageTEXTURE_2D_YUV_NV12",
-    "brush_yuv_imageYUV",
-    "brush_yuv_imageYUV_ALPHA_PASS",
-    "brush_yuv_imageYUV_INTERLEAVED",
-    "brush_yuv_imageYUV_NV12_ALPHA_PASS",
-    "brush_yuv_imageYUV_NV12",
-    "brush_yuv_imageYUV_PLANAR",
+    "brush_yuv_image:TEXTURE_2D:YUV:NV12",
+    "brush_yuv_image:YUV",
+    "brush_yuv_image:YUV:ALPHA_PASS",
+    "brush_yuv_image:YUV:INTERLEAVED",
+    "brush_yuv_image:YUV:NV12:ALPHA_PASS",
+    "brush_yuv_image:YUV:NV12",
+    "brush_yuv_image:YUV:PLANAR",
     "composite",
-    "compositeYUV",
-    "cs_blurALPHA_TARGET",
-    "cs_blurCOLOR_TARGET",
+    "composite:YUV",
+    "cs_blur:ALPHA_TARGET",
+    "cs_blur:COLOR_TARGET",
     "cs_border_segment",
     "cs_border_solid",
     "cs_clip_box_shadow",
     "cs_clip_image",
-    "cs_clip_rectangleFAST_PATH",
+    "cs_clip_rectangle:FAST_PATH",
     "cs_clip_rectangle",
     "cs_gradient",
     "cs_line_decoration",
@@ -140,10 +139,10 @@ const WR_SHADERS: &'static [&'static str] = &[
     "debug_color",
     "debug_font",
     "ps_split_composite",
-    "ps_text_runDUAL_SOURCE_BLENDING_ALPHA_PASS",
-    "ps_text_runGLYPH_TRANSFORM_ALPHA_PASS",
-    "ps_text_runDUAL_SOURCE_BLENDING_GLYPH_TRANSFORM_ALPHA_PASS",
-    "ps_text_runALPHA_PASS",
+    "ps_text_run:DUAL_SOURCE_BLENDING:ALPHA_PASS",
+    "ps_text_run:GLYPH_TRANSFORM:ALPHA_PASS",
+    "ps_text_run:DUAL_SOURCE_BLENDING:GLYPH_TRANSFORM:ALPHA_PASS",
+    "ps_text_run:ALPHA_PASS",
 ];
 
 fn main() {
diff --git a/swgl/src/swgl_fns.rs b/swgl/src/swgl_fns.rs
index 5192c8d031..556884c8e5 100644
--- a/swgl/src/swgl_fns.rs
+++ b/swgl/src/swgl_fns.rs
@@ -485,17 +485,10 @@ impl Gl for Context {
             const PREFIX: &'static str = "// shader: ";
             if let Some(start) = u.find(PREFIX) {
                 if let Some(end) = u[start ..].find('\n') {
-                    debug!(
-                        "shader name: {}",
-                        u[start + PREFIX.len() .. start + end].trim()
-                    );
+                    let name = u[start + PREFIX.len() .. start + end].trim();
+                    debug!("shader name: {}", name);
                     unsafe {
-                        let c_string = CString::new(
-                            u[start + PREFIX.len() .. start + end]
-                                .trim()
-                                .replace(" ", ""),
-                        )
-                        .unwrap();
+                        let c_string = CString::new(name).unwrap();
                         ShaderSourceByName(shader, c_string.as_ptr());
                         return;
                     }
diff --git a/webrender/src/device/gl.rs b/webrender/src/device/gl.rs
index 0638e4c68e..68f1bb644f 100644
--- a/webrender/src/device/gl.rs
+++ b/webrender/src/device/gl.rs
@@ -269,21 +269,18 @@ fn build_shader_prefix_string<F: FnMut(&str)>(
     // GLSL requires that the version number comes first.
     output(gl_version_string);
 
-    let mut features_key = String::new();
+    // Insert the shader name to make debugging easier.
+    let mut name_string = format!("// shader: {}", base_filename);
     for feat in features.lines() {
         const PREFIX: &'static str = "#define WR_FEATURE_";
         if let Some(i) = feat.find(PREFIX) {
             if i + PREFIX.len() < feat.len() {
-                if !features_key.is_empty() {
-                    features_key.push_str("_");
-                }
-                features_key.push_str(&feat[i + PREFIX.len() ..]);
+                name_string.push('_');
+                name_string.push_str(&feat[i + PREFIX.len() ..]);
             }
         }
     }
-
-    // Insert the shader name to make debugging easier.
-    let name_string = format!("// shader: {} {}\n", base_filename, features_key);
+    name_string.push('\n');
     output(&name_string);
 
     // Define a constant depending on whether we are compiling VS or FS.