diff --git a/cppwinrt/code_writers.h b/cppwinrt/code_writers.h
index 2e9c458b5..dbdec7b11 100644
--- a/cppwinrt/code_writers.h
+++ b/cppwinrt/code_writers.h
@@ -203,9 +203,20 @@ namespace cppwinrt
         return { w, write_close_namespace };
     }
 
+    [[nodiscard]] static finish_with wrap_impl_namespace_without_export(writer& w)
+    {
+        auto format = R"(extern "C++" namespace winrt::impl
+{
+)";
+
+        w.write(format);
+
+        return { w, write_close_namespace };
+    }
+
     [[nodiscard]] static finish_with wrap_std_namespace(writer& w)
     {
-        w.write(R"(WINRT_EXPORT namespace std
+        w.write(R"(extern "C++" namespace std
 {
 )");
 
diff --git a/cppwinrt/file_writers.h b/cppwinrt/file_writers.h
index 6f9b4db5d..397785fe5 100644
--- a/cppwinrt/file_writers.h
+++ b/cppwinrt/file_writers.h
@@ -44,6 +44,11 @@ namespace cppwinrt
         {
             auto wrap_file_guard = wrap_open_file_guard(w, "BASE");
 
+            if (settings.modules)
+            {
+                w.write("#ifndef WINRT_CONSUME_MODULE\n");
+            }
+
             {
                 // In module builds, generated projection headers must be "module-aware":
                 // When `WINRT_MODULE` is defined (inside a module interface unit), suppress textual includes so the
@@ -85,6 +90,11 @@ namespace cppwinrt
             w.write(strings::base_coroutine_threadpool);
             w.write(strings::base_natvis);
             w.write(strings::base_version);
+
+            if (settings.modules)
+            {
+                w.write("#endif\n");
+            }
         }
         w.flush_to_file(settings.output_folder + "winrt/base.h");
     }
@@ -142,7 +152,7 @@ namespace cppwinrt
             w.write_each<write_forward>(members.contracts);
         }
         {
-            auto wrap_impl = wrap_impl_namespace(w);
+            auto wrap_impl = wrap_impl_namespace_without_export(w);
             w.write_each<write_category>(members.interfaces, "interface_category");
             w.write_each<write_category>(members.classes, "class_category");
             w.write_each<write_category>(members.enums, "enum_category");
@@ -165,9 +175,12 @@ namespace cppwinrt
             w.write_each<write_default_interface>(members.classes);
             w.write_each<write_interface_abi>(members.interfaces);
             w.write_each<write_delegate_abi>(members.delegates);
-            w.write_each<write_consume>(members.interfaces);
             w.write_each<write_struct_abi>(members.structs);
         }
+        {
+            auto wrap_impl = wrap_impl_namespace(w);
+            w.write_each<write_consume>(members.interfaces);
+        }
 
         if (settings.modules)
         {
@@ -319,66 +332,38 @@ namespace cppwinrt
 #undef GetCurrentTime
 #endif
 
+// Include in advance so that all of numerics's dependencies can be in the global module fragment
+#include <stdexcept>
+#include <limits>
+#if __has_include(<directxmath.h>) && __has_include(<windowsnumerics.impl.h>)
+#include <directxmath.h>
+#endif
+
 export module winrt.base;
 
 // Module dependencies:
 //   - std
-//   - winrt.numerics (re-exported when available)
 
 import std;
-export import winrt.numerics;
-
-#if __has_include(<windowsnumerics.impl.h>)
-#define WINRT_IMPL_NUMERICS
-#endif
-
-#include "winrt/base.h"
-)");
 
-        w.flush_to_file(settings.output_folder + "winrt/winrt.base.ixx");
-    }
-
-    static void write_numerics_ixx()
-    {
-        // Emits $(out)\winrt\winrt.numerics.ixx  (export module winrt.numerics;)
-        // <windowsnumerics.impl.h> pulls in large, legacy headers that are hard to control and can trigger module
-        // diagnostics when textually included in a module purview.
-        // If the header does not exist, then the module exports nothing. To speed up module scanning, modules
-        // can't be controlled by preprocessor directives. Therefore, winrt.base cannot conditionally import it.
-        // In header builds we preserve the historical behavior (base headers include it), but in module builds we
-        // centralize it in this single module and have `winrt.base` re-export it.
-        // MSVC warns (C5244) when encountering textual includes inside a module purview; suppress for this file.
-        writer w;
-        write_preamble(w);
-        write_module_global_fragment(w);
-
-        w.write(R"(
-export module winrt.numerics;
-
-// Module dependencies:
-//   - (none)
-
-#if __has_include(<windowsnumerics.impl.h>)
-#ifdef _MSC_VER
-#pragma warning(push)
+// An MSVC warning whose cause cannot be analyzed
+// warning C5244: '#include <windowsnumerics.impl.h>' in the purview of module 'winrt.base' appears erroneous.  Consider moving that directive before the module declaration, or replace the textual inclusion with 'import <windowsnumerics.impl.h>;'.
 #pragma warning(disable : 5244)
-#endif
-#include <directxmath.h>
 
+#if __has_include(<windowsnumerics.impl.h>)
 #define _WINDOWS_NUMERICS_NAMESPACE_ winrt::Windows::Foundation::Numerics
-#define _WINDOWS_NUMERICS_BEGIN_NAMESPACE_ export extern "C++" namespace winrt::Windows::Foundation::Numerics
+#define _WINDOWS_NUMERICS_BEGIN_NAMESPACE_ export extern "C++" namespace _WINDOWS_NUMERICS_NAMESPACE_
 #define _WINDOWS_NUMERICS_END_NAMESPACE_
 #include <windowsnumerics.impl.h>
 #undef _WINDOWS_NUMERICS_NAMESPACE_
 #undef _WINDOWS_NUMERICS_BEGIN_NAMESPACE_
 #undef _WINDOWS_NUMERICS_END_NAMESPACE_
-#ifdef _MSC_VER
-#pragma warning(pop)
-#endif
 #endif
+
+#include "winrt/base.h"
 )");
 
-        w.flush_to_file(settings.output_folder + "winrt/winrt.numerics.ixx");
+        w.flush_to_file(settings.output_folder + "winrt/winrt.base.ixx");
     }
 
     static void write_namespace_ixx(std::string_view const& ns, std::vector<std::string> const& imports)
@@ -581,7 +566,7 @@ export import winrt.base;
         w.type_namespace = ns;
 
         {
-            auto wrap_impl = wrap_impl_namespace(w);
+            auto wrap_impl = wrap_impl_namespace_without_export(w);
             w.write_each<write_consume_definitions>(members.interfaces);
             w.param_names = true;
             w.write_each<write_delegate_implementation>(members.delegates);
diff --git a/cppwinrt/main.cpp b/cppwinrt/main.cpp
index 9f2e4403b..8695e10ca 100644
--- a/cppwinrt/main.cpp
+++ b/cppwinrt/main.cpp
@@ -622,7 +622,6 @@ R"(  local               Local ^%WinDir^%\System32\WinMetadata folder
 
             if (settings.modules)
             {
-                write_numerics_ixx();
                 write_base_ixx();
             }
 
diff --git a/cppwinrt/type_writers.h b/cppwinrt/type_writers.h
index bb56c5724..182007701 100644
--- a/cppwinrt/type_writers.h
+++ b/cppwinrt/type_writers.h
@@ -334,13 +334,7 @@ namespace cppwinrt
             {
                 if (ns == "Windows.Foundation.Numerics")
                 {
-                    if (name == "Matrix3x2") { name = "float3x2"; }
-                    else if (name == "Matrix4x4") { name = "float4x4"; }
-                    else if (name == "Plane") { name = "plane"; }
-                    else if (name == "Quaternion") { name = "quaternion"; }
-                    else if (name == "Vector2") { name = "float2"; }
-                    else if (name == "Vector3") { name = "float3"; }
-                    else if (name == "Vector4") { name = "float4"; }
+                    transform_special_numeric_type(name);
 
                     write("winrt::@::%", ns, name);
                 }
diff --git a/strings/base_abi.h b/strings/base_abi.h
index 4b7b8f77f..7a5b3550b 100644
--- a/strings/base_abi.h
+++ b/strings/base_abi.h
@@ -1,5 +1,5 @@
 
-WINRT_EXPORT namespace winrt::impl
+extern "C++" namespace winrt::impl
 {
     template <> struct abi<Windows::Foundation::IUnknown>
     {
@@ -11,7 +11,7 @@ WINRT_EXPORT namespace winrt::impl
         };
     };
 
-    using unknown_abi = abi_t<Windows::Foundation::IUnknown>;
+    WINRT_EXPORT using unknown_abi = abi_t<Windows::Foundation::IUnknown>;
 
     template <> struct abi<Windows::Foundation::IInspectable>
     {
@@ -23,7 +23,7 @@ WINRT_EXPORT namespace winrt::impl
         };
     };
 
-    using inspectable_abi = abi_t<Windows::Foundation::IInspectable>;
+    WINRT_EXPORT using inspectable_abi = abi_t<Windows::Foundation::IInspectable>;
 
     template <> struct abi<Windows::Foundation::IActivationFactory>
     {
@@ -33,14 +33,14 @@ WINRT_EXPORT namespace winrt::impl
         };
     };
 
-    struct WINRT_IMPL_ABI_DECL IAgileObject : unknown_abi {};
+    WINRT_EXPORT struct WINRT_IMPL_ABI_DECL IAgileObject : unknown_abi {};
 
-    struct WINRT_IMPL_ABI_DECL IAgileReference : unknown_abi
+    WINRT_EXPORT struct WINRT_IMPL_ABI_DECL IAgileReference : unknown_abi
     {
         virtual std::int32_t __stdcall Resolve(guid const& id, void** object) noexcept = 0;
     };
 
-    struct WINRT_IMPL_ABI_DECL IMarshal : unknown_abi
+    WINRT_EXPORT struct WINRT_IMPL_ABI_DECL IMarshal : unknown_abi
     {
         virtual std::int32_t __stdcall GetUnmarshalClass(guid const& riid, void* pv, std::uint32_t dwDestContext, void* pvDestContext, std::uint32_t mshlflags, guid* pCid) noexcept = 0;
         virtual std::int32_t __stdcall GetMarshalSizeMax(guid const& riid, void* pv, std::uint32_t dwDestContext, void* pvDestContext, std::uint32_t mshlflags, std::uint32_t* pSize) noexcept = 0;
@@ -50,20 +50,20 @@ WINRT_EXPORT namespace winrt::impl
         virtual std::int32_t __stdcall DisconnectObject(std::uint32_t dwReserved) noexcept = 0;
     };
 
-    struct WINRT_IMPL_ABI_DECL IGlobalInterfaceTable : unknown_abi
+    WINRT_EXPORT struct WINRT_IMPL_ABI_DECL IGlobalInterfaceTable : unknown_abi
     {
         virtual std::int32_t __stdcall RegisterInterfaceInGlobal(void* object, guid const& iid, std::uint32_t* cookie) noexcept = 0;
         virtual std::int32_t __stdcall RevokeInterfaceFromGlobal(std::uint32_t cookie) noexcept = 0;
         virtual std::int32_t __stdcall GetInterfaceFromGlobal(std::uint32_t cookie, guid const& iid, void** object) noexcept = 0;
     };
 
-    struct WINRT_IMPL_ABI_DECL IStaticLifetime : inspectable_abi
+    WINRT_EXPORT struct WINRT_IMPL_ABI_DECL IStaticLifetime : inspectable_abi
     {
         virtual std::int32_t __stdcall unused() noexcept = 0;
         virtual std::int32_t __stdcall GetCollection(void** value) noexcept = 0;
     };
 
-    struct WINRT_IMPL_ABI_DECL IStaticLifetimeCollection : inspectable_abi
+    WINRT_EXPORT struct WINRT_IMPL_ABI_DECL IStaticLifetimeCollection : inspectable_abi
     {
         virtual std::int32_t __stdcall Lookup(void*, void**) noexcept = 0;
         virtual std::int32_t __stdcall unused() noexcept = 0;
@@ -74,23 +74,23 @@ WINRT_EXPORT namespace winrt::impl
         virtual std::int32_t __stdcall unused4() noexcept = 0;
     };
 
-    struct WINRT_IMPL_ABI_DECL IWeakReference : unknown_abi
+    WINRT_EXPORT struct WINRT_IMPL_ABI_DECL IWeakReference : unknown_abi
     {
         virtual std::int32_t __stdcall Resolve(guid const& iid, void** objectReference) noexcept = 0;
     };
 
-    struct WINRT_IMPL_ABI_DECL IWeakReferenceSource : unknown_abi
+    WINRT_EXPORT struct WINRT_IMPL_ABI_DECL IWeakReferenceSource : unknown_abi
     {
         virtual std::int32_t __stdcall GetWeakReference(IWeakReference** weakReference) noexcept = 0;
     };
 
-    struct WINRT_IMPL_ABI_DECL IRestrictedErrorInfo : unknown_abi
+    WINRT_EXPORT struct WINRT_IMPL_ABI_DECL IRestrictedErrorInfo : unknown_abi
     {
         virtual std::int32_t __stdcall GetErrorDetails(bstr* description, std::int32_t* error, bstr* restrictedDescription, bstr* capabilitySid) noexcept = 0;
         virtual std::int32_t __stdcall GetReference(bstr* reference) noexcept = 0;
     };
 
-    struct WINRT_IMPL_ABI_DECL IErrorInfo : unknown_abi
+    WINRT_EXPORT struct WINRT_IMPL_ABI_DECL IErrorInfo : unknown_abi
     {
         virtual std::int32_t __stdcall GetGUID(guid* value) noexcept = 0;
         virtual std::int32_t __stdcall GetSource(bstr* value) noexcept = 0;
@@ -99,7 +99,7 @@ WINRT_EXPORT namespace winrt::impl
         virtual std::int32_t __stdcall GetHelpContext(std::uint32_t* value) noexcept = 0;
     };
 
-    struct WINRT_IMPL_ABI_DECL ILanguageExceptionErrorInfo2 : unknown_abi
+    WINRT_EXPORT struct WINRT_IMPL_ABI_DECL ILanguageExceptionErrorInfo2 : unknown_abi
     {
         virtual std::int32_t __stdcall GetLanguageException(void** exception) noexcept = 0;
         virtual std::int32_t __stdcall GetPreviousLanguageExceptionErrorInfo(ILanguageExceptionErrorInfo2** previous) noexcept = 0;
@@ -107,14 +107,14 @@ WINRT_EXPORT namespace winrt::impl
         virtual std::int32_t __stdcall GetPropagationContextHead(ILanguageExceptionErrorInfo2** head) noexcept = 0;
     };
 
-    struct ICallbackWithNoReentrancyToApplicationSTA;
+    WINRT_EXPORT struct ICallbackWithNoReentrancyToApplicationSTA;
 
-    struct WINRT_IMPL_ABI_DECL IContextCallback : unknown_abi
+    WINRT_EXPORT struct WINRT_IMPL_ABI_DECL IContextCallback : unknown_abi
     {
         virtual std::int32_t __stdcall ContextCallback(std::int32_t(__stdcall* callback)(com_callback_args*), com_callback_args* args, guid const& iid, int method, void* reserved) noexcept = 0;
     };
 
-    struct WINRT_IMPL_ABI_DECL IServerSecurity : unknown_abi
+    WINRT_EXPORT struct WINRT_IMPL_ABI_DECL IServerSecurity : unknown_abi
     {
         virtual std::int32_t __stdcall QueryBlanket(std::uint32_t*, std::uint32_t*, wchar_t**, std::uint32_t*, std::uint32_t*, void**, std::uint32_t*) noexcept = 0;
         virtual std::int32_t __stdcall ImpersonateClient() noexcept = 0;
@@ -122,12 +122,12 @@ WINRT_EXPORT namespace winrt::impl
         virtual std::int32_t __stdcall IsImpersonating() noexcept = 0;
     };
 
-    struct WINRT_IMPL_ABI_DECL IBufferByteAccess : unknown_abi
+    WINRT_EXPORT struct WINRT_IMPL_ABI_DECL IBufferByteAccess : unknown_abi
     {
         virtual std::int32_t __stdcall Buffer(std::uint8_t** value) noexcept = 0;
     };
 
-    struct WINRT_IMPL_ABI_DECL IMemoryBufferByteAccess : unknown_abi
+    WINRT_EXPORT struct WINRT_IMPL_ABI_DECL IMemoryBufferByteAccess : unknown_abi
     {
         virtual std::int32_t __stdcall GetBuffer(std::uint8_t** value, std::uint32_t* capacity) noexcept = 0;
     };
diff --git a/strings/base_activation.h b/strings/base_activation.h
index ec4a3e82a..1cee4c306 100644
--- a/strings/base_activation.h
+++ b/strings/base_activation.h
@@ -1,7 +1,7 @@
 
-WINRT_EXPORT namespace winrt::impl
+extern "C++" namespace winrt::impl
 {
-    struct library_traits
+    WINRT_EXPORT struct library_traits
     {
         using type = void*;
 
@@ -16,9 +16,9 @@ WINRT_EXPORT namespace winrt::impl
         }
     };
 
-    using library_handle = handle_type<library_traits>;
+    WINRT_EXPORT using library_handle = handle_type<library_traits>;
 
-    template <bool isSameInterfaceAsIActivationFactory>
+    WINRT_EXPORT template <bool isSameInterfaceAsIActivationFactory>
     WINRT_IMPL_NOINLINE hresult get_runtime_activation_factory_impl(param::hstring const& name, winrt::guid const& guid, void** result) noexcept
     {
         if (winrt_activation_handler)
@@ -96,16 +96,16 @@ WINRT_EXPORT namespace winrt::impl
         return hr;
     }
 
-    template <typename Interface>
+    WINRT_EXPORT template <typename Interface>
     hresult get_runtime_activation_factory(param::hstring const& name, void** result) noexcept
     {
         return get_runtime_activation_factory_impl<std::is_same_v<Interface, Windows::Foundation::IActivationFactory>>(name, guid_of<Interface>(), result);
     }
 }
 
-WINRT_EXPORT namespace winrt
+extern "C++" namespace winrt
 {
-    template <typename Interface = Windows::Foundation::IActivationFactory>
+    WINRT_EXPORT template <typename Interface = Windows::Foundation::IActivationFactory>
     impl::com_ref<Interface> get_activation_factory(param::hstring const& name)
     {
         void* result{};
@@ -114,7 +114,7 @@ WINRT_EXPORT namespace winrt
     }
 }
 
