diff --git a/develop/unbench/cast_function_bench.cpp b/develop/unbench/cast_function_bench.cpp
new file mode 100644
index 0000000..6dc0d8d
--- /dev/null
+++ b/develop/unbench/cast_function_bench.cpp
@@ -0,0 +1,292 @@
+/*******************************************************************************
+ * This file is part of the "https://github.com/blackmatov/meta.hpp"
+ * For conditions of distribution and use, see copyright notice in LICENSE.md
+ * Copyright (C) 2021-2023, by Matvey Cherevko (blackmatov@gmail.com)
+ ******************************************************************************/
+
+#include <meta.hpp/meta_all.hpp>
+#include <vmath.hpp/vmath_all.hpp>
+
+#include <rttr/type>
+#include <rttr/registration>
+
+#include <benchmark/benchmark.h>
+
+namespace
+{
+    namespace meta = meta_hpp;
+    namespace vmath = vmath_hpp;
+
+    volatile unsigned static_acc{};
+
+    struct base1 {
+        unsigned b1{1};
+
+        base1() = default;
+        virtual ~base1() = default;
+
+        base1(const base1&) = default;
+        base1& operator=(const base1&) = default;
+
+        RTTR_ENABLE()
+    };
+
+    struct base2 : base1 {
+        unsigned b2{2};
+        RTTR_ENABLE(base1)
+    };
+
+    struct base3 : base2 {
+        unsigned b3{3};
+        RTTR_ENABLE(base2)
+    };
+
+    struct base4 : base3 {
+        unsigned b4{4};
+        RTTR_ENABLE(base3)
+    };
+
+    unsigned static_function_1(base1* b1) {
+        unsigned r = b1->b1;
+        static_acc = static_acc + r;
+        return r;
+    }
+
+    unsigned static_function_2(base1* b1, base2* b2) {
+        unsigned r = b1->b1 + b2->b2;
+        static_acc = static_acc + r;
+        return r;
+    }
+
+    unsigned static_function_3(base1* b1, base2* b2, base3* b3) {
+        unsigned r = b1->b1 + b2->b2 + b3->b3;
+        static_acc = static_acc + r;
+        return r;
+    }
+
+    unsigned static_function_4(base1* b1, base2* b2, base3* b3, base4* b4) {
+        unsigned r = b1->b1 + b2->b2 + b3->b3 + b4->b4;
+        static_acc = static_acc + r;
+        return r;
+    }
+
+    [[maybe_unused]]
+    void static_function_reset(const benchmark::State&) {
+        static_acc = 0;
+    }
+
+    const bool registered = [](){
+        meta::class_<base1>();
+        meta::class_<base2>().base_<base1>();
+        meta::class_<base3>().base_<base2>();
+        meta::class_<base4>().base_<base3>();
+        return true;
+    }();
+
+    meta::scope meta_bench_scope = meta::local_scope_("")
+        .function_("cast_function_1", &static_function_1)
+        .function_("cast_function_2", &static_function_2)
+        .function_("cast_function_3", &static_function_3)
+        .function_("cast_function_4", &static_function_4);
+}
+
+RTTR_REGISTRATION
+{
+    using namespace rttr;
+
+    registration::method("cast_function_1", &static_function_1);
+    registration::method("cast_function_2", &static_function_2);
+    registration::method("cast_function_3", &static_function_3);
+    registration::method("cast_function_4", &static_function_4);
+}
+
+//
+// native
+//
+
+namespace
+{
+    [[maybe_unused]]
+    void cast_function_1(benchmark::State &state) {
+        base4 b4;
+        for ( auto _ : state ) {
+            unsigned r = static_function_1(&b4);
+            META_HPP_ASSERT(r == 1);
+            benchmark::DoNotOptimize(r);
+        }
+    }
+
+    [[maybe_unused]]
+    void cast_function_2(benchmark::State &state) {
+        base4 b4;
+        for ( auto _ : state ) {
+            unsigned r = static_function_2(&b4, &b4);
+            META_HPP_ASSERT(r == 3);
+            benchmark::DoNotOptimize(r);
+        }
+    }
+
+    [[maybe_unused]]
+    void cast_function_3(benchmark::State &state) {
+        base4 b4;
+        for ( auto _ : state ) {
+            unsigned r = static_function_3(&b4, &b4, &b4);
+            META_HPP_ASSERT(r == 6);
+            benchmark::DoNotOptimize(r);
+        }
+    }
+
+    [[maybe_unused]]
+    void cast_function_4(benchmark::State &state) {
+        base4 b4;
+        for ( auto _ : state ) {
+            unsigned r = static_function_4(&b4, &b4, &b4, &b4);
+            META_HPP_ASSERT(r == 10);
+            benchmark::DoNotOptimize(r);
+        }
+    }
+}
+
+//
+// meta
+//
+
+namespace
+{
+    [[maybe_unused]]
+    void meta_cast_function_1(benchmark::State &state) {
+        meta::function f = meta_bench_scope.get_function("cast_function_1");
+        META_HPP_ASSERT(f.is_valid());
+
+        base4 b4;
+        for ( auto _ : state ) {
+            unsigned r = f(&b4).as<unsigned>();
+            META_HPP_ASSERT(r == 1);
+            benchmark::DoNotOptimize(r);
+        }
+    }
+
+    [[maybe_unused]]
+    void meta_cast_function_2(benchmark::State &state) {
+        meta::function f = meta_bench_scope.get_function("cast_function_2");
+        META_HPP_ASSERT(f.is_valid());
+
+        base4 b4;
+        for ( auto _ : state ) {
+            unsigned r = f(&b4, &b4).as<unsigned>();
+            META_HPP_ASSERT(r == 3);
+            benchmark::DoNotOptimize(r);
+        }
+    }
+
+    [[maybe_unused]]
+    void meta_cast_function_3(benchmark::State &state) {
+        meta::function f = meta_bench_scope.get_function("cast_function_3");
+        META_HPP_ASSERT(f.is_valid());
+
+        base4 b4;
+        for ( auto _ : state ) {
+            unsigned r = f(&b4, &b4, &b4).as<unsigned>();
+            META_HPP_ASSERT(r == 6);
+            benchmark::DoNotOptimize(r);
+        }
+    }
+
+    [[maybe_unused]]
+    void meta_cast_function_4(benchmark::State &state) {
+        meta::function f = meta_bench_scope.get_function("cast_function_4");
+        META_HPP_ASSERT(f.is_valid());
+
+        base4 b4;
+        for ( auto _ : state ) {
+            unsigned r = f(&b4, &b4, &b4, &b4).as<unsigned>();
+            META_HPP_ASSERT(r == 10);
+            benchmark::DoNotOptimize(r);
+        }
+    }
+}
+
+//
+// rttr
+//
+
+namespace
+{
+    [[maybe_unused]]
+    void rttr_cast_function_1(benchmark::State &state) {
+        rttr::method m = rttr::type::get_global_method("cast_function_1");
+        META_HPP_ASSERT(m.is_valid());
+
+        base4 b4;
+        for ( auto _ : state ) {
+            unsigned r = m.invoke({},
+                rttr::rttr_cast<base1*>(&b4)).get_value<unsigned>();
+            META_HPP_ASSERT(r == 1);
+            benchmark::DoNotOptimize(r);
+        }
+    }
+
+    [[maybe_unused]]
+    void rttr_cast_function_2(benchmark::State &state) {
+        rttr::method m = rttr::type::get_global_method("cast_function_2");
+        META_HPP_ASSERT(m.is_valid());
+
+        base4 b4;
+        for ( auto _ : state ) {
+            unsigned r = m.invoke({},
+                rttr::rttr_cast<base1*>(&b4),
+                rttr::rttr_cast<base2*>(&b4)).get_value<unsigned>();
+            META_HPP_ASSERT(r == 3);
+            benchmark::DoNotOptimize(r);
+        }
+    }
+
+    [[maybe_unused]]
+    void rttr_cast_function_3(benchmark::State &state) {
+        rttr::method m = rttr::type::get_global_method("cast_function_3");
+        META_HPP_ASSERT(m.is_valid());
+
+        base4 b4;
+        for ( auto _ : state ) {
+            unsigned r = m.invoke({},
+                rttr::rttr_cast<base1*>(&b4),
+                rttr::rttr_cast<base2*>(&b4),
+                rttr::rttr_cast<base3*>(&b4)).get_value<unsigned>();
+            META_HPP_ASSERT(r == 6);
+            benchmark::DoNotOptimize(r);
+        }
+    }
+
+    [[maybe_unused]]
+    void rttr_cast_function_4(benchmark::State &state) {
+        rttr::method m = rttr::type::get_global_method("cast_function_4");
+        META_HPP_ASSERT(m.is_valid());
+
+        base4 b4;
+        for ( auto _ : state ) {
+            unsigned r = m.invoke({},
+                rttr::rttr_cast<base1*>(&b4),
+                rttr::rttr_cast<base2*>(&b4),
+                rttr::rttr_cast<base3*>(&b4),
+                rttr::rttr_cast<base4*>(&b4)).get_value<unsigned>();
+            META_HPP_ASSERT(r == 10);
+            benchmark::DoNotOptimize(r);
+        }
+    }
+}
+
+BENCHMARK(cast_function_1)->Teardown(static_function_reset);
+BENCHMARK(meta_cast_function_1)->Teardown(static_function_reset);
+BENCHMARK(rttr_cast_function_1)->Teardown(static_function_reset);
+
+BENCHMARK(cast_function_2)->Teardown(static_function_reset);
+BENCHMARK(meta_cast_function_2)->Teardown(static_function_reset);
+BENCHMARK(rttr_cast_function_2)->Teardown(static_function_reset);
+
+BENCHMARK(cast_function_3)->Teardown(static_function_reset);
+BENCHMARK(meta_cast_function_3)->Teardown(static_function_reset);
+BENCHMARK(rttr_cast_function_3)->Teardown(static_function_reset);
+
+BENCHMARK(cast_function_4)->Teardown(static_function_reset);
+BENCHMARK(meta_cast_function_4)->Teardown(static_function_reset);
+BENCHMARK(rttr_cast_function_4)->Teardown(static_function_reset);
diff --git a/develop/unbench/invoke_function_bench.cpp b/develop/unbench/invoke_function_bench.cpp
index 2d58ef2..2f13f0c 100644
--- a/develop/unbench/invoke_function_bench.cpp
+++ b/develop/unbench/invoke_function_bench.cpp
@@ -45,28 +45,29 @@ namespace
         static_angle = static_angle + 0.00001f;
     }
 
