diff --git a/src/utility/small_unique_ptr.hpp b/src/utility/small_unique_ptr.hpp
new file mode 100644
index 00000000..ea07ff5d
--- /dev/null
+++ b/src/utility/small_unique_ptr.hpp
@@ -0,0 +1,319 @@
+/* Copyright (c) 2023 Krisztián Rugási. Subject to the MIT License. */
+
+#ifndef GA_UTILITY_SMALL_UNIQUE_PTR_HPP
+#define GA_UTILITY_SMALL_UNIQUE_PTR_HPP
+
+#include "type_traits.hpp"
+#include "utility.hpp"
+#include <compare>
+#include <memory>
+#include <type_traits>
+#include <utility>
+#include <cstddef>
+
+namespace gapp::detail
+{
+    template<typename T>
+    inline constexpr size_t buffer_size_v = 64 - sizeof(T*) - sizeof(void(*)());
+
+    // should be inside small_unique_ptr
+    template<typename T>
+    inline constexpr bool always_heap_allocated_v = (sizeof(T) > buffer_size_v<T>) || (!std::is_nothrow_move_constructible_v<T> && !std::is_abstract_v<T>);
+
+
+    template<typename T, bool = always_heap_allocated_v<T>>
+    class small_ptr_storage
+    {
+    public:
+        constexpr small_ptr_storage() noexcept {}
+        constexpr ~small_ptr_storage() noexcept {}
+
+        small_ptr_storage(const small_ptr_storage&)            = delete;
+        small_ptr_storage(small_ptr_storage&&)                 = delete;
+
+        small_ptr_storage& operator=(const small_ptr_storage&) = delete;
+        small_ptr_storage& operator=(small_ptr_storage&&)      = delete;
+
+        constexpr T* buffer() noexcept
+        {
+            if constexpr (!std::is_abstract_v<T>) return std::addressof(buffer_);
+            else return reinterpret_cast<T*>(std::addressof(buffer_));
+        }
+
+        constexpr const T* buffer() const noexcept
+        {
+            if constexpr (!std::is_abstract_v<T>) return std::addressof(buffer_);
+            else return reinterpret_cast<const T*>(std::addressof(buffer_));
+        }
+
+        template<typename U>
+        constexpr void move_buffer_to(small_ptr_storage<U>& dst) noexcept
+        {
+            move_(buffer(), dst.buffer());
+            dst.move_ = move_;
+        }
+
+        using buffer_t = std::conditional_t<std::is_abstract_v<T>, unsigned char[sizeof(T)], T>;
+        using move_t = void(*)(void* src, void* dst) noexcept;
+
+        move_t move_ = nullptr;
+        union
+        {
+            unsigned char padding_[buffer_size_v<T>];
+            alignas(T) buffer_t buffer_;
+        };
+    };
+
+    template<typename T>
+    class small_ptr_storage<T, true>
+    {};
+
+
+    template<typename T> // TODO: move CACHE_LINE_SIZE constant from small_vector to utility and use that here too
+    class small_unique_ptr : private small_ptr_storage<std::remove_cv_t<T>>
+    {
+    public:
+        static_assert(!std::is_array_v<T> && !std::is_void_v<T>);
+
+        using element_type = T;
+        using pointer      = T*;
+        using reference    = T&;
+
+        constexpr small_unique_ptr() noexcept = default;
+        constexpr small_unique_ptr(std::nullptr_t) noexcept {}
+
+        constexpr small_unique_ptr(small_unique_ptr&& other) noexcept :
+            small_unique_ptr<T>(std::move(other), detail::empty_t{})
+        {}
+
+        template<typename U>
+        constexpr small_unique_ptr(small_unique_ptr<U>&& other, detail::empty_t = {}) noexcept
+        {
+            static_assert(!detail::is_proper_base_of_v<T, U> || std::has_virtual_destructor_v<T>);
+
+            if (!other.is_local() || std::is_constant_evaluated())
+            {
+                data_ = std::exchange(other.data_, nullptr);
+                return;
+            }
+            //if constexpr (!always_heap_allocated_v<U> && !std::has_virtual_destructor_v<T>)
+            //{
+            //    std::construct_at(this->buffer(), std::move(*other.buffer()));
+            //    data_ = this->buffer();
+            //    other.reset();
+            //}
+            if constexpr (!always_heap_allocated_v<U>) // other.is_local()
+            {
+                other.move_buffer_to(*this);
+                data_ = reinterpret_cast<T*>(reinterpret_cast<unsigned char*>(this->buffer()) + offsetof_base(other));
+                other.reset();
+            }
+        }
+
+        constexpr small_unique_ptr& operator=(small_unique_ptr&& other) noexcept
+        {
+            if (std::addressof(other) == this) [[unlikely]] return *this;
+
+            return operator=<T>(std::move(other));
+        }
+
+        template<typename U>
+        constexpr small_unique_ptr& operator=(small_unique_ptr<U>&& other) noexcept
+        {
+            static_assert(!detail::is_proper_base_of_v<T, U> || std::has_virtual_destructor_v<T>);
+
+            if (!other.is_local() || std::is_constant_evaluated())
+            {
+                reset(std::exchange(other.data_, nullptr));
+                return *this;
+            }
+            if constexpr (!always_heap_allocated_v<U>) // other.is_local()
+            {
+                const ptrdiff_t old_offset = offsetof_this();
+                reset();
+                other.move_buffer_to(*this);
+                data_ = reinterpret_cast<T*>(reinterpret_cast<unsigned char*>(this->buffer()) + offsetof_base(other) + old_offset);
+                other.reset();
+            }
+            return *this;
+        }
+
+        constexpr small_unique_ptr& operator=(std::nullptr_t) noexcept
+        {
+            reset();
+            return *this;
+        }
+
+        constexpr ~small_unique_ptr() noexcept
+        {
+            reset();
+        }
+
+        constexpr void reset(pointer new_data = pointer{}) noexcept
+        {
+            is_local() ? std::destroy_at(data_) : delete data_;
+            data_ = new_data;
+            if constexpr (!always_heap_allocated_v<T>) this->move_ = nullptr; // maybe add reset() method to buffer?
+        }
+
+        constexpr void swap(small_unique_ptr& other) noexcept requires(always_heap_allocated_v<T>)
+        {
+            std::swap(data_, other.data_);
+        }
+
+        constexpr void swap(small_unique_ptr& other) noexcept requires(!always_heap_allocated_v<T>)
+        {
+            if (is_local() && other.is_local())
+            {
+                T* new_this_data  = reinterpret_cast<T*>(reinterpret_cast<unsigned char*>(this->buffer()) + other.offsetof_this());
+                T* new_other_data = reinterpret_cast<T*>(reinterpret_cast<unsigned char*>(other.buffer()) + offsetof_this());
+
+                small_ptr_storage<T> temp;
+
+                other.move_buffer_to(temp);
+                std::destroy_at(other.buffer());
+                this->move_buffer_to(other);
+                std::destroy_at(this->buffer());
+                temp.move_buffer_to(*this);
+                std::destroy_at(temp.buffer());
+
+                this->data_ = new_this_data;
+                other.data_ = new_other_data;
+            }
+            else if (!is_local() && !other.is_local())
+            {
+                std::swap(data_, other.data_);
+            }
+            else if (!is_local() && other.is_local())
+            {
+                T* new_data = reinterpret_cast<T*>(reinterpret_cast<unsigned char*>(this->buffer()) + other.offsetof_this());
+                other.move_buffer_to(*this);
+                other.reset(std::exchange(data_, new_data));
+            }
+            else /* if (is_local() && !other.is_local()) */
+            {
+                T* new_data = reinterpret_cast<T*>(reinterpret_cast<unsigned char*>(other.buffer()) + offsetof_this());
+                this->move_buffer_to(other);
+                reset(std::exchange(other.data_, new_data));
+            }
+        }
+
+        [[nodiscard]]
+        constexpr pointer get() const noexcept
+        {
+            return data_;
+        }
+
+        [[nodiscard]]
+        constexpr explicit operator bool() const noexcept
+        {
+            return bool(data_);
+        }
+
+        [[nodiscard]]
+        constexpr reference operator*() const noexcept(detail::is_nothrow_dereferenceable_v<pointer>)
+        {
+            GAPP_ASSERT(data_);
+            return *data_;
+        }
+
+        [[nodiscard]]
+        constexpr pointer operator->() const noexcept
+        {
+            GAPP_ASSERT(data_);
+            return data_;
+        }
+
+        constexpr bool operator==(std::nullptr_t) const noexcept
+        {
+            return data_ == pointer{ nullptr };
+        }
+
+        constexpr std::strong_ordering operator<=>(std::nullptr_t) const noexcept
+        {
+            return data_ <=> pointer{ nullptr };
+        }
+
+        template<typename U>
+        constexpr bool operator==(const small_unique_ptr<U>& rhs) const noexcept
+        {
+            return data_ == rhs.data_;
+        }
+
+        template<typename U>
+        constexpr std::strong_ordering operator<=>(const small_unique_ptr<U>& rhs) const noexcept
+        {
+            return data_ <=> rhs.data_;
+        }
+
+    private:
+        pointer data_ = nullptr;
+
+        constexpr bool is_local() const noexcept requires(!always_heap_allocated_v<T>) { return this->move_ != nullptr; }
+        constexpr bool is_local() const noexcept requires(always_heap_allocated_v<T>)  { return false; }
+
+        template<typename U>
+        constexpr ptrdiff_t offsetof_base(const small_unique_ptr<U>& other) const noexcept
+        {
+            if constexpr (!detail::is_proper_base_of_v<T, U>) return 0;
+            else
+            {
+                const auto derived_ptr = reinterpret_cast<const volatile unsigned char*>(other.get());
+                const auto base_ptr    = reinterpret_cast<const volatile unsigned char*>(static_cast<const volatile T*>(other.get()));
+
+                return base_ptr - derived_ptr;
+            }
+        }
+
+        constexpr ptrdiff_t offsetof_this() const noexcept
+        {
+            if (!is_local() || !data_) return 0;
+
+            const auto derived_ptr = reinterpret_cast<const volatile unsigned char*>(this->buffer());
+            const auto base_ptr    = reinterpret_cast<const volatile unsigned char*>(data_);
+            
+            return base_ptr - derived_ptr;
+        }
+
+        template<typename U>
+        friend class small_unique_ptr;
+
+        template<typename U, typename... Args>
+        friend constexpr small_unique_ptr<U> make_unique_small(Args&&...);
+    };
+
+    template<typename T>
+    constexpr void swap(small_unique_ptr<T>& lhs, small_unique_ptr<T>& rhs) noexcept
+    {
+        lhs.swap(rhs);
+    }
+
+
+    template<typename T>
+    void move_buffer(void* src, void* dst) noexcept
+    {
+        std::construct_at(static_cast<T*>(dst), std::move(*static_cast<T*>(src)));
+    }
+
+    template<typename T, typename... Args>
+    [[nodiscard]] constexpr small_unique_ptr<T> make_unique_small(Args&&... args)
+    {
+        small_unique_ptr<T> ptr;
+
+        if constexpr (always_heap_allocated_v<T> || std::is_constant_evaluated())
+        {
+            ptr.data_ = new T(std::forward<Args>(args)...);
+        }
+        else
+        {
+            std::construct_at(ptr.buffer(), std::forward<Args>(args)...);
+            ptr.data_ = ptr.buffer();
+            ptr.move_ = move_buffer<T>;
+        }
+
+        return ptr;
+    }
+
+} // namespace gapp::detail
+
+#endif // !GA_UTILITY_SMALL_UNIQUE_PTR_HPP
\ No newline at end of file
diff --git a/src/utility/type_traits.hpp b/src/utility/type_traits.hpp
index 44eba355..6e382b7e 100644
--- a/src/utility/type_traits.hpp
+++ b/src/utility/type_traits.hpp
@@ -92,6 +92,17 @@ namespace gapp::detail
 
 
 
