diff --git a/src/Magnum/Math/BoolVector.h b/src/Magnum/Math/BoolVector.h
index 40cf5e3f4..87df34d18 100644
--- a/src/Magnum/Math/BoolVector.h
+++ b/src/Magnum/Math/BoolVector.h
@@ -49,6 +49,13 @@ namespace Implementation {
     template<std::size_t ...sequence> struct GenerateSequence<0, sequence...> {
         typedef Sequence<sequence...> Type;
     };
+
+    template<std::size_t N, std::size_t ...sequence> struct GenerateReverseSequence:
+        GenerateReverseSequence<N-1, sequence..., N-1> {};
+
+    template<std::size_t ...sequence> struct GenerateReverseSequence<0, sequence...> {
+        typedef Sequence<sequence...> Type;
+    };
     #endif
 
     template<class T> constexpr T repeat(T value, std::size_t) { return value; }
diff --git a/src/Magnum/Math/Test/VectorTest.cpp b/src/Magnum/Math/Test/VectorTest.cpp
index 2c835d5f4..c4f25cc90 100644
--- a/src/Magnum/Math/Test/VectorTest.cpp
+++ b/src/Magnum/Math/Test/VectorTest.cpp
@@ -100,6 +100,8 @@ struct VectorTest: Corrade::TestSuite::Tester {
 
     void projected();
     void projectedOntoNormalized();
+    void flipped();
+
     void angle();
 
     void subclassTypes();
@@ -158,6 +160,8 @@ VectorTest::VectorTest() {
 
               &VectorTest::projected,
               &VectorTest::projectedOntoNormalized,
+              &VectorTest::flipped,
+
               &VectorTest::angle,
 
               &VectorTest::subclassTypes,
@@ -462,6 +466,12 @@ void VectorTest::projectedOntoNormalized() {
     CORRADE_COMPARE(projected, vector.projected(line));
 }
 
+void VectorTest::flipped() {
+    constexpr Vector4 vector{1.0f, -3.5f, 2.1f, 0.5f};
+    constexpr Vector4 flipped = vector.flipped();
+    CORRADE_COMPARE(flipped, (Vector4{0.5f, 2.1f, -3.5f, 1.0f}));
+}
+
 void VectorTest::angle() {
     std::ostringstream o;
     Error redirectError{&o};
@@ -557,6 +567,7 @@ void VectorTest::subclassTypes() {
     CORRADE_VERIFY((std::is_same<decltype(c.resized(1.0f)), Vec2>::value));
     CORRADE_VERIFY((std::is_same<decltype(c.projected(c2)), Vec2>::value));
     CORRADE_VERIFY((std::is_same<decltype(c.projectedOntoNormalized(c2)), Vec2>::value));
+    CORRADE_VERIFY((std::is_same<decltype(c.flipped()), Vec2>::value));
 }
 
 void VectorTest::subclass() {
@@ -638,6 +649,8 @@ void VectorTest::subclass() {
     CORRADE_COMPARE(Vec2(3.0f, 0.0f).resized(6.0f), Vec2(6.0f, 0.0f));
     CORRADE_COMPARE(Vec2(1.0f, 1.0f).projected({0.0f, 2.0f}), Vec2(0.0f, 1.0f));
     CORRADE_COMPARE(Vec2(1.0f, 1.0f).projectedOntoNormalized({0.0f, 1.0f}), Vec2(0.0f, 1.0f));
+    constexpr Vec2 flipped = Vec2{1.0f, 0.4f}.flipped();
+    CORRADE_COMPARE(flipped, (Vec2{0.4f, 1.0f}));
 }
 
 void VectorTest::debug() {
diff --git a/src/Magnum/Math/Vector.h b/src/Magnum/Math/Vector.h
index c78619a1c..5c435b826 100644
--- a/src/Magnum/Math/Vector.h
+++ b/src/Magnum/Math/Vector.h
@@ -536,6 +536,15 @@ template<std::size_t size, class T> class Vector {
          */
         Vector<size, T> projectedOntoNormalized(const Vector<size, T>& line) const;
 
+        /**
+         * @brief Flipped vector
+         *
+         * Returns the vector with components in reverse order.
+         */
+        constexpr Vector<size, T> flipped() const {
+            return flippedInternal(typename Implementation::GenerateReverseSequence<size>::Type{});
+        }
+
         /**
          * @brief Sum of values in the vector
          *
@@ -575,6 +584,10 @@ template<std::size_t size, class T> class Vector {
             return {sequence < otherSize ? a[sequence] : value...};
         }
 
+        template<std::size_t ...sequence> constexpr Vector<size, T> flippedInternal(Implementation::Sequence<sequence...>) const {
+            return {(*this)[sequence]...};
+        }
+
         T _data[size];
 };
 
@@ -1164,6 +1177,9 @@ extern template MAGNUM_EXPORT Corrade::Utility::Debug& operator<<(Corrade::Utili
     }                                                                       \
     Type<T> projectedOntoNormalized(const Math::Vector<size, T>& other) const { \
         return Math::Vector<size, T>::projectedOntoNormalized(other);       \
+    }                                                                       \
+    constexpr Type<T> flipped() const {                                     \
+        return Math::Vector<size, T>::flipped();                            \
     }
 
 #define MAGNUM_VECTORn_OPERATOR_IMPLEMENTATION(size, Type)                  \