diff --git a/doc/changelog.dox b/doc/changelog.dox
index 7bbd08b75..83050843f 100644
--- a/doc/changelog.dox
+++ b/doc/changelog.dox
@@ -693,6 +693,9 @@ See also:
     was a rarely (if ever) used feature.
 -   @cpp DebugTools::Profiler @ce is obsolete, replaced with a much more
     flexible and extensible @ref DebugTools::FrameProfiler
+-   @cpp Math::NoInitT @ce and @cpp Math::NoInit @ce constructor tags are
+    deprecated in favor of @ref NoInitT and @ref NoInit directly in the
+    @ref Magnum namespace
 
 @subsection changelog-latest-compatibility Potential compatibility breakages, removed APIs
 
diff --git a/doc/snippets/MagnumMath.cpp b/doc/snippets/MagnumMath.cpp
index b7efc9bdd..0b9ae7438 100644
--- a/doc/snippets/MagnumMath.cpp
+++ b/doc/snippets/MagnumMath.cpp
@@ -601,7 +601,7 @@ Quaternion q1;
 Quaternion q2{Math::IdentityInit};
 
 /* Avoid unnecessary initialization if is overwritten anyway */
-Matrix4 projection{Math::NoInit};
+Matrix4 projection{NoInit};
 if(orthographic)
     projection = Matrix4::orthographicProjection({4.0f, 3.0f}, 0.1f, 100.0f);
 else