+    template<typename Base, typename Derived>
+    struct is_proper_base_of :
+        std::conjunction<std::is_base_of<std::remove_cv<Base>, std::remove_cv<Derived>>,
+                         std::negation<std::is_same<std::remove_cv<Base>, std::remove_cv<Derived>>>>
+    {};
+    
+    template<typename Base, typename Derived>
+    inline constexpr bool is_proper_base_of_v = is_proper_base_of<Base, Derived>::value;
+
+
+
     template<typename Derived, template<typename...> class BaseTempl>
     struct is_derived_from_spec_of
     {
@@ -161,6 +172,13 @@ namespace gapp::detail
     using promoted_t = typename promoted<T>::type;
 
 
+
+    template<typename T>
+    struct is_nothrow_dereferenceable : std::bool_constant<noexcept(*std::declval<T>())> {};
+
+    template<typename T>
+    inline constexpr bool is_nothrow_dereferenceable_v = is_nothrow_dereferenceable<T>::value;
+
 } // namespace gapp::detail
 
 #endif // !GA_UTILITY_TYPE_TRAITS_HPP
\ No newline at end of file
diff --git a/test/unit/small_unique_ptr.cpp b/test/unit/small_unique_ptr.cpp
new file mode 100644
index 00000000..c640c43d
--- /dev/null
+++ b/test/unit/small_unique_ptr.cpp
@@ -0,0 +1,278 @@
+/* Copyright (c) 2023 Krisztián Rugási. Subject to the MIT License. */
+
+#include <catch2/catch_test_macros.hpp>
+#include "utility/small_unique_ptr.hpp"
+#include <functional>
+
+using namespace gapp::detail;
+
+struct Base
+{
+    constexpr virtual int value() const { return 0; }
+    constexpr virtual void value(int) {}
+    constexpr virtual int padding() const { return 0; }
+    constexpr virtual ~Base() = default;
+};
+
+template<size_t Padding>
+struct Derived : Base
+{
+public:
+    constexpr Derived() = default;
+    constexpr Derived(int n) noexcept : value_(n) {}
+    constexpr ~Derived() override = default;
+    constexpr int value() const override { return value_; }
+    constexpr void value(int n) override { value_ = n; }
+    constexpr int padding() const override { return Padding; }
+private:
+    unsigned char padding_[Padding] = {};
+    int value_ = Padding;
+};
+
+using SmallDerived = Derived<32>;
+using LargeDerived = Derived<64>;
+
+
+TEST_CASE("ptr_size", "[small_unique_ptr]")
+{
+    STATIC_REQUIRE(sizeof(small_unique_ptr<int>) == 64); // could be exactly sizeof(int) for non-polymorphic types
+    STATIC_REQUIRE(sizeof(small_unique_ptr<SmallDerived>) == 64);
+    STATIC_REQUIRE(sizeof(small_unique_ptr<LargeDerived>) == sizeof(LargeDerived*));
+}
+
+TEST_CASE("construction", "[small_unique_ptr]")
+{
+    STATIC_REQUIRE( std::invoke([]{ (void) small_unique_ptr<Base>(nullptr);  return true; }) );
+    STATIC_REQUIRE( std::invoke([]{ (void) small_unique_ptr<SmallDerived>(); return true; }) );
+    STATIC_REQUIRE( std::invoke([]{ (void) small_unique_ptr<LargeDerived>(); return true; }) );
+
+    STATIC_REQUIRE( std::invoke([]{ (void) make_unique_small<double>(3.0);    return true; }) );
+    STATIC_REQUIRE( std::invoke([]{ (void) make_unique_small<Base>();         return true; }) );
+    STATIC_REQUIRE( std::invoke([]{ (void) make_unique_small<SmallDerived>(); return true; }) );
+    STATIC_REQUIRE( std::invoke([]{ (void) make_unique_small<LargeDerived>(); return true; }) );
+
+    REQUIRE_NOTHROW(make_unique_small<Base>());
+    REQUIRE_NOTHROW(make_unique_small<SmallDerived>());
+    REQUIRE_NOTHROW(make_unique_small<LargeDerived>());
+}
+
+TEST_CASE("comparisons", "[small_unique_ptr]")
+{
+    STATIC_REQUIRE(small_unique_ptr<int>(nullptr) == nullptr);
+    STATIC_REQUIRE(small_unique_ptr<int>(nullptr) <= nullptr);
+
+    STATIC_REQUIRE(make_unique_small<SmallDerived>() != nullptr);
+    STATIC_REQUIRE(make_unique_small<LargeDerived>() != nullptr);
+
+    STATIC_REQUIRE(make_unique_small<LargeDerived>() != make_unique_small<Base>());
+    STATIC_REQUIRE(make_unique_small<Base>() != make_unique_small<SmallDerived>());
+}
+
+TEST_CASE("bool_conversion", "[small_unique_ptr]")
+{
+    STATIC_REQUIRE(!small_unique_ptr<SmallDerived>());
+    STATIC_REQUIRE(!small_unique_ptr<LargeDerived>(nullptr));
+
+    STATIC_REQUIRE(make_unique_small<SmallDerived>());
+    STATIC_REQUIRE(make_unique_small<LargeDerived>());
+
+    REQUIRE(make_unique_small<SmallDerived>());
+    REQUIRE(make_unique_small<LargeDerived>());
+}
+
+TEST_CASE("get", "[small_unique_ptr]")
+{
+    STATIC_REQUIRE(small_unique_ptr<SmallDerived>(nullptr).get() == nullptr);
+    STATIC_REQUIRE(small_unique_ptr<LargeDerived>().get() == nullptr);
+
+    STATIC_REQUIRE(make_unique_small<SmallDerived>().get() != nullptr);
+    STATIC_REQUIRE(make_unique_small<LargeDerived>().get() != nullptr);
+
+    REQUIRE(make_unique_small<SmallDerived>().get() != nullptr);
+    REQUIRE(make_unique_small<LargeDerived>().get() != nullptr);
+}
+
+TEST_CASE("dereference", "[small_unique_ptr]")
+{
+    STATIC_REQUIRE((*make_unique_small<SmallDerived>()).padding() == 32);
+    STATIC_REQUIRE((*make_unique_small<LargeDerived>()).padding() == 64);
+
+    STATIC_REQUIRE(make_unique_small<SmallDerived>()->padding() == 32);
+    STATIC_REQUIRE(make_unique_small<LargeDerived>()->padding() == 64);
+
+    const auto p1 = make_unique_small<SmallDerived>();
+    const auto p2 = make_unique_small<LargeDerived>();
+
+    REQUIRE((*p1).value() == 32);
+    REQUIRE((*p2).value() == 64);
+
+    REQUIRE(p1->value() == 32);
+    REQUIRE(p2->value() == 64);
+}
+
+TEST_CASE("move_construct_plain", "[small_unique_ptr]")
+{
+    STATIC_REQUIRE(32 == std::invoke([] { small_unique_ptr<Base> p = make_unique_small<SmallDerived>(); return p->padding(); }));
+    STATIC_REQUIRE(64 == std::invoke([] { small_unique_ptr<Base> p = make_unique_small<LargeDerived>(); return p->padding(); }));
+
+    small_unique_ptr<Base> base1 = make_unique_small<SmallDerived>();
+    small_unique_ptr<Base> base2 = make_unique_small<LargeDerived>();
+
+    REQUIRE(base1->value() == 32);
+    REQUIRE(base2->value() == 64);
+
+    small_unique_ptr<const Base> cbase = std::move(base1);
+
+    REQUIRE(cbase->value() == 32);
+}
+
+TEST_CASE("move_assignment_plain", "[small_unique_ptr]")
+{
+    STATIC_REQUIRE(32 == std::invoke([] { small_unique_ptr<Base> p; p = make_unique_small<SmallDerived>(); return p->padding(); }));
+    STATIC_REQUIRE(64 == std::invoke([] { small_unique_ptr<Base> p; p = make_unique_small<LargeDerived>(); return p->padding(); }));
+
+    small_unique_ptr<const Base> base;
+
+    base = make_unique_small<SmallDerived>();
+    REQUIRE(base->value() == 32);
+
+    base = make_unique_small<LargeDerived>();
+    REQUIRE(base->value() == 64);
+
+    base = nullptr;
+    REQUIRE(!base);
+}
+
+TEST_CASE("swap_large", "[small_unique_ptr]")
+{
+    small_unique_ptr<Base> p1 = nullptr;
+    small_unique_ptr<Base> p2 = make_unique_small<LargeDerived>();
+
+    using std::swap;
+    swap(p1, p2);
+
+    REQUIRE(p2 == nullptr);
+    REQUIRE(p1->value() == 64);
+}
+
+TEST_CASE("swap_mixed", "[small_unique_ptr]")
+{
+    using std::swap;
+
+    small_unique_ptr<Base> p1 = make_unique_small<SmallDerived>();
+    small_unique_ptr<Base> p2 = make_unique_small<LargeDerived>();
+
+    REQUIRE(p1->value() == 32);
+    REQUIRE(p2->value() == 64);
+
+    swap(p1, p2);
+
+    REQUIRE(p1->value() == 64);
+    REQUIRE(p2->value() == 32);
+
+    swap(p1, p2);
+
+    REQUIRE(p1->value() == 32);
+    REQUIRE(p2->value() == 64);
+}
+
+TEST_CASE("swap_small", "[small_unique_ptr]")
+{
+    small_unique_ptr<Base> p1 = make_unique_small<SmallDerived>(1);
+    small_unique_ptr<Base> p2 = make_unique_small<SmallDerived>(2);
+
+    using std::swap;
+    swap(p1, p2);
+
+    REQUIRE(p1->value() == 2);
+    REQUIRE(p2->value() == 1);
+
+    swap(p1, p2);
+
+    REQUIRE(p1->value() == 1);
+    REQUIRE(p2->value() == 2);
+}
+
+TEST_CASE("swap_constexpr", "[small_unique_ptr]")
+{
+    using std::swap;
+
+    STATIC_REQUIRE(32 == std::invoke([]
+    {
+        small_unique_ptr<Base> p1 = make_unique_small<SmallDerived>();
+        small_unique_ptr<Base> p2 = make_unique_small<LargeDerived>();
+
+        swap(p1, p2);
+
+        return p2->padding();
+    }));
+
+    STATIC_REQUIRE(32 == std::invoke([]
+    {
+        small_unique_ptr<Base> p1 = make_unique_small<SmallDerived>();
+        small_unique_ptr<Base> p2 = make_unique_small<SmallDerived>();
+
+        swap(p1, p2);
+
+        return p2->padding();
+    }));
+
+    STATIC_REQUIRE(64 == std::invoke([]
+    {
+        small_unique_ptr<Base> p1 = make_unique_small<LargeDerived>();
+        small_unique_ptr<Base> p2 = make_unique_small<LargeDerived>();
+
+        swap(p1, p2);
+
+        return p2->padding();
+    }));
+}
+
+
+struct VBase
+{
+    int n = -1;
+    virtual int value() const = 0;
+    virtual ~VBase() = default;
+};
+
+struct A : virtual VBase { int a = 0; int value() const override { return a; } };
+struct B : virtual VBase { int b = 1; int value() const override { return b; } };
+struct C : virtual VBase { int c = 2; int value() const override { return c; } };
+struct D : virtual VBase { int d = 3; int value() const override { return d; } };
+struct E : A, B { int e = 4; int value() const override { return e; } };
+struct F : C, D { int f = 5; int value() const override { return f; } };
+struct G : E, F { int g = 6; int value() const override { return g; } };
+
+
+TEST_CASE("move_construct_multi", "[small_unique_ptr]")
+{
+    small_unique_ptr<F> leaf = make_unique_small<G>();
+    REQUIRE(leaf->value() == 6);
+
+    small_unique_ptr<D> derived = std::move(leaf);
+    REQUIRE(derived->value() == 6);
+
+    small_unique_ptr<VBase> base = std::move(derived);
+    REQUIRE(base->value() == 6);
+
+    small_unique_ptr<const VBase> cbase = std::move(base);
+    REQUIRE(cbase->value() == 6);
+}
+
+TEST_CASE("move_assignment_multi", "[small_unique_ptr]")
+{
+    small_unique_ptr<B> p1;
+
+    p1 = make_unique_small<B>();
+    REQUIRE(p1->value() == 1);
+
+    p1 = make_unique_small<G>();
+    REQUIRE(p1->value() == 6);
+
+    p1 = make_unique_small<E>();
+    REQUIRE(p1->value() == 4);
+
+    p1 = make_unique_small<B>();
+    REQUIRE(p1->value() == 1);
+}