+    [[maybe_unused]]
     void static_function_reset(const benchmark::State&) {
         static_acc = 0.f;
         static_angle = 0.f;
     }
 
     meta::scope meta_bench_scope = meta::local_scope_("")
-        .function_("static_function_0", &static_function_0)
-        .function_("static_function_1", &static_function_1)
-        .function_("static_function_2", &static_function_2)
-        .function_("static_function_3", &static_function_3)
-        .function_("static_function_4", &static_function_4);
+        .function_("invoke_function_0", &static_function_0)
+        .function_("invoke_function_1", &static_function_1)
+        .function_("invoke_function_2", &static_function_2)
+        .function_("invoke_function_3", &static_function_3)
+        .function_("invoke_function_4", &static_function_4);
 }
 
 RTTR_REGISTRATION
 {
     using namespace rttr;
 
-    registration::method("static_function_0", &static_function_0);
-    registration::method("static_function_1", &static_function_1);
-    registration::method("static_function_2", &static_function_2);
-    registration::method("static_function_3", &static_function_3);
-    registration::method("static_function_4", &static_function_4);
+    registration::method("invoke_function_0", &static_function_0);
+    registration::method("invoke_function_1", &static_function_1);
+    registration::method("invoke_function_2", &static_function_2);
+    registration::method("invoke_function_3", &static_function_3);
+    registration::method("invoke_function_4", &static_function_4);
 }
 
 //
