diff --git a/gyp/shaders.gypi b/gyp/shaders.gypi
index 800487437..83d40a52f 100644
--- a/gyp/shaders.gypi
+++ b/gyp/shaders.gypi
@@ -4,31 +4,29 @@
       'target_name': 'shaders',
       'type': 'none',
       'hard_dependency': 1,
-      'actions': [
+
+      'sources': [
+        '<!@(find ../src/mbgl/shader -name "*.glsl")'
+      ],
+
+      'rules': [
         {
-          'action_name': 'Build Shaders',
-          'inputs': [
-            '../scripts/build-shaders.py',
-            '<!@(find ../src -name "*.glsl")'
-          ],
-          'outputs': [
-            '<(SHARED_INTERMEDIATE_DIR)/include/mbgl/shader/shaders.hpp',
-            '<(SHARED_INTERMEDIATE_DIR)/src/shader/shaders_gl.cpp',
-            '<(SHARED_INTERMEDIATE_DIR)/src/shader/shaders_gles2.cpp',
-          ],
-          'action': ['../scripts/build-shaders.py', '<(SHARED_INTERMEDIATE_DIR)', '<@(_inputs)'],
+          'rule_name': 'Build Shaders',
+          'message': 'Building shader',
+          'extension': 'glsl',
+          'inputs': [ '../scripts/build-shaders.py' ],
+          'outputs': [ '<(SHARED_INTERMEDIATE_DIR)/include/mbgl/shader/<(RULE_INPUT_ROOT).hpp' ],
+          'action': [ '../scripts/build-shaders.py', '<(RULE_INPUT_PATH)', '<(SHARED_INTERMEDIATE_DIR)/include/mbgl/shader/<(RULE_INPUT_ROOT).hpp' ],
+          'process_outputs_as_sources': 1,
         }
       ],
+
       'direct_dependent_settings': {
-        'sources': [
-            '<(SHARED_INTERMEDIATE_DIR)/include/mbgl/shader/shaders.hpp',
-            '<(SHARED_INTERMEDIATE_DIR)/src/shader/shaders_gl.cpp',
-            '<(SHARED_INTERMEDIATE_DIR)/src/shader/shaders_gles2.cpp'
-        ],
         'include_dirs': [
-          '<(SHARED_INTERMEDIATE_DIR)/include/',
+          '<(SHARED_INTERMEDIATE_DIR)/include',
         ]
       }
+
     },
   ]
 }
diff --git a/scripts/build-shaders.py b/scripts/build-shaders.py
index 3f3b77671..226c1a2ec 100755
--- a/scripts/build-shaders.py
+++ b/scripts/build-shaders.py
@@ -2,10 +2,8 @@
 
 import sys, re, os, errno
 
-
-output_dir = sys.argv[1]
-file_names = sys.argv[2:]
-
+input_file = sys.argv[1]
+output_file = sys.argv[2]
 
 def mkdir_p(path):
     try:
@@ -15,92 +13,40 @@ def mkdir_p(path):
             pass
         else: raise
 
-# Load all shaders
-shaders = {}
-for file_name in file_names:
-    parts = re.search('/(\w+)\.(vertex|fragment)\.glsl$', file_name)
-    if parts:
-        shader_name = parts.group(1)
-        shader_type = parts.group(2)
-        if not shader_name in shaders:
-            shaders[shader_name] = {}
-        with open(file_name, "r") as f:
-            shaders[shader_name][shader_type] = f.read()
+shader_name, shader_type, extension = os.path.basename(input_file).split('.')
 
+with open(input_file, "r") as f:
+    data = f.read()
 
-def write_header():
-    header = """// NOTE: DO NOT CHANGE THIS FILE. IT IS AUTOMATICALLY GENERATED.
+content = """// NOTE: DO NOT CHANGE THIS FILE. IT IS AUTOMATICALLY GENERATED.
 
-#ifndef MBGL_SHADER_SHADERS
-#define MBGL_SHADER_SHADERS
+#ifndef MBGL_SHADER_{NAME}_{TYPE}
+#define MBGL_SHADER_{NAME}_{TYPE}
 
 #include <mbgl/platform/gl.hpp>
 
