diff --git a/CMakeLists.txt b/CMakeLists.txt
index 41d9694..4dab19c 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -1,6 +1,6 @@
 cmake_minimum_required(VERSION 3.20)
 include(cmake/color.cmake)
-set(BLT_VERSION 2.1.9)
+set(BLT_VERSION 2.1.10)
 
 set(BLT_TARGET BLT)
 
diff --git a/include/blt/math/vectors.h b/include/blt/math/vectors.h
index 60d1a8a..c4bd9c9 100644
--- a/include/blt/math/vectors.h
+++ b/include/blt/math/vectors.h
@@ -297,107 +297,107 @@ namespace blt
             }
     };
     
-    template<typename T, blt::u32 size>
-    inline constexpr vec<T, size> operator+(const vec<T, size>& left, const vec<T, size>& right)
+    template<typename T, typename G, blt::u32 size, typename R = decltype(std::declval<T>() + std::declval<G>())>
+    inline constexpr vec<R, size> operator+(const vec<T, size>& left, const vec<G, size>& right)
     {
-        vec<T, size> initializer{};
+        vec<R, size> initializer{};
         for (blt::u32 i = 0; i < size; i++)
-            initializer[i] = left[i] + right[i];
+            initializer[i] = static_cast<R>(left[i]) + static_cast<R>(right[i]);
         return initializer;
     }
     
-    template<typename T, blt::u32 size>
-    inline constexpr vec<T, size> operator-(const vec<T, size>& left, const vec<T, size>& right)
+    template<typename T, typename G, blt::u32 size, typename R = decltype(std::declval<T>() - std::declval<G>())>
+    inline constexpr vec<R, size> operator-(const vec<T, size>& left, const vec<G, size>& right)
     {
-        vec<T, size> initializer{};
+        vec<R, size> initializer{};
         for (blt::u32 i = 0; i < size; i++)
-            initializer[i] = left[i] - right[i];
+            initializer[i] = static_cast<R>(left[i]) - static_cast<R>(right[i]);
         return initializer;
     }
     
-    template<typename T, typename G, blt::u32 size>
-    inline constexpr vec<T, size> operator+(const vec<T, size>& left, G right)
+    template<typename T, typename G, blt::u32 size, typename R = decltype(std::declval<T>() + std::declval<G>())>
+    inline constexpr vec<R, size> operator+(const vec<T, size>& left, G right)
     {
-        vec<T, size> initializer{};
+        vec<R, size> initializer{};
         for (blt::u32 i = 0; i < size; i++)
-            initializer[i] = left[i] + static_cast<T>(right);
+            initializer[i] = static_cast<R>(left[i]) + static_cast<R>(right);
         return initializer;
     }
     
-    template<typename T, typename G, blt::u32 size>
-    inline constexpr vec<T, size> operator-(const vec<T, size>& left, G right)
+    template<typename T, typename G, blt::u32 size, typename R = decltype(std::declval<T>() - std::declval<G>())>
+    inline constexpr vec<R, size> operator-(const vec<T, size>& left, G right)
     {
-        vec<T, size> initializer{};
+        vec<R, size> initializer{};
         for (blt::u32 i = 0; i < size; i++)
-            initializer[i] = left[i] + static_cast<T>(right);
+            initializer[i] = static_cast<R>(left[i]) - static_cast<R>(right);
         return initializer;
     }
     
-    template<typename T, typename G, blt::u32 size>
-    inline constexpr vec<T, size> operator+(G left, const vec<T, size>& right)
+    template<typename T, typename G, blt::u32 size, typename R = decltype(std::declval<T>() + std::declval<G>())>
+    inline constexpr vec<R, size> operator+(G left, const vec<T, size>& right)
     {
-        vec<T, size> initializer{};
+        vec<R, size> initializer{};
         for (blt::u32 i = 0; i < size; i++)
-            initializer[i] = static_cast<T>(left) + right[i];
+            initializer[i] = static_cast<R>(left) + static_cast<R>(right[i]);
         return initializer;
     }
     
