diff --git a/WinRT.Runtime/ComWrappersSupport.net5.cs b/WinRT.Runtime/ComWrappersSupport.net5.cs
index bd048a4bb..1197be275 100644
--- a/WinRT.Runtime/ComWrappersSupport.net5.cs
+++ b/WinRT.Runtime/ComWrappersSupport.net5.cs
@@ -46,7 +46,7 @@ internal static unsafe InspectableInfo GetInspectableInfo(IntPtr pThis)
 
         public static IObjectReference CreateCCWForObject(object obj)
         {
-            IntPtr ccw = ComWrappers.GetOrCreateComInterfaceForObject(obj, CreateComInterfaceFlags.CallerDefinedIUnknown | CreateComInterfaceFlags.TrackerSupport);
+            IntPtr ccw = ComWrappers.GetOrCreateComInterfaceForObject(obj, CreateComInterfaceFlags.TrackerSupport);
             return ObjectReference<IUnknownVftbl>.Attach(ref ccw);
         }
 
diff --git a/WinRT.Runtime/ComWrappersSupport.netstandard2.0.cs b/WinRT.Runtime/ComWrappersSupport.netstandard2.0.cs
index 2900687f8..4d92b9401 100644
--- a/WinRT.Runtime/ComWrappersSupport.netstandard2.0.cs
+++ b/WinRT.Runtime/ComWrappersSupport.netstandard2.0.cs
@@ -286,6 +286,13 @@ internal uint Release()
         internal int QueryInterface(Guid iid, out IntPtr ptr)
         {
             const int E_NOINTERFACE = unchecked((int)0x80004002);
+            if (ManagedObject is ICustomQueryInterface customQI)
+            {
+                if (customQI.GetInterface(ref iid, out ptr) == CustomQueryInterfaceResult.Handled)
+                {
+                    return 0;
+                }
+            }
             if (_managedQITable.TryGetValue(iid, out ptr))
             {
                 AddRef();
diff --git a/WinRT.Runtime/ExceptionHelpers.cs b/WinRT.Runtime/ExceptionHelpers.cs
index bb21b7ae1..653505b6a 100644
--- a/WinRT.Runtime/ExceptionHelpers.cs
+++ b/WinRT.Runtime/ExceptionHelpers.cs
@@ -71,7 +71,7 @@ public static void ThrowExceptionForHR(int hr)
         private static Exception GetExceptionForHR(int hr, bool useGlobalErrorState, out bool restoredExceptionFromGlobalState)
         {
             restoredExceptionFromGlobalState = false;
-            if (hr == 0)
+            if (hr >= 0)
             {
                 return null;
             }
diff --git a/WinRT.Runtime/Projections/Type.cs b/WinRT.Runtime/Projections/Type.cs
index 7dc6d6029..f99068d3e 100644
--- a/WinRT.Runtime/Projections/Type.cs
+++ b/WinRT.Runtime/Projections/Type.cs
@@ -72,11 +72,7 @@ public static Type GetAbi(Marshaler m)
             {
                 return null;
             }
-            if (value.Kind != TypeKind.Custom)
-            {
-                return TypeNameSupport.FindTypeByName(name.AsSpan()).type;
-            }
-            return global::System.Type.GetType(name, throwOnError: true);
+            return TypeNameSupport.FindTypeByName(name.AsSpan()).type;
         }
 
         public static unsafe void CopyAbi(Marshaler arg, IntPtr dest) =>
diff --git a/WinUI/WinUIDesktopSample.Package/NoBuild.Targets b/WinUI/WinUIDesktopSample.Package/NoBuild.Targets
new file mode 100644
index 000000000..35c6b94d9
--- /dev/null
+++ b/WinUI/WinUIDesktopSample.Package/NoBuild.Targets
@@ -0,0 +1,8 @@
+<Project>
+  <!--
+    This target is only imported when building from the command line.
+    It defines an empty Build target because we skip building the
+    project from the command line.
+  -->
+  <Target Name="Build" />
+</Project>
\ No newline at end of file
diff --git a/WinUI/WinUIDesktopSample.Package/WinUIDesktopSample.Package.wapproj b/WinUI/WinUIDesktopSample.Package/WinUIDesktopSample.Package.wapproj
index 69a206bf9..c09c19468 100644
--- a/WinUI/WinUIDesktopSample.Package/WinUIDesktopSample.Package.wapproj
+++ b/WinUI/WinUIDesktopSample.Package/WinUIDesktopSample.Package.wapproj
@@ -85,6 +85,5 @@
     </ProjectReference>
   </ItemGroup>
   <Import Project="$(WapProjPath)\Microsoft.DesktopBridge.targets" Condition="'$(BuildingInsideVisualStudio)'=='true'" />
-  <Target Name="Build" Condition="'$(BuildingInsideVisualStudio)'!='true'" />
-  <Target Name="Clean" />
+  <Import Project="$(MSBuildThisFileDirectory)NoBuild.targets" Condition="'$(BuildingInsideVisualStudio)'!='true'" />
 </Project>
\ No newline at end of file
diff --git a/WinUI/WinUIDesktopSample/App.xaml.cs b/WinUI/WinUIDesktopSample/App.xaml.cs
index 23c160b57..2f4623f6d 100644
--- a/WinUI/WinUIDesktopSample/App.xaml.cs
+++ b/WinUI/WinUIDesktopSample/App.xaml.cs
@@ -19,23 +19,29 @@ public App()
         {
         }
 
+        Window myWindow;
         protected override void OnLaunched(LaunchActivatedEventArgs args)
         {
+            var button = new Button
+            {
+                Content = "Click me to load MainPage",
+                HorizontalAlignment = HorizontalAlignment.Center,
+                VerticalAlignment = VerticalAlignment.Center
+            };
+            button.Click += Button_Click;
             var window = new Microsoft.UI.Xaml.Window
             {
-                // This will cause the InvalidCast exception. Once that is fixed, this can
-                // be removed and just use the new MainPage() line below for setting content
-                Content = new Microsoft.UI.Xaml.Shapes.Rectangle()
-                {
-                    Fill = new SolidColorBrush(Windows.UI.Colors.Red),
-                    Width = 200,
-                    Height = 200
-                }
+                Content = button
             };
 
-            window.Content = new MainPage();
-
             window.Activate();
+
+            myWindow = window;
+        }
+
+        private void Button_Click(object sender, RoutedEventArgs e)
+        {
+            myWindow.Content = new MainPage();
         }
     }
 
diff --git a/WinUI/WinUIDesktopSample/MainPage.xaml.cs b/WinUI/WinUIDesktopSample/MainPage.xaml.cs
index 4272f85e1..c6ae880d0 100644
--- a/WinUI/WinUIDesktopSample/MainPage.xaml.cs
+++ b/WinUI/WinUIDesktopSample/MainPage.xaml.cs
@@ -15,6 +15,7 @@ public partial class MainPage : Page
     {
         public MainPage()
         {
+            InitializeComponent();
         }
     }
 }
