diff --git a/strings/base_reference_produce.h b/strings/base_reference_produce.h
index abffb3384..db9639cc3 100644
--- a/strings/base_reference_produce.h
+++ b/strings/base_reference_produce.h
@@ -2,99 +2,197 @@
 WINRT_EXPORT namespace winrt::impl
 {
     template <typename T>
-    struct reference : implements<reference<T>, Windows::Foundation::IReference<T>, Windows::Foundation::IPropertyValue>
+    struct reference;
+
+    template <typename T>
+    struct reference_array;
+
+    template <typename T>
+    inline constexpr bool is_stock_reference_v =
+        std::is_same_v<T, std::uint8_t> || std::is_same_v<T, std::int16_t> ||
+        std::is_same_v<T, std::uint16_t> || std::is_same_v<T, std::int32_t> ||
+        std::is_same_v<T, std::uint32_t> || std::is_same_v<T, std::int64_t> ||
+        std::is_same_v<T, std::uint64_t> || std::is_same_v<T, float> ||
+        std::is_same_v<T, double> || std::is_same_v<T, char16_t> ||
+        std::is_same_v<T, bool> || std::is_same_v<T, hstring> ||
+        std::is_same_v<T, guid> || std::is_same_v<T, Windows::Foundation::DateTime> ||
+        std::is_same_v<T, Windows::Foundation::TimeSpan> || std::is_same_v<T, Windows::Foundation::Point>;
+
+    template <typename T>
+    constexpr Windows::Foundation::PropertyType scalar_property_type() noexcept
+    {
+        using pt = Windows::Foundation::PropertyType;
+
+        if constexpr (std::is_same_v<T, std::uint8_t>) { return pt::UInt8; }
+        else if constexpr (std::is_same_v<T, std::int16_t>) { return pt::Int16; }
+        else if constexpr (std::is_same_v<T, std::uint16_t>) { return pt::UInt16; }
+        else if constexpr (std::is_same_v<T, std::int32_t>) { return pt::Int32; }
+        else if constexpr (std::is_same_v<T, std::uint32_t>) { return pt::UInt32; }
+        else if constexpr (std::is_same_v<T, std::int64_t>) { return pt::Int64; }
+        else if constexpr (std::is_same_v<T, std::uint64_t>) { return pt::UInt64; }
+        else if constexpr (std::is_same_v<T, float>) { return pt::Single; }
+        else if constexpr (std::is_same_v<T, double>) { return pt::Double; }
+        else if constexpr (std::is_same_v<T, char16_t>) { return pt::Char16; }
+        else if constexpr (std::is_same_v<T, bool>) { return pt::Boolean; }
+        else if constexpr (std::is_same_v<T, hstring>) { return pt::String; }
+        else if constexpr (std::is_same_v<T, Windows::Foundation::IInspectable>) { return pt::Inspectable; }
+        else if constexpr (std::is_same_v<T, guid>) { return pt::Guid; }
+        else if constexpr (std::is_same_v<T, Windows::Foundation::DateTime>) { return pt::DateTime; }
+        else if constexpr (std::is_same_v<T, Windows::Foundation::TimeSpan>) { return pt::TimeSpan; }
+        else if constexpr (std::is_same_v<T, Windows::Foundation::Point>) { return pt::Point; }
+        else if constexpr (std::is_same_v<T, Windows::Foundation::Size>) { return pt::Size; }
+        else if constexpr (std::is_same_v<T, Windows::Foundation::Rect>) { return pt::Rect; }
+        else { return pt::OtherType; }
+    }
+
+    template <typename T>
+    constexpr Windows::Foundation::PropertyType array_property_type() noexcept
     {
-        reference(T const& value) : m_value(value)
-        {
-        }
+        return static_cast<Windows::Foundation::PropertyType>(
+            static_cast<std::int32_t>(scalar_property_type<T>()) + 1024);
+    }
 
-        T Value() const
-        {
-            return m_value;
-        }
+    template <typename U>
+    inline constexpr bool is_numeric_scalar_v =
+        (std::is_arithmetic_v<U> && !std::is_same_v<U, bool> && !std::is_same_v<U, char16_t>) || std::is_enum_v<U>;
 
+    template <typename Derived, typename T, typename Interface, bool IsArray>
+    struct reference_producer : implements<Derived, Interface, Windows::Foundation::IPropertyValue,
+        std::conditional_t<is_stock_reference_v<T>, non_agile, marker>>
+    {
         Windows::Foundation::PropertyType Type() const noexcept
         {
-            return Windows::Foundation::PropertyType::OtherType;
+            if constexpr (IsArray) { return array_property_type<T>(); }
+            else { return scalar_property_type<T>(); }
         }
 
         static constexpr bool IsNumericScalar() noexcept
         {
-            return std::is_arithmetic_v<T> || std::is_enum_v<T>;
+            return !IsArray && is_numeric_scalar_v<T>;
         }
 
-        std::uint8_t GetUInt8() const
-        {
-            return to_scalar<std::uint8_t>();
-        }
+        std::uint8_t GetUInt8() const { return derived()->template get_as<std::uint8_t>(); }
+        std::int16_t GetInt16() const { return derived()->template get_as<std::int16_t>(); }
+        std::uint16_t GetUInt16() const { return derived()->template get_as<std::uint16_t>(); }
+        std::int32_t GetInt32() const { return derived()->template get_as<std::int32_t>(); }
+        std::uint32_t GetUInt32() const { return derived()->template get_as<std::uint32_t>(); }
+        std::int64_t GetInt64() const { return derived()->template get_as<std::int64_t>(); }
+        std::uint64_t GetUInt64() const { return derived()->template get_as<std::uint64_t>(); }
+        float GetSingle() const { return derived()->template get_as<float>(); }
+        double GetDouble() const { return derived()->template get_as<double>(); }
+        char16_t GetChar16() const { return derived()->template get_as<char16_t>(); }
+        bool GetBoolean() const { return derived()->template get_as<bool>(); }
+        hstring GetString() const { return derived()->template get_as<hstring>(); }
+        guid GetGuid() const { return derived()->template get_as<guid>(); }
+        Windows::Foundation::DateTime GetDateTime() const { return derived()->template get_as<Windows::Foundation::DateTime>(); }
+        Windows::Foundation::TimeSpan GetTimeSpan() const { return derived()->template get_as<Windows::Foundation::TimeSpan>(); }
+        Windows::Foundation::Point GetPoint() const { return derived()->template get_as<Windows::Foundation::Point>(); }
+        Windows::Foundation::Size GetSize() const { return derived()->template get_as<Windows::Foundation::Size>(); }
+        Windows::Foundation::Rect GetRect() const { return derived()->template get_as<Windows::Foundation::Rect>(); }
+        void GetUInt8Array(com_array<std::uint8_t>& value) const { derived()->get_as(value); }
+        void GetInt16Array(com_array<std::int16_t>& value) const { derived()->get_as(value); }
+        void GetUInt16Array(com_array<std::uint16_t>& value) const { derived()->get_as(value); }
+        void GetInt32Array(com_array<std::int32_t>& value) const { derived()->get_as(value); }
+        void GetUInt32Array(com_array<std::uint32_t>& value) const { derived()->get_as(value); }
+        void GetInt64Array(com_array<std::int64_t>& value) const { derived()->get_as(value); }
+        void GetUInt64Array(com_array<std::uint64_t>& value) const { derived()->get_as(value); }
+        void GetSingleArray(com_array<float>& value) const { derived()->get_as(value); }
+        void GetDoubleArray(com_array<double>& value) const { derived()->get_as(value); }
+        void GetChar16Array(com_array<char16_t>& value) const { derived()->get_as(value); }
+        void GetBooleanArray(com_array<bool>& value) const { derived()->get_as(value); }
+        void GetStringArray(com_array<hstring>& value) const { derived()->get_as(value); }
+        void GetInspectableArray(com_array<Windows::Foundation::IInspectable>& value) const { derived()->get_as(value); }
+        void GetGuidArray(com_array<guid>& value) const { derived()->get_as(value); }
+        void GetDateTimeArray(com_array<Windows::Foundation::DateTime>& value) const { derived()->get_as(value); }
+        void GetTimeSpanArray(com_array<Windows::Foundation::TimeSpan>& value) const { derived()->get_as(value); }
+        void GetPointArray(com_array<Windows::Foundation::Point>& value) const { derived()->get_as(value); }
+        void GetSizeArray(com_array<Windows::Foundation::Size>& value) const { derived()->get_as(value); }
+        void GetRectArray(com_array<Windows::Foundation::Rect>& value) const { derived()->get_as(value); }
 
-        std::int16_t GetInt16() const
-        {
-            return to_scalar<std::int16_t>();
-        }
+    private:
 
-        std::uint16_t GetUInt16() const
-        {
-            return to_scalar<std::uint16_t>();
-        }
+        Derived const* derived() const noexcept { return static_cast<Derived const*>(this); }
 
-        std::int32_t GetInt32() const
+        std::int32_t query_interface_tearoff(guid const& id, void** object) const noexcept override
         {
-            return to_scalar<std::int32_t>();
-        }
+            if constexpr (is_stock_reference_v<T>)
+            {
+                if (is_guid_of<IMarshal>(id))
+                {
+                    try
+                    {
+                        auto marshal = derived()->create_property_value().template as<IMarshal>();
+                        *object = detach_abi(marshal);
+                        return error_ok;
+                    }
+                    catch (...)
+                    {
+                        *object = nullptr;
+                        return to_hresult();
+                    }
+                }
 
-        std::uint32_t GetUInt32() const
-        {
-            return to_scalar<std::uint32_t>();
+                if (is_guid_of<IAgileObject>(id))
+                {
+                    auto unknown = reinterpret_cast<unknown_abi*>(to_abi<Interface>(derived()));
+                    unknown->AddRef();
+                    *object = unknown;
+                    return error_ok;
+                }
+            }
+
+            *object = nullptr;
+            return error_no_interface;
         }
+    };
 
-        std::int64_t GetInt64() const
+    template <typename T>
+    struct reference : reference_producer<reference<T>, T, Windows::Foundation::IReference<T>, false>
+    {
+        reference(T const& value) : m_value(value)
         {
-            return to_scalar<std::int64_t>();
         }
 
-        std::uint64_t GetUInt64() const
+        T Value() const
         {
-            return to_scalar<std::uint64_t>();
+            return m_value;
         }
 
-        float GetSingle() { throw hresult_not_implemented(); }
-        double GetDouble() { throw hresult_not_implemented(); }
-        char16_t GetChar16() { throw hresult_not_implemented(); }
-        bool GetBoolean() { throw hresult_not_implemented(); }
-        hstring GetString() { throw hresult_not_implemented(); }
-        guid GetGuid() { throw hresult_not_implemented(); }
-        Windows::Foundation::DateTime GetDateTime() { throw hresult_not_implemented(); }
-        Windows::Foundation::TimeSpan GetTimeSpan() { throw hresult_not_implemented(); }
-        Windows::Foundation::Point GetPoint() { throw hresult_not_implemented(); }
-        Windows::Foundation::Size GetSize() { throw hresult_not_implemented(); }
-        Windows::Foundation::Rect GetRect() { throw hresult_not_implemented(); }
-        void GetUInt8Array(com_array<std::uint8_t> &) { throw hresult_not_implemented(); }
-        void GetInt16Array(com_array<std::int16_t> &) { throw hresult_not_implemented(); }
-        void GetUInt16Array(com_array<std::uint16_t> &) { throw hresult_not_implemented(); }
-        void GetInt32Array(com_array<std::int32_t> &) { throw hresult_not_implemented(); }
-        void GetUInt32Array(com_array<std::uint32_t> &) { throw hresult_not_implemented(); }
-        void GetInt64Array(com_array<std::int64_t> &) { throw hresult_not_implemented(); }
-        void GetUInt64Array(com_array<std::uint64_t> &) { throw hresult_not_implemented(); }
-        void GetSingleArray(com_array<float> &) { throw hresult_not_implemented(); }
-        void GetDoubleArray(com_array<double> &) { throw hresult_not_implemented(); }
-        void GetChar16Array(com_array<char16_t> &) { throw hresult_not_implemented(); }
-        void GetBooleanArray(com_array<bool> &) { throw hresult_not_implemented(); }
-        void GetStringArray(com_array<hstring> &) { throw hresult_not_implemented(); }
-        void GetInspectableArray(com_array<Windows::Foundation::IInspectable> &) { throw hresult_not_implemented(); }
-        void GetGuidArray(com_array<guid> &) { throw hresult_not_implemented(); }
-        void GetDateTimeArray(com_array<Windows::Foundation::DateTime> &) { throw hresult_not_implemented(); }
-        void GetTimeSpanArray(com_array<Windows::Foundation::TimeSpan> &) { throw hresult_not_implemented(); }
-        void GetPointArray(com_array<Windows::Foundation::Point> &) { throw hresult_not_implemented(); }
-        void GetSizeArray(com_array<Windows::Foundation::Size> &) { throw hresult_not_implemented(); }
-        void GetRectArray(com_array<Windows::Foundation::Rect> &) { throw hresult_not_implemented(); }
-
     private:
 
+        template <typename, typename, typename, bool> friend struct reference_producer;
+
+        Windows::Foundation::IInspectable create_property_value() const
+        {
+            using pv = Windows::Foundation::PropertyValue;
+
+            if constexpr (std::is_same_v<T, std::uint8_t>) { return pv::CreateUInt8(m_value); }
+            else if constexpr (std::is_same_v<T, std::int16_t>) { return pv::CreateInt16(m_value); }
+            else if constexpr (std::is_same_v<T, std::uint16_t>) { return pv::CreateUInt16(m_value); }
+            else if constexpr (std::is_same_v<T, std::int32_t>) { return pv::CreateInt32(m_value); }
+            else if constexpr (std::is_same_v<T, std::uint32_t>) { return pv::CreateUInt32(m_value); }
+            else if constexpr (std::is_same_v<T, std::int64_t>) { return pv::CreateInt64(m_value); }
+            else if constexpr (std::is_same_v<T, std::uint64_t>) { return pv::CreateUInt64(m_value); }
+            else if constexpr (std::is_same_v<T, float>) { return pv::CreateSingle(m_value); }
+            else if constexpr (std::is_same_v<T, double>) { return pv::CreateDouble(m_value); }
+            else if constexpr (std::is_same_v<T, char16_t>) { return pv::CreateChar16(m_value); }
+            else if constexpr (std::is_same_v<T, bool>) { return pv::CreateBoolean(m_value); }
+            else if constexpr (std::is_same_v<T, hstring>) { return pv::CreateString(m_value); }
+            else if constexpr (std::is_same_v<T, guid>) { return pv::CreateGuid(m_value); }
+            else if constexpr (std::is_same_v<T, Windows::Foundation::DateTime>) { return pv::CreateDateTime(m_value); }
+            else if constexpr (std::is_same_v<T, Windows::Foundation::TimeSpan>) { return pv::CreateTimeSpan(m_value); }
+            else if constexpr (std::is_same_v<T, Windows::Foundation::Point>) { return pv::CreatePoint(m_value); }
+            else { return nullptr; }
+        }
+
         template <typename To>
-        To to_scalar() const
+        To get_as() const
         {
-            if constexpr (IsNumericScalar())
+            if constexpr (std::is_same_v<T, To>)
+            {
+                return m_value;
+            }
+            else if constexpr (is_numeric_scalar_v<To> && is_numeric_scalar_v<T>)
             {
                 return static_cast<To>(m_value);
             }
@@ -104,98 +202,81 @@ WINRT_EXPORT namespace winrt::impl
             }
         }
 
+        template <typename To>
+        void get_as(com_array<To> const&) const
+        {
+            throw hresult_not_implemented();
+        }
+
         T m_value;
     };
 
     template <typename T>
