diff --git a/src/Magnum/Math/Algorithms/GramSchmidt.h b/src/Magnum/Math/Algorithms/GramSchmidt.h
index a35aa392e..ca8486b90 100644
--- a/src/Magnum/Math/Algorithms/GramSchmidt.h
+++ b/src/Magnum/Math/Algorithms/GramSchmidt.h
@@ -35,7 +35,7 @@ namespace Magnum { namespace Math { namespace Algorithms {
 
 /**
 @brief In-place Gram-Schmidt matrix orthogonalization
-@param[in,out] matrix   %Matrix to perform orthogonalization on
+@param[in,out] matrix   Matrix to perform orthogonalization on
 */
 template<std::size_t cols, std::size_t rows, class T> void gramSchmidtOrthogonalizeInPlace(RectangularMatrix<cols, rows, T>& matrix) {
     static_assert(cols <= rows, "Unsupported matrix aspect ratio");
@@ -58,7 +58,7 @@ template<std::size_t cols, std::size_t rows, class T> RectangularMatrix<cols, ro
 
 /**
 @brief In-place Gram-Schmidt matrix orthonormalization
-@param[in,out] matrix   %Matrix to perform orthonormalization on
+@param[in,out] matrix   Matrix to perform orthonormalization on
 */
 template<std::size_t cols, std::size_t rows, class T> void gramSchmidtOrthonormalizeInPlace(RectangularMatrix<cols, rows, T>& matrix) {
     static_assert(cols <= rows, "Unsupported matrix aspect ratio");
diff --git a/src/Magnum/Math/BoolVector.h b/src/Magnum/Math/BoolVector.h
index 4eee4e7a0..0146944a6 100644
--- a/src/Magnum/Math/BoolVector.h
+++ b/src/Magnum/Math/BoolVector.h
@@ -54,7 +54,7 @@ namespace Implementation {
 }
 
 /**
-@brief %Vector storing boolean values
+@brief Vector storing boolean values
 @tparam size    Bit count
 
 Result of component-wise comparison from Vector. The boolean values are stored
@@ -66,8 +66,8 @@ template<std::size_t size> class BoolVector {
     static_assert(size != 0, "BoolVector cannot have zero elements");
 
     public:
-        static const std::size_t Size = size;               /**< @brief %Vector size */
-        static const std::size_t DataSize = (size-1)/8+1;   /**< @brief %Vector storage size */
+        static const std::size_t Size = size;               /**< @brief Vector size */
+        static const std::size_t DataSize = (size-1)/8+1;   /**< @brief Vector storage size */
 
         /** @brief Construct zero-filled boolean vector */
         constexpr BoolVector(): _data() {}
@@ -98,7 +98,7 @@ template<std::size_t size> class BoolVector {
 
         /**
          * @brief Raw data
-         * @return %Array of DataSize length
+         * @return Array of DataSize length
          *
          * @see @ref operator[](), @ref set()
          */
diff --git a/src/Magnum/Math/Complex.h b/src/Magnum/Math/Complex.h
index 6edd026ec..076774996 100644
--- a/src/Magnum/Math/Complex.h
+++ b/src/Magnum/Math/Complex.h
@@ -47,7 +47,7 @@ namespace Implementation {
 }
 
 /**
-@brief %Complex number
+@brief Complex number
 @tparam T   Data type
 
 Represents 2D rotation. See @ref transformations for brief introduction.
@@ -336,7 +336,7 @@ template<class T> class Complex {
         }
 
         /**
-         * @brief %Complex number length
+         * @brief Complex number length
          *
          * See also @ref dot() const which is faster for comparing length with
          * other values. @f[
diff --git a/src/Magnum/Math/Dual.h b/src/Magnum/Math/Dual.h
index 7d5533353..ce2513657 100644
--- a/src/Magnum/Math/Dual.h
+++ b/src/Magnum/Math/Dual.h
@@ -37,7 +37,7 @@
 namespace Magnum { namespace Math {
 
 /**
-@brief %Dual number
+@brief Dual number
 @tparam T   Underlying data type
 */
 template<class T> class Dual {
@@ -76,7 +76,7 @@ template<class T> class Dual {
         /** @brief Real part */
         constexpr T real() const { return _real; }
 
-        /** @brief %Dual part */
+        /** @brief Dual part */
         constexpr T dual() const { return _dual; }
 
         /**
diff --git a/src/Magnum/Math/DualComplex.h b/src/Magnum/Math/DualComplex.h
index 215ab4eef..a8b8a977c 100644
--- a/src/Magnum/Math/DualComplex.h
+++ b/src/Magnum/Math/DualComplex.h
@@ -36,7 +36,7 @@
 namespace Magnum { namespace Math {
 
 /**
-@brief %Dual complex number
+@brief Dual complex number
 @tparam T   Underlying data type
 
 Represents 2D rotation and translation. See @ref transformations for brief
@@ -227,7 +227,7 @@ template<class T> class DualComplex: public Dual<Complex<T>> {
         }
 
         /**
-         * @brief %Complex number length squared
+         * @brief Complex number length squared
          *
          * Should be used instead of length() for comparing complex number
          * length with other values, because it doesn't compute the square root. @f[
@@ -240,7 +240,7 @@ template<class T> class DualComplex: public Dual<Complex<T>> {
         }
 
         /**
-         * @brief %Dual quaternion length
+         * @brief Dual quaternion length
          *
          * See lengthSquared() which is faster for comparing length with other
          * values. @f[
diff --git a/src/Magnum/Math/DualQuaternion.h b/src/Magnum/Math/DualQuaternion.h
index 918207a50..17618da4d 100644
--- a/src/Magnum/Math/DualQuaternion.h
+++ b/src/Magnum/Math/DualQuaternion.h
@@ -36,7 +36,7 @@
 namespace Magnum { namespace Math {
 
 /**
-@brief %Dual quaternion
+@brief Dual quaternion
 @tparam T   Underlying data type
 
 Represents 3D rotation and translation. See @ref transformations for brief
@@ -226,7 +226,7 @@ template<class T> class DualQuaternion: public Dual<Quaternion<T>> {
         }
 
         /**
-         * @brief %Dual quaternion length squared
+         * @brief Dual quaternion length squared
          *
          * Should be used instead of @ref length() for comparing dual
          * quaternion length with other values, because it doesn't compute the
@@ -239,7 +239,7 @@ template<class T> class DualQuaternion: public Dual<Quaternion<T>> {
         }
 
         /**
-         * @brief %Dual quaternion length
+         * @brief Dual quaternion length
          *
          * See @ref lengthSquared() which is faster for comparing length with other
          * values. @f[
diff --git a/src/Magnum/Math/Geometry/Distance.h b/src/Magnum/Math/Geometry/Distance.h
index 26dee4b2d..8efb47fb5 100644
--- a/src/Magnum/Math/Geometry/Distance.h
+++ b/src/Magnum/Math/Geometry/Distance.h
@@ -40,7 +40,7 @@ class Distance {
         Distance() = delete;
 
         /**
-         * @brief %Distance of line and point in 2D
+         * @brief Distance of line and point in 2D
          * @param a         First point of the line
          * @param b         Second point of the line
          * @param point     Point
@@ -58,7 +58,7 @@ class Distance {
         }
 
         /**
-         * @brief %Distance of line and point in 2D, squared
+         * @brief Distance of line and point in 2D, squared
          * @param a         First point of the line
          * @param b         Second point of the line
          * @param point     Point
@@ -74,7 +74,7 @@ class Distance {
         }
 
         /**
-         * @brief %Distance of line and point in 3D
+         * @brief Distance of line and point in 3D
          * @param a         First point of the line
          * @param b         Second point of the line
          * @param point     Point
@@ -92,7 +92,7 @@ class Distance {
         }
 
         /**
-         * @brief %Distance of line and point in 3D, squared
+         * @brief Distance of line and point in 3D, squared
          *
          * More efficient than @ref linePoint(const Vector3<T>&, const Vector3<T>&, const Vector3<T>&)
          * for comparing distance with other values, because it doesn't
@@ -103,7 +103,7 @@ class Distance {
         }
 
         /**
-         * @brief %Dístance of point from line segment in 2D
+         * @brief Dístance of point from line segment in 2D
          * @param a         Starting point of the line
          * @param b         Ending point of the line
          * @param point     Point
@@ -131,7 +131,7 @@ class Distance {
         template<class T> static T lineSegmentPoint(const Vector2<T>& a, const Vector2<T>& b, const Vector2<T>& point);
 
         /**
-         * @brief %Distance of point from line segment in 2D, squared
+         * @brief Distance of point from line segment in 2D, squared
          *
          * More efficient than @ref lineSegmentPoint() for comparing distance
          * with other values, because it doesn't compute the square root.
@@ -139,7 +139,7 @@ class Distance {
         template<class T> static T lineSegmentPointSquared(const Vector2<T>& a, const Vector2<T>& b, const Vector2<T>& point);
 
         /**
-         * @brief %Dístance of point from line segment in 3D
+         * @brief Dístance of point from line segment in 3D
          * @param a         Starting point of the line
          * @param b         Ending point of the line
          * @param point     Point
@@ -154,7 +154,7 @@ class Distance {
         }
 
         /**
-         * @brief %Distance of point from line segment in 3D, squared
+         * @brief Distance of point from line segment in 3D, squared
          *
          * More efficient than
          * @ref lineSegmentPoint(const Vector3<T>&, const Vector3<T>&, const Vector3<T>&)
diff --git a/src/Magnum/Math/Geometry/Intersection.h b/src/Magnum/Math/Geometry/Intersection.h
index fc06ec9cd..c9069321b 100644
--- a/src/Magnum/Math/Geometry/Intersection.h
+++ b/src/Magnum/Math/Geometry/Intersection.h
@@ -39,14 +39,14 @@ class Intersection {
         Intersection() = delete;
 
         /**
-         * @brief %Intersection of two line segments in 2D
+         * @brief Intersection of two line segments in 2D
          * @param p             Starting point of first line segment
          * @param r             Direction of first line segment
          * @param q             Starting point of second line segment
          * @param s             Direction of second line segment
-         * @return %Intersection point positions `t`, `u` on both lines, NaN if
+         * @return Intersection point positions `t`, `u` on both lines, NaN if
          *      the lines are collinear or infinity if they are parallel.
-         *      %Intersection point can be then computed with `p + t*r` or
+         *      Intersection point can be then computed with `p + t*r` or
          *      `q + u*s`. If `t` is in range @f$ [ 0 ; 1 ] @f$, the
          *      intersection is inside the line segment defined by `p` and
          *      `p + r`, if `u` is in range @f$ [ 0 ; 1 ] @f$, the intersection
@@ -78,14 +78,14 @@ class Intersection {
         }
 
         /**
-         * @brief %Intersection of line segment and line in 2D
+         * @brief Intersection of line segment and line in 2D
          * @param p             Starting point of first line segment
          * @param r             Direction of first line segment
          * @param q             Starting point of second line
          * @param s             Direction of second line
-         * @return %Intersection point position `t` on first line, NaN if the
+         * @return Intersection point position `t` on first line, NaN if the
          *      lines are collinear or infinity if they are parallel.
-         *      %Intersection point can be then with `p + t*r`. If returned
+         *      Intersection point can be then with `p + t*r`. If returned
          *      value is in range @f$ [ 0 ; 1 ] @f$, the intersection is inside
          *      the line segment defined by `p` and `p + r`.
          *
@@ -96,14 +96,14 @@ class Intersection {
         }
 
         /**
-         * @brief %Intersection of a plane and line
+         * @brief Intersection of a plane and line
          * @param planePosition Plane position
          * @param planeNormal   Plane normal
          * @param p             Starting point of the line
          * @param r             Direction of the line
-         * @return %Intersection point position `t` on the line, NaN if the
+         * @return Intersection point position `t` on the line, NaN if the
          *      line lies on the plane or infinity if the intersection doesn't
-         *      exist. %Intersection point can be then computed from with
+         *      exist. Intersection point can be then computed from with
          *      `p + t*r`. If returned value is in range @f$ [ 0 ; 1 ] @f$, the
          *      intersection is inside the line segment defined by `p` and `r`.
          *
diff --git a/src/Magnum/Math/Matrix.h b/src/Magnum/Math/Matrix.h
index fa05b1e1b..21ac78ca2 100644
--- a/src/Magnum/Math/Matrix.h
+++ b/src/Magnum/Math/Matrix.h
@@ -39,7 +39,7 @@ namespace Implementation {
 
 /**
 @brief Square matrix
-@tparam size    %Matrix size
+@tparam size    Matrix size
 @tparam T       Data type
 
 See @ref matrix-vector for brief introduction.
@@ -49,7 +49,7 @@ See @ref matrix-vector for brief introduction.
  */
 template<std::size_t size, class T> class Matrix: public RectangularMatrix<size, size, T> {
     public:
-        const static std::size_t Size = size; /**< @brief %Matrix size */
+        const static std::size_t Size = size; /**< @brief Matrix size */
 
         /** @brief Pass to constructor to create zero-filled matrix */
         enum ZeroType { Zero };
@@ -57,7 +57,7 @@ template<std::size_t size, class T> class Matrix: public RectangularMatrix<size,
         /**
          * @brief Zero-filled matrix constructor
          *
-         * Use this constructor by calling `%Matrix m(Matrix::Zero);`.
+         * Use this constructor by calling `Matrix m(Matrix::Zero);`.
          */
         constexpr explicit Matrix(ZeroType) {}
 
@@ -68,13 +68,13 @@ template<std::size_t size, class T> class Matrix: public RectangularMatrix<size,
          * @brief Default constructor
          *
          * You can also explicitly call this constructor with
-         * `%Matrix m(Matrix::Identity);`. Optional parameter @p value allows
+         * `Matrix m(Matrix::Identity);`. Optional parameter @p value allows
          * you to specify value on diagonal.
          */
         constexpr /*implicit*/ Matrix(IdentityType = Identity, T value = T(1)): RectangularMatrix<size, size, T>(typename Implementation::GenerateSequence<size>::Type(), Vector<size, T>(value)) {}
 
         /**
-         * @brief %Matrix from column vectors
+         * @brief Matrix from column vectors
          * @param first First column vector
          * @param next  Next column vectors
          */
@@ -121,7 +121,7 @@ template<std::size_t size, class T> class Matrix: public RectangularMatrix<size,
          */
         T trace() const { return RectangularMatrix<size, size, T>::diagonal().sum(); }
 
-        /** @brief %Matrix without given column and row */
+        /** @brief Matrix without given column and row */
         Matrix<size-1, T> ij(std::size_t skipCol, std::size_t skipRow) const;
 
         /**
@@ -184,7 +184,7 @@ template<std::size_t size, class T> class Matrix: public RectangularMatrix<size,
 /**
 @brief 2x2 matrix
 
-Convenience alternative to <tt>%Matrix<2, T></tt>. See @ref Matrix for more
+Convenience alternative to `Matrix<2, T>`. See @ref Matrix for more
 information.
 @see @ref Magnum::Matrix2x2, @ref Magnum::Matrix2x2d
 */
@@ -193,7 +193,7 @@ template<class T> using Matrix2x2 = Matrix<2, T>;
 /**
 @brief 3x3 matrix
 
-Convenience alternative to <tt>%Matrix<3, T></tt>. See @ref Matrix for more
+Convenience alternative to `Matrix<3, T>`. See @ref Matrix for more
 information. Note that this is different from @ref Matrix3, which contains
 additional functions for transformations in 2D.
 @see @ref Magnum::Matrix3x3, @ref Magnum::Matrix3x3d
@@ -203,7 +203,7 @@ template<class T> using Matrix3x3 = Matrix<3, T>;
 /**
 @brief 4x4 matrix
 
-Convenience alternative to <tt>%Matrix<4, T></tt>. See @ref Matrix for more
+Convenience alternative to `Matrix<4, T>`. See @ref Matrix for more
 information. Note that this is different from @ref Matrix4, which contains
 additional functions for transformations in 3D.
 @see @ref Magnum::Matrix4x4, @ref Magnum::Matrix4x4d
diff --git a/src/Magnum/Math/Matrix3.h b/src/Magnum/Math/Matrix3.h
index c346e46fd..d620a4baf 100644
--- a/src/Magnum/Math/Matrix3.h
+++ b/src/Magnum/Math/Matrix3.h
@@ -132,12 +132,12 @@ template<class T> class Matrix3: public Matrix3x3<T> {
          * @brief Default constructor
          *
          * Creates identity matrix. You can also explicitly call this
-         * constructor with `%Matrix3 m(Matrix3::Identity);`. Optional
+         * constructor with `Matrix3 m(Matrix3::Identity);`. Optional
          * parameter @p value allows you to specify value on diagonal.
          */
         constexpr /*implicit*/ Matrix3(typename Matrix3x3<T>::IdentityType = (Matrix3x3<T>::Identity), T value = T(1)): Matrix3x3<T>(Matrix3x3<T>::Identity, value) {}
 
-        /** @brief %Matrix from column vectors */
+        /** @brief Matrix from column vectors */
         constexpr /*implicit*/ Matrix3(const Vector3<T>& first, const Vector3<T>& second, const Vector3<T>& third): Matrix3x3<T>(first, second, third) {}
 
         /** @copydoc Matrix::Matrix(const RectangularMatrix<size, size, U>&) */
diff --git a/src/Magnum/Math/Matrix4.h b/src/Magnum/Math/Matrix4.h
index bec756648..fc011c4be 100644
--- a/src/Magnum/Math/Matrix4.h
+++ b/src/Magnum/Math/Matrix4.h
@@ -102,7 +102,7 @@ template<class T> class Matrix4: public Matrix4x4<T> {
          * @brief 3D rotation around X axis
          * @param angle Rotation angle (counterclockwise)
          *
-         * Faster than calling `%Matrix4::rotation(angle, %Vector3::xAxis())`.
+         * Faster than calling `Matrix4::rotation(angle, Vector3::xAxis())`.
          * @see @ref rotation(Rad, const Vector3<T>&), @ref rotationY(),
          *      @ref rotationZ(), @link rotation() const @endlink,
          *      @ref Quaternion::rotation(), @ref Matrix3::rotation(Rad)
@@ -114,7 +114,7 @@ template<class T> class Matrix4: public Matrix4x4<T> {
          * @brief 3D rotation around Y axis
          * @param angle Rotation angle (counterclockwise)
          *
-         * Faster than calling `%Matrix4::rotation(angle, %Vector3::yAxis())`.
+         * Faster than calling `Matrix4::rotation(angle, Vector3::yAxis())`.
          * @see @ref rotation(Rad, const Vector3<T>&), @ref rotationX(),
          *      @ref rotationZ(), @link rotation() const @endlink,
          *      @ref Quaternion::rotation(), @ref Matrix3::rotation(Rad)
@@ -126,7 +126,7 @@ template<class T> class Matrix4: public Matrix4x4<T> {
          * @brief 3D rotation matrix around Z axis
          * @param angle Rotation angle (counterclockwise)
          *
-         * Faster than calling `%Matrix4::rotation(angle, %Vector3::zAxis())`.
+         * Faster than calling `Matrix4::rotation(angle, Vector3::zAxis())`.
          * @see @ref rotation(Rad, const Vector3<T>&), @ref rotationX(),
          *      @ref rotationY(), @link rotation() const @endlink,
          *      @ref Quaternion::rotation(), @ref Matrix3::rotation(Rad)
@@ -201,12 +201,12 @@ template<class T> class Matrix4: public Matrix4x4<T> {
          * @brief Default constructor
          *
          * Creates identity matrix. You can also explicitly call this
-         * constructor with `%Matrix4 m(Matrix4::Identity);`. Optional
+         * constructor with `Matrix4 m(Matrix4::Identity);`. Optional
          * parameter @p value allows you to specify value on diagonal.
          */
         constexpr /*implicit*/ Matrix4(typename Matrix4x4<T>::IdentityType = (Matrix4x4<T>::Identity), T value = T(1)): Matrix4x4<T>(Matrix4x4<T>::Identity, value) {}
 
-        /** @brief %Matrix from column vectors */
+        /** @brief Matrix from column vectors */
         constexpr /*implicit*/ Matrix4(const Vector4<T>& first, const Vector4<T>& second, const Vector4<T>& third, const Vector4<T>& fourth): Matrix4x4<T>(first, second, third, fourth) {}
 
         /** @copydoc Matrix::Matrix(const RectangularMatrix<size, size, U>&) */
diff --git a/src/Magnum/Math/Quaternion.h b/src/Magnum/Math/Quaternion.h
index 671151b27..bfec3aef7 100644
--- a/src/Magnum/Math/Quaternion.h
+++ b/src/Magnum/Math/Quaternion.h
@@ -40,7 +40,7 @@
 namespace Magnum { namespace Math {
 
 /**
-@brief %Quaternion
+@brief Quaternion
 @tparam T   Underlying data type
 
 Represents 3D rotation. See @ref transformations for brief introduction.
@@ -169,7 +169,7 @@ template<class T> class Quaternion {
         /**
          * @brief Whether the quaternion is normalized
          *
-         * %Quaternion is normalized if it has unit length: @f[
+         * Quaternion is normalized if it has unit length: @f[
          *      |q \cdot q - 1| < 2 \epsilon + \epsilon^2 \cong 2 \epsilon
          * @f]
          * @see @ref dot(), @ref normalized()
@@ -178,10 +178,10 @@ template<class T> class Quaternion {
             return Implementation::isNormalizedSquared(dot());
         }
 
-        /** @brief %Vector part */
+        /** @brief Vector part */
         constexpr Vector3<T> vector() const { return _vector; }
 
-        /** @brief %Scalar part */
+        /** @brief Scalar part */
         constexpr T scalar() const { return _scalar; }
 
         /**
@@ -335,7 +335,7 @@ template<class T> class Quaternion {
         T dot() const { return dot(*this, *this); }
 
         /**
-         * @brief %Quaternion length
+         * @brief Quaternion length
          *
          * See also @link dot() const @endlink which is faster for comparing
          * length with other values. @f[
diff --git a/src/Magnum/Math/Range.h b/src/Magnum/Math/Range.h
index 2c4404326..a0ba3e29f 100644
--- a/src/Magnum/Math/Range.h
+++ b/src/Magnum/Math/Range.h
@@ -62,7 +62,7 @@ template<UnsignedInt dimensions, class T> class Range {
         /**
          * Create range from minimal coordinates and size
          * @param min   Minimal coordinates
-         * @param size  %Range size
+         * @param size  Range size
          */
         static Range<dimensions, T> fromSize(const VectorType& min, const VectorType& size) {
             return {min, min+size};
@@ -129,7 +129,7 @@ template<UnsignedInt dimensions, class T> class Range {
         constexpr const VectorType max() const { return _max; } /**< @overload */
 
         /**
-         * @brief %Range size
+         * @brief Range size
          *
          * @see @ref min(), @ref max(), @ref Range2D::sizeX(),
          *      @ref Range2D::sizeY(), @ref Range3D::sizeX(),
@@ -138,7 +138,7 @@ template<UnsignedInt dimensions, class T> class Range {
         VectorType size() const { return _max - _min; }
 
         /**
-         * @brief %Range center
+         * @brief Range center
          *
          * @see @ref Range2D::centerX(), @ref Range2D::centerY(),
          *      @ref Range3D::centerX(), @ref Range3D::centerY(),
@@ -195,7 +195,7 @@ template<UnsignedInt dimensions, class T> class Range {
 /**
 @brief One-dimensional range
 
-Convenience alternative to <tt>%Range<1, T></tt>. See @ref Range for more
+Convenience alternative to `Range<1, T>`. See @ref Range for more
 information.
 */
 template<class T> using Range1D = Range<1, T>;
@@ -263,7 +263,7 @@ template<class T> class Range2D: public Range<2, T> {
         constexpr T top() const { return Range<2, T>::max().y(); } /**< @overload */
 
         /**
-         * @brief %Range width
+         * @brief Range width
          *
          * @see @ref size()
          */
@@ -272,7 +272,7 @@ template<class T> class Range2D: public Range<2, T> {
         }
 
         /**
-         * @brief %Range height
+         * @brief Range height
          *
          * @see @ref size()
          */
@@ -281,7 +281,7 @@ template<class T> class Range2D: public Range<2, T> {
         }
 
         /**
-         * @brief %Range center on X axis
+         * @brief Range center on X axis
          *
          * @see @ref center()
          */
@@ -290,7 +290,7 @@ template<class T> class Range2D: public Range<2, T> {
         }
 
         /**
-         * @brief %Range center on Y axis
+         * @brief Range center on Y axis
          *
          * @see @ref center()
          */
@@ -392,7 +392,7 @@ template<class T> class Range3D: public Range<3, T> {
         constexpr T front() const { return Range<3, T>::max().z(); } /**< @overload */
 
         /**
-         * @brief %Range width
+         * @brief Range width
          *
          * @see @ref size()
          */
@@ -401,7 +401,7 @@ template<class T> class Range3D: public Range<3, T> {
         }
 
         /**
-         * @brief %Range height
+         * @brief Range height
          *
          * @see @ref size()
          */
@@ -410,7 +410,7 @@ template<class T> class Range3D: public Range<3, T> {
         }
 
         /**
-         * @brief %Range depth
+         * @brief Range depth
          *
          * @see @ref size()
          */
@@ -420,7 +420,7 @@ template<class T> class Range3D: public Range<3, T> {
 
         /**
          *
-         * @brief %Range center on X axis
+         * @brief Range center on X axis
          *
          * @see @ref center()
          */
@@ -429,7 +429,7 @@ template<class T> class Range3D: public Range<3, T> {
         }
 
         /**
-         * @brief %Range center on Y axis
+         * @brief Range center on Y axis
          *
          * @see @ref center()
          */
@@ -438,7 +438,7 @@ template<class T> class Range3D: public Range<3, T> {
         }
 
         /**
-         * @brief %Range center on Z axis
+         * @brief Range center on Z axis
          *
          * @see @ref center()
          */
diff --git a/src/Magnum/Math/RectangularMatrix.h b/src/Magnum/Math/RectangularMatrix.h
index 0dcd29310..d1d4af656 100644
--- a/src/Magnum/Math/RectangularMatrix.h
+++ b/src/Magnum/Math/RectangularMatrix.h
@@ -59,8 +59,8 @@ template<std::size_t cols, std::size_t rows, class T> class RectangularMatrix {
 
     public:
         typedef T Type;                         /**< @brief Underlying data type */
-        const static std::size_t Cols = cols;   /**< @brief %Matrix column count */
-        const static std::size_t Rows = rows;   /**< @brief %Matrix row count */
+        const static std::size_t Cols = cols;   /**< @brief Matrix column count */
+        const static std::size_t Rows = rows;   /**< @brief Matrix row count */
 
         /**
          * @brief Size of matrix diagonal
@@ -70,7 +70,7 @@ template<std::size_t cols, std::size_t rows, class T> class RectangularMatrix {
         const static std::size_t DiagonalSize = (cols < rows ? cols : rows);
 
         /**
-         * @brief %Matrix from array
+         * @brief Matrix from array
          * @return Reference to the data as if it was matrix, thus doesn't
          *      perform any copying.
          *
@@ -157,7 +157,7 @@ template<std::size_t cols, std::size_t rows, class T> class RectangularMatrix {
         constexpr const T* data() const { return _data[0].data(); } /**< @overload */
 
         /**
-         * @brief %Matrix column
+         * @brief Matrix column
          *
          * Particular elements can be accessed using @ref Vector::operator[](),
          * e.g.:
@@ -172,7 +172,7 @@ template<std::size_t cols, std::size_t rows, class T> class RectangularMatrix {
         constexpr const Vector<rows, T>& operator[](std::size_t col) const { return _data[col]; } /**< @overload */
 
         /**
-         * @brief %Matrix row
+         * @brief Matrix row
          *
          * Consider using @ref transposed() when accessing rows frequently, as
          * this is slower than accessing columns due to the way the matrix is
@@ -367,54 +367,54 @@ template<std::size_t cols, std::size_t rows, class T> class RectangularMatrix {
 };
 
 /**
-@brief %Matrix with 2 columns and 3 rows
+@brief Matrix with 2 columns and 3 rows
 
-Convenience alternative to <tt>%RectangularMatrix<2, 3, T></tt>. See
+Convenience alternative to `RectangularMatrix<2, 3, T>`. See
 @ref RectangularMatrix for more information.
 @see @ref Magnum::Matrix2x3, @ref Magnum::Matrix2x3d
 */
 template<class T> using Matrix2x3 = RectangularMatrix<2, 3, T>;
 
 /**
-@brief %Matrix with 3 columns and 2 rows
+@brief Matrix with 3 columns and 2 rows
 
-Convenience alternative to <tt>%RectangularMatrix<3, 2, T></tt>. See
+Convenience alternative to `RectangularMatrix<3, 2, T>`. See
 @ref RectangularMatrix for more information.
 @see @ref Magnum::Matrix3x2, @ref Magnum::Matrix3x2d
 */
 template<class T> using Matrix3x2 = RectangularMatrix<3, 2, T>;
 
 /**
-@brief %Matrix with 2 columns and 4 rows
+@brief Matrix with 2 columns and 4 rows
 
-Convenience alternative to <tt>%RectangularMatrix<2, 4, T></tt>. See
+Convenience alternative to `RectangularMatrix<2, 4, T>`. See
 @ref RectangularMatrix for more information.
 @see @ref Magnum::Matrix2x4, @ref Magnum::Matrix2x4d
 */
 template<class T> using Matrix2x4 = RectangularMatrix<2, 4, T>;
 
 /**
-@brief %Matrix with 4 columns and 2 rows
+@brief Matrix with 4 columns and 2 rows
 
-Convenience alternative to <tt>%RectangularMatrix<4, 2, T></tt>. See
+Convenience alternative to `RectangularMatrix<4, 2, T>`. See
 @ref RectangularMatrix for more information.
 @see @ref Magnum::Matrix4x2, @ref Magnum::Matrix4x2d
 */
 template<class T> using Matrix4x2 = RectangularMatrix<4, 2, T>;
 
 /**
-@brief %Matrix with 3 columns and 4 rows
+@brief Matrix with 3 columns and 4 rows
 
-Convenience alternative to <tt>%RectangularMatrix<3, 4, T></tt>. See
+Convenience alternative to `RectangularMatrix<3, 4, T>`. See
 @ref RectangularMatrix for more information.
 @see @ref Magnum::Matrix3x4, @ref Magnum::Matrix3x4d
 */
 template<class T> using Matrix3x4 = RectangularMatrix<3, 4, T>;
 
 /**
-@brief %Matrix with 4 columns and 3 rows
+@brief Matrix with 4 columns and 3 rows
 
-Convenience alternative to <tt>%RectangularMatrix<4, 3, T></tt>. See
+Convenience alternative to `RectangularMatrix<4, 3, T>`. See
 @ref RectangularMatrix for more information.
 @see @ref Magnum::Matrix4x3, @ref Magnum::Matrix4x3d
 */
diff --git a/src/Magnum/Math/Vector.h b/src/Magnum/Math/Vector.h
index 39609183f..eb2a2c530 100644
--- a/src/Magnum/Math/Vector.h
+++ b/src/Magnum/Math/Vector.h
@@ -47,8 +47,8 @@ namespace Implementation {
 }
 
 /**
-@brief %Vector
-@tparam size    %Vector size
+@brief Vector
+@tparam size    Vector size
 @tparam T       Underlying data type
 
 See @ref matrix-vector for brief introduction.
@@ -61,10 +61,10 @@ template<std::size_t size, class T> class Vector {
 
     public:
         typedef T Type;                         /**< @brief Underlying data type */
-        const static std::size_t Size = size;   /**< @brief %Vector size */
+        const static std::size_t Size = size;   /**< @brief Vector size */
 
         /**
-         * @brief %Vector from array
+         * @brief Vector from array
          * @return Reference to the data as if it was Vector, thus doesn't
          *      perform any copying.
          *
@@ -404,7 +404,7 @@ template<std::size_t size, class T> class Vector {
         T dot() const { return dot(*this, *this); }
 
         /**
-         * @brief %Vector length
+         * @brief Vector length
          *
          * See also @ref dot() const which is faster for comparing length with
          * other values. @f[
@@ -450,7 +450,7 @@ template<std::size_t size, class T> class Vector {
         }
 
         /**
-         * @brief %Vector projected onto line
+         * @brief Vector projected onto line
          *
          * Returns vector projected onto @p line. @f[
          *      \boldsymbol a_1 = \frac{\boldsymbol a \cdot \boldsymbol b}{\boldsymbol b \cdot \boldsymbol b} \boldsymbol b
@@ -462,7 +462,7 @@ template<std::size_t size, class T> class Vector {
         }
 
         /**
-         * @brief %Vector projected onto normalized line
+         * @brief Vector projected onto normalized line
          *
          * Slightly faster alternative to @ref projected(), expects @p line to
          * be normalized. @f[
diff --git a/src/Magnum/Math/Vector2.h b/src/Magnum/Math/Vector2.h
index fd06a4eff..947428d1b 100644
--- a/src/Magnum/Math/Vector2.h
+++ b/src/Magnum/Math/Vector2.h
@@ -45,7 +45,7 @@ See @ref matrix-vector for brief introduction.
 template<class T> class Vector2: public Vector<2, T> {
     public:
         /**
-         * @brief %Vector in direction of X axis (right)
+         * @brief Vector in direction of X axis (right)
          *
          * Usable for translation in given axis, for example:
          * @code
@@ -56,7 +56,7 @@ template<class T> class Vector2: public Vector<2, T> {
         constexpr static Vector2<T> xAxis(T length = T(1)) { return {length, T(0)}; }
 
         /**
-         * @brief %Vector in direction of Y axis (up)
+         * @brief Vector in direction of Y axis (up)
          *
          * See @ref xAxis() for more information.
          * @see @ref yScale(), @ref Matrix3::up()
diff --git a/src/Magnum/Math/Vector3.h b/src/Magnum/Math/Vector3.h
index 210431beb..8df15aa2a 100644
--- a/src/Magnum/Math/Vector3.h
+++ b/src/Magnum/Math/Vector3.h
@@ -46,7 +46,7 @@ See @ref matrix-vector for brief introduction.
 template<class T> class Vector3: public Vector<3, T> {
     public:
         /**
-         * @brief %Vector in direction of X axis (right)
+         * @brief Vector in direction of X axis (right)
          *
          * Usable for translation or rotation along given axis, for example:
          * @code
@@ -59,7 +59,7 @@ template<class T> class Vector3: public Vector<3, T> {
         constexpr static Vector3<T> xAxis(T length = T(1)) { return {length, T(0), T(0)}; }
 
         /**
-         * @brief %Vector in direction of Y axis (up)
+         * @brief Vector in direction of Y axis (up)
          *
          * See @ref xAxis() for more information.
          * @see @ref yScale(), @ref Color3::green(), @ref Matrix4::up()
@@ -67,7 +67,7 @@ template<class T> class Vector3: public Vector<3, T> {
         constexpr static Vector3<T> yAxis(T length = T(1)) { return {T(0), length, T(0)}; }
 
         /**
-         * @brief %Vector in direction of Z axis (backward)
+         * @brief Vector in direction of Z axis (backward)
          *
          * See @ref xAxis() for more information.
          * @see @ref zScale(), @ref Color3::blue(), @ref Matrix4::backward()