diff --git a/WinUI/WinUIDesktopSample/WinUIDesktopSample.csproj b/WinUI/WinUIDesktopSample/WinUIDesktopSample.csproj
index ca51dedc9..cf59fcaef 100644
--- a/WinUI/WinUIDesktopSample/WinUIDesktopSample.csproj
+++ b/WinUI/WinUIDesktopSample/WinUIDesktopSample.csproj
@@ -5,7 +5,6 @@
     <TargetFramework>netcoreapp5.0</TargetFramework>
     <TargetPlatformVersion>10.0.18362.0</TargetPlatformVersion>
     <DefineConstants>DISABLE_XAML_GENERATED_MAIN</DefineConstants>
-    <GenerateTestProjection>true</GenerateTestProjection>
     <ApplicationManifest>WinUIDesktopSample.exe.manifest</ApplicationManifest>
     <!--
     There seems to be a codegen bug when referencing the cswinrt interop assembly of the Win32XamlHost
diff --git a/cswinrt/code_writers.h b/cswinrt/code_writers.h
index e080fc9c2..d3c4045b7 100644
--- a/cswinrt/code_writers.h
+++ b/cswinrt/code_writers.h
@@ -657,18 +657,19 @@ namespace cswinrt
         );
     }
 
-    void write_class_method(writer& w, MethodDef const& method, bool is_overridable, bool is_protected, std::string_view interface_member)
+    void write_class_method(writer& w, MethodDef const& method, TypeDef const& class_type, bool is_overridable, bool is_protected, std::string_view interface_member)
     {
         if (method.SpecialName())
         {
             return;
         }
 
-        bool write_explicit_implementation = is_protected || is_overridable;
-        auto access_spec = is_protected ? "protected " : "public ";
+        auto access_spec = is_protected || is_overridable ? "protected " : "public ";
         std::string method_spec = "";
 
-        if (is_overridable)
+        // If this interface is overridable but the type is sealed, don't mark the member as virtual.
+        // The C# compiler errors out about declaring a virtual member in a sealed class.
+        if (is_overridable && !class_type.Flags().Sealed())
         {
             // All overridable methods in the WinRT type system have protected visibility.
             access_spec = "protected ";
@@ -703,7 +704,7 @@ namespace cswinrt
 
         write_method(w, signature, method.Name(), return_type, interface_member, access_spec, method_spec);
 
-        if (write_explicit_implementation)
+        if (is_overridable || !is_exclusive_to(method.Parent()))
         {
             w.write(R"(
 % %.%(%) => %(%);)",
@@ -828,7 +829,7 @@ remove => %.% -= value;
         }
         write_event(w, event.Name(), event, interface_member, visibility);
 
-        if (is_protected || is_overridable)
+        if (is_overridable || !is_exclusive_to(event.Parent()))
         {
             write_event(w, w.write_temp("%.%", bind<write_type_name>(event.Parent(), false, false), event.Name()), event, "this");
         }
@@ -1018,8 +1019,10 @@ ComWrappersSupport.RegisterObjectForInterface(this, ThisPtr);
 public %(%)%
 {
 object baseInspectable = this.GetType() != typeof(%) ? this : null;
-_ = %.%(%%baseInspectable, out IntPtr ptr);
-var defaultInterface = new %(ObjectReference<%.Vftbl>.Attach(ref ptr));
+IntPtr composed = %.%(%%baseInspectable, out IntPtr ptr);
+using IObjectReference composedRef = ObjectReference<IUnknownVftbl>.Attach(ref composed);
+_inner = ObjectReference<IInspectable.Vftbl>.Attach(ref ptr);
+var defaultInterface = new %(_inner);
 _defaultLazy = new Lazy<%>(() => defaultInterface);
 
 ComWrappersSupport.RegisterObjectForInterface(this, ThisPtr);
@@ -1034,7 +1037,6 @@ ComWrappersSupport.RegisterObjectForInterface(this, ThisPtr);
                 bind_list<write_parameter_name_with_modifier>(", ", params_without_objects),
                 [&](writer& w) {w.write("%", params_without_objects.empty() ? " " : ", "); },
                 default_interface_name,
-                default_interface_name,
                 default_interface_name);
         }
     }
