diff --git a/include/Orange/Core/Array.h b/include/Orange/Core/Array.h
index 7428b7e..e8f3995 100644
--- a/include/Orange/Core/Array.h
+++ b/include/Orange/Core/Array.h
@@ -1,182 +1,54 @@
 #pragma once
 
+#include <Orange/Core/Types.h>
 #include <Orange/Core/Traits.h>
-#include <Orange/Core/AlignedStorage.h>
-#include <Orange/Core/Span.h>
 
 namespace orange
 {
-    template <typename T, size_t N>
-    class SmallArray
+    template <typename T, size_t Size>
+    struct Array
     {
-    public:
+        constexpr Array()
+            : m_data{ } {}
 
-        SmallArray() {}
-        SmallArray(size_t size) { Resize(size); }
-        SmallArray(Span<T> span)
+        constexpr Array(const T components[Size])
         {
-            Reserve(span.size);
-            for (const auto& val : span)
-                PushBack(val);
+            Copy(&components[0], &components[Size], m_data.begin());
         }
 
-        SmallArray             (const SmallArray&) = delete;
-        SmallArray& operator = (const SmallArray&) = delete;
-
-        ~SmallArray()
+        template <typename... Args>
+        constexpr Array(const Args&... args)
+            : m_data {{ args... }}
         {
-            for (size_t i = 0; i < m_size; i++)
-                Ptr(i)->~T();
-
-            if (m_capacity > N)
-                delete[] u.m_ptr;
+            static_assert(sizeof...(Args) == Size);
         }
 
-        template <typename J>
-        bool operator == (const Span<J>& x)
+        constexpr Array(const Array& other) = default;
+
+        constexpr       T& operator[](size_t index)       { return m_data[index]; }
+        constexpr const T& operator[](size_t index) const { return m_data[index]; }
+
+
+        constexpr const T* begin() const { return &m_data[0]; }
+        constexpr       T* begin()       { return &m_data[0]; }
+        constexpr const T* end()   const { return &m_data[Size]; }
+        constexpr       T* end()         { return &m_data[Size]; }
+
+
+        constexpr bool operator==(const Array& other) const
         {
-            return Span<T>(*this) == x;
+            return Equal(begin(), end(), other.begin());
         }
 
-        bool operator == (const char *x)
+        constexpr bool operator!=(const Array& other) const
         {
-            return Span<T>(*this) == StringView(x);
+            return !operator==(other);
         }
 
-        void Reserve(size_t n)
-        {
-            n = PickCapacity(n);
-
-            if (n <= m_capacity)
-                return;
-
-            Storage* data = new Storage[n];
-
-            for (size_t i = 0; i < m_size; i++)
-            {
-                new (&data[i]) T(Move(*Ptr(i)));
-                Ptr(i)->~T();
-            }
-
-            if (m_capacity > N)
-                delete[] u.m_ptr;
-
-            m_capacity = n;
-            u.m_ptr = data;
-        }
-
-        size_t Size() const   { return m_size; }
-
-        const T* Data() const { return Ptr(0); }
-              T* Data()       { return Ptr(0); }
-
-        void Resize(size_t n)
-        {
-            Reserve(n);
-
-            for (size_t i = n; i < m_size; i++)
-                Ptr(i)->~T();
-
-            for (size_t i = m_size; i < n; i++)
-                new (Ptr(i)) T();
-
-            m_size = n;
-        }
-
-        void PushBack(const T& object)
-        {
-            Reserve(m_size + 1);
-            new (Ptr(m_size++)) T(object);
-        }
-
-        void PushBack(T&& object)
-        {
-            Reserve(m_size + 1);
-            new (Ptr(m_size++)) T(Move(object));
-        }
-
-        template<typename... Args>
-        void EmplaceBack(Args... args)
-        {
-            Reserve(m_size + 1);
-            new (Ptr(m_size++)) T(Forward<Args>(args)...);
-        }
-
-        void Erase(size_t idx)
-        {
-            Ptr(idx)->~T();
-
-            for (size_t i = idx; i < m_size - 1; i++)
-            {
-                new (Ptr(i)) T(Move(*Ptr(i + 1)));
-                Ptr(i + 1)->~T();
-            }
-        }
-
-        void PopBack()
-        {
-            Ptr(--m_size)->~T();
-        }
-
-        bool Empty() const
-        {
-            return Size() == 0;
-        }
-
-              T& operator [] (size_t idx)       { return *Ptr(idx); }
-        const T& operator [] (size_t idx) const { return *Ptr(idx); }
-
-              T* begin()       { return Ptr(0); }
-        const T* begin() const { return Ptr(0); }
-
-              T* end()       { return Ptr(m_size); }
-        const T* end() const { return Ptr(m_size); }
-
-              T& front()       { return *Ptr(0); }
-        const T& front() const { return *Ptr(0); }
-
-              T& back()       { return *Ptr(m_size - 1); }
-        const T& back() const { return *Ptr(m_size - 1); }
-
-        operator Span<T>() { return Span<T>(*this); }
-
     private:
-        using Storage = AlignedStorage<sizeof(T), alignof(T)>;
 
-        size_t m_capacity = N;
-        size_t m_size     = 0;
-
-        union
-        {
-            Storage* m_ptr;
-            Storage  m_data[sizeof(T) * N];
-        } u;
-
-        size_t PickCapacity(size_t n) {
-            size_t capacity = m_capacity;
-
-            while (capacity < n)
-                capacity = (capacity * 2) + 2;
-
-            return capacity;
-        }
-
-        T* Ptr(size_t idx) {
-            return m_capacity == N
-            ? reinterpret_cast<T*>(&u.m_data[idx])
-            : reinterpret_cast<T*>(&u.m_ptr[idx]);
-        }
-
-        const T* Ptr(size_t idx) const
-        {
-            return m_capacity == N
-            ? reinterpret_cast<const T*>(&u.m_data[idx])
-            : reinterpret_cast<const T*>(&u.m_ptr[idx]);
-        }
+        T m_data[Size];
 
     };
 
-    template <typename T>
-    using Array = SmallArray<T, sizeof(T) / sizeof(void*)>;
-
 }
