diff --git a/src/Magnum/Shaders/DistanceFieldVector.cpp b/src/Magnum/Shaders/DistanceFieldVector.cpp
index 2b81b9d03..6479807ae 100644
--- a/src/Magnum/Shaders/DistanceFieldVector.cpp
+++ b/src/Magnum/Shaders/DistanceFieldVector.cpp
@@ -51,14 +51,15 @@ template<UnsignedInt dimensions> DistanceFieldVector<dimensions>::DistanceFieldV
     #endif
 
     Shader frag = Implementation::createCompatibilityShader(version, Shader::Type::Vertex);
+    Shader vert = Implementation::createCompatibilityShader(version, Shader::Type::Fragment);
+
     frag.addSource(rs.get("generic.glsl"))
         .addSource(rs.get(vertexShaderName<dimensions>()));
-    CORRADE_INTERNAL_ASSERT_OUTPUT(frag.compile());
-    AbstractShaderProgram::attachShader(frag);
-
-    Shader vert = Implementation::createCompatibilityShader(version, Shader::Type::Fragment);
     vert.addSource(rs.get("DistanceFieldVector.frag"));
-    CORRADE_INTERNAL_ASSERT_OUTPUT(vert.compile());
+
+    CORRADE_INTERNAL_ASSERT_OUTPUT(Shader::compile({frag, vert}));
+
+    AbstractShaderProgram::attachShader(frag);
     AbstractShaderProgram::attachShader(vert);
 
     #ifndef MAGNUM_TARGET_GLES
diff --git a/src/Magnum/Shaders/Flat.cpp b/src/Magnum/Shaders/Flat.cpp
index 49f5cd830..387e2c1f6 100644
--- a/src/Magnum/Shaders/Flat.cpp
+++ b/src/Magnum/Shaders/Flat.cpp
@@ -54,16 +54,17 @@ template<UnsignedInt dimensions> Flat<dimensions>::Flat(const Flags flags): tran
     #endif
 
     Shader vert = Implementation::createCompatibilityShader(version, Shader::Type::Vertex);
+    Shader frag = Implementation::createCompatibilityShader(version, Shader::Type::Fragment);
+
     vert.addSource(flags & Flag::Textured ? "#define TEXTURED\n" : "")
         .addSource(rs.get("generic.glsl"))
         .addSource(rs.get(vertexShaderName<dimensions>()));
-    CORRADE_INTERNAL_ASSERT_OUTPUT(vert.compile());
-    attachShader(vert);
-
-    Shader frag = Implementation::createCompatibilityShader(version, Shader::Type::Fragment);
     frag.addSource(flags & Flag::Textured ? "#define TEXTURED\n" : "")
         .addSource(rs.get("Flat.frag"));
-    CORRADE_INTERNAL_ASSERT_OUTPUT(frag.compile());
+
+    CORRADE_INTERNAL_ASSERT_OUTPUT(Shader::compile({vert, frag}));
+
+    attachShader(vert);
     attachShader(frag);
 
     #ifndef MAGNUM_TARGET_GLES
diff --git a/src/Magnum/Shaders/MeshVisualizer.cpp b/src/Magnum/Shaders/MeshVisualizer.cpp
index 660929260..c0d50e681 100644
--- a/src/Magnum/Shaders/MeshVisualizer.cpp
+++ b/src/Magnum/Shaders/MeshVisualizer.cpp
@@ -30,6 +30,7 @@
 #include "Magnum/Context.h"
 #include "Magnum/Extensions.h"
 #include "Magnum/Shader.h"
+#include "MagnumExternal/Optional/optional.hpp"
 
 #include "Implementation/CreateCompatibilityShader.h"
 
@@ -56,31 +57,35 @@ MeshVisualizer::MeshVisualizer(const Flags flags): flags(flags), transformationP
     #endif
 
     Shader vert = Implementation::createCompatibilityShader(version, Shader::Type::Vertex);
+    Shader frag = Implementation::createCompatibilityShader(version, Shader::Type::Fragment);
+
     vert.addSource(flags & Flag::Wireframe ? "#define WIREFRAME_RENDERING\n" : "")
         .addSource(flags & Flag::NoGeometryShader ? "#define NO_GEOMETRY_SHADER\n" : "")
         .addSource(rs.get("generic.glsl"))
         .addSource(rs.get("MeshVisualizer.vert"));
-    CORRADE_INTERNAL_ASSERT_OUTPUT(vert.compile());
-    vert.compile();
-    attachShader(vert);
+    frag.addSource(flags & Flag::Wireframe ? "#define WIREFRAME_RENDERING\n" : "")
+        .addSource(flags & Flag::NoGeometryShader ? "#define NO_GEOMETRY_SHADER\n" : "")
+        .addSource(rs.get("MeshVisualizer.frag"));
 
     #ifndef MAGNUM_TARGET_GLES
+    std::optional<Shader> geom;
     if(flags & Flag::Wireframe && !(flags & Flag::NoGeometryShader)) {
-        Shader geom = Implementation::createCompatibilityShader(version, Shader::Type::Geometry);
-        geom.addSource(rs.get("MeshVisualizer.geom"));
-        CORRADE_INTERNAL_ASSERT_OUTPUT(geom.compile());
-        geom.compile();
-        attachShader(geom);
+        geom = Implementation::createCompatibilityShader(version, Shader::Type::Geometry);
+        geom->addSource(rs.get("MeshVisualizer.geom"));
     }
     #endif
 
