diff --git a/sources.cmake b/sources.cmake
index ba4868d71..d4f28ae4d 100644
--- a/sources.cmake
+++ b/sources.cmake
@@ -1,5 +1,5 @@
 # Modify this file to change the last-modified date when you add/remove a file.
-# This will then trigger a new cmake run automatically. 
+# This will then trigger a new cmake run automatically.
 file(GLOB_RECURSE STK_HEADERS RELATIVE ${CMAKE_CURRENT_SOURCE_DIR} "src/*.hpp")
 file(GLOB_RECURSE STK_SOURCES RELATIVE ${CMAKE_CURRENT_SOURCE_DIR} "src/*.cpp")
 file(GLOB_RECURSE STK_SHADERS RELATIVE ${CMAKE_CURRENT_SOURCE_DIR} "data/shaders/*")
diff --git a/src/graphics/2dutils.cpp b/src/graphics/2dutils.cpp
index 42fab11e0..87bf3a16e 100644
--- a/src/graphics/2dutils.cpp
+++ b/src/graphics/2dutils.cpp
@@ -24,7 +24,6 @@
 #include "graphics/shader.hpp"
 #include "graphics/shaders.hpp"
 #include "graphics/shared_gpu_objects.hpp"
-#include "graphics/shared_shaders.hpp"
 #include "graphics/texture_manager.hpp"
 #include "graphics/texture_shader.hpp"
 #include "utils/cpp2011.hpp"
@@ -44,7 +43,7 @@ public:
     Primitive2DList()
     {
         loadProgram(OBJECT, GL_VERTEX_SHADER, "primitive2dlist.vert",
-                            GET_SS(SharedTransparent));
+                            GL_FRAGMENT_SHADER, "transparent.frag");
         assignUniforms("custom_alpha");
         assignSamplerNames(0, "tex", ST_BILINEAR_FILTERED);
     }   // Primitive2DList