diff --git a/include/Orange/Core/Parse.h b/include/Orange/Core/Parse.h
index 5064fca..1a3ed5a 100644
--- a/include/Orange/Core/Parse.h
+++ b/include/Orange/Core/Parse.h
@@ -1,6 +1,6 @@
 #pragma once
 
-#include "Orange/Core/Array.h"
+#include "Orange/Core/Vector.h"
 #include <Orange/Core/Result.h>
 #include <Orange/Core/Span.h>
 
@@ -68,7 +68,7 @@ namespace orange::stream
         return Consume(first, end, " \t");
     }
 
-    template <typename OutArray = SmallArray<char, 1>>
+    template <typename OutArray = SmallVector<char, 1>>
     size_t ReadOrAdvance(const char*& first, const char* end, StringView delims, size_t advancement = 0, OutArray* array = nullptr)
     {
         size_t count = 0;
@@ -88,7 +88,7 @@ namespace orange::stream
         return count;
     }
 
-    template <typename OutArray = SmallArray<char, 1>>
+    template <typename OutArray = SmallVector<char, 1>>
     size_t ReadString(const char*& first, const char* end, StringView delims, OutArray& array)
     {
         return ReadOrAdvance(first, end, delims, 0, &array);
diff --git a/include/Orange/Core/Traits.h b/include/Orange/Core/Traits.h
index 494771a..d154ba3 100644
--- a/include/Orange/Core/Traits.h
+++ b/include/Orange/Core/Traits.h
@@ -60,4 +60,120 @@ namespace orange
     {
         return Min( Max( val, minVal ), maxVal );
     }
+
+    // Transformations
+
+    template <typename InputIt, typename OutputIt, typename UnaryOperation>
+    OutputIt Transform(InputIt inFirst,   InputIt inLast,
+                       OutputIt outFirst, UnaryOperation unaryOp)
+    {
+        while (inFirst != inLast)
+            *outFirst++ = unaryOp(*inFirst++);
+        return outFirst;
+    }
+
+    template<typename InputIt1, typename InputIt2, typename OutputIt, typename BinaryOperation>
+    OutputIt Transform(InputIt1 first1, InputIt1 last1, InputIt2 first2, 
+                       OutputIt outFirst, BinaryOperation binOp)
+    {
+        while (first1 != last1)
+            *outFirst++ = binOp(*first1++, *first2++);
+        return outFirst;
+    }
+
+    template <typename T, typename InputIt, typename UnaryOperation>
+    T TransformResult(InputIt first, InputIt last, UnaryOperation op)
+    {
+        T result;
+        Transform(first, last, result.begin(), op);
+        return result;
+    }
+
+    template <typename T, typename InputIt1, typename InputIt2, typename BinaryOperation>
+    T TransformResult(InputIt1 first1, InputIt1 last1, InputIt2 first2, BinaryOperation op)
+    {
+        T result;
+        Transform(first1, last1, first2, result.begin(), op);
+        return result;
+    }
+
+    template <typename InputIt, typename T>
+    constexpr T Accumulate(InputIt first, InputIt last, T init)
+    {
+        for (; first != last; ++first)
+            init = Move(init) + *first;
+        return init;
+    }
+
+    template <typename InputIt, typename T, typename BinaryOperation>
+    constexpr T Accumulate(InputIt first, InputIt last, T init, BinaryOperation op)
+    {
+        for (; first != last; ++first)
+            init = op(Move(init), *first);
+        return init;
+    }
+
+    template <typename InputIt1, typename InputIt2>
+    bool Equal(InputIt1 first1, InputIt1 last1,  InputIt2 first2)
+    {
+        for (; first1 != last1; ++first1, ++first2)
+        {
+            if (!(*first1 == *first2))
+                return false;
+        }
+        return true;
+    }
+
+    template <typename InputIt1, typename InputIt2, typename BinaryPredicate>
+    bool Equal(InputIt1 first1, InputIt1 last1, InputIt2 first2, BinaryPredicate p)
+    {
+        for (; first1 != last1; ++first1, ++first2)
+        {
+            if (!p(*first1, *first2))
+                return false;
+        }
+        return true;
+    }
+
+    template <typename InputIt, typename OutputIt>
+    OutputIt Copy(InputIt first, InputIt last, OutputIt d_first)
+    {
+        for (; first != last; (void)++first, (void)++d_first)
+            *d_first = *first;
+        return d_first;
+    }
+
+    template <typename InputIt, typename OutputIt, typename UnaryPredicate>
+    OutputIt CopyIf(InputIt first, InputIt last, 
+                    OutputIt d_first, UnaryPredicate pred)
+    {
+        for (; first != last; ++first)
+        {
+            if (pred(*first))
+            {
+                *d_first = *first;
+                ++d_first;
+            }
+        }
+        return d_first;
+    }
+
+    template <typename ForwardIt, typename T>
+    void Fill(ForwardIt first, ForwardIt last, const T& value)
+    {
+        for (; first != last; ++first)
+            *first = value;
+    }
+
+    // Math ops
+    namespace math
+    {
+        template <typename T> T Negate(const T& x) { return -x; }
+
+        template <typename T> T Add       (const T& x, const T& y) { return x + y; }
+        template <typename T> T Subtract  (const T& x, const T& y) { return x - y; }
+        template <typename T> T Multiply  (const T& x, const T& y) { return x * y; }
+        template <typename T> T Divide    (const T& x, const T& y) { return x / y; }
+        template <typename T> T Modulo    (const T& x, const T& y) { return x % y; }
+    }
 }