@@ -119,7 +120,7 @@ namespace
 {
     [[maybe_unused]]
     void meta_invoke_function_0(benchmark::State &state) {
-        meta::function f = meta_bench_scope.get_function("static_function_0");
+        meta::function f = meta_bench_scope.get_function("invoke_function_0");
         for ( auto _ : state ) {
             f();
         }
@@ -127,7 +128,7 @@ namespace
 
     [[maybe_unused]]
     void meta_invoke_function_1(benchmark::State &state) {
-        meta::function f = meta_bench_scope.get_function("static_function_1");
+        meta::function f = meta_bench_scope.get_function("invoke_function_1");
         META_HPP_ASSERT(f.is_valid());
 
         for ( auto _ : state ) {
@@ -137,7 +138,7 @@ namespace
 
     [[maybe_unused]]
     void meta_invoke_function_2(benchmark::State &state) {
-        meta::function f = meta_bench_scope.get_function("static_function_2");
+        meta::function f = meta_bench_scope.get_function("invoke_function_2");
         META_HPP_ASSERT(f.is_valid());
 
         for ( auto _ : state ) {
@@ -147,7 +148,7 @@ namespace
 
     [[maybe_unused]]
     void meta_invoke_function_3(benchmark::State &state) {
-        meta::function f = meta_bench_scope.get_function("static_function_3");
+        meta::function f = meta_bench_scope.get_function("invoke_function_3");
         META_HPP_ASSERT(f.is_valid());
 
         for ( auto _ : state ) {
@@ -157,7 +158,7 @@ namespace
 
     [[maybe_unused]]
     void meta_invoke_function_4(benchmark::State &state) {
-        meta::function f = meta_bench_scope.get_function("static_function_4");
+        meta::function f = meta_bench_scope.get_function("invoke_function_4");
         META_HPP_ASSERT(f.is_valid());
 
         for ( auto _ : state ) {
@@ -174,7 +175,7 @@ namespace
 {
     [[maybe_unused]]
     void rttr_invoke_function_0(benchmark::State &state) {
-        rttr::method m = rttr::type::get_global_method("static_function_0");
+        rttr::method m = rttr::type::get_global_method("invoke_function_0");
         META_HPP_ASSERT(m.is_valid());
 
         for ( auto _ : state ) {
@@ -184,7 +185,7 @@ namespace
 
     [[maybe_unused]]
     void rttr_invoke_function_1(benchmark::State &state) {
-        rttr::method m = rttr::type::get_global_method("static_function_1");
+        rttr::method m = rttr::type::get_global_method("invoke_function_1");
         META_HPP_ASSERT(m.is_valid());
 
         for ( auto _ : state ) {
@@ -194,7 +195,7 @@ namespace
 
     [[maybe_unused]]
     void rttr_invoke_function_2(benchmark::State &state) {
-        rttr::method m = rttr::type::get_global_method("static_function_2");
+        rttr::method m = rttr::type::get_global_method("invoke_function_2");
         META_HPP_ASSERT(m.is_valid());
 
         for ( auto _ : state ) {
@@ -204,7 +205,7 @@ namespace
 
     [[maybe_unused]]
     void rttr_invoke_function_3(benchmark::State &state) {
-        rttr::method m = rttr::type::get_global_method("static_function_3");
+        rttr::method m = rttr::type::get_global_method("invoke_function_3");
         META_HPP_ASSERT(m.is_valid());
 
         for ( auto _ : state ) {
@@ -214,7 +215,7 @@ namespace
 
     [[maybe_unused]]
     void rttr_invoke_function_4(benchmark::State &state) {
-        rttr::method m = rttr::type::get_global_method("static_function_4");
+        rttr::method m = rttr::type::get_global_method("invoke_function_4");
         META_HPP_ASSERT(m.is_valid());
 
         for ( auto _ : state ) {