-    template<typename T, typename G, blt::u32 size>
-    inline constexpr vec<T, size> operator-(G left, const vec<T, size>& right)
+    template<typename T, typename G, blt::u32 size, typename R = decltype(std::declval<T>() - std::declval<G>())>
+    inline constexpr vec<R, size> operator-(G left, const vec<T, size>& right)
     {
-        vec<T, size> initializer{};
+        vec<R, size> initializer{};
         for (blt::u32 i = 0; i < size; i++)
             initializer[i] = static_cast<T>(left) - right[i];
         return initializer;
     }
     
-    template<typename T, blt::u32 size>
-    inline constexpr vec<T, size> operator*(const vec<T, size>& left, const vec<T, size>& right)
+    template<typename T, typename G, blt::u32 size, typename R = decltype(std::declval<T>() * std::declval<G>())>
+    inline constexpr vec<R, size> operator*(const vec<T, size>& left, const vec<G, size>& right)
     {
-        vec<T, size> initializer{};
+        vec<R, size> initializer{};
         for (blt::u32 i = 0; i < size; i++)
-            initializer[i] = left[i] * right[i];
+            initializer[i] = static_cast<R>(left[i]) * static_cast<R>(right[i]);
+        return initializer;
+    }
+    
+    template<typename T, typename G, blt::u32 size, typename R = decltype(std::declval<T>() * std::declval<G>())>
+    inline constexpr vec<R, size> operator*(const vec<T, size>& left, G right)
+    {
+        vec<R, size> initializer{};
+        for (blt::u32 i = 0; i < size; i++)
+            initializer[i] = static_cast<R>(left[i]) * static_cast<R>(right);
+        return initializer;
+    }
+    
+    template<typename T, typename G, blt::u32 size, typename R = decltype(std::declval<T>() * std::declval<G>())>
+    inline constexpr vec<R, size> operator*(G left, const vec<T, size>& right)
+    {
+        vec<R, size> initializer{};
+        for (blt::u32 i = 0; i < size; i++)
+            initializer[i] = static_cast<R>(left) * static_cast<R>(right[i]);
+        return initializer;
+    }
+    
+    template<typename T, typename G, blt::u32 size, typename R = decltype(std::declval<T>() / std::declval<G>())>
+    inline constexpr vec<R, size> operator/(const vec<T, size>& left, G right)
+    {
+        vec<R, size> initializer{};
+        for (blt::u32 i = 0; i < size; i++)
+            initializer[i] = static_cast<R>(left[i]) / static_cast<R>(right);
+        return initializer;
+    }
+    
+    template<typename T, typename G, blt::u32 size, typename R = decltype(std::declval<T>() / std::declval<G>())>
+    inline constexpr vec<R, size> operator/(G left, const vec<T, size>& right)
+    {
+        vec<R, size> initializer{};
+        for (blt::u32 i = 0; i < size; i++)
+            initializer[i] = static_cast<R>(left) / static_cast<R>(right[i]);
         return initializer;
     }
     
     template<typename T, typename G, blt::u32 size>