-    struct reference_traits
-    {
-        static auto make(T const& value) { return winrt::make<impl::reference<T>>(value); }
-        using itf = Windows::Foundation::IReference<T>;
-    };
-
-    template <>
-    struct reference_traits<std::uint8_t>
-    {
-        static auto make(std::uint8_t value) { return Windows::Foundation::PropertyValue::CreateUInt8(value); }
-        using itf = Windows::Foundation::IReference<std::uint8_t>;
-    };
-
-    template <>
-    struct reference_traits<std::uint16_t>
-    {
-        static auto make(std::uint16_t value) { return Windows::Foundation::PropertyValue::CreateUInt16(value); }
-        using itf = Windows::Foundation::IReference<std::uint16_t>;
-    };
-
-    template <>
-    struct reference_traits<std::int16_t>
+    struct reference_array : reference_producer<reference_array<T>, T, Windows::Foundation::IReferenceArray<T>, true>
     {
-        static auto make(std::int16_t value) { return Windows::Foundation::PropertyValue::CreateInt16(value); }
-        using itf = Windows::Foundation::IReference<std::int16_t>;
-    };
+        reference_array(array_view<T const> const& value) : m_value(value.begin(), value.end())
+        {
+        }
 
-    template <>
-    struct reference_traits<std::uint32_t>
-    {
-        static auto make(std::uint32_t value) { return Windows::Foundation::PropertyValue::CreateUInt32(value); }
-        using itf = Windows::Foundation::IReference<std::uint32_t>;
-    };
+        com_array<T> Value() const
+        {
+            return com_array<T>(m_value.begin(), m_value.end());
+        }
 