-namespace mbgl {
-
-struct shader_source {
-    const GLchar *vertex;
-    const GLchar *fragment;
-};
-
-enum {
-%s
-    SHADER_COUNT
-};
-
-extern const shader_source shaders[SHADER_COUNT];
-
-}
-
-#endif
-""" % '\n'.join(['    %s_SHADER,' % name.upper() for name in shaders.keys()])
-    header_path = os.path.join(output_dir, 'include/mbgl/shader/shaders.hpp')
-    mkdir_p(os.path.dirname(header_path))
-    with open(header_path, 'w') as f: f.write(header)
-
-
-def write_source(shader_platform, prefix, suffix):
-    if shader_platform == 'gles2' or shader_platform == 'gles3':
-        # OpenGL ES
-        preamble = 'precision highp float;';
-    else:
-        # Desktop OpenGL
-        preamble = '#version 120';
-
-    shader_lines = [("""    {{
-        R"{name}_vert({preamble}\n{vertex}){name}_vert",
-        R"{name}_frag({preamble}\n{fragment}){name}_frag",
-    }},
-""").format(
-    name = shader,
-    preamble = preamble,
-    vertex = shaders[shader]['vertex'],
-    fragment = shaders[shader]['fragment']
-) for shader in shaders]
-
-    source = """// NOTE: DO NOT CHANGE THIS FILE. IT IS AUTOMATICALLY GENERATED.
-#include <mbgl/platform/gl.hpp>
-{prefix}
-#include <mbgl/shader/shaders.hpp>
-
 namespace mbgl {{
+namespace shaders {{
+namespace {name} {{
 
-const shader_source shaders[SHADER_COUNT] = {{
-{shaders}
-}};
+#ifdef GL_ES_VERSION_2_0
+constexpr const char* {type} = R"MBGL_SHADER(precision highp float;\n{data})MBGL_SHADER";
+#else
+constexpr const char* {type} = R"MBGL_SHADER(#version 120\n{data})MBGL_SHADER";
+#endif
 
-}}
-{suffix}
+}} // namespace {name}
+}} // namespace shaders
+}} // namespace mbgl
+
+#endif
 """.format(
-    prefix = prefix,
-    suffix = suffix,
-    shaders = ''.join(shader_lines)
+     name = shader_name,
+     NAME = shader_name.upper(),
+     type = shader_type,
+     TYPE = shader_type.upper(),
+     data = data,
 )
 
-    source_path = os.path.join(output_dir, 'src/shader/shaders_' + shader_platform + '.cpp')
-    mkdir_p(os.path.dirname(source_path))
-    with open(source_path, 'w') as f: f.write(source)
-
-write_header()
-write_source('gl', '#ifndef GL_ES_VERSION_2_0', '#endif')
-write_source('gles2', '#ifdef GL_ES_VERSION_2_0', '#endif')
+mkdir_p(os.path.dirname(output_file))
+with open(output_file, 'w') as f: f.write(content)
diff --git a/src/mbgl/shader/box_shader.cpp b/src/mbgl/shader/box_shader.cpp
index beb5e15f9..d9845ec36 100644
--- a/src/mbgl/shader/box_shader.cpp
+++ b/src/mbgl/shader/box_shader.cpp
@@ -1,5 +1,6 @@
 #include <mbgl/shader/box_shader.hpp>
-#include <mbgl/shader/shaders.hpp>
+#include <mbgl/shader/box.vertex.hpp>
+#include <mbgl/shader/box.fragment.hpp>
 #include <mbgl/platform/gl.hpp>
 
 #include <cstdio>
@@ -7,11 +8,7 @@
 using namespace mbgl;
 
 CollisionBoxShader::CollisionBoxShader()
-    : Shader(
-        "collisionbox",
-        shaders[BOX_SHADER].vertex,
-        shaders[BOX_SHADER].fragment
-    ) {
+    : Shader("collisionbox", shaders::box::vertex, shaders::box::fragment) {
     a_extrude = MBGL_CHECK_ERROR(glGetAttribLocation(program, "a_extrude"));
     a_data = MBGL_CHECK_ERROR(glGetAttribLocation(program, "a_data"));
 }
diff --git a/src/mbgl/shader/circle_shader.cpp b/src/mbgl/shader/circle_shader.cpp
index 8fa10191b..0af5bcf60 100644
--- a/src/mbgl/shader/circle_shader.cpp
+++ b/src/mbgl/shader/circle_shader.cpp
@@ -1,5 +1,6 @@
 #include <mbgl/shader/circle_shader.hpp>
-#include <mbgl/shader/shaders.hpp>
+#include <mbgl/shader/circle.vertex.hpp>
+#include <mbgl/shader/circle.fragment.hpp>
 #include <mbgl/platform/gl.hpp>
 
 #include <cstdio>
@@ -7,14 +8,10 @@
 using namespace mbgl;
 
 CircleShader::CircleShader()
-    : Shader(
-        "circle",
-        shaders[CIRCLE_SHADER].vertex,
-        shaders[CIRCLE_SHADER].fragment
-    ) {
+    : Shader("circle", shaders::circle::vertex, shaders::circle::fragment) {
 }
 
-void CircleShader::bind(GLbyte *offset) {
+void CircleShader::bind(GLbyte* offset) {
     MBGL_CHECK_ERROR(glEnableVertexAttribArray(a_pos));
     MBGL_CHECK_ERROR(glVertexAttribPointer(a_pos, 2, GL_SHORT, false, 4, offset));
 }
diff --git a/src/mbgl/shader/dot_shader.cpp b/src/mbgl/shader/dot_shader.cpp
index baec3678b..2eba489b6 100644
--- a/src/mbgl/shader/dot_shader.cpp
+++ b/src/mbgl/shader/dot_shader.cpp
@@ -1,20 +1,16 @@
 #include <mbgl/shader/dot_shader.hpp>
-#include <mbgl/shader/shaders.hpp>
+#include <mbgl/shader/dot.vertex.hpp>
+#include <mbgl/shader/dot.fragment.hpp>
 #include <mbgl/platform/gl.hpp>
 
 #include <cstdio>
 
 using namespace mbgl;
 
-DotShader::DotShader()
-: Shader(
-         "dot",
-         shaders[DOT_SHADER].vertex,
-         shaders[DOT_SHADER].fragment
-         ) {
+DotShader::DotShader() : Shader("dot", shaders::dot::vertex, shaders::dot::fragment) {
 }
 
-void DotShader::bind(GLbyte *offset) {
+void DotShader::bind(GLbyte* offset) {
     MBGL_CHECK_ERROR(glEnableVertexAttribArray(a_pos));
     MBGL_CHECK_ERROR(glVertexAttribPointer(a_pos, 2, GL_SHORT, false, 8, offset));
 }
diff --git a/src/mbgl/shader/icon_shader.cpp b/src/mbgl/shader/icon_shader.cpp
index a9b4be23e..bb43cb3e4 100644
--- a/src/mbgl/shader/icon_shader.cpp
+++ b/src/mbgl/shader/icon_shader.cpp
@@ -1,23 +1,19 @@
 #include <mbgl/shader/icon_shader.hpp>
-#include <mbgl/shader/shaders.hpp>
+#include <mbgl/shader/icon.vertex.hpp>
+#include <mbgl/shader/icon.fragment.hpp>
 #include <mbgl/platform/gl.hpp>
 
 #include <cstdio>
 
 using namespace mbgl;
 
-IconShader::IconShader()
-    : Shader(
-         "icon",
-         shaders[ICON_SHADER].vertex,
-         shaders[ICON_SHADER].fragment
-         ) {
+IconShader::IconShader() : Shader("icon", shaders::icon::vertex, shaders::icon::fragment) {
     a_offset = MBGL_CHECK_ERROR(glGetAttribLocation(program, "a_offset"));
     a_data1 = MBGL_CHECK_ERROR(glGetAttribLocation(program, "a_data1"));
     a_data2 = MBGL_CHECK_ERROR(glGetAttribLocation(program, "a_data2"));
 }
 
-void IconShader::bind(GLbyte *offset) {
+void IconShader::bind(GLbyte* offset) {
     const GLsizei stride = 16;
 
     MBGL_CHECK_ERROR(glEnableVertexAttribArray(a_pos));
diff --git a/src/mbgl/shader/line_shader.cpp b/src/mbgl/shader/line_shader.cpp
index 1e2306939..54bc6c114 100644
--- a/src/mbgl/shader/line_shader.cpp
+++ b/src/mbgl/shader/line_shader.cpp
@@ -1,21 +1,17 @@
 #include <mbgl/shader/line_shader.hpp>
-#include <mbgl/shader/shaders.hpp>
+#include <mbgl/shader/line.vertex.hpp>
+#include <mbgl/shader/line.fragment.hpp>
 #include <mbgl/platform/gl.hpp>
 
 #include <cstdio>
 
 using namespace mbgl;
 
-LineShader::LineShader()
-    : Shader(
-        "line",
-        shaders[LINE_SHADER].vertex,
-        shaders[LINE_SHADER].fragment
-    ) {
+LineShader::LineShader() : Shader("line", shaders::line::vertex, shaders::line::fragment) {
     a_data = MBGL_CHECK_ERROR(glGetAttribLocation(program, "a_data"));
 }
 
-void LineShader::bind(GLbyte *offset) {
+void LineShader::bind(GLbyte* offset) {
     MBGL_CHECK_ERROR(glEnableVertexAttribArray(a_pos));
     MBGL_CHECK_ERROR(glVertexAttribPointer(a_pos, 2, GL_SHORT, false, 8, offset + 0));
 
diff --git a/src/mbgl/shader/linepattern_shader.cpp b/src/mbgl/shader/linepattern_shader.cpp
index 4d416d506..9e71d0a9d 100644
--- a/src/mbgl/shader/linepattern_shader.cpp
+++ b/src/mbgl/shader/linepattern_shader.cpp
@@ -1,5 +1,6 @@
 #include <mbgl/shader/linepattern_shader.hpp>
-#include <mbgl/shader/shaders.hpp>
+#include <mbgl/shader/linepattern.vertex.hpp>
+#include <mbgl/shader/linepattern.fragment.hpp>
 #include <mbgl/platform/gl.hpp>
 
 #include <cstdio>
@@ -7,15 +8,11 @@
 using namespace mbgl;
 
 LinepatternShader::LinepatternShader()
-    : Shader(
-        "linepattern",
-         shaders[LINEPATTERN_SHADER].vertex,
-         shaders[LINEPATTERN_SHADER].fragment
-    ) {
+    : Shader("linepattern", shaders::linepattern::vertex, shaders::linepattern::fragment) {
     a_data = MBGL_CHECK_ERROR(glGetAttribLocation(program, "a_data"));
 }
 
-void LinepatternShader::bind(GLbyte *offset) {
+void LinepatternShader::bind(GLbyte* offset) {
     MBGL_CHECK_ERROR(glEnableVertexAttribArray(a_pos));
     MBGL_CHECK_ERROR(glVertexAttribPointer(a_pos, 2, GL_SHORT, false, 8, offset + 0));
 
diff --git a/src/mbgl/shader/linesdf_shader.cpp b/src/mbgl/shader/linesdf_shader.cpp
index 1a56bb106..df988bb33 100644
--- a/src/mbgl/shader/linesdf_shader.cpp
+++ b/src/mbgl/shader/linesdf_shader.cpp
@@ -1,5 +1,6 @@
 #include <mbgl/shader/linesdf_shader.hpp>
-#include <mbgl/shader/shaders.hpp>
+#include <mbgl/shader/linesdf.vertex.hpp>
+#include <mbgl/shader/linesdf.fragment.hpp>
 #include <mbgl/platform/gl.hpp>
 
 #include <cstdio>
@@ -7,15 +8,11 @@
 using namespace mbgl;
 
 LineSDFShader::LineSDFShader()
-    : Shader(
-        "line",
-        shaders[LINESDF_SHADER].vertex,
-        shaders[LINESDF_SHADER].fragment
-    ) {
+    : Shader("line", shaders::linesdf::vertex, shaders::linesdf::fragment) {
     a_data = MBGL_CHECK_ERROR(glGetAttribLocation(program, "a_data"));
 }
 
-void LineSDFShader::bind(GLbyte *offset) {
+void LineSDFShader::bind(GLbyte* offset) {
     MBGL_CHECK_ERROR(glEnableVertexAttribArray(a_pos));
     MBGL_CHECK_ERROR(glVertexAttribPointer(a_pos, 2, GL_SHORT, false, 8, offset + 0));
 
diff --git a/src/mbgl/shader/outline_shader.cpp b/src/mbgl/shader/outline_shader.cpp
index 74453468b..9cda1a110 100644
--- a/src/mbgl/shader/outline_shader.cpp
+++ b/src/mbgl/shader/outline_shader.cpp
@@ -1,5 +1,6 @@
 #include <mbgl/shader/outline_shader.hpp>
-#include <mbgl/shader/shaders.hpp>
+#include <mbgl/shader/outline.vertex.hpp>
+#include <mbgl/shader/outline.fragment.hpp>
 #include <mbgl/platform/gl.hpp>
 
 #include <cstdio>
@@ -7,14 +8,10 @@
 using namespace mbgl;
 
 OutlineShader::OutlineShader()
-    : Shader(
-        "outline",
-        shaders[OUTLINE_SHADER].vertex,
-        shaders[OUTLINE_SHADER].fragment
-    ) {
+    : Shader("outline", shaders::outline::vertex, shaders::outline::fragment) {
 }
 
-void OutlineShader::bind(GLbyte *offset) {
+void OutlineShader::bind(GLbyte* offset) {
     MBGL_CHECK_ERROR(glEnableVertexAttribArray(a_pos));
     MBGL_CHECK_ERROR(glVertexAttribPointer(a_pos, 2, GL_SHORT, false, 0, offset));
 }
diff --git a/src/mbgl/shader/pattern_shader.cpp b/src/mbgl/shader/pattern_shader.cpp
index d6ddab8e2..ef3f35c35 100644
--- a/src/mbgl/shader/pattern_shader.cpp
+++ b/src/mbgl/shader/pattern_shader.cpp
@@ -1,5 +1,6 @@
 #include <mbgl/shader/pattern_shader.hpp>
-#include <mbgl/shader/shaders.hpp>
+#include <mbgl/shader/pattern.vertex.hpp>
+#include <mbgl/shader/pattern.fragment.hpp>
 #include <mbgl/platform/gl.hpp>
 
 #include <cstdio>
@@ -9,8 +10,7 @@ using namespace mbgl;
 PatternShader::PatternShader()
     : Shader(
         "pattern",
-        shaders[PATTERN_SHADER].vertex,
-        shaders[PATTERN_SHADER].fragment
+        shaders::pattern::vertex, shaders::pattern::fragment
     ) {
 }
 
diff --git a/src/mbgl/shader/plain_shader.cpp b/src/mbgl/shader/plain_shader.cpp
index 52fef07c0..1817ffbc3 100644
--- a/src/mbgl/shader/plain_shader.cpp
+++ b/src/mbgl/shader/plain_shader.cpp
@@ -1,20 +1,16 @@
 #include <mbgl/shader/plain_shader.hpp>
-#include <mbgl/shader/shaders.hpp>
+#include <mbgl/shader/plain.vertex.hpp>
+#include <mbgl/shader/plain.fragment.hpp>
 #include <mbgl/platform/gl.hpp>
 
 #include <cstdio>
 
 using namespace mbgl;
 
-PlainShader::PlainShader()
-    : Shader(
-        "plain",
-        shaders[PLAIN_SHADER].vertex,
-        shaders[PLAIN_SHADER].fragment
-    ) {
+PlainShader::PlainShader() : Shader("plain", shaders::plain::vertex, shaders::plain::fragment) {
 }
 
-void PlainShader::bind(GLbyte *offset) {
+void PlainShader::bind(GLbyte* offset) {
     MBGL_CHECK_ERROR(glEnableVertexAttribArray(a_pos));
     MBGL_CHECK_ERROR(glVertexAttribPointer(a_pos, 2, GL_SHORT, false, 0, offset));
 }
diff --git a/src/mbgl/shader/raster_shader.cpp b/src/mbgl/shader/raster_shader.cpp
index b8496230b..aaf0bfd2a 100644
--- a/src/mbgl/shader/raster_shader.cpp
+++ b/src/mbgl/shader/raster_shader.cpp
@@ -1,5 +1,6 @@
 #include <mbgl/shader/raster_shader.hpp>
-#include <mbgl/shader/shaders.hpp>
+#include <mbgl/shader/raster.vertex.hpp>
+#include <mbgl/shader/raster.fragment.hpp>
 #include <mbgl/platform/gl.hpp>
 
 #include <cstdio>
@@ -7,14 +8,10 @@
 using namespace mbgl;
 
 RasterShader::RasterShader()
-    : Shader(
-         "raster",
-         shaders[RASTER_SHADER].vertex,
-         shaders[RASTER_SHADER].fragment
-         ) {
+    : Shader("raster", shaders::raster::vertex, shaders::raster::fragment) {
 }
 
-void RasterShader::bind(GLbyte *offset) {
+void RasterShader::bind(GLbyte* offset) {
     MBGL_CHECK_ERROR(glEnableVertexAttribArray(a_pos));
     MBGL_CHECK_ERROR(glVertexAttribPointer(a_pos, 2, GL_SHORT, false, 0, offset));
 }
diff --git a/src/mbgl/shader/sdf_shader.cpp b/src/mbgl/shader/sdf_shader.cpp
index 144ba6c47..97297a7ba 100644
--- a/src/mbgl/shader/sdf_shader.cpp
+++ b/src/mbgl/shader/sdf_shader.cpp
@@ -1,23 +1,19 @@
 #include <mbgl/shader/sdf_shader.hpp>
-#include <mbgl/shader/shaders.hpp>
+#include <mbgl/shader/sdf.vertex.hpp>
+#include <mbgl/shader/sdf.fragment.hpp>
 #include <mbgl/platform/gl.hpp>
 
 #include <cstdio>
 
 using namespace mbgl;
 
-SDFShader::SDFShader()
-    : Shader(
-        "sdf",
-        shaders[SDF_SHADER].vertex,
-        shaders[SDF_SHADER].fragment
-    ) {
+SDFShader::SDFShader() : Shader("sdf", shaders::sdf::vertex, shaders::sdf::fragment) {
     a_offset = MBGL_CHECK_ERROR(glGetAttribLocation(program, "a_offset"));
     a_data1 = MBGL_CHECK_ERROR(glGetAttribLocation(program, "a_data1"));
     a_data2 = MBGL_CHECK_ERROR(glGetAttribLocation(program, "a_data2"));
 }
 
-void SDFGlyphShader::bind(GLbyte *offset) {
+void SDFGlyphShader::bind(GLbyte* offset) {
     const int stride = 16;
 
     MBGL_CHECK_ERROR(glEnableVertexAttribArray(a_pos));
@@ -33,7 +29,7 @@ void SDFGlyphShader::bind(GLbyte *offset) {
     MBGL_CHECK_ERROR(glVertexAttribPointer(a_data2, 4, GL_UNSIGNED_BYTE, false, stride, offset + 12));
 }
 
-void SDFIconShader::bind(GLbyte *offset) {
+void SDFIconShader::bind(GLbyte* offset) {
     const int stride = 16;
 
     MBGL_CHECK_ERROR(glEnableVertexAttribArray(a_pos));