@@ -1360,6 +1362,61 @@ target);
         }
     }
 
+    std::pair<std::string, bool> find_property_interface(writer& w, TypeDef const& setter_iface, std::string_view prop_name)
+    {
+        std::string getter_iface;
+
+        auto search_interface = [&](TypeDef const& type)
+        {
+            for (auto&& prop : type.PropertyList())
+            {
+                if (prop.Name() == prop_name)
+                {
+                    getter_iface = write_type_name_temp(w, type, "%", true);
+                    return true;
+                }
+            }
+            return false;
+        };
+
+        std::function<bool(TypeDef const&)> search_interfaces = [&](TypeDef const& type)
+        {
+            for (auto&& iface : type.InterfaceImpl())
+            {
+                auto semantics = get_type_semantics(iface.Interface());
+                if (for_typedef(w, semantics, [&](auto&& type)
+                    {
+                        return (setter_iface != type) && (search_interface(type) || search_interfaces(type));
+                    })) {
+                    return true;
+                }
+            }
+            return false;
+        };
+
+        // first search base interfaces for property getter
+        if (search_interfaces(setter_iface))
+        {
+            return { getter_iface, true };
+        }
+
+        // then search peer exclusive-to interfaces and their bases
+        if (auto exclusive_to_attr = get_attribute(setter_iface, "Windows.Foundation.Metadata", "ExclusiveToAttribute"))
+        {
+            auto sig = exclusive_to_attr.Value();
+            auto const& fixed_args = sig.FixedArgs();
+            XLANG_ASSERT(fixed_args.size() == 1);
+            auto sys_type = std::get<ElemSig::SystemType>(std::get<ElemSig>(fixed_args[0].value).value);
+            auto exclusive_to_type = setter_iface.get_cache().find_required(sys_type.name);
+            if (search_interfaces(exclusive_to_type))
+            {
+                return { getter_iface, false };
+            }
+        }
+
+        throw_invalid("Could not find property getter interface");
+    }
+
     void write_class_members(writer& w, TypeDef const& type)
     {
         std::map<std::string_view, std::tuple<std::string, std::string, std::string, bool, bool>> properties;
@@ -1377,7 +1434,7 @@ target);
                 if (!is_default_interface)
                 {
                     w.write(R"(
-private % AsInternal(InterfaceTag<%> _) => new %(_default.ObjRef);
+private % AsInternal(InterfaceTag<%> _) => new %(GetReferenceForQI());
 )",
                         interface_name,
                         interface_name,
@@ -1393,15 +1450,7 @@ private % AsInternal(InterfaceTag<%> _) => new %(_default.ObjRef);
                 auto is_overridable_interface = has_attribute(ii, "Windows.Foundation.Metadata", "OverridableAttribute");
                 auto is_protected_interface = has_attribute(ii, "Windows.Foundation.Metadata", "ProtectedAttribute");
 
-                // If this interface is overridable but the type is sealed, make the interface act as though it is protected.
-                // If we don't do this, then the C# compiler errors out about declaring a virtual member in a sealed class.
-                if (is_overridable_interface && type.Flags().Sealed())
-                {
-                    is_overridable_interface = false;
-                    is_protected_interface = true;
-                }
-
-                w.write_each<write_class_method>(interface_type.MethodList(), is_overridable_interface, is_protected_interface, target);
+                w.write_each<write_class_method>(interface_type.MethodList(), type, is_overridable_interface, is_protected_interface, target);
                 w.write_each<write_class_event>(interface_type.EventList(), is_overridable_interface, is_protected_interface, target);
 
                 // Merge property getters/setters, since such may be defined across interfaces
@@ -1437,8 +1486,8 @@ private % AsInternal(InterfaceTag<%> _) => new %(_default.ObjRef);
                         XLANG_ASSERT(!getter_target.empty() || !setter_target.empty());
                     }
 