-    template <>
-    struct reference_traits<std::int32_t>
-    {
-        static auto make(std::int32_t value) { return Windows::Foundation::PropertyValue::CreateInt32(value); }
-        using itf = Windows::Foundation::IReference<std::int32_t>;
-    };
+    private:
 
-    template <>
-    struct reference_traits<std::uint64_t>
-    {
-        static auto make(std::uint64_t value) { return Windows::Foundation::PropertyValue::CreateUInt64(value); }
-        using itf = Windows::Foundation::IReference<std::uint64_t>;
-    };
+        template <typename, typename, typename, bool> friend struct reference_producer;
 
-    template <>
-    struct reference_traits<std::int64_t>
-    {
-        static auto make(std::int64_t value) { return Windows::Foundation::PropertyValue::CreateInt64(value); }
-        using itf = Windows::Foundation::IReference<std::int64_t>;
-    };
-
-    template <>
-    struct reference_traits<float>
-    {
-        static auto make(float value) { return Windows::Foundation::PropertyValue::CreateSingle(value); }
-        using itf = Windows::Foundation::IReference<float>;
-    };
+        Windows::Foundation::IInspectable create_property_value() const
+        {
+            using pv = Windows::Foundation::PropertyValue;
+
+            if constexpr (std::is_same_v<T, std::uint8_t>) { return pv::CreateUInt8Array(m_value); }
+            else if constexpr (std::is_same_v<T, std::int16_t>) { return pv::CreateInt16Array(m_value); }
+            else if constexpr (std::is_same_v<T, std::uint16_t>) { return pv::CreateUInt16Array(m_value); }
+            else if constexpr (std::is_same_v<T, std::int32_t>) { return pv::CreateInt32Array(m_value); }
+            else if constexpr (std::is_same_v<T, std::uint32_t>) { return pv::CreateUInt32Array(m_value); }
+            else if constexpr (std::is_same_v<T, std::int64_t>) { return pv::CreateInt64Array(m_value); }
+            else if constexpr (std::is_same_v<T, std::uint64_t>) { return pv::CreateUInt64Array(m_value); }
+            else if constexpr (std::is_same_v<T, float>) { return pv::CreateSingleArray(m_value); }
+            else if constexpr (std::is_same_v<T, double>) { return pv::CreateDoubleArray(m_value); }
+            else if constexpr (std::is_same_v<T, char16_t>) { return pv::CreateChar16Array(m_value); }
+            else if constexpr (std::is_same_v<T, bool>) { return pv::CreateBooleanArray(m_value); }
+            else if constexpr (std::is_same_v<T, hstring>) { return pv::CreateStringArray(m_value); }
+            else if constexpr (std::is_same_v<T, guid>) { return pv::CreateGuidArray(m_value); }
+            else if constexpr (std::is_same_v<T, Windows::Foundation::DateTime>) { return pv::CreateDateTimeArray(m_value); }
+            else if constexpr (std::is_same_v<T, Windows::Foundation::TimeSpan>) { return pv::CreateTimeSpanArray(m_value); }
+            else if constexpr (std::is_same_v<T, Windows::Foundation::Point>) { return pv::CreatePointArray(m_value); }
+            else { return nullptr; }
+        }
 