-    Shader frag = Implementation::createCompatibilityShader(version, Shader::Type::Fragment);
-    frag.addSource(flags & Flag::Wireframe ? "#define WIREFRAME_RENDERING\n" : "")
-        .addSource(flags & Flag::NoGeometryShader ? "#define NO_GEOMETRY_SHADER\n" : "")
-        .addSource(rs.get("MeshVisualizer.frag"));
-    CORRADE_INTERNAL_ASSERT_OUTPUT(frag.compile());
-    frag.compile();
+    #ifndef MAGNUM_TARGET_GLES
+    if(geom) Shader::compile({vert, *geom, frag});
+    else
+    #endif
+        Shader::compile({vert, frag});
+
+    attachShader(vert);
     attachShader(frag);
+    #ifndef MAGNUM_TARGET_GLES
+    if(geom) attachShader(*geom);
+    #endif
 
     #ifndef MAGNUM_TARGET_GLES
     if(!Context::current()->isExtensionSupported<Extensions::GL::ARB::explicit_attrib_location>(version))
@@ -99,7 +104,6 @@ MeshVisualizer::MeshVisualizer(const Flags flags): flags(flags), transformationP
     }
 
     CORRADE_INTERNAL_ASSERT_OUTPUT(link());
-    link();
 
     #ifndef MAGNUM_TARGET_GLES
     if(!Context::current()->isExtensionSupported<Extensions::GL::ARB::explicit_uniform_location>(version))
diff --git a/src/Magnum/Shaders/Phong.cpp b/src/Magnum/Shaders/Phong.cpp
index 48f34597c..e7bf2594e 100644
--- a/src/Magnum/Shaders/Phong.cpp
+++ b/src/Magnum/Shaders/Phong.cpp
@@ -54,18 +54,19 @@ Phong::Phong(const Flags flags): transformationMatrixUniform(0), projectionMatri
     #endif
 
     Shader vert = Implementation::createCompatibilityShader(version, Shader::Type::Vertex);
+    Shader frag = Implementation::createCompatibilityShader(version, Shader::Type::Fragment);
+
     vert.addSource(flags ? "#define TEXTURED\n" : "")
         .addSource(rs.get("generic.glsl"))
         .addSource(rs.get("Phong.vert"));
-    CORRADE_INTERNAL_ASSERT_OUTPUT(vert.compile());
-    attachShader(vert);
-
-    Shader frag = Implementation::createCompatibilityShader(version, Shader::Type::Fragment);
     frag.addSource(flags & Flag::AmbientTexture ? "#define AMBIENT_TEXTURE\n" : "")
         .addSource(flags & Flag::DiffuseTexture ? "#define DIFFUSE_TEXTURE\n" : "")
         .addSource(flags & Flag::SpecularTexture ? "#define SPECULAR_TEXTURE\n" : "")
         .addSource(rs.get("Phong.frag"));
-    CORRADE_INTERNAL_ASSERT_OUTPUT(frag.compile());
+
+    CORRADE_INTERNAL_ASSERT_OUTPUT(Shader::compile({vert, frag}));
+
+    attachShader(vert);
     attachShader(frag);
 
     #ifndef MAGNUM_TARGET_GLES
diff --git a/src/Magnum/Shaders/Vector.cpp b/src/Magnum/Shaders/Vector.cpp
index a4337f26f..c02411e5e 100644
--- a/src/Magnum/Shaders/Vector.cpp
+++ b/src/Magnum/Shaders/Vector.cpp
@@ -51,14 +51,15 @@ template<UnsignedInt dimensions> Vector<dimensions>::Vector(): transformationPro
     #endif
 
     Shader vert = Implementation::createCompatibilityShader(version, Shader::Type::Vertex);
+    Shader frag = Implementation::createCompatibilityShader(version, Shader::Type::Fragment);
+
     vert.addSource(rs.get("generic.glsl"))
         .addSource(rs.get(vertexShaderName<dimensions>()));
-    CORRADE_INTERNAL_ASSERT_OUTPUT(vert.compile());
-    AbstractShaderProgram::attachShader(vert);
-
-    Shader frag = Implementation::createCompatibilityShader(version, Shader::Type::Fragment);
     frag.addSource(rs.get("Vector.frag"));
-    CORRADE_INTERNAL_ASSERT_OUTPUT(frag.compile());
+
+    CORRADE_INTERNAL_ASSERT_OUTPUT(Shader::compile({vert, frag}));
+
+    AbstractShaderProgram::attachShader(vert);
     AbstractShaderProgram::attachShader(frag);
 
     #ifndef MAGNUM_TARGET_GLES
diff --git a/src/Magnum/Shaders/VertexColor.cpp b/src/Magnum/Shaders/VertexColor.cpp
index ca08de6ce..178d3bf6f 100644
--- a/src/Magnum/Shaders/VertexColor.cpp
+++ b/src/Magnum/Shaders/VertexColor.cpp
@@ -51,14 +51,15 @@ template<UnsignedInt dimensions> VertexColor<dimensions>::VertexColor(): transfo
     #endif
 
     Shader vert = Implementation::createCompatibilityShader(version, Shader::Type::Vertex);
+    Shader frag = Implementation::createCompatibilityShader(version, Shader::Type::Fragment);
+
     vert.addSource(rs.get("generic.glsl"))
         .addSource(rs.get(vertexShaderName<dimensions>()));
-    CORRADE_INTERNAL_ASSERT_OUTPUT(vert.compile());
-    attachShader(vert);
-
-    Shader frag = Implementation::createCompatibilityShader(version, Shader::Type::Fragment);
     frag.addSource(rs.get("VertexColor.frag"));
-    CORRADE_INTERNAL_ASSERT_OUTPUT(frag.compile());
+
+    CORRADE_INTERNAL_ASSERT_OUTPUT(Shader::compile({vert, frag}));
+
+    attachShader(vert);
     attachShader(frag);
 
     #ifndef MAGNUM_TARGET_GLES