diff --git a/src/Magnum/GL/AbstractTexture.cpp b/src/Magnum/GL/AbstractTexture.cpp
index 5d970db59..7c848855b 100644
--- a/src/Magnum/GL/AbstractTexture.cpp
+++ b/src/Magnum/GL/AbstractTexture.cpp
@@ -2061,7 +2061,7 @@ Math::Vector<1, GLint> AbstractTexture::DataHelper<1>::compressedBlockSize(const
 }
 
 Vector2i AbstractTexture::DataHelper<2>::compressedBlockSize(const GLenum target, const TextureFormat format) {
-    Vector2i value{Math::NoInit};
+    Vector2i value{NoInit};
     glGetInternalformativ(target, GLenum(format), GL_TEXTURE_COMPRESSED_BLOCK_WIDTH, 1, &value.x());
     glGetInternalformativ(target, GLenum(format), GL_TEXTURE_COMPRESSED_BLOCK_HEIGHT, 1, &value.y());
     return value;
diff --git a/src/Magnum/Math/Algorithms/Test/SvdTest.cpp b/src/Magnum/Math/Algorithms/Test/SvdTest.cpp
index 1479c61ac..a092ab524 100644
--- a/src/Magnum/Math/Algorithms/Test/SvdTest.cpp
+++ b/src/Magnum/Math/Algorithms/Test/SvdTest.cpp
@@ -60,9 +60,9 @@ template<class T> void SvdTest::test() {
         Vector8<T>{T{ 7}, T{ 8}, T{  3}, T{ 4}, T{ 4}, T{-1}, T{ 1}, T{ 2}}};
     const Vector5<T> expected(std::sqrt(T{1248}), T{0}, T{20}, std::sqrt(T{384}), T{0});
 
-    Matrix5x8<T> u{NoInit};
-    Vector5<T> w{NoInit};
-    Matrix5<T> v{NoInit};
+    Matrix5x8<T> u{Magnum::NoInit};
+    Vector5<T> w{Magnum::NoInit};
+    Matrix5<T> v{Magnum::NoInit};
     std::tie(u, w, v) = Algorithms::svd(a);
 
     /* Test composition */
@@ -103,9 +103,9 @@ void SvdTest::decomposeRotationShear() {
 
     Matrix4 a = Matrix4::scaling({1.5f, 2.0f, 1.0f})*Matrix4::rotationZ(35.0_degf);
 
-    Matrix3x3 u{NoInit};
-    Vector3 w{NoInit};
-    Matrix3x3 v{NoInit};
+    Matrix3x3 u{Magnum::NoInit};
+    Vector3 w{Magnum::NoInit};
+    Matrix3x3 v{Magnum::NoInit};
     std::tie(u, w, v) = Algorithms::svd(a.rotationScaling());
 
     CORRADE_COMPARE(u*Matrix3x3::fromDiagonal(w)*v.transposed(), a.rotationScaling());
diff --git a/src/Magnum/Math/Angle.h b/src/Magnum/Math/Angle.h
index 63c3633c4..10a431f31 100644
--- a/src/Magnum/Math/Angle.h
+++ b/src/Magnum/Math/Angle.h
@@ -112,7 +112,7 @@ template<class T> class Deg: public Unit<Deg, T> {
         constexpr explicit Deg(ZeroInitT) noexcept: Unit<Math::Deg, T>{ZeroInit} {}
 
         /** @brief Construct without initializing the contents */
-        explicit Deg(NoInitT) noexcept: Unit<Math::Deg, T>{NoInit} {}
+        explicit Deg(Magnum::NoInitT) noexcept: Unit<Math::Deg, T>{Magnum::NoInit} {}
 
         /** @brief Explicit constructor from unitless type */
         constexpr explicit Deg(T value) noexcept: Unit<Math::Deg, T>(value) {}
@@ -181,7 +181,7 @@ template<class T> class Rad: public Unit<Rad, T> {
         constexpr explicit Rad(ZeroInitT) noexcept: Unit<Math::Rad, T>{ZeroInit} {}
 
         /** @brief Construct without initializing the contents */
-        explicit Rad(NoInitT) noexcept: Unit<Math::Rad, T>{NoInit} {}
+        explicit Rad(Magnum::NoInitT) noexcept: Unit<Math::Rad, T>{Magnum::NoInit} {}
 
         /** @brief Construct from unitless type */
         constexpr explicit Rad(T value) noexcept: Unit<Math::Rad, T>(value) {}
diff --git a/src/Magnum/Math/Bezier.h b/src/Magnum/Math/Bezier.h
index b89db55e8..c63039c01 100644
--- a/src/Magnum/Math/Bezier.h
+++ b/src/Magnum/Math/Bezier.h
@@ -112,7 +112,7 @@ template<UnsignedInt order, UnsignedInt dimensions, class T> class Bezier {
         constexpr explicit Bezier(ZeroInitT) noexcept: Bezier<order, dimensions, T>{typename Implementation::GenerateSequence<order + 1>::Type{}, ZeroInit} {}
 
         /** @brief Construct Bézier without initializing the contents */
-        explicit Bezier(NoInitT) noexcept: Bezier<order, dimensions, T>{typename Implementation::GenerateSequence<order + 1>::Type{}, NoInit} {}
+        explicit Bezier(Magnum::NoInitT) noexcept: Bezier<order, dimensions, T>{typename Implementation::GenerateSequence<order + 1>::Type{}, Magnum::NoInit} {}
 
         /** @brief Construct Bézier curve with given array of control points */
         template<typename... U> constexpr /*implicit*/ Bezier(const Vector<dimensions, T>& first, U... next) noexcept: _data{first, next...} {
diff --git a/src/Magnum/Math/BoolVector.h b/src/Magnum/Math/BoolVector.h
index 10eddfeaf..e967a152e 100644
--- a/src/Magnum/Math/BoolVector.h
+++ b/src/Magnum/Math/BoolVector.h
@@ -112,7 +112,7 @@ template<std::size_t size> class BoolVector {
         constexpr explicit BoolVector(ZeroInitT) noexcept: _data{} {}
 
         /** @brief Construct without initializing the contents */
-        explicit BoolVector(NoInitT) noexcept {}
+        explicit BoolVector(Magnum::NoInitT) noexcept {}
 
         /**
          * @brief Construct a boolean vector from segment values
@@ -389,7 +389,7 @@ template<std::size_t size> inline bool BoolVector<size>::none() const {
 }
 
 template<std::size_t size> inline BoolVector<size> BoolVector<size>::operator~() const {
-    BoolVector<size> out{NoInit};
+    BoolVector<size> out{Magnum::NoInit};
 
     for(std::size_t i = 0; i != DataSize; ++i)
         out._data[i] = ~_data[i];
diff --git a/src/Magnum/Math/Color.h b/src/Magnum/Math/Color.h
index a363d9c92..6d2fa9f05 100644
--- a/src/Magnum/Math/Color.h
+++ b/src/Magnum/Math/Color.h
@@ -462,8 +462,8 @@ template<class T> class Color3: public Vector3<T> {
          */
         constexpr explicit Color3(ZeroInitT) noexcept: Vector3<T>{ZeroInit} {}
 
-        /** @copydoc Vector::Vector(NoInitT) */
-        explicit Color3(NoInitT) noexcept: Vector3<T>{NoInit} {}
+        /** @copydoc Vector::Vector(Magnum::NoInitT) */
+        explicit Color3(Magnum::NoInitT) noexcept: Vector3<T>{Magnum::NoInit} {}
 
         /**
          * @brief Gray constructor
@@ -875,7 +875,7 @@ class Color4: public Vector4<T> {
         constexpr explicit Color4(ZeroInitT) noexcept: Vector4<T>{ZeroInit} {}
 
         /** @copydoc Vector::Vector(NoInitT) */
-        explicit Color4(NoInitT) noexcept: Vector4<T>{NoInit} {}
+        explicit Color4(Magnum::NoInitT) noexcept: Vector4<T>{Magnum::NoInit} {}
 
         /**
          * @copydoc Color3::Color3(T)
@@ -1087,7 +1087,7 @@ template<class T> struct ColorHsv {
     constexpr explicit ColorHsv(ZeroInitT) noexcept: hue{}, saturation{}, value{} {}
 
     /** @brief Construct without initializing the contents */
-    explicit ColorHsv(NoInitT) noexcept: hue{NoInit} /* and the others not */ {}
+    explicit ColorHsv(Magnum::NoInitT) noexcept: hue{Magnum::NoInit} /* and the others not */ {}
 
     /** @brief Constructor */
     constexpr /*implicit*/ ColorHsv(Deg<T> hue, T saturation, T value) noexcept: hue{hue}, saturation{saturation}, value{value} {}
diff --git a/src/Magnum/Math/Complex.h b/src/Magnum/Math/Complex.h
index 206393154..a38d3d832 100644
--- a/src/Magnum/Math/Complex.h
+++ b/src/Magnum/Math/Complex.h
@@ -145,7 +145,7 @@ template<class T> class Complex {
         constexpr explicit Complex(ZeroInitT) noexcept: _real{}, _imaginary{} {}
 
         /** @brief Construct without initializing the contents */
-        explicit Complex(NoInitT) noexcept {}
+        explicit Complex(Magnum::NoInitT) noexcept {}
 
         /**
          * @brief Construct a complex number from real and imaginary part
diff --git a/src/Magnum/Math/CubicHermite.h b/src/Magnum/Math/CubicHermite.h
index 1d3b2d68d..75460dca2 100644
--- a/src/Magnum/Math/CubicHermite.h
+++ b/src/Magnum/Math/CubicHermite.h
@@ -126,7 +126,7 @@ template<class T> class CubicHermite {
         template<class U = T, class = typename std::enable_if<std::is_constructible<U, IdentityInitT>::value>::type> constexpr explicit CubicHermite(IdentityInitT) noexcept: _inTangent{ZeroInit}, _point{IdentityInit}, _outTangent{ZeroInit} {}
 
         /** @brief Construct cubic Hermite spline point without initializing its contents */
-        explicit CubicHermite(NoInitT) noexcept: CubicHermite{NoInit, typename std::conditional<std::is_constructible<T, NoInitT>::value, NoInitT*, void*>::type{}} {}
+        explicit CubicHermite(Magnum::NoInitT) noexcept: CubicHermite{Magnum::NoInit, typename std::conditional<std::is_constructible<T, Magnum::NoInitT>::value, Magnum::NoInitT*, void*>::type{}} {}
 
         /**
          * @brief Construct cubic Hermite spline point with given control points
@@ -187,8 +187,8 @@ template<class T> class CubicHermite {
 
         /* Called from CubicHermite(NoInit), either using the NoInit
            constructor (if available) or not doing anything */
-        explicit CubicHermite(NoInitT, NoInitT*) noexcept: _inTangent{NoInit}, _point{NoInit}, _outTangent{NoInit} {}
-        explicit CubicHermite(NoInitT, void*) noexcept {}
+        explicit CubicHermite(Magnum::NoInitT, Magnum::NoInitT*) noexcept: _inTangent{Magnum::NoInit}, _point{Magnum::NoInit}, _outTangent{Magnum::NoInit} {}
+        explicit CubicHermite(Magnum::NoInitT, void*) noexcept {}
 
         T _inTangent;
         T _point;
diff --git a/src/Magnum/Math/Dual.h b/src/Magnum/Math/Dual.h
index 68a96af6c..de77964de 100644
--- a/src/Magnum/Math/Dual.h
+++ b/src/Magnum/Math/Dual.h
@@ -81,8 +81,8 @@ template<class T> class Dual {
         explicit Dual(NoInitT) noexcept;
         #else
         /* MSVC 2015 can't handle {} instead of ::value */
-        template<class U = T, class = typename std::enable_if<std::is_standard_layout<U>::value && std::is_trivial<U>::value>::type> explicit Dual(NoInitT) noexcept {}
-        template<class U = T, class V = T, class = typename std::enable_if<std::is_constructible<U, NoInitT>::value>::type> explicit Dual(NoInitT) noexcept: _real{NoInit}, _dual{NoInit} {}
+        template<class U = T, class = typename std::enable_if<std::is_standard_layout<U>::value && std::is_trivial<U>::value>::type> explicit Dual(Magnum::NoInitT) noexcept {}
+        template<class U = T, class V = T, class = typename std::enable_if<std::is_constructible<U, Magnum::NoInitT>::value>::type> explicit Dual(Magnum::NoInitT) noexcept: _real{Magnum::NoInit}, _dual{Magnum::NoInit} {}
         #endif
 
         /**
diff --git a/src/Magnum/Math/DualComplex.h b/src/Magnum/Math/DualComplex.h
index b59f3580d..3af8cd492 100644
--- a/src/Magnum/Math/DualComplex.h
+++ b/src/Magnum/Math/DualComplex.h
@@ -126,7 +126,7 @@ template<class T> class DualComplex: public Dual<Complex<T>> {
         constexpr explicit DualComplex(ZeroInitT) noexcept: Dual<Complex<T>>{Complex<T>{ZeroInit}, Complex<T>{ZeroInit}} {}
 
         /** @brief Construct without initializing the contents */
-        explicit DualComplex(NoInitT) noexcept: Dual<Complex<T>>{NoInit} {}
+        explicit DualComplex(Magnum::NoInitT) noexcept: Dual<Complex<T>>{Magnum::NoInit} {}
 
         /**
          * @brief Construct dual complex number from real and dual part
diff --git a/src/Magnum/Math/DualQuaternion.h b/src/Magnum/Math/DualQuaternion.h
index 9d9cef1f3..356e13235 100644
--- a/src/Magnum/Math/DualQuaternion.h
+++ b/src/Magnum/Math/DualQuaternion.h
@@ -266,7 +266,7 @@ template<class T> class DualQuaternion: public Dual<Quaternion<T>> {
         constexpr explicit DualQuaternion(ZeroInitT) noexcept: Dual<Quaternion<T>>{Quaternion<T>{ZeroInit}, Quaternion<T>{ZeroInit}} {}
 
         /** @brief Construct without initializing the contents */
-        explicit DualQuaternion(NoInitT) noexcept: Dual<Quaternion<T>>{NoInit} {}
+        explicit DualQuaternion(Magnum::NoInitT) noexcept: Dual<Quaternion<T>>{Magnum::NoInit} {}
 
         /**
          * @brief Construct dual quaternion from real and dual part
diff --git a/src/Magnum/Math/Frustum.h b/src/Magnum/Math/Frustum.h
index 9dc673d87..49cc8dd27 100644
--- a/src/Magnum/Math/Frustum.h
+++ b/src/Magnum/Math/Frustum.h
@@ -85,7 +85,7 @@ template<class T> class Frustum {
         constexpr explicit Frustum(IdentityInitT) noexcept;
 
         /** @brief Construct a frustum without initializing the contents */
-        explicit Frustum(NoInitT) noexcept: _data{Vector4<T>{NoInit}, Vector4<T>{NoInit}, Vector4<T>{NoInit}, Vector4<T>{NoInit}, Vector4<T>{NoInit}, Vector4<T>{NoInit}} {}
+        explicit Frustum(Magnum::NoInitT) noexcept: _data{Vector4<T>{Magnum::NoInit}, Vector4<T>{Magnum::NoInit}, Vector4<T>{Magnum::NoInit}, Vector4<T>{Magnum::NoInit}, Vector4<T>{Magnum::NoInit}, Vector4<T>{Magnum::NoInit}} {}
 
         /**
          * @brief Construct a frustum from plane equations
diff --git a/src/Magnum/Math/Functions.h b/src/Magnum/Math/Functions.h
index 7404b3ca7..c0ea46235 100644
--- a/src/Magnum/Math/Functions.h
+++ b/src/Magnum/Math/Functions.h
@@ -245,7 +245,7 @@ template<class T> constexpr typename std::enable_if<IsScalar<T>::value, T>::type
 
 /** @overload */
 template<std::size_t size, class T> inline Vector<size, T> min(const Vector<size, T>& value, const Vector<size, T>& min) {
-    Vector<size, T> out{NoInit};
+    Vector<size, T> out{Magnum::NoInit};
     for(std::size_t i = 0; i != size; ++i)
         out[i] = Math::min(value[i], min[i]);
     return out;
@@ -253,7 +253,7 @@ template<std::size_t size, class T> inline Vector<size, T> min(const Vector<size
 
 /** @overload */
 template<std::size_t size, class T> inline Vector<size, T> min(const Vector<size, T>& value, T min) {
-    Vector<size, T> out{NoInit};
+    Vector<size, T> out{Magnum::NoInit};
     for(std::size_t i = 0; i != size; ++i)
         out[i] = Math::min(value[i], min);
     return out;
@@ -272,7 +272,7 @@ template<class T> constexpr typename std::enable_if<IsScalar<T>::value, T>::type
 
 /** @overload */
 template<std::size_t size, class T> Vector<size, T> max(const Vector<size, T>& value, const Vector<size, T>& max) {
-    Vector<size, T> out{NoInit};
+    Vector<size, T> out{Magnum::NoInit};
     for(std::size_t i = 0; i != size; ++i)
         out[i] = Math::max(value[i], max[i]);
     return out;
@@ -280,7 +280,7 @@ template<std::size_t size, class T> Vector<size, T> max(const Vector<size, T>& v
 
 /** @overload */
 template<std::size_t size, class T> inline Vector<size, T> max(const Vector<size, T>& value, T max) {
-    Vector<size, T> out{NoInit};
+    Vector<size, T> out{Magnum::NoInit};
     for(std::size_t i = 0; i != size; ++i)
         out[i] = Math::max(value[i], max);
     return out;
@@ -323,7 +323,7 @@ template<class T> constexpr typename std::enable_if<IsScalar<T>::value, T>::type
 
 /** @overload */
 template<std::size_t size, class T> inline Vector<size, T> clamp(const Vector<size, T>& value, const Vector<size, T>& min, const Vector<size, T>& max) {
-    Vector<size, T> out{NoInit};
+    Vector<size, T> out{Magnum::NoInit};
     for(std::size_t i = 0; i != size; ++i)
         out[i] = Math::clamp(value[i], min[i], max[i]);
     return out;
@@ -331,7 +331,7 @@ template<std::size_t size, class T> inline Vector<size, T> clamp(const Vector<si
 
 /** @overload */
 template<std::size_t size, class T> inline Vector<size, T> clamp(const Vector<size, T>& value, T min, T max) {
-    Vector<size, T> out{NoInit};
+    Vector<size, T> out{Magnum::NoInit};
     for(std::size_t i = 0; i != size; ++i)
         out[i] = Math::clamp(value[i], min, max);
     return out;
@@ -350,7 +350,7 @@ template<class T> inline typename std::enable_if<IsScalar<T>::value, T>::type si
 
 /** @overload */
 template<std::size_t size, class T> inline Vector<size, T> sign(const Vector<size, T>& a) {
-    Vector<size, T> out{NoInit};
+    Vector<size, T> out{Magnum::NoInit};
     for(std::size_t i = 0; i != size; ++i)
         out[i] = Math::sign(a[i]);
     return out;
@@ -363,7 +363,7 @@ template<class T> inline typename std::enable_if<IsScalar<T>::value, T>::type ab
 
 /** @overload */
 template<std::size_t size, class T> inline Vector<size, T> abs(const Vector<size, T>& a) {
-    Vector<size, T> out{NoInit};
+    Vector<size, T> out{Magnum::NoInit};
     for(std::size_t i = 0; i != size; ++i)
         out[i] = Math::abs(a[i]);
     return out;
@@ -376,7 +376,7 @@ template<class T> inline typename std::enable_if<IsScalar<T>::value, T>::type fl
 
 /** @overload */
 template<std::size_t size, class T> inline Vector<size, T> floor(const Vector<size, T>& a) {
-    Vector<size, T> out{NoInit};
+    Vector<size, T> out{Magnum::NoInit};
     for(std::size_t i = 0; i != size; ++i)
         out[i] = Math::floor(a[i]);
     return out;
@@ -389,7 +389,7 @@ template<class T> inline typename std::enable_if<IsScalar<T>::value, T>::type ro
 
 /** @overload */
 template<std::size_t size, class T> inline Vector<size, T> round(const Vector<size, T>& a) {
-    Vector<size, T> out{NoInit};
+    Vector<size, T> out{Magnum::NoInit};
     for(std::size_t i = 0; i != size; ++i)
         out[i] = Math::round(a[i]);
     return out;
@@ -402,7 +402,7 @@ template<class T> inline typename std::enable_if<IsScalar<T>::value, T>::type ce
 
 /** @overload */
 template<std::size_t size, class T> inline Vector<size, T> ceil(const Vector<size, T>& a) {
-    Vector<size, T> out{NoInit};
+    Vector<size, T> out{Magnum::NoInit};
     for(std::size_t i = 0; i != size; ++i)
         out[i] = Math::ceil(a[i]);
     return out;
@@ -450,7 +450,7 @@ component-wise selection from either @p a or @p b based on values in @p t.
 @m_keyword{mix(),GLSL mix(),}
 */
 template<std::size_t size, class T> inline Vector<size, T> lerp(const Vector<size, T>& a, const Vector<size, T>& b, const BoolVector<size>& t) {
-    Vector<size, T> out{NoInit};
+    Vector<size, T> out{Magnum::NoInit};
     for(std::size_t i = 0; i != size; ++i)
         out[i] = t[i] ? b[i] : a[i];
     return out;
@@ -599,7 +599,7 @@ template<UnsignedInt exponent, class T> constexpr typename std::enable_if<IsScal
 
 /** @overload */
 template<UnsignedInt exponent, std::size_t size, class T> inline Vector<size, T> pow(const Vector<size, T>& base) {
-    Vector<size, T> out{NoInit};
+    Vector<size, T> out{Magnum::NoInit};
     for(std::size_t i = 0; i != size; ++i)
         out[i] = Math::pow<exponent>(base[i]);
     return out;
@@ -619,7 +619,7 @@ template<class T> inline typename std::enable_if<IsScalar<T>::value, T>::type po
 
 /** @overload */
 template<std::size_t size, class T> inline Vector<size, T> pow(const Vector<size, T>& base, T exponent) {
-    Vector<size, T> out{NoInit};
+    Vector<size, T> out{Magnum::NoInit};
     for(std::size_t i = 0; i != size; ++i)
         out[i] = Math::pow(base[i], exponent);
     return out;
@@ -638,7 +638,7 @@ template<class T> inline typename std::enable_if<IsScalar<T>::value, T>::type sq
 
 /** @overload */
 template<std::size_t size, class T> inline Vector<size, T> sqrt(const Vector<size, T>& a) {
-    Vector<size, T> out{NoInit};
+    Vector<size, T> out{Magnum::NoInit};
     for(std::size_t i = 0; i != size; ++i)
         out[i] = Math::sqrt(a[i]);
     return out;
diff --git a/src/Magnum/Math/Half.h b/src/Magnum/Math/Half.h
index 960e023c0..581947a51 100644
--- a/src/Magnum/Math/Half.h
+++ b/src/Magnum/Math/Half.h
@@ -102,7 +102,7 @@ class Half {
         explicit Half(Double value) noexcept: _data{packHalf(Float(value))} {}
 
         /** @brief Construct without initializing the contents */
-        explicit Half(NoInitT) noexcept {}
+        explicit Half(Magnum::NoInitT) noexcept {}
 
         /**
          * @brief Equality comparison
diff --git a/src/Magnum/Math/Matrix.h b/src/Magnum/Math/Matrix.h
index 395623fac..4cb0d83f1 100644
--- a/src/Magnum/Math/Matrix.h
+++ b/src/Magnum/Math/Matrix.h
@@ -85,8 +85,8 @@ template<std::size_t size, class T> class Matrix: public RectangularMatrix<size,
         /** @copydoc RectangularMatrix::RectangularMatrix(ZeroInitT) */
         constexpr explicit Matrix(ZeroInitT) noexcept: RectangularMatrix<size, size, T>{ZeroInit} {}
 
-        /** @copydoc RectangularMatrix::RectangularMatrix(NoInitT) */
-        constexpr explicit Matrix(NoInitT) noexcept: RectangularMatrix<size, size, T>{NoInit} {}
+        /** @copydoc RectangularMatrix::RectangularMatrix(Magnum::NoInitT) */
+        constexpr explicit Matrix(Magnum::NoInitT) noexcept: RectangularMatrix<size, size, T>{Magnum::NoInit} {}
 
         /** @brief Construct from column vectors */
         template<class ...U> constexpr /*implicit*/ Matrix(const Vector<size, T>& first, const U&... next) noexcept: RectangularMatrix<size, size, T>(first, next...) {}
@@ -475,7 +475,7 @@ template<std::size_t size, class T> bool Matrix<size, T>::isOrthogonal() const {
 }
 
 template<std::size_t size, class T> Matrix<size-1, T> Matrix<size, T>::ij(const std::size_t skipCol, const std::size_t skipRow) const {
-    Matrix<size-1, T> out{NoInit};
+    Matrix<size-1, T> out{Magnum::NoInit};
 
     /* Using ._data[] instead of [] to avoid function call indirection on debug
        builds (saves a lot, yet doesn't obfuscate too much) */
@@ -493,7 +493,7 @@ template<std::size_t size, class T> T Matrix<size, T>::cofactor(std::size_t col,
 }
 
 template<std::size_t size, class T> Matrix<size, T> Matrix<size, T>::comatrix() const {
-    Matrix<size, T> out{NoInit};
+    Matrix<size, T> out{Magnum::NoInit};
 
     /* Using ._data[] instead of [] to avoid function call indirection on debug
        builds (saves a lot, yet doesn't obfuscate too much) */
@@ -505,7 +505,7 @@ template<std::size_t size, class T> Matrix<size, T> Matrix<size, T>::comatrix()
 }
 
 template<std::size_t size, class T> Matrix<size, T> Matrix<size, T>::adjugate() const {
-    Matrix<size, T> out{NoInit};
+    Matrix<size, T> out{Magnum::NoInit};
 
     /* Same as comatrix(), except using cofactor(row, col) instead of
        cofactor(col, row). Could also be just comatrix().transpose() but since
diff --git a/src/Magnum/Math/Matrix3.h b/src/Magnum/Math/Matrix3.h
index 6eeb71f7f..ad55716a5 100644
--- a/src/Magnum/Math/Matrix3.h
+++ b/src/Magnum/Math/Matrix3.h
@@ -213,8 +213,8 @@ template<class T> class Matrix3: public Matrix3x3<T> {
         /** @copydoc Matrix::Matrix(ZeroInitT) */
         constexpr explicit Matrix3(ZeroInitT) noexcept: Matrix3x3<T>{ZeroInit} {}
 
-        /** @copydoc Matrix::Matrix(NoInitT) */
-        constexpr explicit Matrix3(NoInitT) noexcept: Matrix3x3<T>{NoInit} {}
+        /** @copydoc Matrix::Matrix(Magnum::NoInitT) */
+        constexpr explicit Matrix3(Magnum::NoInitT) noexcept: Matrix3x3<T>{Magnum::NoInit} {}
 
         /** @brief Construct from column vectors */
         constexpr /*implicit*/ Matrix3(const Vector3<T>& first, const Vector3<T>& second, const Vector3<T>& third) noexcept: Matrix3x3<T>(first, second, third) {}
diff --git a/src/Magnum/Math/Matrix4.h b/src/Magnum/Math/Matrix4.h
index 6b31f0b87..41190f32e 100644
--- a/src/Magnum/Math/Matrix4.h
+++ b/src/Magnum/Math/Matrix4.h
@@ -447,8 +447,8 @@ template<class T> class Matrix4: public Matrix4x4<T> {
         /** @copydoc Matrix::Matrix(ZeroInitT) */
         constexpr explicit Matrix4(ZeroInitT) noexcept: Matrix4x4<T>{ZeroInit} {}
 
-        /** @copydoc Matrix::Matrix(NoInitT) */
-        constexpr explicit Matrix4(NoInitT) noexcept: Matrix4x4<T>{NoInit} {}
+        /** @copydoc Matrix::Matrix(Magnum::NoInitT) */
+        constexpr explicit Matrix4(Magnum::NoInitT) noexcept: Matrix4x4<T>{Magnum::NoInit} {}
 
         /** @brief Construct from column vectors */
         constexpr /*implicit*/ Matrix4(const Vector4<T>& first, const Vector4<T>& second, const Vector4<T>& third, const Vector4<T>& fourth) noexcept: Matrix4x4<T>(first, second, third, fourth) {}
diff --git a/src/Magnum/Math/Packing.h b/src/Magnum/Math/Packing.h
index 9cb3b491e..39b2bfce4 100644
--- a/src/Magnum/Math/Packing.h
+++ b/src/Magnum/Math/Packing.h
@@ -99,7 +99,7 @@ template<class FloatingPoint, class Integral, UnsignedInt bits = sizeof(Integral
 template<class FloatingPoint, std::size_t size, class Integral, UnsignedInt bits = sizeof(Integral)*8> FloatingPoint unpack(const Vector<size, Integral>& value) {
     static_assert(FloatingPoint::Size == size,
         "return vector type should have the same size as input vector type");
-    FloatingPoint out{NoInit};
+    FloatingPoint out{Magnum::NoInit};
     for(std::size_t i = 0; i != size; ++i)
         out[i] = unpack<typename FloatingPoint::Type, Integral, bits>(value[i]);
     return out;
@@ -148,7 +148,7 @@ template<class Integral, class FloatingPoint, UnsignedInt bits = sizeof(Integral
 template<class Integral, std::size_t size, class FloatingPoint, UnsignedInt bits = sizeof(typename Integral::Type)*8> Integral pack(const Vector<size, FloatingPoint>& value) {
     static_assert(Integral::Size == size,
         "return vector type should have the same size as input vector type");
-    Integral out{NoInit};
+    Integral out{Magnum::NoInit};
     for(std::size_t i = 0; i != size; ++i)
         out[i] = pack<typename Integral::Type, FloatingPoint, bits>(value[i]);
     return out;
@@ -190,7 +190,7 @@ MAGNUM_EXPORT UnsignedShort packHalf(Float value);
 
 /** @overload */
 template<std::size_t size> Vector<size, UnsignedShort> packHalf(const Vector<size, Float>& value) {
-    Vector<size, UnsignedShort> out{NoInit};
+    Vector<size, UnsignedShort> out{Magnum::NoInit};
     for(std::size_t i = 0; i != size; ++i)
         out[i] = packHalf(value[i]);
     return out;
@@ -211,7 +211,7 @@ MAGNUM_EXPORT Float unpackHalf(UnsignedShort value);
 
 /** @overload */
 template<std::size_t size> Vector<size, Float> unpackHalf(const Vector<size, UnsignedShort>& value) {
-    Vector<size, Float> out{NoInit};
+    Vector<size, Float> out{Magnum::NoInit};
     for(std::size_t i = 0; i != size; ++i)
         out[i] = unpackHalf(value[i]);
     return out;
diff --git a/src/Magnum/Math/Quaternion.h b/src/Magnum/Math/Quaternion.h
index 1f9ceda26..262dffebf 100644
--- a/src/Magnum/Math/Quaternion.h
+++ b/src/Magnum/Math/Quaternion.h
@@ -318,7 +318,7 @@ template<class T> class Quaternion {
         constexpr explicit Quaternion(ZeroInitT) noexcept: _vector{ZeroInit}, _scalar{T{0}} {}
 
         /** @brief Construct without initializing the contents */
-        explicit Quaternion(NoInitT) noexcept: _vector{NoInit} {}
+        explicit Quaternion(Magnum::NoInitT) noexcept: _vector{Magnum::NoInit} {}
 
         /**
          * @brief Construct from a vector and a scalar
@@ -783,7 +783,7 @@ template<class T> Vector3<Rad<T>> Quaternion<T>::toEuler() const {
     CORRADE_ASSERT(isNormalized(),
         "Math::Quaternion::toEuler():" << *this << "is not normalized", {});
 
-    Vector3<Rad<T>> euler{NoInit};
+    Vector3<Rad<T>> euler{Magnum::NoInit};
 
     Matrix3x3<T> rotMatrix = toMatrix();
 
diff --git a/src/Magnum/Math/Range.h b/src/Magnum/Math/Range.h
index e0907531b..1627ffa3b 100644
--- a/src/Magnum/Math/Range.h
+++ b/src/Magnum/Math/Range.h
@@ -111,7 +111,7 @@ template<UnsignedInt dimensions, class T> class Range {
         constexpr explicit Range(ZeroInitT) noexcept: Range<dimensions, T>{ZeroInit, typename std::conditional<dimensions == 1, void*, ZeroInitT*>::type{}} {}
 
         /** @brief Construct without initializing the contents */
-        explicit Range(NoInitT) noexcept: Range<dimensions, T>{NoInit, typename std::conditional<dimensions == 1, void*, NoInitT*>::type{}} {}
+        explicit Range(Magnum::NoInitT) noexcept: Range<dimensions, T>{Magnum::NoInit, typename std::conditional<dimensions == 1, void*, Magnum::NoInitT*>::type{}} {}
 
         /** @brief Construct a range from minimal and maximal coordinates */
         constexpr /*implicit*/ Range(const VectorType& min, const VectorType& max) noexcept: _min{min}, _max{max} {}
@@ -306,8 +306,8 @@ template<UnsignedInt dimensions, class T> class Range {
 
         /* Called from Range(NoInit), either using the NoInit constructor (if
            available) or not doing anything */
-        explicit Range(NoInitT, NoInitT*) noexcept: _min{NoInit}, _max{NoInit} {}
-        explicit Range(NoInitT, void*) noexcept {}
+        explicit Range(Magnum::NoInitT, Magnum::NoInitT*) noexcept: _min{Magnum::NoInit}, _max{Magnum::NoInit} {}
+        explicit Range(Magnum::NoInitT, void*) noexcept {}
 
         /* Called from data(), always returning a T* */
         constexpr const VectorType* dataInternal(void*) const { return &_min; }
@@ -373,7 +373,7 @@ template<class T> class Range2D: public Range<2, T> {
         constexpr explicit Range2D(ZeroInitT) noexcept: Range<2, T>{ZeroInit} {}
 
         /** @copydoc Range(NoInitT) */
-        explicit Range2D(NoInitT) noexcept: Range<2, T>{NoInit} {}
+        explicit Range2D(Magnum::NoInitT) noexcept: Range<2, T>{Magnum::NoInit} {}
 
         /** @copydoc Range(const VectorType&, const VectorType&) */
         constexpr /*implicit*/ Range2D(const Vector2<T>& min, const Vector2<T>& max) noexcept: Range<2, T>(min, max) {}
@@ -526,8 +526,8 @@ template<class T> class Range3D: public Range<3, T> {
         /** @copydoc Range(ZeroInitT) */
         constexpr explicit Range3D(ZeroInitT) noexcept: Range<3, T>{ZeroInit} {}
 
-        /** @brief @copybrief Range(NoInitT) */
-        explicit Range3D(NoInitT) noexcept: Range<3, T>{NoInit} {}
+        /** @brief @copybrief Range(Magnum::NoInitT) */
+        explicit Range3D(Magnum::NoInitT) noexcept: Range<3, T>{Magnum::NoInit} {}
 
         /** @copydoc Range(const VectorType&, const VectorType&) */
         constexpr /*implicit*/ Range3D(const Vector3<T>& min, const Vector3<T>& max) noexcept: Range<3, T>(min, max) {}
diff --git a/src/Magnum/Math/RectangularMatrix.h b/src/Magnum/Math/RectangularMatrix.h
index c27074d94..b46cce8d0 100644
--- a/src/Magnum/Math/RectangularMatrix.h
+++ b/src/Magnum/Math/RectangularMatrix.h
@@ -128,7 +128,7 @@ template<std::size_t cols, std::size_t rows, class T> class RectangularMatrix {
         constexpr explicit RectangularMatrix(ZeroInitT) noexcept: RectangularMatrix<cols, rows, T>{typename Implementation::GenerateSequence<cols>::Type{}, ZeroInit} {}
 
         /** @brief Construct without initializing the contents */
-        explicit RectangularMatrix(NoInitT) noexcept: RectangularMatrix<cols, rows, T>{typename Implementation::GenerateSequence<cols>::Type{}, NoInit} {}
+        explicit RectangularMatrix(Magnum::NoInitT) noexcept: RectangularMatrix<cols, rows, T>{typename Implementation::GenerateSequence<cols>::Type{}, Magnum::NoInit} {}
 
         /** @brief Construct from column vectors */
         template<class ...U> constexpr /*implicit*/ RectangularMatrix(const Vector<rows, T>& first, const U&... next) noexcept: _data{first, next...} {
@@ -579,7 +579,7 @@ template<std::size_t cols, std::size_t rows, class T> inline RectangularMatrix<c
     #endif
     scalar, const RectangularMatrix<cols, rows, T>& matrix)
 {
-    RectangularMatrix<cols, rows, T> out{NoInit};
+    RectangularMatrix<cols, rows, T> out{Magnum::NoInit};
 
     for(std::size_t i = 0; i != cols; ++i)
         out[i] = scalar/matrix[i];
@@ -764,7 +764,7 @@ template<std::size_t cols, std::size_t rows, class T> template<std::size_t size>
 }
 
 template<std::size_t cols, std::size_t rows, class T> inline RectangularMatrix<rows, cols, T> RectangularMatrix<cols, rows, T>::transposed() const {
-    RectangularMatrix<rows, cols, T> out{NoInit};
+    RectangularMatrix<rows, cols, T> out{Magnum::NoInit};
 
     /* Using ._data[] instead of [] to avoid function call indirection
        on debug builds (saves a lot, yet doesn't obfuscate too much) */
diff --git a/src/Magnum/Math/Tags.h b/src/Magnum/Math/Tags.h
index bfa626b5b..981a75929 100644
--- a/src/Magnum/Math/Tags.h
+++ b/src/Magnum/Math/Tags.h
@@ -26,20 +26,26 @@
 */
 
 /** @file
- * @brief Tag type @ref Magnum::Math::NoInitT, @ref Magnum::Math::ZeroInitT, @ref Magnum::Math::IdentityInitT, tag @ref Magnum::Math::NoInit, @ref Magnum::Math::ZeroInit, @ref Magnum::Math::IdentityInit
+ * @brief Tag type @ref Magnum::Math::ZeroInitT, @ref Magnum::Math::IdentityInitT, tag @ref Magnum::Math::ZeroInit, @ref Magnum::Math::IdentityInit
  */
 
 #include <Corrade/Containers/Tags.h>
 
+#include "Magnum/Tags.h"
+
+#ifdef MAGNUM_BUILD_DEPRECATED
+#include <Corrade/Utility/Macros.h>
+#endif
+
 namespace Magnum { namespace Math {
 
+#ifdef MAGNUM_BUILD_DEPRECATED
 /**
 @brief No initialization tag type
-
-Used to distinguish construction with no initialization at all.
-@see @ref NoInit
+@m_deprecated_since_latest Use @ref Magnum::NoInitT instead.
 */
-typedef Corrade::Containers::NoInitT NoInitT;
+typedef CORRADE_DEPRECATED("use Magnum::NoInitT instead") Magnum::NoInitT NoInitT;
+#endif
 
 /**
 @brief Zero initialization tag type
@@ -69,16 +75,14 @@ struct IdentityInitT {
     #endif
 };
 
+#ifdef MAGNUM_BUILD_DEPRECATED
 /**
 @brief No initialization tag
-
-Use for construction with no initialization at all.
+@m_deprecated_since_latest Use @ref Magnum::NoInit instead.
 */
-#ifdef DOXYGEN_GENERATING_OUTPUT
+/** @todo when removing, clean up all Magnum::NoInit in Math to be NoInit again */
 /* Explicit constructor to avoid ambiguous calls when using {} */
-constexpr NoInitT NoInit{};
-#else
-using Corrade::Containers::NoInit;
+constexpr CORRADE_DEPRECATED("use Magnum::NoInit instead") Magnum::NoInitT NoInit{Magnum::NoInitT::Init{}};
 #endif
 
 /**
diff --git a/src/Magnum/Math/Test/AngleTest.cpp b/src/Magnum/Math/Test/AngleTest.cpp
index e101a2401..7c0562524 100644
--- a/src/Magnum/Math/Test/AngleTest.cpp
+++ b/src/Magnum/Math/Test/AngleTest.cpp
@@ -179,8 +179,8 @@ void AngleTest::constructDefault() {
 void AngleTest::constructNoInit() {
     Deg a{25.0f};
     Rad b{3.14f};
-    new(&a) Deg{NoInit};
-    new(&b) Rad{NoInit};
+    new(&a) Deg{Magnum::NoInit};
+    new(&b) Rad{Magnum::NoInit};
     {
         #if defined(__GNUC__) && __GNUC__*100 + __GNUC_MINOR__ >= 601
         /* The warning is reported for both debug and release build */
@@ -197,12 +197,12 @@ void AngleTest::constructNoInit() {
         #endif
     }
 
-    CORRADE_VERIFY((std::is_nothrow_constructible<Deg, NoInitT>::value));
-    CORRADE_VERIFY((std::is_nothrow_constructible<Rad, NoInitT>::value));
+    CORRADE_VERIFY((std::is_nothrow_constructible<Deg, Magnum::NoInitT>::value));
+    CORRADE_VERIFY((std::is_nothrow_constructible<Rad, Magnum::NoInitT>::value));
 
     /* Implicit construction is not allowed */
-    CORRADE_VERIFY(!(std::is_convertible<NoInitT, Deg>::value));
-    CORRADE_VERIFY(!(std::is_convertible<NoInitT, Rad>::value));
+    CORRADE_VERIFY(!(std::is_convertible<Magnum::NoInitT, Deg>::value));
+    CORRADE_VERIFY(!(std::is_convertible<Magnum::NoInitT, Rad>::value));
 }
 
 void AngleTest::constructConversion() {
diff --git a/src/Magnum/Math/Test/BezierTest.cpp b/src/Magnum/Math/Test/BezierTest.cpp
index dc63a97bf..4ce42f7b9 100644
--- a/src/Magnum/Math/Test/BezierTest.cpp
+++ b/src/Magnum/Math/Test/BezierTest.cpp
@@ -139,7 +139,7 @@ void BezierTest::constructDefault() {
 
 void BezierTest::constructNoInit() {
     QuadraticBezier2D a{Vector2{0.5f, 1.0f}, Vector2{1.1f, 0.3f}, Vector2{0.1f, 1.2f}};
-    new(&a) QuadraticBezier2D{NoInit};
+    new(&a) QuadraticBezier2D{Magnum::NoInit};
     {
         #if defined(__GNUC__) && __GNUC__*100 + __GNUC_MINOR__ >= 601 && __OPTIMIZE__
         CORRADE_EXPECT_FAIL("GCC 6.1+ misoptimizes and overwrites the value.");
@@ -147,10 +147,10 @@ void BezierTest::constructNoInit() {
         CORRADE_COMPARE(a, (QuadraticBezier2D{Vector2{0.5f, 1.0f}, Vector2{1.1f, 0.3f}, Vector2{0.1f, 1.2f}}));
     }
 
-    CORRADE_VERIFY((std::is_nothrow_constructible<QuadraticBezier2D, NoInitT>::value));
+    CORRADE_VERIFY((std::is_nothrow_constructible<QuadraticBezier2D, Magnum::NoInitT>::value));
 
     /* Implicit construction is not allowed */
-    CORRADE_VERIFY(!(std::is_convertible<NoInitT, QuadraticBezier2D>::value));
+    CORRADE_VERIFY(!(std::is_convertible<Magnum::NoInitT, QuadraticBezier2D>::value));
 }
 
 void BezierTest::constructConversion() {
diff --git a/src/Magnum/Math/Test/BoolVectorTest.cpp b/src/Magnum/Math/Test/BoolVectorTest.cpp
index 0e0738fa6..6028dbdd5 100644
--- a/src/Magnum/Math/Test/BoolVectorTest.cpp
+++ b/src/Magnum/Math/Test/BoolVectorTest.cpp
@@ -136,7 +136,7 @@ void BoolVectorTest::constructDefault() {
 
 void BoolVectorTest::constructNoInit() {
     BoolVector19 a{0xa5, 0x5f, 0x07};
-    new(&a) BoolVector19{NoInit};
+    new(&a) BoolVector19{Magnum::NoInit};
     {
         #if defined(__GNUC__) && __GNUC__*100 + __GNUC_MINOR__ >= 601 && __OPTIMIZE__
         CORRADE_EXPECT_FAIL("GCC 6.1+ misoptimizes and overwrites the value.");
@@ -144,10 +144,10 @@ void BoolVectorTest::constructNoInit() {
         CORRADE_COMPARE(a, BoolVector19(0xa5, 0x5f, 0x07));
     }
 
-    CORRADE_VERIFY((std::is_nothrow_constructible<BoolVector19, NoInitT>::value));
+    CORRADE_VERIFY((std::is_nothrow_constructible<BoolVector19, Magnum::NoInitT>::value));
 
     /* Implicit construction is not allowed */
-    CORRADE_VERIFY(!(std::is_convertible<NoInitT, BoolVector19>::value));
+    CORRADE_VERIFY(!(std::is_convertible<Magnum::NoInitT, BoolVector19>::value));
 }
 
 void BoolVectorTest::constructOneValue() {
diff --git a/src/Magnum/Math/Test/ColorTest.cpp b/src/Magnum/Math/Test/ColorTest.cpp
index a9b4a61b9..aa1e0af90 100644
--- a/src/Magnum/Math/Test/ColorTest.cpp
+++ b/src/Magnum/Math/Test/ColorTest.cpp
@@ -331,8 +331,8 @@ void ColorTest::constructDefault() {
 void ColorTest::constructNoInit() {
     Color3 a{1.0f, 0.5f, 0.75f};
     Color4 b{1.0f, 0.5f, 0.75f, 0.5f};
-    new(&a) Color3{NoInit};
-    new(&b) Color4{NoInit};
+    new(&a) Color3{Magnum::NoInit};
+    new(&b) Color4{Magnum::NoInit};
     {
         #if defined(__GNUC__) && __GNUC__*100 + __GNUC_MINOR__ >= 601 && __OPTIMIZE__
         CORRADE_EXPECT_FAIL("GCC 6.1+ misoptimizes and overwrites the value.");
@@ -341,12 +341,12 @@ void ColorTest::constructNoInit() {
         CORRADE_COMPARE(b, (Color4{1.0f, 0.5f, 0.75f, 0.5f}));
     }
 
-    CORRADE_VERIFY((std::is_nothrow_constructible<Color3, NoInitT>::value));
-    CORRADE_VERIFY((std::is_nothrow_constructible<Color4, NoInitT>::value));
+    CORRADE_VERIFY((std::is_nothrow_constructible<Color3, Magnum::NoInitT>::value));
+    CORRADE_VERIFY((std::is_nothrow_constructible<Color4, Magnum::NoInitT>::value));
 
     /* Implicit construction is not allowed */
-    CORRADE_VERIFY(!(std::is_convertible<NoInitT, Color3>::value));
-    CORRADE_VERIFY(!(std::is_convertible<NoInitT, Color4>::value));
+    CORRADE_VERIFY(!(std::is_convertible<Magnum::NoInitT, Color3>::value));
+    CORRADE_VERIFY(!(std::is_convertible<Magnum::NoInitT, Color4>::value));
 }
 
 void ColorTest::constructOneValue() {
@@ -508,7 +508,7 @@ void ColorTest::constructHsvDefault() {
 
 void ColorTest::constructHsvNoInit() {
     ColorHsv a{135.0_degf, 0.5f, 0.9f};
-    new(&a) ColorHsv{NoInit};
+    new(&a) ColorHsv{Magnum::NoInit};
     {
         #if defined(__GNUC__) && __GNUC__*100 + __GNUC_MINOR__ >= 601 && __OPTIMIZE__
         CORRADE_EXPECT_FAIL("GCC 6.1+ misoptimizes and overwrites the value.");
@@ -516,10 +516,10 @@ void ColorTest::constructHsvNoInit() {
         CORRADE_COMPARE(a, (ColorHsv{135.0_degf, 0.5f, 0.9f}));
     }
 
-    CORRADE_VERIFY((std::is_nothrow_constructible<ColorHsv, NoInitT>::value));
+    CORRADE_VERIFY((std::is_nothrow_constructible<ColorHsv, Magnum::NoInitT>::value));
 
     /* Implicit construction is not allowed */
-    CORRADE_VERIFY(!(std::is_convertible<NoInitT, ColorHsv>::value));
+    CORRADE_VERIFY(!(std::is_convertible<Magnum::NoInitT, ColorHsv>::value));
 }
 
 void ColorTest::constructHsvConversion() {
diff --git a/src/Magnum/Math/Test/ComplexTest.cpp b/src/Magnum/Math/Test/ComplexTest.cpp
index 7e8e7edf2..8757143e7 100644
--- a/src/Magnum/Math/Test/ComplexTest.cpp
+++ b/src/Magnum/Math/Test/ComplexTest.cpp
@@ -204,7 +204,7 @@ void ComplexTest::constructZero() {
 
 void ComplexTest::constructNoInit() {
     Complex a{0.5f, -3.7f};
-    new(&a) Complex{NoInit};
+    new(&a) Complex{Magnum::NoInit};
     {
         #if defined(__GNUC__) && __GNUC__*100 + __GNUC_MINOR__ >= 601 && __OPTIMIZE__
         CORRADE_EXPECT_FAIL("GCC 6.1+ misoptimizes and overwrites the value.");
@@ -212,10 +212,10 @@ void ComplexTest::constructNoInit() {
         CORRADE_COMPARE(a, Complex(0.5f, -3.7f));
     }
 
-    CORRADE_VERIFY((std::is_nothrow_constructible<Complex, NoInitT>::value));
+    CORRADE_VERIFY((std::is_nothrow_constructible<Complex, Magnum::NoInitT>::value));
 
     /* Implicit construction is not allowed */
-    CORRADE_VERIFY(!(std::is_convertible<NoInitT, Complex>::value));
+    CORRADE_VERIFY(!(std::is_convertible<Magnum::NoInitT, Complex>::value));
 }
 
 void ComplexTest::constructFromVector() {
diff --git a/src/Magnum/Math/Test/CubicHermiteTest.cpp b/src/Magnum/Math/Test/CubicHermiteTest.cpp
index 144a24980..6c62724e1 100644
--- a/src/Magnum/Math/Test/CubicHermiteTest.cpp
+++ b/src/Magnum/Math/Test/CubicHermiteTest.cpp
@@ -431,7 +431,7 @@ void CubicHermiteTest::constructIdentityQuaternion() {
 
 void CubicHermiteTest::constructNoInitScalar() {
     CubicHermite1D spline{2.0f, -2.0f, -0.5f};
-    new(&spline) CubicHermite1D{NoInit};
+    new(&spline) CubicHermite1D{Magnum::NoInit};
     {
         #if defined(__GNUC__) && __GNUC__*100 + __GNUC_MINOR__ >= 601 && __OPTIMIZE__
         CORRADE_EXPECT_FAIL("GCC 6.1+ misoptimizes and overwrites the value.");
@@ -439,15 +439,15 @@ void CubicHermiteTest::constructNoInitScalar() {
         CORRADE_COMPARE(spline, (CubicHermite1D{2.0f, -2.0f, -0.5f}));
     }
 
-    CORRADE_VERIFY((std::is_nothrow_constructible<CubicHermite1D, NoInitT>::value));
+    CORRADE_VERIFY((std::is_nothrow_constructible<CubicHermite1D, Magnum::NoInitT>::value));
 
     /* Implicit construction is not allowed */
-    CORRADE_VERIFY(!(std::is_convertible<NoInitT, CubicHermite1D>::value));
+    CORRADE_VERIFY(!(std::is_convertible<Magnum::NoInitT, CubicHermite1D>::value));
 }
 
 void CubicHermiteTest::constructNoInitVector() {
     CubicHermite2D spline{{1.0f, 2.0f}, {1.5f, -2.0f}, {3.0f, -0.5f}};
-    new(&spline) CubicHermite2D{NoInit};
+    new(&spline) CubicHermite2D{Magnum::NoInit};
     {
         #if defined(__GNUC__) && __GNUC__*100 + __GNUC_MINOR__ >= 601 && __OPTIMIZE__
         CORRADE_EXPECT_FAIL("GCC 6.1+ misoptimizes and overwrites the value.");
@@ -455,15 +455,15 @@ void CubicHermiteTest::constructNoInitVector() {
         CORRADE_COMPARE(spline, (CubicHermite2D{{1.0f, 2.0f}, {1.5f, -2.0f}, {3.0f, -0.5f}}));
     }
 
-    CORRADE_VERIFY((std::is_nothrow_constructible<CubicHermite2D, NoInitT>::value));
+    CORRADE_VERIFY((std::is_nothrow_constructible<CubicHermite2D, Magnum::NoInitT>::value));
 
     /* Implicit construction is not allowed */
-    CORRADE_VERIFY(!(std::is_convertible<NoInitT, CubicHermite2D>::value));
+    CORRADE_VERIFY(!(std::is_convertible<Magnum::NoInitT, CubicHermite2D>::value));
 }
 
 void CubicHermiteTest::constructNoInitComplex() {
     CubicHermiteComplex spline{{1.0f, 2.0f}, {1.5f, -2.0f}, {3.0f, -0.5f}};
-    new(&spline) CubicHermiteComplex{NoInit};
+    new(&spline) CubicHermiteComplex{Magnum::NoInit};
     {
         #if defined(__GNUC__) && __GNUC__*100 + __GNUC_MINOR__ >= 601 && __OPTIMIZE__
         CORRADE_EXPECT_FAIL("GCC 6.1+ misoptimizes and overwrites the value.");
@@ -471,10 +471,10 @@ void CubicHermiteTest::constructNoInitComplex() {
         CORRADE_COMPARE(spline, (CubicHermiteComplex{{1.0f, 2.0f}, {1.5f, -2.0f}, {3.0f, -0.5f}}));
     }
 
-    CORRADE_VERIFY((std::is_nothrow_constructible<CubicHermiteComplex, NoInitT>::value));
+    CORRADE_VERIFY((std::is_nothrow_constructible<CubicHermiteComplex, Magnum::NoInitT>::value));
 
     /* Implicit construction is not allowed */
-    CORRADE_VERIFY(!(std::is_convertible<NoInitT, CubicHermiteComplex>::value));
+    CORRADE_VERIFY(!(std::is_convertible<Magnum::NoInitT, CubicHermiteComplex>::value));
 }
 
 void CubicHermiteTest::constructNoInitQuaternion() {
@@ -482,7 +482,7 @@ void CubicHermiteTest::constructNoInitQuaternion() {
         {{1.0f, 2.0f, -1.0f}, 3.0f},
         {{1.5f, -2.0f, 0.1f}, 1.1f},
         {{3.0f, -0.5f, 1.2f}, 0.3f}};
-    new(&spline) CubicHermiteQuaternion{NoInit};
+    new(&spline) CubicHermiteQuaternion{Magnum::NoInit};
     {
         #if defined(__GNUC__) && __GNUC__*100 + __GNUC_MINOR__ >= 601 && __OPTIMIZE__
         CORRADE_EXPECT_FAIL("GCC 6.1+ misoptimizes and overwrites the value.");
@@ -493,10 +493,10 @@ void CubicHermiteTest::constructNoInitQuaternion() {
             {{3.0f, -0.5f, 1.2f}, 0.3f}}));
     }
 
-    CORRADE_VERIFY((std::is_nothrow_constructible<CubicHermiteQuaternion, NoInitT>::value));
+    CORRADE_VERIFY((std::is_nothrow_constructible<CubicHermiteQuaternion, Magnum::NoInitT>::value));
 
     /* Implicit construction is not allowed */
-    CORRADE_VERIFY(!(std::is_convertible<NoInitT, CubicHermiteQuaternion>::value));
+    CORRADE_VERIFY(!(std::is_convertible<Magnum::NoInitT, CubicHermiteQuaternion>::value));
 }
 
 void CubicHermiteTest::constructConversionScalar() {
diff --git a/src/Magnum/Math/Test/DualComplexTest.cpp b/src/Magnum/Math/Test/DualComplexTest.cpp
index b3d523d62..962210704 100644
--- a/src/Magnum/Math/Test/DualComplexTest.cpp
+++ b/src/Magnum/Math/Test/DualComplexTest.cpp
@@ -195,7 +195,7 @@ void DualComplexTest::constructZero() {
 
 void DualComplexTest::constructNoInit() {
     DualComplex a{{-1.0f, 2.5f}, {3.0f, -7.5f}};
-    new(&a) DualComplex{NoInit};
+    new(&a) DualComplex{Magnum::NoInit};
     {
         #if defined(__GNUC__) && __GNUC__*100 + __GNUC_MINOR__ >= 601 && __OPTIMIZE__
         CORRADE_EXPECT_FAIL("GCC 6.1+ misoptimizes and overwrites the value.");
@@ -203,10 +203,10 @@ void DualComplexTest::constructNoInit() {
         CORRADE_COMPARE(a, DualComplex({-1.0f, 2.5f}, {3.0f, -7.5f}));
     }
 
-    CORRADE_VERIFY((std::is_nothrow_constructible<DualComplex, NoInitT>::value));
+    CORRADE_VERIFY((std::is_nothrow_constructible<DualComplex, Magnum::NoInitT>::value));
 
     /* Implicit construction is not allowed */
-    CORRADE_VERIFY(!(std::is_convertible<NoInitT, DualComplex>::value));
+    CORRADE_VERIFY(!(std::is_convertible<Magnum::NoInitT, DualComplex>::value));
 }
 
 void DualComplexTest::constructFromVector() {
diff --git a/src/Magnum/Math/Test/DualQuaternionTest.cpp b/src/Magnum/Math/Test/DualQuaternionTest.cpp
index 3ca05623e..c51338d14 100644
--- a/src/Magnum/Math/Test/DualQuaternionTest.cpp
+++ b/src/Magnum/Math/Test/DualQuaternionTest.cpp
@@ -224,7 +224,7 @@ void DualQuaternionTest::constructZero() {
 
 void DualQuaternionTest::constructNoInit() {
     DualQuaternion a{{{1.0f, 2.0f, 3.0f}, -4.0f}, {{0.5f, -3.1f, 3.3f}, 2.0f}};
-    new(&a) DualQuaternion{NoInit};
+    new(&a) DualQuaternion{Magnum::NoInit};
     {
         #if defined(__GNUC__) && __GNUC__*100 + __GNUC_MINOR__ >= 601 && __OPTIMIZE__
         CORRADE_EXPECT_FAIL("GCC 6.1+ misoptimizes and overwrites the value.");
@@ -232,10 +232,10 @@ void DualQuaternionTest::constructNoInit() {
         CORRADE_COMPARE(a, DualQuaternion({{1.0f, 2.0f, 3.0f}, -4.0f}, {{0.5f, -3.1f, 3.3f}, 2.0f}));
     }
 
-    CORRADE_VERIFY((std::is_nothrow_constructible<DualQuaternion, NoInitT>::value));
+    CORRADE_VERIFY((std::is_nothrow_constructible<DualQuaternion, Magnum::NoInitT>::value));
 
     /* Implicit construction is not allowed */
-    CORRADE_VERIFY(!(std::is_convertible<NoInitT, DualQuaternion>::value));
+    CORRADE_VERIFY(!(std::is_convertible<Magnum::NoInitT, DualQuaternion>::value));
 }
 
 void DualQuaternionTest::constructFromVector() {
diff --git a/src/Magnum/Math/Test/DualTest.cpp b/src/Magnum/Math/Test/DualTest.cpp
index 44849fb4c..2337c21e1 100644
--- a/src/Magnum/Math/Test/DualTest.cpp
+++ b/src/Magnum/Math/Test/DualTest.cpp
@@ -147,8 +147,8 @@ void DualTest::constructZero() {
 void DualTest::constructNoInit() {
     Dual a{2.0f, -7.5f};
     Math::Dual<Math::Quaternion<Float>> b{{{3.0f, 0.1f, 1.0f}, 1.0f}, {{0.1f, 0.0f, 1.0f}, 0.3f}};
-    new(&a) Dual{NoInit};
-    new(&b) Math::Dual<Math::Quaternion<Float>>{NoInit};
+    new(&a) Dual{Magnum::NoInit};
+    new(&b) Math::Dual<Math::Quaternion<Float>>{Magnum::NoInit};
     {
         #if defined(__GNUC__) && __GNUC__*100 + __GNUC_MINOR__ >= 601 && __OPTIMIZE__
         CORRADE_EXPECT_FAIL("GCC 6.1+ misoptimizes and overwrites the value.");
@@ -157,12 +157,12 @@ void DualTest::constructNoInit() {
         CORRADE_COMPARE(b, (Math::Dual<Math::Quaternion<Float>>{{{3.0f, 0.1f, 1.0f}, 1.0f}, {{0.1f, 0.0f, 1.0f}, 0.3f}}));
     }
 
-    CORRADE_VERIFY((std::is_nothrow_constructible<Dual, NoInitT>::value));
-    CORRADE_VERIFY((std::is_nothrow_constructible<Math::Dual<Math::Quaternion<Float>>, NoInitT>::value));
+    CORRADE_VERIFY((std::is_nothrow_constructible<Dual, Magnum::NoInitT>::value));
+    CORRADE_VERIFY((std::is_nothrow_constructible<Math::Dual<Math::Quaternion<Float>>, Magnum::NoInitT>::value));
 
     /* Implicit construction is not allowed */
-    CORRADE_VERIFY(!(std::is_convertible<NoInitT, Dual>::value));
-    CORRADE_VERIFY(!(std::is_convertible<NoInitT, Math::Dual<Math::Quaternion<Float>>>::value));
+    CORRADE_VERIFY(!(std::is_convertible<Magnum::NoInitT, Dual>::value));
+    CORRADE_VERIFY(!(std::is_convertible<Magnum::NoInitT, Math::Dual<Math::Quaternion<Float>>>::value));
 }
 
 void DualTest::constructConversion() {
diff --git a/src/Magnum/Math/Test/FrustumTest.cpp b/src/Magnum/Math/Test/FrustumTest.cpp
index 8fc9d39d5..26b778ca8 100644
--- a/src/Magnum/Math/Test/FrustumTest.cpp
+++ b/src/Magnum/Math/Test/FrustumTest.cpp
@@ -189,7 +189,7 @@ void FrustumTest::constructNoInit() {
         {-7.0f,  8.0f, -9.0f, 0.5f},
         { 7.0f,  8.0f,  9.0f, 0.6f}};
 
-    new(&a) Frustum{NoInit};
+    new(&a) Frustum{Magnum::NoInit};
     {
         #if defined(__GNUC__) && __GNUC__*100 + __GNUC_MINOR__ >= 601 && __OPTIMIZE__
         CORRADE_EXPECT_FAIL("GCC 6.1+ misoptimizes and overwrites the value.");
@@ -205,7 +205,7 @@ void FrustumTest::constructNoInit() {
     }
 
     /* Implicit construction is not allowed */
-    CORRADE_VERIFY((std::is_nothrow_constructible<Frustum, NoInitT>::value));
+    CORRADE_VERIFY((std::is_nothrow_constructible<Frustum, Magnum::NoInitT>::value));
 }
 
 void FrustumTest::constructConversion() {
diff --git a/src/Magnum/Math/Test/HalfTest.cpp b/src/Magnum/Math/Test/HalfTest.cpp
index 66de63d67..188dda880 100644
--- a/src/Magnum/Math/Test/HalfTest.cpp
+++ b/src/Magnum/Math/Test/HalfTest.cpp
@@ -542,7 +542,7 @@ void HalfTest::constructData() {
 
 void HalfTest::constructNoInit() {
     Half a{3.5f};
-    new(&a) Half{NoInit};
+    new(&a) Half{Magnum::NoInit};
     {
         #if defined(__GNUC__) && __GNUC__*100 + __GNUC_MINOR__ >= 601 && __OPTIMIZE__
         CORRADE_EXPECT_FAIL("GCC 6.1+ misoptimizes and overwrites the value.");
@@ -550,10 +550,10 @@ void HalfTest::constructNoInit() {
         CORRADE_COMPARE(a, Half{3.5f});
     }
 
-    CORRADE_VERIFY((std::is_nothrow_constructible<Half, NoInitT>::value));
+    CORRADE_VERIFY((std::is_nothrow_constructible<Half, Magnum::NoInitT>::value));
 
     /* Implicit construction is not allowed */
-    CORRADE_VERIFY(!(std::is_convertible<NoInitT, Half>::value));
+    CORRADE_VERIFY(!(std::is_convertible<Magnum::NoInitT, Half>::value));
 }
 
 void HalfTest::constructCopy() {
diff --git a/src/Magnum/Math/Test/Matrix3Test.cpp b/src/Magnum/Math/Test/Matrix3Test.cpp
index 93beadfaa..d85804800 100644
--- a/src/Magnum/Math/Test/Matrix3Test.cpp
+++ b/src/Magnum/Math/Test/Matrix3Test.cpp
@@ -207,7 +207,7 @@ void Matrix3Test::constructNoInit() {
     Matrix3 a{{3.0f,  5.0f, 8.0f},
               {4.5f,  4.0f, 7.0f},
               {7.9f, -1.0f, 8.0f}};
-    new(&a) Matrix3{NoInit};
+    new(&a) Matrix3{Magnum::NoInit};
     {
         #if defined(__GNUC__) && __GNUC__*100 + __GNUC_MINOR__ >= 601 && __OPTIMIZE__
         CORRADE_EXPECT_FAIL("GCC 6.1+ misoptimizes and overwrites the value.");
@@ -217,10 +217,10 @@ void Matrix3Test::constructNoInit() {
                                    {7.9f, -1.0f, 8.0f}));
     }
 
-    CORRADE_VERIFY((std::is_nothrow_constructible<Matrix3, NoInitT>::value));
+    CORRADE_VERIFY((std::is_nothrow_constructible<Matrix3, Magnum::NoInitT>::value));
 
     /* Implicit construction is not allowed */
-    CORRADE_VERIFY(!(std::is_convertible<NoInitT, Matrix3>::value));
+    CORRADE_VERIFY(!(std::is_convertible<Magnum::NoInitT, Matrix3>::value));
 }
 
 void Matrix3Test::constructOneValue() {
diff --git a/src/Magnum/Math/Test/Matrix4Test.cpp b/src/Magnum/Math/Test/Matrix4Test.cpp
index 0021ecaf4..0cfe1a2a5 100644
--- a/src/Magnum/Math/Test/Matrix4Test.cpp
+++ b/src/Magnum/Math/Test/Matrix4Test.cpp
@@ -248,7 +248,7 @@ void Matrix4Test::constructNoInit() {
                  {4.5f,  4.0f, 7.0f,  2.0f},
                  {1.0f,  2.0f, 3.0f, -1.0f},
                  {7.9f, -1.0f, 8.0f, -1.5f}};
-    new(&a) Matrix4{NoInit};
+    new(&a) Matrix4{Magnum::NoInit};
     {
         #if defined(__GNUC__) && __GNUC__*100 + __GNUC_MINOR__ >= 601 && __OPTIMIZE__
         CORRADE_EXPECT_FAIL("GCC 6.1+ misoptimizes and overwrites the value.");
@@ -259,10 +259,10 @@ void Matrix4Test::constructNoInit() {
                                    {7.9f, -1.0f, 8.0f, -1.5f}));
     }
 
-    CORRADE_VERIFY((std::is_nothrow_constructible<Matrix4, NoInitT>::value));
+    CORRADE_VERIFY((std::is_nothrow_constructible<Matrix4, Magnum::NoInitT>::value));
 
     /* Implicit construction is not allowed */
-    CORRADE_VERIFY(!(std::is_convertible<NoInitT, Matrix4>::value));
+    CORRADE_VERIFY(!(std::is_convertible<Magnum::NoInitT, Matrix4>::value));
 }
 
 void Matrix4Test::constructOneValue() {
diff --git a/src/Magnum/Math/Test/MatrixTest.cpp b/src/Magnum/Math/Test/MatrixTest.cpp
index 0fd66bcb6..8b2a98ed4 100644
--- a/src/Magnum/Math/Test/MatrixTest.cpp
+++ b/src/Magnum/Math/Test/MatrixTest.cpp
@@ -186,7 +186,7 @@ void MatrixTest::constructNoInit() {
                 Vector4(4.5f,  4.0f, 7.0f,  2.0f),
                 Vector4(1.0f,  2.0f, 3.0f, -1.0f),
                 Vector4(7.9f, -1.0f, 8.0f, -1.5f)};
-    new(&a) Matrix4x4{NoInit};
+    new(&a) Matrix4x4{Magnum::NoInit};
     {
         #if defined(__GNUC__) && __GNUC__*100 + __GNUC_MINOR__ >= 601 && __OPTIMIZE__
         CORRADE_EXPECT_FAIL("GCC 6.1+ misoptimizes and overwrites the value.");
@@ -197,10 +197,10 @@ void MatrixTest::constructNoInit() {
                                      Vector4(7.9f, -1.0f, 8.0f, -1.5f)));
     }
 
-    CORRADE_VERIFY((std::is_nothrow_constructible<Matrix4x4, NoInitT>::value));
+    CORRADE_VERIFY((std::is_nothrow_constructible<Matrix4x4, Magnum::NoInitT>::value));
 
         /* Implicit construction is not allowed */
-    CORRADE_VERIFY(!(std::is_convertible<NoInitT, Matrix4x4>::value));
+    CORRADE_VERIFY(!(std::is_convertible<Magnum::NoInitT, Matrix4x4>::value));
 }
 
 void MatrixTest::constructOneValue() {
diff --git a/src/Magnum/Math/Test/QuaternionTest.cpp b/src/Magnum/Math/Test/QuaternionTest.cpp
index d6c15cf6e..09a2f3164 100644
--- a/src/Magnum/Math/Test/QuaternionTest.cpp
+++ b/src/Magnum/Math/Test/QuaternionTest.cpp
@@ -247,7 +247,7 @@ void QuaternionTest::constructZero() {
 
 void QuaternionTest::constructNoInit() {
     Quaternion a{{1.0f, 2.0f, 3.0f}, -4.0f};
-    new(&a) Quaternion{NoInit};
+    new(&a) Quaternion{Magnum::NoInit};
     {
         #if defined(__GNUC__) && __GNUC__*100 + __GNUC_MINOR__ >= 601 && __OPTIMIZE__
         CORRADE_EXPECT_FAIL("GCC 6.1+ misoptimizes and overwrites the value.");
@@ -255,10 +255,10 @@ void QuaternionTest::constructNoInit() {
         CORRADE_COMPARE(a, Quaternion({1.0f, 2.0f, 3.0f}, -4.0f));
     }
 
-    CORRADE_VERIFY((std::is_nothrow_constructible<Quaternion, NoInitT>::value));
+    CORRADE_VERIFY((std::is_nothrow_constructible<Quaternion, Magnum::NoInitT>::value));
 
     /* Implicit construction is not allowed */
-    CORRADE_VERIFY(!(std::is_convertible<NoInitT, Quaternion>::value));
+    CORRADE_VERIFY(!(std::is_convertible<Magnum::NoInitT, Quaternion>::value));
 }
 
 void QuaternionTest::constructFromVector() {
diff --git a/src/Magnum/Math/Test/RangeTest.cpp b/src/Magnum/Math/Test/RangeTest.cpp
index 8da37e498..9ea76a865 100644
--- a/src/Magnum/Math/Test/RangeTest.cpp
+++ b/src/Magnum/Math/Test/RangeTest.cpp
@@ -243,9 +243,9 @@ void RangeTest::constructNoInit() {
     Range2Di b{{3, 5}, {23, 78}};
     Range3Di c{{3, 5, -7}, {23, 78, 2}};
 
-    new(&a) Range1Di{NoInit};
-    new(&b) Range2Di{NoInit};
-    new(&c) Range3Di{NoInit};
+    new(&a) Range1Di{Magnum::NoInit};
+    new(&b) Range2Di{Magnum::NoInit};
+    new(&c) Range3Di{Magnum::NoInit};
 
     {
         #if defined(__GNUC__) && __GNUC__*100 + __GNUC_MINOR__ >= 601 && __OPTIMIZE__
@@ -256,14 +256,14 @@ void RangeTest::constructNoInit() {
         CORRADE_COMPARE(c, (Range3Di{{3, 5, -7}, {23, 78, 2}}));
     }
 
-    CORRADE_VERIFY((std::is_nothrow_constructible<Range1Di, NoInitT>::value));
-    CORRADE_VERIFY((std::is_nothrow_constructible<Range2Di, NoInitT>::value));
-    CORRADE_VERIFY((std::is_nothrow_constructible<Range3Di, NoInitT>::value));
+    CORRADE_VERIFY((std::is_nothrow_constructible<Range1Di, Magnum::NoInitT>::value));
+    CORRADE_VERIFY((std::is_nothrow_constructible<Range2Di, Magnum::NoInitT>::value));
+    CORRADE_VERIFY((std::is_nothrow_constructible<Range3Di, Magnum::NoInitT>::value));
 
     /* Implicit construction is not allowed */
-    CORRADE_VERIFY(!(std::is_convertible<NoInitT, Range1Di>::value));
-    CORRADE_VERIFY(!(std::is_convertible<NoInitT, Range2Di>::value));
-    CORRADE_VERIFY(!(std::is_convertible<NoInitT, Range3Di>::value));
+    CORRADE_VERIFY(!(std::is_convertible<Magnum::NoInitT, Range1Di>::value));
+    CORRADE_VERIFY(!(std::is_convertible<Magnum::NoInitT, Range2Di>::value));
+    CORRADE_VERIFY(!(std::is_convertible<Magnum::NoInitT, Range3Di>::value));
 }
 
 void RangeTest::constructFromSize() {
diff --git a/src/Magnum/Math/Test/RectangularMatrixTest.cpp b/src/Magnum/Math/Test/RectangularMatrixTest.cpp
index 88b286127..045864151 100644
--- a/src/Magnum/Math/Test/RectangularMatrixTest.cpp
+++ b/src/Magnum/Math/Test/RectangularMatrixTest.cpp
@@ -183,7 +183,7 @@ void RectangularMatrixTest::constructNoInit() {
     Matrix3x4 a{Vector4(1.0f,  2.0f,  3.0f,  4.0f),
                 Vector4(5.0f,  6.0f,  7.0f,  8.0f),
                 Vector4(9.0f, 10.0f, 11.0f, 12.0f)};
-    new(&a) Matrix3x4{NoInit};
+    new(&a) Matrix3x4{Magnum::NoInit};
     {
         #if defined(__GNUC__) && __GNUC__*100 + __GNUC_MINOR__ >= 601 && __OPTIMIZE__
         CORRADE_EXPECT_FAIL("GCC 6.1+ misoptimizes and overwrites the value.");
@@ -193,10 +193,10 @@ void RectangularMatrixTest::constructNoInit() {
                                      Vector4(9.0f, 10.0f, 11.0f, 12.0f)));
     }
 
-    CORRADE_VERIFY((std::is_nothrow_constructible<Matrix3x4, NoInitT>::value));
+    CORRADE_VERIFY((std::is_nothrow_constructible<Matrix3x4, Magnum::NoInitT>::value));
 
     /* Implicit construction is not allowed */
-    CORRADE_VERIFY(!(std::is_convertible<NoInitT, Matrix3x4>::value));
+    CORRADE_VERIFY(!(std::is_convertible<Magnum::NoInitT, Matrix3x4>::value));
 }
 
 void RectangularMatrixTest::constructOneValue() {
diff --git a/src/Magnum/Math/Test/TagsTest.cpp b/src/Magnum/Math/Test/TagsTest.cpp
index 2b44c9bfe..1e2abd465 100644
--- a/src/Magnum/Math/Test/TagsTest.cpp
+++ b/src/Magnum/Math/Test/TagsTest.cpp
@@ -39,7 +39,6 @@ TagsTest::TagsTest() {
 }
 
 void TagsTest::noDefaultConstructor() {
-    CORRADE_VERIFY(!std::is_default_constructible<NoInitT>::value);
     CORRADE_VERIFY(!std::is_default_constructible<ZeroInitT>::value);
     CORRADE_VERIFY(!std::is_default_constructible<IdentityInitT>::value);
 }
diff --git a/src/Magnum/Math/Test/UnitTest.cpp b/src/Magnum/Math/Test/UnitTest.cpp
index 7a8df6fa8..f9cbd86dd 100644
--- a/src/Magnum/Math/Test/UnitTest.cpp
+++ b/src/Magnum/Math/Test/UnitTest.cpp
@@ -94,7 +94,7 @@ void UnitTest::constructDefault() {
 
 void UnitTest::constructNoInit() {
     Sec a{25.0f};
-    new(&a) Sec{NoInit};
+    new(&a) Sec{Magnum::NoInit};
     {
         #if defined(__GNUC__) && __GNUC__*100 + __GNUC_MINOR__ >= 601 && __OPTIMIZE__
         CORRADE_EXPECT_FAIL("GCC 6.1+ misoptimizes and overwrites the value.");
@@ -102,10 +102,10 @@ void UnitTest::constructNoInit() {
         CORRADE_COMPARE(a, Sec{25.0f});
     }
 
-    CORRADE_VERIFY((std::is_nothrow_constructible<Sec, NoInitT>::value));
+    CORRADE_VERIFY((std::is_nothrow_constructible<Sec, Magnum::NoInitT>::value));
 
     /* Implicit construction is not allowed */
-    CORRADE_VERIFY(!(std::is_convertible<NoInitT, Sec>::value));
+    CORRADE_VERIFY(!(std::is_convertible<Magnum::NoInitT, Sec>::value));
 }
 
 void UnitTest::constructConversion() {
diff --git a/src/Magnum/Math/Test/Vector2Test.cpp b/src/Magnum/Math/Test/Vector2Test.cpp
index 8109be6f1..75c9db291 100644
--- a/src/Magnum/Math/Test/Vector2Test.cpp
+++ b/src/Magnum/Math/Test/Vector2Test.cpp
@@ -125,7 +125,7 @@ void Vector2Test::constructDefault() {
 
 void Vector2Test::constructNoInit() {
     Vector2 a{1.5f, 2.5f};
-    new(&a) Vector2{NoInit};
+    new(&a) Vector2{Magnum::NoInit};
     {
         #if defined(__GNUC__) && __GNUC__*100 + __GNUC_MINOR__ >= 601 && __OPTIMIZE__
         CORRADE_EXPECT_FAIL("GCC 6.1+ misoptimizes and overwrites the value.");
@@ -133,10 +133,10 @@ void Vector2Test::constructNoInit() {
         CORRADE_COMPARE(a, (Vector2{1.5f, 2.5f}));
     }
 
-    CORRADE_VERIFY((std::is_nothrow_constructible<Vector2, NoInitT>::value));
+    CORRADE_VERIFY((std::is_nothrow_constructible<Vector2, Magnum::NoInitT>::value));
 
     /* Implicit construction is not allowed */
-    CORRADE_VERIFY(!(std::is_convertible<NoInitT, Vector2>::value));
+    CORRADE_VERIFY(!(std::is_convertible<Magnum::NoInitT, Vector2>::value));
 }
 
 void Vector2Test::constructOneValue() {
diff --git a/src/Magnum/Math/Test/Vector3Test.cpp b/src/Magnum/Math/Test/Vector3Test.cpp
index 28ea50136..fb96d4a6c 100644
--- a/src/Magnum/Math/Test/Vector3Test.cpp
+++ b/src/Magnum/Math/Test/Vector3Test.cpp
@@ -125,7 +125,7 @@ void Vector3Test::constructDefault() {
 
 void Vector3Test::constructNoInit() {
     Vector3 a{1.0f, 2.5f, -3.0f};
-    new(&a) Vector3{NoInit};
+    new(&a) Vector3{Magnum::NoInit};
     {
         #if defined(__GNUC__) && __GNUC__*100 + __GNUC_MINOR__ >= 601 && __OPTIMIZE__
         CORRADE_EXPECT_FAIL("GCC 6.1+ misoptimizes and overwrites the value.");
@@ -133,10 +133,10 @@ void Vector3Test::constructNoInit() {
         CORRADE_COMPARE(a, (Vector3{1.0f, 2.5f, -3.0f}));
     }
 
-    CORRADE_VERIFY((std::is_nothrow_constructible<Vector3, NoInitT>::value));
+    CORRADE_VERIFY((std::is_nothrow_constructible<Vector3, Magnum::NoInitT>::value));
 
     /* Implicit construction is not allowed */
-    CORRADE_VERIFY(!(std::is_convertible<NoInitT, Vector3>::value));
+    CORRADE_VERIFY(!(std::is_convertible<Magnum::NoInitT, Vector3>::value));
 }
 
 void Vector3Test::constructOneValue() {
diff --git a/src/Magnum/Math/Test/Vector4Test.cpp b/src/Magnum/Math/Test/Vector4Test.cpp
index 98e3980cb..348aed026 100644
--- a/src/Magnum/Math/Test/Vector4Test.cpp
+++ b/src/Magnum/Math/Test/Vector4Test.cpp
@@ -146,7 +146,7 @@ void Vector4Test::constructDefault() {
 
 void Vector4Test::constructNoInit() {
     Vector4 a{1.0f, -2.5f, 3.0f, 4.1f};
-    new(&a) Vector4{NoInit};
+    new(&a) Vector4{Magnum::NoInit};
     {
         #if defined(__GNUC__) && __GNUC__*100 + __GNUC_MINOR__ >= 601 && __OPTIMIZE__
         CORRADE_EXPECT_FAIL("GCC 6.1+ misoptimizes and overwrites the value.");
@@ -154,10 +154,10 @@ void Vector4Test::constructNoInit() {
         CORRADE_COMPARE(a, (Vector4{1.0f, -2.5f, 3.0f, 4.1f}));
     }
 
-    CORRADE_VERIFY((std::is_nothrow_constructible<Vector4, NoInitT>::value));
+    CORRADE_VERIFY((std::is_nothrow_constructible<Vector4, Magnum::NoInitT>::value));
 
     /* Implicit construction is not allowed */
-    CORRADE_VERIFY(!(std::is_convertible<NoInitT, Vector4>::value));
+    CORRADE_VERIFY(!(std::is_convertible<Magnum::NoInitT, Vector4>::value));
 }
 
 void Vector4Test::constructOneValue() {
diff --git a/src/Magnum/Math/Test/VectorTest.cpp b/src/Magnum/Math/Test/VectorTest.cpp
index a549c719b..b319d1872 100644
--- a/src/Magnum/Math/Test/VectorTest.cpp
+++ b/src/Magnum/Math/Test/VectorTest.cpp
@@ -239,7 +239,7 @@ void VectorTest::constructDefault() {
 
 void VectorTest::constructNoInit() {
     Vector4 a{1.0f, 2.0f, -3.0f, 4.5f};
-    new(&a) Vector4{NoInit};
+    new(&a) Vector4{Magnum::NoInit};
     {
         #if defined(__GNUC__) && __GNUC__*100 + __GNUC_MINOR__ >= 601 && __OPTIMIZE__
         CORRADE_EXPECT_FAIL("GCC 6.1+ misoptimizes and overwrites the value.");
@@ -247,10 +247,10 @@ void VectorTest::constructNoInit() {
         CORRADE_COMPARE(a, (Vector4{1.0f, 2.0f, -3.0f, 4.5f}));
     }
 
-    CORRADE_VERIFY((std::is_nothrow_constructible<Vector4, NoInitT>::value));
+    CORRADE_VERIFY((std::is_nothrow_constructible<Vector4, Magnum::NoInitT>::value));
 
     /* Implicit construction is not allowed */
-    CORRADE_VERIFY(!(std::is_convertible<NoInitT, Vector4>::value));
+    CORRADE_VERIFY(!(std::is_convertible<Magnum::NoInitT, Vector4>::value));
 }
 
 void VectorTest::constructOneValue() {
diff --git a/src/Magnum/Math/Unit.h b/src/Magnum/Math/Unit.h
index ca94cf87a..e02a84bed 100644
--- a/src/Magnum/Math/Unit.h
+++ b/src/Magnum/Math/Unit.h
@@ -57,7 +57,7 @@ template<template<class> class Derived, class T> class Unit {
         constexpr explicit Unit(ZeroInitT) noexcept: _value(T(0)) {}
 
         /** @brief Construct without initializing the contents */
-        explicit Unit(NoInitT) noexcept {}
+        explicit Unit(Magnum::NoInitT) noexcept {}
 
         /** @brief Explicit conversion from a unitless type */
         constexpr explicit Unit(T value) noexcept: _value(value) {}
diff --git a/src/Magnum/Math/Vector.h b/src/Magnum/Math/Vector.h
index 3271b0fa6..861a49664 100644
--- a/src/Magnum/Math/Vector.h
+++ b/src/Magnum/Math/Vector.h
@@ -197,7 +197,7 @@ template<std::size_t size, class T> class Vector {
         constexpr explicit Vector(ZeroInitT) noexcept: _data{} {}
 
         /** @brief Construct a vector without initializing the contents */
-        explicit Vector(NoInitT) noexcept {}
+        explicit Vector(Magnum::NoInitT) noexcept {}
 
         /** @brief Construct a vector from components */
         #ifdef DOXYGEN_GENERATING_OUTPUT
diff --git a/src/Magnum/Math/Vector2.h b/src/Magnum/Math/Vector2.h
index f68e4d39a..d10812dec 100644
--- a/src/Magnum/Math/Vector2.h
+++ b/src/Magnum/Math/Vector2.h
@@ -112,7 +112,7 @@ template<class T> class Vector2: public Vector<2, T> {
         constexpr explicit Vector2(ZeroInitT) noexcept: Vector<2, T>{ZeroInit} {}
 
         /** @copydoc Vector::Vector(NoInitT) */
-        explicit Vector2(NoInitT) noexcept: Vector<2, T>{NoInit} {}
+        explicit Vector2(Magnum::NoInitT) noexcept: Vector<2, T>{Magnum::NoInit} {}
 
         /** @copydoc Vector::Vector(T) */
         constexpr explicit Vector2(T value) noexcept: Vector<2, T>(value) {}
diff --git a/src/Magnum/Math/Vector3.h b/src/Magnum/Math/Vector3.h
index 3ebfa0191..1488343a1 100644
--- a/src/Magnum/Math/Vector3.h
+++ b/src/Magnum/Math/Vector3.h
@@ -129,7 +129,7 @@ template<class T> class Vector3: public Vector<3, T> {
         constexpr explicit Vector3(ZeroInitT) noexcept: Vector<3, T>{ZeroInit} {}
 
         /** @copydoc Vector::Vector(NoInitT) */
-        explicit Vector3(NoInitT) noexcept: Vector<3, T>{NoInit} {}
+        explicit Vector3(Magnum::NoInitT) noexcept: Vector<3, T>{Magnum::NoInit} {}
 
         /** @copydoc Vector::Vector(T) */
         constexpr explicit Vector3(T value) noexcept: Vector<3, T>(value) {}
diff --git a/src/Magnum/Math/Vector4.h b/src/Magnum/Math/Vector4.h
index d39b87f45..75977c9a2 100644
--- a/src/Magnum/Math/Vector4.h
+++ b/src/Magnum/Math/Vector4.h
@@ -73,11 +73,11 @@ template<class T> class Vector4: public Vector<4, T> {
            fire! FFS. */
         constexpr explicit Vector4(ZeroInitT) noexcept: Vector<4, T>{ZeroInit} {}
 
-        /** @copydoc Magnum::Math::Vector::Vector(NoInitT) */
+        /** @copydoc Magnum::Math::Vector::Vector(Magnum::NoInitT) */
         /* For some freaking reason doxygen 1.8.17 needs a fully qualified name
            here but GUESS WHAT! Not in the other Vector2/3 classes! Dumpster
            fire! FFS. */
-        explicit Vector4(NoInitT) noexcept: Vector<4, T>{NoInit} {}
+        explicit Vector4(Magnum::NoInitT) noexcept: Vector<4, T>{Magnum::NoInit} {}
 
         /** @copydoc Magnum::Math::Vector::Vector(T) */
         /* For some freaking reason doxygen 1.8.17 needs a fully qualified name
diff --git a/src/Magnum/MeshTools/GenerateNormals.cpp b/src/Magnum/MeshTools/GenerateNormals.cpp
index 3ed467139..c88af57ed 100644
--- a/src/Magnum/MeshTools/GenerateNormals.cpp
+++ b/src/Magnum/MeshTools/GenerateNormals.cpp
@@ -147,7 +147,7 @@ template<class T> inline void generateSmoothNormalsIntoImplementation(const Cont
     /* Precalculate cross product and interior angles of each face --- the loop
        below would otherwise calculate it for every vertex, which is at least
        3x as much work */
-    Containers::Array<std::pair<Vector3, Math::Vector3<Rad>>> crossAngles{Math::NoInit, indices.size()/3};
+    Containers::Array<std::pair<Vector3, Math::Vector3<Rad>>> crossAngles{NoInit, indices.size()/3};
     for(std::size_t i = 0; i != crossAngles.size(); ++i) {
         const Vector3 v0 = positions[indices[i*3 + 0]];
         const Vector3 v1 = positions[indices[i*3 + 1]];
diff --git a/src/Magnum/Tags.h b/src/Magnum/Tags.h
index 90ae19683..45fc66047 100644
--- a/src/Magnum/Tags.h
+++ b/src/Magnum/Tags.h
@@ -26,18 +26,29 @@
 */
 
 /** @file
- * @brief Tag type @ref Magnum::NoCreateT, tag @ref Magnum::NoCreate
+ * @brief Tag type @ref Magnum::NoInitT, @ref Magnum::NoCreateT, tag @ref Magnum::NoInit, @ref Magnum::NoCreate
  */
 
-#include "Corrade/configure.h"
+#include <Corrade/Containers/Tags.h>
+
 #include "Magnum/configure.h"
 
 namespace Magnum {
 
+/**
+@brief No initialization tag type
+@m_since_latest
+
+Used to distinguish construction with no initialization at all.
+@see @ref NoInit
+*/
+typedef Corrade::Containers::NoInitT NoInitT;
+
 /**
 @brief No creation tag type
 
-Used to distinguish construction without creating the underlying OpenGL object.
+Used to distinguish construction without creating the underlying OpenGL /
+Vulkan / ... object.
 @see @ref NoCreate
 */
 /* Explicit constructor to avoid ambiguous calls when using {} */
@@ -48,14 +59,27 @@ struct NoCreateT {
     #endif
 };
 
+/**
+@brief No initialization tag
+@m_since_latest
+
+Use for construction with no initialization at all.
+*/
+#ifdef DOXYGEN_GENERATING_OUTPUT
+/* Explicit constructor to avoid ambiguous calls when using {} */
+constexpr NoInitT NoInit{};
+#else
+using Corrade::Containers::NoInit;
+#endif
+
 /**
 @brief No creation tag
 
-Use for construction without creating the underlying OpenGL object. Note that
-calling anything on objects created this way is not defined (and not checked or
-guarded in any way) and may result in crashes. If you want delayed object
-creation with safety checks (however with some extra memory overhead), wrap
-the objects in an @ref Corrade::Containers::Optional.
+Use for construction without creating the underlying OpenGL / Vulkan / ...
+object. Note that calling anything on objects created this way is not defined
+(and not checked or guarded in any way) and may result in crashes. If you want
+delayed object creation with safety checks (however with some extra memory
+overhead), wrap the objects in an @ref Corrade::Containers::Optional.
 */
 constexpr NoCreateT NoCreate{NoCreateT::Init{}};
 
diff --git a/src/Magnum/Test/TagsTest.cpp b/src/Magnum/Test/TagsTest.cpp
index b9f8298c2..9824f8b05 100644
--- a/src/Magnum/Test/TagsTest.cpp
+++ b/src/Magnum/Test/TagsTest.cpp
@@ -41,6 +41,7 @@ TagsTest::TagsTest() {
 }
 
 void TagsTest::noDefaultConstructor() {
+    CORRADE_VERIFY(!std::is_default_constructible<NoInitT>::value);
     CORRADE_VERIFY(!std::is_default_constructible<NoCreateT>::value);
 }