-    template <>
-    struct reference_traits<double>
-    {
-        static auto make(double value) { return Windows::Foundation::PropertyValue::CreateDouble(value); }
-        using itf = Windows::Foundation::IReference<double>;
-    };
+        template <typename To>
+        To get_as() const
+        {
+            throw hresult_not_implemented();
+        }
 
-    template <>
-    struct reference_traits<char16_t>
-    {
-        static auto make(char16_t value) { return Windows::Foundation::PropertyValue::CreateChar16(value); }
-        using itf = Windows::Foundation::IReference<char16_t>;
-    };
+        template <typename To>
+        void get_as(com_array<To>& value) const
+        {
+            if constexpr (std::is_same_v<T, To>)
+            {
+                value = com_array<To>(m_value.begin(), m_value.end());
+            }
+            else
+            {
+                throw hresult_not_implemented();
+            }
+        }
 
-    template <>
-    struct reference_traits<bool>
-    {
-        static auto make(bool value) { return Windows::Foundation::PropertyValue::CreateBoolean(value); }
-        using itf = Windows::Foundation::IReference<bool>;
+        com_array<T> m_value;
     };
 
-    template <>
-    struct reference_traits<hstring>
+    template <typename T>
+    struct reference_traits
     {
-        static auto make(hstring const& value) { return Windows::Foundation::PropertyValue::CreateString(value); }
-        using itf = Windows::Foundation::IReference<hstring>;
+        static auto make(T const& value) { return winrt::make<impl::reference<T>>(value); }
+        using itf = Windows::Foundation::IReference<T>;
     };
 
     template <>
@@ -205,41 +286,13 @@ WINRT_EXPORT namespace winrt::impl
         using itf = Windows::Foundation::IInspectable;
     };
 
-    template <>
-    struct reference_traits<guid>
-    {
-        static auto make(guid const& value) { return Windows::Foundation::PropertyValue::CreateGuid(value); }
-        using itf = Windows::Foundation::IReference<guid>;
-    };
-
     template <>
     struct reference_traits<GUID>
     {
-        static auto make(GUID const& value) { return Windows::Foundation::PropertyValue::CreateGuid(reinterpret_cast<guid const&>(value)); }
+        static auto make(GUID const& value) { return reference_traits<guid>::make(reinterpret_cast<guid const&>(value)); }
         using itf = Windows::Foundation::IReference<guid>;
     };
 
