diff --git a/headers/vmath.hpp/vmath_mat_fun.hpp b/headers/vmath.hpp/vmath_mat_fun.hpp
index aa71d47..1039cb6 100644
--- a/headers/vmath.hpp/vmath_mat_fun.hpp
+++ b/headers/vmath.hpp/vmath_mat_fun.hpp
@@ -107,6 +107,18 @@ namespace vmath_hpp
         return zip(std::plus<>(), xs, ys);
     }
 
+    // operator+=
+
+    template < typename T, std::size_t Size >
+    constexpr mat<T, Size>& operator+=(mat<T, Size>& xs, T y) {
+        return (xs = xs + y);
+    }
+
+    template < typename T, std::size_t Size >
+    constexpr mat<T, Size>& operator+=(mat<T, Size>& xs, const mat<T, Size>& ys) {
+        return (xs = xs + ys);
+    }
+
     // operator-
 
     template < typename T, std::size_t Size >
@@ -124,6 +136,18 @@ namespace vmath_hpp
         return zip(std::minus<>(), xs, ys);
     }
 
+    // operator-=
+
+    template < typename T, std::size_t Size >
+    constexpr mat<T, Size>& operator-=(mat<T, Size>& xs, T y) {
+        return (xs = xs - y);
+    }
+
+    template < typename T, std::size_t Size >
+    constexpr mat<T, Size>& operator-=(mat<T, Size>& xs, const mat<T, Size>& ys) {
+        return (xs = xs - ys);
+    }
+
     // operator*
 
     template < typename T, std::size_t Size >
@@ -210,6 +234,23 @@ namespace vmath_hpp
             xs[3][0] * ys[0][3] + xs[3][1] * ys[1][3] + xs[3][2] * ys[2][3] + xs[3][3] * ys[3][3]};
     }
 
+    // operator*=
+
+    template < typename T, std::size_t Size >
+    constexpr mat<T, Size>& operator*=(mat<T, Size>& xs, T y) {
+        return (xs = xs * y);
+    }
+
+    template < typename T, std::size_t Size >
+    constexpr vec<T, Size>& operator*=(vec<T, Size>& xs, const mat<T, Size>& ys) {
+        return (xs = xs * ys);
+    }
+
+    template < typename T, std::size_t Size >
+    constexpr mat<T, Size>& operator*=(mat<T, Size>& xs, const mat<T, Size>& ys) {
+        return (xs = xs * ys);
+    }
+
     // operator/
 
     template < typename T, std::size_t Size >
@@ -227,6 +268,18 @@ namespace vmath_hpp
         return zip(std::divides<>(), xs, ys);
     }
 
+    // operator/=
+
+    template < typename T, std::size_t Size >
+    constexpr mat<T, Size>& operator/=(mat<T, Size>& xs, T y) {
+        return (xs = xs / y);
+    }
+
+    template < typename T, std::size_t Size >
+    constexpr mat<T, Size>& operator/=(mat<T, Size>& xs, const mat<T, Size>& ys) {
+        return (xs = xs / ys);
+    }
+
     // operator==
 
     template < typename T, std::size_t Size >
diff --git a/headers/vmath.hpp/vmath_vec_fun.hpp b/headers/vmath.hpp/vmath_vec_fun.hpp
index bc77b64..e5a17ac 100644
--- a/headers/vmath.hpp/vmath_vec_fun.hpp
+++ b/headers/vmath.hpp/vmath_vec_fun.hpp
@@ -107,6 +107,18 @@ namespace vmath_hpp
         return zip(std::plus<>(), xs, ys);
     }
 
+    // operator+=
+
+    template < typename T, std::size_t Size >
+    constexpr vec<T, Size>& operator+=(vec<T, Size>& xs, T y) {
+        return (xs = xs + y);
+    }
+
+    template < typename T, std::size_t Size >
+    constexpr vec<T, Size>& operator+=(vec<T, Size>& xs, const vec<T, Size>& ys) {
+        return (xs = xs + ys);
+    }
+
     // operator-
 
     template < typename T, std::size_t Size >
@@ -124,6 +136,18 @@ namespace vmath_hpp
         return zip(std::minus<>(), xs, ys);
     }
 
+    // operator-=
+
+    template < typename T, std::size_t Size >
+    constexpr vec<T, Size>& operator-=(vec<T, Size>& xs, T y) {
+        return (xs = xs - y);
+    }
+
+    template < typename T, std::size_t Size >
+    constexpr vec<T, Size>& operator-=(vec<T, Size>& xs, const vec<T, Size>& ys) {
+        return (xs = xs - ys);
+    }
+
     // operator*
 
     template < typename T, std::size_t Size >
@@ -141,6 +165,18 @@ namespace vmath_hpp
         return zip(std::multiplies<>(), xs, ys);
     }
 
+    // operator*=
+
+    template < typename T, std::size_t Size >
+    constexpr vec<T, Size>& operator*=(vec<T, Size>& xs, T y) {
+        return (xs = xs * y);
+    }
+
+    template < typename T, std::size_t Size >
+    constexpr vec<T, Size>& operator*=(vec<T, Size>& xs, const vec<T, Size>& ys) {
+        return (xs = xs * ys);
+    }
+
     // operator/
 
     template < typename T, std::size_t Size >
@@ -158,6 +194,18 @@ namespace vmath_hpp
         return zip(std::divides<>(), xs, ys);
     }
 