-                    // If this interface is overridable or protected then we need to emit an explicit implementation of the property for that interface.
-                    if (is_overridable_interface || is_protected_interface)
+                    // If this interface is overridable then we need to emit an explicit implementation of the property for that interface.
+                    if (is_overridable_interface || !is_exclusive_to(interface_type))
                     {
                         w.write("% %.% {%%}",
                             prop_type,
@@ -1446,7 +1495,7 @@ private % AsInternal(InterfaceTag<%> _) => new %(_default.ObjRef);
                             prop.Name(),
                             bind([&](writer& w)
                             {
-                                if (getter)
+                                if (getter || find_property_interface(w, interface_type, prop.Name()).second)
                                 {
                                     w.write("get => %; ", prop.Name());
                                 }
@@ -1517,61 +1566,6 @@ private EventSource<%> _%;)",
         }
     }
 
-    std::pair<std::string, bool> find_property_interface(writer& w, TypeDef const& setter_iface, std::string_view prop_name)
-    {
-        std::string getter_iface;
-
-        auto search_interface = [&](TypeDef const& type)
-        {
-            for (auto&& prop : type.PropertyList())
-            {
-                if (prop.Name() == prop_name)
-                {
-                    getter_iface = write_type_name_temp(w, type, "%", true);
-                    return true;
-                }
-            }
-            return false;
-        };
-
-        std::function<bool(TypeDef const&)> search_interfaces = [&](TypeDef const& type)
-        {
-            for (auto&& iface : type.InterfaceImpl())
-            {
-                auto semantics = get_type_semantics(iface.Interface());
-                if (for_typedef(w, semantics, [&](auto&& type)
-                {
-                    return (setter_iface != type) && (search_interface(type) || search_interfaces(type));
-                })) {
-                    return true;
-                }
-            }
-            return false;
-        };
-
-        // first search base interfaces for property getter
-        if (search_interfaces(setter_iface))
-        {
-            return { getter_iface, true };
-        }
-
-        // then search peer exclusive-to interfaces and their bases
-        if (auto exclusive_to_attr = get_attribute(setter_iface, "Windows.Foundation.Metadata", "ExclusiveToAttribute"))
-        {
-            auto sig = exclusive_to_attr.Value();
-            auto const& fixed_args = sig.FixedArgs();
-            XLANG_ASSERT(fixed_args.size() == 1);
-            auto sys_type = std::get<ElemSig::SystemType>(std::get<ElemSig>(fixed_args[0].value).value);
-            auto exclusive_to_type = setter_iface.get_cache().find_required(sys_type.name);
-            if (search_interfaces(exclusive_to_type))
-            {
-                return { getter_iface, false };
-            }
-        }
-
-        throw_invalid("Could not find property getter interface");
-    }
-
     void write_interface_member_signatures(writer& w, TypeDef const& type)
     {
         for (auto&& method : type.MethodList())
@@ -1965,15 +1959,8 @@ event % %;)",
                 }
                 break;
             case category::class_type:
-                if(get_mapped_type(type.TypeNamespace(), type.TypeName()))
-                {
-                    m.marshaler_type = w.write_temp("%", bind<write_type_name>(type, true, true));
-                    m.local_type = m.is_out() ? "IntPtr" : "IObjectReference";
-                }
-                else
-                {
-                    m.local_type = "IntPtr";
-                }
+                m.marshaler_type = w.write_temp("%", bind<write_type_name>(semantics, true, true));
+                m.local_type = m.is_out() ? "IntPtr" : "IObjectReference";
                 break;
             case category::delegate_type:
                 m.marshaler_type = get_abi_type();
@@ -2245,10 +2232,22 @@ public unsafe new % %(%)
                 bind<write_parameter_name>(params[params.size() - 1]));
         };
 
+        auto write_raw_return_type = [](writer& w, method_signature const& sig)
+        {
+            if (auto return_sig = sig.return_signature())
+            {
+                write_abi_type(w, get_type_semantics(return_sig.Type()));
+            }
+            else
+            {
+                w.write("void");
+            }
+        };
+
         method_signature signature{ method };
         auto [invoke_target, is_generic] = get_method_info(method);
 
-        auto abi_marshalers = get_abi_marshalers(w, signature, is_generic, "", false);
+        auto abi_marshalers = get_abi_marshalers(w, signature, is_generic, "", true);
         // The last abi marshaler is the return value and the second-to-last one
         // is the inner object (which is the return value we want).
         size_t inner_inspectable_index = abi_marshalers.size() - 2;
@@ -2268,7 +2267,7 @@ public unsafe new % %(%)
 public unsafe % %(%)
 {%}
 )",
-            bind<write_projection_return_type>(signature),
+            bind(write_raw_return_type, signature),
             method.Name(),
             bind(write_composable_constructor_params, signature),
             bind<write_abi_method_call_marshalers>(invoke_target, is_generic, abi_marshalers));
@@ -2540,8 +2539,11 @@ remove => _%.Unsubscribe(value);
         {
             for_typedef(w, get_type_semantics(iface.Interface()), [&](auto type)
             {
-                write_required_interface(type);
-                write_required_interface_members_for_abi_type(w, type, required_interfaces);
+                if (has_attribute(iface, "Windows.Foundation.Metadata", "OverridableAttribute") || !is_exclusive_to(type))
+                {
+                    write_required_interface(type);
+                    write_required_interface_members_for_abi_type(w, type, required_interfaces);
+                }
             });
         }
     }
@@ -2577,7 +2579,7 @@ remove => _%.Unsubscribe(value);
             get<uint8_t>(get_arg(10)));
     }
 
