diff --git a/Sources/OpenRenderBox/include/OpenRenderBoxCxx/Vector/realloc_vector.hpp b/Sources/OpenRenderBox/include/OpenRenderBoxCxx/Vector/realloc_vector.hpp
new file mode 100644
index 0000000..38b05aa
--- /dev/null
+++ b/Sources/OpenRenderBox/include/OpenRenderBoxCxx/Vector/realloc_vector.hpp
@@ -0,0 +1,24 @@
+//
+//  realloc_vector.hpp
+//  OpenRenderBoxCxx
+
+#ifndef realloc_vector_hpp
+#define realloc_vector_hpp
+
+#include <OpenRenderBox/ORBBase.h>
+
+ORB_ASSUME_NONNULL_BEGIN
+
+namespace ORB {
+namespace details {
+template <typename T = uint32_t, size_t Alignment>
+void *_Nullable realloc_vector(void* ptr, T& size, T new_size);
+
+template <typename T = uint32_t, size_t Alignment>
+void *_Nullable realloc_vector(void* src, void* dst, T dstSize, T& size, T newSize);
+} /* details */
+} /* ORB */
+
+ORB_ASSUME_NONNULL_END
+
+#endif /* realloc_vector_hpp */
diff --git a/Sources/OpenRenderBox/include/OpenRenderBoxCxx/Vector/vector.hpp b/Sources/OpenRenderBox/include/OpenRenderBoxCxx/Vector/vector.hpp
new file mode 100644
index 0000000..fdf4ae4
--- /dev/null
+++ b/Sources/OpenRenderBox/include/OpenRenderBoxCxx/Vector/vector.hpp
@@ -0,0 +1,240 @@
+//
+//  vector.hpp
+//  OpenRenderBoxCxx
+//
+//  Status: Complete
+//  Modified based Compute code
+
+#ifndef vector_hpp
+#define vector_hpp
+
+#include <OpenRenderBox/ORBBase.h>
+#include <concepts>
+#include <iterator>
+#include <memory>
+
+ORB_ASSUME_NONNULL_BEGIN
+
+namespace ORB {
+
+template <typename T, unsigned int _stack_size = 0, typename size_type = std::size_t>
+    requires std::unsigned_integral<size_type>
+class vector {
+  private:
+    T _stack_buffer[_stack_size];
+    T *_Nullable _buffer = nullptr;
+    size_type _size = 0;
+    size_type _capacity = _stack_size;
+
+    void reserve_slow(size_type new_cap);
+
+  public:
+    using value_type = T;
+    using reference = value_type &;
+    using const_reference = const value_type &;
+    using iterator = value_type *_Nonnull;
+    using const_iterator = const value_type *_Nonnull;
+    using reverse_iterator = std::reverse_iterator<iterator>;
+    using const_reverse_iterator = std::reverse_iterator<const_iterator>;
+
+    ~vector();
+
+    // Element access
+
+    reference operator[](size_type pos) { return data()[pos]; };
+    const_reference operator[](size_type pos) const { return data()[pos]; };
+
+    reference front() { return &data()[0]; };
+    const_reference front() const { return *&data()[0]; };
+    reference back() { return *&data()[_size - 1]; };
+    const_reference back() const { return *&data()[_size - 1]; };
+
+    T *_Nonnull data() { return _buffer != nullptr ? _buffer : _stack_buffer; };
+    const T *_Nonnull data() const { return _buffer != nullptr ? _buffer : _stack_buffer; };
+
+    // Iterators
+
+    iterator begin() { return iterator(&data()[0]); };
+    const_iterator cbegin() const { return const_iterator(&data()[0]); };
+    iterator end() { return iterator(&data()[_size]); };
+    const_iterator cend() const { return const_iterator(&data()[_size]); };
+
+    reverse_iterator rbegin() { return std::reverse_iterator(end()); };
+    const_reverse_iterator crbegin() const { return std::reverse_iterator(cend()); };
+    reverse_iterator rend() { return std::reverse_iterator(begin()); };
+    const_reverse_iterator crend() const { return std::reverse_iterator(cbegin()); };
+
+    // Capacity
+
+    bool empty() const { return _size == 0; };
+    size_type size() const { return _size; };
+    void reserve(size_type new_cap);
+    size_type capacity() const { return _capacity; };
+    void shrink_to_fit();
+
+    // Modifiers
+
+    void clear();
+
+    void push_back(const T &value);
+    void push_back(T &&value);
+    void pop_back();
+
+    void resize(size_type count);
+    void resize(size_type count, const value_type &value);
+};
+
+static_assert(std::contiguous_iterator<vector<int>::iterator>);
+static_assert(std::contiguous_iterator<vector<int>::const_iterator>);
+
+// MARK: Specialization for empty stack buffer
+
+template <typename T, typename size_type>
+    requires std::unsigned_integral<size_type>
+class vector<T, 0, size_type> {
+  private:
+    T *_Nullable _buffer = nullptr;
+    size_type _size = 0;
+    size_type _capacity = 0;
+
+    void reserve_slow(size_type new_cap);
+
+  public:
+    using value_type = T;
+    using reference = value_type &;
+    using const_reference = const value_type &;
+    using iterator = value_type *_Nonnull;
+    using const_iterator = const value_type *_Nonnull;
+    using reverse_iterator = std::reverse_iterator<iterator>;
+    using const_reverse_iterator = std::reverse_iterator<const_iterator>;
+
+    ~vector();
+
+    // Element access
+
+    reference operator[](size_type pos) { return data()[pos]; };
+    const_reference operator[](size_type pos) const { return data()[pos]; };
+
+    reference front() { return &data()[0]; };
+    const_reference front() const { return *&data()[0]; };
+    reference back() { return *&data()[_size - 1]; };
+    const_reference back() const { return *&data()[_size - 1]; };
+
+    T *_Nonnull data() { return _buffer; };
+    const T *_Nonnull data() const { return _buffer; };
+
+    // Iterators
+
+    iterator begin() { return iterator(&data()[0]); };
+    iterator end() { return iterator(&data()[_size]); };
+    const_iterator cbegin() const { return const_iterator(&data()[0]); };
+    const_iterator cend() const { return const_iterator(&data()[_size]); };
+    const_iterator begin() const { return cbegin(); };
+    const_iterator end() const { return cend(); };
+
+    reverse_iterator rbegin() { return std::reverse_iterator(end()); };
+    reverse_iterator rend() { return std::reverse_iterator(begin()); };
+    const_reverse_iterator crbegin() const { return std::reverse_iterator(cend()); };
+    const_reverse_iterator crend() const { return std::reverse_iterator(cbegin()); };
+    const_reverse_iterator rbegin() const { return crbegin(); };
+    const_reverse_iterator rend() const { return crend(); };
+
+    // Capacity
+
+    bool empty() const { return _size == 0; };
+    size_type size() const { return _size; };
+    void reserve(size_type new_cap);
+    size_type capacity() const { return _capacity; };
+    void shrink_to_fit();
+
+    // Modifiers
+
+    void clear();
+
+    void push_back(const T &value);
+    void push_back(T &&value);
+    void pop_back();
+
+    void resize(size_type count);
+    void resize(size_type count, const value_type &value);
+};
+
+// MARK: Specialization for unique_ptr
+
+template <typename T, typename size_type>
+    requires std::unsigned_integral<size_type>
+class vector<std::unique_ptr<T>, 0, size_type> {
+  private:
+    std::unique_ptr<T> *_Nullable _buffer = nullptr;
+    size_type _size = 0;
+    size_type _capacity = 0;
+
+    void reserve_slow(size_type new_cap);
+
+  public:
+    using value_type = std::unique_ptr<T>;
+    using reference = value_type &;
+    using const_reference = const value_type &;
+    using iterator = value_type *_Nonnull;
+    using const_iterator = const value_type *_Nonnull;
+    using reverse_iterator = std::reverse_iterator<iterator>;
+    using const_reverse_iterator = std::reverse_iterator<const_iterator>;
+
+    ~vector();
+
+    // Element access
+
+    reference operator[](size_type pos) { return data()[pos]; };
+    const_reference operator[](size_type pos) const { return data()[pos]; };
+
+    reference front() { return &data()[0]; };
+    const_reference front() const { return *&data()[0]; };
+    reference back() { return *&data()[_size - 1]; };
+    const_reference back() const { return *&data()[_size - 1]; };
+
+    std::unique_ptr<T> *_Nonnull data() { return _buffer; };
+    const std::unique_ptr<T> *_Nonnull data() const { return _buffer; };
+
+    // Iterators
+
+    iterator begin() { return iterator(&data()[0]); };
+    iterator end() { return iterator(&data()[_size]); };
+    const_iterator cbegin() const { return const_iterator(&data()[0]); };
+    const_iterator cend() const { return const_iterator(&data()[_size]); };
+    const_iterator begin() const { return cbegin(); };
+    const_iterator end() const { return cend(); };
+
+    reverse_iterator rbegin() { return std::reverse_iterator(end()); };
+    reverse_iterator rend() { return std::reverse_iterator(begin()); };
+    const_reverse_iterator crbegin() const { return std::reverse_iterator(cend()); };
+    const_reverse_iterator crend() const { return std::reverse_iterator(cbegin()); };
+    const_reverse_iterator rbegin() const { return crbegin(); };
+    const_reverse_iterator rend() const { return crend(); };
+
+    // Capacity
+
+    bool empty() const { return _size == 0; };
+    size_type size() const { return _size; };
+    void reserve(size_type new_cap);
+    size_type capacity() const { return _capacity; };
+    void shrink_to_fit();
+
+    // Modifiers
+
+    void clear();
+
+    void push_back(const std::unique_ptr<T> &value) = delete;
+    ORB_INLINE void push_back(std::unique_ptr<T> &&value);
+    ORB_INLINE void pop_back();
+
+    void resize(size_type count);
+    void resize(size_type count, const value_type &value);
+};
+
+} /* ORB */
+
+ORB_ASSUME_NONNULL_END
+
+#include "vector.tpp"
+
+#endif /* vector.hpp */
diff --git a/Sources/OpenRenderBox/include/OpenRenderBoxCxx/Vector/vector.tpp b/Sources/OpenRenderBox/include/OpenRenderBoxCxx/Vector/vector.tpp
new file mode 100644
index 0000000..1a878c2
--- /dev/null
+++ b/Sources/OpenRenderBox/include/OpenRenderBoxCxx/Vector/vector.tpp
@@ -0,0 +1,395 @@
+//
+//  vector.tpp
+//  OpenRenderBoxCxx
+//
+//  Status: Complete
+//  Modified based Compute code
+
+#include <OpenRenderBoxCxx/Vector/vector.hpp>
+#include <OpenRenderBoxCxx/Util/assert.hpp>
+
+#include <algorithm>
+#if ORB_TARGET_OS_DARWIN
+#include <malloc/malloc.h>
+#else
+#include <malloc.h>
+#endif /* ORB_TARGET_OS_DARWIN */
+#include <memory>
+#include <cassert>
+
+namespace ORB {
+
+#pragma mark - Base implementation
+
+namespace details {
+
+template <typename size_type, unsigned int element_size_bytes>
+    requires std::unsigned_integral<size_type>
+void *realloc_vector(void *buffer, void *stack_buffer, size_type stack_size, size_type *size,
+                     size_type preferred_new_size) {
+    // copy data from heap buffer buffer into stack buffer if possible
+    if (preferred_new_size <= stack_size) {
+        if (buffer) {
+            memcpy(stack_buffer, buffer, preferred_new_size * element_size_bytes);
+            free(buffer);
+            *size = stack_size;
+        }
+        return nullptr;
+    }
+
+    #if ORB_TARGET_OS_DARWIN
+    size_t new_size_bytes = malloc_good_size(preferred_new_size * element_size_bytes);
+    #else
+    size_t new_size_bytes = malloc_good_size(preferred_new_size * element_size_bytes);
+    #endif
+    size_type new_size = new_size_bytes / element_size_bytes;
+    if (new_size == *size) {
+        // nothing to do
+        return buffer;
+    }
+
+    void *new_buffer = realloc(buffer, new_size_bytes);
+    if (!new_buffer) {
+        precondition_failure("allocation failure");
+    }
+
+    // copy data from stack buffer into heap buffer
+    if (!buffer) {
+        memcpy(new_buffer, stack_buffer, (*size) * element_size_bytes);
+    }
+
+    *size = new_size;
+    return new_buffer;
+}
+
+} /* namespace details */
+
+template <typename T, unsigned int _stack_size, typename size_type>
+    requires std::unsigned_integral<size_type>
+vector<T, _stack_size, size_type>::~vector() {
+    for (auto i = 0; i < _size; i++) {
+        data()[i].~T();
+    }
+    if (_buffer) {
+        free(_buffer);
+    }
+}
+
+template <typename T, unsigned int _stack_size, typename size_type>
+    requires std::unsigned_integral<size_type>
+void vector<T, _stack_size, size_type>::reserve_slow(size_type new_cap) {
+    size_type effective_new_cap = std::max(capacity() * 1.5, new_cap * 1.0);
+    _buffer = reinterpret_cast<T *>(details::realloc_vector<size_type, sizeof(T)>(_buffer, _stack_buffer, _stack_size,
+                                                                                  &_capacity, effective_new_cap));
+}
+
+template <typename T, unsigned int _stack_size, typename size_type>
+    requires std::unsigned_integral<size_type>
+void vector<T, _stack_size, size_type>::reserve(size_type new_cap) {
+    if (new_cap <= capacity()) {
+        return;
+    }
+    reserve_slow(new_cap);
+}
+
+template <typename T, unsigned int _stack_size, typename size_type>
+    requires std::unsigned_integral<size_type>
+void vector<T, _stack_size, size_type>::shrink_to_fit() {
+    if (capacity() > _size) {
+        _buffer = reinterpret_cast<T *>(
+            details::realloc_vector<size_type, sizeof(T)>(_buffer, _stack_buffer, _stack_size, &_capacity, _size));
+    }
+}
+
+template <typename T, unsigned int _stack_size, typename size_type>
+    requires std::unsigned_integral<size_type>
+void vector<T, _stack_size, size_type>::clear() {
+    for (auto i = 0; i < _size; i++) {
+        data()[i].~T();
+    }
+    _size = 0;
+}
+
+template <typename T, unsigned int _stack_size, typename size_type>
+    requires std::unsigned_integral<size_type>
+void vector<T, _stack_size, size_type>::push_back(const T &value) {
+    reserve(_size + 1);
+    new (&data()[_size]) value_type(value);
+    _size += 1;
+}
+
+template <typename T, unsigned int _stack_size, typename size_type>
+    requires std::unsigned_integral<size_type>
+void vector<T, _stack_size, size_type>::push_back(T &&value) {
+    reserve(_size + 1);
+    new (&data()[_size]) value_type(std::move(value));
+    _size += 1;
+}
+
+template <typename T, unsigned int _stack_size, typename size_type>
+    requires std::unsigned_integral<size_type>
+void vector<T, _stack_size, size_type>::pop_back() {
+    assert(size() > 0);
+    data()[_size - 1].~T();
+    _size -= 1;
+}
+
+template <typename T, unsigned int _stack_size, typename size_type>
+    requires std::unsigned_integral<size_type>
+void vector<T, _stack_size, size_type>::resize(size_type count) {
+    reserve(count);
+    if (count < _size) {
+        for (auto i = count; i < _size; i++) {
+            data()[i].~T();
+        }
+    } else if (count > _size) {
+        for (auto i = _size; i < count; i++) {
+            new (this[i]) value_type();
+        }
+    }
+    _size = count;
+}
+
+template <typename T, unsigned int _stack_size, typename size_type>
+    requires std::unsigned_integral<size_type>
+void vector<T, _stack_size, size_type>::resize(size_type count, const value_type &value) {
+    reserve(count);
+    if (count < _size) {
+        for (auto i = count; i < _size; i++) {
+            data()[i].~T();
+        }
+    } else if (count > _size) {
+        for (auto i = _size; i < count; i++) {
+            new (this[i]) value_type(value);
+        }
+    }
+    _size = count;
+}
+
+#pragma mark - Specialization for empty stack buffer
+
+namespace details {
+
+template <typename size_type, size_t element_size>
+    requires std::unsigned_integral<size_type>
+void *realloc_vector(void *buffer, size_type *size, size_type preferred_new_size) {
+    if (preferred_new_size == 0) {
+        *size = 0;
+        free(buffer);
+        return nullptr;
+    }
+
+    #if ORB_TARGET_OS_DARWIN
+    size_t new_size_bytes = malloc_good_size(preferred_new_size * element_size);
+    #else
+    size_t new_size_bytes = preferred_new_size * element_size;
+    #endif
+    size_type new_size = (size_type)(new_size_bytes / element_size);
+    if (new_size == *size) {
+        // nothing to do
+        return buffer;
+    }
+
+    void *new_buffer = realloc(buffer, new_size_bytes);
+    if (!new_buffer) {
+        precondition_failure("allocation failure");
+    }
+    *size = new_size;
+    return new_buffer;
+}
+
+} /* namespace details */
+
+template <typename T, typename size_type>
+    requires std::unsigned_integral<size_type>
+vector<T, 0, size_type>::~vector() {
+    for (auto i = 0; i < _size; i++) {
+        _buffer[i].~T();
+    }
+    if (_buffer) {
+        free(_buffer);
+    }
+}
+
+template <typename T, typename size_type>
+    requires std::unsigned_integral<size_type>
+void vector<T, 0, size_type>::reserve_slow(size_type new_cap) {
+    size_type effective_new_cap = std::max(capacity() * 1.5, new_cap * 1.0);
+    _buffer =
+        reinterpret_cast<T *>(details::realloc_vector<size_type, sizeof(T)>(_buffer, &_capacity, effective_new_cap));
+}
+
+template <typename T, typename size_type>
+    requires std::unsigned_integral<size_type>
+void vector<T, 0, size_type>::reserve(size_type new_cap) {
+    if (new_cap <= capacity()) {
+        return;
+    }
+    reserve_slow(new_cap);
+}
+
+template <typename T, typename size_type>
+requires std::unsigned_integral<size_type>
+void vector<T, 0, size_type>::shrink_to_fit() {
+    if (capacity() > size()) {
+        _buffer =
+        reinterpret_cast<T *>(details::realloc_vector<size_type, sizeof(T)>(_buffer, &_capacity, 0));
+    }
+}
+
+template <typename T, typename size_type>
+    requires std::unsigned_integral<size_type>
+void vector<T, 0, size_type>::clear() {
+    for (auto i = 0; i < _size; i++) {
+        data()[i].~T();
+    }
+    _size = 0;
+}
+
+template <typename T, typename size_type>
+    requires std::unsigned_integral<size_type>
+void vector<T, 0, size_type>::push_back(const T &value) {
+    reserve(_size + 1);
+    new (&_buffer[_size]) value_type(value);
+    _size += 1;
+}
+
+template <typename T, typename size_type>
+    requires std::unsigned_integral<size_type>
+void vector<T, 0, size_type>::push_back(T &&value) {
+    reserve(_size + 1);
+    new (&_buffer[_size]) value_type(std::move(value));
+    _size += 1;
+}
+
+template <typename T, typename size_type>
+    requires std::unsigned_integral<size_type>
+void vector<T, 0, size_type>::pop_back() {
+    assert(size() > 0);
+    data()[_size - 1].~T();
+    _size -= 1;
+}
+
+template <typename T, typename size_type>
+    requires std::unsigned_integral<size_type>
+void vector<T, 0, size_type>::resize(size_type count) {
+    reserve(count);
+    if (count < _size) {
+        for (auto i = count; i < _size; i++) {
+            data()[i].~T();
+        }
+    } else if (count > _size) {
+        for (auto i = _size; i < count; i++) {
+            new (this[i]) value_type();
+        }
+    }
+    _size = count;
+}
+
+template <typename T, typename size_type>
+    requires std::unsigned_integral<size_type>
+void vector<T, 0, size_type>::resize(size_type count, const value_type &value) {
+    reserve(count);
+    if (count < _size) {
+        for (auto i = count; i < _size; i++) {
+            data()[i].~T();
+        }
+    } else if (count > _size) {
+        for (auto i = _size; i < count; i++) {
+            new (this[i]) value_type(value);
+        }
+    }
+    _size = count;
+}
+
+#pragma mark - Specialization for unique_ptr
+
+template <typename T, typename size_type>
+    requires std::unsigned_integral<size_type>
+vector<std::unique_ptr<T>, 0, size_type>::~vector() {
+    clear();
+    if (_buffer) {
+        free(_buffer);
+        _buffer = nullptr;
+    }
+}
+
+template <typename T, typename size_type>
+    requires std::unsigned_integral<size_type>
+void vector<std::unique_ptr<T>, 0, size_type>::clear() {
+    for (size_type i = 0; i < _size; ++i) {
+        _buffer[i].reset();
+        _buffer[i].~unique_ptr();
+    }
+    _size = 0;
+}
+
+template <typename T, typename size_type>
+    requires std::unsigned_integral<size_type>
+void vector<std::unique_ptr<T>, 0, size_type>::reserve_slow(size_type new_cap) {
+    if (new_cap <= _capacity) {
+        return;
+    }
+
+    size_type actual_new_cap = std::max(new_cap, _capacity * 2);
+    std::unique_ptr<T> *new_buffer = (std::unique_ptr<T> *)malloc(actual_new_cap * sizeof(std::unique_ptr<T>));
+    if (!new_buffer) {
+        return;
+    }
+
+    for (size_type i = 0; i < _size; ++i) {
+        new (&new_buffer[i]) std::unique_ptr<T>(std::move(_buffer[i]));
+        _buffer[i].~unique_ptr();
+    }
+
+    if (_buffer) {
+        free(_buffer);
+    }
+
+    _buffer = new_buffer;
+    _capacity = actual_new_cap;
+}
+
+template <typename T, typename size_type>
+    requires std::unsigned_integral<size_type>
+void vector<std::unique_ptr<T>, 0, size_type>::reserve(size_type new_cap) {
+    if (new_cap > _capacity) {
+        reserve_slow(new_cap);
+    }
+}
+
+template <typename T, typename size_type>
+    requires std::unsigned_integral<size_type>
+ORB_INLINE void vector<std::unique_ptr<T>, 0, size_type>::push_back(std::unique_ptr<T> &&value) {
+    reserve(_size + 1);
+    new (&_buffer[_size]) std::unique_ptr<T>(std::move(value));
+    ++_size;
+}
+
+template <typename T, typename size_type>
+    requires std::unsigned_integral<size_type>
+ORB_INLINE void vector<std::unique_ptr<T>, 0, size_type>::pop_back() {
+    assert(_size > 0);
+    _buffer[_size - 1].reset();
+    _buffer[_size - 1].~unique_ptr();
+    --_size;
+}
+
+template <typename T, typename size_type>
+    requires std::unsigned_integral<size_type>
+void vector<std::unique_ptr<T>, 0, size_type>::resize(size_type count) {
+    reserve(count);
+    if (count < _size) {
+        for (auto i = count; i < _size; i++) {
+            _buffer[i].reset();
+            _buffer[i].~unique_ptr();
+        }
+    } else if (count > _size) {
+        for (auto i = _size; i < count; i++) {
+            new (&_buffer[i]) std::unique_ptr<T>();
+        }
+    }
+    _size = count;
+}
+
+} /* ORB */