-    template <>
-    struct reference_traits<Windows::Foundation::DateTime>
-    {
-        static auto make(Windows::Foundation::DateTime value) { return Windows::Foundation::PropertyValue::CreateDateTime(value); }
-        using itf = Windows::Foundation::IReference<Windows::Foundation::DateTime>;
-    };
-
-    template <>
-    struct reference_traits<Windows::Foundation::TimeSpan>
-    {
-        static auto make(Windows::Foundation::TimeSpan value) { return Windows::Foundation::PropertyValue::CreateTimeSpan(value); }
-        using itf = Windows::Foundation::IReference<Windows::Foundation::TimeSpan>;
-    };
-
-    template <>
-    struct reference_traits<Windows::Foundation::Point>
-    {
-        static auto make(Windows::Foundation::Point const& value) { return Windows::Foundation::PropertyValue::CreatePoint(value); }
-        using itf = Windows::Foundation::IReference<Windows::Foundation::Point>;
-    };
-
     template <>
     struct reference_traits<Windows::Foundation::Size>
     {
@@ -257,77 +310,77 @@ WINRT_EXPORT namespace winrt::impl
     template <>
     struct reference_traits<com_array<std::uint8_t>>
     {
-        static auto make(array_view<std::uint8_t const> const& value) { return Windows::Foundation::PropertyValue::CreateUInt8Array(value); }
+        static auto make(array_view<std::uint8_t const> const& value) { return winrt::make<impl::reference_array<std::uint8_t>>(value); }
         using itf = Windows::Foundation::IReferenceArray<std::uint8_t>;
     };
 
     template <>
     struct reference_traits<com_array<std::int16_t>>
     {
-        static auto make(array_view<std::int16_t const> const& value) { return Windows::Foundation::PropertyValue::CreateInt16Array(value); }
+        static auto make(array_view<std::int16_t const> const& value) { return winrt::make<impl::reference_array<std::int16_t>>(value); }
         using itf = Windows::Foundation::IReferenceArray<std::int16_t>;
     };
 
     template <>
     struct reference_traits<com_array<std::uint16_t>>
     {
-        static auto make(array_view<std::uint16_t const> const& value) { return Windows::Foundation::PropertyValue::CreateUInt16Array(value); }
+        static auto make(array_view<std::uint16_t const> const& value) { return winrt::make<impl::reference_array<std::uint16_t>>(value); }
         using itf = Windows::Foundation::IReferenceArray<std::uint16_t>;
     };
 
     template <>
     struct reference_traits<com_array<std::int32_t>>
     {
-        static auto make(array_view<std::int32_t const> const& value) { return Windows::Foundation::PropertyValue::CreateInt32Array(value); }
+        static auto make(array_view<std::int32_t const> const& value) { return winrt::make<impl::reference_array<std::int32_t>>(value); }
         using itf = Windows::Foundation::IReferenceArray<std::int32_t>;
     };
 
     template <>
     struct reference_traits<com_array<std::uint32_t>>
     {
-        static auto make(com_array<std::uint32_t> const& value) { return Windows::Foundation::PropertyValue::CreateUInt32Array(value); }
+        static auto make(com_array<std::uint32_t> const& value) { return winrt::make<impl::reference_array<std::uint32_t>>(value); }
         using itf = Windows::Foundation::IReferenceArray<std::uint32_t>;
     };
 
     template <>
     struct reference_traits<com_array<std::int64_t>>
     {
-        static auto make(array_view<std::int64_t const> const& value) { return Windows::Foundation::PropertyValue::CreateInt64Array(value); }
+        static auto make(array_view<std::int64_t const> const& value) { return winrt::make<impl::reference_array<std::int64_t>>(value); }
         using itf = Windows::Foundation::IReferenceArray<std::int64_t>;
     };
 
     template <>
     struct reference_traits<com_array<std::uint64_t>>
     {
-        static auto make(array_view<std::uint64_t const> const& value) { return Windows::Foundation::PropertyValue::CreateUInt64Array(value); }
+        static auto make(array_view<std::uint64_t const> const& value) { return winrt::make<impl::reference_array<std::uint64_t>>(value); }
         using itf = Windows::Foundation::IReferenceArray<std::uint64_t>;
     };
 
     template <>
     struct reference_traits<com_array<float>>
     {
-        static auto make(array_view<float const> const& value) { return Windows::Foundation::PropertyValue::CreateSingleArray(value); }
+        static auto make(array_view<float const> const& value) { return winrt::make<impl::reference_array<float>>(value); }
         using itf = Windows::Foundation::IReferenceArray<float>;
     };
 
     template <>
     struct reference_traits<com_array<double>>
     {
-        static auto make(array_view<double const> const& value) { return Windows::Foundation::PropertyValue::CreateDoubleArray(value); }
+        static auto make(array_view<double const> const& value) { return winrt::make<impl::reference_array<double>>(value); }
         using itf = Windows::Foundation::IReferenceArray<double>;
     };
 
     template <>
     struct reference_traits<com_array<char16_t>>
     {
-        static auto make(array_view<char16_t const> const& value) { return Windows::Foundation::PropertyValue::CreateChar16Array(value); }
+        static auto make(array_view<char16_t const> const& value) { return winrt::make<impl::reference_array<char16_t>>(value); }
         using itf = Windows::Foundation::IReferenceArray<char16_t>;
     };
 
     template <>
     struct reference_traits<com_array<bool>>
     {
-        static auto make(array_view<bool const> const& value) { return Windows::Foundation::PropertyValue::CreateBooleanArray(value); }
+        static auto make(array_view<bool const> const& value) { return winrt::make<impl::reference_array<bool>>(value); }
         using itf = Windows::Foundation::IReferenceArray<bool>;
     };
 
@@ -348,14 +401,14 @@ WINRT_EXPORT namespace winrt::impl
     template <>
     struct reference_traits<com_array<guid>>
     {
-        static auto make(array_view<guid const> const& value) { return Windows::Foundation::PropertyValue::CreateGuidArray(value); }
+        static auto make(array_view<guid const> const& value) { return winrt::make<impl::reference_array<guid>>(value); }
         using itf = Windows::Foundation::IReferenceArray<guid>;
     };
 
     template <>
     struct reference_traits<com_array<GUID>>
     {
-        static auto make(array_view<GUID const> const& value) { return Windows::Foundation::PropertyValue::CreateGuidArray(reinterpret_cast<array_view<guid const> const&>(value)); }
+        static auto make(array_view<GUID const> const& value) { return winrt::make<impl::reference_array<guid>>(reinterpret_cast<array_view<guid const> const&>(value)); }
         using itf = Windows::Foundation::IReferenceArray<guid>;
     };
 
@@ -376,7 +429,7 @@ WINRT_EXPORT namespace winrt::impl
     template <>
     struct reference_traits<com_array<Windows::Foundation::Point>>
     {
-        static auto make(array_view<Windows::Foundation::Point const> const& value) { return Windows::Foundation::PropertyValue::CreatePointArray(value); }
+        static auto make(array_view<Windows::Foundation::Point const> const& value) { return winrt::make<impl::reference_array<Windows::Foundation::Point>>(value); }
         using itf = Windows::Foundation::IReferenceArray<Windows::Foundation::Point>;
     };
 
diff --git a/strings/base_string.h b/strings/base_string.h
index 6b1fb37b5..50a248c02 100644
--- a/strings/base_string.h
+++ b/strings/base_string.h
@@ -155,6 +155,24 @@ WINRT_EXPORT namespace winrt::impl
             return nullptr;
         }
     };
+
+    template <std::size_t N>
+    struct hstring_literal_storage
+    {
+        static constexpr std::size_t size = N;
+        wchar_t value[N];
+
+        constexpr hstring_literal_storage(wchar_t const (&str)[N]) noexcept
+        {
+            for (std::size_t i = 0; i != N; ++i)
+            {
+                value[i] = str[i];
+            }
+        }
+    };
+
+    template <std::size_t N>
+    hstring_literal_storage(wchar_t const (&)[N]) -> hstring_literal_storage<N>;
 }
 
 WINRT_EXPORT namespace winrt
@@ -386,6 +404,30 @@ WINRT_EXPORT namespace winrt
         handle_type<impl::hstring_traits> m_handle;
     };
 
+    struct hstring_reference
+    {
+        constexpr hstring_reference() noexcept = default;
+
+        constexpr explicit hstring_reference(impl::hstring_header const* header) noexcept :
+            m_handle(const_cast<impl::hstring_header*>(header))
+        {
+        }
+
+        operator hstring const&() const noexcept
+        {
+            return *reinterpret_cast<hstring const*>(this);
+        }
+
+    private:
+
+        [[maybe_unused]] void* m_handle{};
+    };
+
+    inline void* get_abi(hstring_reference const& object) noexcept
+    {
+        return *(void**)(&object);
+    }
+
     inline void* get_abi(hstring const& object) noexcept
     {
         return *(void**)(&object);
@@ -437,6 +479,44 @@ WINRT_EXPORT namespace winrt
     }
 }
 