-    void write_type_inheritance(writer& w, TypeDef const& type, type_semantics base_semantics)
+    void write_type_inheritance(writer& w, TypeDef const& type, type_semantics base_semantics, bool add_custom_qi)
     {
         auto delimiter{ " : " };
         auto write_delimiter = [&]()
@@ -2596,10 +2598,19 @@ remove => _%.Unsubscribe(value);
         {
             for_typedef(w, get_type_semantics(iface.Interface()), [&](auto type)
             {
-                write_delimiter();
-                w.write("%", bind<write_type_name>(type, false, false));
+                if (has_attribute(iface, "Windows.Foundation.Metadata", "OverridableAttribute") || !is_exclusive_to(type))
+                {
+                    write_delimiter();
+                    w.write("%", bind<write_type_name>(type, false, false));
+                }
             });
         }
+
+        if (add_custom_qi)
+        {
+            write_delimiter();
+            w.write("global::System.Runtime.InteropServices.ICustomQueryInterface");
+        }
     }
     
     std::string get_vmethod_delegate_type(writer& w, MethodDef const& method, std::string vmethod_name)
@@ -3732,7 +3743,7 @@ AbiToProjectionVftablePtr = (IntPtr)nativeVftbl;
             bind<write_custom_attributes>(type),
             is_exclusive_to(type) ? "internal" : "public",
             type_name,
-            bind<write_type_inheritance>(type, object_type{}),
+            bind<write_type_inheritance>(type, object_type{}, false),
             bind<write_interface_member_signatures>(type)
         );
     }
@@ -3866,6 +3877,7 @@ public static class %
 {
 public %IntPtr ThisPtr => _default.ThisPtr;
 
+private IObjectReference _inner = null;
 private readonly Lazy<%> _defaultLazy;
 
 private % _default => _defaultLazy.Value;
@@ -3881,13 +3893,13 @@ _defaultLazy = new Lazy<%>(() => ifc);
 private struct InterfaceTag<I>{};
 
 private % AsInternal(InterfaceTag<%> _) => _default;
-%
+%%
 }
 )",
             bind<write_custom_attributes>(type),
             bind<write_class_modifiers>(type),
             type_name,
-            bind<write_type_inheritance>(type, base_semantics),
+            bind<write_type_inheritance>(type, base_semantics, true),
             derived_new,
             default_interface_abi_name,
             default_interface_abi_name,
@@ -3933,10 +3945,78 @@ default_interface_abi_name);
                     access_spec,
                     override_spec);
 
+                w.write(R"(
+%%IObjectReference GetReferenceForQI() => _inner ?? _default.ObjRef;)",
+                    access_spec,
+                    override_spec);
             }),
             default_interface_name,
             default_interface_name,
-            bind<write_class_members>(type));
+            bind<write_class_members>(type),
+            bind([&](writer& w)
+            {
+                    bool has_base_class = !std::holds_alternative<object_type>(get_type_semantics(type.Extends()));
+                    separator s{ w, " || " };
+                    w.write(R"(
+%bool IsOverridableInterface(Guid iid) => %%;
+
+global::System.Runtime.InteropServices.CustomQueryInterfaceResult global::System.Runtime.InteropServices.ICustomQueryInterface.GetInterface(ref Guid iid, out IntPtr ppv)
+{
+ppv = IntPtr.Zero;
+if (IsOverridableInterface(iid))
+{
+return global::System.Runtime.InteropServices.CustomQueryInterfaceResult.NotHandled;
+}
+
+try
+{
+using IObjectReference objRef = GetReferenceForQI().As<IUnknownVftbl>(iid);
+ppv = objRef.GetRef();
+return global::System.Runtime.InteropServices.CustomQueryInterfaceResult.Handled;
+}
+catch (InvalidCastException)
+{
+return global::System.Runtime.InteropServices.CustomQueryInterfaceResult.NotHandled;
+}
+})",
+                bind([&](writer& w)
+                {
+                    auto visibility = "protected ";
+                    auto overridable = "virtual ";
+                    if (has_base_class)
+                    {
+                        overridable = "override ";
+                    }
+                    else if (type.Flags().Sealed())
+                    {
+                        visibility = "private ";
+                        overridable = "";
+                    }
+                    w.write(visibility);
+                    w.write(overridable);
+                }),
+                bind_each([&](writer& w, InterfaceImpl const& iface)
+                {
+                    if (has_attribute(iface, "Windows.Foundation.Metadata", "OverridableAttribute"))
+                    {
+                        s();
+                        w.write("GuidGenerator.GetIID(typeof(%)) == iid",
+                            bind<write_type_name>(get_type_semantics(iface.Interface()), false, false));
+                    }
+                }, type.InterfaceImpl()),
+                bind([&](writer& w)
+                {
+                    if (has_base_class)
+                    {
+                        s();
+                        w.write("base.IsOverridableInterface(iid)");
+                    }
+                    if (s.first)
+                    {
+                        w.write("false");
+                    }
+                }));
+            }));
     }
 
     void write_abi_class(writer& w, TypeDef const& type)