@@ -59,7 +58,7 @@ class UniformColoredTextureRectShader : public TextureShader<UniformColoredTextu
 public:
     UniformColoredTextureRectShader()
     {
-        loadProgram(OBJECT, GET_SS(SharedTexturedQuad),
+        loadProgram(OBJECT, GL_VERTEX_SHADER, "texturedquad.vert",
                     GL_FRAGMENT_SHADER, "uniformcolortexturedquad.frag");
 
         assignUniforms("center", "size", "texcenter", "texsize", "color");
@@ -76,7 +75,7 @@ class TextureRectShader : public TextureShader<TextureRectShader, 1,
 public:
     TextureRectShader()
     {
-        loadProgram(OBJECT, GET_SS(SharedTexturedQuad),
+        loadProgram(OBJECT, GL_VERTEX_SHADER, "texturedquad.vert",
                             GL_FRAGMENT_SHADER, "texturedquad.frag");
         assignUniforms("center", "size", "texcenter", "texsize");
 
@@ -92,7 +91,7 @@ public:
     ColoredRectShader()
     {
         loadProgram(OBJECT, GL_VERTEX_SHADER, "coloredquad.vert",
-                            GET_SS(SharedColoredQuad));
+                            GL_FRAGMENT_SHADER, "coloredquad.frag");
         assignUniforms("center", "size", "color");
     }   // ColoredRectShader
 };   // ColoredRectShader
diff --git a/src/graphics/irr_driver.cpp b/src/graphics/irr_driver.cpp
index 909420162..6b92b20c5 100644
--- a/src/graphics/irr_driver.cpp
+++ b/src/graphics/irr_driver.cpp
@@ -919,6 +919,7 @@ void IrrDriver::applyResolutionSettings()
     // FIXME: this load sequence is (mostly) duplicated from main.cpp!!
     // That's just error prone
     // (we're sure to update main.cpp at some point and forget this one...)
+    ShaderBase::updateShaders();
     VAOManager::getInstance()->kill();
     resetTextureTable();
     cleanUnicolorTextures();
@@ -929,7 +930,6 @@ void IrrDriver::applyResolutionSettings()
     }
     delete m_renderer;
     initDevice();
-    ShaderBase::updateShaders();
 
     font_manager = new FontManager();
     font_manager->loadFonts();
diff --git a/src/graphics/lighting_passes.cpp b/src/graphics/lighting_passes.cpp
index cf321c176..55675ed8d 100644
--- a/src/graphics/lighting_passes.cpp
+++ b/src/graphics/lighting_passes.cpp
@@ -26,8 +26,7 @@
 #include "graphics/post_processing.hpp"
 #include "graphics/rtts.hpp"
 #include "graphics/shaders.hpp"
-#include "graphics/shadow_matrices.hpp"
-#include "graphics/shared_shaders.hpp"
+#include "graphics/shadow_matrices.hpp"
 #include "modes/world.hpp"
 #include "tracks/track.hpp"
 #include "utils/profiler.hpp"
@@ -64,7 +63,7 @@ class FogShader : public TextureShader<FogShader, 1, float, core::vector3df>
 public:
     FogShader()
     {
-        loadProgram(OBJECT, GET_SS(SharedScreenQuad),
+        loadProgram(OBJECT, GL_VERTEX_SHADER, "screenquad.vert",
                             GL_FRAGMENT_SHADER, "fog.frag");
         assignUniforms("density", "col");
         assignSamplerNames(0, "tex", ST_NEAREST_FILTERED);
@@ -191,12 +190,12 @@ public:
     {
         if (CVS->isAMDVertexShaderLayerUsable())
         {
-            loadProgram(OBJECT, GET_SS(SharedSlicedScreenQuad),
+            loadProgram(OBJECT, GL_VERTEX_SHADER, "slicedscreenquad.vert",
                                 GL_FRAGMENT_SHADER, "rh.frag");
         }
         else
         {
-            loadProgram(OBJECT, GET_SS(SharedSlicedScreenQuad),
+            loadProgram(OBJECT, GL_VERTEX_SHADER, "slicedscreenquad.vert",
                                 GL_GEOMETRY_SHADER, "rhpassthrough.geom",
                                 GL_FRAGMENT_SHADER, "rh.frag");
         }
@@ -239,7 +238,7 @@ class GlobalIlluminationReconstructionShader
 public:
     GlobalIlluminationReconstructionShader()
     {
-        loadProgram(OBJECT, GET_SS(SharedScreenQuad),
+        loadProgram(OBJECT, GL_VERTEX_SHADER, "screenquad.vert",
                             GL_FRAGMENT_SHADER, "gi.frag");
 
         assignUniforms("rh_matrix", "inv_rh_matrix", "extents");
@@ -272,7 +271,7 @@ class IBLShader : public TextureShader<IBLShader, 3>
 public:
     IBLShader()
     {
-        loadProgram(OBJECT, GET_SS(SharedScreenQuad),
+        loadProgram(OBJECT, GL_VERTEX_SHADER, "screenquad.vert",
                             GL_FRAGMENT_SHADER, "IBL.frag");
         assignUniforms();
         assignSamplerNames(0, "ntex",  ST_NEAREST_FILTERED,
@@ -287,7 +286,7 @@ class DegradedIBLShader : public TextureShader<DegradedIBLShader, 1>
 public:
     DegradedIBLShader()
     {
-        loadProgram(OBJECT, GET_SS(SharedScreenQuad),
+        loadProgram(OBJECT, GL_VERTEX_SHADER, "screenquad.vert",
                             GL_FRAGMENT_SHADER, "degraded_ibl.frag");
         assignUniforms();
         assignSamplerNames(0, "ntex", ST_NEAREST_FILTERED);
@@ -302,7 +301,7 @@ class ShadowedSunLightShaderPCF : public TextureShader<ShadowedSunLightShaderPCF
 public:
     ShadowedSunLightShaderPCF()
     {
-        loadProgram(OBJECT, GET_SS(SharedScreenQuad),
+        loadProgram(OBJECT, GL_VERTEX_SHADER, "screenquad.vert",
                             GL_FRAGMENT_SHADER, "sunlightshadow.frag");
 
         // Use 8 to circumvent a catalyst bug when binding sampler
@@ -336,7 +335,7 @@ class ShadowedSunLightShaderESM : public TextureShader<ShadowedSunLightShaderESM
 public:
     ShadowedSunLightShaderESM()
     {
-        loadProgram(OBJECT, GET_SS(SharedScreenQuad),
+        loadProgram(OBJECT, GL_VERTEX_SHADER, "screenquad.vert",
                             GL_FRAGMENT_SHADER, "sunlightshadowesm.frag");
 
         // Use 8 to circumvent a catalyst bug when binding sampler
@@ -369,7 +368,7 @@ class SunLightShader : public TextureShader<SunLightShader, 2,
 public:
     SunLightShader()
     {
-        loadProgram(OBJECT, GET_SS(SharedScreenQuad),
+        loadProgram(OBJECT, GL_VERTEX_SHADER, "screenquad.vert",
                             GL_FRAGMENT_SHADER, "sunlight.frag");
 
         assignSamplerNames(0, "ntex", ST_NEAREST_FILTERED,
diff --git a/src/graphics/materials.hpp b/src/graphics/materials.hpp
index f51aee83f..239a97ad1 100644
--- a/src/graphics/materials.hpp
+++ b/src/graphics/materials.hpp
@@ -22,18 +22,18 @@
 
 #include "graphics/shader.hpp"
 #include "graphics/shaders.hpp"
-#include "graphics/shared_shaders.hpp"
 #include "graphics/stk_mesh.hpp"
 #include "graphics/vao_manager.hpp"
 
+
 // ============================================================================
 class InstancedObjectPass1Shader : public TextureShader<InstancedObjectPass1Shader, 1>
 {
 public:
     InstancedObjectPass1Shader()
     {
-        loadProgram(OBJECT, GET_SS(SharedInstanced),
-                            GET_SS(SharedInstancedPass1));
+        loadProgram(OBJECT, GL_VERTEX_SHADER, "instanced_object_pass.vert",
+                            GL_FRAGMENT_SHADER, "instanced_object_pass1.frag");
 
         assignUniforms();
         assignSamplerNames(0, "glosstex", ST_TRILINEAR_ANISOTROPIC_FILTERED);
@@ -46,8 +46,8 @@ class InstancedObjectRefPass1Shader : public TextureShader<InstancedObjectRefPas
 public:
     InstancedObjectRefPass1Shader()
     {
-        loadProgram(OBJECT, GET_SS(SharedInstanced),
-                            GET_SS(SharedInstancedRefPass1));
+        loadProgram(OBJECT, GL_VERTEX_SHADER, "instanced_object_pass.vert",
+                            GL_FRAGMENT_SHADER, "instanced_objectref_pass1.frag");
 
         assignUniforms();
         assignSamplerNames(0, "tex", ST_TRILINEAR_ANISOTROPIC_FILTERED,
@@ -64,7 +64,7 @@ class ObjectRefPass2Shader : public TextureShader<ObjectRefPass2Shader, 6,
 public:
     ObjectRefPass2Shader()
     {
-        loadProgram(OBJECT, GET_SS(SharedObject),
+        loadProgram(OBJECT, GL_VERTEX_SHADER, "object_pass.vert",
                             GL_FRAGMENT_SHADER, "objectref_pass2.frag");
         assignUniforms("ModelMatrix", "texture_trans", "color_change");
         assignSamplerNames(0, "DiffuseMap", ST_NEAREST_FILTERED,
@@ -82,8 +82,8 @@ class InstancedObjectPass2Shader : public TextureShader<InstancedObjectPass2Shad
 public:
     InstancedObjectPass2Shader()
     {
-        loadProgram(OBJECT, GET_SS(SharedInstanced),
-                            GET_SS(SharedInstancedPass2));
+        loadProgram(OBJECT, GL_VERTEX_SHADER, "instanced_object_pass.vert",
+                            GL_FRAGMENT_SHADER, "instanced_object_pass2.frag");
         assignUniforms();
         assignSamplerNames(0, "DiffuseMap", ST_NEAREST_FILTERED,
                            1, "SpecularMap", ST_NEAREST_FILTERED,
@@ -100,8 +100,8 @@ class InstancedObjectRefPass2Shader : public TextureShader<InstancedObjectRefPas
 public:
     InstancedObjectRefPass2Shader()
     {
-        loadProgram(OBJECT, GET_SS(SharedInstanced),
-                            GET_SS(SharedInstancedRefPass2));
+        loadProgram(OBJECT, GL_VERTEX_SHADER, "instanced_object_pass.vert",
+                            GL_FRAGMENT_SHADER, "instanced_objectref_pass2.frag");
         assignUniforms();
         assignSamplerNames(0, "DiffuseMap", ST_NEAREST_FILTERED,
                            1, "SpecularMap", ST_NEAREST_FILTERED,
@@ -150,12 +150,12 @@ public:
             return;
         if (CVS->isAMDVertexShaderLayerUsable())
         {
-            loadProgram(OBJECT, GET_SS(SharedInstancedShadow),
+            loadProgram(OBJECT, GL_VERTEX_SHADER, "instanciedshadow.vert",
                                 GL_FRAGMENT_SHADER, "shadow.frag");
         }
         else
         {
-            loadProgram(OBJECT, GET_SS(SharedInstancedShadow),
+            loadProgram(OBJECT, GL_VERTEX_SHADER, "instanciedshadow.vert",
                                 GL_GEOMETRY_SHADER, "instanced_shadow.geom",
                                 GL_FRAGMENT_SHADER, "shadow.frag");
         }
@@ -222,7 +222,7 @@ class SphereMapShader : public TextureShader<SphereMapShader, 4, core::matrix4,
 public:
     SphereMapShader()
     {
-        loadProgram(OBJECT, GET_SS(SharedObject),
+        loadProgram(OBJECT, GL_VERTEX_SHADER, "object_pass.vert",
                             GL_FRAGMENT_SHADER, "objectpass_spheremap.frag");
         assignUniforms("ModelMatrix", "InverseModelMatrix");
         assignSamplerNames(0, "DiffuseMap", ST_NEAREST_FILTERED,
@@ -239,7 +239,7 @@ public:
     InstancedSphereMapShader()
     {
         loadProgram(OBJECT,
-                    GET_SS(SharedInstanced),
+                    GL_VERTEX_SHADER, "instanced_object_pass.vert",
                     GL_FRAGMENT_SHADER, "instanced_objectpass_spheremap.frag");
         assignUniforms();
         assignSamplerNames(0, "DiffuseMap", ST_NEAREST_FILTERED,
@@ -255,7 +255,7 @@ class SplattingShader : public TextureShader<SplattingShader, 8, core::matrix4>
 public:
     SplattingShader()
     {
-        loadProgram(OBJECT, GET_SS(SharedObject),
+        loadProgram(OBJECT, GL_VERTEX_SHADER, "object_pass.vert",
                             GL_FRAGMENT_SHADER, "splatting.frag");
         assignUniforms("ModelMatrix");
 
@@ -277,7 +277,7 @@ class ObjectRefPass1Shader : public TextureShader<ObjectRefPass1Shader, 2, core:
 public:
     ObjectRefPass1Shader()
     {
-        loadProgram(OBJECT, GET_SS(SharedObject),
+        loadProgram(OBJECT, GL_VERTEX_SHADER, "object_pass.vert",
                             GL_FRAGMENT_SHADER, "objectref_pass1.frag");
         assignUniforms("ModelMatrix", "InverseModelMatrix", "texture_trans");
         assignSamplerNames(0, "tex", ST_TRILINEAR_ANISOTROPIC_FILTERED,
@@ -293,7 +293,7 @@ class NormalMapShader : public TextureShader<NormalMapShader, 2, core::matrix4,
 public:
     NormalMapShader()
     {
-        loadProgram(OBJECT, GET_SS(SharedObject),
+        loadProgram(OBJECT, GL_VERTEX_SHADER, "object_pass.vert",
                             GL_FRAGMENT_SHADER, "normalmap.frag");
         assignUniforms("ModelMatrix", "InverseModelMatrix");
         assignSamplerNames(0, "normalMap", ST_TRILINEAR_ANISOTROPIC_FILTERED,
@@ -308,8 +308,8 @@ class InstancedNormalMapShader : public TextureShader<InstancedNormalMapShader,
 public:
     InstancedNormalMapShader()
     {
-        loadProgram(OBJECT, GET_SS(SharedInstanced),
-                            GET_SS(SharedInstancedNormal));
+        loadProgram(OBJECT, GL_VERTEX_SHADER, "instanced_object_pass.vert",
+                            GL_FRAGMENT_SHADER, "instanced_normalmap.frag");
         assignUniforms();
         assignSamplerNames(0, "normalMap", ST_TRILINEAR_ANISOTROPIC_FILTERED,
                            1, "glossMap", ST_TRILINEAR_ANISOTROPIC_FILTERED);
@@ -323,7 +323,7 @@ class ObjectUnlitShader : public TextureShader<ObjectUnlitShader, 4, core::matri
 public:
     ObjectUnlitShader()
     {
-        loadProgram(OBJECT, GET_SS(SharedObject),
+        loadProgram(OBJECT, GL_VERTEX_SHADER, "object_pass.vert",
                             GL_FRAGMENT_SHADER, "object_unlit.frag");
         assignUniforms("ModelMatrix", "texture_trans");
         assignSamplerNames(0, "DiffuseMap", ST_NEAREST_FILTERED,
@@ -339,8 +339,8 @@ class InstancedObjectUnlitShader : public TextureShader<InstancedObjectUnlitShad
 public:
     InstancedObjectUnlitShader()
     {
-        loadProgram(OBJECT, GET_SS(SharedInstanced),
-                            GET_SS(SharedInstancedUnlit));
+        loadProgram(OBJECT, GL_VERTEX_SHADER, "instanced_object_pass.vert",
+                            GL_FRAGMENT_SHADER, "instanced_object_unlit.frag");
         assignUniforms();
         assignSamplerNames(0, "DiffuseMap", ST_NEAREST_FILTERED,
                            1, "SpecularMap", ST_NEAREST_FILTERED,
@@ -390,12 +390,12 @@ public:
             return;
         if (CVS->isAMDVertexShaderLayerUsable())
         {
-            loadProgram(OBJECT,GET_SS(SharedInstancedShadow),
+            loadProgram(OBJECT,GL_VERTEX_SHADER, "instanciedshadow.vert",
                                GL_FRAGMENT_SHADER, "instanced_shadowref.frag");
         }
         else
         {
-            loadProgram(OBJECT,GET_SS(SharedInstancedShadow),
+            loadProgram(OBJECT,GL_VERTEX_SHADER, "instanciedshadow.vert",
                                GL_GEOMETRY_SHADER, "instanced_shadow.geom",
                                GL_FRAGMENT_SHADER, "instanced_shadowref.frag");
         }
@@ -442,9 +442,9 @@ public:
     NormalVisualizer()
     {
 #if !defined(USE_GLES2)
-        loadProgram(OBJECT, GET_SS(SharedInstanced),
+        loadProgram(OBJECT, GL_VERTEX_SHADER, "instanced_object_pass.vert",
                             GL_GEOMETRY_SHADER, "normal_visualizer.geom",
-                            GET_SS(SharedColoredQuad));
+                            GL_FRAGMENT_SHADER, "coloredquad.frag");
         assignUniforms("color");
 #endif
     }   // NormalVisualizer
@@ -473,8 +473,8 @@ class InstancedGrassPass1Shader : public TextureShader<InstancedGrassPass1Shader
 public:
     InstancedGrassPass1Shader()
     {
-        loadProgram(OBJECT, GET_SS(SharedInstancedGrass),
-                            GET_SS(SharedInstancedRefPass1));
+        loadProgram(OBJECT, GL_VERTEX_SHADER, "instanced_grass.vert",
+                            GL_FRAGMENT_SHADER, "instanced_objectref_pass1.frag");
         assignUniforms("windDir");
         assignSamplerNames(0, "tex", ST_TRILINEAR_ANISOTROPIC_FILTERED,
                            1, "glosstex", ST_TRILINEAR_ANISOTROPIC_FILTERED);
@@ -566,8 +566,8 @@ class InstancedGrassPass2Shader : public TextureShader<InstancedGrassPass2Shader
 public:
     InstancedGrassPass2Shader()
     {
-        loadProgram(OBJECT, GET_SS(SharedInstancedGrass),
-                            GET_SS(SharedInstancedGrassPass2));
+        loadProgram(OBJECT, GL_VERTEX_SHADER, "instanced_grass.vert",
+                            GL_FRAGMENT_SHADER, "instanced_grass_pass2.frag");
         assignUniforms("windDir");
         assignSamplerNames(0, "DiffuseMap", ST_NEAREST_FILTERED,
                            1, "SpecularMap", ST_NEAREST_FILTERED,
@@ -586,7 +586,7 @@ class DetailedObjectPass2Shader : public TextureShader<DetailedObjectPass2Shader
 public:
     DetailedObjectPass2Shader()
     {
-        loadProgram(OBJECT, GET_SS(SharedObject),
+        loadProgram(OBJECT, GL_VERTEX_SHADER, "object_pass.vert",
                             GL_FRAGMENT_SHADER, "detailed_object_pass2.frag");
         assignUniforms("ModelMatrix");
         assignSamplerNames(0, "DiffuseMap", ST_NEAREST_FILTERED,
@@ -605,7 +605,7 @@ public:
     InstancedDetailedObjectPass2Shader()
     {
         loadProgram(OBJECT,
-                   GET_SS(SharedInstanced),
+                   GL_VERTEX_SHADER, "instanced_object_pass.vert",
                    GL_FRAGMENT_SHADER, "instanced_detailed_object_pass2.frag");
         assignUniforms();
         assignSamplerNames(0, "DiffuseMap", ST_NEAREST_FILTERED,
@@ -626,8 +626,8 @@ public:
     SkinnedPass1Shader()
     {
         if (!CVS->supportsHardwareSkinning()) return;
-        loadProgram(OBJECT, GET_SS(SharedSkinning),
-                            GET_SS(SharedPass1));
+        loadProgram(OBJECT, GL_VERTEX_SHADER, "skinning.vert",
+                            GL_FRAGMENT_SHADER, "object_pass1.frag");
         assignUniforms("ModelMatrix", "InverseModelMatrix", "skinning_offset");
         assignSamplerNames(0, "tex", ST_TRILINEAR_ANISOTROPIC_FILTERED);
     }   // SkinnedPass1Shader
@@ -640,8 +640,8 @@ public:
     InstancedSkinnedPass1Shader()
     {
         if (!CVS->supportsHardwareSkinning()) return;
-        loadProgram(OBJECT, GET_SS(SharedInstancedSkinning),
-                            GET_SS(SharedInstancedPass1));
+        loadProgram(OBJECT, GL_VERTEX_SHADER, "instanced_skinning.vert",
+                            GL_FRAGMENT_SHADER, "instanced_object_pass1.frag");
         assignUniforms();
         assignSamplerNames(0, "glosstex", ST_TRILINEAR_ANISOTROPIC_FILTERED);
     }   // InstancedSkinnedPass1Shader
@@ -656,7 +656,7 @@ public:
     SkinnedPass2Shader()
     {
         if (!CVS->supportsHardwareSkinning()) return;
-        loadProgram(OBJECT, GET_SS(SharedSkinning),
+        loadProgram(OBJECT, GL_VERTEX_SHADER, "skinning.vert",
                             GL_FRAGMENT_SHADER, "object_pass2.frag");
         assignUniforms("ModelMatrix", "texture_trans", "color_change",
                        "skinning_offset");
@@ -676,8 +676,8 @@ public:
     InstancedSkinnedPass2Shader()
     {
         if (!CVS->supportsHardwareSkinning()) return;
-        loadProgram(OBJECT, GET_SS(SharedInstancedSkinning),
-                            GET_SS(SharedInstancedPass2));
+        loadProgram(OBJECT, GL_VERTEX_SHADER, "instanced_skinning.vert",
+                            GL_FRAGMENT_SHADER, "instanced_object_pass2.frag");
         assignUniforms();
         assignSamplerNames(0, "DiffuseMap", ST_NEAREST_FILTERED,
                            1, "SpecularMap", ST_NEAREST_FILTERED,
@@ -698,7 +698,7 @@ public:
     SkinnedRefPass1Shader()
     {
         if (!CVS->supportsHardwareSkinning()) return;
-        loadProgram(OBJECT, GET_SS(SharedSkinning),
+        loadProgram(OBJECT, GL_VERTEX_SHADER, "skinning.vert",
                             GL_FRAGMENT_SHADER, "objectref_pass1.frag");
         assignUniforms("ModelMatrix", "InverseModelMatrix", "texture_trans",
                        "skinning_offset");
@@ -714,8 +714,8 @@ public:
     InstancedSkinnedRefPass1Shader()
     {
         if (!CVS->supportsHardwareSkinning()) return;
-        loadProgram(OBJECT, GET_SS(SharedInstancedSkinning),
-                            GET_SS(SharedInstancedRefPass1));
+        loadProgram(OBJECT, GL_VERTEX_SHADER, "instanced_skinning.vert",
+                            GL_FRAGMENT_SHADER, "instanced_objectref_pass1.frag");
         assignUniforms();
         assignSamplerNames(0, "tex", ST_TRILINEAR_ANISOTROPIC_FILTERED,
                            1, "glosstex", ST_TRILINEAR_ANISOTROPIC_FILTERED);
@@ -732,7 +732,7 @@ public:
     SkinnedRefPass2Shader()
     {
         if (!CVS->supportsHardwareSkinning()) return;
-        loadProgram(OBJECT, GET_SS(SharedSkinning),
+        loadProgram(OBJECT, GL_VERTEX_SHADER, "skinning.vert",
                             GL_FRAGMENT_SHADER, "objectref_pass2.frag");
         assignUniforms("ModelMatrix", "texture_trans", "color_change",
                        "skinning_offset");
@@ -752,8 +752,8 @@ public:
     InstancedSkinnedRefPass2Shader()
     {
         if (!CVS->supportsHardwareSkinning()) return;
-        loadProgram(OBJECT, GET_SS(SharedInstancedSkinning),
-                            GET_SS(SharedInstancedRefPass2));
+        loadProgram(OBJECT, GL_VERTEX_SHADER, "instanced_skinning.vert",
+                            GL_FRAGMENT_SHADER, "instanced_objectref_pass2.frag");
         assignUniforms();
         assignSamplerNames(0, "DiffuseMap", ST_NEAREST_FILTERED,
                            1, "SpecularMap", ST_NEAREST_FILTERED,
@@ -773,7 +773,7 @@ public:
     SkinnedUnlitShader()
     {
         if (!CVS->supportsHardwareSkinning()) return;
-        loadProgram(OBJECT, GET_SS(SharedSkinning),
+        loadProgram(OBJECT, GL_VERTEX_SHADER, "skinning.vert",
                             GL_FRAGMENT_SHADER, "object_unlit.frag");
         assignUniforms("ModelMatrix", "texture_trans", "skinning_offset");
         assignSamplerNames(0, "DiffuseMap", ST_NEAREST_FILTERED,
@@ -790,8 +790,8 @@ public:
     InstancedSkinnedUnlitShader()
     {
         if (!CVS->supportsHardwareSkinning()) return;
-        loadProgram(OBJECT, GET_SS(SharedInstancedSkinning),
-                            GET_SS(SharedInstancedUnlit));
+        loadProgram(OBJECT, GL_VERTEX_SHADER, "instanced_skinning.vert",
+                            GL_FRAGMENT_SHADER, "instanced_object_unlit.frag");
         assignUniforms();
         assignSamplerNames(0, "DiffuseMap", ST_NEAREST_FILTERED,
                            1, "SpecularMap", ST_NEAREST_FILTERED,
@@ -809,7 +809,7 @@ public:
     SkinnedNormalMapShader()
     {
         if (!CVS->supportsHardwareSkinning()) return;
-        loadProgram(OBJECT, GET_SS(SharedSkinning),
+        loadProgram(OBJECT, GL_VERTEX_SHADER, "skinning.vert",
                             GL_FRAGMENT_SHADER, "normalmap.frag");
         assignUniforms("ModelMatrix", "InverseModelMatrix", "skinning_offset");
         assignSamplerNames(0, "normalMap", ST_TRILINEAR_ANISOTROPIC_FILTERED,
@@ -824,8 +824,8 @@ public:
     InstancedSkinnedNormalMapShader()
     {
         if (!CVS->supportsHardwareSkinning()) return;
-        loadProgram(OBJECT, GET_SS(SharedInstancedSkinning),
-                            GET_SS(SharedInstancedNormal));
+        loadProgram(OBJECT, GL_VERTEX_SHADER, "instanced_skinning.vert",
+                            GL_FRAGMENT_SHADER, "instanced_normalmap.frag");
         assignUniforms();
         assignSamplerNames(0, "normalMap", ST_TRILINEAR_ANISOTROPIC_FILTERED,
                            1, "glossMap", ST_TRILINEAR_ANISOTROPIC_FILTERED);
@@ -871,12 +871,12 @@ public:
             return;
         if (CVS->isAMDVertexShaderLayerUsable())
         {
-            loadProgram(OBJECT, GET_SS(SharedInstancedSkinningShadow),
+            loadProgram(OBJECT, GL_VERTEX_SHADER, "instanced_skinning_shadow.vert",
                                 GL_FRAGMENT_SHADER, "shadow.frag");
         }
         else
         {
-            loadProgram(OBJECT, GET_SS(SharedInstancedSkinningShadow),
+            loadProgram(OBJECT, GL_VERTEX_SHADER, "instanced_skinning_shadow.vert",
                                 GL_GEOMETRY_SHADER, "instanced_shadow.geom",
                                 GL_FRAGMENT_SHADER, "shadow.frag");
         }
@@ -926,12 +926,12 @@ public:
             return;
         if (CVS->isAMDVertexShaderLayerUsable())
         {
-            loadProgram(OBJECT, GET_SS(SharedInstancedSkinningShadow),
+            loadProgram(OBJECT, GL_VERTEX_SHADER, "instanced_skinning_shadow.vert",
                                 GL_FRAGMENT_SHADER, "instanced_shadowref.frag");
         }
         else
         {
-            loadProgram(OBJECT, GET_SS(SharedInstancedSkinningShadow),
+            loadProgram(OBJECT, GL_VERTEX_SHADER, "instanced_skinning_shadow.vert",
                                 GL_GEOMETRY_SHADER, "instanced_shadow.geom",
                                 GL_FRAGMENT_SHADER, "instanced_shadowref.frag");
         }
diff --git a/src/graphics/post_processing.cpp b/src/graphics/post_processing.cpp
index da6e1f8bb..3ba0be240 100644
--- a/src/graphics/post_processing.cpp
+++ b/src/graphics/post_processing.cpp
@@ -30,7 +30,6 @@
 #include "graphics/rtts.hpp"
 #include "graphics/shaders.hpp"
 #include "graphics/shared_gpu_objects.hpp"
-#include "graphics/shared_shaders.hpp"
 #include "graphics/stk_mesh_scene_node.hpp"
 #include "graphics/texture_manager.hpp"
 #include "graphics/weather.hpp"
@@ -57,7 +56,7 @@ class Gaussian3HBlurShader : public TextureShader<Gaussian3HBlurShader, 1,
 public:
     Gaussian3HBlurShader()
     {
-        loadProgram(OBJECT, GET_SS(SharedScreenQuad),
+        loadProgram(OBJECT, GL_VERTEX_SHADER, "screenquad.vert",
                             GL_FRAGMENT_SHADER, "gaussian3h.frag");
         assignUniforms("pixel");
 
@@ -99,7 +98,7 @@ class Gaussian6VBlurShader : public TextureShader<Gaussian6VBlurShader, 1,
 public:
     Gaussian6VBlurShader()
     {
-        loadProgram(OBJECT, GET_SS(SharedScreenQuad),
+        loadProgram(OBJECT, GL_VERTEX_SHADER, "screenquad.vert",
                             GL_FRAGMENT_SHADER, "gaussian6v.frag");
         assignUniforms("pixel", "sigma");
 
@@ -121,7 +120,7 @@ class Gaussian3VBlurShader : public TextureShader<Gaussian3VBlurShader, 1,
 public:
     Gaussian3VBlurShader()
     {
-        loadProgram(OBJECT, GET_SS(SharedScreenQuad),
+        loadProgram(OBJECT, GL_VERTEX_SHADER, "screenquad.vert",
                             GL_FRAGMENT_SHADER, "gaussian3v.frag");
         assignUniforms("pixel");
 
@@ -195,7 +194,7 @@ class Gaussian6HBlurShader : public TextureShader<Gaussian6HBlurShader, 1,
 public:
     Gaussian6HBlurShader()
     {
-        loadProgram(OBJECT, GET_SS(SharedScreenQuad),
+        loadProgram(OBJECT, GL_VERTEX_SHADER, "screenquad.vert",
                             GL_FRAGMENT_SHADER, "gaussian6h.frag");
         assignUniforms("pixel", "sigma");
 
@@ -219,7 +218,7 @@ class Gaussian17TapHShader : public TextureShader<Gaussian17TapHShader, 2,
 public:
     Gaussian17TapHShader()
     {
-        loadProgram(OBJECT, GET_SS(SharedScreenQuad),
+        loadProgram(OBJECT, GL_VERTEX_SHADER, "screenquad.vert",
                             GL_FRAGMENT_SHADER, "bilateralH.frag");
         assignUniforms("pixel");
         assignSamplerNames(0, "tex", ST_BILINEAR_CLAMPED_FILTERED,
@@ -279,7 +278,7 @@ class Gaussian17TapVShader : public TextureShader<Gaussian17TapVShader, 2,
 public:
     Gaussian17TapVShader()
     {
-        loadProgram(OBJECT, GET_SS(SharedScreenQuad),
+        loadProgram(OBJECT, GL_VERTEX_SHADER, "screenquad.vert",
                             GL_FRAGMENT_SHADER, "bilateralV.frag");
         assignUniforms("pixel");
 
@@ -341,7 +340,7 @@ class BloomShader : public TextureShader<BloomShader, 1, float>
 public:
     BloomShader()
     {
-        loadProgram(OBJECT, GET_SS(SharedScreenQuad),
+        loadProgram(OBJECT, GL_VERTEX_SHADER, "screenquad.vert",
                             GL_FRAGMENT_SHADER, "bloom.frag");
         assignUniforms("scale");
         assignSamplerNames(0, "tex", ST_NEAREST_FILTERED);
@@ -365,7 +364,7 @@ public:
 		if (!lensDustTex)
 			lensDustTex = irr_driver->getTexture(FileManager::TEXTURE, "gfx_lensDust_a.png");
 
-        loadProgram(OBJECT, GET_SS(SharedScreenQuad),
+        loadProgram(OBJECT, GL_VERTEX_SHADER, "screenquad.vert",
                             GL_FRAGMENT_SHADER, "bloomblend.frag");
         assignUniforms();
         assignSamplerNames(0, "tex_128", ST_BILINEAR_FILTERED,
@@ -392,7 +391,7 @@ class LensBlendShader : public TextureShader<LensBlendShader, 3>
 public:
     LensBlendShader()
     {
-        loadProgram(OBJECT, GET_SS(SharedScreenQuad),
+        loadProgram(OBJECT, GL_VERTEX_SHADER, "screenquad.vert",
                             GL_FRAGMENT_SHADER, "lensblend.frag");
         assignUniforms();
 
@@ -420,7 +419,7 @@ public:
 
     ToneMapShader()
     {
-        loadProgram(OBJECT, GET_SS(SharedScreenQuad),
+        loadProgram(OBJECT, GL_VERTEX_SHADER, "screenquad.vert",
                             GL_FRAGMENT_SHADER, "tonemap.frag");
         assignUniforms("vignette_weight");
         assignSamplerNames(0, "text", ST_NEAREST_FILTERED);
@@ -440,7 +439,7 @@ class DepthOfFieldShader : public TextureShader<DepthOfFieldShader, 2>
 public:
     DepthOfFieldShader()
     {
-        loadProgram(OBJECT, GET_SS(SharedScreenQuad),
+        loadProgram(OBJECT, GL_VERTEX_SHADER, "screenquad.vert",
                             GL_FRAGMENT_SHADER, "dof.frag");
 
         assignUniforms();
@@ -482,7 +481,7 @@ class PassThroughShader : public TextureShader<PassThroughShader, 1, int, int>
 public:
     PassThroughShader()
     {
-        loadProgram(OBJECT, GET_SS(SharedScreenQuad),
+        loadProgram(OBJECT, GL_VERTEX_SHADER, "screenquad.vert",
                             GL_FRAGMENT_SHADER, "passthrough.frag");
         assignUniforms("width", "height");
         assignSamplerNames(0, "tex", ST_BILINEAR_FILTERED);
@@ -506,7 +505,7 @@ private:
 public:
     LayerPassThroughShader()
     {
-        loadProgram(OBJECT, GET_SS(SharedScreenQuad),
+        loadProgram(OBJECT, GL_VERTEX_SHADER, "screenquad.vert",
                             GL_FRAGMENT_SHADER, "layertexturequad.frag");
         m_tu_texture = 0;
         assignUniforms("layer");
@@ -532,7 +531,7 @@ class LinearizeDepthShader : public TextureShader<LinearizeDepthShader, 1,
 public:
     LinearizeDepthShader()
     {
-        loadProgram(OBJECT, GET_SS(SharedScreenQuad),
+        loadProgram(OBJECT, GL_VERTEX_SHADER, "screenquad.vert",
                             GL_FRAGMENT_SHADER, "linearizedepth.frag");
         assignUniforms("zn", "zf");
         assignSamplerNames(0, "texture", ST_BILINEAR_FILTERED);
@@ -556,7 +555,7 @@ public:
 
     GlowShader()
     {
-        loadProgram(OBJECT, GET_SS(SharedScreenQuad),
+        loadProgram(OBJECT, GL_VERTEX_SHADER, "screenquad.vert",
                             GL_FRAGMENT_SHADER, "glow.frag");
         assignUniforms();
         assignSamplerNames(0, "tex", ST_BILINEAR_FILTERED);
@@ -579,7 +578,7 @@ class SSAOShader : public TextureShader<SSAOShader, 1, float, float, float>
 public:
     SSAOShader()
     {
-        loadProgram(OBJECT, GET_SS(SharedScreenQuad),
+        loadProgram(OBJECT, GL_VERTEX_SHADER, "screenquad.vert",
                             GL_FRAGMENT_SHADER, "ssao.frag");
 
         assignUniforms("radius", "k", "sigma");
@@ -606,7 +605,7 @@ class MotionBlurShader : public TextureShader<MotionBlurShader, 2,
 public:
     MotionBlurShader()
     {
-        loadProgram(OBJECT, GET_SS(SharedScreenQuad),
+        loadProgram(OBJECT, GL_VERTEX_SHADER, "screenquad.vert",
                             GL_FRAGMENT_SHADER, "motion_blur.frag");
         assignUniforms("previous_viewproj", "center", "boost_amount",
                         "mask_radius");
@@ -632,7 +631,7 @@ class GodFadeShader : public TextureShader<GodFadeShader, 1, video::SColorf>
 public:
     GodFadeShader()
     {
-        loadProgram(OBJECT, GET_SS(SharedScreenQuad),
+        loadProgram(OBJECT, GL_VERTEX_SHADER, "screenquad.vert",
                             GL_FRAGMENT_SHADER, "godfade.frag");
         assignUniforms("col");
         assignSamplerNames(0, "tex", ST_BILINEAR_FILTERED);
@@ -651,7 +650,7 @@ class GodRayShader : public TextureShader<GodRayShader, 1, core::vector2df>
 public:
     GodRayShader()
     {
-        loadProgram(OBJECT, GET_SS(SharedScreenQuad),
+        loadProgram(OBJECT, GL_VERTEX_SHADER, "screenquad.vert",
                             GL_FRAGMENT_SHADER, "godray.frag");
 
         assignUniforms("sunpos");
@@ -672,7 +671,7 @@ class MLAAColorEdgeDetectionSHader
 public:
     MLAAColorEdgeDetectionSHader()
     {
-        loadProgram(OBJECT, GET_SS(SharedScreenQuad),
+        loadProgram(OBJECT, GL_VERTEX_SHADER, "screenquad.vert",
                             GL_FRAGMENT_SHADER, "mlaa_color1.frag");
         assignUniforms("PIXEL_SIZE");
         assignSamplerNames(0, "colorMapG", ST_NEAREST_FILTERED);
@@ -693,7 +692,7 @@ class MLAABlendWeightSHader : public TextureShader<MLAABlendWeightSHader,
 public:
     MLAABlendWeightSHader()
     {
-        loadProgram(OBJECT, GET_SS(SharedScreenQuad),
+        loadProgram(OBJECT, GL_VERTEX_SHADER, "screenquad.vert",
                             GL_FRAGMENT_SHADER, "mlaa_blend2.frag");
         assignUniforms("PIXEL_SIZE");
 
@@ -720,7 +719,7 @@ class MLAAGatherSHader : public TextureShader<MLAAGatherSHader, 2,
 public:
     MLAAGatherSHader()
     {
-        loadProgram(OBJECT, GET_SS(SharedScreenQuad),
+        loadProgram(OBJECT, GL_VERTEX_SHADER, "screenquad.vert",
                             GL_FRAGMENT_SHADER, "mlaa_neigh3.frag");
         assignUniforms("PIXEL_SIZE");
         assignSamplerNames(0, "blendMap", ST_NEAREST_FILTERED,
@@ -746,7 +745,7 @@ class LightningShader : public TextureShader<LightningShader, 1,
 public:
     LightningShader()
     {
-        loadProgram(OBJECT, GET_SS(SharedScreenQuad),
+        loadProgram(OBJECT, GL_VERTEX_SHADER, "screenquad.vert",
                             GL_FRAGMENT_SHADER, "lightning.frag");
         assignUniforms("intensity");
     }   // LightningShader
diff --git a/src/graphics/shader.hpp b/src/graphics/shader.hpp
index 9c70ec5ba..8e6ab5e93 100644
--- a/src/graphics/shader.hpp
+++ b/src/graphics/shader.hpp
@@ -22,7 +22,6 @@
 
 #include "graphics/central_settings.hpp"
 #include "graphics/gl_headers.hpp"
-#include "graphics/shared_shader.hpp"
 #include "graphics/shared_gpu_objects.hpp"
 #include "utils/singleton.hpp"
 
@@ -82,18 +81,6 @@ protected:
         loadAndAttachShader(args...);
     }   // loadAndAttachShader
     // ------------------------------------------------------------------------
-    template<typename ... Types>
-    void loadAndAttachShader(SharedShader* ss, Types ... args)
-    {
-        GLint shader_id = ss->getShaderID();
-        glAttachShader(m_program, shader_id);
-        GLint is_deleted = GL_TRUE;
-        glGetShaderiv(shader_id, GL_DELETE_STATUS, &is_deleted);
-        if (is_deleted == GL_FALSE)
-            glDeleteShader(shader_id);
-        loadAndAttachShader(args...);
-    }   // loadAndAttachShader
-    // ------------------------------------------------------------------------
     /** Convenience interface using const char. */
     template<typename ... Types>
     void loadAndAttachShader(GLint shader_type, const char *name,
@@ -103,12 +90,12 @@ protected:
     }   // loadAndAttachShader
     // ------------------------------------------------------------------------
 
-    static const std::string& getHeader();
+    const std::string& getHeader();
+    GLuint loadShader(const std::string &file, unsigned type);
     void setAttribute(AttributeType type);
 
 public:
         ShaderBase();
-    static GLuint loadShader(const std::string &file, unsigned type);
     int loadTFBProgram(const std::string &vertex_file_path,
                        const char **varyings,
                        unsigned varyingscount);
@@ -298,13 +285,7 @@ protected:
         Log::error("shader", filepath);
         printFileList(args...);
     }   // printFileList
-    // ------------------------------------------------------------------------
-    template<typename ...Types>
-    void printFileList(SharedShader* ss, Types ... args)
-    {
-        Log::error("shader", ss->getName());
-        printFileList(args...);
-    }   // printFileList
+
     // ------------------------------------------------------------------------
     /** End recursion for variadic template. */
 private:
diff --git a/src/graphics/shader_based_renderer.cpp b/src/graphics/shader_based_renderer.cpp
index 6253bfb56..4c8e3e278 100644
--- a/src/graphics/shader_based_renderer.cpp
+++ b/src/graphics/shader_based_renderer.cpp
@@ -31,7 +31,6 @@
 #include "graphics/render_target.hpp"
 #include "graphics/rtts.hpp"
 #include "graphics/shaders.hpp"
-#include "graphics/shared_shaders.hpp"
 #include "graphics/skybox.hpp"
 #include "graphics/spherical_harmonics.hpp"
 #include "graphics/texture_manager.hpp"
@@ -642,8 +641,7 @@ ShaderBasedRenderer::ShaderBasedRenderer()
     m_skybox                = NULL;
     m_spherical_harmonics   = new SphericalHarmonics(irr_driver->getAmbientLight().toSColor());
     m_nb_static_glowing     = 0;
-    preloadSharedShaders();
-
+    
     if (CVS->isAZDOEnabled())
     {
         m_geometry_passes = new GeometryPasses<MultidrawPolicy>();
@@ -683,7 +681,6 @@ ShaderBasedRenderer::~ShaderBasedRenderer()
     delete m_spherical_harmonics;
     delete m_skybox;
     delete m_rtts;
-    SharedShaderManager::kill();
 }
 
 // ----------------------------------------------------------------------------
@@ -964,41 +961,4 @@ void ShaderBasedRenderer::renderToTexture(GL3RenderTarget *render_target,
 
 } //renderToTexture
 
-void ShaderBasedRenderer::preloadSharedShaders()
-{
-    SharedShaderManager* ssm = SharedShaderManager::getInstance();
-    // Common shaders:
-    ssm->addSharedShader(new SharedObject());
-    ssm->addSharedShader(new SharedPass1());
-    if (CVS->supportsHardwareSkinning())
-        ssm->addSharedShader(new SharedSkinning());
-    ssm->addSharedShader(new SharedTransparent());
-    ssm->addSharedShader(new SharedTexturedQuad());
-    ssm->addSharedShader(new SharedColoredQuad());
-    ssm->addSharedShader(new SharedSlicedScreenQuad());
-    ssm->addSharedShader(new SharedScreenQuad());
-
-    if (CVS->supportsIndirectInstancingRendering())
-    {
-        ssm->addSharedShader(new SharedInstanced());
-        if (CVS->supportsHardwareSkinning())
-            ssm->addSharedShader(new SharedInstancedSkinning());
-        ssm->addSharedShader(new SharedInstancedPass1());
-        ssm->addSharedShader(new SharedInstancedPass2());
-        ssm->addSharedShader(new SharedInstancedRefPass1());
-        ssm->addSharedShader(new SharedInstancedRefPass2());
-        ssm->addSharedShader(new SharedInstancedUnlit());
-        ssm->addSharedShader(new SharedInstancedNormal());
-        ssm->addSharedShader(new SharedInstancedGrass());
-        ssm->addSharedShader(new SharedInstancedGrassPass2());
-        if (CVS->isShadowEnabled())
-        {
-            ssm->addSharedShader(new SharedInstancedShadow());
-            if (CVS->supportsHardwareSkinning())
-                ssm->addSharedShader(new SharedInstancedSkinningShadow());
-        }
-    }
-
-} //preLoadSharedShaders
-
 #endif   // !SERVER_ONLY
diff --git a/src/graphics/shader_based_renderer.hpp b/src/graphics/shader_based_renderer.hpp
index e3a97ed88..e5e33752d 100644
--- a/src/graphics/shader_based_renderer.hpp
+++ b/src/graphics/shader_based_renderer.hpp
@@ -85,7 +85,7 @@ private:
 
     void debugPhysics();
     void renderPostProcessing(Camera * const camera);
-    void preloadSharedShaders();
+
 
 public:
     ShaderBasedRenderer();
diff --git a/src/graphics/shaders.cpp b/src/graphics/shaders.cpp
index f448bd488..ed8e6c238 100644
--- a/src/graphics/shaders.cpp
+++ b/src/graphics/shaders.cpp
@@ -100,7 +100,6 @@
 #include "graphics/gpu_particles.hpp"
 #include "graphics/irr_driver.hpp"
 #include "graphics/shared_gpu_objects.hpp"
-#include "graphics/shared_shaders.hpp"
 #include "io/file_manager.hpp"
 #include "utils/log.hpp"
 
@@ -341,8 +340,8 @@ void Shaders::check(const int num)
 // Solid Normal and depth pass shaders
 Shaders::ObjectPass1Shader::ObjectPass1Shader()
 {
-    loadProgram(OBJECT, GET_SS(SharedObject),
-                        GET_SS(SharedPass1));
+    loadProgram(OBJECT, GL_VERTEX_SHADER, "object_pass.vert",
+                        GL_FRAGMENT_SHADER, "object_pass1.frag");
     assignUniforms("ModelMatrix", "InverseModelMatrix");
     assignSamplerNames(0, "tex", ST_TRILINEAR_ANISOTROPIC_FILTERED);
 }   // ObjectPass1Shader
@@ -351,7 +350,7 @@ Shaders::ObjectPass1Shader::ObjectPass1Shader()
 // Solid Lit pass shaders
 Shaders::ObjectPass2Shader::ObjectPass2Shader()
 {
-    loadProgram(OBJECT, GET_SS(SharedObject),
+    loadProgram(OBJECT, GL_VERTEX_SHADER, "object_pass.vert",
                         GL_FRAGMENT_SHADER, "object_pass2.frag");
     assignUniforms("ModelMatrix", "texture_trans", "color_change");
     assignSamplerNames(0, "DiffuseMap", ST_NEAREST_FILTERED,
@@ -366,8 +365,8 @@ Shaders::ObjectPass2Shader::ObjectPass2Shader()
 Shaders::SkinnedTransparentShader::SkinnedTransparentShader()
 {
     if (!CVS->supportsHardwareSkinning()) return;
-    loadProgram(OBJECT, GET_SS(SharedSkinning),
-                        GET_SS(SharedTransparent));
+    loadProgram(OBJECT, GL_VERTEX_SHADER, "skinning.vert",
+                        GL_FRAGMENT_SHADER, "transparent.frag");
     assignUniforms("ModelMatrix", "texture_trans", "skinning_offset",  "custom_alpha");
     assignSamplerNames(0, "tex", ST_TRILINEAR_ANISOTROPIC_FILTERED);
 }   // SkinnedTransparentShader
@@ -375,8 +374,8 @@ Shaders::SkinnedTransparentShader::SkinnedTransparentShader()
 // ============================================================================
 Shaders::TransparentShader::TransparentShader()
 {
-    loadProgram(OBJECT, GET_SS(SharedObject),
-                        GET_SS(SharedTransparent));
+    loadProgram(OBJECT, GL_VERTEX_SHADER, "object_pass.vert",
+                        GL_FRAGMENT_SHADER, "transparent.frag");
     assignUniforms("ModelMatrix", "texture_trans", "custom_alpha");
     assignSamplerNames(0, "tex", ST_TRILINEAR_ANISOTROPIC_FILTERED);
 }   // TransparentShader
@@ -384,7 +383,7 @@ Shaders::TransparentShader::TransparentShader()
 // ============================================================================
 Shaders::TransparentFogShader::TransparentFogShader()
 {
-    loadProgram(OBJECT, GET_SS(SharedObject),
+    loadProgram(OBJECT, GL_VERTEX_SHADER, "object_pass.vert",
                         GL_FRAGMENT_SHADER, "transparentfog.frag");
     assignUniforms("ModelMatrix", "texture_trans", "fogmax", "startH",
                    "endH", "start", "end", "col");
@@ -394,8 +393,9 @@ Shaders::TransparentFogShader::TransparentFogShader()
 // ============================================================================
 Shaders::ColoredLine::ColoredLine()
 {
-    loadProgram(OBJECT, GET_SS(SharedObject),
-                        GET_SS(SharedColoredQuad));
+    loadProgram(OBJECT, GL_VERTEX_SHADER,   "object_pass.vert",
+                        GL_FRAGMENT_SHADER, "coloredquad.frag");
+
     assignUniforms("color");
 
     glGenVertexArrays(1, &m_vao);
diff --git a/src/graphics/shadow_matrices.cpp b/src/graphics/shadow_matrices.cpp
index c3dc5e51b..9ba9f0b6a 100644
--- a/src/graphics/shadow_matrices.cpp
+++ b/src/graphics/shadow_matrices.cpp
@@ -27,7 +27,6 @@
 #include "graphics/rtts.hpp"
 #include "graphics/shaders.hpp"
 #include "graphics/shared_gpu_objects.hpp"
-#include "graphics/shared_shaders.hpp"
 #include "modes/world.hpp"
 #include "physics/triangle_mesh.hpp"
 #include "tracks/track.hpp"
@@ -96,7 +95,7 @@ private:
 public:    ViewFrustrumShader()
     {
         loadProgram(OBJECT, GL_VERTEX_SHADER, "frustrum.vert",
-                            GET_SS(SharedColoredQuad));
+                            GL_FRAGMENT_SHADER, "coloredquad.frag");
 
         assignUniforms("color", "idx");
 
diff --git a/src/graphics/shared_shader.cpp b/src/graphics/shared_shader.cpp
deleted file mode 100644
index 238c86b7a..000000000
--- a/src/graphics/shared_shader.cpp
+++ /dev/null
@@ -1,28 +0,0 @@
-//  SuperTuxKart - a fun racing game with go-kart
-//  Copyright (C) 2016 SuperTuxKart-Team
-//
-//  This program is free software; you can redistribute it and/or
-//  modify it under the terms of the GNU General Public License
-//  as published by the Free Software Foundation; either version 3
-//  of the License, or (at your option) any later version.
-//
-//  This program is distributed in the hope that it will be useful,
-//  but WITHOUT ANY WARRANTY; without even the implied warranty of
-//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-//  GNU General Public License for more details.
-//
-//  You should have received a copy of the GNU General Public License
-//  along with this program; if not, write to the Free Software
-//  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
-
-#ifndef SERVER_ONLY
-
-#include "graphics/shared_shader.hpp"
-#include "graphics/shader.hpp"
-
-void SharedShader::loadSharedShader()
-{
-    m_shader_id = ShaderBase::loadShader(getName(), getShaderType());
-};   // loadSharedShader
-
-#endif   // !SERVER_ONLY
diff --git a/src/graphics/shared_shader.hpp b/src/graphics/shared_shader.hpp
deleted file mode 100644
index 68a941e4e..000000000
--- a/src/graphics/shared_shader.hpp
+++ /dev/null
@@ -1,49 +0,0 @@
-//  SuperTuxKart - a fun racing game with go-kart
-//  Copyright (C) 2016 SuperTuxKart-Team
-//
-//  This program is free software; you can redistribute it and/or
-//  modify it under the terms of the GNU General Public License
-//  as published by the Free Software Foundation; either version 3
-//  of the License, or (at your option) any later version.
-//
-//  This program is distributed in the hope that it will be useful,
-//  but WITHOUT ANY WARRANTY; without even the implied warranty of
-//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-//  GNU General Public License for more details.
-//
-//  You should have received a copy of the GNU General Public License
-//  along with this program; if not, write to the Free Software
-//  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
-
-#ifndef SERVER_ONLY
-
-#ifndef HEADER_SHARED_SHADER_HPP
-#define HEADER_SHARED_SHADER_HPP
-
-#include "graphics/gl_headers.hpp"
-#include "utils/no_copy.hpp"
-
-class SharedShader : public NoCopy
-{
-private:
-    GLuint m_shader_id;
-public:
-    // ------------------------------------------------------------------------
-    SharedShader() { m_shader_id = 0; }
-    // ------------------------------------------------------------------------
-    virtual ~SharedShader() {}
-    // ------------------------------------------------------------------------
-    GLuint getShaderID() const { return m_shader_id; }
-    // ------------------------------------------------------------------------
-    virtual const char* getName() = 0;
-    // ------------------------------------------------------------------------
-    virtual unsigned getShaderType() = 0;
-    // ------------------------------------------------------------------------
-    void loadSharedShader();
-
-};   // SharedShader
-
-#endif
-
-#endif   // !SERVER_ONLY
-
diff --git a/src/graphics/shared_shader_manager.hpp b/src/graphics/shared_shader_manager.hpp
deleted file mode 100644
index 17a8fd45d..000000000
--- a/src/graphics/shared_shader_manager.hpp
+++ /dev/null
@@ -1,81 +0,0 @@
-//  SuperTuxKart - a fun racing game with go-kart
-//  Copyright (C) 2016 SuperTuxKart-Team
-//
-//  This program is free software; you can redistribute it and/or
-//  modify it under the terms of the GNU General Public License
-//  as published by the Free Software Foundation; either version 3
-//  of the License, or (at your option) any later version.
-//
-//  This program is distributed in the hope that it will be useful,
-//  but WITHOUT ANY WARRANTY; without even the implied warranty of
-//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-//  GNU General Public License for more details.
-//
-//  You should have received a copy of the GNU General Public License
-//  along with this program; if not, write to the Free Software
-//  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
-
-#ifndef SERVER_ONLY
-
-#ifndef HEADER_SHARED_SHADER_MANAGER_HPP
-#define HEADER_SHARED_SHADER_MANAGER_HPP
-
-#include "graphics/shared_shader.hpp"
-#include "utils/no_copy.hpp"
-#include "utils/singleton.hpp"
-
-#include <algorithm>
-#include <typeindex>
-#include <unordered_map>
-#include <vector>
-
-class SharedShaderManager : public Singleton<SharedShaderManager>, NoCopy
-{
-private:
-    std::unordered_map<std::type_index, int> m_shaders_map;
-
-    std::vector<SharedShader*> m_shared_shaders;
-
-    unsigned int m_shared_shader_loaded;
-
-public:
-    // ------------------------------------------------------------------------
-    SharedShaderManager() { m_shared_shader_loaded = 0; }
-    // ------------------------------------------------------------------------
-    ~SharedShaderManager()
-    {
-        for (SharedShader* ss : m_shared_shaders)
-            delete ss;
-    }   // ~SharedShaderManager
-    // ------------------------------------------------------------------------
-    template <typename T>
-    void addSharedShader(T* ss)
-    {
-        ss->loadSharedShader();
-        m_shaders_map[std::type_index(typeid(T))] = m_shared_shader_loaded++;
-        m_shared_shaders.push_back(ss);
-    }   // addSharedShader
-    // ------------------------------------------------------------------------
-    template <typename T> T* getSharedShader()
-    {
-        std::unordered_map<std::type_index, int>::const_iterator i =
-            m_shaders_map.find(std::type_index(typeid(T)));
-        if (i != m_shaders_map.end())
-        {
-            T* ss = dynamic_cast<T*>(m_shared_shaders[i->second]);
-            assert(ss != NULL);
-            return ss;
-        }
-        else
-        {
-            T* new_ss = new T();
-            addSharedShader(new_ss);
-            return new_ss;
-        }
-    }   // getSharedShader
-};   // SharedShaderManager
-
-#endif
-
-#endif   // !SERVER_ONLY
-
diff --git a/src/graphics/shared_shaders.hpp b/src/graphics/shared_shaders.hpp
deleted file mode 100644
index 98ed601c2..000000000
--- a/src/graphics/shared_shaders.hpp
+++ /dev/null
@@ -1,244 +0,0 @@
-//  SuperTuxKart - a fun racing game with go-kart
-//  Copyright (C) 2016 SuperTuxKart-Team
-//
-//  This program is free software; you can redistribute it and/or
-//  modify it under the terms of the GNU General Public License
-//  as published by the Free Software Foundation; either version 3
-//  of the License, or (at your option) any later version.
-//
-//  This program is distributed in the hope that it will be useful,
-//  but WITHOUT ANY WARRANTY; without even the implied warranty of
-//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-//  GNU General Public License for more details.
-//
-//  You should have received a copy of the GNU General Public License
-//  along with this program; if not, write to the Free Software
-//  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
-
-#ifndef SERVER_ONLY
-
-#ifndef HEADER_SHARED_SHADERS_HPP
-#define HEADER_SHARED_SHADERS_HPP
-
-#include "graphics/shared_shader_manager.hpp"
-#include "utils/cpp2011.hpp"
-
-#define GET_SS(SS) SharedShaderManager::getInstance()->getSharedShader<SS>()
-
-// ============================================================================
-// Common shaders:
-class SharedObject : public SharedShader
-{
-public:
-    // ------------------------------------------------------------------------
-    virtual const char* getName() OVERRIDE       { return "object_pass.vert"; }
-    // ------------------------------------------------------------------------
-    virtual unsigned getShaderType()  OVERRIDE     { return GL_VERTEX_SHADER; }
-};   // SharedObject
-
-// ============================================================================
-class SharedPass1 : public SharedShader
-{
-public:
-    // ------------------------------------------------------------------------
-    virtual const char* getName() OVERRIDE      { return "object_pass1.frag"; }
-    // ------------------------------------------------------------------------
-    virtual unsigned getShaderType()  OVERRIDE   { return GL_FRAGMENT_SHADER; }
-};   // SharedPass1
-
-// ============================================================================
-class SharedSkinning : public SharedShader
-{
-public:
-    // ------------------------------------------------------------------------
-    virtual const char* getName() OVERRIDE          { return "skinning.vert"; }
-    // ------------------------------------------------------------------------
-    virtual unsigned getShaderType() OVERRIDE      { return GL_VERTEX_SHADER; }
-};   // SharedSkinning
-
-// ============================================================================
-class SharedTransparent : public SharedShader
-{
-public:
-    // ------------------------------------------------------------------------
-    virtual const char* getName() OVERRIDE       { return "transparent.frag"; }
-    // ------------------------------------------------------------------------
-    virtual unsigned getShaderType() OVERRIDE    { return GL_FRAGMENT_SHADER; }
-};   // SharedTransparent
-
-// ============================================================================
-class SharedTexturedQuad : public SharedShader
-{
-public:
-    // ------------------------------------------------------------------------
-    virtual const char* getName() OVERRIDE      { return "texturedquad.vert"; }
-    // ------------------------------------------------------------------------
-    virtual unsigned getShaderType() OVERRIDE      { return GL_VERTEX_SHADER; }
-};   // SharedTexturedQuad
-
-// ============================================================================
-class SharedColoredQuad : public SharedShader
-{
-public:
-    // ------------------------------------------------------------------------
-    virtual const char* getName() OVERRIDE       { return "coloredquad.frag"; }
-    // ------------------------------------------------------------------------
-    virtual unsigned getShaderType() OVERRIDE    { return GL_FRAGMENT_SHADER; }
-};   // SharedColoredQuad
-
-// ============================================================================
-class SharedSlicedScreenQuad : public SharedShader
-{
-public:
-    // ------------------------------------------------------------------------
-    virtual const char* getName() OVERRIDE  { return "slicedscreenquad.vert"; }
-    // ------------------------------------------------------------------------
-    virtual unsigned getShaderType() OVERRIDE      { return GL_VERTEX_SHADER; }
-};   // SharedSlicedScreenQuad
-
-// ============================================================================
-class SharedScreenQuad : public SharedShader
-{
-public:
-    // ------------------------------------------------------------------------
-    virtual const char* getName() OVERRIDE        { return "screenquad.vert"; }
-    // ------------------------------------------------------------------------
-    virtual unsigned getShaderType() OVERRIDE      { return GL_VERTEX_SHADER; }
-};   // SharedScreenQuad
-
-// ============================================================================
-// Instanced shaders:
-class SharedInstanced : public SharedShader
-{
-public:
-    // ------------------------------------------------------------------------
-    virtual const char* getName() OVERRIDE
-                                       { return "instanced_object_pass.vert"; }
-    // ------------------------------------------------------------------------
-    virtual unsigned getShaderType() OVERRIDE      { return GL_VERTEX_SHADER; }
-};   // SharedInstanced
-
-// ============================================================================
-class SharedInstancedSkinning : public SharedShader
-{
-public:
-    // ------------------------------------------------------------------------
-    virtual const char* getName() OVERRIDE
-                                          { return "instanced_skinning.vert"; }
-    // ------------------------------------------------------------------------
-    virtual unsigned getShaderType() OVERRIDE      { return GL_VERTEX_SHADER; }
-};   // SharedInstancedSkinning
-
-// ============================================================================
-class SharedInstancedPass1 : public SharedShader
-{
-public:
-    // ------------------------------------------------------------------------
-    virtual const char* getName() OVERRIDE
-                                      { return "instanced_object_pass1.frag"; }
-    // ------------------------------------------------------------------------
-    virtual unsigned getShaderType() OVERRIDE    { return GL_FRAGMENT_SHADER; }
-};   // SharedInstancedPass1
-
-// ============================================================================
-class SharedInstancedPass2 : public SharedShader
-{
-public:
-    // ------------------------------------------------------------------------
-    virtual const char* getName() OVERRIDE
-                                      { return "instanced_object_pass2.frag"; }
-    // ------------------------------------------------------------------------
-    virtual unsigned getShaderType() OVERRIDE    { return GL_FRAGMENT_SHADER; }
-};   // SharedInstancedPass2
-
-// ============================================================================
-class SharedInstancedRefPass1 : public SharedShader
-{
-public:
-    // ------------------------------------------------------------------------
-    virtual const char* getName() OVERRIDE
-                                   { return "instanced_objectref_pass1.frag"; }
-    // ------------------------------------------------------------------------
-    virtual unsigned getShaderType() OVERRIDE    { return GL_FRAGMENT_SHADER; }
-};   // SharedInstancedRefPass1
-
-// ============================================================================
-class SharedInstancedRefPass2 : public SharedShader
-{
-public:
-    // ------------------------------------------------------------------------
-    virtual const char* getName() OVERRIDE
-                                   { return "instanced_objectref_pass2.frag"; }
-    // ------------------------------------------------------------------------
-    virtual unsigned getShaderType() OVERRIDE    { return GL_FRAGMENT_SHADER; }
-};   // SharedInstancedRefPass2
-
-// ============================================================================
-class SharedInstancedUnlit : public SharedShader
-{
-public:
-    // ------------------------------------------------------------------------
-    virtual const char* getName() OVERRIDE
-                                      { return "instanced_object_unlit.frag"; }
-    // ------------------------------------------------------------------------
-    virtual unsigned getShaderType() OVERRIDE    { return GL_FRAGMENT_SHADER; }
-};   // SharedInstancedUnlit
-
-// ============================================================================
-class SharedInstancedNormal : public SharedShader
-{
-public:
-    // ------------------------------------------------------------------------
-    virtual const char* getName() OVERRIDE
-                                         { return "instanced_normalmap.frag"; }
-    // ------------------------------------------------------------------------
-    virtual unsigned getShaderType() OVERRIDE    { return GL_FRAGMENT_SHADER; }
-};   // SharedInstancedNormal
-
-// ============================================================================
-class SharedInstancedGrass : public SharedShader
-{
-public:
-    // ------------------------------------------------------------------------
-    virtual const char* getName() OVERRIDE
-                                             { return "instanced_grass.vert"; }
-    // ------------------------------------------------------------------------
-    virtual unsigned getShaderType() OVERRIDE      { return GL_VERTEX_SHADER; }
-};   // SharedInstancedGrass
-
-// ============================================================================
-class SharedInstancedGrassPass2 : public SharedShader
-{
-public:
-    // ------------------------------------------------------------------------
-    virtual const char* getName() OVERRIDE
-                                       { return "instanced_grass_pass2.frag"; }
-    // ------------------------------------------------------------------------
-    virtual unsigned getShaderType() OVERRIDE    { return GL_FRAGMENT_SHADER; }
-};   // SharedInstancedGrassPass2
-
-// ============================================================================
-class SharedInstancedShadow : public SharedShader
-{
-public:
-    // ------------------------------------------------------------------------
-    virtual const char* getName() OVERRIDE  { return "instanciedshadow.vert"; }
-    // ------------------------------------------------------------------------
-    virtual unsigned getShaderType() OVERRIDE      { return GL_VERTEX_SHADER; }
-};   // SharedInstancedShadow
-
-// ============================================================================
-class SharedInstancedSkinningShadow : public SharedShader
-{
-public:
-    // ------------------------------------------------------------------------
-    virtual const char* getName() OVERRIDE
-                                   { return "instanced_skinning_shadow.vert"; }
-    // ------------------------------------------------------------------------
-    virtual unsigned getShaderType() OVERRIDE      { return GL_VERTEX_SHADER; }
-};   // SharedInstancedSkinningShadow
-
-#endif
-
-#endif   // !SERVER_ONLY
-
diff --git a/src/graphics/skybox.cpp b/src/graphics/skybox.cpp
index 0bb22c5ce..fd1c597b8 100644
--- a/src/graphics/skybox.cpp
+++ b/src/graphics/skybox.cpp
@@ -21,7 +21,7 @@
 #include "graphics/central_settings.hpp"
 #include "graphics/irr_driver.hpp"
 #include "graphics/shaders.hpp"
-#include "graphics/shared_shaders.hpp"
+
 
 #include <algorithm>
 #include <cassert>
@@ -64,7 +64,7 @@ public:
     GLuint m_tu_samples;
     SpecularIBLGenerator()
     {
-        loadProgram(OBJECT, GET_SS(SharedScreenQuad),
+        loadProgram(OBJECT, GL_VERTEX_SHADER,   "screenquad.vert",
                             GL_FRAGMENT_SHADER, "importance_sampling_specular.frag");
         assignUniforms("PermutationMatrix", "ViewportSize");
         m_tu_samples = 1;
diff --git a/src/graphics/stk_mesh_scene_node.cpp b/src/graphics/stk_mesh_scene_node.cpp
index e915e53e4..7b2c6c0ab 100644
--- a/src/graphics/stk_mesh_scene_node.cpp
+++ b/src/graphics/stk_mesh_scene_node.cpp
@@ -24,7 +24,6 @@
 #include "graphics/material_manager.hpp"
 #include "graphics/render_info.hpp"
 #include "graphics/rtts.hpp"
-#include "graphics/shared_shaders.hpp"
 #include "graphics/stk_mesh.hpp"
 #include "graphics/texture_manager.hpp"
 #include "graphics/vao_manager.hpp"
@@ -41,7 +40,7 @@ class ColorizeShader : public Shader<ColorizeShader, core::matrix4,
 public:
     ColorizeShader()
     {
-        loadProgram(OBJECT, GET_SS(SharedObject),
+        loadProgram(OBJECT, GL_VERTEX_SHADER, "object_pass.vert",
                             GL_FRAGMENT_SHADER, "colorize.frag");
         assignUniforms("ModelMatrix", "col");
     }
diff --git a/src/utils/debug.cpp b/src/utils/debug.cpp
index 657640375..0d7e351d1 100644
--- a/src/utils/debug.cpp
+++ b/src/utils/debug.cpp
@@ -29,7 +29,6 @@
 #include "graphics/irr_driver.hpp"
 #include "graphics/light.hpp"
 #include "graphics/shaders.hpp"
-#include "graphics/shared_shader_manager.hpp"
 #include "items/powerup_manager.hpp"
 #include "items/attachment.hpp"
 #include "karts/abstract_kart.hpp"
@@ -237,10 +236,9 @@ bool handleContextMenuAction(s32 cmd_id)
     case DEBUG_GRAPHICS_RELOAD_SHADERS:
 #ifndef SERVER_ONLY
         Log::info("Debug", "Reloading shaders...");
-        SharedShaderManager::kill();
-        ShaderBase::updateShaders();
+            ShaderBase::updateShaders();
 #endif
-        break;
+            break;
     case DEBUG_GRAPHICS_RESET:
         if (physics)
             physics->setDebugMode(IrrDebugDrawer::DM_NONE);