diff --git a/include/Orange/Core/Vector.h b/include/Orange/Core/Vector.h
new file mode 100644
index 0000000..775fe22
--- /dev/null
+++ b/include/Orange/Core/Vector.h
@@ -0,0 +1,182 @@
+#pragma once
+
+#include <Orange/Core/Traits.h>
+#include <Orange/Core/AlignedStorage.h>
+#include <Orange/Core/Span.h>
+
+namespace orange
+{
+    template <typename T, size_t N>
+    class SmallVector
+    {
+    public:
+
+        SmallVector() {}
+        SmallVector(size_t size) { Resize(size); }
+        SmallVector(Span<T> span)
+        {
+            Reserve(span.size);
+            for (const auto& val : span)
+                PushBack(val);
+        }
+
+        SmallVector             (const SmallVector&) = delete;
+        SmallVector& operator = (const SmallVector&) = delete;
+
+        ~SmallVector()
+        {
+            for (size_t i = 0; i < m_size; i++)
+                Ptr(i)->~T();
+
+            if (m_capacity > N)
+                delete[] u.m_ptr;
+        }
+
+        template <typename J>
+        bool operator == (const Span<J>& x)
+        {
+            return Span<T>(*this) == x;
+        }
+
+        bool operator == (const char *x)
+        {
+            return Span<T>(*this) == StringView(x);
+        }
+
+        void Reserve(size_t n)
+        {
+            n = PickCapacity(n);
+
+            if (n <= m_capacity)
+                return;
+
+            Storage* data = new Storage[n];
+
+            for (size_t i = 0; i < m_size; i++)
+            {
+                new (&data[i]) T(Move(*Ptr(i)));
+                Ptr(i)->~T();
+            }
+
+            if (m_capacity > N)
+                delete[] u.m_ptr;
+
+            m_capacity = n;
+            u.m_ptr = data;
+        }
+
+        size_t Size() const   { return m_size; }
+
+        const T* Data() const { return Ptr(0); }
+              T* Data()       { return Ptr(0); }
+
+        void Resize(size_t n)
+        {
+            Reserve(n);
+
+            for (size_t i = n; i < m_size; i++)
+                Ptr(i)->~T();
+
+            for (size_t i = m_size; i < n; i++)
+                new (Ptr(i)) T();
+
+            m_size = n;
+        }
+
+        void PushBack(const T& object)
+        {
+            Reserve(m_size + 1);
+            new (Ptr(m_size++)) T(object);
+        }
+
+        void PushBack(T&& object)
+        {
+            Reserve(m_size + 1);
+            new (Ptr(m_size++)) T(Move(object));
+        }
+
+        template<typename... Args>
+        void EmplaceBack(Args... args)
+        {
+            Reserve(m_size + 1);
+            new (Ptr(m_size++)) T(Forward<Args>(args)...);
+        }
+
+        void Erase(size_t idx)
+        {
+            Ptr(idx)->~T();
+
+            for (size_t i = idx; i < m_size - 1; i++)
+            {
+                new (Ptr(i)) T(Move(*Ptr(i + 1)));
+                Ptr(i + 1)->~T();
+            }
+        }
+
+        void PopBack()
+        {
+            Ptr(--m_size)->~T();
+        }
+
+        bool Empty() const
+        {
+            return Size() == 0;
+        }
+
+              T& operator [] (size_t idx)       { return *Ptr(idx); }
+        const T& operator [] (size_t idx) const { return *Ptr(idx); }
+
+              T* begin()       { return Ptr(0); }
+        const T* begin() const { return Ptr(0); }
+
+              T* end()       { return Ptr(m_size); }
+        const T* end() const { return Ptr(m_size); }
+
+              T& front()       { return *Ptr(0); }
+        const T& front() const { return *Ptr(0); }
+
+              T& back()       { return *Ptr(m_size - 1); }
+        const T& back() const { return *Ptr(m_size - 1); }
+
+        operator Span<T>() { return Span<T>(*this); }
+
+    private:
+        using Storage = AlignedStorage<sizeof(T), alignof(T)>;
+
+        size_t m_capacity = N;
+        size_t m_size     = 0;
+
+        union
+        {
+            Storage* m_ptr;
+            Storage  m_data[sizeof(T) * N];
+        } u;
+
+        size_t PickCapacity(size_t n) {
+            size_t capacity = m_capacity;
+
+            while (capacity < n)
+                capacity = (capacity * 2) + 2;
+
+            return capacity;
+        }
+
+        T* Ptr(size_t idx) {
+            return m_capacity == N
+            ? reinterpret_cast<T*>(&u.m_data[idx])
+            : reinterpret_cast<T*>(&u.m_ptr[idx]);
+        }
+
+        const T* Ptr(size_t idx) const
+        {
+            return m_capacity == N
+            ? reinterpret_cast<const T*>(&u.m_data[idx])
+            : reinterpret_cast<const T*>(&u.m_ptr[idx]);
+        }
+
+    };
+
+    template <typename T>
+    using Vector = SmallVector<T, sizeof(T) / sizeof(void*)>;
+
+}
diff --git a/include/Orange/Math/Basic.h b/include/Orange/Math/Basic.h
new file mode 100644
index 0000000..301c23e
--- /dev/null
+++ b/include/Orange/Math/Basic.h
@@ -0,0 +1,30 @@
+#pragma once
+
+#include <math.h>
+
+namespace orange
+{
+    template <typename T>
+    struct DefaultLengthTypeResolver
+    {
+        using LengthType = float;
+    };
+
+    template <>
+    struct DefaultLengthTypeResolver<double>
+    {
+        using LengthType = double;
+    };
+
+    template <>
+    struct DefaultLengthTypeResolver<long double>
+    {
+        using LengthType = long double;
+    };
+
+    template <typename T, typename J = DefaultLengthTypeResolver<T>::LengthType>
+    constexpr J rcp(const T& a)
+    {
+        return static_cast<J>(1) / static_cast<J>(a);
+    }
+}
diff --git a/include/Orange/Math/Vector.h b/include/Orange/Math/Vector.h
new file mode 100644
index 0000000..7174e62
--- /dev/null
+++ b/include/Orange/Math/Vector.h
@@ -0,0 +1,275 @@
+#pragma once
+
+#include <Orange/Core/Types.h>
+#include <Orange/Core/Traits.h>
+#include <Orange/Core/Array.h>
+
+#include <Orange/Math/Basic.h>
+
+namespace orange
+{
+    template <typename T, size_t Size>
+    struct Vec
+    {
+        using DefaultLengthType = DefaultLengthTypeResolver<T>::LengthType;
+        using DefaultLengthVec  = Vec<DefaultLengthType, Size>;
+
+        constexpr Vec()
+            : data{ } {}
+
+        constexpr explicit Vec(T splat)
+        {
+            Fill(data.begin(), data.end(), splat);
+        }
+
+        constexpr Vec(const T components[Size])
+        {
+            Copy(&components[0], &components[Size], data.begin());
+        }
+
+        template <typename... Args>
+        constexpr Vec(const Args&... args)
+            : data {{ args... }}
+        {
+            static_assert(sizeof...(Args) == Size);
+        }
+
+        constexpr Vec(const Vec& other) = default;
+
+
+        constexpr       T& operator[](size_t index)       { return data[index]; }
+        constexpr const T& operator[](size_t index) const { return data[index]; }
+
+
+        constexpr const T* begin() const { return data.begin(); }
+        constexpr       T* begin()       { return data.begin(); }
+        constexpr const T* end()   const { return data.end();   }
+        constexpr       T* end()         { return data.end();   }
+
+
+        constexpr bool operator==(const Vec& other) const
+        {
+            return Equal(begin(), end(), other.begin());
+        }
+
+        constexpr bool operator!=(const Vec& other) const
+        {
+            return !operator==(other);
+        }
+    
+
+        template <typename UnaryOperation>
+        constexpr Vec TransformResult(UnaryOperation op) const
+        {
+            return TransformResult<Vec>(begin(), end(), op);
+        }
+        
+        template <typename BinaryOperation>
+        constexpr Vec TransformResult(const T *other, BinaryOperation op) const
+        {
+            return TransformResult<Vec>(begin(), end(), other, op);
+        }
+
+        template <typename BinaryOperation>
+        constexpr Vec TransformResult(const Vec& other, BinaryOperation op) const
+        {
+            return TransformResult(other.begin(), op);
+        }
+
+        template <typename UnaryOperation>
+        constexpr Vec& TransformInPlace(UnaryOperation op)
+        {
+            Transform(begin(), end(), begin(), op);
+            return *this;
+        }
+        
+        template <typename BinaryOperation>
+        constexpr Vec& TransformInPlace(const T *other, BinaryOperation op)
+        {
+            Transform(begin(), end(), other, begin(), op);
+            return *this;
+        }
+
+        template <typename BinaryOperation>
+        constexpr Vec& TransformInPlace(const Vec& other, BinaryOperation op)
+        {
+            return TransformInPlace(other.begin(), op);
+        }
+
+
+        constexpr Vec operator-() const
+        {
+            return TransformResult(math::Negate);
+        }
+    
+
+        constexpr Vec operator+(const Vec& other) const
+        {
+            return TransformResult(other, math::Add);
+        }
+
+        constexpr Vec operator-(const Vec& other) const
+        {
+            return TransformResult(other, math::Subtract);
+        }
+
+        constexpr Vec operator*(const Vec& other) const
+        {
+            return TransformResult(other, math::Multiply);
+        }
+
+        constexpr Vec operator*(const T& scalar) const
+        {
+            return TransformResult([scalar](T value) { return value * scalar; });
+        }
+
+        constexpr Vec operator/(const Vec& other) const
+        {
+            return TransformResult(other, math::Divide);
+        }
+
+        constexpr Vec operator/(const T& scalar) const
+        {
+            return TransformResult([scalar](T value) { return value / scalar; });
+        }
+
+        constexpr Vec operator%(const Vec& other) const
+        {
+            return TransformResult(other, math::Modulo);
+        }
+
+        constexpr Vec operator%(const T& scalar) const
+        {
+            return TransformResult([scalar](T value) { return value % scalar; });
+        }
+
+
+        constexpr Vec& operator+=(const Vec& other)
+        {
+            return TransformInPlace(math::Add);
+        }
+
+        constexpr Vec& operator-=(const Vec& other)
+        {
+            return TransformInPlace(math::Subtract);
+        }
+
+        constexpr Vec& operator*=(const Vec& other)
+        {
+            return TransformInPlace(math::Multiply);
+        }
+
+        constexpr Vec& operator*=(const T& scalar)
+        {
+            return TransformInPlace([scalar](T value) { return value * scalar; });
+        }
+
+        constexpr Vec& operator/=(const Vec& other)
+        {
+            return TransformInPlace(math::Divide);
+        }
+
+        constexpr Vec& operator/=(const T& scalar)
+        {
+            return TransformInPlace([scalar](T value) { return value / scalar; });
+        }
+
+        constexpr Vec& operator%=(const Vec& other)
+        {
+            return TransformInPlace(math::Modulo);
+        }
+
+        constexpr Vec& operator%=(const T& scalar)
+        {
+            return TransformInPlace([scalar](T value) { return value % scalar; });
+        }
+
+    
+        static constexpr Vec Zero     = Vec{ T{ 0 } };
+        static constexpr Vec Identity = Vec{ T{ 1 } };
+
+
+        // Align to 16 if the size is a multiple of 4 and T is 4 bytes in size.
+        // to take advantage of aligned load/stores.
+        static constexpr size_t Alignment =
+            (Size % 4zu == 0 && sizeof(T) == 4zu)
+                ? Max<size_t>(16zu, alignof(T))
+                : alignof(T);
+
+        alignas(Alignment) Array<T, Size> data;
+
+    };
+
+    template <typename T, size_t Size>
+    constexpr Vec<T, Size> operator*(T scalar, const Vec<T, Size>& Vec)
+    {
+        return Vec.TransformResult([scalar](T value) { return scalar * value; });
+    }
+
+    template <typename T, size_t Size>
+    constexpr Vec<T, Size> operator/(T scalar, const Vec<T, Size>& Vec)
+    {
+        return Vec.TransformResult([scalar](T value) { return scalar / value; });
+    }
+
+    template <typename T, size_t Size>
+    constexpr Vec<T, Size> operator%(T scalar, const Vec<T, Size>& Vec)
+    {
+        return Vec.TransformResult([scalar](T value) { return scalar % value; });
+    }
+
+
+    template <typename T, size_t Size>
+    constexpr T accumulate(const Vec<T, Size>& a, T init = T{})
+    {
+        return Accumulate(a.begin(), a.end(), init);
+    }
+
+    template <typename T, size_t Size>
+    constexpr T dot(const Vec<T, Size>& a, const Vec<T, Size>& b)
+    {
+        return accumulate(a * b);
+    }
+
+    template <typename T, size_t Size>
+    constexpr T lengthSqr(const Vec<T, Size>& a)
+    {
+        return dot(a, a);
+    }
+
+    template <typename T, size_t Size, typename J = Vec<T, Size>::DefaultLengthType>
+    constexpr J length(const Vec<T, Size>& a)
+    {
+        sqrtf(J{ lengthSqr(a) });
+    }
+
+    template <typename T, size_t Size, typename J = Vec<T, Size>::DefaultLengthType>
+    constexpr Vec<J, Size> normalize(const Vec<T, Size>& a)
+    {
+        return a * J{ rcp( length<T, Size>(a) ) };
+    }
+
+    template <typename T, size_t Size, typename J = Vec<T, Size>::DefaultLengthType>
+    constexpr Vec<J, Size> rcp(const Vec<T, Size>& a)
+    {
+        return TransformResult<Vec<J, Size>>(a.begin(), a.end(), [](T value){ return rcp<T, J>(value); });
+    }
+
+    template <typename T, size_t Size>
+    constexpr bool empty(const Vec<T, Size>& a)
+    {
+        return a == Vec<T, Size>::Zero;
+    }
+
+    template <typename T, size_t Size>
+    constexpr bool identity(const Vec<T, Size>& a)
+    {
+        return a == Vec<T, Size>::Identity;
+    }
+
+    using Vec1 = Vec<float, 1>;
+    using Vec2 = Vec<float, 2>;
+    using Vec3 = Vec<float, 3>;
+    using Vec4 = Vec<float, 4>;
+
+}
diff --git a/include/Orange/Render/Swapchain.h b/include/Orange/Render/Swapchain.h
index 935a48d..77a7202 100644
--- a/include/Orange/Render/Swapchain.h
+++ b/include/Orange/Render/Swapchain.h
@@ -2,7 +2,7 @@
 
 #include <Orange/Core/Span.h>
 #include <Orange/Core/Result.h>