+#if defined(__cpp_nontype_template_args) && __cpp_nontype_template_args >= 201911L
+
+WINRT_EXPORT namespace winrt::impl
+{
+    template <hstring_literal_storage Literal>
+    inline constexpr hstring_header hstring_literal_header
+    {
+        hstring_reference_flag,
+        static_cast<std::uint32_t>(Literal.size - 1),
+        0,
+        0,
+        Literal.value
+    };
+}
+
+WINRT_EXPORT namespace winrt
+{
+    inline namespace literals
+    {
+        template <impl::hstring_literal_storage Literal>
+        constexpr hstring_reference operator ""_hs() noexcept
+        {
+            static_assert(Literal.value[Literal.size - 1] == L'\0', "_hs requires a null-terminated wide string literal");
+
+            if constexpr (Literal.size <= 1)
+            {
+                return hstring_reference{};
+            }
+            else
+            {
+                return hstring_reference{ &impl::hstring_literal_header<Literal> };
+            }
+        }
+    }
+}
+
+#endif
+
 #ifdef __cpp_lib_format
 template<>
 struct std::formatter<winrt::hstring, wchar_t> : std::formatter<std::wstring_view, wchar_t> {};
diff --git a/strings/base_string_input.h b/strings/base_string_input.h
index 71cd5f3c0..ccf955547 100644
--- a/strings/base_string_input.h
+++ b/strings/base_string_input.h
@@ -18,6 +18,10 @@ WINRT_EXPORT namespace winrt::param
         {
         }
 
