diff --git a/src/python/magnum/shaders.cpp b/src/python/magnum/shaders.cpp
index d0d737b..a13f217 100644
--- a/src/python/magnum/shaders.cpp
+++ b/src/python/magnum/shaders.cpp
@@ -53,7 +53,13 @@ template<UnsignedInt dimensions> void distanceFieldVector(PyNonDestructibleClass
 
     /* Methods */
     c
-        .def(py::init<typename Shaders::DistanceFieldVectorGL<dimensions>::Flag>(), "Constructor",
+        .def(py::init([](typename Shaders::DistanceFieldVectorGL<dimensions>::Flag flags) {
+            return typename Shaders::DistanceFieldVectorGL<dimensions>{typename Shaders::DistanceFieldVectorGL<dimensions>::Configuration{}
+                .setFlags(flags)};
+        }), "Constructor",
+            #if PYBIND11_VERSION_MAJOR*100 + PYBIND11_VERSION_MINOR >= 206
+            py::kw_only{}, /* new in pybind11 2.6 */
+            #endif
             py::arg("flags") = typename Shaders::DistanceFieldVectorGL<dimensions>::Flag{})
 
         /* Using lambdas to avoid method chaining getting into signatures */
@@ -92,7 +98,13 @@ template<UnsignedInt dimensions> void flat(PyNonDestructibleClass<Shaders::FlatG
 
     /* Methods */
     c
-        .def(py::init<typename Shaders::FlatGL<dimensions>::Flag>(), "Constructor",
+        .def(py::init([](typename Shaders::FlatGL<dimensions>::Flag flags) {
+            return typename Shaders::FlatGL<dimensions>{typename Shaders::FlatGL<dimensions>::Configuration{}
+                .setFlags(flags)};
+        }), "Constructor",
+            #if PYBIND11_VERSION_MAJOR*100 + PYBIND11_VERSION_MINOR >= 206
+            py::kw_only{}, /* new in pybind11 2.6 */
+            #endif
             py::arg("flags") = typename Shaders::FlatGL<dimensions>::Flag{})
 
         /* Using lambdas to avoid method chaining getting into signatures */
@@ -135,7 +147,13 @@ template<UnsignedInt dimensions> void vector(PyNonDestructibleClass<Shaders::Vec
 
     /* Methods */
     c
-        .def(py::init<typename Shaders::VectorGL<dimensions>::Flag>(), "Constructor",
+        .def(py::init([](typename Shaders::VectorGL<dimensions>::Flag flags) {
+            return typename Shaders::VectorGL<dimensions>{typename Shaders::VectorGL<dimensions>::Configuration{}
+                .setFlags(flags)};
+        }), "Constructor",
+            #if PYBIND11_VERSION_MAJOR*100 + PYBIND11_VERSION_MINOR >= 206
+            py::kw_only{}, /* new in pybind11 2.6 */
+            #endif
             py::arg("flags") = typename Shaders::VectorGL<dimensions>::Flag{})
 
         /* Using lambdas to avoid method chaining getting into signatures */
@@ -285,7 +303,14 @@ void shaders(py::module_& m) {
         corrade::enumOperators(flags);
 
         phongGL
-            .def(py::init<Shaders::PhongGL::Flag, UnsignedInt>(), "Constructor",
+            .def(py::init([](Shaders::PhongGL::Flag flags, UnsignedInt lightCount) {
+                return Shaders::PhongGL{Shaders::PhongGL::Configuration{}
+                    .setFlags(flags)
+                    .setLightCount(lightCount)};
+            }), "Constructor",
+                #if PYBIND11_VERSION_MAJOR*100 + PYBIND11_VERSION_MINOR >= 206
+                py::kw_only{}, /* new in pybind11 2.6 */
+                #endif
                 py::arg("flags") = Shaders::PhongGL::Flag{},
                 py::arg("light_count") = 1)
             .def_property_readonly("flags", [](Shaders::PhongGL& self) {
diff --git a/src/python/magnum/test/test_shaders_gl.py b/src/python/magnum/test/test_shaders_gl.py
index a67271f..dfdcfb4 100644
--- a/src/python/magnum/test/test_shaders_gl.py
+++ b/src/python/magnum/test/test_shaders_gl.py
@@ -41,7 +41,7 @@ class DistanceFieldGL(GLTestCase):
         self.assertEqual(b.flags, shaders.DistanceFieldVectorGL3D.Flags.TEXTURE_TRANSFORMATION)
 
     def test_uniforms_bindings(self):
-        a = shaders.DistanceFieldVectorGL3D(shaders.DistanceFieldVectorGL3D.Flags.TEXTURE_TRANSFORMATION)
+        a = shaders.DistanceFieldVectorGL3D(flags=shaders.DistanceFieldVectorGL3D.Flags.TEXTURE_TRANSFORMATION)
         a.color = (0.5, 1.0, 0.9)
         a.outline_color = (1.0, 0.5, 0.9, 0.3)
         a.outline_range = (0.5, 0.8)
@@ -64,11 +64,11 @@ class FlatGL(GLTestCase):
         a = shaders.FlatGL3D()
         self.assertEqual(a.flags, shaders.FlatGL3D.Flags.NONE)
 
-        b = shaders.FlatGL3D(shaders.FlatGL3D.Flags.TEXTURED|shaders.FlatGL3D.Flags.ALPHA_MASK)
+        b = shaders.FlatGL3D(flags=shaders.FlatGL3D.Flags.TEXTURED|shaders.FlatGL3D.Flags.ALPHA_MASK)
         self.assertEqual(b.flags, shaders.FlatGL3D.Flags.TEXTURED|shaders.FlatGL3D.Flags.ALPHA_MASK)
 
     def test_uniforms_bindings(self):
-        a = shaders.FlatGL3D(shaders.FlatGL3D.Flags.TEXTURED|shaders.FlatGL3D.Flags.ALPHA_MASK|shaders.FlatGL3D.Flags.TEXTURE_TRANSFORMATION)
+        a = shaders.FlatGL3D(flags=shaders.FlatGL3D.Flags.TEXTURED|shaders.FlatGL3D.Flags.ALPHA_MASK|shaders.FlatGL3D.Flags.TEXTURE_TRANSFORMATION)
         a.color = (0.5, 1.0, 0.9)
         a.transformation_projection_matrix = Matrix4.translation(Vector3.x_axis())
         a.alpha_mask = 0.3
@@ -106,16 +106,16 @@ class PhongGL(GLTestCase):
         self.assertEqual(a.flags, shaders.PhongGL.Flags.NONE)
         self.assertEqual(a.light_count, 1)
 
-        b = shaders.PhongGL(shaders.PhongGL.Flags.DIFFUSE_TEXTURE|shaders.PhongGL.Flags.ALPHA_MASK)
+        b = shaders.PhongGL(flags=shaders.PhongGL.Flags.DIFFUSE_TEXTURE|shaders.PhongGL.Flags.ALPHA_MASK)
         self.assertEqual(b.flags, shaders.PhongGL.Flags.DIFFUSE_TEXTURE|shaders.PhongGL.Flags.ALPHA_MASK)
         self.assertEqual(b.light_count, 1)
 
-        c = shaders.PhongGL(shaders.PhongGL.Flags.NONE, 3)
+        c = shaders.PhongGL(flags=shaders.PhongGL.Flags.NONE, light_count=3)
         self.assertEqual(c.flags, shaders.PhongGL.Flags.NONE)
         self.assertEqual(c.light_count, 3)
 
     def test_uniforms_bindings(self):
-        a = shaders.PhongGL(shaders.PhongGL.Flags.ALPHA_MASK|shaders.PhongGL.Flags.AMBIENT_TEXTURE|shaders.PhongGL.Flags.DIFFUSE_TEXTURE|shaders.PhongGL.Flags.SPECULAR_TEXTURE|shaders.PhongGL.Flags.NORMAL_TEXTURE|shaders.PhongGL.Flags.TEXTURE_TRANSFORMATION, 2)
+        a = shaders.PhongGL(flags=shaders.PhongGL.Flags.ALPHA_MASK|shaders.PhongGL.Flags.AMBIENT_TEXTURE|shaders.PhongGL.Flags.DIFFUSE_TEXTURE|shaders.PhongGL.Flags.SPECULAR_TEXTURE|shaders.PhongGL.Flags.NORMAL_TEXTURE|shaders.PhongGL.Flags.TEXTURE_TRANSFORMATION, light_count=2)
         a.diffuse_color = (0.5, 1.0, 0.9)
         a.transformation_matrix = Matrix4.translation(Vector3.x_axis())
         a.projection_matrix = Matrix4.zero_init()
@@ -169,11 +169,11 @@ class DistanceFieldGL(GLTestCase):
         a = shaders.VectorGL3D()
         self.assertEqual(a.flags, shaders.VectorGL3D.Flags.NONE)
 
-        b = shaders.VectorGL3D(shaders.VectorGL3D.Flags.TEXTURE_TRANSFORMATION)
+        b = shaders.VectorGL3D(flags=shaders.VectorGL3D.Flags.TEXTURE_TRANSFORMATION)
         self.assertEqual(b.flags, shaders.VectorGL3D.Flags.TEXTURE_TRANSFORMATION)
 
     def test_uniforms_bindings(self):
-        a = shaders.VectorGL3D(shaders.VectorGL3D.Flags.TEXTURE_TRANSFORMATION)
+        a = shaders.VectorGL3D(flags=shaders.VectorGL3D.Flags.TEXTURE_TRANSFORMATION)
         a.color = (0.5, 1.0, 0.9)
         a.background_color = (1.0, 0.5, 0.9, 0.3)
         a.transformation_projection_matrix = Matrix4.translation(Vector3.x_axis())