-#include <Orange/Core/Array.h>
+#include <Orange/Core/Vector.h>
 
 #include <Orange/Render/RenderContext.h>
 #include <vulkan/vulkan_core.h>
@@ -51,13 +51,13 @@ namespace orange
         VkExtent2D      m_extent;
         VkSwapchainKHR  m_swapchain;
 
-        SmallArray<VkImage,         6> m_images;
-        SmallArray<VkImageView,     6> m_imageViews;
+        SmallVector<VkImage,         6> m_images;
+        SmallVector<VkImageView,     6> m_imageViews;
 
-        SmallArray<VkCommandBuffer, MaxFramesInFlight> m_commandBuffers;
-        SmallArray<VkSemaphore,     MaxFramesInFlight> m_imageAvailableSemaphores;
-        SmallArray<VkSemaphore,     MaxFramesInFlight> m_renderFinishedSemaphores;
-        SmallArray<VkFence,         MaxFramesInFlight> m_inFlightFences;
+        SmallVector<VkCommandBuffer, MaxFramesInFlight> m_commandBuffers;
+        SmallVector<VkSemaphore,     MaxFramesInFlight> m_imageAvailableSemaphores;
+        SmallVector<VkSemaphore,     MaxFramesInFlight> m_renderFinishedSemaphores;
+        SmallVector<VkFence,         MaxFramesInFlight> m_inFlightFences;
 
         uint32_t m_currentFrame = 0;
         uint32_t m_currentImage = 0;