-WINRT_EXPORT namespace winrt::impl
+extern "C++" namespace winrt::impl
 {
 
 #ifdef __clang__
@@ -122,7 +122,7 @@ WINRT_EXPORT namespace winrt::impl
 #pragma clang diagnostic ignored "-Wdeprecated-declarations"
 #endif
 
-    template <typename T>
+    WINRT_EXPORT template <typename T>
     T* interlocked_read_pointer(T* const volatile* target) noexcept
     {
 #if defined(_M_IX86) || defined(_M_X64)
@@ -152,16 +152,16 @@ WINRT_EXPORT namespace winrt::impl
 #endif
 
 #ifdef _WIN64
-    inline constexpr std::uint32_t memory_allocation_alignment{ 16 };
+    WINRT_EXPORT inline constexpr std::uint32_t memory_allocation_alignment{ 16 };
 #if defined(_MSC_VER) && !defined(__clang__)
 #pragma warning(push)
 #pragma warning(disable:4324) // structure was padded due to alignment specifier
 #endif
-    struct alignas(16) slist_entry
+    WINRT_EXPORT struct alignas(16) slist_entry
     {
         slist_entry* next;
     };
-    union alignas(16) slist_header
+    WINRT_EXPORT union alignas(16) slist_header
     {
         struct
         {
@@ -180,12 +180,12 @@ WINRT_EXPORT namespace winrt::impl
 #pragma warning(pop)
 #endif
 #else
-    inline constexpr std::uint32_t memory_allocation_alignment{ 8 };
-    struct slist_entry
+    WINRT_EXPORT inline constexpr std::uint32_t memory_allocation_alignment{ 8 };
+    WINRT_EXPORT struct slist_entry
     {
         slist_entry* next;
     };
-    union slist_header
+    WINRT_EXPORT union slist_header
     {
         std::uint64_t reserved1;
         struct
@@ -197,7 +197,7 @@ WINRT_EXPORT namespace winrt::impl
     };
 #endif
 
-    struct factory_count_guard
+    WINRT_EXPORT struct factory_count_guard
     {
         factory_count_guard(factory_count_guard const&) = delete;
         factory_count_guard& operator=(factory_count_guard const&) = delete;
@@ -228,7 +228,7 @@ WINRT_EXPORT namespace winrt::impl
         [[maybe_unused]] std::size_t& m_count; // Field is unused when WINRT_NO_MODULE_LOCK is defined.
     };
 
-    struct factory_cache_entry_base
+    WINRT_EXPORT struct factory_cache_entry_base
     {
         struct alignas(sizeof(void*) * 2) object_and_count
         {
@@ -277,7 +277,7 @@ WINRT_EXPORT namespace winrt::impl
 #error Unsupported architecture: verify that zero-initialization of SLIST_HEADER is still safe
 #endif
 
-    struct factory_cache
+    WINRT_EXPORT struct factory_cache
     {
         factory_cache(factory_cache const&) = delete;
         factory_cache& operator=(factory_cache const&) = delete;
@@ -308,13 +308,13 @@ WINRT_EXPORT namespace winrt::impl
         alignas(memory_allocation_alignment) slist_header m_list;
     };
 
-    inline factory_cache& get_factory_cache() noexcept
+    WINRT_EXPORT inline factory_cache& get_factory_cache() noexcept
     {
         static factory_cache cache;
         return cache;
     }
 
-    template <typename Class, typename Interface>
+    WINRT_EXPORT template <typename Class, typename Interface>
     struct factory_cache_entry : factory_cache_entry_base
     {
         template <typename F>
@@ -351,10 +351,10 @@ WINRT_EXPORT namespace winrt::impl
         }
     };
 
-    template <typename Class, typename Interface>
+    WINRT_EXPORT template <typename Class, typename Interface>
     factory_cache_entry<Class, Interface> factory_cache_entry_v{};
 
-    template <typename Class, typename Interface = Windows::Foundation::IActivationFactory, typename F>
+    WINRT_EXPORT template <typename Class, typename Interface = Windows::Foundation::IActivationFactory, typename F>
     auto call_factory(F&& callback)
     {
         auto& factory = factory_cache_entry_v<Class, Interface>;
@@ -371,7 +371,7 @@ WINRT_EXPORT namespace winrt::impl
         return factory.call(callback);
     }
 
-    template <typename CastType, typename Class, typename Interface = Windows::Foundation::IActivationFactory, typename F>
+    WINRT_EXPORT template <typename CastType, typename Class, typename Interface = Windows::Foundation::IActivationFactory, typename F>
     auto call_factory_cast(F&& callback)
     {
         auto& factory = factory_cache_entry_v<Class, Interface>;
@@ -388,7 +388,7 @@ WINRT_EXPORT namespace winrt::impl
         return factory.call(static_cast<CastType>(callback));
     }
 
-    template <typename Interface = Windows::Foundation::IActivationFactory>
+    WINRT_EXPORT template <typename Interface = Windows::Foundation::IActivationFactory>
     com_ref<Interface> try_get_activation_factory(param::hstring const& name, hresult_error* exception = nullptr) noexcept
     {
         void* result{};
@@ -422,15 +422,15 @@ WINRT_EXPORT namespace winrt::impl
     };
 }
 
-WINRT_EXPORT namespace winrt
+extern "C++" namespace winrt
 {
-    enum class apartment_type : std::int32_t
+    WINRT_EXPORT enum class apartment_type : std::int32_t
     {
         multi_threaded = 0,
         single_threaded = 2,
     };
 
-    inline void init_apartment(apartment_type const type = apartment_type::multi_threaded)
+    WINRT_EXPORT inline void init_apartment(apartment_type const type = apartment_type::multi_threaded)
     {
         hresult const result = WINRT_IMPL_CoInitializeEx(nullptr, static_cast<std::uint32_t>(type));
 
@@ -440,12 +440,12 @@ WINRT_EXPORT namespace winrt
         }
     }
 
-    inline void uninit_apartment() noexcept
+    WINRT_EXPORT inline void uninit_apartment() noexcept
     {
         WINRT_IMPL_CoUninitialize();
     }
 
-    template <typename Class, typename Interface = Windows::Foundation::IActivationFactory>
+    WINRT_EXPORT template <typename Class, typename Interface = Windows::Foundation::IActivationFactory>
     auto get_activation_factory()
     {
         // Normally, the callback avoids having to return a ref-counted object and the resulting AddRef/Release bump.
@@ -457,42 +457,42 @@ WINRT_EXPORT namespace winrt
         });
     }
 
-    template <typename Class, typename Interface = Windows::Foundation::IActivationFactory>
+    WINRT_EXPORT template <typename Class, typename Interface = Windows::Foundation::IActivationFactory>
     auto try_get_activation_factory() noexcept
     {
         return impl::try_get_activation_factory<Interface>(name_of<Class>());
     }
 
-    template <typename Class, typename Interface = Windows::Foundation::IActivationFactory>
+    WINRT_EXPORT template <typename Class, typename Interface = Windows::Foundation::IActivationFactory>
     auto try_get_activation_factory(hresult_error& exception) noexcept
     {
         return impl::try_get_activation_factory<Interface>(name_of<Class>(), &exception);
     }
 
-    template <typename Interface = Windows::Foundation::IActivationFactory>
+    WINRT_EXPORT template <typename Interface = Windows::Foundation::IActivationFactory>
     auto try_get_activation_factory(param::hstring const& name) noexcept
     {
         return impl::try_get_activation_factory<Interface>(name);
     }
 
-    template <typename Interface = Windows::Foundation::IActivationFactory>
+    WINRT_EXPORT template <typename Interface = Windows::Foundation::IActivationFactory>
     auto try_get_activation_factory(param::hstring const& name, hresult_error& exception) noexcept
     {
         return impl::try_get_activation_factory<Interface>(name, &exception);
     }
 
-    inline void clear_factory_cache() noexcept
+    WINRT_EXPORT inline void clear_factory_cache() noexcept
     {
         impl::get_factory_cache().clear();
     }
 
-    template <typename Interface>
+    WINRT_EXPORT template <typename Interface>
     auto try_create_instance(guid const& clsid, std::uint32_t context = 0x1 /*CLSCTX_INPROC_SERVER*/, void* outer = nullptr)
     {
         return try_capture<Interface>(WINRT_IMPL_CoCreateInstance, clsid, outer, context);
     }
 
-    template <typename Interface>
+    WINRT_EXPORT template <typename Interface>
     auto create_instance(guid const& clsid, std::uint32_t context = 0x1 /*CLSCTX_INPROC_SERVER*/, void* outer = nullptr)
     {
         return capture<Interface>(WINRT_IMPL_CoCreateInstance, clsid, outer, context);
@@ -500,7 +500,7 @@ WINRT_EXPORT namespace winrt
 
     namespace Windows::Foundation
     {
-        struct IActivationFactory : IInspectable
+        WINRT_EXPORT struct IActivationFactory : IInspectable
         {
             IActivationFactory(std::nullptr_t = nullptr) noexcept {}
             IActivationFactory(void* ptr, take_ownership_from_abi_t) noexcept : IInspectable(ptr, take_ownership_from_abi) {}
@@ -516,9 +516,9 @@ WINRT_EXPORT namespace winrt
     }
 }
 
-WINRT_EXPORT namespace winrt::impl
+extern "C++" namespace winrt::impl
 {
-    template <typename T>
+    WINRT_EXPORT template <typename T>
     T fast_activate(Windows::Foundation::IActivationFactory const& factory)
     {
         void* result{};
diff --git a/strings/base_agile_ref.h b/strings/base_agile_ref.h
index af8345037..a9c89617e 100644
--- a/strings/base_agile_ref.h
+++ b/strings/base_agile_ref.h
@@ -1,12 +1,12 @@
 
-WINRT_EXPORT namespace winrt
+extern "C++" namespace winrt
 {
 #if defined(WINRT_NO_MODULE_LOCK)
 
     // Defining WINRT_NO_MODULE_LOCK is appropriate for apps (executables) or pinned DLLs (that don't support unloading)
     // and can thus avoid the synchronization overhead imposed by the default module lock.
 
-    constexpr auto get_module_lock() noexcept
+    WINRT_EXPORT constexpr auto get_module_lock() noexcept
     {
         struct lock
         {
@@ -38,7 +38,7 @@ WINRT_EXPORT namespace winrt
 
     // This is the default implementation for use with DllCanUnloadNow.
 
-    inline impl::atomic_ref_count& get_module_lock() noexcept
+    WINRT_EXPORT inline impl::atomic_ref_count& get_module_lock() noexcept
     {
         static impl::atomic_ref_count s_lock;
         return s_lock;
@@ -47,9 +47,9 @@ WINRT_EXPORT namespace winrt
 #endif
 }
 
-WINRT_EXPORT namespace winrt::impl
+extern "C++" namespace winrt::impl
 {
-    template<bool UseModuleLock>
+    WINRT_EXPORT template<bool UseModuleLock>
     struct module_lock_updater;
 
     template<>
@@ -69,22 +69,22 @@ WINRT_EXPORT namespace winrt::impl
     template<>
     struct module_lock_updater<false> {};
 
-    using update_module_lock = module_lock_updater<true>;
+    WINRT_EXPORT using update_module_lock = module_lock_updater<true>;
 
-    inline void* load_library(wchar_t const* library) noexcept
+    WINRT_EXPORT inline void* load_library(wchar_t const* library) noexcept
     {
         return WINRT_IMPL_LoadLibraryExW(library, nullptr, 0x00001000 /* LOAD_LIBRARY_SEARCH_DEFAULT_DIRS */);
     }
 
-    inline hresult get_agile_reference(winrt::guid const& iid, void* object, void** reference) noexcept
+    WINRT_EXPORT inline hresult get_agile_reference(winrt::guid const& iid, void* object, void** reference) noexcept
     {
         return WINRT_IMPL_RoGetAgileReference(0, iid, object, reference);
     }
 }
 
-WINRT_EXPORT namespace winrt
+extern "C++" namespace winrt
 {
-    template <typename T>
+    WINRT_EXPORT template <typename T>
     struct agile_ref
     {
         agile_ref(std::nullptr_t = nullptr) noexcept {}
@@ -121,7 +121,7 @@ WINRT_EXPORT namespace winrt
 
     template<typename T> agile_ref(T const&)->agile_ref<impl::wrapped_type_t<T>>;
 
-    template <typename T>
+    WINRT_EXPORT template <typename T>
     agile_ref<impl::wrapped_type_t<T>> make_agile(T const& object)
     {
         return object;
diff --git a/strings/base_array.h b/strings/base_array.h
index ce536d807..1ff263ae3 100644
--- a/strings/base_array.h
+++ b/strings/base_array.h
@@ -1,7 +1,7 @@
 
-WINRT_EXPORT namespace winrt
+extern "C++" namespace winrt
 {
-    template <typename T>
+    WINRT_EXPORT template <typename T>
     struct array_view
     {
         using value_type = T;
@@ -252,7 +252,7 @@ WINRT_EXPORT namespace winrt
     template <typename C, std::size_t extent> array_view(std::span<C, extent>& value) -> array_view<C>;
     template <typename C, std::size_t extent> array_view(std::span<C, extent> const& value) -> array_view<C const>;
 
-    template <typename T>
+    WINRT_EXPORT template <typename T>
     struct com_array : array_view<T>
     {
         using value_type = typename array_view<T>::value_type;
@@ -417,7 +417,7 @@ WINRT_EXPORT namespace winrt
     template <typename C, std::size_t extent> com_array(std::span<C, extent> const& value) -> com_array<std::decay_t<C>>;
 
 
-    template <typename T>
+    WINRT_EXPORT template <typename T>
     auto get_abi(array_view<T> object) noexcept
     {
         using U = std::remove_const_t<T>;
@@ -434,7 +434,7 @@ WINRT_EXPORT namespace winrt
         }
     }
 
-    template <typename T>
+    WINRT_EXPORT template <typename T>
     auto put_abi(array_view<T> object) noexcept
     {
         if constexpr (!std::is_trivially_destructible_v<T>)
@@ -445,29 +445,29 @@ WINRT_EXPORT namespace winrt
         return get_abi(object);
     }
 
-    template<typename T>
+    WINRT_EXPORT template<typename T>
     auto put_abi(com_array<T>& object) noexcept
     {
         object.clear();
         return reinterpret_cast<impl::arg_out<T>*>(&object);
     }
 
-    template <typename T>
+    WINRT_EXPORT template <typename T>
     std::pair<std::uint32_t, impl::arg_out<T>> detach_abi(com_array<T>& object) noexcept
     {
         return object.detach_abi();
     }
 
-    template <typename T>
+    WINRT_EXPORT template <typename T>
     auto detach_abi(com_array<T>&& object) noexcept
     {
         return detach_abi(object);
     }
 }
 
-WINRT_EXPORT namespace winrt::impl
+extern "C++" namespace winrt::impl
 {
-    template <typename T>
+    WINRT_EXPORT template <typename T>
     struct array_size_proxy
     {
         array_size_proxy& operator=(array_size_proxy const&) = delete;
@@ -497,13 +497,13 @@ WINRT_EXPORT namespace winrt::impl
         std::uint32_t m_size{ 0 };
     };
 
-    template<typename T>
+    WINRT_EXPORT template<typename T>
     array_size_proxy<T> put_size_abi(com_array<T>& object) noexcept
     {
         return array_size_proxy<T>(object);
     }
 
-    template <typename T>
+    WINRT_EXPORT template <typename T>
     struct com_array_proxy
     {
         com_array_proxy(std::uint32_t* size, winrt::impl::arg_out<T>* value) noexcept : m_size(size), m_value(value)
@@ -533,29 +533,29 @@ WINRT_EXPORT namespace winrt::impl
     };
 }
 
-WINRT_EXPORT namespace winrt
+extern "C++" namespace winrt
 {
-    template <typename T>
+    WINRT_EXPORT template <typename T>
     auto detach_abi(std::uint32_t* __valueSize, impl::arg_out<T>* value) noexcept
     {
         return impl::com_array_proxy<T>(__valueSize, value);
     }
 
-    inline hstring get_class_name(Windows::Foundation::IInspectable const& object)
+    WINRT_EXPORT inline hstring get_class_name(Windows::Foundation::IInspectable const& object)
     {
         void* value{};
         check_hresult(static_cast<impl::inspectable_abi*>(*impl::abi_cast(object))->GetRuntimeClassName(&value));
         return { value, take_ownership_from_abi };
     }
 
-    inline com_array<guid> get_interfaces(Windows::Foundation::IInspectable const& object)
+    WINRT_EXPORT inline com_array<guid> get_interfaces(Windows::Foundation::IInspectable const& object)
     {
         com_array<guid> value;
         check_hresult(static_cast<impl::inspectable_abi*>(*impl::abi_cast(object))->GetIids(impl::put_size_abi(value), put_abi(value)));
         return value;
     }
 
-    inline Windows::Foundation::TrustLevel get_trust_level(Windows::Foundation::IInspectable const& object)
+    WINRT_EXPORT inline Windows::Foundation::TrustLevel get_trust_level(Windows::Foundation::IInspectable const& object)
     {
         Windows::Foundation::TrustLevel value{};
         check_hresult(static_cast<impl::inspectable_abi*>(*impl::abi_cast(object))->GetTrustLevel(&value));
diff --git a/strings/base_chrono.h b/strings/base_chrono.h
index 7934ac5b2..721ca55cb 100644
--- a/strings/base_chrono.h
+++ b/strings/base_chrono.h
@@ -1,7 +1,7 @@
 
-WINRT_EXPORT namespace winrt
+extern "C++" namespace winrt
 {
-    struct file_time
+    WINRT_EXPORT struct file_time
     {
         std::uint64_t value{};
 
@@ -24,7 +24,7 @@ WINRT_EXPORT namespace winrt
 #endif
     };
 
-    struct clock
+    WINRT_EXPORT struct clock
     {
         using rep = std::int64_t;
         using period = impl::filetime_period;
diff --git a/strings/base_collections.h b/strings/base_collections.h
index 7d8dc2e77..55278465d 100644
--- a/strings/base_collections.h
+++ b/strings/base_collections.h
@@ -1,5 +1,5 @@
 
-WINRT_EXPORT namespace winrt::impl
+extern "C++" namespace winrt::impl
 {
     namespace wfc = Windows::Foundation::Collections;
 
@@ -14,7 +14,7 @@ WINRT_EXPORT namespace winrt::impl
         return get_end_iterator(static_cast<D const&>(*this));
     }
 
-    template <typename T>
+    WINRT_EXPORT template <typename T>
     struct key_value_pair;
 
     template <typename K, typename V>
@@ -42,13 +42,13 @@ WINRT_EXPORT namespace winrt::impl
         V const m_value;
     };
 
-    template <typename T>
+    WINRT_EXPORT template <typename T>
     struct is_key_value_pair : std::false_type {};
 
     template <typename K, typename V>
     struct is_key_value_pair<wfc::IKeyValuePair<K, V>> : std::true_type {};
 
-    struct input_scope
+    WINRT_EXPORT struct input_scope
     {
         void invalidate_scope() noexcept
         {
@@ -68,7 +68,7 @@ WINRT_EXPORT namespace winrt::impl
         bool m_invalid{};
     };
 
-    struct no_collection_version
+    WINRT_EXPORT struct no_collection_version
     {
         struct iterator_type
         {
@@ -82,7 +82,7 @@ WINRT_EXPORT namespace winrt::impl
         };
     };
 
-    struct collection_version
+    WINRT_EXPORT struct collection_version
     {
         struct iterator_type
         {
@@ -119,7 +119,7 @@ WINRT_EXPORT namespace winrt::impl
         std::atomic<std::uint32_t> m_version{};
     };
 
-    template <typename T>
+    WINRT_EXPORT template <typename T>
     struct range_container
     {
         T const first;
diff --git a/strings/base_collections_base.h b/strings/base_collections_base.h
index d107c633e..0197268c2 100644
--- a/strings/base_collections_base.h
+++ b/strings/base_collections_base.h
@@ -1,8 +1,9 @@
-WINRT_EXPORT namespace winrt::impl
+
+extern "C++" namespace winrt::impl
 {
-    struct nop_lock_guard {};
+    WINRT_EXPORT struct nop_lock_guard {};
 
-    struct single_threaded_collection_base
+    WINRT_EXPORT struct single_threaded_collection_base
     {
         [[nodiscard]] auto acquire_exclusive() const
         {
@@ -15,7 +16,7 @@ WINRT_EXPORT namespace winrt::impl
         }
     };
 
-    struct multi_threaded_collection_base
+    WINRT_EXPORT struct multi_threaded_collection_base
     {
         [[nodiscard]] auto acquire_exclusive() const
         {
@@ -32,10 +33,10 @@ WINRT_EXPORT namespace winrt::impl
         mutable slim_mutex m_mutex;
     };
 
-    template <typename D>
+    WINRT_EXPORT template <typename D>
     using container_type_t = std::decay_t<decltype(std::declval<D>().get_container())>;
 
-    template <typename D>
+    WINRT_EXPORT template <typename D>
     struct removed_values
     {
         void assign(container_type_t<D>& value)
@@ -57,7 +58,7 @@ WINRT_EXPORT namespace winrt::impl
         }
     };
 
-    template <typename T>
+    WINRT_EXPORT template <typename T>
     struct removed_value
     {
         // Trivially destructible; okay to run destructor under lock
@@ -79,9 +80,9 @@ WINRT_EXPORT namespace winrt::impl
     };
 }
 
-WINRT_EXPORT namespace winrt
+extern "C++" namespace winrt
 {
-    template <typename D, typename T, typename Version = impl::no_collection_version>
+    WINRT_EXPORT template <typename D, typename T, typename Version = impl::no_collection_version>
     struct iterable_base : Version
     {
         template <typename U>
@@ -245,7 +246,7 @@ WINRT_EXPORT namespace winrt
         };
     };
 
-    template <typename D, typename T, typename Version = impl::no_collection_version>
+    WINRT_EXPORT template <typename D, typename T, typename Version = impl::no_collection_version>
     struct vector_view_base : iterable_base<D, T, Version>
     {
         T GetAt(std::uint32_t const index) const
@@ -298,7 +299,7 @@ WINRT_EXPORT namespace winrt
         }
     };
 
-    template <typename D, typename T>
+    WINRT_EXPORT template <typename D, typename T>
     struct vector_base : vector_view_base<D, T, impl::collection_version>
     {
         Windows::Foundation::Collections::IVectorView<T> GetView() const noexcept
@@ -414,7 +415,7 @@ WINRT_EXPORT namespace winrt
         }
     };
 
-    template <typename D, typename T>
+    WINRT_EXPORT template <typename D, typename T>
     struct observable_vector_base : vector_base<D, T>
     {
         event_token VectorChanged(Windows::Foundation::Collections::VectorChangedEventHandler<T> const& handler)
@@ -505,7 +506,7 @@ WINRT_EXPORT namespace winrt
         };
     };
 
-    template <typename D, typename K, typename V, typename Version = impl::no_collection_version>
+    WINRT_EXPORT template <typename D, typename K, typename V, typename Version = impl::no_collection_version>
     struct map_view_base : iterable_base<D, Windows::Foundation::Collections::IKeyValuePair<K, V>, Version>
     {
         // specialization of Lookup that avoids throwing the hresult
@@ -555,7 +556,7 @@ WINRT_EXPORT namespace winrt
 
     };
 
-    template <typename D, typename K, typename V>
+    WINRT_EXPORT template <typename D, typename K, typename V>
     struct map_base : map_view_base<D, K, V, impl::collection_version>
     {
         Windows::Foundation::Collections::IMapView<K, V> GetView() const
@@ -604,7 +605,7 @@ WINRT_EXPORT namespace winrt
         }
     };
 
-    template <typename D, typename K, typename V>
+    WINRT_EXPORT template <typename D, typename K, typename V>
     struct observable_map_base : map_base<D, K, V>
     {
         event_token MapChanged(Windows::Foundation::Collections::MapChangedEventHandler<K, V> const& handler)
diff --git a/strings/base_collections_input_iterable.h b/strings/base_collections_input_iterable.h
index 302d403b7..4477762de 100644
--- a/strings/base_collections_input_iterable.h
+++ b/strings/base_collections_input_iterable.h
@@ -1,7 +1,7 @@
 
-WINRT_EXPORT namespace winrt::impl
+extern "C++" namespace winrt::impl
 {
-    template <typename T, typename Container>
+    WINRT_EXPORT template <typename T, typename Container>
     struct input_iterable :
         implements<input_iterable<T, Container>, non_agile, no_weak_ref, wfc::IIterable<T>>,
         iterable_base<input_iterable<T, Container>, T>
@@ -22,7 +22,7 @@ WINRT_EXPORT namespace winrt::impl
         Container const m_values;
     };
 
-    template <typename T, typename InputIt>
+    WINRT_EXPORT template <typename T, typename InputIt>
     struct scoped_input_iterable :
         input_scope,
         implements<scoped_input_iterable<T, InputIt>, non_agile, no_weak_ref, wfc::IIterable<T>>,
@@ -54,13 +54,13 @@ WINRT_EXPORT namespace winrt::impl
         InputIt const m_end;
     };
 
-    template <typename T, typename Container>
+    WINRT_EXPORT template <typename T, typename Container>
     auto make_input_iterable(Container&& values)
     {
         return make<input_iterable<T, Container>>(std::forward<Container>(values));
     }
 
-    template <typename T, typename InputIt>
+    WINRT_EXPORT template <typename T, typename InputIt>
     auto make_scoped_input_iterable(InputIt first, InputIt last)
     {
         using interface_type = wfc::IIterable<T>;
@@ -72,9 +72,9 @@ WINRT_EXPORT namespace winrt::impl
     }
 }
 
-WINRT_EXPORT namespace winrt::param
+extern "C++" namespace winrt::param
 {
-    template <typename T>
+    WINRT_EXPORT template <typename T>
     struct iterable
     {
         using value_type = T;
@@ -226,13 +226,13 @@ WINRT_EXPORT namespace winrt::param
         bool m_owned{ true };
     };
 
-    template <typename T>
+    WINRT_EXPORT template <typename T>
     auto get_abi(iterable<T> const& object) noexcept
     {
         return *impl::abi_cast(object);
     }
 
-    template <typename T>
+    WINRT_EXPORT template <typename T>
     struct async_iterable
     {
         using value_type = T;
@@ -348,7 +348,7 @@ WINRT_EXPORT namespace winrt::param
         bool m_owned{ true };
     };
 
-    template <typename T>
+    WINRT_EXPORT template <typename T>
     auto get_abi(async_iterable<T> const& object) noexcept
     {
         return *impl::abi_cast(object);
diff --git a/strings/base_collections_input_map.h b/strings/base_collections_input_map.h
index 7cc8cca9c..805e1bffd 100644
--- a/strings/base_collections_input_map.h
+++ b/strings/base_collections_input_map.h
@@ -1,7 +1,7 @@
 
-WINRT_EXPORT namespace winrt::impl
+extern "C++" namespace winrt::impl
 {
-    template <typename K, typename V, typename Container, typename ThreadingBase>
+    WINRT_EXPORT template <typename K, typename V, typename Container, typename ThreadingBase>
     struct map_impl :
         implements<map_impl<K, V, Container, ThreadingBase>, wfc::IMap<K, V>, wfc::IMapView<K, V>, wfc::IIterable<wfc::IKeyValuePair<K, V>>>,
         map_base<map_impl<K, V, Container, ThreadingBase>, K, V>,
@@ -31,19 +31,19 @@ WINRT_EXPORT namespace winrt::impl
         Container m_values;
     };
 
-    template <typename K, typename V, typename Container>
+    WINRT_EXPORT template <typename K, typename V, typename Container>
     using input_map = map_impl<K, V, Container, single_threaded_collection_base>;
 
-    template <typename K, typename V, typename Container>
+    WINRT_EXPORT template <typename K, typename V, typename Container>
     auto make_input_map(Container&& values)
     {
         return make<input_map<K, V, Container>>(std::forward<Container>(values));
     }
 }
 
-WINRT_EXPORT namespace winrt::param
+extern "C++" namespace winrt::param
 {
-    template <typename K, typename V>
+    WINRT_EXPORT template <typename K, typename V>
     struct map
     {
         using value_type = Windows::Foundation::Collections::IKeyValuePair<K, V>;
@@ -104,7 +104,7 @@ WINRT_EXPORT namespace winrt::param
         bool m_owned{ true };
     };
 
-    template <typename K, typename V>
+    WINRT_EXPORT template <typename K, typename V>
     auto get_abi(map<K, V> const& object) noexcept
     {
         return *impl::abi_cast(object);
diff --git a/strings/base_collections_input_map_view.h b/strings/base_collections_input_map_view.h
index 43262300f..65d617441 100644
--- a/strings/base_collections_input_map_view.h
+++ b/strings/base_collections_input_map_view.h
@@ -1,7 +1,7 @@
 
-WINRT_EXPORT namespace winrt::impl
+extern "C++" namespace winrt::impl
 {
-    template <typename K, typename V, typename Container>
+    WINRT_EXPORT template <typename K, typename V, typename Container>
     struct input_map_view :
         implements<input_map_view<K, V, Container>, non_agile, no_weak_ref, wfc::IMapView<K, V>, wfc::IIterable<wfc::IKeyValuePair<K, V>>>,
         map_view_base<input_map_view<K, V, Container>, K, V>
@@ -22,7 +22,7 @@ WINRT_EXPORT namespace winrt::impl
         Container const m_values;
     };
 
-    template <typename K, typename V, typename Container>
+    WINRT_EXPORT template <typename K, typename V, typename Container>
     struct scoped_input_map_view :
         input_scope,
         implements<scoped_input_map_view<K, V, Container>, non_agile, no_weak_ref, wfc::IMapView<K, V>, wfc::IIterable<wfc::IKeyValuePair<K, V>>>,
@@ -53,13 +53,13 @@ WINRT_EXPORT namespace winrt::impl
         Container const& m_values;
     };
 
-    template <typename K, typename V, typename Container>
+    WINRT_EXPORT template <typename K, typename V, typename Container>
     auto make_input_map_view(Container&& values)
     {
         return make<input_map_view<K, V, Container>>(std::forward<Container>(values));
     }
 
-    template <typename K, typename V, typename Container>
+    WINRT_EXPORT template <typename K, typename V, typename Container>
     auto make_scoped_input_map_view(Container const& values)
     {
         using interface_type = wfc::IMapView<K, V>;
@@ -71,9 +71,9 @@ WINRT_EXPORT namespace winrt::impl
     }
 }
 
-WINRT_EXPORT namespace winrt::param
+extern "C++" namespace winrt::param
 {
-    template <typename K, typename V>
+    WINRT_EXPORT template <typename K, typename V>
     struct map_view
     {
         using value_type = Windows::Foundation::Collections::IKeyValuePair<K, V>;
@@ -146,13 +146,13 @@ WINRT_EXPORT namespace winrt::param
         bool m_owned{ true };
     };
 
-    template <typename K, typename V>
+    WINRT_EXPORT template <typename K, typename V>
     auto get_abi(map_view<K, V> const& object) noexcept
     {
         return *impl::abi_cast(object);
     }
 
-    template <typename K, typename V>
+    WINRT_EXPORT template <typename K, typename V>
     struct async_map_view
     {
         using value_type = Windows::Foundation::Collections::IKeyValuePair<K, V>;
@@ -213,7 +213,7 @@ WINRT_EXPORT namespace winrt::param
         bool m_owned{ true };
     };
 
-    template <typename K, typename V>
+    WINRT_EXPORT template <typename K, typename V>
     auto get_abi(async_map_view<K, V> const& object) noexcept
     {
         return *impl::abi_cast(object);
diff --git a/strings/base_collections_input_vector.h b/strings/base_collections_input_vector.h
index 412e591a8..9b2682632 100644
--- a/strings/base_collections_input_vector.h
+++ b/strings/base_collections_input_vector.h
@@ -1,7 +1,7 @@
 
-WINRT_EXPORT namespace winrt::impl
+extern "C++" namespace winrt::impl
 {
-    template <typename T, typename Container, typename ThreadingBase>
+    WINRT_EXPORT template <typename T, typename Container, typename ThreadingBase>
     struct vector_impl :
         implements<vector_impl<T, Container, ThreadingBase>, wfc::IVector<T>, wfc::IVectorView<T>, wfc::IIterable<T>>,
         vector_base<vector_impl<T, Container, ThreadingBase>, T>,
@@ -31,13 +31,13 @@ WINRT_EXPORT namespace winrt::impl
         Container m_values;
     };
 
-    template <typename T, typename Container>
+    WINRT_EXPORT template <typename T, typename Container>
     using input_vector = vector_impl<T, Container, single_threaded_collection_base>;
 }
 
-WINRT_EXPORT namespace winrt::param
+extern "C++" namespace winrt::param
 {
-    template <typename T>
+    WINRT_EXPORT template <typename T>
     struct vector
     {
         using value_type = T;
@@ -92,7 +92,7 @@ WINRT_EXPORT namespace winrt::param
         bool m_owned = true;
     };
 
-    template <typename T>
+    WINRT_EXPORT template <typename T>
     auto get_abi(vector<T> const& object) noexcept
     {
         return *impl::abi_cast(object);
diff --git a/strings/base_collections_input_vector_view.h b/strings/base_collections_input_vector_view.h
index 0674f384b..50b218322 100644
--- a/strings/base_collections_input_vector_view.h
+++ b/strings/base_collections_input_vector_view.h
@@ -1,7 +1,7 @@
 
-WINRT_EXPORT namespace winrt::impl
+extern "C++" namespace winrt::impl
 {
-    template <typename T, typename Container>
+    WINRT_EXPORT template <typename T, typename Container>
     struct input_vector_view :
         implements<input_vector_view<T, Container>, non_agile, no_weak_ref, wfc::IVectorView<T>, wfc::IIterable<T>>,
         vector_view_base<input_vector_view<T, Container>, T>
@@ -22,7 +22,7 @@ WINRT_EXPORT namespace winrt::impl
         Container const m_values;
     };
 
-    template <typename T, typename InputIt>
+    WINRT_EXPORT template <typename T, typename InputIt>
     struct scoped_input_vector_view :
         input_scope,
         implements<scoped_input_vector_view<T, InputIt>, non_agile, no_weak_ref, wfc::IVectorView<T>, wfc::IIterable<T>>,
@@ -54,7 +54,7 @@ WINRT_EXPORT namespace winrt::impl
         InputIt const m_end;
     };
 
-    template <typename T, typename InputIt>
+    WINRT_EXPORT template <typename T, typename InputIt>
     auto make_scoped_input_vector_view(InputIt first, InputIt last)
     {
         using interface_type = wfc::IVectorView<T>;
@@ -66,9 +66,9 @@ WINRT_EXPORT namespace winrt::impl
     }
 }
 
-WINRT_EXPORT namespace winrt::param
+extern "C++" namespace winrt::param
 {
-    template <typename T>
+    WINRT_EXPORT template <typename T>
     struct vector_view
     {
         using value_type = T;
@@ -142,13 +142,13 @@ WINRT_EXPORT namespace winrt::param
         bool m_owned{ true };
     };
 
-    template <typename T>
+    WINRT_EXPORT template <typename T>
     auto get_abi(vector_view<T> const& object) noexcept
     {
         return *impl::abi_cast(object);
     }
 
-    template <typename T>
+    WINRT_EXPORT template <typename T>
     struct async_vector_view
     {
         using value_type = T;
@@ -203,7 +203,7 @@ WINRT_EXPORT namespace winrt::param
         bool m_owned{ true };
     };
 
-    template <typename T>
+    WINRT_EXPORT template <typename T>
     auto get_abi(async_vector_view<T> const& object) noexcept
     {
         return *impl::abi_cast(object);
diff --git a/strings/base_collections_map.h b/strings/base_collections_map.h
index b40247dab..19b6127eb 100644
--- a/strings/base_collections_map.h
+++ b/strings/base_collections_map.h
@@ -1,10 +1,10 @@
 
-WINRT_EXPORT namespace winrt::impl
+extern "C++" namespace winrt::impl
 {
-    template <typename K, typename V, typename Container>
+    WINRT_EXPORT template <typename K, typename V, typename Container>
     using multi_threaded_map = map_impl<K, V, Container, multi_threaded_collection_base>;
 
-    template <typename K, typename V, typename Container, typename ThreadingBase>
+    WINRT_EXPORT template <typename K, typename V, typename Container, typename ThreadingBase>
     struct observable_map_impl :
         implements<observable_map_impl<K, V, Container, ThreadingBase>, wfc::IObservableMap<K, V>, wfc::IMap<K, V>, wfc::IMapView<K, V>, wfc::IIterable<wfc::IKeyValuePair<K, V>>>,
         observable_map_base<observable_map_impl<K, V, Container, ThreadingBase>, K, V>,
@@ -34,89 +34,89 @@ WINRT_EXPORT namespace winrt::impl
         Container m_values;
     };
 
-    template <typename K, typename V, typename Container>
+    WINRT_EXPORT template <typename K, typename V, typename Container>
     using observable_map = observable_map_impl<K, V, Container, single_threaded_collection_base>;
 
-    template <typename K, typename V, typename Container>
+    WINRT_EXPORT template <typename K, typename V, typename Container>
     using multi_threaded_observable_map = observable_map_impl<K, V, Container, multi_threaded_collection_base>;
 }
 
-WINRT_EXPORT namespace winrt
+extern "C++" namespace winrt
 {
-    template <typename K, typename V, typename Compare = std::less<K>, typename Allocator = std::allocator<std::pair<K const, V>>>
+    WINRT_EXPORT template <typename K, typename V, typename Compare = std::less<K>, typename Allocator = std::allocator<std::pair<K const, V>>>
     Windows::Foundation::Collections::IMap<K, V> single_threaded_map()
     {
         return make<impl::input_map<K, V, std::map<K, V, Compare, Allocator>>>(std::map<K, V, Compare, Allocator>{});
     }
 
-    template <typename K, typename V, typename Compare = std::less<K>, typename Allocator = std::allocator<std::pair<K const, V>>>
+    WINRT_EXPORT template <typename K, typename V, typename Compare = std::less<K>, typename Allocator = std::allocator<std::pair<K const, V>>>
     Windows::Foundation::Collections::IMap<K, V> single_threaded_map(std::map<K, V, Compare, Allocator>&& values)
     {
         return make<impl::input_map<K, V, std::map<K, V, Compare, Allocator>>>(std::move(values));
     }
 
-    template <typename K, typename V, typename Hash = std::hash<K>, typename KeyEqual = std::equal_to<K>, typename Allocator = std::allocator<std::pair<K const, V>>>
+    WINRT_EXPORT template <typename K, typename V, typename Hash = std::hash<K>, typename KeyEqual = std::equal_to<K>, typename Allocator = std::allocator<std::pair<K const, V>>>
     Windows::Foundation::Collections::IMap<K, V> single_threaded_map(std::unordered_map<K, V, Hash, KeyEqual, Allocator>&& values)
     {
         return make<impl::input_map<K, V, std::unordered_map<K, V, Hash, KeyEqual, Allocator>>>(std::move(values));
     }
 
-    template <typename K, typename V, typename Compare = std::less<K>, typename Allocator = std::allocator<std::pair<K const, V>>>
+    WINRT_EXPORT template <typename K, typename V, typename Compare = std::less<K>, typename Allocator = std::allocator<std::pair<K const, V>>>
     Windows::Foundation::Collections::IMap<K, V> multi_threaded_map()
     {
         return make<impl::multi_threaded_map<K, V, std::map<K, V, Compare, Allocator>>>(std::map<K, V, Compare, Allocator>{});
     }
 
-    template <typename K, typename V, typename Compare = std::less<K>, typename Allocator = std::allocator<std::pair<K const, V>>>
+    WINRT_EXPORT template <typename K, typename V, typename Compare = std::less<K>, typename Allocator = std::allocator<std::pair<K const, V>>>
     Windows::Foundation::Collections::IMap<K, V> multi_threaded_map(std::map<K, V, Compare, Allocator>&& values)
     {
         return make<impl::multi_threaded_map<K, V, std::map<K, V, Compare, Allocator>>>(std::move(values));
     }
 
-    template <typename K, typename V, typename Hash = std::hash<K>, typename KeyEqual = std::equal_to<K>, typename Allocator = std::allocator<std::pair<K const, V>>>
+    WINRT_EXPORT template <typename K, typename V, typename Hash = std::hash<K>, typename KeyEqual = std::equal_to<K>, typename Allocator = std::allocator<std::pair<K const, V>>>
     Windows::Foundation::Collections::IMap<K, V> multi_threaded_map(std::unordered_map<K, V, Hash, KeyEqual, Allocator>&& values)
     {
         return make<impl::multi_threaded_map<K, V, std::unordered_map<K, V, Hash, KeyEqual, Allocator>>>(std::move(values));
     }
 
-    template <typename K, typename V, typename Compare = std::less<K>, typename Allocator = std::allocator<std::pair<K const, V>>>
+    WINRT_EXPORT template <typename K, typename V, typename Compare = std::less<K>, typename Allocator = std::allocator<std::pair<K const, V>>>
     Windows::Foundation::Collections::IObservableMap<K, V> single_threaded_observable_map()
     {
         return make<impl::observable_map<K, V, std::map<K, V, Compare, Allocator>>>(std::map<K, V, Compare, Allocator>{});
     }
 
-    template <typename K, typename V, typename Compare = std::less<K>, typename Allocator = std::allocator<std::pair<K const, V>>>
+    WINRT_EXPORT template <typename K, typename V, typename Compare = std::less<K>, typename Allocator = std::allocator<std::pair<K const, V>>>
     Windows::Foundation::Collections::IObservableMap<K, V> single_threaded_observable_map(std::map<K, V, Compare, Allocator>&& values)
     {
         return make<impl::observable_map<K, V, std::map<K, V, Compare, Allocator>>>(std::move(values));
     }
 
-    template <typename K, typename V, typename Hash = std::hash<K>, typename KeyEqual = std::equal_to<K>, typename Allocator = std::allocator<std::pair<K const, V>>>
+    WINRT_EXPORT template <typename K, typename V, typename Hash = std::hash<K>, typename KeyEqual = std::equal_to<K>, typename Allocator = std::allocator<std::pair<K const, V>>>
     Windows::Foundation::Collections::IObservableMap<K, V> single_threaded_observable_map(std::unordered_map<K, V, Hash, KeyEqual, Allocator>&& values)
     {
         return make<impl::observable_map<K, V, std::unordered_map<K, V, Hash, KeyEqual, Allocator>>>(std::move(values));
     }
 
-    template <typename K, typename V, typename Compare = std::less<K>, typename Allocator = std::allocator<std::pair<K const, V>>>
+    WINRT_EXPORT template <typename K, typename V, typename Compare = std::less<K>, typename Allocator = std::allocator<std::pair<K const, V>>>
     Windows::Foundation::Collections::IObservableMap<K, V> multi_threaded_observable_map()
     {
         return make<impl::multi_threaded_observable_map<K, V, std::map<K, V, Compare, Allocator>>>(std::map<K, V, Compare, Allocator>{});
     }
 
-    template <typename K, typename V, typename Compare = std::less<K>, typename Allocator = std::allocator<std::pair<K const, V>>>
+    WINRT_EXPORT template <typename K, typename V, typename Compare = std::less<K>, typename Allocator = std::allocator<std::pair<K const, V>>>
     Windows::Foundation::Collections::IObservableMap<K, V> multi_threaded_observable_map(std::map<K, V, Compare, Allocator>&& values)
     {
         return make<impl::multi_threaded_observable_map<K, V, std::map<K, V, Compare, Allocator>>>(std::move(values));
     }
 
-    template <typename K, typename V, typename Hash = std::hash<K>, typename KeyEqual = std::equal_to<K>, typename Allocator = std::allocator<std::pair<K const, V>>>
+    WINRT_EXPORT template <typename K, typename V, typename Hash = std::hash<K>, typename KeyEqual = std::equal_to<K>, typename Allocator = std::allocator<std::pair<K const, V>>>
     Windows::Foundation::Collections::IObservableMap<K, V> multi_threaded_observable_map(std::unordered_map<K, V, Hash, KeyEqual, Allocator>&& values)
     {
         return make<impl::multi_threaded_observable_map<K, V, std::unordered_map<K, V, Hash, KeyEqual, Allocator>>>(std::move(values));
     }
 }
 
-namespace std
+extern "C++" namespace std
 {
     template<typename K, typename V>
     struct tuple_size<winrt::Windows::Foundation::Collections::IKeyValuePair<K, V>>
@@ -132,7 +132,7 @@ namespace std
     };
 }
 
-namespace winrt::Windows::Foundation::Collections
+extern "C++" namespace winrt::Windows::Foundation::Collections
 {
     template<std::size_t Idx, typename K, typename V>
     std::tuple_element_t<Idx, IKeyValuePair<K, V>> get(IKeyValuePair<K, V> const& kvp)
diff --git a/strings/base_collections_vector.h b/strings/base_collections_vector.h
index 3388806af..8b015fa1b 100644
--- a/strings/base_collections_vector.h
+++ b/strings/base_collections_vector.h
@@ -1,10 +1,10 @@
 
-WINRT_EXPORT namespace winrt::impl
+extern "C++" namespace winrt::impl
 {
-    template <typename T, typename Container>
+    WINRT_EXPORT template <typename T, typename Container>
     using multi_threaded_vector = vector_impl<T, Container, multi_threaded_collection_base>;
 
-    template <typename Container, typename ThreadingBase = single_threaded_collection_base>
+    WINRT_EXPORT template <typename Container, typename ThreadingBase = single_threaded_collection_base>
     struct inspectable_observable_vector :
         observable_vector_base<inspectable_observable_vector<Container, ThreadingBase>, Windows::Foundation::IInspectable>,
         implements<inspectable_observable_vector<Container, ThreadingBase>,
@@ -35,10 +35,10 @@ WINRT_EXPORT namespace winrt::impl
         Container m_values;
     };
 
-    template <typename Container>
+    WINRT_EXPORT template <typename Container>
     using multi_threaded_inspectable_observable_vector = inspectable_observable_vector<Container, multi_threaded_collection_base>;
 
-    template <typename T, typename Container, typename ThreadingBase = single_threaded_collection_base>
+    WINRT_EXPORT template <typename T, typename Container, typename ThreadingBase = single_threaded_collection_base>
     struct convertible_observable_vector :
         observable_vector_base<convertible_observable_vector<T, Container, ThreadingBase>, T>,
         implements<convertible_observable_vector<T, Container, ThreadingBase>,
@@ -293,25 +293,25 @@ WINRT_EXPORT namespace winrt::impl
         Container m_values;
     };
 
-    template <typename T, typename Container>
+    WINRT_EXPORT template <typename T, typename Container>
     using multi_threaded_convertible_observable_vector = convertible_observable_vector<T, Container, multi_threaded_collection_base>;
 }
 
-WINRT_EXPORT namespace winrt
+extern "C++" namespace winrt
 {
-    template <typename T, typename Allocator = std::allocator<T>>
+    WINRT_EXPORT template <typename T, typename Allocator = std::allocator<T>>
     Windows::Foundation::Collections::IVector<T> single_threaded_vector(std::vector<T, Allocator>&& values = {})
     {
         return make<impl::input_vector<T, std::vector<T, Allocator>>>(std::move(values));
     }
 
-    template <typename T, typename Allocator = std::allocator<T>>
+    WINRT_EXPORT template <typename T, typename Allocator = std::allocator<T>>
     Windows::Foundation::Collections::IVector<T> multi_threaded_vector(std::vector<T, Allocator>&& values = {})
     {
         return make<impl::multi_threaded_vector<T, std::vector<T, Allocator>>>(std::move(values));
     }
 
-    template <typename T, typename Allocator = std::allocator<T>>
+    WINRT_EXPORT template <typename T, typename Allocator = std::allocator<T>>
     Windows::Foundation::Collections::IObservableVector<T> single_threaded_observable_vector(std::vector<T, Allocator>&& values = {})
     {
         if constexpr (std::is_same_v<T, Windows::Foundation::IInspectable>)
@@ -324,7 +324,7 @@ WINRT_EXPORT namespace winrt
         }
     }
 
-    template <typename T, typename Allocator = std::allocator<T>>
+    WINRT_EXPORT template <typename T, typename Allocator = std::allocator<T>>
     Windows::Foundation::Collections::IObservableVector<T> multi_threaded_observable_vector(std::vector<T, Allocator>&& values = {})
     {
         if constexpr (std::is_same_v<T, Windows::Foundation::IInspectable>)
diff --git a/strings/base_com_ptr.h b/strings/base_com_ptr.h
index 1925bf5df..7aaa0cd95 100644
--- a/strings/base_com_ptr.h
+++ b/strings/base_com_ptr.h
@@ -1,13 +1,13 @@
 
-WINRT_EXPORT namespace winrt
+extern "C++" namespace winrt
 {
-    template <typename T>
+    WINRT_EXPORT template <typename T>
     struct com_ptr;
 }
 
-WINRT_EXPORT namespace winrt::impl
+extern "C++" namespace winrt::impl
 {
-    struct capture_decay
+    WINRT_EXPORT struct capture_decay
     {
         void** result;
 
@@ -18,26 +18,26 @@ WINRT_EXPORT namespace winrt::impl
         }
     };
 
-    template <typename T, typename F, typename...Args>
+    WINRT_EXPORT template <typename T, typename F, typename...Args>
     std::int32_t capture_to(void**result, F function, Args&& ...args)
     {
         return function(args..., guid_of<T>(), capture_decay{ result });
     }
 
-    template <typename T, typename O, typename M, typename...Args>
+    WINRT_EXPORT template <typename T, typename O, typename M, typename...Args>
         requires (std::is_class_v<O> || std::is_union_v<O>)
     std::int32_t capture_to(void** result, O* object, M method, Args&& ...args)
     {
         return (object->*method)(args..., guid_of<T>(), capture_decay{ result });
     }
 
-    template <typename T, typename O, typename M, typename...Args>
+    WINRT_EXPORT template <typename T, typename O, typename M, typename...Args>
     std::int32_t capture_to(void** result, com_ptr<O> const& object, M method, Args&& ...args);
 }
 
-WINRT_EXPORT namespace winrt
+extern "C++" namespace winrt
 {
-    template <typename T>
+    WINRT_EXPORT template <typename T>
     struct com_ptr
     {
         using type = impl::abi_t<T>;
@@ -262,7 +262,7 @@ WINRT_EXPORT namespace winrt
         type* m_ptr{};
     };
 
-    template <typename T, typename...Args>
+    WINRT_EXPORT template <typename T, typename...Args>
     impl::com_ref<T> try_capture(Args&& ...args)
     {
         void* result{};
@@ -270,7 +270,7 @@ WINRT_EXPORT namespace winrt
         return { result, take_ownership_from_abi };
     }
 
-    template <typename T, typename...Args>
+    WINRT_EXPORT template <typename T, typename...Args>
     impl::com_ref<T> capture(Args&& ...args)
     {
         void* result{};
@@ -278,42 +278,45 @@ WINRT_EXPORT namespace winrt
         return { result, take_ownership_from_abi };
     }
 
-    template <typename T>
+    WINRT_EXPORT template <typename T>
     auto get_abi(com_ptr<T> const& object) noexcept
     {
         return object.get();
     }
 
-    template <typename T>
+    WINRT_EXPORT template <typename T>
     auto put_abi(com_ptr<T>& object) noexcept
     {
         return object.put_void();
     }
 
-    template <typename T>
+    WINRT_EXPORT template <typename T>
     void attach_abi(com_ptr<T>& object, impl::abi_t<T>* value) noexcept
     {
         object.attach(value);
     }
 
-    template <typename T>
+    WINRT_EXPORT template <typename T>
     auto detach_abi(com_ptr<T>& object) noexcept
     {
         return object.detach();
     }
 }
 
-WINRT_EXPORT namespace winrt::impl
+extern "C++" namespace winrt::impl
 {
-    template <typename T, typename O, typename M, typename...Args>
+    WINRT_EXPORT template <typename T, typename O, typename M, typename...Args>
     std::int32_t capture_to(void** result, com_ptr<O> const& object, M method, Args&& ...args)
     {
         return (object.get()->*(method))(args..., guid_of<T>(), capture_decay{ result });
     }
 }
 
-template <typename T>
-void** IID_PPV_ARGS_Helper(winrt::com_ptr<T>* ptr) noexcept
+extern "C++"
 {
-    return winrt::put_abi(*ptr);
+    template <typename T>
+    void** IID_PPV_ARGS_Helper(winrt::com_ptr<T>* ptr) noexcept
+    {
+        return winrt::put_abi(*ptr);
+    }
 }
diff --git a/strings/base_composable.h b/strings/base_composable.h
index a6d5da179..0e1bd6536 100644
--- a/strings/base_composable.h
+++ b/strings/base_composable.h
@@ -1,7 +1,7 @@
 
-WINRT_EXPORT namespace winrt::impl
+extern "C++" namespace winrt::impl
 {
-    template <typename D>
+    WINRT_EXPORT template <typename D>
     struct composable_factory
     {
 #if defined(_MSC_VER) && !defined(__clang__)
@@ -33,7 +33,7 @@ WINRT_EXPORT namespace winrt::impl
         }
     };
 
-    template <typename T, typename D, typename I>
+    WINRT_EXPORT template <typename T, typename D, typename I>
     class WINRT_IMPL_EMPTY_BASES produce_dispatch_to_overridable_base
     {
     protected:
@@ -55,10 +55,10 @@ WINRT_EXPORT namespace winrt::impl
         }
     };
 
-    template <typename T, typename D, typename I>
+    WINRT_EXPORT template <typename T, typename D, typename I>
     struct produce_dispatch_to_overridable;
 
-    template <typename D, typename... I>
+    WINRT_EXPORT template <typename D, typename... I>
     class dispatch_to_overridable
     {
         class wrapper : public produce_dispatch_to_overridable<wrapper, D, I>...
diff --git a/strings/base_coroutine_foundation.h b/strings/base_coroutine_foundation.h
index db8e299a4..f9dd949ed 100644
--- a/strings/base_coroutine_foundation.h
+++ b/strings/base_coroutine_foundation.h
@@ -1,10 +1,10 @@
 
-WINRT_EXPORT namespace winrt::impl
+extern "C++" namespace winrt::impl
 {
-    template <typename Async>
+    WINRT_EXPORT template <typename Async>
     struct async_completed_handler;
 
-    template <typename Async>
+    WINRT_EXPORT template <typename Async>
     using async_completed_handler_t = typename async_completed_handler<Async>::type;
 
     template <>
@@ -31,14 +31,14 @@ WINRT_EXPORT namespace winrt::impl
         using type = Windows::Foundation::AsyncOperationWithProgressCompletedHandler<TResult, TProgress>;
     };
 
-    inline void check_sta_blocking_wait() noexcept
+    WINRT_EXPORT inline void check_sta_blocking_wait() noexcept
     {
         // Note: A blocking wait on the UI thread for an asynchronous operation can cause a deadlock.
         // See https://docs.microsoft.com/windows/uwp/cpp-and-winrt-apis/concurrency#block-the-calling-thread
         WINRT_ASSERT(!is_sta_thread());
     }
 
-    template <typename T, typename H>
+    WINRT_EXPORT template <typename T, typename H>
     std::pair<T, H*> make_delegate_with_shared_state(H&& handler)
     {
         auto d = make_delegate<T, H>(std::forward<H>(handler));
@@ -46,7 +46,7 @@ WINRT_EXPORT namespace winrt::impl
         return { std::move(d), abi };
     }
 
-    template <typename Async>
+    WINRT_EXPORT template <typename Async>
     auto wait_for_completed(Async const& async, std::uint32_t const timeout)
     {
         struct shared_type
@@ -67,7 +67,7 @@ WINRT_EXPORT namespace winrt::impl
         return shared->status;
     }
 
-    template <typename Async>
+    WINRT_EXPORT template <typename Async>
     auto wait_for(Async const& async, Windows::Foundation::TimeSpan const& timeout)
     {
         check_sta_blocking_wait();
@@ -76,7 +76,7 @@ WINRT_EXPORT namespace winrt::impl
         return wait_for_completed(async, static_cast<std::uint32_t>(milliseconds));
     }
 
-    inline void check_status_canceled(Windows::Foundation::AsyncStatus status)
+    WINRT_EXPORT inline void check_status_canceled(Windows::Foundation::AsyncStatus status)
     {
         if (status == Windows::Foundation::AsyncStatus::Canceled)
         {
@@ -84,7 +84,7 @@ WINRT_EXPORT namespace winrt::impl
         }
     }
 
-    template <typename Async>
+    WINRT_EXPORT template <typename Async>
     auto wait_get(Async const& async)
     {
         check_sta_blocking_wait();
@@ -99,9 +99,9 @@ WINRT_EXPORT namespace winrt::impl
         return async.GetResults();
     }
 
-    struct ignore_apartment_context {};
+    WINRT_EXPORT struct ignore_apartment_context {};
 
-    template<bool preserve_context, typename Awaiter>
+    WINRT_EXPORT template<bool preserve_context, typename Awaiter>
     struct disconnect_aware_handler : private std::conditional_t<preserve_context, resume_apartment_context, ignore_apartment_context>
     {
         disconnect_aware_handler(Awaiter* awaiter, std::coroutine_handle<> handle) noexcept
@@ -149,7 +149,7 @@ WINRT_EXPORT namespace winrt::impl
         }
     };
 
-    template <typename Async, bool preserve_context = true>
+    WINRT_EXPORT template <typename Async, bool preserve_context = true>
     struct await_adapter : cancellable_awaiter<await_adapter<Async, preserve_context>>
     {
         template<typename T>
@@ -257,9 +257,9 @@ WINRT_EXPORT namespace winrt::impl
     }
 }
 
-WINRT_EXPORT namespace winrt
+extern "C++" namespace winrt
 {
-    template<typename Async>
+    WINRT_EXPORT template<typename Async>
         requires std::convertible_to<Async, winrt::Windows::Foundation::IAsyncInfo>
     inline impl::await_adapter<std::decay_t<Async>, false> resume_agile(Async&& async)
     {
@@ -267,52 +267,52 @@ WINRT_EXPORT namespace winrt
     };
 }
 
-WINRT_EXPORT namespace winrt::Windows::Foundation
+extern "C++" namespace winrt::Windows::Foundation
 {
-    inline impl::await_adapter<IAsyncAction> operator co_await(IAsyncAction const& async)
+    WINRT_EXPORT inline impl::await_adapter<IAsyncAction> operator co_await(IAsyncAction const& async)
     {
         return{ async };
     }
 
-    template <typename TProgress>
+    WINRT_EXPORT template <typename TProgress>
     impl::await_adapter<IAsyncActionWithProgress<TProgress>> operator co_await(IAsyncActionWithProgress<TProgress> const& async)
     {
         return{ async };
     }
 
-    template <typename TResult>
+    WINRT_EXPORT template <typename TResult>
     impl::await_adapter<IAsyncOperation<TResult>> operator co_await(IAsyncOperation<TResult> const& async)
     {
         return{ async };
     }
 
-    template <typename TResult, typename TProgress>
+    WINRT_EXPORT template <typename TResult, typename TProgress>
     impl::await_adapter<IAsyncOperationWithProgress<TResult, TProgress>> operator co_await(IAsyncOperationWithProgress<TResult, TProgress> const& async)
     {
         return{ async };
     }
 }
 
-WINRT_EXPORT namespace winrt
+extern "C++" namespace winrt
 {
-    struct get_progress_token_t {};
+    WINRT_EXPORT struct get_progress_token_t {};
 
-    inline get_progress_token_t get_progress_token() noexcept
+    WINRT_EXPORT inline get_progress_token_t get_progress_token() noexcept
     {
         return{};
     }
 
-    struct get_cancellation_token_t {};
+    WINRT_EXPORT struct get_cancellation_token_t {};
 
-    inline get_cancellation_token_t get_cancellation_token() noexcept
+    WINRT_EXPORT inline get_cancellation_token_t get_cancellation_token() noexcept
     {
         return{};
     }
 }
 
-WINRT_EXPORT namespace winrt::impl
+extern "C++" namespace winrt::impl
 {
-    template <typename Promise>
+    WINRT_EXPORT template <typename Promise>
     struct cancellation_token
     {
         cancellation_token(Promise* promise) noexcept : m_promise(promise)
@@ -357,7 +357,7 @@ WINRT_EXPORT namespace winrt::impl
         Promise* m_promise;
     };
 
-    template <typename Promise, typename Progress>
+    WINRT_EXPORT template <typename Promise, typename Progress>
     struct progress_token
     {
         progress_token(Promise* promise) noexcept :
@@ -396,7 +396,7 @@ WINRT_EXPORT namespace winrt::impl
         Promise* m_promise;
     };
 
-    template <typename Derived, typename AsyncInterface, typename TProgress = void>
+    WINRT_EXPORT template <typename Derived, typename AsyncInterface, typename TProgress = void>
     struct promise_base : implements<Derived, AsyncInterface, Windows::Foundation::IAsyncInfo>, cancellable_promise
     {
         using AsyncStatus = Windows::Foundation::AsyncStatus;
@@ -702,7 +702,7 @@ WINRT_EXPORT namespace winrt::impl
     };
 }
 
-WINRT_EXPORT namespace std
+extern "C++" namespace std
 {
     template <typename... Args>
     struct coroutine_traits<winrt::Windows::Foundation::IAsyncAction, Args...>
@@ -835,16 +835,16 @@ WINRT_EXPORT namespace std
     };
 }
 
-WINRT_EXPORT namespace winrt
+extern "C++" namespace winrt
 {
-    template <typename... T>
+    WINRT_EXPORT template <typename... T>
     Windows::Foundation::IAsyncAction when_all(T... async)
     {
         (void(co_await async), ...);
         co_return;
     }
 
-    template <typename T, typename... Rest>
+    WINRT_EXPORT template <typename T, typename... Rest>
     T when_any(T const& first, Rest const& ... rest)
     {
         static_assert(impl::has_category_v<T>, "T must be WinRT async type such as IAsyncAction or IAsyncOperation.");
diff --git a/strings/base_coroutine_system.h b/strings/base_coroutine_system.h
index 96d942bec..9430dd498 100644
--- a/strings/base_coroutine_system.h
+++ b/strings/base_coroutine_system.h
@@ -1,7 +1,7 @@
 
-WINRT_EXPORT namespace winrt
+extern "C++" namespace winrt
 {
-    [[nodiscard]] inline auto resume_foreground(
+    WINRT_EXPORT [[nodiscard]] inline auto resume_foreground(
         Windows::System::DispatcherQueue const& dispatcher,
         Windows::System::DispatcherQueuePriority const priority = Windows::System::DispatcherQueuePriority::Normal) noexcept
     {
@@ -41,7 +41,7 @@ WINRT_EXPORT namespace winrt
         return awaitable{ dispatcher, priority };
     };
 
-    inline auto operator co_await(Windows::System::DispatcherQueue const& dispatcher)
+    WINRT_EXPORT inline auto operator co_await(Windows::System::DispatcherQueue const& dispatcher)
     {
         return resume_foreground(dispatcher);
     }
diff --git a/strings/base_coroutine_system_winui.h b/strings/base_coroutine_system_winui.h
index 93eb4fe61..037d2afdf 100644
--- a/strings/base_coroutine_system_winui.h
+++ b/strings/base_coroutine_system_winui.h
@@ -1,7 +1,7 @@
 
-WINRT_EXPORT namespace winrt
+extern "C++" namespace winrt
 {
-    [[nodiscard]] inline auto resume_foreground(
+    WINRT_EXPORT [[nodiscard]] inline auto resume_foreground(
         Microsoft::System::DispatcherQueue const& dispatcher,
         Microsoft::System::DispatcherQueuePriority const priority = Microsoft::System::DispatcherQueuePriority::Normal) noexcept
     {
@@ -39,9 +39,9 @@ WINRT_EXPORT namespace winrt
         };
 
         return awaitable{ dispatcher, priority };
-    };
+    }
 
-    inline auto operator co_await(Microsoft::System::DispatcherQueue const& dispatcher)
+    WINRT_EXPORT inline auto operator co_await(Microsoft::System::DispatcherQueue const& dispatcher)
     {
         return resume_foreground(dispatcher);
     }
diff --git a/strings/base_coroutine_threadpool.h b/strings/base_coroutine_threadpool.h
index 9a3bbb652..df28f9fbb 100644
--- a/strings/base_coroutine_threadpool.h
+++ b/strings/base_coroutine_threadpool.h
@@ -1,7 +1,7 @@
 
-WINRT_EXPORT namespace winrt::impl
+extern "C++" namespace winrt::impl
 {
-    inline auto submit_threadpool_callback(void(__stdcall* callback)(void*, void* context), void* context)
+    WINRT_EXPORT inline auto submit_threadpool_callback(void(__stdcall* callback)(void*, void* context), void* context)
     {
         if (!WINRT_IMPL_TrySubmitThreadpoolCallback(callback, context, nullptr))
         {
@@ -9,17 +9,17 @@ WINRT_EXPORT namespace winrt::impl
         }
     }
 
-    inline void __stdcall resume_background_callback(void*, void* context) noexcept
+    WINRT_EXPORT inline void __stdcall resume_background_callback(void*, void* context) noexcept
     {
         std::coroutine_handle<>::from_address(context)();
     };
 
-    inline auto resume_background(std::coroutine_handle<> handle)
+    WINRT_EXPORT inline auto resume_background(std::coroutine_handle<> handle)
     {
         submit_threadpool_callback(resume_background_callback, handle.address());
     }
 
-    inline std::pair<std::int32_t, std::int32_t> get_apartment_type() noexcept
+    WINRT_EXPORT inline std::pair<std::int32_t, std::int32_t> get_apartment_type() noexcept
     {
         std::int32_t aptType;
         std::int32_t aptTypeQualifier;
@@ -33,7 +33,7 @@ WINRT_EXPORT namespace winrt::impl
         }
     }
 
-    inline bool is_sta_thread() noexcept
+    WINRT_EXPORT inline bool is_sta_thread() noexcept
     {
         auto type = get_apartment_type();
         switch (type.first)
@@ -48,7 +48,7 @@ WINRT_EXPORT namespace winrt::impl
         return false;
     }
 
-    struct resume_apartment_context
+    WINRT_EXPORT struct resume_apartment_context
     {
         resume_apartment_context() = default;
         resume_apartment_context(std::nullptr_t) : m_context(nullptr), m_context_type(-1) {}
@@ -62,13 +62,13 @@ WINRT_EXPORT namespace winrt::impl
         movable_primitive<std::int32_t, -1> m_context_type = get_apartment_type().first;
     };
 
-    inline std::int32_t __stdcall resume_apartment_callback(com_callback_args* args) noexcept
+    WINRT_EXPORT inline std::int32_t __stdcall resume_apartment_callback(com_callback_args* args) noexcept
     {
         std::coroutine_handle<>::from_address(args->data)();
         return 0;
     };
 
-    [[nodiscard]] inline bool resume_apartment_sync(com_ptr<IContextCallback> const& context, std::coroutine_handle<> handle, std::int32_t* failure)
+    WINRT_EXPORT [[nodiscard]] inline bool resume_apartment_sync(com_ptr<IContextCallback> const& context, std::coroutine_handle<> handle, std::int32_t* failure)
     {
         com_callback_args args{};
         args.data = handle.address();
@@ -83,7 +83,7 @@ WINRT_EXPORT namespace winrt::impl
         return true;
     }
 
-    struct threadpool_resume
+    WINRT_EXPORT struct threadpool_resume
     {
         threadpool_resume(com_ptr<IContextCallback> const& context, std::coroutine_handle<> handle, std::int32_t* failure) :
             m_context(context), m_handle(handle), m_failure(failure) { }
@@ -92,7 +92,7 @@ WINRT_EXPORT namespace winrt::impl
         std::int32_t* m_failure;
     };
 
-    inline void __stdcall fallback_submit_threadpool_callback(void*, void* p) noexcept
+    WINRT_EXPORT inline void __stdcall fallback_submit_threadpool_callback(void*, void* p) noexcept
     {
         std::unique_ptr<threadpool_resume> state{ static_cast<threadpool_resume*>(p) };
         if (!resume_apartment_sync(state->m_context, state->m_handle, state->m_failure))
@@ -101,14 +101,14 @@ WINRT_EXPORT namespace winrt::impl
         }
     }
 
-    inline void resume_apartment_on_threadpool(com_ptr<IContextCallback> const& context, std::coroutine_handle<> handle, std::int32_t* failure)
+    WINRT_EXPORT inline void resume_apartment_on_threadpool(com_ptr<IContextCallback> const& context, std::coroutine_handle<> handle, std::int32_t* failure)
     {
         auto state = std::make_unique<threadpool_resume>(context, handle, failure);
         submit_threadpool_callback(fallback_submit_threadpool_callback, state.get());
         state.release();
     }
 
-    [[nodiscard]] inline auto resume_apartment(resume_apartment_context const& context, std::coroutine_handle<> handle, std::int32_t* failure)
+    WINRT_EXPORT [[nodiscard]] inline auto resume_apartment(resume_apartment_context const& context, std::coroutine_handle<> handle, std::int32_t* failure)
     {
         WINRT_ASSERT(context.valid());
         if ((context.m_context == nullptr) || (context.m_context == try_capture<IContextCallback>(WINRT_IMPL_CoGetObjectContext)))
@@ -131,9 +131,9 @@ WINRT_EXPORT namespace winrt::impl
         }
     }
 
-    using canceller_t = void(*)(void*);
+    WINRT_EXPORT using canceller_t = void(*)(void*);
 
-    struct unique_cancellation_lock
+    WINRT_EXPORT struct unique_cancellation_lock
     {
         std::atomic<canceller_t>& m_pcanceller;
 
@@ -144,9 +144,9 @@ WINRT_EXPORT namespace winrt::impl
     };
 }
 
-WINRT_EXPORT namespace winrt
+extern "C++" namespace winrt
 {
-    struct cancellable_promise
+    WINRT_EXPORT struct cancellable_promise
     {
         void set_canceller(impl::canceller_t canceller, void* context)
         {
@@ -202,7 +202,7 @@ WINRT_EXPORT namespace winrt
         bool m_originate_on_cancel{ true }; // By default, will call RoOriginateError before throwing a cancel error code.
     };
 
-    template <typename Derived>
+    WINRT_EXPORT template <typename Derived>
     struct cancellable_awaiter
     {
         cancellable_awaiter() noexcept = default;
@@ -242,9 +242,9 @@ WINRT_EXPORT namespace winrt
     };
 }
 
-WINRT_EXPORT namespace winrt
+extern "C++" namespace winrt
 {
-    [[nodiscard]] inline auto resume_background() noexcept
+    WINRT_EXPORT [[nodiscard]] inline auto resume_background() noexcept
     {
         struct awaitable
         {
@@ -266,7 +266,7 @@ WINRT_EXPORT namespace winrt
         return awaitable{};
     }
 
-    template <typename T>
+    WINRT_EXPORT template <typename T>
     [[nodiscard]] auto resume_background(T const& context) noexcept
     {
         struct awaitable
@@ -310,7 +310,7 @@ WINRT_EXPORT namespace winrt
         return awaitable{ context };
     }
 
-    struct apartment_context
+    WINRT_EXPORT struct apartment_context
     {
         apartment_context() = default;
         apartment_context(std::nullptr_t) : context(nullptr) { }
@@ -322,9 +322,9 @@ WINRT_EXPORT namespace winrt
     };
 }
 
-WINRT_EXPORT namespace winrt::impl
+extern "C++" namespace winrt::impl
 {
-    struct apartment_awaiter
+    WINRT_EXPORT struct apartment_awaiter
     {
         apartment_context const& context;
         std::int32_t failure = 0;
@@ -346,7 +346,7 @@ WINRT_EXPORT namespace winrt::impl
         }
     };
 
-    struct timespan_awaiter : cancellable_awaiter<timespan_awaiter>
+    WINRT_EXPORT struct timespan_awaiter : cancellable_awaiter<timespan_awaiter>
     {
         explicit timespan_awaiter(Windows::Foundation::TimeSpan duration) noexcept :
             m_duration(duration)
@@ -452,7 +452,7 @@ WINRT_EXPORT namespace winrt::impl
         std::atomic<state> m_state{ state::idle };
     };
 
-    struct signal_awaiter : cancellable_awaiter<signal_awaiter>
+    WINRT_EXPORT struct signal_awaiter : cancellable_awaiter<signal_awaiter>
     {
         signal_awaiter(void* handle, Windows::Foundation::TimeSpan timeout) noexcept :
             m_timeout(timeout),
@@ -567,29 +567,29 @@ WINRT_EXPORT namespace winrt::impl
     };
 }
 
-WINRT_EXPORT namespace winrt
+extern "C++" namespace winrt
 {
-    inline impl::apartment_awaiter operator co_await(apartment_context const& context)
+    WINRT_EXPORT inline impl::apartment_awaiter operator co_await(apartment_context const& context)
     {
         return{ context };
     }
 
-    [[nodiscard]] inline impl::timespan_awaiter resume_after(Windows::Foundation::TimeSpan duration) noexcept
+    WINRT_EXPORT [[nodiscard]] inline impl::timespan_awaiter resume_after(Windows::Foundation::TimeSpan duration) noexcept
     {
         return impl::timespan_awaiter{ duration };
     }
 
-    inline impl::timespan_awaiter operator co_await(Windows::Foundation::TimeSpan duration)
+    WINRT_EXPORT inline impl::timespan_awaiter operator co_await(Windows::Foundation::TimeSpan duration)
     {
         return resume_after(duration);
     }
 
-    [[nodiscard]] inline impl::signal_awaiter resume_on_signal(void* handle, Windows::Foundation::TimeSpan timeout = {}) noexcept
+    WINRT_EXPORT [[nodiscard]] inline impl::signal_awaiter resume_on_signal(void* handle, Windows::Foundation::TimeSpan timeout = {}) noexcept
     {
         return impl::signal_awaiter{ handle, timeout };
     }
 
-    struct thread_pool
+    WINRT_EXPORT struct thread_pool
     {
         thread_pool() :
             m_pool(check_pointer(WINRT_IMPL_CreateThreadpool(nullptr)))
@@ -669,10 +669,10 @@ WINRT_EXPORT namespace winrt
         environment m_environment;
     };
 
-    struct fire_and_forget {};
+    WINRT_EXPORT struct fire_and_forget {};
 }
 
-WINRT_EXPORT namespace std
+extern "C++" namespace std
 {
     template <typename... Args>
     struct coroutine_traits<winrt::fire_and_forget, Args...>
diff --git a/strings/base_coroutine_ui_core.h b/strings/base_coroutine_ui_core.h
index 03d374905..af248c1e9 100644
--- a/strings/base_coroutine_ui_core.h
+++ b/strings/base_coroutine_ui_core.h
@@ -1,7 +1,7 @@
 
-WINRT_EXPORT namespace winrt
+extern "C++" namespace winrt
 {
-    [[nodiscard]] inline auto resume_foreground(
+    WINRT_EXPORT [[nodiscard]] inline auto resume_foreground(
         Windows::UI::Core::CoreDispatcher const& dispatcher,
         Windows::UI::Core::CoreDispatcherPriority const priority = Windows::UI::Core::CoreDispatcherPriority::Normal) noexcept
     {
@@ -39,7 +39,7 @@ WINRT_EXPORT namespace winrt
         return awaitable{ dispatcher, priority };
     };
 
-    inline auto operator co_await(Windows::UI::Core::CoreDispatcher const& dispatcher)
+    WINRT_EXPORT inline auto operator co_await(Windows::UI::Core::CoreDispatcher const& dispatcher)
     {
         return resume_foreground(dispatcher);
     }
diff --git a/strings/base_deferral.h b/strings/base_deferral.h
index 702cf3a32..590824828 100644
--- a/strings/base_deferral.h
+++ b/strings/base_deferral.h
@@ -1,7 +1,7 @@
 
-WINRT_EXPORT namespace winrt
+extern "C++" namespace winrt
 {
-    template<typename D>
+    WINRT_EXPORT template<typename D>
     struct deferrable_event_args
     {
         Windows::Foundation::Deferral GetDeferral()
diff --git a/strings/base_delegate.h b/strings/base_delegate.h
index 5d3c1b722..f48c4af17 100644
--- a/strings/base_delegate.h
+++ b/strings/base_delegate.h
@@ -1,12 +1,12 @@
 
-WINRT_EXPORT namespace winrt::impl
+extern "C++" namespace winrt::impl
 {
 #if defined(_MSC_VER) && !defined(__clang__)
 #pragma warning(push)
 #pragma warning(disable:4458) // declaration hides class member (okay because we do not use named members of base class)
 #endif
 
-    struct implements_delegate_base
+    WINRT_EXPORT struct implements_delegate_base
     {
         WINRT_IMPL_NOINLINE std::uint32_t increment_reference() noexcept
         {
@@ -40,7 +40,7 @@ WINRT_EXPORT namespace winrt::impl
         atomic_ref_count m_references{ 1 };
     };
 
-    template <typename T, typename H>
+    WINRT_EXPORT template <typename T, typename H>
     struct implements_delegate : abi_t<T>, implements_delegate_base, H, update_module_lock
     {
         implements_delegate(H&& handler) : H(std::forward<H>(handler))
@@ -70,13 +70,13 @@ WINRT_EXPORT namespace winrt::impl
         }
     };
 
-    template <typename T, typename H>
+    WINRT_EXPORT template <typename T, typename H>
     T make_delegate(H&& handler)
     {
         return { static_cast<void*>(static_cast<abi_t<T>*>(new delegate<T, H>(std::forward<H>(handler)))), take_ownership_from_abi };
     }
 
-    template <typename T>
+    WINRT_EXPORT template <typename T>
     T make_agile_delegate(T const& delegate) noexcept
     {
         if constexpr (!has_category_v<T>)
@@ -108,13 +108,13 @@ WINRT_EXPORT namespace winrt::impl
         }
     }
 
-    template <typename R, typename... Args>
+    WINRT_EXPORT template <typename R, typename... Args>
     struct WINRT_IMPL_ABI_DECL variadic_delegate_abi : unknown_abi
     {
         virtual R invoke(Args const& ...) = 0;
     };
 
-    template <typename H, typename R, typename... Args>
+    WINRT_EXPORT template <typename H, typename R, typename... Args>
     struct variadic_delegate final : variadic_delegate_abi<R, Args...>, implements_delegate_base, H, update_module_lock
     {
         variadic_delegate(H&& handler) : H(std::forward<H>(handler))
@@ -156,7 +156,7 @@ WINRT_EXPORT namespace winrt::impl
         }
     };
 
-    template <typename R, typename... Args>
+    WINRT_EXPORT template <typename R, typename... Args>
     struct WINRT_IMPL_EMPTY_BASES delegate_base : Windows::Foundation::IUnknown
     {
         delegate_base(std::nullptr_t = nullptr) noexcept {}
@@ -220,9 +220,9 @@ WINRT_EXPORT namespace winrt::impl
 #endif
 }
 
-WINRT_EXPORT namespace winrt
+extern "C++" namespace winrt
 {
-    template <typename... Args>
+    WINRT_EXPORT template <typename... Args>
     struct WINRT_IMPL_EMPTY_BASES delegate : impl::delegate_base<void, Args...>
     {
         using impl::delegate_base<void, Args...>::delegate_base;
diff --git a/strings/base_error.h b/strings/base_error.h
index 36e1ed588..55aedbeb5 100644
--- a/strings/base_error.h
+++ b/strings/base_error.h
@@ -7,9 +7,9 @@
 #define WINRT_IMPL_RETURNADDRESS() nullptr
 #endif
 
-WINRT_EXPORT namespace winrt::impl
+extern "C++" namespace winrt::impl
 {
-    struct heap_traits
+    WINRT_EXPORT struct heap_traits
     {
         using type = wchar_t*;
 
@@ -24,7 +24,7 @@ WINRT_EXPORT namespace winrt::impl
         }
     };
 
-    struct bstr_traits
+    WINRT_EXPORT struct bstr_traits
     {
         using type = wchar_t*;
 
@@ -39,9 +39,9 @@ WINRT_EXPORT namespace winrt::impl
         }
     };
 
-    using bstr_handle = handle_type<bstr_traits>;
+    WINRT_EXPORT using bstr_handle = handle_type<bstr_traits>;
 
-    inline hstring trim_hresult_message(wchar_t const* const message, std::uint32_t size) noexcept
+    WINRT_EXPORT inline hstring trim_hresult_message(wchar_t const* const message, std::uint32_t size) noexcept
     {
         wchar_t const* back = message + size - 1;
 
@@ -54,7 +54,7 @@ WINRT_EXPORT namespace winrt::impl
         return { message, size };
     }
 
-    inline hstring message_from_hresult(hresult code) noexcept
+    WINRT_EXPORT inline hstring message_from_hresult(hresult code) noexcept
     {
         handle_type<impl::heap_traits> message;
 
@@ -69,20 +69,20 @@ WINRT_EXPORT namespace winrt::impl
         return trim_hresult_message(message.get(), size);
     }
 
-    constexpr std::int32_t hresult_from_win32(std::uint32_t const x) noexcept
+    WINRT_EXPORT constexpr std::int32_t hresult_from_win32(std::uint32_t const x) noexcept
     {
         return (std::int32_t)(x) <= 0 ? (std::int32_t)(x) : (std::int32_t)(((x) & 0x0000FFFF) | (7 << 16) | 0x80000000);
     }
 
-    constexpr std::int32_t hresult_from_nt(std::uint32_t const x) noexcept
+    WINRT_EXPORT constexpr std::int32_t hresult_from_nt(std::uint32_t const x) noexcept
     {
         return ((std::int32_t)((x) | 0x10000000));
     }
 }
 
-WINRT_EXPORT namespace winrt
+extern "C++" namespace winrt
 {
-    struct hresult_error
+    WINRT_EXPORT struct hresult_error
     {
         struct no_originate_t {};
         static constexpr no_originate_t no_originate{};
@@ -210,9 +210,6 @@ WINRT_EXPORT namespace winrt
         {
             WINRT_VERIFY(WINRT_IMPL_RoOriginateLanguageException(code, message, nullptr));
 
-            // This is an extension point that can be filled in by other libraries (such as WIL) to get call outs when errors are
-            // originated.  This is intended for logging purposes.  When possible include the std::source_information so that accurate
-            // information is available on the caller who generated the error.
             if (winrt_throw_hresult_handler)
             {
                 winrt_throw_hresult_handler(sourceInformation.line(), sourceInformation.file_name(), sourceInformation.function_name(), WINRT_IMPL_RETURNADDRESS(), code);
@@ -245,91 +242,91 @@ WINRT_EXPORT namespace winrt
 #endif
     };
 
-    struct hresult_access_denied : hresult_error
+    WINRT_EXPORT struct hresult_access_denied : hresult_error
     {
         hresult_access_denied(winrt::impl::slim_source_location const& sourceInformation = winrt::impl::slim_source_location::current()) noexcept : hresult_error(impl::error_access_denied, sourceInformation) {}
         hresult_access_denied(param::hstring const& message, winrt::impl::slim_source_location const& sourceInformation = winrt::impl::slim_source_location::current()) noexcept : hresult_error(impl::error_access_denied, message, sourceInformation) {}
         hresult_access_denied(take_ownership_from_abi_t, winrt::impl::slim_source_location const& sourceInformation = winrt::impl::slim_source_location::current()) noexcept : hresult_error(impl::error_access_denied, take_ownership_from_abi, sourceInformation) {}
     };
 
-    struct hresult_wrong_thread : hresult_error
+    WINRT_EXPORT struct hresult_wrong_thread : hresult_error
     {
         hresult_wrong_thread(winrt::impl::slim_source_location const& sourceInformation = winrt::impl::slim_source_location::current()) noexcept : hresult_error(impl::error_wrong_thread, sourceInformation) {}
         hresult_wrong_thread(param::hstring const& message, winrt::impl::slim_source_location const& sourceInformation = winrt::impl::slim_source_location::current()) noexcept : hresult_error(impl::error_wrong_thread, message, sourceInformation) {}
         hresult_wrong_thread(take_ownership_from_abi_t, winrt::impl::slim_source_location const& sourceInformation = winrt::impl::slim_source_location::current()) noexcept : hresult_error(impl::error_wrong_thread, take_ownership_from_abi, sourceInformation) {}
     };
 
-    struct hresult_not_implemented : hresult_error
+    WINRT_EXPORT struct hresult_not_implemented : hresult_error
     {
         hresult_not_implemented(winrt::impl::slim_source_location const& sourceInformation = winrt::impl::slim_source_location::current()) noexcept : hresult_error(impl::error_not_implemented, sourceInformation) {}
         hresult_not_implemented(param::hstring const& message, winrt::impl::slim_source_location const& sourceInformation = winrt::impl::slim_source_location::current()) noexcept : hresult_error(impl::error_not_implemented, message, sourceInformation) {}
         hresult_not_implemented(take_ownership_from_abi_t, winrt::impl::slim_source_location const& sourceInformation = winrt::impl::slim_source_location::current()) noexcept : hresult_error(impl::error_not_implemented, take_ownership_from_abi, sourceInformation) {}
     };
 
-    struct hresult_invalid_argument : hresult_error
+    WINRT_EXPORT struct hresult_invalid_argument : hresult_error
     {
         hresult_invalid_argument(winrt::impl::slim_source_location const& sourceInformation = winrt::impl::slim_source_location::current()) noexcept : hresult_error(impl::error_invalid_argument, sourceInformation) {}
         hresult_invalid_argument(param::hstring const& message, winrt::impl::slim_source_location const& sourceInformation = winrt::impl::slim_source_location::current()) noexcept : hresult_error(impl::error_invalid_argument, message, sourceInformation) {}
         hresult_invalid_argument(take_ownership_from_abi_t, winrt::impl::slim_source_location const& sourceInformation = winrt::impl::slim_source_location::current()) noexcept : hresult_error(impl::error_invalid_argument, take_ownership_from_abi, sourceInformation) {}
     };
 
-    struct hresult_out_of_bounds : hresult_error
+    WINRT_EXPORT struct hresult_out_of_bounds : hresult_error
     {
         hresult_out_of_bounds(winrt::impl::slim_source_location const& sourceInformation = winrt::impl::slim_source_location::current()) noexcept : hresult_error(impl::error_out_of_bounds, sourceInformation) {}
         hresult_out_of_bounds(param::hstring const& message, winrt::impl::slim_source_location const& sourceInformation = winrt::impl::slim_source_location::current()) noexcept : hresult_error(impl::error_out_of_bounds, message, sourceInformation) {}
         hresult_out_of_bounds(take_ownership_from_abi_t, winrt::impl::slim_source_location const& sourceInformation = winrt::impl::slim_source_location::current()) noexcept : hresult_error(impl::error_out_of_bounds, take_ownership_from_abi, sourceInformation) {}
     };
 
-    struct hresult_no_interface : hresult_error
+    WINRT_EXPORT struct hresult_no_interface : hresult_error
     {
         hresult_no_interface(winrt::impl::slim_source_location const& sourceInformation = winrt::impl::slim_source_location::current()) noexcept : hresult_error(impl::error_no_interface, sourceInformation) {}
         hresult_no_interface(param::hstring const& message, winrt::impl::slim_source_location const& sourceInformation = winrt::impl::slim_source_location::current()) noexcept : hresult_error(impl::error_no_interface, message, sourceInformation) {}
         hresult_no_interface(take_ownership_from_abi_t, winrt::impl::slim_source_location const& sourceInformation = winrt::impl::slim_source_location::current()) noexcept : hresult_error(impl::error_no_interface, take_ownership_from_abi, sourceInformation) {}
     };
 
-    struct hresult_class_not_available : hresult_error
+    WINRT_EXPORT struct hresult_class_not_available : hresult_error
     {
         hresult_class_not_available(winrt::impl::slim_source_location const& sourceInformation = winrt::impl::slim_source_location::current()) noexcept : hresult_error(impl::error_class_not_available, sourceInformation) {}
         hresult_class_not_available(param::hstring const& message, winrt::impl::slim_source_location const& sourceInformation = winrt::impl::slim_source_location::current()) noexcept : hresult_error(impl::error_class_not_available, message, sourceInformation) {}
         hresult_class_not_available(take_ownership_from_abi_t, winrt::impl::slim_source_location const& sourceInformation = winrt::impl::slim_source_location::current()) noexcept : hresult_error(impl::error_class_not_available, take_ownership_from_abi, sourceInformation) {}
     };
 
-    struct hresult_class_not_registered : hresult_error
+    WINRT_EXPORT struct hresult_class_not_registered : hresult_error
     {
         hresult_class_not_registered(winrt::impl::slim_source_location const& sourceInformation = winrt::impl::slim_source_location::current()) noexcept : hresult_error(impl::error_class_not_registered, sourceInformation) {}
         hresult_class_not_registered(param::hstring const& message, winrt::impl::slim_source_location const& sourceInformation = winrt::impl::slim_source_location::current()) noexcept : hresult_error(impl::error_class_not_registered, message, sourceInformation) {}
         hresult_class_not_registered(take_ownership_from_abi_t, winrt::impl::slim_source_location const& sourceInformation = winrt::impl::slim_source_location::current()) noexcept : hresult_error(impl::error_class_not_registered, take_ownership_from_abi, sourceInformation) {}
     };
 
-    struct hresult_changed_state : hresult_error
+    WINRT_EXPORT struct hresult_changed_state : hresult_error
     {
         hresult_changed_state(winrt::impl::slim_source_location const& sourceInformation = winrt::impl::slim_source_location::current()) noexcept : hresult_error(impl::error_changed_state, sourceInformation) {}
         hresult_changed_state(param::hstring const& message, winrt::impl::slim_source_location const& sourceInformation = winrt::impl::slim_source_location::current()) noexcept : hresult_error(impl::error_changed_state, message, sourceInformation) {}
         hresult_changed_state(take_ownership_from_abi_t, winrt::impl::slim_source_location const& sourceInformation = winrt::impl::slim_source_location::current()) noexcept : hresult_error(impl::error_changed_state, take_ownership_from_abi, sourceInformation) {}
     };
 
-    struct hresult_illegal_method_call : hresult_error
+    WINRT_EXPORT struct hresult_illegal_method_call : hresult_error
     {
         hresult_illegal_method_call(winrt::impl::slim_source_location const& sourceInformation = winrt::impl::slim_source_location::current()) noexcept : hresult_error(impl::error_illegal_method_call, sourceInformation) {}
         hresult_illegal_method_call(param::hstring const& message, winrt::impl::slim_source_location const& sourceInformation = winrt::impl::slim_source_location::current()) noexcept : hresult_error(impl::error_illegal_method_call, message, sourceInformation) {}
         hresult_illegal_method_call(take_ownership_from_abi_t, winrt::impl::slim_source_location const& sourceInformation = winrt::impl::slim_source_location::current()) noexcept : hresult_error(impl::error_illegal_method_call, take_ownership_from_abi, sourceInformation) {}
     };
 
-    struct hresult_illegal_state_change : hresult_error
+    WINRT_EXPORT struct hresult_illegal_state_change : hresult_error
     {
         hresult_illegal_state_change(winrt::impl::slim_source_location const& sourceInformation = winrt::impl::slim_source_location::current()) noexcept : hresult_error(impl::error_illegal_state_change, sourceInformation) {}
         hresult_illegal_state_change(param::hstring const& message, winrt::impl::slim_source_location const& sourceInformation = winrt::impl::slim_source_location::current()) noexcept : hresult_error(impl::error_illegal_state_change, message, sourceInformation) {}
         hresult_illegal_state_change(take_ownership_from_abi_t, winrt::impl::slim_source_location const& sourceInformation = winrt::impl::slim_source_location::current()) noexcept : hresult_error(impl::error_illegal_state_change, take_ownership_from_abi, sourceInformation) {}
     };
 
-    struct hresult_illegal_delegate_assignment : hresult_error
+    WINRT_EXPORT struct hresult_illegal_delegate_assignment : hresult_error
     {
         hresult_illegal_delegate_assignment(winrt::impl::slim_source_location const& sourceInformation = winrt::impl::slim_source_location::current()) noexcept : hresult_error(impl::error_illegal_delegate_assignment, sourceInformation) {}
         hresult_illegal_delegate_assignment(param::hstring const& message, winrt::impl::slim_source_location const& sourceInformation = winrt::impl::slim_source_location::current()) noexcept : hresult_error(impl::error_illegal_delegate_assignment, message, sourceInformation) {}
         hresult_illegal_delegate_assignment(take_ownership_from_abi_t, winrt::impl::slim_source_location const& sourceInformation = winrt::impl::slim_source_location::current()) noexcept : hresult_error(impl::error_illegal_delegate_assignment, take_ownership_from_abi, sourceInformation) {}
     };
 
-    struct hresult_canceled : hresult_error
+    WINRT_EXPORT struct hresult_canceled : hresult_error
     {
         hresult_canceled(winrt::impl::slim_source_location const& sourceInformation = winrt::impl::slim_source_location::current()) noexcept : hresult_error(impl::error_canceled, sourceInformation) {}
         hresult_canceled(hresult_error::no_originate_t) noexcept : hresult_error(impl::error_canceled, hresult_error::no_originate) {}
@@ -337,7 +334,7 @@ WINRT_EXPORT namespace winrt
         hresult_canceled(take_ownership_from_abi_t, winrt::impl::slim_source_location const& sourceInformation = winrt::impl::slim_source_location::current()) noexcept : hresult_error(impl::error_canceled, take_ownership_from_abi, sourceInformation) {}
     };
 
-    [[noreturn]] inline WINRT_IMPL_NOINLINE void throw_hresult(hresult const result, winrt::impl::slim_source_location const& sourceInformation = winrt::impl::slim_source_location::current())
+    WINRT_EXPORT [[noreturn]] inline WINRT_IMPL_NOINLINE void throw_hresult(hresult const result, winrt::impl::slim_source_location const& sourceInformation = winrt::impl::slim_source_location::current())
     {
         if (winrt_throw_hresult_handler)
         {
@@ -417,7 +414,7 @@ WINRT_EXPORT namespace winrt
         throw hresult_error(result, take_ownership_from_abi, sourceInformation);
     }
 
-    inline WINRT_IMPL_NOINLINE hresult to_hresult() noexcept
+    WINRT_EXPORT inline WINRT_IMPL_NOINLINE hresult to_hresult() noexcept
     {
         if (winrt_to_hresult_handler)
         {
@@ -450,7 +447,7 @@ WINRT_EXPORT namespace winrt
         }
     }
 
-    inline WINRT_IMPL_NOINLINE hstring to_message()
+    WINRT_EXPORT inline WINRT_IMPL_NOINLINE hstring to_message()
     {
         if (winrt_to_message_handler)
         {
@@ -475,12 +472,12 @@ WINRT_EXPORT namespace winrt
         }
     }
 
-    [[noreturn]] inline void throw_last_error(winrt::impl::slim_source_location const& sourceInformation = winrt::impl::slim_source_location::current())
+    WINRT_EXPORT [[noreturn]] inline void throw_last_error(winrt::impl::slim_source_location const& sourceInformation = winrt::impl::slim_source_location::current())
     {
         throw_hresult(impl::hresult_from_win32(WINRT_IMPL_GetLastError()), sourceInformation);
     }
 
-    inline hresult check_hresult(hresult const result, winrt::impl::slim_source_location const& sourceInformation)
+    WINRT_EXPORT inline hresult check_hresult(hresult const result, winrt::impl::slim_source_location const& sourceInformation)
     {
         if (result < 0)
         {
@@ -489,7 +486,7 @@ WINRT_EXPORT namespace winrt
         return result;
     }
 
-    template<typename T>
+    WINRT_EXPORT template<typename T>
     void check_nt(T result, winrt::impl::slim_source_location const& sourceInformation = winrt::impl::slim_source_location::current())
     {
         if (result != 0)
@@ -498,7 +495,7 @@ WINRT_EXPORT namespace winrt
         }
     }
 
-    template<typename T>
+    WINRT_EXPORT template<typename T>
     void check_win32(T result, winrt::impl::slim_source_location const& sourceInformation = winrt::impl::slim_source_location::current())
     {
         if (result != 0)
@@ -507,7 +504,7 @@ WINRT_EXPORT namespace winrt
         }
     }
 
-    template<typename T>
+    WINRT_EXPORT template<typename T>
     T check_bool(T result, winrt::impl::slim_source_location const& sourceInformation = winrt::impl::slim_source_location::current())
     {
         if (!result)
@@ -518,7 +515,7 @@ WINRT_EXPORT namespace winrt
         return result;
     }
 
-    template<typename T>
+    WINRT_EXPORT template<typename T>
     T* check_pointer(T* pointer, winrt::impl::slim_source_location const& sourceInformation = winrt::impl::slim_source_location::current())
     {
         if (!pointer)
@@ -529,16 +526,16 @@ WINRT_EXPORT namespace winrt
         return pointer;
     }
 
-    [[noreturn]] inline void terminate() noexcept
+    WINRT_EXPORT [[noreturn]] inline void terminate() noexcept
     {
         WINRT_IMPL_RoFailFastWithErrorContext(to_hresult());
         std::abort();
     }
 }
 
-WINRT_EXPORT namespace winrt::impl
+extern "C++" namespace winrt::impl
 {
-    inline hresult check_hresult_allow_bounds(hresult const result, winrt::impl::slim_source_location const& sourceInformation = winrt::impl::slim_source_location::current())
+    WINRT_EXPORT inline hresult check_hresult_allow_bounds(hresult const result, winrt::impl::slim_source_location const& sourceInformation = winrt::impl::slim_source_location::current())
     {
         if (result != impl::error_out_of_bounds && result != impl::error_fail && result != impl::error_file_not_found)
         {
diff --git a/strings/base_events.h b/strings/base_events.h
index 0855f4614..023935d73 100644
--- a/strings/base_events.h
+++ b/strings/base_events.h
@@ -1,7 +1,7 @@
 
-WINRT_EXPORT namespace winrt
+extern "C++" namespace winrt
 {
-    struct event_token
+    WINRT_EXPORT struct event_token
     {
         std::int64_t value{};
 
@@ -13,10 +13,10 @@ WINRT_EXPORT namespace winrt
         bool operator==(event_token const& other) const noexcept = default;
     };
 
-    struct auto_revoke_t {};
-    inline constexpr auto_revoke_t auto_revoke{};
+    WINRT_EXPORT struct auto_revoke_t {};
+    WINRT_EXPORT inline constexpr auto_revoke_t auto_revoke{};
 
-    template <typename I>
+    WINRT_EXPORT template <typename I>
     struct event_revoker
     {
         using method_type = std::int32_t(__stdcall impl::abi_t<I>::*)(winrt::event_token);
@@ -71,7 +71,7 @@ WINRT_EXPORT namespace winrt
         event_token m_token{};
     };
 
-    template <typename I>
+    WINRT_EXPORT template <typename I>
     struct factory_event_revoker
     {
         using method_type = std::int32_t(__stdcall impl::abi_t<I>::*)(winrt::event_token);
@@ -127,9 +127,9 @@ WINRT_EXPORT namespace winrt
     };
 }
 
-WINRT_EXPORT namespace winrt::impl
+extern "C++" namespace winrt::impl
 {
-    template <typename I, auto Method>
+    WINRT_EXPORT template <typename I, auto Method>
     struct event_revoker
     {
         event_revoker() noexcept = default;
@@ -190,7 +190,7 @@ WINRT_EXPORT namespace winrt::impl
         event_token m_token{};
     };
 
-    template <typename I, auto Method>
+    WINRT_EXPORT template <typename I, auto Method>
     struct factory_event_revoker
     {
         factory_event_revoker() noexcept = default;
@@ -250,13 +250,13 @@ WINRT_EXPORT namespace winrt::impl
         event_token m_token{};
     };
 
-    template <typename D, typename Revoker, typename S>
+    WINRT_EXPORT template <typename D, typename Revoker, typename S>
     Revoker make_event_revoker(S source, event_token token)
     {
         return { static_cast<D const&>(*source), token };
     }
 
-    template <typename T>
+    WINRT_EXPORT template <typename T>
     struct event_array
     {
         using value_type = T;
@@ -324,7 +324,7 @@ WINRT_EXPORT namespace winrt::impl
         std::uint32_t m_size{ 0 };
     };
 
-    template <typename T>
+    WINRT_EXPORT template <typename T>
     com_ptr<event_array<T>> make_event_array(std::uint32_t const capacity)
     {
         void* raw = ::operator new(sizeof(event_array<T>) + (sizeof(T)* capacity));
@@ -334,7 +334,7 @@ WINRT_EXPORT namespace winrt::impl
         return { new(raw) event_array<T>(capacity), take_ownership_from_abi };
     }
 
-    WINRT_IMPL_NOINLINE inline bool report_failed_invoke()
+    WINRT_EXPORT WINRT_IMPL_NOINLINE inline bool report_failed_invoke()
     {
         std::int32_t const code = to_hresult();
         WINRT_IMPL_RoTransformError(code, 0, nullptr);
@@ -349,7 +349,7 @@ WINRT_EXPORT namespace winrt::impl
         return true;
     }
 
-    template <typename Delegate, typename... Arg>
+    WINRT_EXPORT template <typename Delegate, typename... Arg>
     bool invoke(Delegate const& delegate, Arg const&... args) noexcept
     {
         try
@@ -365,9 +365,9 @@ WINRT_EXPORT namespace winrt::impl
     }
 }
 
-WINRT_EXPORT namespace winrt
+extern "C++" namespace winrt
 {
-    template <typename Delegate>
+    WINRT_EXPORT template <typename Delegate>
     struct event
     {
         using delegate_type = Delegate;
diff --git a/strings/base_extern.h b/strings/base_extern.h
index 25c25e9d2..0d6ccfb2c 100644
--- a/strings/base_extern.h
+++ b/strings/base_extern.h
@@ -1,8 +1,8 @@
 
-WINRT_EXPORT __declspec(selectany) std::int32_t(__stdcall* winrt_to_hresult_handler)(void* address) noexcept {};
-WINRT_EXPORT __declspec(selectany) winrt::hstring(__stdcall* winrt_to_message_handler)(void* address) {};
-WINRT_EXPORT __declspec(selectany) void(__stdcall* winrt_throw_hresult_handler)(std::uint32_t lineNumber, char const* fileName, char const* functionName, void* returnAddress, winrt::hresult const result) noexcept {};
-WINRT_EXPORT __declspec(selectany) std::int32_t(__stdcall* winrt_activation_handler)(void* classId, winrt::guid const& iid, void** factory) noexcept {};
+extern "C++" __declspec(selectany) std::int32_t(__stdcall* winrt_to_hresult_handler)(void* address) noexcept {};
+extern "C++" __declspec(selectany) winrt::hstring(__stdcall* winrt_to_message_handler)(void* address) {};
+extern "C++" __declspec(selectany) void(__stdcall* winrt_throw_hresult_handler)(std::uint32_t lineNumber, char const* fileName, char const* functionName, void* returnAddress, winrt::hresult const result) noexcept {};
+extern "C++" __declspec(selectany) std::int32_t(__stdcall* winrt_activation_handler)(void* classId, winrt::guid const& iid, void** factory) noexcept {};
 
 #if defined(_MSC_VER)
 #ifdef _M_HYBRID
diff --git a/strings/base_fast_forward.h b/strings/base_fast_forward.h
index a5954298c..2ec43d223 100644
--- a/strings/base_fast_forward.h
+++ b/strings/base_fast_forward.h
@@ -1,3 +1,4 @@
+
 #include <cstddef>
 #include <atomic>
 
@@ -28,7 +29,7 @@ static_assert(WINRT_FAST_ABI_SIZE >= %);
 
 #pragma detect_mismatch("WINRT_FAST_ABI_SIZE", WINRT_IMPL_STRING(WINRT_FAST_ABI_SIZE))
 
-namespace winrt::impl
+extern "C++" namespace winrt::impl
 {
     // Thunk definitions are in arch-specific assembly sources
 %
@@ -138,7 +139,7 @@ namespace winrt::impl
     static_assert(offsetof(fast_abi_forwarder, m_offset) == sizeof(fast_abi_forwarder::m_vfptr) + sizeof(fast_abi_forwarder::m_owner));
 }
 
-namespace winrt
+extern "C++" namespace winrt
 {
     template<typename TGuid>
     auto make_fast_abi_forwarder(void* owner, TGuid const& guid, std::size_t offset)
diff --git a/strings/base_foundation.h b/strings/base_foundation.h
index 52a02ecd7..d9741c3d1 100644
--- a/strings/base_foundation.h
+++ b/strings/base_foundation.h
@@ -1,7 +1,7 @@
 
-WINRT_EXPORT namespace winrt::Windows::Foundation
+extern "C++" namespace winrt::Windows::Foundation
 {
-    struct Point
+    WINRT_EXPORT struct Point
     {
         float X;
         float Y;
@@ -28,7 +28,7 @@ WINRT_EXPORT namespace winrt::Windows::Foundation
         constexpr bool operator==(Point const&) const noexcept = default;
     };
 
-    struct Size
+    WINRT_EXPORT struct Size
     {
         float Width;
         float Height;
@@ -55,7 +55,7 @@ WINRT_EXPORT namespace winrt::Windows::Foundation
         constexpr bool operator==(Size const&) const noexcept = default;
     };
 
-    struct Rect
+    WINRT_EXPORT struct Rect
     {
         float X;
         float Y;
@@ -76,7 +76,7 @@ WINRT_EXPORT namespace winrt::Windows::Foundation
     };
 }
 
-WINRT_EXPORT namespace winrt::impl
+extern "C++" namespace winrt::impl
 {
     template <> inline constexpr auto& name_v<Windows::Foundation::Point> = L"Windows.Foundation.Point";
     template <> inline constexpr auto& name_v<Windows::Foundation::Size> = L"Windows.Foundation.Size";
diff --git a/strings/base_handle.h b/strings/base_handle.h
index 7a65af7b3..9c3a983e6 100644
--- a/strings/base_handle.h
+++ b/strings/base_handle.h
@@ -1,7 +1,7 @@
 
-WINRT_EXPORT namespace winrt
+extern "C++" namespace winrt
 {
-    template <typename T>
+    WINRT_EXPORT template <typename T>
     struct handle_type
     {
         using type = typename T::type;
@@ -79,7 +79,7 @@ WINRT_EXPORT namespace winrt
         type m_value = T::invalid();
     };
 
-    struct handle_traits
+    WINRT_EXPORT struct handle_traits
     {
         using type = void*;
 
@@ -94,9 +94,9 @@ WINRT_EXPORT namespace winrt
         }
     };
 
-    using handle = handle_type<handle_traits>;
+    WINRT_EXPORT using handle = handle_type<handle_traits>;
 
-    struct file_handle_traits
+    WINRT_EXPORT struct file_handle_traits
     {
         using type = void*;
 
@@ -111,5 +111,5 @@ WINRT_EXPORT namespace winrt
         }
     };
 
-    using file_handle = handle_type<file_handle_traits>;
+    WINRT_EXPORT using file_handle = handle_type<file_handle_traits>;
 }
diff --git a/strings/base_identity.h b/strings/base_identity.h
index 8120a2fbf..48950975c 100644
--- a/strings/base_identity.h
+++ b/strings/base_identity.h
@@ -1,16 +1,16 @@
 
 WINRT_EXPORT namespace winrt
 {
-    template <typename T>
+    WINRT_EXPORT template <typename T>
     using default_interface = typename impl::default_interface<T>::type;
 
-    template <typename T>
+    WINRT_EXPORT template <typename T>
     constexpr guid const& guid_of() noexcept
     {
         return impl::guid_v<default_interface<T>>;
     }
 
-    template <typename... T>
+    WINRT_EXPORT template <typename... T>
     bool is_guid_of(guid const& id) noexcept
     {
         return ((id == guid_of<T>()) || ...);
@@ -19,31 +19,31 @@ WINRT_EXPORT namespace winrt
 
 WINRT_EXPORT namespace winrt::impl
 {
-    template <std::size_t Size, typename T, std::size_t... Index>
+    WINRT_EXPORT template <std::size_t Size, typename T, std::size_t... Index>
     constexpr std::array<T, Size> to_array(T const* value, std::index_sequence<Index...> const) noexcept
     {
         return { value[Index]... };
     }
 
-    template <typename T, std::size_t Size>
+    WINRT_EXPORT template <typename T, std::size_t Size>
     constexpr auto to_array(std::array<T, Size> const& value) noexcept
     {
         return value;
     }
 
-    template <std::size_t Size>
+    WINRT_EXPORT template <std::size_t Size>
     constexpr auto to_array(char const(&value)[Size]) noexcept
     {
         return to_array<Size - 1>(value, std::make_index_sequence<Size - 1>());
     }
 
-    template <std::size_t Size>
+    WINRT_EXPORT template <std::size_t Size>
     constexpr auto to_array(wchar_t const(&value)[Size]) noexcept
     {
         return to_array<Size - 1>(value, std::make_index_sequence<Size - 1>());
     }
 
-    template <typename T, std::size_t LeftSize, std::size_t RightSize, std::size_t... LeftIndex, std::size_t... RightIndex>
+    WINRT_EXPORT template <typename T, std::size_t LeftSize, std::size_t RightSize, std::size_t... LeftIndex, std::size_t... RightIndex>
     constexpr std::array<T, LeftSize + RightSize> concat(
         [[maybe_unused]] std::array<T, LeftSize> const& left,
         [[maybe_unused]] std::array<T, RightSize> const& right,
@@ -53,37 +53,37 @@ WINRT_EXPORT namespace winrt::impl
         return { left[LeftIndex]..., right[RightIndex]... };
     }
 
-    template <typename T, std::size_t LeftSize, std::size_t RightSize>
+    WINRT_EXPORT template <typename T, std::size_t LeftSize, std::size_t RightSize>
     constexpr auto concat(std::array<T, LeftSize> const& left, std::array<T, RightSize> const& right) noexcept
     {
         return concat(left, right, std::make_index_sequence<LeftSize>(), std::make_index_sequence<RightSize>());
     }
 
-    template <typename T, std::size_t LeftSize, std::size_t RightSize>
+    WINRT_EXPORT template <typename T, std::size_t LeftSize, std::size_t RightSize>
     constexpr auto concat(std::array<T, LeftSize> const& left, T const(&right)[RightSize]) noexcept
     {
         return concat(left, to_array(right));
     }
 
-    template <typename T, std::size_t LeftSize, std::size_t RightSize>
+    WINRT_EXPORT template <typename T, std::size_t LeftSize, std::size_t RightSize>
     constexpr auto concat(T const(&left)[LeftSize], std::array<T, RightSize> const& right) noexcept
     {
         return concat(to_array(left), right);
     }
 
-    template <typename T, std::size_t LeftSize>
+    WINRT_EXPORT template <typename T, std::size_t LeftSize>
     constexpr auto concat(std::array<T, LeftSize> const& left, T const right) noexcept
     {
         return concat(left, std::array<T, 1>{right});
     }
 
-    template <typename T, std::size_t RightSize>
+    WINRT_EXPORT template <typename T, std::size_t RightSize>
     constexpr auto concat(T const left, std::array<T, RightSize> const& right) noexcept
     {
         return concat(std::array<T, 1>{left}, right);
     }
 
-    template <typename First, typename... Rest>
+    WINRT_EXPORT template <typename First, typename... Rest>
     constexpr auto combine(First const& first, Rest const&... rest) noexcept
     {
         if constexpr (sizeof...(rest) == 0)
@@ -96,37 +96,37 @@ WINRT_EXPORT namespace winrt::impl
         }
     }
 
-    template <typename T, std::size_t LS, std::size_t RS, std::size_t... LI, std::size_t... RI>
+    WINRT_EXPORT template <typename T, std::size_t LS, std::size_t RS, std::size_t... LI, std::size_t... RI>
     constexpr std::array<T, LS + RS - 1> zconcat_base(std::array<T, LS> const& left, std::array<T, RS> const& right, std::index_sequence<LI...> const, std::index_sequence<RI...> const) noexcept
     {
         return { left[LI]..., right[RI]..., T{} };
     }
 
-    template <typename T, std::size_t LS, std::size_t RS>
+    WINRT_EXPORT template <typename T, std::size_t LS, std::size_t RS>
     constexpr auto zconcat(std::array<T, LS> const& left, std::array<T, RS> const& right) noexcept
     {
         return zconcat_base(left, right, std::make_index_sequence<LS - 1>(), std::make_index_sequence<RS - 1>());
     }
 
-    template <typename T, std::size_t S, std::size_t... I>
+    WINRT_EXPORT template <typename T, std::size_t S, std::size_t... I>
     constexpr std::array<T, S> to_zarray_base(T const(&value)[S], std::index_sequence<I...> const) noexcept
     {
         return { value[I]... };
     }
 
-    template <typename T, std::size_t S>
+    WINRT_EXPORT template <typename T, std::size_t S>
     constexpr auto to_zarray(T const(&value)[S]) noexcept
     {
         return to_zarray_base(value, std::make_index_sequence<S>());
     }
 
-    template <typename T, std::size_t S>
+    WINRT_EXPORT template <typename T, std::size_t S>
     constexpr auto to_zarray(std::array<T, S> const& value) noexcept
     {
         return value;
     }
 
-    template <typename First, typename... Rest>
+    WINRT_EXPORT template <typename First, typename... Rest>
     constexpr auto zcombine(First const& first, Rest const&... rest) noexcept
     {
         if constexpr (sizeof...(rest) == 0)
@@ -139,48 +139,48 @@ WINRT_EXPORT namespace winrt::impl
         }
     }
 
-    constexpr std::array<std::uint8_t, 4> to_array(std::uint32_t value) noexcept
+    WINRT_EXPORT constexpr std::array<std::uint8_t, 4> to_array(std::uint32_t value) noexcept
     {
         return { static_cast<std::uint8_t>(value & 0x000000ff), static_cast<std::uint8_t>((value & 0x0000ff00) >> 8), static_cast<std::uint8_t>((value & 0x00ff0000) >> 16), static_cast<std::uint8_t>((value & 0xff000000) >> 24) };
     }
 
-    constexpr std::array<std::uint8_t, 2> to_array(std::uint16_t value) noexcept
+    WINRT_EXPORT constexpr std::array<std::uint8_t, 2> to_array(std::uint16_t value) noexcept
     {
         return { static_cast<std::uint8_t>(value & 0x00ff), static_cast<std::uint8_t>((value & 0xff00) >> 8) };
     }
 
-    constexpr auto to_array(guid const& value) noexcept
+    WINRT_EXPORT constexpr auto to_array(guid const& value) noexcept
     {
         return combine(to_array(value.Data1), to_array(value.Data2), to_array(value.Data3),
             std::array<std::uint8_t, 8>{ value.Data4[0], value.Data4[1], value.Data4[2], value.Data4[3], value.Data4[4], value.Data4[5], value.Data4[6], value.Data4[7] });
     }
 
-    template <typename T>
+    WINRT_EXPORT template <typename T>
     constexpr T to_hex_digit(std::uint8_t value) noexcept
     {
         value &= 0xF;
         return value < 10 ? static_cast<T>('0') + value : static_cast<T>('a') + (value - 10);
     }
 
-    template <typename T>
+    WINRT_EXPORT template <typename T>
     constexpr std::array<T, 2> uint8_to_hex(std::uint8_t const value) noexcept
     {
         return { to_hex_digit<T>(value >> 4), to_hex_digit<T>(value & 0xF) };
     }
 
-    template <typename T>
+    WINRT_EXPORT template <typename T>
     constexpr auto uint16_to_hex(std::uint16_t value) noexcept
     {
         return combine(uint8_to_hex<T>(static_cast<std::uint8_t>(value >> 8)), uint8_to_hex<T>(value & 0xFF));
     }
 
-    template <typename T>
+    WINRT_EXPORT template <typename T>
     constexpr auto uint32_to_hex(std::uint32_t const value) noexcept
     {
         return combine(uint16_to_hex<T>(value >> 16), uint16_to_hex<T>(value & 0xFFFF));
     }
 
-    template <typename T>
+    WINRT_EXPORT template <typename T>
     constexpr auto to_array(guid const& value) noexcept
     {
         return combine
@@ -197,17 +197,17 @@ WINRT_EXPORT namespace winrt::impl
         );
     }
 
-    constexpr std::uint32_t to_guid(std::uint8_t a, std::uint8_t b, std::uint8_t c, std::uint8_t d) noexcept
+    WINRT_EXPORT constexpr std::uint32_t to_guid(std::uint8_t a, std::uint8_t b, std::uint8_t c, std::uint8_t d) noexcept
     {
         return (static_cast<std::uint32_t>(d) << 24) | (static_cast<std::uint32_t>(c) << 16) | (static_cast<std::uint32_t>(b) << 8) | static_cast<std::uint32_t>(a);
     }
 
-    constexpr std::uint16_t to_guid(std::uint8_t a, std::uint8_t b) noexcept
+    WINRT_EXPORT constexpr std::uint16_t to_guid(std::uint8_t a, std::uint8_t b) noexcept
     {
         return (static_cast<std::uint32_t>(b) << 8) | static_cast<std::uint32_t>(a);
     }
 
-    template <std::size_t Size>
+    WINRT_EXPORT template <std::size_t Size>
     constexpr guid to_guid(std::array<std::uint8_t, Size> const& arr) noexcept
     {
         return
@@ -219,17 +219,17 @@ WINRT_EXPORT namespace winrt::impl
         };
     }
 
-    constexpr std::uint32_t endian_swap(std::uint32_t value) noexcept
+    WINRT_EXPORT constexpr std::uint32_t endian_swap(std::uint32_t value) noexcept
     {
         return (value & 0xFF000000) >> 24 | (value & 0x00FF0000) >> 8 | (value & 0x0000FF00) << 8 | (value & 0x000000FF) << 24;
     }
 
-    constexpr std::uint16_t endian_swap(std::uint16_t value) noexcept
+    WINRT_EXPORT constexpr std::uint16_t endian_swap(std::uint16_t value) noexcept
     {
         return (value & 0xFF00) >> 8 | (value & 0x00FF) << 8;
     }
 
-    constexpr guid endian_swap(guid value) noexcept
+    WINRT_EXPORT constexpr guid endian_swap(guid value) noexcept
     {
         value.Data1 = endian_swap(value.Data1);
         value.Data2 = endian_swap(value.Data2);
@@ -237,40 +237,40 @@ WINRT_EXPORT namespace winrt::impl
         return value;
     }
 
-    constexpr guid set_named_guid_fields(guid value) noexcept
+    WINRT_EXPORT constexpr guid set_named_guid_fields(guid value) noexcept
     {
         value.Data3 = static_cast<std::uint16_t>((value.Data3 & 0x0fff) | (5 << 12));
         value.Data4[0] = static_cast<std::uint8_t>((value.Data4[0] & 0x3f) | 0x80);
         return value;
     }
 
-    template <typename T, std::size_t Size, std::size_t... Index>
+    WINRT_EXPORT template <typename T, std::size_t Size, std::size_t... Index>
     constexpr std::array<std::uint8_t, Size> char_to_byte_array(std::array<T, Size> const& value, std::index_sequence<Index...> const) noexcept
     {
         return { static_cast<std::uint8_t>(value[Index])... };
     }
 
-    constexpr auto sha1_rotl(std::uint8_t bits, std::uint32_t word) noexcept
+    WINRT_EXPORT constexpr auto sha1_rotl(std::uint8_t bits, std::uint32_t word) noexcept
     {
         return  (word << bits) | (word >> (32 - bits));
     }
 
-    constexpr auto sha_ch(std::uint32_t x, std::uint32_t y, std::uint32_t z) noexcept
+    WINRT_EXPORT constexpr auto sha_ch(std::uint32_t x, std::uint32_t y, std::uint32_t z) noexcept
     {
         return (x & y) ^ ((~x) & z);
     }
 
-    constexpr auto sha_parity(std::uint32_t x, std::uint32_t y, std::uint32_t z) noexcept
+    WINRT_EXPORT constexpr auto sha_parity(std::uint32_t x, std::uint32_t y, std::uint32_t z) noexcept
     {
         return x ^ y ^ z;
     }
 
-    constexpr auto sha_maj(std::uint32_t x, std::uint32_t y, std::uint32_t z) noexcept
+    WINRT_EXPORT constexpr auto sha_maj(std::uint32_t x, std::uint32_t y, std::uint32_t z) noexcept
     {
         return (x & y) ^ (x & z) ^ (y & z);
     }
 
-    constexpr std::array<std::uint32_t, 5> process_msg_block(std::uint8_t const* input, std::size_t start_pos, std::array<std::uint32_t, 5> const& intermediate_hash) noexcept
+    WINRT_EXPORT constexpr std::array<std::uint32_t, 5> process_msg_block(std::uint8_t const* input, std::size_t start_pos, std::array<std::uint32_t, 5> const& intermediate_hash) noexcept
     {
         std::uint32_t const K[4] = { 0x5A827999, 0x6ED9EBA1, 0x8F1BBCDC, 0xCA62C1D6 };
         std::array<std::uint32_t, 80> W = {};
@@ -340,13 +340,13 @@ WINRT_EXPORT namespace winrt::impl
         return { intermediate_hash[0] + A, intermediate_hash[1] + B, intermediate_hash[2] + C, intermediate_hash[3] + D, intermediate_hash[4] + E };
     }
 
-    template <std::size_t Size>
+    WINRT_EXPORT template <std::size_t Size>
     constexpr std::array<std::uint32_t, 5> process_msg_block(std::array<std::uint8_t, Size> const& input, std::size_t start_pos, std::array<std::uint32_t, 5> const& intermediate_hash) noexcept
     {
         return process_msg_block(input.data(), start_pos, intermediate_hash);
     }
 
-    constexpr std::array<std::uint8_t, 8> size_to_bytes(std::size_t size) noexcept
+    WINRT_EXPORT constexpr std::array<std::uint8_t, 8> size_to_bytes(std::size_t size) noexcept
     {
         return
         {
@@ -361,20 +361,20 @@ WINRT_EXPORT namespace winrt::impl
         };
     }
 
-    template <std::size_t Size, std::size_t RemainingSize, std::size_t... Index>
+    WINRT_EXPORT template <std::size_t Size, std::size_t RemainingSize, std::size_t... Index>
     constexpr std::array<std::uint8_t, RemainingSize + 1> make_remaining([[maybe_unused]] std::array<std::uint8_t, Size> const& input, [[maybe_unused]] std::size_t start_pos, std::index_sequence<Index...>) noexcept
     {
         return { input[Index + start_pos]..., 0x80 };
     }
 
-    template <std::size_t Size>
+    WINRT_EXPORT template <std::size_t Size>
     constexpr auto make_remaining(std::array<std::uint8_t, Size> const& input, std::size_t start_pos) noexcept
     {
         constexpr auto remaining_size = Size % 64;
         return make_remaining<Size, remaining_size>(input, start_pos, std::make_index_sequence<remaining_size>());
     }
 
-    template <std::size_t InputSize, std::size_t RemainderSize>
+    WINRT_EXPORT template <std::size_t InputSize, std::size_t RemainderSize>
     constexpr auto make_buffer(std::array<std::uint8_t, RemainderSize> const& remaining_buffer) noexcept
     {
         constexpr auto message_length = (RemainderSize + 8 <= 64) ? 64 : 64 * 2;
@@ -386,7 +386,7 @@ WINRT_EXPORT namespace winrt::impl
         return combine(remaining_buffer, padding_buffer, length_buffer);
     }
 
-    template <std::size_t Size>
+    WINRT_EXPORT template <std::size_t Size>
     constexpr std::array<std::uint32_t, 5> finalize_remaining_buffer(std::array<std::uint8_t, Size> const& input, std::array<std::uint32_t, 5> const& intermediate_hash) noexcept
     {
         if constexpr (Size == 64)
@@ -399,18 +399,18 @@ WINRT_EXPORT namespace winrt::impl
         }
     }
 
-    template <std::size_t... Index>
+    WINRT_EXPORT template <std::size_t... Index>
     constexpr std::array<std::uint8_t, 20> get_result(std::array<std::uint32_t, 5> const& intermediate_hash, std::index_sequence<Index...>) noexcept
     {
         return { static_cast<std::uint8_t>(intermediate_hash[Index >> 2] >> (8 * (3 - (Index & 0x03))))... };
     }
 
-    constexpr auto get_result(std::array<std::uint32_t, 5> const& intermediate_hash) noexcept
+    WINRT_EXPORT constexpr auto get_result(std::array<std::uint32_t, 5> const& intermediate_hash) noexcept
     {
         return get_result(intermediate_hash, std::make_index_sequence<20>{});
     }
 
-    template <std::size_t Size>
+    WINRT_EXPORT template <std::size_t Size>
     constexpr auto calculate_sha1(std::array<std::uint8_t, Size> const& input) noexcept
     {
         std::array<std::uint32_t, 5> intermediate_hash{ 0x67452301, 0xEFCDAB89, 0x98BADCFE, 0x10325476, 0xC3D2E1F0 };
@@ -426,7 +426,7 @@ WINRT_EXPORT namespace winrt::impl
         return get_result(intermediate_hash);
     }
 
-    template <std::size_t Size>
+    WINRT_EXPORT template <std::size_t Size>
     constexpr guid generate_guid(std::array<char, Size> const& value) noexcept
     {
         guid namespace_guid = { 0xd57af411, 0x737b, 0xc042,{ 0xab, 0xae, 0x87, 0x8b, 0x1e, 0x16, 0xad, 0xee } };
@@ -438,7 +438,7 @@ WINRT_EXPORT namespace winrt::impl
         return set_named_guid_fields(little_endian_guid);
     }
 
-    template <typename TArg, typename... TRest>
+    WINRT_EXPORT template <typename TArg, typename... TRest>
     struct arg_collection
     {
         constexpr static auto data{ combine(to_array(signature<TArg>::data), ";", arg_collection<TRest...>::data) };
@@ -450,7 +450,7 @@ WINRT_EXPORT namespace winrt::impl
         constexpr static auto data{ to_array(signature<TArg>::data) };
     };
 
-    template <typename T>
+    WINRT_EXPORT template <typename T>
     struct pinterface_guid
     {
 #ifdef _MSC_VER // T
@@ -459,7 +459,7 @@ WINRT_EXPORT namespace winrt::impl
         static constexpr guid value{ generate_guid(signature<T>::data) };
     };
 
-    template <typename T>
+    WINRT_EXPORT template <typename T>
 #ifdef _MSC_VER // T
 #pragma warning(suppress: 4307)
 #endif
@@ -472,7 +472,7 @@ WINRT_EXPORT namespace winrt::impl
         )
     };
 
-    constexpr std::size_t to_utf8_size(wchar_t const value) noexcept
+    WINRT_EXPORT constexpr std::size_t to_utf8_size(wchar_t const value) noexcept
     {
         if (value <= 0x7F)
         {
@@ -487,7 +487,7 @@ WINRT_EXPORT namespace winrt::impl
         return 3;
     }
 
-    constexpr std::size_t to_utf8(wchar_t const value, char* buffer) noexcept
+    WINRT_EXPORT constexpr std::size_t to_utf8(wchar_t const value, char* buffer) noexcept
     {
         if (value <= 0x7F)
         {
@@ -508,7 +508,7 @@ WINRT_EXPORT namespace winrt::impl
         return 3;
     }
 
-    template <typename T>
+    WINRT_EXPORT template <typename T>
     constexpr std::size_t to_utf8_size() noexcept
     {
         auto input = to_array(name_v<T>);
@@ -522,7 +522,7 @@ WINRT_EXPORT namespace winrt::impl
         return length;
     }
 
-    template <typename T>
+    WINRT_EXPORT template <typename T>
     constexpr auto to_utf8() noexcept
     {
         auto input = to_array(name_v<T>);
@@ -537,10 +537,10 @@ WINRT_EXPORT namespace winrt::impl
         return output;
     }
 
-    template <typename T>
+    WINRT_EXPORT template <typename T>
     constexpr guid generic_guid_v{};
 
-    template <typename T>
+    WINRT_EXPORT template <typename T>
     constexpr auto& basic_signature_v = "";
 
     template <> inline constexpr auto& basic_signature_v<bool> = "b1";
@@ -642,22 +642,22 @@ WINRT_EXPORT namespace winrt::impl
         constexpr static auto data{ combine("delegate(", to_array<char>(guid_of<T>()), ")") };
     };
 
-    template <std::size_t Size>
+    WINRT_EXPORT template <std::size_t Size>
     constexpr std::wstring_view to_wstring_view(std::array<wchar_t, Size> const& value) noexcept
     {
         return { value.data(), Size - 1 };
     }
 
-    template <std::size_t Size>
+    WINRT_EXPORT template <std::size_t Size>
     constexpr std::wstring_view to_wstring_view(wchar_t const (&value)[Size]) noexcept
     {
         return { value, Size - 1 };
     }
 }
 
-WINRT_EXPORT namespace winrt
+extern "C++" namespace winrt
 {
-    template <typename T>
+    WINRT_EXPORT template <typename T>
     constexpr auto name_of() noexcept
     {
         return impl::to_wstring_view(impl::name_v<T>);
diff --git a/strings/base_implements.h b/strings/base_implements.h
index c2c514132..4a90ae154 100644
--- a/strings/base_implements.h
+++ b/strings/base_implements.h
@@ -1,3 +1,4 @@
+
 #if defined(_MSC_VER)
 #if defined(_DEBUG) && !defined(WINRT_NO_MAKE_DETECTION)
 #pragma detect_mismatch("C++/WinRT WINRT_NO_MAKE_DETECTION", "make detection enabled (DEBUG and !WINRT_NO_MAKE_DETECTION)")
@@ -6,51 +7,51 @@
 #endif
 #endif
 
-WINRT_EXPORT namespace winrt::impl
+extern "C++" namespace winrt::impl
 {
-    struct marker
+    WINRT_EXPORT struct marker
     {
         marker() = delete;
     };
 }
 
-WINRT_EXPORT namespace winrt
+extern "C++" namespace winrt
 {
-    struct non_agile : impl::marker {};
-    struct no_weak_ref : impl::marker {};
-    struct composing : impl::marker {};
-    struct composable : impl::marker {};
-    struct no_module_lock : impl::marker {};
-    struct static_lifetime : impl::marker {};
-
-    template <typename Interface>
+    WINRT_EXPORT struct non_agile : impl::marker {};
+    WINRT_EXPORT struct no_weak_ref : impl::marker {};
+    WINRT_EXPORT struct composing : impl::marker {};
+    WINRT_EXPORT struct composable : impl::marker {};
+    WINRT_EXPORT struct no_module_lock : impl::marker {};
+    WINRT_EXPORT struct static_lifetime : impl::marker {};
+
+    WINRT_EXPORT template <typename Interface>
     struct cloaked : Interface {};
 
-    template <typename D, typename... I>
+    WINRT_EXPORT template <typename D, typename... I>
     struct implements;
 }
 
-WINRT_EXPORT namespace winrt::impl
+extern "C++" namespace winrt::impl
 {
-    template<typename...T>
+    WINRT_EXPORT template<typename...T>
     using tuple_cat_t = decltype(std::tuple_cat(std::declval<T>()...));
 
-    template <template <typename> typename Condition, typename>
+    WINRT_EXPORT template <template <typename> typename Condition, typename>
     struct tuple_if_base;
 
     template <template <typename> typename Condition, typename...T>
     struct tuple_if_base<Condition, std::tuple<T...>> { using type = tuple_cat_t<typename std::conditional<Condition<T>::value, std::tuple<T>, std::tuple<>>::type...>; };
 
-    template <template <typename> typename Condition, typename T>
+    WINRT_EXPORT template <template <typename> typename Condition, typename T>
     using tuple_if = typename tuple_if_base<Condition, T>::type;
 
-    template <typename T>
+    WINRT_EXPORT template <typename T>
     struct is_interface : std::disjunction<std::is_base_of<Windows::Foundation::IInspectable, T>, is_classic_com_interface<T>> {};
 
-    template <typename T>
+    WINRT_EXPORT template <typename T>
     struct is_marker : std::disjunction<std::is_base_of<marker, T>, std::is_void<T>> {};
 
-    template <typename T>
+    WINRT_EXPORT template <typename T>
     struct uncloak_base
     {
         using type = T;
@@ -62,10 +63,10 @@ WINRT_EXPORT namespace winrt::impl
         using type = T;
     };
 
-    template <typename T>
+    WINRT_EXPORT template <typename T>
     using uncloak = typename uncloak_base<T>::type;
 
-    template <typename I>
+    WINRT_EXPORT template <typename I>
     struct is_cloaked : std::disjunction<
         std::is_same<Windows::Foundation::IInspectable, I>,
         std::negation<std::is_base_of<Windows::Foundation::IInspectable, I>>
@@ -74,16 +75,16 @@ WINRT_EXPORT namespace winrt::impl
     template <typename I>
     struct is_cloaked<cloaked<I>> : std::true_type {};
 
-    template <typename D, typename I>
+    WINRT_EXPORT template <typename D, typename I>
     struct producer;
 
-    template <typename D, typename T>
+    WINRT_EXPORT template <typename D, typename T>
     struct producers_base;
 
-    template <typename D, typename I>
+    WINRT_EXPORT template <typename D, typename I>
     struct producer_convert;
 
-    template <typename T>
+    WINRT_EXPORT template <typename T>
     struct producer_ref : T
     {
         producer_ref(producer_ref const&) = delete;
@@ -101,13 +102,13 @@ WINRT_EXPORT namespace winrt::impl
         }
     };
 
-    template <typename T>
+    WINRT_EXPORT template <typename T>
     struct producer_vtable
     {
         void* value;
     };
 
-    template <typename D, typename I>
+    WINRT_EXPORT template <typename D, typename I>
     struct producer_convert : producer<D, typename default_interface<I>::type>
     {
 #ifdef __clang__
@@ -139,13 +140,13 @@ WINRT_EXPORT namespace winrt::impl
     template <typename D, typename...T>
     struct producers_base<D, std::tuple<T...>> : producer_convert<D, T>... {};
 
-    template <typename D, typename...T>
+    WINRT_EXPORT template <typename D, typename...T>
     using producers = producers_base<D, tuple_if<is_interface, std::tuple<uncloak<T>...>>>;
 
-    template <typename D, typename... I>
+    WINRT_EXPORT template <typename D, typename... I>
     struct root_implements;
 
-    template <typename T>
+    WINRT_EXPORT template <typename T>
     struct unwrap_implements
     {
         using type = T;
@@ -158,10 +159,10 @@ WINRT_EXPORT namespace winrt::impl
         using type = typename T::implements_type;
     };
 
-    template <typename T>
+    WINRT_EXPORT template <typename T>
     using unwrap_implements_t = typename unwrap_implements<T>::type;
 
-    template <typename...>
+    WINRT_EXPORT template <typename...>
     struct nested_implements
     {};
 
@@ -174,7 +175,7 @@ WINRT_EXPORT namespace winrt::impl
             "Duplicate nested implements found");
     };
 
-    template <typename D, typename Dummy = void, typename... I>
+    WINRT_EXPORT template <typename D, typename Dummy = void, typename... I>
     struct base_implements_impl
         : impl::identity<root_implements<D, I...>> {};
 
@@ -183,33 +184,33 @@ WINRT_EXPORT namespace winrt::impl
     struct base_implements_impl<D, void, I...>
         : nested_implements<I...> {};
 
-    template <typename D, typename... I>
+    WINRT_EXPORT template <typename D, typename... I>
     using base_implements = base_implements_impl<D, void, I...>;
 
-    template <typename T>
+    WINRT_EXPORT template <typename T>
     struct has_composable : std::false_type {};
 
     template <typename T>
         requires requires { typename T::composable; }
     struct has_composable<T> : std::true_type {};
 
-    template <typename T>
+    WINRT_EXPORT template <typename T>
     struct has_class_type : std::false_type {};
 
     template <typename T>
         requires requires { typename T::class_type; }
     struct has_class_type<T> : std::true_type {};
 
-    template <typename>
+    WINRT_EXPORT template <typename>
     struct has_static_lifetime : std::false_type {};
 
     template <typename D, typename...I>
     struct has_static_lifetime<implements<D, I...>> : std::disjunction<std::is_same<static_lifetime, I>...> {};
 
-    template <typename D>
+    WINRT_EXPORT template <typename D>
     inline constexpr bool has_static_lifetime_v = has_static_lifetime<typename D::implements_type>::value;
 
-    template <typename T>
+    WINRT_EXPORT template <typename T>
     void clear_abi(T*) noexcept
     {}
 
@@ -219,7 +220,7 @@ WINRT_EXPORT namespace winrt::impl
         *value = nullptr;
     }
 
-    template <typename T>
+    WINRT_EXPORT template <typename T>
     void zero_abi([[maybe_unused]] void* ptr, [[maybe_unused]] std::uint32_t const capacity) noexcept
     {
         if constexpr (!std::is_trivially_destructible_v<T>)
@@ -228,7 +229,7 @@ WINRT_EXPORT namespace winrt::impl
         }
     }
 
-    template <typename T>
+    WINRT_EXPORT template <typename T>
     void zero_abi([[maybe_unused]] void* ptr) noexcept
     {
         if constexpr (!std::is_trivially_destructible_v<T>)
@@ -238,42 +239,42 @@ WINRT_EXPORT namespace winrt::impl
     }
 }
 
-WINRT_EXPORT namespace winrt
+extern "C++" namespace winrt
 {
-    template <typename D, typename I>
+    WINRT_EXPORT template <typename D, typename I>
     D* get_self(I const& from) noexcept
     {
         return &static_cast<impl::produce<D, default_interface<I>>*>(get_abi(from))->shim();
     }
 
-    template <typename D, typename I>
+    WINRT_EXPORT template <typename D, typename I>
     D* get_self(com_ptr<I> const& from) noexcept
     {
         return static_cast<D*>(static_cast<impl::producer<D, I>*>(from.get()));
     }
 
-    template <typename D, typename I>
+    WINRT_EXPORT template <typename D, typename I>
     [[deprecated]] D* from_abi(I const& from) noexcept
     {
         return get_self<D>(from);
     }
 
-    template <typename I, typename D>
+    WINRT_EXPORT template <typename I, typename D>
     impl::abi_t<I>* to_abi(impl::producer<D, I> const* from) noexcept
     {
         return reinterpret_cast<impl::abi_t<I>*>(const_cast<impl::producer<D, I>*>(from));
     }
 
-    template <typename I, typename D>
+    WINRT_EXPORT template <typename I, typename D>
     impl::abi_t<I>* to_abi(impl::producer_convert<D, I> const* from) noexcept
     {
         return reinterpret_cast<impl::abi_t<I>*>(const_cast<impl::producer_convert<D, I>*>(from));
     }
 }
 
-WINRT_EXPORT namespace winrt::impl
+extern "C++" namespace winrt::impl
 {
-    template <typename...> struct interface_list;
+    WINRT_EXPORT template <typename...> struct interface_list;
 
     template <>
     struct interface_list<>
@@ -300,7 +301,7 @@ WINRT_EXPORT namespace winrt::impl
         using first_interface = First;
     };
 
-    template <typename, typename> struct interface_list_append_impl;
+    WINRT_EXPORT template <typename, typename> struct interface_list_append_impl;
 
     template <typename... T, typename... U>
     struct interface_list_append_impl<interface_list<T...>, interface_list<U...>>
@@ -308,10 +309,10 @@ WINRT_EXPORT namespace winrt::impl
         using type = interface_list<T..., U...>;
     };
 
-    template <template <typename> class, typename...>
+    WINRT_EXPORT template <template <typename> class, typename...>
     struct filter_impl;
 
-    template <template <typename> class Predicate, typename... T>
+    WINRT_EXPORT template <template <typename> class Predicate, typename... T>
     using filter = typename filter_impl<Predicate, unwrap_implements_t<T>...>::type;
 
     template <template <typename> class Predicate>
@@ -351,15 +352,15 @@ WINRT_EXPORT namespace winrt::impl
         >::type;
     };
 
-    template <typename T>
+    WINRT_EXPORT template <typename T>
     using implemented_interfaces = filter<is_interface, typename T::implements_type>;
 
-    template <typename T>
+    WINRT_EXPORT template <typename T>
     struct is_uncloaked_interface : std::conjunction<is_interface<T>, std::negation<winrt::impl::is_cloaked<T>>> {};
-    template <typename T>
+    WINRT_EXPORT template <typename T>
     using uncloaked_interfaces = filter<is_uncloaked_interface, typename T::implements_type>;
 
-    template <typename T>
+    WINRT_EXPORT template <typename T>
     struct uncloaked_iids;
 
     template <typename ... T>
@@ -371,7 +372,7 @@ WINRT_EXPORT namespace winrt::impl
         static constexpr std::array<guid, sizeof...(T)> value{ winrt::guid_of<T>() ... };
     };
 
-    template <typename T>
+    WINRT_EXPORT template <typename T>
     struct implements_default_interface
     {
         using type = typename default_interface<typename implemented_interfaces<T>::first_interface>::type;
@@ -391,7 +392,7 @@ WINRT_EXPORT namespace winrt::impl
         using type = typename implements_default_interface<T>::type;
     };
 
-    template<typename T>
+    WINRT_EXPORT template<typename T>
     struct find_iid_traits
     {
         T const* m_object;
@@ -415,13 +416,13 @@ WINRT_EXPORT namespace winrt::impl
         }
     };
 
-    template <typename T>
+    WINRT_EXPORT template <typename T>
     auto find_iid(T const* obj, guid const& iid) noexcept
     {
         return static_cast<unknown_abi*>(implemented_interfaces<T>::find(find_iid_traits<T>{ obj, iid }));
     }
 
-    template <typename I>
+    WINRT_EXPORT template <typename I>
     struct has_interface_traits
     {
         template <typename T>
@@ -442,13 +443,13 @@ WINRT_EXPORT namespace winrt::impl
         }
     };
 
-    template <typename T, typename I>
+    WINRT_EXPORT template <typename T, typename I>
     constexpr bool has_interface() noexcept
     {
         return impl::implemented_interfaces<T>::find(has_interface_traits<I>{});
     }
 
-    template<typename T>
+    WINRT_EXPORT template<typename T>
     struct find_inspectable_traits
     {
         T const* m_object;
@@ -471,7 +472,7 @@ WINRT_EXPORT namespace winrt::impl
         }
     };
 
-    template <typename T>
+    WINRT_EXPORT template <typename T>
     inspectable_abi* find_inspectable(T const* obj) noexcept
     {
         using default_interface = typename implements_default_interface<T>::type;
@@ -486,7 +487,7 @@ WINRT_EXPORT namespace winrt::impl
         }
     }
 
-    template <typename I>
+    WINRT_EXPORT template <typename I>
     struct runtime_class_name
     {
         static hstring get()
@@ -514,14 +515,14 @@ WINRT_EXPORT namespace winrt::impl
         }
     };
 
-    template <typename D, typename I>
+    WINRT_EXPORT template <typename D, typename I>
     struct producer
     {
     private:
         produce<D, I> vtable;
     };
 
-    template <typename D, typename I>
+    WINRT_EXPORT template <typename D, typename I>
     struct produce_base : abi_t<I>
     {
         D& shim() noexcept
@@ -575,7 +576,7 @@ WINRT_EXPORT namespace winrt::impl
     {
     };
 
-    struct INonDelegatingInspectable : Windows::Foundation::IUnknown
+    WINRT_EXPORT struct INonDelegatingInspectable : Windows::Foundation::IUnknown
     {
         INonDelegatingInspectable(std::nullptr_t = nullptr) noexcept {}
     };
@@ -614,13 +615,13 @@ WINRT_EXPORT namespace winrt::impl
         }
     };
 
-    template <bool Agile, bool UseModuleLock>
+    WINRT_EXPORT template <bool Agile, bool UseModuleLock>
     struct weak_ref;
 
-    template <bool Agile, bool UseModuleLock>
+    WINRT_EXPORT template <bool Agile, bool UseModuleLock>
     struct weak_source_producer;
 
-    template <bool Agile, bool UseModuleLock>
+    WINRT_EXPORT template <bool Agile, bool UseModuleLock>
     struct weak_source final : IWeakReferenceSource, module_lock_updater<UseModuleLock>
     {
         weak_ref<Agile, UseModuleLock>* that() noexcept
@@ -658,14 +659,14 @@ WINRT_EXPORT namespace winrt::impl
         }
     };
 
-    template <bool Agile, bool UseModuleLock>
+    WINRT_EXPORT template <bool Agile, bool UseModuleLock>
     struct weak_source_producer
     {
     protected:
         weak_source<Agile, UseModuleLock> m_source;
     };
 
-    template <bool Agile, bool UseModuleLock>
+    WINRT_EXPORT template <bool Agile, bool UseModuleLock>
     struct weak_ref final : IWeakReference, weak_source_producer<Agile, UseModuleLock>
     {
         weak_ref(unknown_abi* object, std::uint32_t const strong) noexcept :
@@ -780,7 +781,7 @@ WINRT_EXPORT namespace winrt::impl
         std::atomic<std::uint32_t> m_weak{ 1 };
     };
 
-    template <bool>
+    WINRT_EXPORT template <bool>
     struct WINRT_IMPL_EMPTY_BASES root_implements_composing_outer
     {
     protected:
@@ -817,7 +818,7 @@ WINRT_EXPORT namespace winrt::impl
         }
     };
 
-    template <typename D, bool>
+    WINRT_EXPORT template <typename D, bool>
     struct WINRT_IMPL_EMPTY_BASES root_implements_composable_inner
     {
     protected:
@@ -842,7 +843,7 @@ WINRT_EXPORT namespace winrt::impl
         friend struct composable_factory;
     };
 
-    template <typename D, typename... I>
+    WINRT_EXPORT template <typename D, typename... I>
     struct WINRT_IMPL_NOVTABLE root_implements
         : root_implements_composing_outer<std::disjunction_v<std::is_same<composing, I>...>>
         , root_implements_composable_inner<D, std::disjunction_v<std::is_same<composable, I>...>>
@@ -1306,7 +1307,7 @@ WINRT_EXPORT namespace winrt::impl
     template <typename T>
     using heap_implements = T;
 #else
-    template <typename T>
+    WINRT_EXPORT template <typename T>
     struct heap_implements final : T
     {
         using T::T;
@@ -1319,7 +1320,7 @@ WINRT_EXPORT namespace winrt::impl
     };
 #endif
 
-    template<typename T>
+    WINRT_EXPORT template<typename T>
     class has_initializer
     {
         template <typename U, typename = decltype(std::declval<U>().InitializeComponent())> static constexpr bool get_value(int) { return true; }
@@ -1329,7 +1330,7 @@ WINRT_EXPORT namespace winrt::impl
         static constexpr bool value = get_value<T>(0);
     };
 
-    template<typename T, typename... Args>
+    WINRT_EXPORT template<typename T, typename... Args>
     T* create_and_initialize(Args&&... args)
     {
         com_ptr<T> instance{ new heap_implements<T>(std::forward<Args>(args)...), take_ownership_from_abi };
@@ -1342,7 +1343,7 @@ WINRT_EXPORT namespace winrt::impl
         return instance.detach();
     }
 
-    inline com_ptr<IStaticLifetimeCollection> get_static_lifetime_map()
+    WINRT_EXPORT inline com_ptr<IStaticLifetimeCollection> get_static_lifetime_map()
     {
         auto const lifetime_factory = get_activation_factory<impl::IStaticLifetime>(L"Windows.ApplicationModel.Core.CoreApplication");
         Windows::Foundation::IUnknown collection;
@@ -1350,7 +1351,7 @@ WINRT_EXPORT namespace winrt::impl
         return collection.as<IStaticLifetimeCollection>();
     }
 
-    template <typename D>
+    WINRT_EXPORT template <typename D>
     auto make_factory() -> typename impl::implements_default_interface<D>::type
     {
         using result_type = typename impl::implements_default_interface<D>::type;
@@ -1390,20 +1391,20 @@ WINRT_EXPORT namespace winrt::impl
         }
     }
 
-    template <typename T>
+    WINRT_EXPORT template <typename T>
     auto detach_from(T&& object) noexcept
     {
         return detach_abi(std::forward<T>(object));
     }
 }
 
-WINRT_EXPORT namespace winrt
+extern "C++" namespace winrt
 {
 #if defined(_MSC_VER) && !defined(__clang__)
 #pragma warning(push)
 #pragma warning(disable: 4702) // Compiler bug causing spurious "unreachable code" warnings
 #endif
-    template <typename D, typename... Args>
+    WINRT_EXPORT template <typename D, typename... Args>
     auto make(Args&&... args)
     {
 #if !defined(WINRT_NO_MAKE_DETECTION)
@@ -1435,7 +1436,7 @@ WINRT_EXPORT namespace winrt
         }
     }
 
-    template <typename D, typename... Args>
+    WINRT_EXPORT template <typename D, typename... Args>
     com_ptr<D> make_self(Args&&... args)
     {
 #if !defined(WINRT_NO_MAKE_DETECTION)
@@ -1460,7 +1461,7 @@ WINRT_EXPORT namespace winrt
 #pragma warning(pop)
 #endif
 
-    template <typename... FactoryClasses>
+    WINRT_EXPORT template <typename... FactoryClasses>
     inline void clear_factory_static_lifetime()
     {
         auto unregister = [map = impl::get_static_lifetime_map()](param::hstring name)
@@ -1470,7 +1471,7 @@ WINRT_EXPORT namespace winrt
         ((unregister(name_of<typename FactoryClasses::instance_type>())), ...);
     }
 
-    template <typename D, typename... I>
+    WINRT_EXPORT template <typename D, typename... I>
     struct implements : impl::producers<D, I...>, impl::base_implements<D, I...>::type
     {
     protected:
diff --git a/strings/base_includes.h b/strings/base_includes.h
index 6f1a2df55..2f1978c67 100644
--- a/strings/base_includes.h
+++ b/strings/base_includes.h
@@ -40,13 +40,16 @@
 #include <source_location>
 #include <coroutine>
 
-// <windowsnumerics.impl.h> pulls in large, hard-to-control legacy headers. In header builds we keep the
-// existing behavior, but in module builds it's provided by the winrt.numerics module.
-#ifndef WINRT_MODULE
 #if __has_include(<windowsnumerics.impl.h>)
 #define WINRT_IMPL_NUMERICS
 #include <directxmath.h>
-#endif
+#define _WINDOWS_NUMERICS_NAMESPACE_ winrt::Windows::Foundation::Numerics
+#define _WINDOWS_NUMERICS_BEGIN_NAMESPACE_ extern "C++" namespace _WINDOWS_NUMERICS_NAMESPACE_
+#define _WINDOWS_NUMERICS_END_NAMESPACE_
+#include <windowsnumerics.impl.h>
+#undef _WINDOWS_NUMERICS_NAMESPACE_
+#undef _WINDOWS_NUMERICS_BEGIN_NAMESPACE_
+#undef _WINDOWS_NUMERICS_END_NAMESPACE_
 #endif
 
 #ifdef WINRT_ENABLE_LEGACY_COM
diff --git a/strings/base_iterator.h b/strings/base_iterator.h
index 9cc37252a..fc1e28c0e 100644
--- a/strings/base_iterator.h
+++ b/strings/base_iterator.h
@@ -1,7 +1,7 @@
 
-WINRT_EXPORT namespace winrt::impl
+extern "C++" namespace winrt::impl
 {
-    template <typename T>
+    WINRT_EXPORT template <typename T>
     struct fast_iterator
     {
         using iterator_concept = std::random_access_iterator_tag;
@@ -109,7 +109,7 @@ WINRT_EXPORT namespace winrt::impl
         std::uint32_t m_index = 0;
     };
 
-    template <typename T>
+    WINRT_EXPORT template <typename T>
     class has_GetAt
     {
         template <typename U, typename = decltype(std::declval<U>().GetAt(0))> static constexpr bool get_value(int) { return true; }
@@ -120,7 +120,7 @@ WINRT_EXPORT namespace winrt::impl
         static constexpr bool value = get_value<T>(0);
     };
 
-    template <typename T>
+    WINRT_EXPORT template <typename T>
         requires (!has_GetAt<T>::value)
     auto get_begin_iterator(T const& collection) -> decltype(collection.First())
     {
@@ -134,41 +134,41 @@ WINRT_EXPORT namespace winrt::impl
         return result;
     }
 
-    template <typename T>
+    WINRT_EXPORT template <typename T>
         requires (!has_GetAt<T>::value)
     auto get_end_iterator([[maybe_unused]] T const& collection) noexcept -> decltype(collection.First())
     {
         return {};
     }
 
-    template <typename T>
+    WINRT_EXPORT template <typename T>
         requires has_GetAt<T>::value
     fast_iterator<T> get_begin_iterator(T const& collection) noexcept
     {
         return { collection, 0 };
     }
 
-    template <typename T>
+    WINRT_EXPORT template <typename T>
         requires has_GetAt<T>::value
     fast_iterator<T> get_end_iterator(T const& collection)
     {
         return { collection, collection.Size() };
     }
 
-    template <typename T>
+    WINRT_EXPORT template <typename T>
         requires has_GetAt<T>::value
     auto rbegin(T const& collection)
     {
         return std::make_reverse_iterator(get_end_iterator(collection));
     }
 
-    template <typename T>
+    WINRT_EXPORT template <typename T>
         requires has_GetAt<T>::value
     auto rend(T const& collection)
     {
         return std::make_reverse_iterator(get_begin_iterator(collection));
     }
 
-    using std::begin;
-    using std::end;
+    WINRT_EXPORT using std::begin;
+    WINRT_EXPORT using std::end;
 }
diff --git a/strings/base_lock.h b/strings/base_lock.h
index a0d6261e4..f13c09847 100644
--- a/strings/base_lock.h
+++ b/strings/base_lock.h
@@ -1,9 +1,9 @@
 
-WINRT_EXPORT namespace winrt
+extern "C++" namespace winrt
 {
-    struct slim_condition_variable;
+    WINRT_EXPORT struct slim_condition_variable;
 
-    struct slim_mutex
+    WINRT_EXPORT struct slim_mutex
     {
         slim_mutex(slim_mutex const&) = delete;
         slim_mutex& operator=(slim_mutex const&) = delete;
@@ -50,7 +50,7 @@ WINRT_EXPORT namespace winrt
         impl::srwlock m_lock{};
     };
 
-    struct slim_lock_guard
+    WINRT_EXPORT struct slim_lock_guard
     {
         explicit slim_lock_guard(slim_mutex& m) noexcept :
         m_mutex(m)
@@ -69,7 +69,7 @@ WINRT_EXPORT namespace winrt
         slim_mutex& m_mutex;
     };
 
-    struct slim_shared_lock_guard
+    WINRT_EXPORT struct slim_shared_lock_guard
     {
         explicit slim_shared_lock_guard(slim_mutex& m) noexcept :
             m_mutex(m)
@@ -88,7 +88,7 @@ WINRT_EXPORT namespace winrt
         slim_mutex& m_mutex;
     };
 
-    struct slim_condition_variable
+    WINRT_EXPORT struct slim_condition_variable
     {
         slim_condition_variable(slim_condition_variable const&) = delete;
         slim_condition_variable const& operator=(slim_condition_variable const&) = delete;
diff --git a/strings/base_macros.h b/strings/base_macros.h
index 612e2beb9..3b86721dc 100644
--- a/strings/base_macros.h
+++ b/strings/base_macros.h
@@ -22,35 +22,20 @@
 // Note: this is a workaround for a false-positive warning produced by the Visual C++ 16.3 compiler.
 #pragma warning(disable : 4268)
 
-// C++ module warnings by /W4
+// https://developercommunity.visualstudio.com/t/11077314
 #pragma warning(disable : 4499)
+// https://developercommunity.visualstudio.com/t/11077315
 #pragma warning(disable : 4630)
 #endif
 
 #ifndef WINRT_EXPORT
 #ifdef WINRT_MODULE
-#define WINRT_EXPORT export extern "C++"
+#define WINRT_EXPORT export
 #else
 #define WINRT_EXPORT
 #endif
 #endif
 
-// <windowsnumerics.impl.h> pulls in large, hard-to-control legacy headers. In header builds we keep the
-// existing behavior, but in module builds it's provided by the winrt.numerics module.
-#if !(defined(WINRT_MODULE) || defined(WINRT_CONSUME_MODULE))
-
-#ifdef WINRT_IMPL_NUMERICS
-#define _WINDOWS_NUMERICS_NAMESPACE_ winrt::Windows::Foundation::Numerics
-#define _WINDOWS_NUMERICS_BEGIN_NAMESPACE_ WINRT_EXPORT namespace winrt::Windows::Foundation::Numerics
-#define _WINDOWS_NUMERICS_END_NAMESPACE_
-#include <windowsnumerics.impl.h>
-#undef _WINDOWS_NUMERICS_NAMESPACE_
-#undef _WINDOWS_NUMERICS_BEGIN_NAMESPACE_
-#undef _WINDOWS_NUMERICS_END_NAMESPACE_
-#endif
-
-#endif
-
 #if defined(_MSC_VER)
 #define WINRT_IMPL_NOINLINE __declspec(noinline)
 #elif defined(__GNUC__)
diff --git a/strings/base_marshaler.h b/strings/base_marshaler.h
index 9be6959c9..2f1c81781 100644
--- a/strings/base_marshaler.h
+++ b/strings/base_marshaler.h
@@ -1,7 +1,7 @@
 
-WINRT_EXPORT namespace winrt::impl
+extern "C++" namespace winrt::impl
 {
-    inline std::int32_t make_marshaler(unknown_abi* outer, void** result) noexcept
+    WINRT_EXPORT inline std::int32_t make_marshaler(unknown_abi* outer, void** result) noexcept
     {
         struct marshaler final : IMarshal
         {
diff --git a/strings/base_meta.h b/strings/base_meta.h
index fea443041..3a3c5a322 100644
--- a/strings/base_meta.h
+++ b/strings/base_meta.h
@@ -1,67 +1,67 @@
 
-WINRT_EXPORT namespace winrt
+extern "C++" namespace winrt
 {
-    hresult check_hresult(hresult const result, winrt::impl::slim_source_location const& sourceInformation = winrt::impl::slim_source_location::current());
-    hresult to_hresult() noexcept;
+    WINRT_EXPORT hresult check_hresult(hresult const result, winrt::impl::slim_source_location const& sourceInformation = winrt::impl::slim_source_location::current());
+    WINRT_EXPORT hresult to_hresult() noexcept;
 
-    template <typename D, typename I>
+    WINRT_EXPORT template <typename D, typename I>
     D* get_self(I const& from) noexcept;
 
-    struct take_ownership_from_abi_t {};
-    inline constexpr take_ownership_from_abi_t take_ownership_from_abi{};
+    WINRT_EXPORT struct take_ownership_from_abi_t {};
+    WINRT_EXPORT inline constexpr take_ownership_from_abi_t take_ownership_from_abi{};
 
     // Map implementations can implement TryLookup with trylookup_from_abi_t as an optimization
-    struct trylookup_from_abi_t {};
-    inline constexpr trylookup_from_abi_t trylookup_from_abi{};
+    WINRT_EXPORT struct trylookup_from_abi_t {};
+    WINRT_EXPORT inline constexpr trylookup_from_abi_t trylookup_from_abi{};
 
-    template <typename T>
+    WINRT_EXPORT template <typename T>
     struct com_ptr;
 
-    template <typename D, typename I>
+    WINRT_EXPORT template <typename D, typename I>
     D* get_self(com_ptr<I> const& from) noexcept;
 
     namespace param
     {
-        template <typename T>
+        WINRT_EXPORT template <typename T>
         struct iterable;
 
-        template <typename T>
+        WINRT_EXPORT template <typename T>
         struct async_iterable;
 
-        template <typename K, typename V>
+        WINRT_EXPORT template <typename K, typename V>
         struct map_view;
 
-        template <typename K, typename V>
+        WINRT_EXPORT template <typename K, typename V>
         struct async_map_view;
 
-        template <typename K, typename V>
+        WINRT_EXPORT template <typename K, typename V>
         struct map;
 
-        template <typename T>
+        WINRT_EXPORT template <typename T>
         struct vector_view;
 
-        template <typename T>
+        WINRT_EXPORT template <typename T>
         struct async_vector_view;
 
-        template <typename T>
+        WINRT_EXPORT template <typename T>
         struct vector;
     }
 }
 
-WINRT_EXPORT namespace winrt::impl
+extern "C++" namespace winrt::impl
 {
     using namespace std::literals;
 
-    template <typename T>
+    WINRT_EXPORT template <typename T>
     struct reference_traits;
 
-    template <typename T>
+    WINRT_EXPORT template <typename T>
     struct identity
     {
         using type = T;
     };
 
-    template <typename T>
+    WINRT_EXPORT template <typename T>
     struct abi
     {
         using type = T;
@@ -74,64 +74,64 @@ WINRT_EXPORT namespace winrt::impl
         using type = std::underlying_type_t<T>;
     };
 
-    template <typename T>
+    WINRT_EXPORT template <typename T>
     using abi_t = typename abi<T>::type;
 
-    template <typename T>
+    WINRT_EXPORT template <typename T>
     auto abi_t_abi_cast(T const& value) noexcept
     {
         return reinterpret_cast<abi_t<T>**>(const_cast<T*>(&value));
     }
 
-    template <typename T>
+    WINRT_EXPORT template <typename T>
     struct consume;
 
-    template <typename D, typename I = D>
+    WINRT_EXPORT template <typename D, typename I = D>
     using consume_t = typename consume<I>::template type<D>;
 
-    template <typename T, typename H>
+    WINRT_EXPORT template <typename T, typename H>
     struct delegate;
 
-    template <typename T>
+    WINRT_EXPORT template <typename T>
     struct default_interface
     {
         using type = T;
     };
 
-    struct basic_category;
-    struct interface_category;
-    struct delegate_category;
-    struct enum_category;
-    struct class_category;
+    WINRT_EXPORT struct basic_category;
+    WINRT_EXPORT struct interface_category;
+    WINRT_EXPORT struct delegate_category;
+    WINRT_EXPORT struct enum_category;
+    WINRT_EXPORT struct class_category;
 
-    template <typename T>
+    WINRT_EXPORT template <typename T>
     struct category
     {
         using type = void;
     };
 
-    template <typename T>
+    WINRT_EXPORT template <typename T>
     using category_t = typename category<T>::type;
 
-    template <typename T>
+    WINRT_EXPORT template <typename T>
     inline constexpr bool has_category_v = !std::is_same_v<category_t<T>, void>;
 
-    template <typename... Args>
+    WINRT_EXPORT template <typename... Args>
     struct generic_category;
 
-    template <typename... Fields>
+    WINRT_EXPORT template <typename... Fields>
     struct struct_category;
 
-    template <typename Category, typename T>
+    WINRT_EXPORT template <typename Category, typename T>
     struct category_signature;
 
-    template <typename T>
+    WINRT_EXPORT template <typename T>
     struct signature
     {
         static constexpr auto data{ category_signature<category_t<T>, T>::data };
     };
 
-    template <typename T>
+    WINRT_EXPORT template <typename T>
     struct classic_com_guid_error
     {
 #if !defined(__MINGW32__) && defined(__clang__) && !WINRT_IMPL_HAS_DECLSPEC_UUID
@@ -143,30 +143,30 @@ WINRT_EXPORT namespace winrt::impl
 #endif
     };
 
-    template <typename T>
+    WINRT_EXPORT template <typename T>
 #if (defined(_MSC_VER) && !defined(__clang__)) || ((WINRT_IMPL_HAS_DECLSPEC_UUID || defined(__MINGW32__)) && defined(WINRT_IMPL_IUNKNOWN_DEFINED))
     inline constexpr guid guid_v{ __uuidof(T) };
 #else
     inline constexpr guid guid_v = classic_com_guid_error<T>::value;
 #endif
 
-    template <typename T>
+    WINRT_EXPORT template <typename T>
     constexpr auto to_underlying_type(T const value) noexcept
     {
         return static_cast<std::underlying_type_t<T>>(value);
     }
 
-    template <typename T>
+    WINRT_EXPORT template <typename T>
     struct is_implements : std::false_type {};
 
     template <typename T>
         requires requires { typename T::implements_type; }
     struct is_implements<T> : std::true_type {};
 
-    template <typename T>
+    WINRT_EXPORT template <typename T>
     inline constexpr bool is_implements_v = is_implements<T>::value;
 
-    template <typename D, typename I>
+    WINRT_EXPORT template <typename D, typename I>
     struct require_one : consume_t<D, I>
     {
         operator I() const noexcept
@@ -175,11 +175,11 @@ WINRT_EXPORT namespace winrt::impl
         }
     };
 
-    template <typename D, typename... I>
+    WINRT_EXPORT template <typename D, typename... I>
     struct WINRT_IMPL_EMPTY_BASES require : require_one<D, I>...
     {};
 
-    template <typename D, typename I>
+    WINRT_EXPORT template <typename D, typename I>
     struct base_one
     {
         operator I() const noexcept
@@ -188,11 +188,11 @@ WINRT_EXPORT namespace winrt::impl
         }
     };
 
-    template <typename D, typename... I>
+    WINRT_EXPORT template <typename D, typename... I>
     struct WINRT_IMPL_EMPTY_BASES base : base_one<D, I>...
     {};
 
-    template <typename T>
+    WINRT_EXPORT template <typename T>
     T empty_value() noexcept
     {
         if constexpr (std::is_base_of_v<Windows::Foundation::IUnknown, T>)
@@ -205,7 +205,7 @@ WINRT_EXPORT namespace winrt::impl
         }
     }
 
-    template<typename T, auto empty_value = T{}>
+    WINRT_EXPORT template<typename T, auto empty_value = T{}>
     struct movable_primitive
     {
         T value = empty_value;
@@ -224,7 +224,7 @@ WINRT_EXPORT namespace winrt::impl
         T detach() { return std::exchange(value, empty_value); }
     };
 
-    template <typename T>
+    WINRT_EXPORT template <typename T>
     struct arg
     {
         using in = abi_t<T>;
@@ -237,16 +237,16 @@ WINRT_EXPORT namespace winrt::impl
         using in = void*;
     };
 
-    template <typename T>
+    WINRT_EXPORT template <typename T>
     using arg_in = typename arg<T>::in;
 
-    template <typename T>
+    WINRT_EXPORT template <typename T>
     using arg_out = arg_in<T>*;
 
-    template <typename D, typename I>
+    WINRT_EXPORT template <typename D, typename I>
     struct produce_base;
 
-    template <typename D, typename I>
+    WINRT_EXPORT template <typename D, typename I>
     struct produce;
 
     template <typename D>
@@ -254,7 +254,7 @@ WINRT_EXPORT namespace winrt::impl
     {
     };
 
-    template <typename T>
+    WINRT_EXPORT template <typename T>
     struct wrapped_type
     {
         using type = T;
@@ -266,13 +266,13 @@ WINRT_EXPORT namespace winrt::impl
         using type = T;
     };
 
-    template <typename T>
+    WINRT_EXPORT template <typename T>
     using wrapped_type_t = typename wrapped_type<T>::type;
 
-    template <typename ... Types>
+    WINRT_EXPORT template <typename ... Types>
     struct typelist {};
 
-    template <typename ... Lists>
+    WINRT_EXPORT template <typename ... Lists>
     struct typelist_concat;
 
     template <>
@@ -286,7 +286,7 @@ WINRT_EXPORT namespace winrt::impl
         : typelist_concat<winrt::impl::typelist<List1..., List2...>, Rest...>
     {};
 
-    template <typename T>
+    WINRT_EXPORT template <typename T>
     struct for_each;
 
     template <typename ... Types>
@@ -299,7 +299,7 @@ WINRT_EXPORT namespace winrt::impl
         }
     };
 
-    template <typename T>
+    WINRT_EXPORT template <typename T>
     struct find_if;
 
     template <typename ... Types>
@@ -312,7 +312,7 @@ WINRT_EXPORT namespace winrt::impl
         }
     };
 
-    template <typename D, typename K>
+    WINRT_EXPORT template <typename D, typename K>
     struct has_TryLookup
     {
         template <typename U, typename = decltype(std::declval<U>().TryLookup(std::declval<K>(), trylookup_from_abi))> static constexpr bool get_value(int) { return true; }
@@ -321,6 +321,6 @@ WINRT_EXPORT namespace winrt::impl
         static constexpr bool value = get_value<D>(0);
     };
 
-    template <typename D, typename K>
+    WINRT_EXPORT template <typename D, typename K>
     inline constexpr bool has_TryLookup_v = has_TryLookup<D, K>::value;
 }
diff --git a/strings/base_natvis.h b/strings/base_natvis.h
index 8ae69b2d6..8422842df 100644
--- a/strings/base_natvis.h
+++ b/strings/base_natvis.h
@@ -5,9 +5,9 @@
 
 #ifdef WINRT_NATVIS
 
-WINRT_EXPORT namespace winrt::impl
+extern "C++" namespace winrt::impl
 {
-    struct natvis
+    WINRT_EXPORT struct natvis
     {
         static auto __stdcall abi_val(void* object, wchar_t const * iid_str, int method)
         {
diff --git a/strings/base_reference_produce.h b/strings/base_reference_produce.h
index d13262449..e5239d96e 100644
--- a/strings/base_reference_produce.h
+++ b/strings/base_reference_produce.h
@@ -1,7 +1,7 @@
 
-WINRT_EXPORT namespace winrt::impl
+extern "C++" namespace winrt::impl
 {
-    template <typename T>
+    WINRT_EXPORT template <typename T>
     struct reference : implements<reference<T>, Windows::Foundation::IReference<T>, Windows::Foundation::IPropertyValue>
     {
         reference(T const& value) : m_value(value)
@@ -107,7 +107,7 @@ WINRT_EXPORT namespace winrt::impl
         T m_value;
     };
 
-    template <typename T>
+    WINRT_EXPORT template <typename T>
     struct reference_traits
     {
         static auto make(T const& value) { return winrt::make<impl::reference<T>>(value); }
@@ -395,9 +395,9 @@ WINRT_EXPORT namespace winrt::impl
     };
 }
 
-WINRT_EXPORT namespace winrt::Windows::Foundation
+extern "C++" namespace winrt::Windows::Foundation
 {
-    template <typename T>
+    WINRT_EXPORT template <typename T>
     bool operator==(IReference<T> const& left, IReference<T> const& right)
     {
         if (get_abi(left) == get_abi(right))
@@ -414,9 +414,9 @@ WINRT_EXPORT namespace winrt::Windows::Foundation
     }
 }
 
-WINRT_EXPORT namespace winrt::impl
+extern "C++" namespace winrt::impl
 {
-    template <typename T, typename From>
+    WINRT_EXPORT template <typename T, typename From>
     T unbox_value_type(From&& value)
     {
         if (!value)
@@ -446,7 +446,7 @@ WINRT_EXPORT namespace winrt::impl
         }
     }
 
-    template <typename T, typename Ret = T, typename From, typename U>
+    WINRT_EXPORT template <typename T, typename Ret = T, typename From, typename U>
     Ret unbox_value_type_or(From&& value, U&& default_value)
     {
         if constexpr (std::is_enum_v<T>)
@@ -480,7 +480,7 @@ WINRT_EXPORT namespace winrt::impl
         return default_value;
     }
 
-    template <typename To, typename From>
+    WINRT_EXPORT template <typename To, typename From>
         requires (!is_com_interface_v<To>)
     auto as(From* ptr)
     {
@@ -494,7 +494,7 @@ WINRT_EXPORT namespace winrt::impl
         }
     }
 
-    template <typename To, typename From>
+    WINRT_EXPORT template <typename To, typename From>
         requires (!is_com_interface_v<To>)
     auto try_as(From* ptr) noexcept
     {
@@ -503,14 +503,14 @@ WINRT_EXPORT namespace winrt::impl
     }
 }
 
-WINRT_EXPORT namespace winrt
+extern "C++" namespace winrt
 {
-    inline Windows::Foundation::IInspectable box_value(param::hstring const& value)
+    WINRT_EXPORT inline Windows::Foundation::IInspectable box_value(param::hstring const& value)
     {
         return Windows::Foundation::IReference<hstring>(*reinterpret_cast<hstring const*>(&value));
     }
 
-    template <typename T>
+    WINRT_EXPORT template <typename T>
         requires (!std::is_convertible_v<T, param::hstring>)
     Windows::Foundation::IInspectable box_value(T const& value)
     {
@@ -524,7 +524,7 @@ WINRT_EXPORT namespace winrt
         }
     }
 
-    template <typename T>
+    WINRT_EXPORT template <typename T>
     T unbox_value(Windows::Foundation::IInspectable const& value)
     {
         if constexpr (std::is_base_of_v<Windows::Foundation::IInspectable, T>)
@@ -537,7 +537,7 @@ WINRT_EXPORT namespace winrt
         }
     }
 
-    template <typename T = hstring>
+    WINRT_EXPORT template <typename T = hstring>
         requires std::same_as<T, hstring>
     hstring unbox_value_or(Windows::Foundation::IInspectable const& value, param::hstring const& default_value)
     {
@@ -552,7 +552,7 @@ WINRT_EXPORT namespace winrt
         return *reinterpret_cast<hstring const*>(&default_value);
     }
 
-    template <typename T>
+    WINRT_EXPORT template <typename T>
         requires (!std::is_same_v<T, hstring>)
     T unbox_value_or(Windows::Foundation::IInspectable const& value, T const& default_value)
     {
@@ -573,6 +573,6 @@ WINRT_EXPORT namespace winrt
         return default_value;
     }
 
-    template <typename T>
+    WINRT_EXPORT template <typename T>
     using optional = typename impl::reference_traits<T>::itf;
 }
diff --git a/strings/base_reference_produce_1.h b/strings/base_reference_produce_1.h
index db857446e..77fb39db9 100644
--- a/strings/base_reference_produce_1.h
+++ b/strings/base_reference_produce_1.h
@@ -1,6 +1,6 @@
 
-WINRT_EXPORT namespace winrt::Windows::Foundation
+extern "C++" namespace winrt::Windows::Foundation
 {
-    template <typename T>
+    WINRT_EXPORT template <typename T>
     bool operator==(IReference<T> const& left, IReference<T> const& right);
 }
diff --git a/strings/base_security.h b/strings/base_security.h
index a912487e4..399409f82 100644
--- a/strings/base_security.h
+++ b/strings/base_security.h
@@ -1,7 +1,7 @@
 
-WINRT_EXPORT namespace winrt
+extern "C++" namespace winrt
 {
-    struct access_token : handle
+    WINRT_EXPORT struct access_token : handle
     {
         static access_token process()
         {
diff --git a/strings/base_source_location.h b/strings/base_source_location.h
index 58c93efd2..e615d2cdd 100644
--- a/strings/base_source_location.h
+++ b/strings/base_source_location.h
@@ -1,3 +1,4 @@
+
 // The intrinsics (such as __builtin_FILE()) that power std::source_location are also used to power winrt:impl::slim_source_location.
 // The source location needs to be for the calling code, not cppwinrt itself, so that it is useful to developers building on top of
 // this library.  As a result any public-facing method that can result in an error needs a default-constructed slim_source_location
@@ -43,12 +44,12 @@
 #define WINRT_IMPL_BUILTIN_FUNCTION nullptr
 #endif
 
-WINRT_EXPORT namespace winrt::impl
+extern "C++" namespace winrt::impl
 {
     // This struct is intended to be highly similar to std::source_location.  The key difference is
     // that function_name is NOT included.  Function names do not fold to identical strings and can
     // have heavy binary size overhead when templates cause many permutations to exist.
-    struct slim_source_location
+    WINRT_EXPORT struct slim_source_location
     {
         [[nodiscard]] static WINRT_IMPL_CONSTEVAL slim_source_location current(
             const std::uint_least32_t line = WINRT_IMPL_BUILTIN_LINE,
diff --git a/strings/base_std_hash.h b/strings/base_std_hash.h
index 42ff52e59..b56409725 100644
--- a/strings/base_std_hash.h
+++ b/strings/base_std_hash.h
@@ -1,7 +1,7 @@
 
-WINRT_EXPORT namespace winrt::impl
+extern "C++" namespace winrt::impl
 {
-    inline std::size_t hash_data(void const* ptr, std::size_t const bytes) noexcept
+    WINRT_EXPORT inline std::size_t hash_data(void const* ptr, std::size_t const bytes) noexcept
     {
 #ifdef _WIN64
         constexpr std::size_t fnv_offset_basis = 14695981039346656037ULL;
@@ -22,7 +22,7 @@ WINRT_EXPORT namespace winrt::impl
         return result;
     }
 
-    struct hash_base
+    WINRT_EXPORT struct hash_base
     {
         std::size_t operator()(Windows::Foundation::IUnknown const& value) const noexcept
         {
@@ -32,7 +32,7 @@ WINRT_EXPORT namespace winrt::impl
     };
 }
 
-namespace std
+extern "C++" namespace std
 {
     template<> struct hash<winrt::hstring>
     {
diff --git a/strings/base_string.h b/strings/base_string.h
index e2c01b9b5..fce257b72 100644
--- a/strings/base_string.h
+++ b/strings/base_string.h
@@ -1,7 +1,7 @@
 
-WINRT_EXPORT namespace winrt::impl
+extern "C++" namespace winrt::impl
 {
-    struct atomic_ref_count
+    WINRT_EXPORT struct atomic_ref_count
     {
         atomic_ref_count() noexcept = default;
 
@@ -45,9 +45,9 @@ WINRT_EXPORT namespace winrt::impl
         std::atomic<std::int32_t> m_count;
     };
 
-    constexpr std::uint32_t hstring_reference_flag{ 1 };
+    inline constexpr std::uint32_t hstring_reference_flag{ 1 };
 
-    struct hstring_header
+    WINRT_EXPORT struct hstring_header
     {
         std::uint32_t flags;
         std::uint32_t length;
@@ -56,13 +56,13 @@ WINRT_EXPORT namespace winrt::impl
         wchar_t const* ptr;
     };
 
-    struct shared_hstring_header : hstring_header
+    WINRT_EXPORT struct shared_hstring_header : hstring_header
     {
         atomic_ref_count count;
         wchar_t buffer[1];
     };
 
-    inline void release_hstring(hstring_header* handle) noexcept
+    WINRT_EXPORT inline void release_hstring(hstring_header* handle) noexcept
     {
         WINRT_ASSERT((handle->flags & hstring_reference_flag) == 0);
 
@@ -72,7 +72,7 @@ WINRT_EXPORT namespace winrt::impl
         }
     }
 
-    inline shared_hstring_header* precreate_hstring_on_heap(std::uint32_t length)
+    WINRT_EXPORT inline shared_hstring_header* precreate_hstring_on_heap(std::uint32_t length)
     {
         WINRT_ASSERT(length != 0);
         std::uint64_t bytes_required = static_cast<std::uint64_t>(sizeof(shared_hstring_header)) + static_cast<std::uint64_t>(sizeof(wchar_t)) * static_cast<std::uint64_t>(length);
@@ -97,7 +97,7 @@ WINRT_EXPORT namespace winrt::impl
         return header;
     }
 
-    inline hstring_header* create_hstring_on_heap(wchar_t const* value, std::uint32_t length)
+    WINRT_EXPORT inline hstring_header* create_hstring_on_heap(wchar_t const* value, std::uint32_t length)
     {
         if (!length)
         {
@@ -109,7 +109,7 @@ WINRT_EXPORT namespace winrt::impl
         return header;
     }
 
-    inline void create_hstring_on_stack(hstring_header& header, wchar_t const* value, std::uint32_t length) noexcept
+    WINRT_EXPORT inline void create_hstring_on_stack(hstring_header& header, wchar_t const* value, std::uint32_t length) noexcept
     {
         WINRT_ASSERT(value);
         WINRT_ASSERT(length != 0);
@@ -124,7 +124,7 @@ WINRT_EXPORT namespace winrt::impl
         header.ptr = value;
     }
 
-    inline hstring_header* duplicate_hstring(hstring_header* handle)
+    WINRT_EXPORT inline hstring_header* duplicate_hstring(hstring_header* handle)
     {
         if (!handle)
         {
@@ -141,7 +141,7 @@ WINRT_EXPORT namespace winrt::impl
         }
     }
 
-    struct hstring_traits
+    WINRT_EXPORT struct hstring_traits
     {
         using type = hstring_header*;
 
@@ -157,9 +157,9 @@ WINRT_EXPORT namespace winrt::impl
     };
 }
 
-WINRT_EXPORT namespace winrt
+extern "C++" namespace winrt
 {
-    struct hstring
+    WINRT_EXPORT struct hstring
     {
         using value_type = wchar_t;
         using size_type = std::uint32_t;
@@ -418,52 +418,52 @@ WINRT_EXPORT namespace winrt
         handle_type<impl::hstring_traits> m_handle;
     };
 
-    inline void* get_abi(hstring const& object) noexcept
+    WINRT_EXPORT inline void* get_abi(hstring const& object) noexcept
     {
         return *impl::abi_cast(object);
     }
 
-    inline void** put_abi(hstring& object) noexcept
+    WINRT_EXPORT inline void** put_abi(hstring& object) noexcept
     {
         object.clear();
         return impl::abi_cast(object);
     }
 
-    inline void attach_abi(hstring& object, void* value) noexcept
+    WINRT_EXPORT inline void attach_abi(hstring& object, void* value) noexcept
     {
         object.clear();
         *put_abi(object) = value;
     }
 
-    inline void* detach_abi(hstring& object) noexcept
+    WINRT_EXPORT inline void* detach_abi(hstring& object) noexcept
     {
         void* temp = get_abi(object);
         *impl::abi_cast(object) = nullptr;
         return temp;
     }
 
-    inline void* detach_abi(hstring&& object) noexcept
+    WINRT_EXPORT inline void* detach_abi(hstring&& object) noexcept
     {
         return detach_abi(object);
     }
 
-    inline void copy_from_abi(hstring& object, void* value)
+    WINRT_EXPORT inline void copy_from_abi(hstring& object, void* value)
     {
         attach_abi(object, impl::duplicate_hstring(static_cast<impl::hstring_header*>(value)));
     }
 
-    inline void copy_to_abi(hstring const& object, void*& value)
+    WINRT_EXPORT inline void copy_to_abi(hstring const& object, void*& value)
     {
         WINRT_ASSERT(value == nullptr);
         value = impl::duplicate_hstring(static_cast<impl::hstring_header*>(get_abi(object)));
     }
 
-    inline void* detach_abi(std::wstring_view const& value)
+    WINRT_EXPORT inline void* detach_abi(std::wstring_view const& value)
     {
         return impl::create_hstring_on_heap(value.data(), static_cast<std::uint32_t>(value.size()));
     }
 
-    inline void* detach_abi(wchar_t const* const value)
+    WINRT_EXPORT inline void* detach_abi(wchar_t const* const value)
     {
         return impl::create_hstring_on_heap(value, static_cast<std::uint32_t>(std::wcslen(value)));
     }
@@ -472,7 +472,7 @@ WINRT_EXPORT namespace winrt
 template<>
 struct std::formatter<winrt::hstring, wchar_t> : std::formatter<std::wstring_view, wchar_t> {};
 
-WINRT_EXPORT namespace winrt::impl
+extern "C++" namespace winrt::impl
 {
     template <> struct abi<hstring>
     {
@@ -484,7 +484,7 @@ WINRT_EXPORT namespace winrt::impl
         using type = basic_category;
     };
 
-    struct hstring_builder
+    WINRT_EXPORT struct hstring_builder
     {
         hstring_builder(hstring_builder const&) = delete;
         hstring_builder& operator=(hstring_builder const&) = delete;
@@ -509,7 +509,7 @@ WINRT_EXPORT namespace winrt::impl
         handle_type<impl::hstring_traits> m_handle;
     };
 
-    template <typename T>
+    WINRT_EXPORT template <typename T>
     struct bind_in
     {
         bind_in(T const& object) noexcept : object(object)
@@ -537,7 +537,7 @@ WINRT_EXPORT namespace winrt::impl
 #endif
     };
 
-    template <typename T>
+    WINRT_EXPORT template <typename T>
     struct bind_out
     {
         bind_out(T& object) noexcept : object(object)
@@ -572,7 +572,7 @@ WINRT_EXPORT namespace winrt::impl
         }
     };
 
-    template <typename T>
+    WINRT_EXPORT template <typename T>
     inline hstring hstring_convert(T value)
     {
         static_assert(std::is_arithmetic_v<T>);
@@ -594,7 +594,7 @@ WINRT_EXPORT namespace winrt::impl
     }
 
 #if __cpp_lib_format >= 202207L
-    template <typename... Args>
+    WINRT_EXPORT template <typename... Args>
     inline hstring base_format(Args&&... args)
     {
         // don't forward because an object could be moved-from, causing issues
@@ -614,23 +614,23 @@ WINRT_EXPORT namespace winrt::impl
 #endif
 }
 
-WINRT_EXPORT namespace winrt
+extern "C++" namespace winrt
 {
 #if __cpp_lib_format >= 202207L
-    template <typename... Args>
+    WINRT_EXPORT template <typename... Args>
     inline hstring format(std::wformat_string<Args&...> const fmt, Args&&... args)
     {
         return impl::base_format(fmt, args...);
     }
 
-    template <typename... Args>
+    WINRT_EXPORT template <typename... Args>
     inline hstring format(std::locale const& loc, std::wformat_string<Args&...> const fmt, Args&&... args)
     {
         return impl::base_format(loc, fmt, args...);
     }
 #endif
 
-    inline bool embedded_null(hstring const& value) noexcept
+    WINRT_EXPORT inline bool embedded_null(hstring const& value) noexcept
     {
         return std::any_of(value.begin(), value.end(), [](auto item)
             {
@@ -638,70 +638,70 @@ WINRT_EXPORT namespace winrt
             });
     }
 
-    inline hstring to_hstring(std::uint8_t value)
+    WINRT_EXPORT inline hstring to_hstring(std::uint8_t value)
     {
         return impl::hstring_convert(value);
     }
 
-    inline hstring to_hstring(std::int8_t value)
+    WINRT_EXPORT inline hstring to_hstring(std::int8_t value)
     {
         return impl::hstring_convert(value);
     }
 
-    inline hstring to_hstring(std::uint16_t value)
+    WINRT_EXPORT inline hstring to_hstring(std::uint16_t value)
     {
         return impl::hstring_convert(value);
     }
 
-    inline hstring to_hstring(std::int16_t value)
+    WINRT_EXPORT inline hstring to_hstring(std::int16_t value)
     {
         return impl::hstring_convert(value);
     }
 
-    inline hstring to_hstring(std::uint32_t value)
+    WINRT_EXPORT inline hstring to_hstring(std::uint32_t value)
     {
         return impl::hstring_convert(value);
     }
 
-    inline hstring to_hstring(std::int32_t value)
+    WINRT_EXPORT inline hstring to_hstring(std::int32_t value)
     {
         return impl::hstring_convert(value);
     }
 
-    inline hstring to_hstring(std::uint64_t value)
+    WINRT_EXPORT inline hstring to_hstring(std::uint64_t value)
     {
         return impl::hstring_convert(value);
     }
 
-    inline hstring to_hstring(std::int64_t value)
+    WINRT_EXPORT inline hstring to_hstring(std::int64_t value)
     {
         return impl::hstring_convert(value);
     }
 
 #if !defined(_LIBCPP_VERSION) || _LIBCPP_VERSION >= 14000
-    inline hstring to_hstring(float value)
+    WINRT_EXPORT inline hstring to_hstring(float value)
     {
         return impl::hstring_convert(value);
     }
 
-    inline hstring to_hstring(double value)
+    WINRT_EXPORT inline hstring to_hstring(double value)
     {
         return impl::hstring_convert(value);
     }
 #endif
 
-    inline hstring to_hstring(char16_t value)
+    WINRT_EXPORT inline hstring to_hstring(char16_t value)
     {
         wchar_t buffer[2] = { value, 0 };
         return hstring{ std::wstring_view{ buffer, 1 } };
     }
 
-    inline hstring to_hstring(hstring const& value) noexcept
+    WINRT_EXPORT inline hstring to_hstring(hstring const& value) noexcept
     {
         return value;
     }
 
-    template <typename T>
+    WINRT_EXPORT template <typename T>
         requires std::same_as<T, bool>
     hstring to_hstring(T const value)
     {
@@ -715,7 +715,7 @@ WINRT_EXPORT namespace winrt
         }
     }
 
-    inline hstring to_hstring(guid const& value)
+    WINRT_EXPORT inline hstring to_hstring(guid const& value)
     {
         wchar_t buffer[40];
         //{00000000-0000-0000-0000-000000000000}
@@ -725,7 +725,7 @@ WINRT_EXPORT namespace winrt
         return hstring{ buffer };
     }
 
-    template <typename T>
+    WINRT_EXPORT template <typename T>
         requires std::convertible_to<T, std::string_view>
     hstring to_hstring(T const& value)
     {
@@ -742,7 +742,7 @@ WINRT_EXPORT namespace winrt
         return result.to_hstring();
     }
 
-    inline std::string to_string(std::wstring_view value)
+    WINRT_EXPORT inline std::string to_string(std::wstring_view value)
     {
         int const size = WINRT_IMPL_WideCharToMultiByte(65001 /*CP_UTF8*/, 0, value.data(), static_cast<std::int32_t>(value.size()), nullptr, 0, nullptr, nullptr);
 
diff --git a/strings/base_string_input.h b/strings/base_string_input.h
index f992076e6..103279208 100644
--- a/strings/base_string_input.h
+++ b/strings/base_string_input.h
@@ -1,7 +1,7 @@
 
-WINRT_EXPORT namespace winrt::param
+extern "C++" namespace winrt::param
 {
-    struct hstring
+    WINRT_EXPORT struct hstring
     {
 #ifdef _MSC_VER // T
 #pragma warning(suppress: 26495)
@@ -59,14 +59,14 @@ WINRT_EXPORT namespace winrt::param
         impl::hstring_header m_header;
     };
 
-    inline void* get_abi(hstring const& object) noexcept
+    WINRT_EXPORT inline void* get_abi(hstring const& object) noexcept
     {
         return *impl::abi_cast(object);
     }
 }
 
-WINRT_EXPORT namespace winrt::impl
+extern "C++" namespace winrt::impl
 {
-    template <typename T>
+    WINRT_EXPORT template <typename T>
     using param_type = std::conditional_t<std::is_same_v<T, hstring>, param::hstring, T>;
 }
diff --git a/strings/base_string_operators.h b/strings/base_string_operators.h
index 7e237866d..6d8a9efe3 100644
--- a/strings/base_string_operators.h
+++ b/strings/base_string_operators.h
@@ -1,6 +1,7 @@
-WINRT_EXPORT namespace winrt::impl
+
+extern "C++" namespace winrt::impl
 {
-    inline hstring concat_hstring(std::wstring_view const& left, std::wstring_view const& right)
+    WINRT_EXPORT inline hstring concat_hstring(std::wstring_view const& left, std::wstring_view const& right)
     {
         auto size = static_cast<std::uint32_t>(left.size() + right.size());
         if (size == 0)
@@ -14,59 +15,59 @@ WINRT_EXPORT namespace winrt::impl
     }
 }
 
-WINRT_EXPORT namespace winrt
+extern "C++" namespace winrt
 {
-    inline hstring operator+(hstring const& left, hstring const& right)
+    WINRT_EXPORT inline hstring operator+(hstring const& left, hstring const& right)
     {
         return impl::concat_hstring(left, right);
     }
 
-    inline hstring operator+(hstring const& left, std::wstring const& right)
+    WINRT_EXPORT inline hstring operator+(hstring const& left, std::wstring const& right)
     {
         return impl::concat_hstring(left, right);
     }
 
-    inline hstring operator+(std::wstring const& left, hstring const& right)
+    WINRT_EXPORT inline hstring operator+(std::wstring const& left, hstring const& right)
     {
         return impl::concat_hstring(left, right);
     }
 
-    inline hstring operator+(hstring const& left, wchar_t const* right)
+    WINRT_EXPORT inline hstring operator+(hstring const& left, wchar_t const* right)
     {
         return impl::concat_hstring(left, right);
     }
 
-    inline hstring operator+(wchar_t const* left, hstring const& right)
+    WINRT_EXPORT inline hstring operator+(wchar_t const* left, hstring const& right)
     {
         return impl::concat_hstring(left, right);
     }
 
-    inline hstring operator+(hstring const& left, wchar_t right)
+    WINRT_EXPORT inline hstring operator+(hstring const& left, wchar_t right)
     {
         return impl::concat_hstring(left, std::wstring_view(&right, 1));
     }
 
-    inline hstring operator+(wchar_t left, hstring const& right)
+    WINRT_EXPORT inline hstring operator+(wchar_t left, hstring const& right)
     {
         return impl::concat_hstring(std::wstring_view(&left, 1), right);
     }
 
-    hstring operator+(hstring const& left, std::nullptr_t) = delete;
+    WINRT_EXPORT hstring operator+(hstring const& left, std::nullptr_t) = delete;
 
-    hstring operator+(std::nullptr_t, hstring const& right) = delete;
+    WINRT_EXPORT hstring operator+(std::nullptr_t, hstring const& right) = delete;
 
-    inline hstring operator+(hstring const& left, std::wstring_view const& right)
+    WINRT_EXPORT inline hstring operator+(hstring const& left, std::wstring_view const& right)
     {
         return impl::concat_hstring(left, right);
     }
 
-    inline hstring operator+(std::wstring_view const& left, hstring const& right)
+    WINRT_EXPORT inline hstring operator+(std::wstring_view const& left, hstring const& right)
     {
         return impl::concat_hstring(left, right);
     }
 
 #ifndef WINRT_LEAN_AND_MEAN
-    inline std::wostream& operator<<(std::wostream& stream, hstring const& string)
+    WINRT_EXPORT inline std::wostream& operator<<(std::wostream& stream, hstring const& string)
     {
         stream << static_cast<std::wstring_view>(string);
         return stream;
diff --git a/strings/base_stringable_format.h b/strings/base_stringable_format.h
index bfa711aa0..97d47b627 100644
--- a/strings/base_stringable_format.h
+++ b/strings/base_stringable_format.h
@@ -1,6 +1,9 @@
 
-template <typename FormatContext>
-auto std::formatter<winrt::Windows::Foundation::IStringable, wchar_t>::format(winrt::Windows::Foundation::IStringable const& obj, FormatContext& fc) const
+extern "C++"
 {
-    return std::formatter<winrt::hstring, wchar_t>::format(obj.ToString(), fc);
+    template <typename FormatContext>
+    auto std::formatter<winrt::Windows::Foundation::IStringable, wchar_t>::format(winrt::Windows::Foundation::IStringable const& obj, FormatContext& fc) const
+    {
+        return std::formatter<winrt::hstring, wchar_t>::format(obj.ToString(), fc);
+    }
 }
diff --git a/strings/base_stringable_format_1.h b/strings/base_stringable_format_1.h
index cc75bf183..706ad2808 100644
--- a/strings/base_stringable_format_1.h
+++ b/strings/base_stringable_format_1.h
@@ -1,7 +1,10 @@
 
-template <>
-struct std::formatter<winrt::Windows::Foundation::IStringable, wchar_t> : std::formatter<winrt::hstring, wchar_t>
+extern "C++"
 {
-    template <typename FormatContext>
-    auto format(winrt::Windows::Foundation::IStringable const& obj, FormatContext& fc) const;
-};
+    template <>
+    struct std::formatter<winrt::Windows::Foundation::IStringable, wchar_t> : std::formatter<winrt::hstring, wchar_t>
+    {
+        template <typename FormatContext>
+        auto format(winrt::Windows::Foundation::IStringable const& obj, FormatContext& fc) const;
+    };
+}
diff --git a/strings/base_stringable_streams.h b/strings/base_stringable_streams.h
index 52b481d6f..ae90de6ac 100644
--- a/strings/base_stringable_streams.h
+++ b/strings/base_stringable_streams.h
@@ -1,4 +1,6 @@
 
+extern "C++"
+{
 #ifndef WINRT_LEAN_AND_MEAN
 inline std::wostream& operator<<(std::wostream& stream, winrt::Windows::Foundation::IStringable const& stringable)
 {
@@ -6,3 +8,4 @@ inline std::wostream& operator<<(std::wostream& stream, winrt::Windows::Foundati
     return stream;
 }
 #endif
+}
diff --git a/strings/base_stringable_to_hstring.h b/strings/base_stringable_to_hstring.h
index f92da965b..753d030de 100644
--- a/strings/base_stringable_to_hstring.h
+++ b/strings/base_stringable_to_hstring.h
@@ -1,7 +1,7 @@
 
-WINRT_EXPORT namespace winrt
+extern "C++" namespace winrt
 {
-    inline hstring to_hstring(Windows::Foundation::IStringable const& stringable)
+    WINRT_EXPORT inline hstring to_hstring(Windows::Foundation::IStringable const& stringable)
     {
         return stringable.ToString();
     }
diff --git a/strings/base_types.h b/strings/base_types.h
index 7684dfa3a..53d6ba6e2 100644
--- a/strings/base_types.h
+++ b/strings/base_types.h
@@ -1,25 +1,25 @@
 
-WINRT_EXPORT namespace winrt::impl
+extern "C++" namespace winrt::impl
 {
-    using ptp_io = struct tp_io*;
-    using ptp_timer = struct tp_timer*;
-    using ptp_wait = struct tp_wait*;
-    using ptp_pool = struct tp_pool*;
-    using srwlock = struct srwlock_*;
-    using condition_variable = struct condition_variable_*;
-    using bstr = wchar_t*;
+    WINRT_EXPORT using ptp_io = struct tp_io*;
+    WINRT_EXPORT using ptp_timer = struct tp_timer*;
+    WINRT_EXPORT using ptp_wait = struct tp_wait*;
+    WINRT_EXPORT using ptp_pool = struct tp_pool*;
+    WINRT_EXPORT using srwlock = struct srwlock_*;
+    WINRT_EXPORT using condition_variable = struct condition_variable_*;
+    WINRT_EXPORT using bstr = wchar_t*;
 
-    using filetime_period = std::ratio_multiply<std::ratio<100>, std::nano>;
-    struct IAgileObject;
+    WINRT_EXPORT using filetime_period = std::ratio_multiply<std::ratio<100>, std::nano>;
+    WINRT_EXPORT struct IAgileObject;
 
-    struct com_callback_args
+    WINRT_EXPORT struct com_callback_args
     {
         std::uint32_t reserved1;
         std::uint32_t reserved2;
         void* data;
     };
 
-    template <typename T>
+    WINRT_EXPORT template <typename T>
     constexpr std::uint8_t hex_to_uint(T const c)
     {
         if (c >= '0' && c <= '9')
@@ -40,31 +40,31 @@ WINRT_EXPORT namespace winrt::impl
         }
     }
 
-    template <typename T>
+    WINRT_EXPORT template <typename T>
     constexpr std::uint8_t hex_to_uint8(T const a, T const b)
     {
         return (hex_to_uint(a) << 4) | hex_to_uint(b);
     }
 
-    constexpr std::uint16_t uint8_to_uint16(std::uint8_t a, std::uint8_t b)
+    WINRT_EXPORT constexpr std::uint16_t uint8_to_uint16(std::uint8_t a, std::uint8_t b)
     {
         return (static_cast<std::uint16_t>(a) << 8) | static_cast<std::uint16_t>(b);
     }
 
-    constexpr std::uint32_t uint8_to_uint32(std::uint8_t a, std::uint8_t b, std::uint8_t c, std::uint8_t d)
+    WINRT_EXPORT constexpr std::uint32_t uint8_to_uint32(std::uint8_t a, std::uint8_t b, std::uint8_t c, std::uint8_t d)
     {
         return (static_cast<std::uint32_t>(uint8_to_uint16(a, b)) << 16) |
                 static_cast<std::uint32_t>(uint8_to_uint16(c, d));
     }
 }
 
-WINRT_EXPORT namespace winrt
+extern "C++" namespace winrt
 {
-    struct event_token;
-    struct hstring;
-    struct clock;
+    WINRT_EXPORT struct event_token;
+    WINRT_EXPORT struct hstring;
+    WINRT_EXPORT struct clock;
 
-    struct hresult
+    WINRT_EXPORT struct hresult
     {
         std::int32_t value{};
 
@@ -80,7 +80,7 @@ WINRT_EXPORT namespace winrt
         }
     };
 
-    struct guid
+    WINRT_EXPORT struct guid
     {
     private:
 
@@ -200,58 +200,58 @@ WINRT_EXPORT namespace winrt
     };
 }
 
-WINRT_EXPORT namespace winrt::Windows::Foundation
+extern "C++" namespace winrt::Windows::Foundation
 {
-    enum class TrustLevel : std::int32_t
+    WINRT_EXPORT enum class TrustLevel : std::int32_t
     {
         BaseTrust,
         PartialTrust,
         FullTrust
     };
 
-    struct IUnknown;
-    struct IInspectable;
-    struct IActivationFactory;
-    using TimeSpan = std::chrono::duration<std::int64_t, impl::filetime_period>;
-    using DateTime = std::chrono::time_point<clock, TimeSpan>;
+    WINRT_EXPORT struct IUnknown;
+    WINRT_EXPORT struct IInspectable;
+    WINRT_EXPORT struct IActivationFactory;
+    WINRT_EXPORT using TimeSpan = std::chrono::duration<std::int64_t, impl::filetime_period>;
+    WINRT_EXPORT using DateTime = std::chrono::time_point<clock, TimeSpan>;
 }
 
-WINRT_EXPORT namespace winrt::impl
+extern "C++" namespace winrt::impl
 {
 #ifdef WINRT_IMPL_IUNKNOWN_DEFINED
-    using hresult_type = long;
-    using count_type = unsigned long;
-    using guid_type = GUID;
+    WINRT_EXPORT using hresult_type = long;
+    WINRT_EXPORT using count_type = unsigned long;
+    WINRT_EXPORT using guid_type = GUID;
 #else
-    using hresult_type = std::int32_t;
-    using count_type = std::uint32_t;
-    using guid_type = guid;
+    WINRT_EXPORT using hresult_type = std::int32_t;
+    WINRT_EXPORT using count_type = std::uint32_t;
+    WINRT_EXPORT using guid_type = guid;
 #endif
 
 #ifdef __IInspectable_INTERFACE_DEFINED__
-    using hstring_type = HSTRING;
-    using trust_level_type = ::TrustLevel;
+    WINRT_EXPORT using hstring_type = HSTRING;
+    WINRT_EXPORT using trust_level_type = ::TrustLevel;
 #else
-    using hstring_type = void*;
-    using trust_level_type = Windows::Foundation::TrustLevel;
+    WINRT_EXPORT using hstring_type = void*;
+    WINRT_EXPORT using trust_level_type = Windows::Foundation::TrustLevel;
 #endif
 
-    inline constexpr hresult error_ok{ 0 }; // S_OK
-    inline constexpr hresult error_fail{ static_cast<hresult>(0x80004005) }; // E_FAIL
-    inline constexpr hresult error_access_denied{ static_cast<hresult>(0x80070005) }; // E_ACCESSDENIED
-    inline constexpr hresult error_wrong_thread{ static_cast<hresult>(0x8001010E) }; // RPC_E_WRONG_THREAD
-    inline constexpr hresult error_not_implemented{ static_cast<hresult>(0x80004001) }; // E_NOTIMPL
-    inline constexpr hresult error_invalid_argument{ static_cast<hresult>(0x80070057) }; // E_INVALIDARG
-    inline constexpr hresult error_out_of_bounds{ static_cast<hresult>(0x8000000B) }; // E_BOUNDS
-    inline constexpr hresult error_no_interface{ static_cast<hresult>(0x80004002) }; // E_NOINTERFACE
-    inline constexpr hresult error_class_not_available{ static_cast<hresult>(0x80040111) }; // CLASS_E_CLASSNOTAVAILABLE
-    inline constexpr hresult error_class_not_registered{ static_cast<hresult>(0x80040154) }; // REGDB_E_CLASSNOTREG
-    inline constexpr hresult error_changed_state{ static_cast<hresult>(0x8000000C) }; // E_CHANGED_STATE
-    inline constexpr hresult error_illegal_method_call{ static_cast<hresult>(0x8000000E) }; // E_ILLEGAL_METHOD_CALL
-    inline constexpr hresult error_illegal_state_change{ static_cast<hresult>(0x8000000D) }; // E_ILLEGAL_STATE_CHANGE
-    inline constexpr hresult error_illegal_delegate_assignment{ static_cast<hresult>(0x80000018) }; // E_ILLEGAL_DELEGATE_ASSIGNMENT
-    inline constexpr hresult error_canceled{ static_cast<hresult>(0x800704C7) }; // HRESULT_FROM_WIN32(ERROR_CANCELLED)
-    inline constexpr hresult error_bad_alloc{ static_cast<hresult>(0x8007000E) }; // E_OUTOFMEMORY
-    inline constexpr hresult error_not_initialized{ static_cast<hresult>(0x800401F0) }; // CO_E_NOTINITIALIZED
-    inline constexpr hresult error_file_not_found{ static_cast<hresult>(0x80070002) }; // HRESULT_FROM_WIN32(ERROR_FILE_NOT_FOUND)
+    WINRT_EXPORT inline constexpr hresult error_ok{ 0 }; // S_OK
+    WINRT_EXPORT inline constexpr hresult error_fail{ static_cast<hresult>(0x80004005) }; // E_FAIL
+    WINRT_EXPORT inline constexpr hresult error_access_denied{ static_cast<hresult>(0x80070005) }; // E_ACCESSDENIED
+    WINRT_EXPORT inline constexpr hresult error_wrong_thread{ static_cast<hresult>(0x8001010E) }; // RPC_E_WRONG_THREAD
+    WINRT_EXPORT inline constexpr hresult error_not_implemented{ static_cast<hresult>(0x80004001) }; // E_NOTIMPL
+    WINRT_EXPORT inline constexpr hresult error_invalid_argument{ static_cast<hresult>(0x80070057) }; // E_INVALIDARG
+    WINRT_EXPORT inline constexpr hresult error_out_of_bounds{ static_cast<hresult>(0x8000000B) }; // E_BOUNDS
+    WINRT_EXPORT inline constexpr hresult error_no_interface{ static_cast<hresult>(0x80004002) }; // E_NOINTERFACE
+    WINRT_EXPORT inline constexpr hresult error_class_not_available{ static_cast<hresult>(0x80040111) }; // CLASS_E_CLASSNOTAVAILABLE
+    WINRT_EXPORT inline constexpr hresult error_class_not_registered{ static_cast<hresult>(0x80040154) }; // REGDB_E_CLASSNOTREG
+    WINRT_EXPORT inline constexpr hresult error_changed_state{ static_cast<hresult>(0x8000000C) }; // E_CHANGED_STATE
+    WINRT_EXPORT inline constexpr hresult error_illegal_method_call{ static_cast<hresult>(0x8000000E) }; // E_ILLEGAL_METHOD_CALL
+    WINRT_EXPORT inline constexpr hresult error_illegal_state_change{ static_cast<hresult>(0x8000000D) }; // E_ILLEGAL_STATE_CHANGE
+    WINRT_EXPORT inline constexpr hresult error_illegal_delegate_assignment{ static_cast<hresult>(0x80000018) }; // E_ILLEGAL_DELEGATE_ASSIGNMENT
+    WINRT_EXPORT inline constexpr hresult error_canceled{ static_cast<hresult>(0x800704C7) }; // HRESULT_FROM_WIN32(ERROR_CANCELLED)
+    WINRT_EXPORT inline constexpr hresult error_bad_alloc{ static_cast<hresult>(0x8007000E) }; // E_OUTOFMEMORY
+    WINRT_EXPORT inline constexpr hresult error_not_initialized{ static_cast<hresult>(0x800401F0) }; // CO_E_NOTINITIALIZED
+    WINRT_EXPORT inline constexpr hresult error_file_not_found{ static_cast<hresult>(0x80070002) }; // HRESULT_FROM_WIN32(ERROR_FILE_NOT_FOUND)
 }
diff --git a/strings/base_version.h b/strings/base_version.h
index 4a6b68e66..f120fcc82 100644
--- a/strings/base_version.h
+++ b/strings/base_version.h
@@ -14,9 +14,9 @@ char const * const WINRT_version = "C++/WinRT version:" CPPWINRT_VERSION;
 #pragma detect_mismatch("C++/WinRT version", CPPWINRT_VERSION)
 #endif
 
-WINRT_EXPORT namespace winrt
+extern "C++" namespace winrt
 {
-    template <std::size_t BaseSize, std::size_t ComponentSize>
+    WINRT_EXPORT template <std::size_t BaseSize, std::size_t ComponentSize>
     constexpr bool check_version(char const(&base)[BaseSize], char const(&component)[ComponentSize]) noexcept
     {
         if constexpr (BaseSize != ComponentSize)
diff --git a/strings/base_version_odr.h b/strings/base_version_odr.h
index 03963dded..5dde2b109 100644
--- a/strings/base_version_odr.h
+++ b/strings/base_version_odr.h
@@ -1,2 +1,3 @@
+
 #define CPPWINRT_VERSION "%"
 
diff --git a/strings/base_weak_ref.h b/strings/base_weak_ref.h
index 5f124045a..944cffa1a 100644
--- a/strings/base_weak_ref.h
+++ b/strings/base_weak_ref.h
@@ -1,7 +1,7 @@
 
-WINRT_EXPORT namespace winrt
+extern "C++" namespace winrt
 {
-    template <typename T>
+    WINRT_EXPORT template <typename T>
     struct weak_ref
     {
         weak_ref(std::nullptr_t = nullptr) noexcept {}
@@ -91,7 +91,7 @@ WINRT_EXPORT namespace winrt
     {
     };
 
-    template <typename T>
+    WINRT_EXPORT template <typename T>
     weak_ref<impl::wrapped_type_t<T>> make_weak(T const& object)
     {
         return object;
diff --git a/strings/base_windows.h b/strings/base_windows.h
index baa90e9e3..4887d4d39 100644
--- a/strings/base_windows.h
+++ b/strings/base_windows.h
@@ -1,21 +1,21 @@
 
-WINRT_EXPORT namespace winrt::impl
+extern "C++" namespace winrt::impl
 {
 #ifdef WINRT_DIAGNOSTICS
 
-    struct factory_diagnostics_info
+    WINRT_EXPORT struct factory_diagnostics_info
     {
         bool is_agile{ true };
         std::uint32_t requests{ 0 };
     };
 
-    struct diagnostics_info
+    WINRT_EXPORT struct diagnostics_info
     {
         std::map<std::wstring_view, std::uint32_t> queries;
         std::map<std::wstring_view, factory_diagnostics_info> factories;
     };
 
-    struct diagnostics_cache
+    WINRT_EXPORT struct diagnostics_cache
     {
         template <typename T>
         void add_query()
@@ -58,7 +58,7 @@ WINRT_EXPORT namespace winrt::impl
         diagnostics_info m_info;
     };
 
-    inline diagnostics_cache& get_diagnostics_info() noexcept
+    WINRT_EXPORT inline diagnostics_cache& get_diagnostics_info() noexcept
     {
         static diagnostics_cache info;
         return info;
@@ -66,38 +66,38 @@ WINRT_EXPORT namespace winrt::impl
 
 #endif
 
-    template <typename T>
+    WINRT_EXPORT template <typename T>
     using com_ref = std::conditional_t<std::is_base_of_v<Windows::Foundation::IUnknown, T>, T, com_ptr<T>>;
 
-    template <typename T>
+    WINRT_EXPORT template <typename T>
         requires is_implements_v<T>
     com_ref<T> wrap_as_result(void* result)
     {
         return { &static_cast<produce<T, typename default_interface<T>::type>*>(result)->shim(), take_ownership_from_abi };
     }
 
-    template <typename T>
+    WINRT_EXPORT template <typename T>
         requires (!is_implements_v<T>)
     com_ref<T> wrap_as_result(void* result)
     {
         return { result, take_ownership_from_abi };
     }
 
-    template<typename T>
+    WINRT_EXPORT template<typename T>
     struct is_classic_com_interface : std::conjunction<std::is_base_of<::IUnknown, T>, std::negation<is_implements<T>>> {};
 
-    template <typename T>
+    WINRT_EXPORT template <typename T>
     struct is_com_interface : std::disjunction<std::is_base_of<Windows::Foundation::IUnknown, T>, std::is_base_of<unknown_abi, T>, is_implements<T>, is_classic_com_interface<T>> {};
 
-    template <typename T>
+    WINRT_EXPORT template <typename T>
     inline constexpr bool is_com_interface_v = is_com_interface<T>::value;
 
     // You must include <winrt/Windows.Foundation.h> to use this overload.
-    template <typename To, typename From>
+    WINRT_EXPORT template <typename To, typename From>
         requires (!is_com_interface_v<To>)
     auto as(From* ptr);
 
-    template <typename To, typename From>
+    WINRT_EXPORT template <typename To, typename From>
         requires is_com_interface_v<To>
     com_ref<To> as(From* ptr)
     {
@@ -116,11 +116,11 @@ WINRT_EXPORT namespace winrt::impl
     }
 
     // You must include <winrt/Windows.Foundation.h> to use this overload.
-    template <typename To, typename From>
+    WINRT_EXPORT template <typename To, typename From>
         requires (!is_com_interface_v<To>)
     auto try_as(From* ptr) noexcept;
 
-    template <typename To, typename From>
+    WINRT_EXPORT template <typename To, typename From>
         requires is_com_interface_v<To>
     com_ref<To> try_as(From* ptr) noexcept
     {
@@ -138,7 +138,7 @@ WINRT_EXPORT namespace winrt::impl
         return wrap_as_result<To>(result);
     }
 
-    template <typename To, typename From>
+    WINRT_EXPORT template <typename To, typename From>
         requires is_com_interface_v<To>
     com_ref<To> try_as_with_reason(From* ptr, hresult& code) noexcept
     {
@@ -157,16 +157,16 @@ WINRT_EXPORT namespace winrt::impl
         return wrap_as_result<To>(result);
     }
 
-    template <typename To, typename From>
+    WINRT_EXPORT template <typename To, typename From>
     auto try_as_with_reason(From ptr, hresult& code) noexcept
     {
         return ptr->template try_as_with_reason<To>(code);
     }
 }
 
-WINRT_EXPORT namespace winrt::Windows::Foundation
+extern "C++" namespace winrt::Windows::Foundation
 {
-    struct IUnknown
+    WINRT_EXPORT struct IUnknown
     {
         IUnknown() noexcept = default;
         IUnknown(std::nullptr_t) noexcept {}
@@ -346,25 +346,25 @@ WINRT_EXPORT namespace winrt::Windows::Foundation
     };
 }
 
-WINRT_EXPORT namespace winrt::impl
+extern "C++" namespace winrt::impl
 {
-    template<typename T>
+    WINRT_EXPORT template<typename T>
     void** abi_cast(T const& object) noexcept
     {
         return reinterpret_cast<void**>(const_cast<T*>(&object));
     }
 }
 
-WINRT_EXPORT namespace winrt
+extern "C++" namespace winrt
 {
-    template <typename T>
+    WINRT_EXPORT template <typename T>
         requires (!std::is_base_of_v<Windows::Foundation::IUnknown, T>)
     auto get_abi(T const& object) noexcept
     {
         return reinterpret_cast<impl::abi_t<T> const&>(object);
     }
 
-    template <typename T>
+    WINRT_EXPORT template <typename T>
         requires (!std::is_base_of_v<Windows::Foundation::IUnknown, T>)
     auto put_abi(T& object) noexcept
     {
@@ -376,21 +376,21 @@ WINRT_EXPORT namespace winrt
         return reinterpret_cast<impl::abi_t<T>*>(&object);
     }
 
-    template <typename T, typename V>
+    WINRT_EXPORT template <typename T, typename V>
         requires (!std::is_base_of_v<Windows::Foundation::IUnknown, T>)
     void copy_from_abi(T& object, V&& value)
     {
         object = reinterpret_cast<T const&>(value);
     }
 
-    template <typename T, typename V>
+    WINRT_EXPORT template <typename T, typename V>
         requires (!std::is_base_of_v<Windows::Foundation::IUnknown, T>)
     void copy_to_abi(T const& object, V& value)
     {
         reinterpret_cast<T&>(value) = object;
     }
 
-    template <typename T>
+    WINRT_EXPORT template <typename T>
         requires (!std::is_base_of_v<Windows::Foundation::IUnknown, std::decay_t<T>> && !std::is_convertible_v<T, std::wstring_view>)
     auto detach_abi(T&& object)
     {
@@ -399,43 +399,43 @@ WINRT_EXPORT namespace winrt
         return result;
     }
 
-    inline void* get_abi(Windows::Foundation::IUnknown const& object) noexcept
+    WINRT_EXPORT inline void* get_abi(Windows::Foundation::IUnknown const& object) noexcept
     {
         return *impl::abi_cast(object);
     }
 
-    inline void** put_abi(Windows::Foundation::IUnknown& object) noexcept
+    WINRT_EXPORT inline void** put_abi(Windows::Foundation::IUnknown& object) noexcept
     {
         object = nullptr;
         return impl::abi_cast(object);
     }
 
-    inline void attach_abi(Windows::Foundation::IUnknown& object, void* value) noexcept
+    WINRT_EXPORT inline void attach_abi(Windows::Foundation::IUnknown& object, void* value) noexcept
     {
         object = nullptr;
         *put_abi(object) = value;
     }
 
-    inline void* detach_abi(Windows::Foundation::IUnknown& object) noexcept
+    WINRT_EXPORT inline void* detach_abi(Windows::Foundation::IUnknown& object) noexcept
     {
         void* temp = get_abi(object);
         *impl::abi_cast(object) = nullptr;
         return temp;
     }
 
-    inline void* detach_abi(Windows::Foundation::IUnknown&& object) noexcept
+    WINRT_EXPORT inline void* detach_abi(Windows::Foundation::IUnknown&& object) noexcept
     {
         void* temp = get_abi(object);
         *impl::abi_cast(object) = nullptr;
         return temp;
     }
 
-    constexpr void* detach_abi(std::nullptr_t) noexcept
+    WINRT_EXPORT constexpr void* detach_abi(std::nullptr_t) noexcept
     {
         return nullptr;
     }
 
-    inline void copy_from_abi(Windows::Foundation::IUnknown& object, void* value) noexcept
+    WINRT_EXPORT inline void copy_from_abi(Windows::Foundation::IUnknown& object, void* value) noexcept
     {
         object = nullptr;
 
@@ -446,7 +446,7 @@ WINRT_EXPORT namespace winrt
         }
     }
 
-    inline void copy_to_abi(Windows::Foundation::IUnknown const& object, void*& value) noexcept
+    WINRT_EXPORT inline void copy_to_abi(Windows::Foundation::IUnknown const& object, void*& value) noexcept
     {
         WINRT_ASSERT(value == nullptr);
         value = get_abi(object);
@@ -457,24 +457,24 @@ WINRT_EXPORT namespace winrt
         }
     }
 
-    inline ::IUnknown* get_unknown(Windows::Foundation::IUnknown const& object) noexcept
+    WINRT_EXPORT inline ::IUnknown* get_unknown(Windows::Foundation::IUnknown const& object) noexcept
     {
         return static_cast<::IUnknown*>(get_abi(object));
     }
 }
 
-WINRT_EXPORT namespace winrt::Windows::Foundation
+extern "C++" namespace winrt::Windows::Foundation
 {
-    struct IInspectable : IUnknown
+    WINRT_EXPORT struct IInspectable : IUnknown
     {
         IInspectable(std::nullptr_t = nullptr) noexcept {}
         IInspectable(void* ptr, take_ownership_from_abi_t) noexcept : IUnknown(ptr, take_ownership_from_abi) {}
     };
 }
 
-WINRT_EXPORT namespace winrt::impl
+extern "C++" namespace winrt::impl
 {
-    template <typename Base, typename Derive, typename MemberPointer, typename ...Args>
+    WINRT_EXPORT template <typename Base, typename Derive, typename MemberPointer, typename ...Args>
     void consume_noexcept_remove_overload(Derive const* d, MemberPointer mptr, Args&&... args) noexcept
     {
         if constexpr (!std::is_same_v<Derive, Base>)
@@ -492,7 +492,7 @@ WINRT_EXPORT namespace winrt::impl
         }
     }
 
-    template <typename Base, typename Derive, typename MemberPointer, typename ...Args>
+    WINRT_EXPORT template <typename Base, typename Derive, typename MemberPointer, typename ...Args>
     void consume_noexcept(Derive const* d, MemberPointer mptr, Args&&... args) noexcept
     {
         if constexpr (!std::is_same_v<Derive, Base>)
@@ -510,7 +510,7 @@ WINRT_EXPORT namespace winrt::impl
         }
     }
 
-    template <typename Base, typename Derive, typename MemberPointer, typename ...Args>
+    WINRT_EXPORT template <typename Base, typename Derive, typename MemberPointer, typename ...Args>
     void consume_general(Derive const* d, MemberPointer mptr, Args&&... args)
     {
         if constexpr (!std::is_same_v<Derive, Base>)
diff --git a/strings/base_xaml_component_connector.h b/strings/base_xaml_component_connector.h
index 092944613..f78fdd972 100644
--- a/strings/base_xaml_component_connector.h
+++ b/strings/base_xaml_component_connector.h
@@ -1,7 +1,7 @@
 
-WINRT_EXPORT namespace winrt::Windows::UI::Xaml::Markup
+extern "C++" namespace winrt::Windows::UI::Xaml::Markup
 {
-    template <typename D>
+    WINRT_EXPORT template <typename D>
     struct ComponentConnectorT : D
     {
         using composable_base = typename D::composable_base;
diff --git a/strings/base_xaml_component_connector_winui.h b/strings/base_xaml_component_connector_winui.h
index 312f5af29..93345ffb1 100644
--- a/strings/base_xaml_component_connector_winui.h
+++ b/strings/base_xaml_component_connector_winui.h
@@ -1,7 +1,7 @@
 
-WINRT_EXPORT namespace winrt::Microsoft::UI::Xaml::Markup
+extern "C++" namespace winrt::Microsoft::UI::Xaml::Markup
 {
-    template <typename D>
+    WINRT_EXPORT template <typename D>
     struct ComponentConnectorT : D
     {
         using composable_base = typename D::composable_base;
diff --git a/strings/base_xaml_typename.h b/strings/base_xaml_typename.h
index 2cc45b0bb..6c48d8d31 100644
--- a/strings/base_xaml_typename.h
+++ b/strings/base_xaml_typename.h
@@ -1,7 +1,7 @@
 
-WINRT_EXPORT namespace winrt::impl
+extern "C++" namespace winrt::impl
 {
-    template <typename T>
+    WINRT_EXPORT template <typename T>
     struct xaml_typename_name
     {
         static constexpr std::wstring_view value() noexcept
@@ -50,7 +50,7 @@ WINRT_EXPORT namespace winrt::impl
         }
     };
 
-    template <typename T>
+    WINRT_EXPORT template <typename T>
     struct xaml_typename_kind
     {
         static constexpr Windows::UI::Xaml::Interop::TypeKind value = Windows::UI::Xaml::Interop::TypeKind::Metadata;
@@ -138,9 +138,9 @@ WINRT_EXPORT namespace winrt::impl
     }
 }
 
-WINRT_EXPORT namespace winrt
+extern "C++" namespace winrt
 {
-    template <typename T>
+    WINRT_EXPORT template <typename T>
     inline Windows::UI::Xaml::Interop::TypeName xaml_typename()
     {
         static_assert(impl::has_category_v<T>, "T must be WinRT type.");