+        hstring(winrt::hstring_reference const& value) noexcept : m_handle(get_abi(value))
+        {
+        }
+
         hstring(std::wstring_view const& value) noexcept
         {
             create_string_reference(value.data(), value.size());
diff --git a/test/test/reference_boxing.cpp b/test/test/reference_boxing.cpp
new file mode 100644
index 000000000..c6e300886
--- /dev/null
+++ b/test/test/reference_boxing.cpp
@@ -0,0 +1,268 @@
+#include "pch.h"
+#include <objbase.h>
+#include <objidl.h>
+#include <thread>
+
+using namespace winrt;
+using namespace Windows::Foundation;
+
+// Scalar box_value now produces a local IReference/IPropertyValue instead of hopping to
+// combase PropertyValue. These confirm it reports the correct PropertyType, keeps combase-style
+// numeric conversion on mismatched getters, and round-trips through unbox_value.
+TEST_CASE("reference_boxing")
+{
+    {
+        auto boxed = box_value(42);
+        auto pv = boxed.as<IPropertyValue>();
+        REQUIRE(pv.Type() == PropertyType::Int32);
+        REQUIRE(pv.IsNumericScalar());
+        REQUIRE(pv.GetInt32() == 42);
+        REQUIRE(pv.GetInt16() == 42);
+        REQUIRE(pv.GetDouble() == 42.0);
+        // A scalar reference holds no array, so every array getter routes through get_as and throws.
+        {
+            com_array<int32_t> ints;
+            REQUIRE_THROWS_AS(pv.GetInt32Array(ints), hresult_not_implemented);
+            com_array<hstring> strings;
+            REQUIRE_THROWS_AS(pv.GetStringArray(strings), hresult_not_implemented);
+        }
+        REQUIRE(unbox_value<int32_t>(boxed) == 42);
+    }
+
+    {
+        auto pv = box_value(3.5).as<IPropertyValue>();
+        REQUIRE(pv.Type() == PropertyType::Double);
+        REQUIRE(pv.IsNumericScalar());
+        REQUIRE(pv.GetDouble() == 3.5);
+        REQUIRE(pv.GetSingle() == 3.5f);
+    }
+
+    {
+        auto pv = box_value(hstring{ L"hello" }).as<IPropertyValue>();
+        REQUIRE(pv.Type() == PropertyType::String);
+        REQUIRE(!pv.IsNumericScalar());
+        REQUIRE(pv.GetString() == L"hello");
+        REQUIRE_THROWS_AS(pv.GetInt32(), hresult_not_implemented);
+    }
+
+    {
+        auto pv = box_value(true).as<IPropertyValue>();
+        REQUIRE(pv.Type() == PropertyType::Boolean);
+        REQUIRE(!pv.IsNumericScalar());
+        REQUIRE(pv.GetBoolean());
+        REQUIRE_THROWS_AS(pv.GetInt32(), hresult_not_implemented);
+    }
+
+    {
+        guid const g{ 0x11223344, 0x5566, 0x7788, { 0x99, 0xAA, 0xBB, 0xCC, 0xDD, 0xEE, 0xFF, 0x00 } };
+        auto pv = box_value(g).as<IPropertyValue>();
+        REQUIRE(pv.Type() == PropertyType::Guid);
+        REQUIRE(!pv.IsNumericScalar());
+        REQUIRE(pv.GetGuid() == g);
+    }
+
+    {
+        auto pv = box_value(static_cast<uint8_t>(7)).as<IPropertyValue>();
+        REQUIRE(pv.Type() == PropertyType::UInt8);
+        REQUIRE(pv.IsNumericScalar());
+        REQUIRE(pv.GetUInt8() == 7);
+        REQUIRE(unbox_value<uint8_t>(box_value(static_cast<uint8_t>(7))) == 7);
+    }
+
+    // DateTime, TimeSpan, and Point are also boxed in-process now (they still marshal by value).
+    {
+        Point const point{ 3.0f, 4.0f };
+        auto pv = box_value(point).as<IPropertyValue>();
+        REQUIRE(pv.Type() == PropertyType::Point);
+        REQUIRE(!pv.IsNumericScalar());
+        REQUIRE(pv.GetPoint().X == point.X);
+        REQUIRE(pv.GetPoint().Y == point.Y);
+        auto const round_tripped = unbox_value<Point>(box_value(point));
+        REQUIRE(round_tripped.X == point.X);
+        REQUIRE(round_tripped.Y == point.Y);
+        REQUIRE_THROWS_AS(pv.GetInt32(), hresult_not_implemented);
+    }
+
+    {
+        TimeSpan const span{ std::chrono::seconds{ 90 } };
+        auto pv = box_value(span).as<IPropertyValue>();
+        REQUIRE(pv.Type() == PropertyType::TimeSpan);
+        REQUIRE(!pv.IsNumericScalar());
+        REQUIRE(pv.GetTimeSpan() == span);
+        REQUIRE(unbox_value<TimeSpan>(box_value(span)) == span);
+    }
+
+    {
+        DateTime const when{ TimeSpan{ std::chrono::seconds{ 1000 } } };
+        auto pv = box_value(when).as<IPropertyValue>();
+        REQUIRE(pv.Type() == PropertyType::DateTime);
+        REQUIRE(!pv.IsNumericScalar());
+        REQUIRE(pv.GetDateTime() == when);
+        REQUIRE(unbox_value<DateTime>(box_value(when)) == when);
+    }
+}
+
+// Array boxing produces a local IReferenceArray<T> / IPropertyValue (no combase PropertyValue) for the
+// stock element types. Confirm the array PropertyType, round-trips, and the get_as throw behavior.
+TEST_CASE("reference_boxing arrays")
+{
+    {
+        int32_t values[]{ 0, 42, 1729, -1 };
+        auto boxed = box_value(com_array<int32_t>{ std::begin(values), std::end(values) });
+        auto pv = boxed.as<IPropertyValue>();
+        REQUIRE(pv.Type() == PropertyType::Int32Array);
+        REQUIRE(!pv.IsNumericScalar());
+
+        com_array<int32_t> out;
+        pv.GetInt32Array(out);
+        REQUIRE(out == array_view<int32_t>{ values });
+
+        // A scalar getter on an array PV throws, and so does a mismatched-element array getter.
+        REQUIRE_THROWS_AS(pv.GetInt32(), hresult_not_implemented);
+        com_array<double> wrong;
+        REQUIRE_THROWS_AS(pv.GetDoubleArray(wrong), hresult_not_implemented);
+
+        REQUIRE(unbox_value<com_array<int32_t>>(boxed) == array_view<int32_t>{ values });
+        REQUIRE(boxed.as<IReferenceArray<int32_t>>().Value() == array_view<int32_t>{ values });
+    }
+
+    // guid arrays are local too.
+    {
+        guid values[]{
+            { 0x11223344, 0x5566, 0x7788, { 0x99, 0xAA, 0xBB, 0xCC, 0xDD, 0xEE, 0xFF, 0x00 } },
+            { 0x00112233, 0x4455, 0x6677, { 0x88, 0x99, 0xAA, 0xBB, 0xCC, 0xDD, 0xEE, 0xFF } } };
+        auto boxed = box_value(com_array<guid>{ std::begin(values), std::end(values) });
+        REQUIRE(boxed.as<IPropertyValue>().Type() == PropertyType::GuidArray);
+        REQUIRE(unbox_value<com_array<guid>>(boxed) == array_view<guid>{ values });
+    }
+}
+
+// The local array reference must marshal by value across processes just like the scalar one: its
+// IMarshal reports the same unmarshal class as a genuine combase array PropertyValue, and not the
+// free-threaded (by-reference) class.
+TEST_CASE("reference_boxing array marshal by value")
+{
+    int32_t values[]{ 1, 2, 3 };
+    auto boxed = box_value(com_array<int32_t>{ std::begin(values), std::end(values) });
+    REQUIRE(boxed.try_as<IAgileObject>());
+    auto ours = boxed.as<impl::IMarshal>();
+
+    auto genuine = PropertyValue::CreateInt32Array(values);
+    auto reference = genuine.as<impl::IMarshal>();
+
+    guid our_clsid{};
+    guid reference_clsid{};
+    check_hresult(ours->GetUnmarshalClass(guid_of<IPropertyValue>(), get_unknown(boxed),
+        MSHCTX_DIFFERENTMACHINE, nullptr, MSHLFLAGS_NORMAL, &our_clsid));
+    check_hresult(reference->GetUnmarshalClass(guid_of<IPropertyValue>(), get_unknown(genuine),
+        MSHCTX_DIFFERENTMACHINE, nullptr, MSHLFLAGS_NORMAL, &reference_clsid));
+
+    REQUIRE(our_clsid == reference_clsid);
+
+    guid const free_threaded_marshaler{ 0x0000033A, 0x0000, 0x0000, { 0xC0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x46 } };
+    REQUIRE(our_clsid != free_threaded_marshaler);
+}
+
+// The in-proc reference stays agile but must marshal by value across processes, exactly like a real
+// combase PropertyValue. Prove it by confirming our IMarshal reports the SAME unmarshal class as a
+// genuine PropertyValue - i.e. we forward marshaling to combase - and specifically NOT the
+// free-threaded (marshal-by-reference) class the default agile path would have used.
+TEST_CASE("reference_boxing marshal by value")
+{
+    auto boxed = box_value(42);
+    REQUIRE(boxed.try_as<IAgileObject>());
+    auto ours = boxed.as<impl::IMarshal>();
+
+    auto genuine = PropertyValue::CreateInt32(42);
+    auto reference = genuine.as<impl::IMarshal>();
+
+    guid our_clsid{};
+    guid reference_clsid{};
+    check_hresult(ours->GetUnmarshalClass(guid_of<IPropertyValue>(), get_unknown(boxed),
+        MSHCTX_DIFFERENTMACHINE, nullptr, MSHLFLAGS_NORMAL, &our_clsid));
+    check_hresult(reference->GetUnmarshalClass(guid_of<IPropertyValue>(), get_unknown(genuine),
+        MSHCTX_DIFFERENTMACHINE, nullptr, MSHLFLAGS_NORMAL, &reference_clsid));
+
+    REQUIRE(our_clsid == reference_clsid);
+
+    // CLSID_InProcFreeMarshaler - the by-reference class the agile FTM would have produced.
+    guid const free_threaded_marshaler{ 0x0000033A, 0x0000, 0x0000, { 0xC0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x46 } };
+    REQUIRE(our_clsid != free_threaded_marshaler);
+}
+
+// The in-proc reference advertises IAgileObject, so handing it between two single-threaded
+// apartments in the same process must resolve to the *same* object pointer - no proxy. The Global
+// Interface Table returns an agile object's original pointer directly, but hands back a proxy (a
+// different identity) for a non-agile object, so pointer equality here confirms the agile fast path.
+TEST_CASE("reference_boxing agile in-proc identity across apartments")
+{
+    auto identity_of = [](::IUnknown* raw) -> void*
+    {
+        com_ptr<::IUnknown> identity;
+        check_hresult(raw->QueryInterface(IID_PPV_ARGS(identity.put())));
+        return identity.get();
+    };
+
+    com_ptr<IGlobalInterfaceTable> git;
+    check_hresult(CoCreateInstance(CLSID_StdGlobalInterfaceTable, nullptr,
+        CLSCTX_INPROC_SERVER, IID_PPV_ARGS(git.put())));
+
+    Windows::Foundation::IInspectable boxed{ nullptr };
+    DWORD cookie{};
+    void* original_identity{};
+    void* marshaled_identity{};
+    HRESULT sta1_hr = S_OK;
+    HRESULT sta2_hr = S_OK;
+
+    handle registered{ check_pointer(CreateEventW(nullptr, true, false, nullptr)) };
+    handle fetched{ check_pointer(CreateEventW(nullptr, true, false, nullptr)) };
+
+    std::thread sta1([&]
+    {
+        sta1_hr = CoInitializeEx(nullptr, COINIT_APARTMENTTHREADED);
+        if (SUCCEEDED(sta1_hr))
+        {
+            boxed = box_value(42);
+            auto unknown = reinterpret_cast<::IUnknown*>(get_abi(boxed));
+            original_identity = identity_of(unknown);
+            sta1_hr = git->RegisterInterfaceInGlobal(unknown, IID_IUnknown, &cookie);
+        }
+        SetEvent(registered.get());
+
+        WaitForSingleObject(fetched.get(), INFINITE);
+        if (SUCCEEDED(sta1_hr))
+        {
+            CoUninitialize();
+        }
+    });
+
+    std::thread sta2([&]
+    {
+        WaitForSingleObject(registered.get(), INFINITE);
+        if (SUCCEEDED(sta1_hr))
+        {
+            sta2_hr = CoInitializeEx(nullptr, COINIT_APARTMENTTHREADED);
+            if (SUCCEEDED(sta2_hr))
+            {
+                ::IUnknown* raw{};
+                sta2_hr = git->GetInterfaceFromGlobal(cookie, IID_IUnknown, reinterpret_cast<void**>(&raw));
+                if (SUCCEEDED(sta2_hr))
+                {
+                    marshaled_identity = identity_of(raw);
+                    raw->Release();
+                }
+                git->RevokeInterfaceFromGlobal(cookie);
+                CoUninitialize();
+            }
+        }
+        SetEvent(fetched.get());
+    });
+
+    sta1.join();
+    sta2.join();
+
+    REQUIRE(SUCCEEDED(sta1_hr));
+    REQUIRE(SUCCEEDED(sta2_hr));
+    REQUIRE(original_identity != nullptr);
+    REQUIRE(original_identity == marshaled_identity);
+}
diff --git a/test/test/test.vcxproj b/test/test/test.vcxproj
index 43928dab2..f95584d99 100644
--- a/test/test/test.vcxproj
+++ b/test/test/test.vcxproj
@@ -324,6 +324,7 @@
     <ClCompile Include="main.cpp">
       <PrecompiledHeader>NotUsing</PrecompiledHeader>
     </ClCompile>
+    <ClCompile Include="reference_boxing.cpp" />
     <ClCompile Include="memory_buffer.cpp" />
     <ClCompile Include="missing_required_interfaces.cpp" />
     <ClCompile Include="module_lock_dll.cpp">
diff --git a/test/test_cpp20/hstring_literal.cpp b/test/test_cpp20/hstring_literal.cpp
new file mode 100644
index 000000000..2ba0f3ad7
--- /dev/null
+++ b/test/test_cpp20/hstring_literal.cpp
@@ -0,0 +1,68 @@
+#include "pch.h"
+
+using namespace winrt;
+using namespace std::literals;
+
+#if defined(__cpp_nontype_template_args) && __cpp_nontype_template_args >= 201911L
+
+using namespace winrt::literals;
+
+namespace
+{
+    // Exercises the hstring_reference -> param::hstring conversion that projected
+    // setters rely on, and duplicates into an owning hstring on the way out.
+    winrt::hstring copy_via_param(winrt::param::hstring const& value)
+    {
+        winrt::hstring const& as_hstring = value;
+        return as_hstring;
+    }
+}
+
+TEST_CASE("hstring_literal")
+{
+    // The literal is a genuine constant expression: the fast-pass header is built at
+    // compile time, so an hstring_reference can be constructed in a constexpr context.
+    {
+        constexpr winrt::hstring_reference lit = L"kittens"_hs;
+        winrt::hstring const& value = lit;
+        REQUIRE(value == L"kittens"sv);
+        REQUIRE(value.size() == 7);
+    }
+
+    // Content and length match the literal.
+    {
+        winrt::hstring_reference const lit = L"kittens"_hs;
+        winrt::hstring const& value = lit;
+        REQUIRE(value == L"kittens"sv);
+        REQUIRE(value.size() == 7);
+        REQUIRE(wcslen(value.c_str()) == 7);
+    }
+
+    // Built as a fast-pass reference string (no heap allocation).
+    {
+        winrt::hstring_reference const lit = L"puppies"_hs;
+        auto const header = static_cast<winrt::impl::hstring_header*>(winrt::get_abi(lit));
+        REQUIRE(header != nullptr);
+        REQUIRE((header->flags & winrt::impl::hstring_reference_flag) != 0);
+        REQUIRE(header->length == 7);
+    }
+
+    // Empty literal projects as the empty (null) HSTRING.
+    {
+        winrt::hstring_reference const lit = L""_hs;
+        winrt::hstring const& value = lit;
+        REQUIRE(value.empty());
+        REQUIRE(value.size() == 0);
+        REQUIRE(winrt::get_abi(value) == nullptr);
+    }
+
+    // Binds to a projected setter parameter in a single conversion, and copying
+    // into an owning hstring duplicates correctly.
+    {
+        winrt::hstring const copied = copy_via_param(L"waffles"_hs);
+        REQUIRE(copied == L"waffles"sv);
+        REQUIRE(copied.size() == 7);
+    }
+}
+
+#endif
diff --git a/test/test_cpp20/test_cpp20.vcxproj b/test/test_cpp20/test_cpp20.vcxproj
index 4eaee0a18..b13becd23 100644
--- a/test/test_cpp20/test_cpp20.vcxproj
+++ b/test/test_cpp20/test_cpp20.vcxproj
@@ -239,6 +239,7 @@
     <ClCompile Include="custom_error.cpp" />
     <ClCompile Include="format.cpp" />
     <ClCompile Include="hstring.cpp" />
+    <ClCompile Include="hstring_literal.cpp" />
     <ClCompile Include="main.cpp">
       <PrecompiledHeader>NotUsing</PrecompiledHeader>
     </ClCompile>