+    // operator/=
+
+    template < typename T, std::size_t Size >
+    constexpr vec<T, Size>& operator/=(vec<T, Size>& xs, T y) {
+        return (xs = xs / y);
+    }
+
+    template < typename T, std::size_t Size >
+    constexpr vec<T, Size>& operator/=(vec<T, Size>& xs, const vec<T, Size>& ys) {
+        return (xs = xs / ys);
+    }
+
     // operator==
 
     template < typename T, std::size_t Size >
diff --git a/untests/vmath_mat_fun_tests.cpp b/untests/vmath_mat_fun_tests.cpp
index a2d1f97..98e482b 100644
--- a/untests/vmath_mat_fun_tests.cpp
+++ b/untests/vmath_mat_fun_tests.cpp
@@ -158,6 +158,54 @@ TEST_CASE("vmath/mat_fun") {
         STATIC_REQUIRE(vec2i(1,2) * mat2i() == vec2i(1,2));
         STATIC_REQUIRE(vec3i(1,2,3) * mat3i() == vec3i(1,2,3));
         STATIC_REQUIRE(vec4i(1,2,3,4) * mat4i() == vec4i(1,2,3,4));
+
+        {
+            mat2i v{1,2,3,4};
+            REQUIRE(&v == &(v += 3));
+            REQUIRE(v == mat2i{4,5,6,7});
+            REQUIRE(&v == &(v += mat2i{1,2,3,4}));
+            REQUIRE(v == mat2i{5,7,9,11});
+        }
+        {
+            mat2i v{4,5,6,7};
+            REQUIRE(&v == &(v -= 3));
+            REQUIRE(v == mat2i{1,2,3,4});
+            REQUIRE(&v == &(v -= mat2i{2,4,6,8}));
+            REQUIRE(v == mat2i{-1,-2,-3,-4});
+        }
+        {
+            mat2i v{1,2,3,4};
+            REQUIRE(&v == &(v *= 3));
+            REQUIRE(v == mat2i{3,6,9,12});
+        }
+        {
+            mat2i v{6,18,36,60};
+            REQUIRE(&v == &(v /= 2));
+            REQUIRE(v == mat2i{3,9,18,30});
+            REQUIRE(&v == &(v /= mat2i{3,4,3,10}));
+            REQUIRE(v == mat2i{1,2,6,3});
+        }
+
+        {
+            vec4f v{0.f, 0.f, 0.f, 1.f};
+            REQUIRE(&v == &(v *= translate(1.f,2.f,3.f)));
+            REQUIRE(v == approx4(1.f,2.f,3.f,1.f));
+        }
+        {
+            vec3f v{1.f, 2.f, 3.f};
+            REQUIRE(&v == &(v *= mat3f(scale(2.f,3.f,4.f))));
+            REQUIRE(v == approx3(2.f,6.f,12.f));
+        }
+        {
+            mat4f v = translate(1.f, 2.f, 3.f);
+            REQUIRE(&v == &(v *= translate(1.f,2.f,3.f)));
+            REQUIRE(v == approx4x4(translate(2.f,4.f,6.f)));
+        }
+        {
+            mat3f v = mat3f(scale(1.f, 2.f, 3.f));
+            REQUIRE(&v == &(v *= mat3f(scale(2.f,3.f,4.f))));
+            REQUIRE(v == approx3x3(mat3f(scale(2.f,6.f,12.f))));
+        }
     }
 
     SECTION("Matrix Functions") {
diff --git a/untests/vmath_vec_fun_tests.cpp b/untests/vmath_vec_fun_tests.cpp
index c90660d..2994c6c 100644
--- a/untests/vmath_vec_fun_tests.cpp
+++ b/untests/vmath_vec_fun_tests.cpp
@@ -68,6 +68,35 @@ TEST_CASE("vmath/vec_fun") {
         STATIC_REQUIRE(vec2i(1,2) - vec2i(3,4) == vec2i(-2,-2));
         STATIC_REQUIRE(vec2i(1,2) * vec2i(3,4) == vec2i(3,8));
         STATIC_REQUIRE(vec2i(3,4) / vec2i(1,2) == vec2i(3,2));
+
+        {
+            vec2i v{1,2};
+            REQUIRE(&v == &(v += 3));
+            REQUIRE(v == vec2i{4,5});
+            REQUIRE(&v == &(v += vec2i{1,2}));
+            REQUIRE(v == vec2i{5,7});
+        }
+        {
+            vec2i v{4,5};
+            REQUIRE(&v == &(v -= 3));
+            REQUIRE(v == vec2i{1,2});
+            REQUIRE(&v == &(v -= vec2i{2,4}));
+            REQUIRE(v == vec2i{-1,-2});
+        }
+        {
+            vec2i v{1,2};
+            REQUIRE(&v == &(v *= 3));
+            REQUIRE(v == vec2i{3,6});
+            REQUIRE(&v == &(v *= vec2i{2,3}));
+            REQUIRE(v == vec2i{6,18});
+        }
+        {
+            vec2i v{6,18};
+            REQUIRE(&v == &(v /= 2));
+            REQUIRE(v == vec2i{3,9});
+            REQUIRE(&v == &(v /= vec2i{3,4}));
+            REQUIRE(v == vec2i{1,2});
+        }
     }
 
     SECTION("Angle and Trigonometry Functions") {