-    inline constexpr vec<T, size> operator*(const vec<T, size>& left, G right)
-    {
-        vec<T, size> initializer{};
-        for (blt::u32 i = 0; i < size; i++)
-            initializer[i] = left[i] * static_cast<T>(right);
-        return initializer;
-    }
-    
-    template<typename T, typename G, blt::u32 size>
-    inline constexpr vec<T, size> operator*(G left, const vec<T, size>& right)
-    {
-        vec<T, size> initializer{};
-        for (blt::u32 i = 0; i < size; i++)
-            initializer[i] = static_cast<T>(left) * right[i];
-        return initializer;
-    }
-    
-    template<typename T, typename G, blt::u32 size>
-    inline constexpr vec<T, size> operator/(const vec<T, size>& left, G right)
-    {
-        vec<T, size> initializer{};
-        for (blt::u32 i = 0; i < size; i++)
-            initializer[i] = left[i] / static_cast<T>(right);
-        return initializer;
-    }
-    
-    template<typename T, typename G, blt::u32 size>
-    inline constexpr vec<T, size> operator/(G left, const vec<T, size>& right)
-    {
-        vec<T, size> initializer{};
-        for (blt::u32 i = 0; i < size; i++)
-            initializer[i] = static_cast<T>(left) / right[i];
-        return initializer;
-    }
-    
-    template<typename T, blt::u32 size>
-    inline constexpr bool operator==(const vec<T, size>& left, const vec<T, size>& right)
+    inline constexpr bool operator==(const vec<T, size>& left, const vec<G, size>& right)
     {
         constexpr double E = std::numeric_limits<T>::epsilon();
         for (blt::u32 i = 0; i < size; i++)
@@ -409,19 +409,19 @@ namespace blt
         return true;
     }
     
-    template<typename T, blt::u32 size>
-    inline constexpr bool operator!=(const vec<T, size>& left, const vec<T, size>& right)
+    template<typename T, typename G, blt::u32 size>
+    inline constexpr bool operator!=(const vec<T, size>& left, const vec<G, size>& right)
     {
         return !(left == right);
     }
     
-    template<typename T, blt::u32 size>
-    inline constexpr bool operator&&(const vec<T, size>& left, const vec<T, size>& right)
+    template<typename Ret, typename T, blt::u32 size>
+    inline constexpr vec<Ret, size> vec_cast(const vec<T, size>& conv)
     {
+        vec<Ret, size> initializer{};
         for (blt::u32 i = 0; i < size; i++)
-            if (!f_equal(left[i], right[i]))
-                return false;
-        return true;
+            initializer[i] = static_cast<Ret>(conv[i]);
+        return initializer;
     }
     
     using vec2f = vec<float, 2>;
diff --git a/include/blt/meta/codegen.h b/include/blt/meta/codegen.h
new file mode 100644
index 0000000..ee6616c
--- /dev/null
+++ b/include/blt/meta/codegen.h
@@ -0,0 +1,55 @@
+#pragma once
+/*
+ *  Copyright (C) 2024  Brett Terpstra
+ *
+ *  This program is free software: you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation, either version 3 of the License, or
+ *  (at your option) any later version.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+#ifndef BLT_META_CODEGEN_H
+#define BLT_META_CODEGEN_H
+
+namespace blt
+{
+#define BLT_CONST_LVALUE_GETTER(TYPE, NAME) const TYPE& get_##NAME() const { return NAME; }
+#define BLT_LVALUE_GETTER(TYPE, NAME) TYPE& get_##NAME() { return NAME; }
+#define BLT_PRVALUE_GETTER(TYPE, NAME) TYPE get_##NAME() const { return NAME; }
+
+#define BLT_GLVALUE_GETTER(TYPE, NAME)                                  \
+    BLT_CONST_LVALUE_GETTER(TYPE, NAME)                                 \
+    BLT_LVALUE_GETTER(TYPE, NAME)
+
+#define BLT_PRVALUE_SETTER(TYPE, NAME)                                  \
+    auto& set_##NAME(TYPE new_##NAME)                                   \
+    {                                                                   \
+        NAME = new_##NAME;                                              \
+        return *this;                                                   \
+    }
+
+#define BLT_PRVALUE_MOVE_SETTER(TYPE, NAME)                             \
+    auto& set_##NAME(TYPE new_##NAME)                                   \
+    {                                                                   \
+        NAME = std::move(new_##NAME);                                   \
+        return *this;                                                   \
+    }
+
+#define BLT_LVALUE_SETTER(TYPE, NAME)                                   \
+    auto& set_##NAME(const TYPE& new_##NAME)                            \
+    {                                                                   \
+        NAME = new_##NAME;                                              \
+        return *this;                                                   \
+    }
+    
+}
+
+#endif //BLT_META_CODEGEN_H