diff --git a/src-test/common/AnyFnTest.cpp b/src-test/common/AnyFnTest.cpp
new file mode 100644
index 0000000000..960e765c0c
--- /dev/null
+++ b/src-test/common/AnyFnTest.cpp
@@ -0,0 +1,24 @@
+#include "ll/core/LeviLamina.h"
+
+#include "ll/api/data/AnyFunction.h"
+
+static bool run = [] {
+    using ll::data::AnyFunction;
+
+
+    auto fn = AnyFunction([](std::string const& par, int i, std::vector<float>&& fs) {
+        ll::getLogger().warn("{}, {}, {}", par, i, fs);
+    });
+
+    fn(std::string{"emmmmm"}, 10, std::vector<float>{0.2f, 0.2f, 0.2f});
+
+    auto vec = std::vector<float>{0.7f, 0.7f, 0.7f};
+
+    fn = AnyFunction([](std::string const& par, int i, std::vector<float>&& fs) {
+        ll::getLogger().info("{} | {} | {}", par, i, fs);
+    });
+
+    fn(std::string{"hmmmmm"}, 17, std::ref(vec));
+
+    return true;
+}();
diff --git a/src/ll/api/base/Concepts.h b/src/ll/api/base/Concepts.h
index 54efa90217..ff0ee2bd62 100644
--- a/src/ll/api/base/Concepts.h
+++ b/src/ll/api/base/Concepts.h
@@ -2,56 +2,28 @@
 
 #include <string>
 #include <tuple>
-#include <type_traits>
 #include <utility>
 
 #include "ll/api/base/Macro.h"
 #include "ll/api/base/StdInt.h"
