diff --git a/proxy.h b/proxy.h
index 3dc3c25..437dfe9 100644
--- a/proxy.h
+++ b/proxy.h
@@ -15,6 +15,14 @@
 #include <type_traits>
 #include <utility>
 
+#ifdef __cpp_rtti
+#ifndef __cpp_exceptions
+#include <cstdlib>  // For std::abort() when "throw" is not available
+#endif  // __cpp_exceptions
+#include <optional>
+#include <typeinfo>
+#endif  // __cpp_rtti
+
 #if __has_cpp_attribute(msvc::no_unique_address)
 #define ___PRO_NO_UNIQUE_ADDRESS_ATTRIBUTE msvc::no_unique_address
 #elif __has_cpp_attribute(no_unique_address)
@@ -1240,6 +1248,10 @@ using proxy_view = proxy<observer_facade<F>>;
     ___PRO_DEBUG( \
         accessor() noexcept { ::std::ignore = &accessor::__VA_ARGS__; })
 
+#ifdef __cpp_rtti
+struct bad_proxy_cast : std::bad_cast {};
+#endif  // __cpp_rtti
+
 namespace details {
 
 template <class F, class C>
@@ -1537,6 +1549,113 @@ struct sign {
 template <std::size_t N>
 sign(const char (&str)[N]) -> sign<N>;
 
+#ifdef __cpp_rtti
+#ifdef __cpp_exceptions
+#define ___PRO_THROW(...) throw __VA_ARGS__
+#else
+#define ___PRO_THROW(...) std::abort()
+#endif  // __cpp_exceptions
+
+struct proxy_cast_context {
+  const std::type_info* type_ptr;
+  bool is_ref;
+  bool is_const;
+  void* result_ptr;
+};
+
+template <class F, class C, class O>
+struct proxy_cast_accessor_impl {
+  using _Self =
+      add_qualifier_t<adl_accessor_arg_t<F, C>, overload_traits<O>::qualifier>;
+  template <class T>
+  friend T proxy_cast(_Self self) {
+    static_assert(!std::is_rvalue_reference_v<T>);
+    if (!access_proxy<F>(self).has_value()) { ___PRO_THROW(bad_proxy_cast{}); }
+    if constexpr (std::is_lvalue_reference_v<T>) {
+      using U = std::remove_reference_t<T>;
+      void* result = nullptr;
+      proxy_cast_context ctx{.type_ptr = &typeid(T), .is_ref = true,
+          .is_const = std::is_const_v<U>, .result_ptr = &result};
+      proxy_invoke<C, O>(access_proxy<F>(std::forward<_Self>(self)), ctx);
+      if (result == nullptr) { ___PRO_THROW(bad_proxy_cast{}); }
+      return *static_cast<U*>(result);
+    } else {
+      std::optional<std::remove_const_t<T>> result;
+      proxy_cast_context ctx{.type_ptr = &typeid(T), .is_ref = false,
+          .is_const = false, .result_ptr = &result};
+      proxy_invoke<C, O>(access_proxy<F>(std::forward<_Self>(self)), ctx);
+      if (!result.has_value()) { ___PRO_THROW(bad_proxy_cast{}); }
+      return std::move(*result);
+    }
+  }
+  template <class T>
+  friend T* proxy_cast(std::remove_reference_t<_Self>* self) noexcept
+      requires(std::is_lvalue_reference_v<_Self>) {
+    if (!access_proxy<F>(*self).has_value()) { return nullptr; }
+    void* result = nullptr;
+    proxy_cast_context ctx{.type_ptr = &typeid(T), .is_ref = true,
+        .is_const = std::is_const_v<T>, .result_ptr = &result};
+    proxy_invoke<C, O>(access_proxy<F>(*self), ctx);
+    return static_cast<T*>(result);
+  }
+};
+
+#define ___PRO_DEF_PROXY_CAST_ACCESSOR(Q, ...) \
+    template <class F, class C> \
+    struct accessor<F, C, void(proxy_cast_context) Q> \
+        : proxy_cast_accessor_impl<F, C, void(proxy_cast_context) Q> {}
+struct proxy_cast_dispatch {
+  template <class T>
+  void operator()(T&& self, proxy_cast_context ctx) {
+    if (typeid(T) == *ctx.type_ptr) {
+      if (ctx.is_ref) {
+        if constexpr (std::is_lvalue_reference_v<T>) {
+          if (ctx.is_const || !std::is_const_v<T>) {
+            *static_cast<void**>(ctx.result_ptr) = (void*)&self;
+          }
+        }
+      } else {
+        if constexpr (std::is_constructible_v<std::decay_t<T>, T>) {
+          static_cast<std::optional<std::decay_t<T>>*>(ctx.result_ptr)
+              ->emplace(std::forward<T>(self));
+        }
+      }
+    }
+  }
+  ___PRO_DEF_FREE_ACCESSOR_TEMPLATE(___PRO_DEF_PROXY_CAST_ACCESSOR)
+};
+#undef ___PRO_DEF_PROXY_CAST_ACCESSOR
+
+struct proxy_typeid_reflector {
+  template <class T>
+  constexpr explicit proxy_typeid_reflector(std::in_place_type_t<T>)
+      : info(&typeid(T)) {}
+  constexpr proxy_typeid_reflector(const proxy_typeid_reflector&) = default;
+
+  template <class F, class R>
+  struct accessor {
+    friend const std::type_info& proxy_typeid(
+        const adl_accessor_arg_t<F, R>& self) noexcept {
+      const proxy<F>& p = access_proxy<F>(self);
+      if (!p.has_value()) { return typeid(void); }
+      const proxy_typeid_reflector& refl = proxy_reflect<R>(p);
+      return *refl.info;
+    }
+___PRO_DEBUG(
+    accessor() noexcept { std::ignore = &accessor::_symbol_guard; }
+
+   private:
+    static inline const std::type_info& _symbol_guard(
+        const adl_accessor_arg_t<F, R>& self) noexcept
+        { return proxy_typeid(self); }
+)
+  };
+
+  const std::type_info* info;
+};
+#undef ___PRO_THROW
+#endif  // __cpp_rtti
+
 }  // namespace details
 
 template <class Cs, class Rs, proxiable_ptr_constraints C>
@@ -1582,6 +1701,25 @@ struct basic_facade_builder {
   template <constraint_level CL>
   using support_destruction = basic_facade_builder<
       Cs, Rs, details::make_destructible(C, CL)>;
+#ifdef __cpp_rtti
+  using support_indirect_rtti =
+      basic_facade_builder<
+          details::add_conv_t<Cs, details::conv_impl<false,
+              details::proxy_cast_dispatch, void(details::proxy_cast_context) &,
+              void(details::proxy_cast_context) const&,
+              void(details::proxy_cast_context) &&>>,
+          details::add_tuple_t<Rs, details::refl_impl<false,
+              details::proxy_typeid_reflector>>, C>;
+  using support_direct_rtti =
+      basic_facade_builder<
+          details::add_conv_t<Cs, details::conv_impl<true,
+              details::proxy_cast_dispatch, void(details::proxy_cast_context) &,
+              void(details::proxy_cast_context) const&,
+              void(details::proxy_cast_context) &&>>,
+          details::add_tuple_t<Rs, details::refl_impl<true,
+              details::proxy_typeid_reflector>>, C>;
+  using support_rtti = support_indirect_rtti;
+#endif  // __cpp_rtti
   template <class F>
   using add_view = add_direct_convention<
       details::proxy_view_dispatch, details::proxy_view_overload<F>>;
diff --git a/tests/CMakeLists.txt b/tests/CMakeLists.txt
index cb2870a..49a6987 100644
--- a/tests/CMakeLists.txt
+++ b/tests/CMakeLists.txt
@@ -24,6 +24,7 @@ add_executable(msft_proxy_tests
   proxy_lifetime_tests.cpp
   proxy_reflection_tests.cpp
   proxy_regression_tests.cpp
+  proxy_rtti_tests.cpp
   proxy_traits_tests.cpp
   proxy_view_tests.cpp
 )
diff --git a/tests/proxy_rtti_tests.cpp b/tests/proxy_rtti_tests.cpp
new file mode 100644
index 0000000..6a78b0e
--- /dev/null
+++ b/tests/proxy_rtti_tests.cpp
@@ -0,0 +1,293 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+
+#include <gtest/gtest.h>
+#include <vector>
+#include "proxy.h"
+
+namespace proxy_rtti_tests_details {
+
+struct TestFacade : pro::facade_builder
+    ::support_rtti
+    ::support_direct_rtti
+    ::build {};
+
+}  // namespace proxy_rtti_tests_details
+
+namespace details = proxy_rtti_tests_details;
+
+TEST(ProxyRttiTests, TestIndirectCast_Void_Fail) {
+  pro::proxy<details::TestFacade> p;
+  bool exception_thrown = false;
+  try {
+    proxy_cast<int>(*p);
+  } catch (const pro::bad_proxy_cast&) {
+    exception_thrown = true;
+  }
+  ASSERT_TRUE(exception_thrown);
+}
+
+TEST(ProxyRttiTests, TestIndirectCast_Ref_Succeed) {
+  int v = 123;
+  pro::proxy<details::TestFacade> p = &v;
+  proxy_cast<int&>(*p) = 456;
+  ASSERT_EQ(v, 456);
+}
+
+TEST(ProxyRttiTests, TestIndirectCast_Ref_Fail) {
+  int v = 123;
+  pro::proxy<details::TestFacade> p = &v;
+  bool exception_thrown = false;
+  try {
+    proxy_cast<double&>(*p);
+  } catch (const pro::bad_proxy_cast&) {
+    exception_thrown = true;
+  }
+  ASSERT_TRUE(exception_thrown);
+}
+
+TEST(ProxyRttiTests, TestIndirectCast_ConstRef_Succeed) {
+  int v = 123;
+  pro::proxy<details::TestFacade> p = &v;
+  const int& r = proxy_cast<const int&>(*p);
+  ASSERT_EQ(&v, &r);
+  ASSERT_EQ(v, 123);
+}
+
+TEST(ProxyRttiTests, TestIndirectCast_ConstRef_Fail) {
+  int v = 123;
+  pro::proxy<details::TestFacade> p = &v;
+  bool exception_thrown = false;
+  try {
+    proxy_cast<const double&>(*p);
+  } catch (const pro::bad_proxy_cast&) {
+    exception_thrown = true;
+  }
+  ASSERT_TRUE(exception_thrown);
+}
+
+TEST(ProxyRttiTests, TestIndirectCast_Copy_Succeed) {
+  int v1 = 123;
+  pro::proxy<details::TestFacade> p = &v1;
+  int v2 = proxy_cast<int>(*p);
+  ASSERT_EQ(v1, 123);
+  ASSERT_EQ(v2, 123);
+}
+
+TEST(ProxyRttiTests, TestIndirectCast_Copy_Fail) {
+  int v = 123;
+  pro::proxy<details::TestFacade> p = &v;
+  bool exception_thrown = false;
+  try {
+    proxy_cast<double>(*p);
+  } catch (const pro::bad_proxy_cast&) {
+    exception_thrown = true;
+  }
+  ASSERT_TRUE(exception_thrown);
+}
+
+TEST(ProxyRttiTests, TestIndirectCast_Move_Succeed) {
+  const std::vector<int> v1{1, 2, 3};
+  auto p = pro::make_proxy<details::TestFacade>(v1);
+  auto v2 = proxy_cast<std::vector<int>>(std::move(*p));
+  ASSERT_EQ(v2, v1);
+  v2 = proxy_cast<std::vector<int>>(std::move(*p));
+  ASSERT_TRUE(v2.empty());
+}
+
+TEST(ProxyRttiTests, TestIndirectCast_Move_Fail) {
+  auto p = pro::make_proxy<details::TestFacade>(std::vector<int>{1, 2, 3});
+  bool exception_thrown = false;
+  try {
+    proxy_cast<std::vector<double>>(std::move(*p));
+  } catch (const pro::bad_proxy_cast&) {
+    exception_thrown = true;
+  }
+  ASSERT_TRUE(exception_thrown);
+}
+
+TEST(ProxyRttiTests, TestIndirectCast_Ptr_Succeed) {
+  int v = 123;
+  pro::proxy<details::TestFacade> p = &v;
+  auto ptr = proxy_cast<int>(&*p);
+  static_assert(std::is_same_v<decltype(ptr), int*>);
+  ASSERT_EQ(ptr, &v);
+  ASSERT_EQ(v, 123);
+}
+
+TEST(ProxyRttiTests, TestIndirectCast_Ptr_Fail) {
+  int v = 123;
+  pro::proxy<details::TestFacade> p = &v;
+  auto ptr = proxy_cast<double>(&*p);
+  static_assert(std::is_same_v<decltype(ptr), double*>);
+  ASSERT_EQ(ptr, nullptr);
+  ASSERT_EQ(v, 123);
+}
+
+TEST(ProxyRttiTests, TestIndirectCast_ConstPtr_Succeed) {
+  int v = 123;
+  pro::proxy<details::TestFacade> p = &v;
+  auto ptr = proxy_cast<const int>(&*p);
+  static_assert(std::is_same_v<decltype(ptr), const int*>);
+  ASSERT_EQ(ptr, &v);
+  ASSERT_EQ(v, 123);
+}
+
+TEST(ProxyRttiTests, TestIndirectCast_ConstPtr_Fail) {
+  int v = 123;
+  pro::proxy<details::TestFacade> p = &v;
+  auto ptr = proxy_cast<const double>(&*p);
+  static_assert(std::is_same_v<decltype(ptr), const double*>);
+  ASSERT_EQ(ptr, nullptr);
+  ASSERT_EQ(v, 123);
+}
+
+TEST(ProxyRttiTests, TestIndirectTypeid_Void) {
+  pro::proxy<details::TestFacade> p;
+  ASSERT_EQ(proxy_typeid(*p), typeid(void));
+}
+
+TEST(ProxyRttiTests, TestIndirectTypeid_Value) {
+  int a = 123;
+  pro::proxy<details::TestFacade> p = &a;
+  ASSERT_EQ(proxy_typeid(*p), typeid(int));
+}
+
+TEST(ProxyRttiTests, TestDirectCast_Void_Fail) {
+  pro::proxy<details::TestFacade> p;
+  bool exception_thrown = false;
+  try {
+    proxy_cast<int>(p);
+  } catch (const pro::bad_proxy_cast&) {
+    exception_thrown = true;
+  }
+  ASSERT_TRUE(exception_thrown);
+}
+
+TEST(ProxyRttiTests, TestDirectCast_Ref_Succeed) {
+  int v = 123;
+  pro::proxy<details::TestFacade> p = &v;
+  *proxy_cast<int*&>(p) = 456;
+  ASSERT_EQ(v, 456);
+}
+
+TEST(ProxyRttiTests, TestDirectCast_Ref_Fail) {
+  int v = 123;
+  pro::proxy<details::TestFacade> p = &v;
+  bool exception_thrown = false;
+  try {
+    proxy_cast<double*&>(p);
+  } catch (const pro::bad_proxy_cast&) {
+    exception_thrown = true;
+  }
+  ASSERT_TRUE(exception_thrown);
+}
+
+TEST(ProxyRttiTests, TestDirectCast_ConstRef_Succeed) {
+  int v = 123;
+  pro::proxy<details::TestFacade> p = &v;
+  int* const& r = proxy_cast<int* const&>(p);
+  ASSERT_EQ(&v, r);
+  ASSERT_EQ(v, 123);
+}
+
+TEST(ProxyRttiTests, TestDirectCast_ConstRef_Fail) {
+  int v = 123;
+  pro::proxy<details::TestFacade> p = &v;
+  bool exception_thrown = false;
+  try {
+    proxy_cast<double* const&>(p);
+  } catch (const pro::bad_proxy_cast&) {
+    exception_thrown = true;
+  }
+  ASSERT_TRUE(exception_thrown);
+}
+
+TEST(ProxyRttiTests, TestDirectCast_Copy_Succeed) {
+  int v1 = 123;
+  pro::proxy<details::TestFacade> p = &v1;
+  int* v2 = proxy_cast<int*>(p);
+  ASSERT_EQ(v2, &v1);
+  ASSERT_EQ(v1, 123);
+}
+
+TEST(ProxyRttiTests, TestDirectCast_Copy_Fail) {
+  int v = 123;
+  pro::proxy<details::TestFacade> p = &v;
+  bool exception_thrown = false;
+  try {
+    proxy_cast<double*>(p);
+  } catch (const pro::bad_proxy_cast&) {
+    exception_thrown = true;
+  }
+  ASSERT_TRUE(exception_thrown);
+}
+
+TEST(ProxyRttiTests, TestDirectCast_Move_Succeed) {
+  int v1 = 123;
+  pro::proxy<details::TestFacade> p = &v1;
+  auto v2 = proxy_cast<int*>(std::move(p));
+  ASSERT_EQ(v2, &v1);
+  ASSERT_EQ(v1, 123);
+  ASSERT_FALSE(p.has_value());
+}
+
+TEST(ProxyRttiTests, TestDirectCast_Move_Fail) {
+  int v1 = 123;
+  pro::proxy<details::TestFacade> p = &v1;
+  bool exception_thrown = false;
+  try {
+    proxy_cast<double*>(std::move(p));
+  } catch (const pro::bad_proxy_cast&) {
+    exception_thrown = true;
+  }
+  ASSERT_TRUE(exception_thrown);
+  ASSERT_FALSE(p.has_value());
+}
+
+TEST(ProxyRttiTests, TestDirectCast_Ptr_Succeed) {
+  int v = 123;
+  pro::proxy<details::TestFacade> p = &v;
+  auto ptr = proxy_cast<int*>(&p);
+  static_assert(std::is_same_v<decltype(ptr), int**>);
+  ASSERT_EQ(*ptr, &v);
+  ASSERT_EQ(v, 123);
+}
+
+TEST(ProxyRttiTests, TestDirectCast_Ptr_Fail) {
+  int v = 123;
+  pro::proxy<details::TestFacade> p = &v;
+  auto ptr = proxy_cast<double*>(&p);
+  static_assert(std::is_same_v<decltype(ptr), double**>);
+  ASSERT_EQ(ptr, nullptr);
+  ASSERT_EQ(v, 123);
+}
+
+TEST(ProxyRttiTests, TestDirectCast_ConstPtr_Succeed) {
+  int v = 123;
+  pro::proxy<details::TestFacade> p = &v;
+  auto ptr = proxy_cast<int* const>(&p);
+  static_assert(std::is_same_v<decltype(ptr), int* const*>);
+  ASSERT_EQ(*ptr, &v);
+  ASSERT_EQ(v, 123);
+}
+
+TEST(ProxyRttiTests, TestDirectCast_ConstPtr_Fail) {
+  int v = 123;
+  pro::proxy<details::TestFacade> p = &v;
+  auto ptr = proxy_cast<double* const>(&*p);
+  static_assert(std::is_same_v<decltype(ptr), double* const*>);
+  ASSERT_EQ(ptr, nullptr);
+  ASSERT_EQ(v, 123);
+}
+
+TEST(ProxyRttiTests, TestDirectTypeid_Void) {
+  pro::proxy<details::TestFacade> p;
+  ASSERT_EQ(proxy_typeid(p), typeid(void));
+}
+
+TEST(ProxyRttiTests, TestDirectTypeid_Value) {
+  int a = 123;
+  pro::proxy<details::TestFacade> p = &a;
+  ASSERT_EQ(proxy_typeid(p), typeid(int*));
+}