diff --git a/src/Apps/Tools/CubeTest.cpp b/src/Apps/Tools/CubeTest.cpp
index fe04f12..c08025c 100644
--- a/src/Apps/Tools/CubeTest.cpp
+++ b/src/Apps/Tools/CubeTest.cpp
@@ -1,7 +1,9 @@
-#include "Orange/Core/Array.h"
+#include <Orange/Core/Array.h>
+#include <Orange/Core/Vector.h>
 #include "Orange/Core/Span.h"
 #include <Orange/Core/Result.h>
 #include <Orange/Core/FileSystem.h>
+#include <Orange/Math/Vector.h>
 #include <Orange/Core/Parse.h>
 
 #include <Orange/Render/Window.h>
@@ -16,7 +18,7 @@ Result<VoidResult> ParseOBJ(StringView buffer)
     const char* end = buffer.data + buffer.size;
     while (obj != end)
     {
-        SmallArray<char, 8> element;
+        SmallVector<char, 8> element;
         stream::ReadString(obj, end, " #\n", element);
 
         if (element == "v" || element == "vn" || element == "vt")
@@ -37,7 +39,7 @@ Result<VoidResult> ParseOBJ(StringView buffer)
         else if (element == "g" || element == "o")
         {
             stream::ConsumeSpace(obj, end);
-            SmallArray<char, 32> name;
+            SmallVector<char, 32> name;
             stream::ReadString(obj, end, " #\n", name);
 
             name.PushBack('\0');
diff --git a/src/Orange/Render/RenderContext_Init.cpp b/src/Orange/Render/RenderContext_Init.cpp
index 36f379f..d89796b 100644
--- a/src/Orange/Render/RenderContext_Init.cpp
+++ b/src/Orange/Render/RenderContext_Init.cpp
@@ -1,5 +1,5 @@
 #include <Orange/Core/Log.h>
-#include <Orange/Core/Array.h>
+#include <Orange/Core/Vector.h>
 
 #include <Orange/Render/VulkanHelpers.h>
 #include <Orange/Render/RenderContext.h>
@@ -9,7 +9,7 @@ namespace orange
 {
     static VulkanResult<VkInstance> CreateVkInstance(const char* appName)
     {
-        SmallArray<const char *, 32> instanceExtensions;
+        SmallVector<const char *, 32> instanceExtensions;
         {
             auto r_tempWindow = Window::Create();
             if (!r_tempWindow)
@@ -49,7 +49,7 @@ namespace orange
 
     static Result<uint32_t> PickQueueFamilyIndex(VkPhysicalDevice physicalDevice)
     {
-        SmallArray<VkQueueFamilyProperties, 32> queueFamilyProperties;
+        SmallVector<VkQueueFamilyProperties, 32> queueFamilyProperties;
         VkEnumerate(vkGetPhysicalDeviceQueueFamilyProperties, queueFamilyProperties, physicalDevice);
 
         for (uint32_t i = 0; i < queueFamilyProperties.Size(); i++)
@@ -80,7 +80,7 @@ namespace orange
 
     static Result<VkPhysicalDevice> PickPhysicalDevice(VkInstance instance)
     {
-        SmallArray<VkPhysicalDevice, 32> physicalDevices;
+        SmallVector<VkPhysicalDevice, 32> physicalDevices;
         VkEnumerate(vkEnumeratePhysicalDevices, physicalDevices, instance);
 
         VkPhysicalDevice bestPhysicalDevice = VK_NULL_HANDLE;
diff --git a/src/Orange/Render/Swapchain.cpp b/src/Orange/Render/Swapchain.cpp
index 6f2b9e5..b1918cd 100644
--- a/src/Orange/Render/Swapchain.cpp
+++ b/src/Orange/Render/Swapchain.cpp
@@ -11,7 +11,7 @@ namespace orange
 
     static Result<VkSurfaceFormatKHR> ChooseSwapChainFormat(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface)
     {
-        SmallArray<VkSurfaceFormatKHR, 32> surfaceFormats;
+        SmallVector<VkSurfaceFormatKHR, 32> surfaceFormats;
         if (!VkEnumerate(vkGetPhysicalDeviceSurfaceFormatsKHR, surfaceFormats, physicalDevice, surface))
         {
             log::err("Surface supports no formats");
@@ -29,7 +29,7 @@ namespace orange
 
     static VkPresentModeKHR ChoosePresentMode(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface)
     {
-        SmallArray<VkPresentModeKHR, 32> presentModes;
+        SmallVector<VkPresentModeKHR, 32> presentModes;
         VkEnumerate(vkGetPhysicalDeviceSurfacePresentModesKHR, presentModes, physicalDevice, surface);
 
         for (auto& presentMode : presentModes) { if (presentMode == VK_PRESENT_MODE_MAILBOX_KHR)   return presentMode; }
@@ -99,11 +99,11 @@ namespace orange
         if (vkCreateSwapchainKHR(context.Device(), &swapchainInfo, nullptr, &swapchain) != VK_SUCCESS)
             return Result<Swapchain>::PrintError("Failed to create swapchain");
 
-        SmallArray<VkImage, 6> swapchainImages;
+        SmallVector<VkImage, 6> swapchainImages;
         if (!VkEnumerate(vkGetSwapchainImagesKHR, swapchainImages, context.Device(), swapchain))
             return Result<Swapchain>::PrintError("Failed to get swapchain images");
 
-        SmallArray<VkImageView, 6> swapchainImageViews{ swapchainImages.Size() };
+        SmallVector<VkImageView, 6> swapchainImageViews{ swapchainImages.Size() };
         for (size_t i = 0; i < swapchainImages.Size(); i++)
         {
             VkImageViewCreateInfo imageViewInfo =
@@ -119,7 +119,7 @@ namespace orange
                 return Result<Swapchain>::PrintError("Failed to get swapchain image view");
         }
 
-        SmallArray<VkCommandBuffer, 6> commandBuffers{ DefaultFramesInFlight };
+        SmallVector<VkCommandBuffer, 6> commandBuffers{ DefaultFramesInFlight };
         {
             VkCommandBufferAllocateInfo commandBufferInfo =
             {
@@ -133,9 +133,9 @@ namespace orange
                 return Result<Swapchain>::PrintError("Failed to get swapchain image view");
         }
 
-        SmallArray<VkSemaphore, MaxFramesInFlight> imageAvailableSemaphores{ DefaultFramesInFlight };
-        SmallArray<VkSemaphore, MaxFramesInFlight> renderFinishedSemaphores{ DefaultFramesInFlight };
-        SmallArray<VkFence,     MaxFramesInFlight> inFlightFences          { DefaultFramesInFlight };
+        SmallVector<VkSemaphore, MaxFramesInFlight> imageAvailableSemaphores{ DefaultFramesInFlight };
+        SmallVector<VkSemaphore, MaxFramesInFlight> renderFinishedSemaphores{ DefaultFramesInFlight };
+        SmallVector<VkFence,     MaxFramesInFlight> inFlightFences          { DefaultFramesInFlight };
         for (uint32_t i = 0; i < DefaultFramesInFlight; i++)
         {
             auto r_fence = context.CreateFence(true);