+#include "ll/api/base/TypeTraits.h"
 
 namespace ll::concepts {
 
 template <class T, class U>
-struct is_in_types;
-
-template <class T, template <class...> class U, class... Ts>
-struct is_in_types<T, U<Ts...>> : std::bool_constant<(std::is_same_v<T, Ts> || ...)> {};
-
-template <class T, class U>
-inline constexpr bool is_in_types_v = is_in_types<T, U>::value;
-
-template <class T, class U>
-concept IsInTypes = is_in_types_v<T, U>;
-
-template <class T, class... Ts>
-inline constexpr bool is_one_of_v = (std::is_same_v<T, Ts> || ...);
-
-template <class T, class... Ts>
-struct is_one_of : std::bool_constant<is_one_of_v<T, Ts...>> {};
+concept IsInTypes = traits::is_in_types_v<T, U>;
 
 template <class T, class... Ts>
-concept IsOneOf = is_one_of_v<T, Ts...>;
+concept IsOneOf = traits::is_one_of_v<T, Ts...>;
 
 template <class T, class... Ts>
-inline constexpr bool is_all_same_v = (std::is_same_v<T, Ts> && ...);
-
-template <class T, class... Ts>
-struct is_all_same : std::bool_constant<is_all_same_v<T, Ts...>> {};
-
-template <class T, class... Ts>
-concept IsAllSame = is_all_same_v<T, Ts...>;
-
-template <class T>
-inline constexpr bool is_string_v = std::is_constructible_v<std::string, T>;
-
-template <class T>
-inline constexpr bool is_non_char_integral_v =
-    is_one_of_v<std::remove_cv_t<T>, bool, schar, uchar, short, ushort, int, uint, long, ulong, int64, uint64>;
+concept IsAllSame = traits::is_all_same_v<T, Ts...>;
 
 template <class T>
-concept IsNonCharIntegral = is_non_char_integral_v<T>;
+concept IsNonCharIntegral = traits::is_non_char_integral_v<T>;
 
 template <class T>
-concept IsString = is_string_v<T>;
+concept IsString = traits::is_string_v<T>;
 
 template <class T, template <class> class Z>
 concept Require = Z<T>::value;
@@ -100,32 +72,12 @@ template <typename T>
 concept IsVectorBase = std::is_base_of_v<VectorBaseTag, T>;
 
 template <class T, template <class...> class Z>
-inline constexpr bool is_specialization_of_v = false;
-
-template <template <class...> class Z, class... Args>
-inline constexpr bool is_specialization_of_v<Z<Args...>, Z> = true;
-
-template <class T, template <class...> class Z>
-struct is_specialization_of : std::bool_constant<is_specialization_of_v<T, Z>> {};
-
-template <class T, template <class...> class Z>
-concept Specializes = is_specialization_of_v<T, Z>;
-
-template <class>
-inline constexpr bool is_std_array_v = false;
-
-template <class T, size_t N>
-inline constexpr bool is_std_array_v<::std::array<T, N>> = true;
-
-template <class>
-inline constexpr bool is_subrange_v = false;
-
-template <class I, class S, ::std::ranges::subrange_kind K>
-constexpr bool is_subrange_v<::std::ranges::subrange<I, S, K>> = true;
+concept Specializes = traits::is_specialization_of_v<T, Z>;
 
 template <class T>
-inline constexpr bool tuple_like_impl = is_specialization_of_v<T, ::std::tuple>
-                                     || is_specialization_of_v<T, ::std::pair> || is_std_array_v<T> || is_subrange_v<T>;
+inline constexpr bool tuple_like_impl =
+    traits::is_specialization_of_v<T, ::std::tuple> || traits::is_specialization_of_v<T, ::std::pair>
+    || traits::is_std_array_v<T> || traits::is_subrange_v<T>;
 
 template <class T>
 concept TupleLike = tuple_like_impl<std::remove_cvref_t<T>> || (!Rangeable<T> && requires(T t) {
@@ -136,27 +88,11 @@ concept TupleLike = tuple_like_impl<std::remove_cvref_t<T>> || (!Rangeable<T> &&
 template <class T>
 concept ArrayLike = Rangeable<T> && !requires { typename std::remove_cvref_t<T>::mapped_type; };
 
-template <template <class...> class T, class... Ts>
-void DerivedFromSpecializationImpl(T<Ts...> const&);
-
-template <class T, template <class...> class Z>
-concept DerivedFromSpecializes = requires(T const& t) { DerivedFromSpecializationImpl<Z>(t); };
-
-template <class T, template <class...> class Z>
-inline constexpr bool is_derived_from_specialization_of_v = DerivedFromSpecializes<T, Z>;
-
 template <class T, template <class...> class Z>
-struct is_derived_from_specialization_of : std::bool_constant<is_derived_from_specialization_of_v<T, Z>> {};
-
-template <class...>
-inline constexpr bool always_false = false;
-
-template <class T>
-inline constexpr bool is_virtual_cloneable_v =
-    std::is_polymorphic_v<T> && requires(T const& t) { static_cast<T*>(t.clone().release()); };
+concept DerivedFromSpecializes = traits::is_derived_from_specialization_of_v<T, Z>;
 
 template <class T>
-concept VirtualCloneable = is_virtual_cloneable_v<T>;
+concept VirtualCloneable = traits::is_virtual_cloneable_v<T>;
 
 template <class T>
 concept Stringable = requires(T t) {
diff --git a/src/ll/api/base/Containers.h b/src/ll/api/base/Containers.h
index 9c044805e9..e286226c65 100644
--- a/src/ll/api/base/Containers.h
+++ b/src/ll/api/base/Containers.h
@@ -120,7 +120,7 @@ using Indirect = data::IndirectValue<T, data::defaultCopy<T>, D>;
 template <
     class T,
     class C =
-        std::conditional_t<concepts::is_virtual_cloneable_v<T>, data::virtualCloneCopy<T>, data::polymorphicCopy<T>>,
+        std::conditional_t<traits::is_virtual_cloneable_v<T>, data::virtualCloneCopy<T>, data::polymorphicCopy<T>>,
     class D = std::default_delete<T>>
 using Polymorphic = data::IndirectValue<T, C, D>;
 
diff --git a/src/ll/api/base/Meta.h b/src/ll/api/base/Meta.h
index 0422bae1df..4a928fffff 100644
--- a/src/ll/api/base/Meta.h
+++ b/src/ll/api/base/Meta.h
@@ -1,13 +1,13 @@
 #pragma once
 
 #include <cstddef>
-#include <type_traits>
 #include <utility>
 
 #include "ll/api/base/CompilerPredefine.h"
 #include "ll/api/base/Concepts.h"
 #include "ll/api/base/Macro.h"
 #include "ll/api/base/StdInt.h"
+#include "ll/api/base/TypeTraits.h"
 
 namespace ll::meta {
 namespace detail {
@@ -22,7 +22,7 @@ struct VisitStrategy;
 template <size_t N>
 struct VisitStrategy<N, -1> {
     // Fallback strategy for visitations with too many total states for the following "switch" strategies.
-    template <typename T, typename... Ts>
+    template <class T, class... Ts>
     static constexpr std::array<std::decay_t<T>, sizeof...(Ts) + 1> makeVisitorArray(T&& t, Ts&&... ts) {
         return {
             {std::forward<T>(t), std::forward<Ts>(ts)...}
@@ -198,38 +198,6 @@ constexpr Ret visitIndex(size_t index, Fn&& fn, Args&&... args) {
     return Strategy::template impl<Ret>(index, std::forward<Fn>(fn), std::forward<Args>(args)...);
 }
 
-template <size_t N, class T, class... Types>
-struct get_type {
-    using type = typename get_type<N - 1, Types...>::type;
-};
-
-template <class T, class... Types>
-struct get_type<0, T, Types...> {
-    using type = T;
-};
-
-template <size_t N, class... Types>
-using get_type_t = typename get_type<N, Types...>::type;
-
-template <class T, class U, class... Args>
-struct max_type {
-    using type = typename max_type<T, typename max_type<U, Args...>::type>::type;
-};
-
-template <class T, class U>
-struct max_type<T, U> {
-    using type = typename std::conditional<(sizeof(T) < sizeof(U)), U, T>::type;
-};
-
-template <class T, class... Ts>
-struct index_of;
-
-template <class T, class... Ts>
-struct index_of<T, T, Ts...> : std::integral_constant<size_t, 0> {};
-
-template <class T, class U, class... Ts>
-struct index_of<T, U, Ts...> : std::integral_constant<size_t, 1 + index_of<T, Ts...>::value> {};
-
 template <class... TL>
 class TypeList {
 public:
@@ -257,7 +225,7 @@ class TypeList {
     using push_front = TypeList<T, TL...>;
 
     template <size_t N>
-    using get = get_type_t<N + 1, void, TL...>;
+    using get = traits::get_type_t<N + 1, void, TL...>;
 
     template <template <class...> class U>
     using to = U<TL...>;
@@ -273,7 +241,7 @@ class TypeList {
     }
 
     template <class T>
-    static constexpr size_t index = index_of<T, TL...>::value;
+    static constexpr size_t index = traits::index_of<T, TL...>::value;
 };
 
 template <class Group, class T, auto Id = int64{}>
diff --git a/src/ll/api/base/ToString.h b/src/ll/api/base/ToString.h
index 7541e085de..c9200a2f78 100644
--- a/src/ll/api/base/ToString.h
+++ b/src/ll/api/base/ToString.h
@@ -18,7 +18,7 @@ std::string to_string(T const& t) {
     } else if constexpr (requires { t.to_string(); }) {
         return t.to_string();
     } else {
-        static_assert(ll::concepts::always_false<T>, "T must be a stringable type");
+        static_assert(ll::traits::always_false<T>, "T must be a stringable type");
     }
 }
 
diff --git a/src/ll/api/base/TypeTraits.h b/src/ll/api/base/TypeTraits.h
new file mode 100644
index 0000000000..6c75bb547c
--- /dev/null
+++ b/src/ll/api/base/TypeTraits.h
@@ -0,0 +1,156 @@
+#pragma once
+
+#include <array>
+#include <type_traits>
+#include <utility>
+
+namespace ll::traits {
+
+template <size_t N, class T, class... Types>
+struct get_type {
+    using type = typename get_type<N - 1, Types...>::type;
+};
+
+template <class T, class... Types>
+struct get_type<0, T, Types...> {
+    using type = T;
+};
+
+template <size_t N, class... Types>
+using get_type_t = typename get_type<N, Types...>::type;
+
+template <class T, class U, class... Args>
+struct max_type {
+    using type = typename max_type<T, typename max_type<U, Args...>::type>::type;
+};
+
+template <class T, class U>
+struct max_type<T, U> {
+    using type = typename std::conditional<(sizeof(T) < sizeof(U)), U, T>::type;
+};
+
+template <class T, class... Ts>
+struct index_of;
+
+template <class T, class... Ts>
+struct index_of<T, T, Ts...> : std::integral_constant<size_t, 0> {};
+
+template <class T, class U, class... Ts>
+struct index_of<T, U, Ts...> : std::integral_constant<size_t, 1 + index_of<T, Ts...>::value> {};
+
+
+template <class>
+struct function_signature;
+
+template <class Ret, class... Args>
+struct function_signature<Ret(Args...)> {
+    using type = Ret(Args...);
+};
+
+template <class Ret, class... Args>
+struct function_signature<Ret (*)(Args...)> : function_signature<Ret(Args...)> {};
+
+template <class F>
+struct function_signature : function_signature<decltype(&F::operator())> {};
+
+#define LL_BUILD_FUNCTOR_FUNCTION_SIGNATURE(...)                                                                       \
+    template <class Ret, class Cls, class... Args>                                                                     \
+    struct function_signature<Ret (Cls::*)(Args...) __VA_ARGS__> : function_signature<Ret(Args...)> {};
+LL_BUILD_FUNCTOR_FUNCTION_SIGNATURE()
+LL_BUILD_FUNCTOR_FUNCTION_SIGNATURE(const)
+LL_BUILD_FUNCTOR_FUNCTION_SIGNATURE(volatile)
+LL_BUILD_FUNCTOR_FUNCTION_SIGNATURE(const volatile)
+LL_BUILD_FUNCTOR_FUNCTION_SIGNATURE(noexcept)
+LL_BUILD_FUNCTOR_FUNCTION_SIGNATURE(const noexcept)
+LL_BUILD_FUNCTOR_FUNCTION_SIGNATURE(volatile noexcept)
+LL_BUILD_FUNCTOR_FUNCTION_SIGNATURE(const volatile noexcept)
+LL_BUILD_FUNCTOR_FUNCTION_SIGNATURE(&)
+LL_BUILD_FUNCTOR_FUNCTION_SIGNATURE(const&)
+LL_BUILD_FUNCTOR_FUNCTION_SIGNATURE(volatile&)
+LL_BUILD_FUNCTOR_FUNCTION_SIGNATURE(const volatile&)
+LL_BUILD_FUNCTOR_FUNCTION_SIGNATURE(& noexcept)
+LL_BUILD_FUNCTOR_FUNCTION_SIGNATURE(const& noexcept)
+LL_BUILD_FUNCTOR_FUNCTION_SIGNATURE(volatile& noexcept)
+LL_BUILD_FUNCTOR_FUNCTION_SIGNATURE(const volatile& noexcept)
+LL_BUILD_FUNCTOR_FUNCTION_SIGNATURE(&&)
+LL_BUILD_FUNCTOR_FUNCTION_SIGNATURE(const&&)
+LL_BUILD_FUNCTOR_FUNCTION_SIGNATURE(volatile&&)
+LL_BUILD_FUNCTOR_FUNCTION_SIGNATURE(const volatile&&)
+LL_BUILD_FUNCTOR_FUNCTION_SIGNATURE(&& noexcept)
+LL_BUILD_FUNCTOR_FUNCTION_SIGNATURE(const&& noexcept)
+LL_BUILD_FUNCTOR_FUNCTION_SIGNATURE(volatile&& noexcept)
+LL_BUILD_FUNCTOR_FUNCTION_SIGNATURE(const volatile&& noexcept)
+#undef LL_BUILD_FUNCTOR_FUNCTION_SIGNATURE
+
+template <class T>
+using function_signature_t = typename function_signature<T>::type;
+
+template <class T, class U>
+struct is_in_types;
+
+template <class T, template <class...> class U, class... Ts>
+struct is_in_types<T, U<Ts...>> : std::bool_constant<(std::is_same_v<T, Ts> || ...)> {};
+
+template <class T, class U>
+inline constexpr bool is_in_types_v = is_in_types<T, U>::value;
+
+template <class T, class... Ts>
+inline constexpr bool is_one_of_v = (std::is_same_v<T, Ts> || ...);
+
+template <class T, class... Ts>
+struct is_one_of : std::bool_constant<is_one_of_v<T, Ts...>> {};
+
+template <class T, class... Ts>
+inline constexpr bool is_all_same_v = (std::is_same_v<T, Ts> && ...);
+
+template <class T, class... Ts>
+struct is_all_same : std::bool_constant<is_all_same_v<T, Ts...>> {};
+
+template <class T>
+inline constexpr bool is_string_v = std::is_constructible_v<std::string, T>;
+
+template <class T>
+inline constexpr bool is_char_v = is_one_of_v<T, char, wchar_t, char8_t, char16_t, char32_t>;
+
+template <class T>
+inline constexpr bool is_non_char_integral_v = std::is_integral_v<T> && !is_char_v<T>;
+
+template <class T, template <class...> class Z>
+inline constexpr bool is_specialization_of_v = false;
+
+template <template <class...> class Z, class... Args>
+inline constexpr bool is_specialization_of_v<Z<Args...>, Z> = true;
+
+template <class T, template <class...> class Z>
+struct is_specialization_of : std::bool_constant<is_specialization_of_v<T, Z>> {};
+
+template <class>
+inline constexpr bool is_std_array_v = false;
+
+template <class T, size_t N>
+inline constexpr bool is_std_array_v<::std::array<T, N>> = true;
+
+template <class>
+inline constexpr bool is_subrange_v = false;
+
+template <class I, class S, ::std::ranges::subrange_kind K>
+constexpr bool is_subrange_v<::std::ranges::subrange<I, S, K>> = true;
+
+template <template <class...> class T, class... Ts>
+void derivedFromSpecializationImpl(T<Ts...> const&);
+
+template <class T, template <class...> class Z>
+inline constexpr bool is_derived_from_specialization_of_v =
+    requires(T const& t) { derivedFromSpecializationImpl<Z>(t); };
+
+template <class T, template <class...> class Z>
+struct is_derived_from_specialization_of : std::bool_constant<is_derived_from_specialization_of_v<T, Z>> {};
+
+template <class...>
+inline constexpr bool always_false = false;
+
+template <class T>
+inline constexpr bool is_virtual_cloneable_v =
+    std::is_polymorphic_v<T> && requires(T const& t) { static_cast<T*>(t.clone().release()); };
+
+} // namespace ll::traits
diff --git a/src/ll/api/command/Overload.h b/src/ll/api/command/Overload.h
index ed696cd22b..40049c7855 100644
--- a/src/ll/api/command/Overload.h
+++ b/src/ll/api/command/Overload.h
@@ -46,13 +46,13 @@ class Overload : private OverloadData {
             using RemoveOptionalType = remove_optional_t<OriginalType>;
 
             using ParamType = std::conditional_t<
-                concepts::is_specialization_of_v<RemoveOptionalType, SoftEnum>,
+                traits::is_specialization_of_v<RemoveOptionalType, SoftEnum>,
                 std::string,
                 RemoveOptionalType>;
 
             int offset     = (int)(size_t)std::addressof(val);
             int flagOffset = -1;
-            if constexpr (concepts::is_specialization_of_v<OriginalType, Optional>) {
+            if constexpr (traits::is_specialization_of_v<OriginalType, Optional>) {
                 flagOffset = offset + OptionalOffsetGetter<ParamType>::value;
             }
 
@@ -60,7 +60,7 @@ class Overload : private OverloadData {
             if constexpr (std::is_enum_v<ParamType>) {
                 paramType = CommandParameterDataType::Enum;
                 CommandRegistrar::getInstance().template tryRegisterEnum<ParamType>();
-            } else if constexpr (concepts::is_specialization_of_v<RemoveOptionalType, SoftEnum>) {
+            } else if constexpr (traits::is_specialization_of_v<RemoveOptionalType, SoftEnum>) {
                 paramType = CommandParameterDataType::SoftEnum;
                 CommandRegistrar::getInstance().template tryRegisterSoftEnum<RemoveOptionalType>();
             }
diff --git a/src/ll/api/data/AnyFunction.h b/src/ll/api/data/AnyFunction.h
index 67ec7f573a..c35072a88e 100644
--- a/src/ll/api/data/AnyFunction.h
+++ b/src/ll/api/data/AnyFunction.h
@@ -2,32 +2,93 @@
 
 #include <any>
 #include <array>
+#include <functional>
 #include <span>
 
 #include "ll/api/base/Containers.h"
 #include "ll/api/base/Macro.h"
+#include "ll/api/base/Meta.h"
 
 namespace ll::data {
-class AnyInvokerBase {
+class AnyFunctionDataBase {
+protected:
+    template <class Arg>
+    static auto getArg(std::any& any
+    ) -> std::conditional_t<std::is_reference_v<Arg>, Arg, std::add_lvalue_reference_t<Arg>> {
+        using Ret   = std::conditional_t<std::is_reference_v<Arg>, Arg, std::add_lvalue_reference_t<Arg>>;
+        using Decay = std::decay_t<Arg>;
+        using Wrap  = std::remove_cvref_t<Arg>;
+        if constexpr (std::is_const_v<std::remove_reference_t<Arg>>) {
+            if (auto* res = std::any_cast<std::reference_wrapper<std::add_const_t<Wrap>>>(&any)) {
+                return static_cast<Ret>(res->get());
+            }
+        }
+        if (auto* res = std::any_cast<std::reference_wrapper<Wrap>>(&any)) {
+            return static_cast<Ret>(res->get());
+        }
+        return static_cast<Ret>(std::any_cast<std::add_lvalue_reference_t<std::decay_t<Arg>>>(any));
+    }
+
 public:
-    virtual ~AnyInvokerBase() = default;
+    virtual ~AnyFunctionDataBase() = default;
 
-    virtual std::any invoke(std::span<std::any const>) = 0;
+    virtual std::any invoke(std::span<std::any>) = 0;
 
-    virtual std::unique_ptr<AnyInvokerBase> clone() const = 0;
+    virtual std::unique_ptr<AnyFunctionDataBase> clone() const = 0;
+};
+template <class Fn, class Ret, class... Args>
+class AnyFunctionData : public AnyFunctionDataBase {
+    Fn fn;
+
+    template <std::size_t... I>
+    std::any invokeImpl(std::span<std::any> args, std::index_sequence<I...>) {
+        if constexpr (std::is_void_v<Ret>) {
+            (void)fn(getArg<Args>(args[I])...);
+            return {};
+        } else {
+            return std::make_any<Ret>(fn(getArg<Args>(args[I])...));
+        }
+    }
+
+public:
+    AnyFunctionData(Fn fn) : fn(std::move(fn)) {}
+
+    ~AnyFunctionData() override = default;
+
+    std::any invoke(std::span<std::any> args) override { return invokeImpl(args, std::index_sequence_for<Args...>{}); }
+
+    std::unique_ptr<AnyFunctionDataBase> clone() const override { return std::make_unique<AnyFunctionData>(*this); }
 };
 class AnyFunction {
-    mutable Polymorphic<AnyInvokerBase> invoker;
+    mutable Polymorphic<AnyFunctionDataBase> data;
 
 public:
     AnyFunction()  = default;
     ~AnyFunction() = default;
 
-    std::any invoke(std::span<std::any const> args) const { return invoker->invoke(args); }
+    AnyFunction(std::nullptr_t) {}
+
+    template <class Ret, class... Args>
+    AnyFunction(std::function<Ret(Args...)> fn)
+    : data(makePolymorphic<AnyFunctionData<std::function<Ret(Args...)>, Ret, Args...>>(std::move(fn))) {}
+
+    template <class Fn, class Ret, class... Args>
+    AnyFunction(std::in_place_type_t<Ret(Args...)>, Fn&& fn)
+    : data(makePolymorphic<AnyFunctionData<std::decay_t<Fn>, Ret, Args...>>(std::forward<Fn>(fn))) {}
+
+    template <class Fn>
+    AnyFunction(Fn&& fn)
+    : AnyFunction(std::in_place_type<traits::function_signature_t<std::remove_cvref_t<Fn>>>, std::forward<Fn>(fn)) {}
+
+    std::any invoke(std::span<std::any> args) const { return data->invoke(args); }
 
     template <class... Args>
     std::any operator()(Args&&... args) const {
-        return invoke(std::initializer_list{std::make_any<std::decay_t<Args>>(std::forward<Args>(args))...});
+        auto arr =
+            std::array<std::any, sizeof...(Args)>{std::make_any<std::decay_t<Args>>(std::forward<Args>(args))...};
+        return invoke(arr);
     }
+
+    explicit operator bool() const noexcept { return static_cast<bool>(data); }
 };
 } // namespace ll::data
diff --git a/src/ll/api/data/IndirectValue.h b/src/ll/api/data/IndirectValue.h
index 05ddf759db..53f05a4ab6 100644
--- a/src/ll/api/data/IndirectValue.h
+++ b/src/ll/api/data/IndirectValue.h
@@ -95,7 +95,7 @@ class IndirectValue {
     : storage(oneThenVariadicArgs, other.getCopyCtor(), other.clone()) {}
 
     template <class U, class C2, class D2>
-        requires(std::is_convertible_v<U*, T*> && std::is_constructible_v<CopyCtor, C2 const&>)
+        requires(std::is_convertible_v<U*, T*>)
     constexpr IndirectValue(IndirectValue<U, C2, D2> const& other) noexcept(std::is_nothrow_copy_constructible_v<U>)
     : storage(oneThenVariadicArgs, other.getCopyCtor(), other.clone()) {}
 
@@ -103,7 +103,7 @@ class IndirectValue {
     : storage(oneThenVariadicArgs, std::move(other.getCopyCtor()), std::move(other.unique())) {}
 
     template <class U, class C2, class D2>
-        requires(std::is_convertible_v<U*, T*> && std::is_constructible_v<CopyCtor, C2 &&>)
+        requires(std::is_convertible_v<U*, T*>)
     constexpr IndirectValue(IndirectValue<U, C2, D2>&& other) noexcept
     : storage(oneThenVariadicArgs, std::move(other.getCopyCtor()), std::move(other.unique())) {}
 
@@ -116,7 +116,7 @@ class IndirectValue {
         return *this;
     }
     template <class U, class C2, class D2>
-        requires(std::is_convertible_v<U*, T*> && std::is_constructible_v<CopyCtor, C2 const&>)
+        requires(std::is_convertible_v<U*, T*>)
     constexpr IndirectValue& operator=(IndirectValue<U, C2, D2> const& other
     ) noexcept(std::is_nothrow_copy_constructible_v<U>) {
         if constexpr (std::is_same_v<U, T>) {
@@ -138,7 +138,7 @@ class IndirectValue {
         return *this;
     }
     template <class U, class C2, class D2>
-        requires(std::is_convertible_v<U*, T*> && std::is_constructible_v<CopyCtor, C2 const&>)
+        requires(std::is_convertible_v<U*, T*>)
     constexpr IndirectValue& operator=(IndirectValue<U, C2, D2>&& other) noexcept {
         if constexpr (std::is_same_v<U, T>) {
             if (std::addressof(other) == this) {
diff --git a/src/ll/api/event/Cancellable.h b/src/ll/api/event/Cancellable.h
index 176b08b5f2..b9f29701f4 100644
--- a/src/ll/api/event/Cancellable.h
+++ b/src/ll/api/event/Cancellable.h
@@ -10,7 +10,7 @@ class Cancellable : public T {
     using T::T;
 
     static_assert(
-        !concepts::is_derived_from_specialization_of_v<T, Cancellable>,
+        !traits::is_derived_from_specialization_of_v<T, Cancellable>,
         "can't be derived from Cancellable twice"
     );
 
diff --git a/src/ll/api/memory/Hook.h b/src/ll/api/memory/Hook.h
index 140d2e51ea..d1cbac5602 100644
--- a/src/ll/api/memory/Hook.h
+++ b/src/ll/api/memory/Hook.h
@@ -159,7 +159,7 @@ struct LL_EBO Hook {};
             if constexpr (requires { ::ll::memory::virtualDetector<T, IDENTIFIER>(); }) {                              \
                 if constexpr (::ll::memory::virtualDetector<T, IDENTIFIER>()) {                                        \
                     static_assert(                                                                                     \
-                        ::ll::concepts::always_false<T>,                                                               \
+                        ::ll::traits::always_false<T>,                                                               \
                         #IDENTIFIER " is a virtual function, you need use prefix $ workaround to hook it."             \
                     );                                                                                                 \
                 }                                                                                                      \
diff --git a/src/ll/api/reflection/Deserialization.h b/src/ll/api/reflection/Deserialization.h
index 3512d2fb46..5ca89bbb7d 100644
--- a/src/ll/api/reflection/Deserialization.h
+++ b/src/ll/api/reflection/Deserialization.h
@@ -181,7 +181,7 @@ inline Expected<> deserialize_impl(T& obj, J const& j, meta::PriorityTag<1>) {
                 res = deserialize<member_type>(member, j[sname]);
                 if (!res) res = makeSerMemberError(sname, res.error());
             } else {
-                static_assert(concepts::always_false<member_type>, "this type can't deserialize");
+                static_assert(traits::always_false<member_type>, "this type can't deserialize");
             }
         } else {
             if constexpr (!concepts::IsOptional<member_type>) {
diff --git a/src/ll/api/reflection/Serialization.h b/src/ll/api/reflection/Serialization.h
index d2eaf1b70e..a2d3b4f5ae 100644
--- a/src/ll/api/reflection/Serialization.h
+++ b/src/ll/api/reflection/Serialization.h
@@ -187,7 +187,7 @@ inline Expected<J> serialize_impl(T&& obj, meta::PriorityTag<1>)
                 res = makeSerMemberError(std::string{name}, v.error());
             }
         } else {
-            static_assert(concepts::always_false<member_type>, "this type can't serialize");
+            static_assert(traits::always_false<member_type>, "this type can't serialize");
         }
     });
     return res;
diff --git a/src/ll/api/service/ServiceId.h b/src/ll/api/service/ServiceId.h
index 58a876a3db..f3e5973f82 100644
--- a/src/ll/api/service/ServiceId.h
+++ b/src/ll/api/service/ServiceId.h
@@ -48,7 +48,7 @@ constexpr ServiceId getServiceId = []() -> ServiceId {
     if constexpr (requires { self::ServiceId; } && self::ServiceId != EmptyServiceId) {
         return self::ServiceId;
     } else {
-        static_assert(ll::concepts::always_false<T>, "ServiceId not defined for type");
+        static_assert(traits::always_false<T>, "ServiceId not defined for type");
     }
 }();
 } // namespace ll::service
diff --git a/src/ll/api/thread/TaskExecuter.h b/src/ll/api/thread/TaskExecuter.h
index 4d9ead7388..f876c11134 100644
--- a/src/ll/api/thread/TaskExecuter.h
+++ b/src/ll/api/thread/TaskExecuter.h
@@ -10,7 +10,6 @@ class TaskExecuter {
 public:
     virtual ~TaskExecuter() = default;
 
-public:
     virtual void addTask(std::function<void()>) = 0;
 
     template <class F, class... Args>
diff --git a/src/mc/math/vector/base/VectorBase.h b/src/mc/math/vector/base/VectorBase.h
index 2010f60848..3008b74220 100644
--- a/src/mc/math/vector/base/VectorBase.h
+++ b/src/mc/math/vector/base/VectorBase.h
@@ -49,7 +49,7 @@ class boolN;
 
 template <typename T, typename... Components>
 struct LL_EBO VectorBase : concepts::VectorBaseTag {
-    using first_type = typename ll::meta::max_type<Components...>::type;
+    using first_type = typename ll::traits::max_type<Components...>::type;
 
     using size_type = size_t;