@@ -3948,33 +4028,37 @@ default_interface_abi_name);
 
         auto abi_type_name = write_type_name_temp(w, type, "%", true);
         auto projected_type_name = write_type_name_temp(w, type);
-        auto default_interface_name = get_default_interface_name(w, type, false);
         auto default_interface_abi_name = get_default_interface_name(w, type, true);
 
-        w.write(R"([global::System.ComponentModel.EditorBrowsable(global::System.ComponentModel.EditorBrowsableState.Never)]
-public struct %
+        w.write(R"(internal struct %
 {
-public static IObjectReference CreateMarshaler(% obj) => MarshalInterface<%>.CreateMarshaler(obj);
-public static IntPtr GetAbi(IObjectReference value) => MarshalInterfaceHelper<%>.GetAbi(value);
+public static IObjectReference CreateMarshaler(% obj) => MarshalInspectable.CreateMarshaler(obj).As<%.Vftbl>();
+public static IntPtr GetAbi(IObjectReference value) => MarshalInterfaceHelper<object>.GetAbi(value);
 public static % FromAbi(IntPtr thisPtr) => (%)MarshalInspectable.FromAbi(thisPtr);
-public static IntPtr FromManaged(% obj) => MarshalInterface<%>.FromManaged(obj);
-public static (int length, IntPtr data) FromManagedArray(%[] obj) => MarshalInterface<%>.FromManagedArray(obj);
-public static void DisposeMarshaler(IObjectReference value) => MarshalInterfaceHelper<%>.DisposeMarshaler(value);
-public static void DisposeAbi(IntPtr abi) => MarshalInterfaceHelper<%>.DisposeAbi(abi);
+public static IntPtr FromManaged(% obj) => obj is null ? IntPtr.Zero : CreateMarshaler(obj).GetRef();
+public static unsafe MarshalInterfaceHelper<%>.MarshalerArray CreateMarshalerArray(%[] array) => MarshalInterfaceHelper<%>.CreateMarshalerArray(array, (o) => CreateMarshaler(o));
+public static (int length, IntPtr data) GetAbiArray(object box) => MarshalInterfaceHelper<%>.GetAbiArray(box);
+public static unsafe %[] FromAbiArray(object box) => MarshalInterfaceHelper<%>.FromAbiArray(box, FromAbi);
+public static (int length, IntPtr data) FromManagedArray(%[] array) => MarshalInterfaceHelper<%>.FromManagedArray(array, (o) => FromManaged(o));
+public static void DisposeMarshaler(IObjectReference value) => MarshalInspectable.DisposeMarshaler(value);
+public static void DisposeAbi(IntPtr abi) => MarshalInspectable.DisposeAbi(abi);
+public static unsafe void DisposeAbiArray(object box) => MarshalInspectable.DisposeAbiArray(box);
 }
 )",
             abi_type_name,
             projected_type_name,
-            default_interface_name,
-            default_interface_name,
+            default_interface_abi_name,
             projected_type_name,
             projected_type_name,
             projected_type_name,
-            default_interface_name,
             projected_type_name,
-            default_interface_name,
-            default_interface_name,
-            default_interface_name);
+            projected_type_name,
+            projected_type_name,
+            projected_type_name,
+            projected_type_name,
+            projected_type_name,
+            projected_type_name,
+            projected_type_name);
     }
 
     void write_delegate(writer& w, TypeDef const& type)