diff --git a/src/Tasks/Microsoft.NET.Build.Tasks/RunCsWinRTGenerator.cs b/src/Tasks/Microsoft.NET.Build.Tasks/RunCsWinRTGenerator.cs
new file mode 100644
index 000000000000..3c28ee32aa74
--- /dev/null
+++ b/src/Tasks/Microsoft.NET.Build.Tasks/RunCsWinRTGenerator.cs
@@ -0,0 +1,262 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+using System.Collections.Generic;
+using System.Diagnostics.CodeAnalysis;
+using System.IO;
+using System.Linq;
+using System.Runtime.InteropServices;
+using System.Text;
+using Microsoft.Build.Framework;
+using Microsoft.Build.Utilities;
+
+namespace Microsoft.NET.Build.Tasks;
+
+/// <summary>
+/// The custom MSBuild task that invokes the 'cswinrtgen' tool.
+/// </summary>
+public sealed class RunCsWinRTGenerator : ToolTask
+{
+    /// <summary>
+    /// Gets or sets the paths to assembly files that are reference assemblies, representing
+    /// the entire surface area for compilation. These assemblies are the full set of assemblies
+    /// that will contribute to the interop .dll being generated.
+    /// </summary>
+    [Required]
+    public ITaskItem[]? ReferenceAssemblyPaths { get; set; }
+
+    /// <summary>
+    /// Gets or sets the path to the output assembly that was produced by the build (for the current project).
+    /// </summary>
+    /// <remarks>
+    /// This property is an array, but it should only ever receive a single item.
+    /// </remarks>
+    [Required]
+    public ITaskItem[]? OutputAssemblyPath { get; set; }
+
+    /// <summary>
+    /// Gets or sets the directory where the generated interop assembly will be placed.
+    /// </summary>
+    [Required]
+    public string? InteropAssemblyDirectory { get; set; }
+
+    /// <summary>
+    /// Gets or sets the directory where the debug repro will be produced.
+    /// </summary>
+    /// <remarks>If not set, no debug repro will be produced.</remarks>
+    public string? DebugReproDirectory { get; set; }
+
+    /// <summary>
+    /// Gets or sets the tools directory where the 'cswinrtgen' tool is located.
+    /// </summary>
+    [Required]
+    public string? CsWinRTToolsDirectory { get; set; }
+
+    /// <summary>
+    /// Gets or sets the architecture of 'cswinrtgen' to use.
+    /// </summary>
+    /// <remarks>
+    /// If not set, the architecture will be determined based on the current process architecture.
+    /// </remarks>
+    public string? CsWinRTToolsArchitecture { get; set; }
+
+    /// <summary>
+    /// Gets or sets whether to use <c>Windows.UI.Xaml</c> projections.
+    /// </summary>
+    /// <remarks>If not set, it will default to <see langword="false"/> (i.e. using <c>Microsoft.UI.Xaml</c> projections).</remarks>
+    public bool UseWindowsUIXamlProjections { get; set; } = false;
+
+    /// <summary>
+    /// Gets whether to validate the assembly version of <c>WinRT.Runtime.dll</c>, to ensure it matches the generator.
+    /// </summary>
+    public bool ValidateWinRTRuntimeAssemblyVersion { get; set; } = true;
+
+    /// <summary>
+    /// Gets whether to validate that any references to <c>WinRT.Runtime.dll</c> version 2 are present across any assemblies.
+    /// </summary>
+    public bool ValidateWinRTRuntimeDllVersion2References { get; set; } = true;
+
+    /// <summary>
+    /// Gets whether to enable incremental generation (i.e. with a cache file on disk saving the full set of types to generate).
+    /// </summary>
+    public bool EnableIncrementalGeneration { get; set; } = true;
+
+    /// <summary>
+    /// Gets whether to treat warnings coming from 'cswinrtgen' as errors (regardless of the global 'TreatWarningsAsErrors' setting).
+    /// </summary>
+    public bool TreatWarningsAsErrors { get; set; } = false;
+
+    /// <summary>
+    /// Gets or sets the maximum number of parallel tasks to use for execution.
+    /// </summary>
+    /// <remarks>If not set, the default will match the number of available processor cores.</remarks>
+    public int MaxDegreesOfParallelism { get; set; } = -1;
+
+    /// <summary>
+    /// Gets or sets additional arguments to pass to the tool.
+    /// </summary>
+    public ITaskItem[]? AdditionalArguments { get; set; }
+
+    /// <inheritdoc/>
+    protected override string ToolName => "cswinrtgen.exe";
+
+    /// <summary>
+    /// Gets the effective item spec for the output assembly.
+    /// </summary>
+    private string EffectiveOutputAssemblyItemSpec => OutputAssemblyPath![0].ItemSpec;
+
+    /// <inheritdoc/>
+#if NET10_0_OR_GREATER
+    [MemberNotNullWhen(true, nameof(ReferenceAssemblyPaths))]
+    [MemberNotNullWhen(true, nameof(OutputAssemblyPath))]
+    [MemberNotNullWhen(true, nameof(InteropAssemblyDirectory))]
+    [MemberNotNullWhen(true, nameof(CsWinRTToolsDirectory))]
+#endif
+    protected override bool ValidateParameters()
+    {
+        if (!base.ValidateParameters())
+        {
+            return false;
+        }
+
+        if (ReferenceAssemblyPaths is not { Length: > 0 })
+        {
+            Log.LogWarning("Invalid 'ReferenceAssemblyPaths' input(s).");
+
+            return false;
+        }
+
+        if (OutputAssemblyPath is not { Length: 1 })
+        {
+            Log.LogWarning("Invalid 'OutputAssemblyPath' input.");
+
+            return false;
+        }
+
+        if (InteropAssemblyDirectory is null || !Directory.Exists(InteropAssemblyDirectory))
+        {
+            Log.LogWarning("Generated assembly directory '{0}' is invalid or does not exist.", InteropAssemblyDirectory);
+
+            return false;
+        }
+
+        if (DebugReproDirectory is not null && !Directory.Exists(DebugReproDirectory))
+        {
+            Log.LogWarning("Debug repro directory '{0}' is invalid or does not exist.", DebugReproDirectory);
+
+            return false;
+        }
+
+        if (CsWinRTToolsDirectory is null || !Directory.Exists(CsWinRTToolsDirectory))
+        {
+            Log.LogWarning("Tools directory '{0}' is invalid or does not exist.", CsWinRTToolsDirectory);
+
+            return false;
+        }
+
+        if (CsWinRTToolsArchitecture is not null &&
+            !CsWinRTToolsArchitecture.Equals("x86", StringComparison.OrdinalIgnoreCase) &&
+            !CsWinRTToolsArchitecture.Equals("x64", StringComparison.OrdinalIgnoreCase) &&
+            !CsWinRTToolsArchitecture.Equals("arm64", StringComparison.OrdinalIgnoreCase) &&
+            !CsWinRTToolsArchitecture.Equals("AnyCPU", StringComparison.OrdinalIgnoreCase))
+        {
+            Log.LogWarning("Tools architecture '{0}' is invalid (it must be 'x86', 'x64', 'arm64', or 'AnyCPU').", CsWinRTToolsArchitecture);
+
+            return false;
+        }
+
+        // The degrees of parallelism matches the semantics of the 'MaxDegreesOfParallelism' property of 'Parallel.For'. That is, it must either be exactly '-1', which is a special
+        // value meaning "use as many parallel threads as the runtime deems appropriate", or it must be set to a positive integer, to explicitly control the number of threads.
+        // See: https://learn.microsoft.com/dotnet/api/system.threading.tasks.paralleloptions.maxdegreeofparallelism#system-threading-tasks-paralleloptions-maxdegreeofparallelism.
+        if (MaxDegreesOfParallelism is not (-1 or > 0))
+        {
+            Log.LogWarning("Invalid 'MaxDegreesOfParallelism' value. It must be '-1' or greater than '0' (but was '{0}').", MaxDegreesOfParallelism);
+
+            return false;
+        }
+
+        return true;
+    }
+
+    /// <inheritdoc/>
+    [SuppressMessage("Style", "IDE0072", Justification = "We always use 'x86' as a fallback for all other CPU architectures.")]
+    protected override string GenerateFullPathToTool()
+    {
+        string? effectiveArchitecture = CsWinRTToolsArchitecture;
+
+        // Special case for when 'AnyCPU' is specified (mostly for testing scenarios).
+        // We just reuse the exact input directory and assume the architecture matches.
+        // This makes it easy to run the task against a local build of 'cswinrtgen'.
+        if (effectiveArchitecture?.Equals("AnyCPU", StringComparison.OrdinalIgnoreCase) is true)
+        {
+            return Path.Combine(CsWinRTToolsDirectory!, ToolName);
+        }
+
+        // If the architecture is not specified, determine it based on the current process architecture
+        effectiveArchitecture ??= RuntimeInformation.ProcessArchitecture switch
+        {
+            Architecture.X64 => "x64",
+            Architecture.Arm64 => "arm64",
+            _ => "x86"
+        };
+
+        // The tool is inside an architecture-specific subfolder, as it's a native binary
+        string architectureDirectory = $"win-{effectiveArchitecture}";
+
+        return Path.Combine(CsWinRTToolsDirectory!, architectureDirectory, ToolName);
+    }
+
+    /// <inheritdoc/>
+    protected override string GenerateResponseFileCommands()
+    {
+        StringBuilder args = new();
+
+        IEnumerable<string> referenceAssemblyPaths = ReferenceAssemblyPaths!.Select(static path => path.ItemSpec);
+        string referenceAssemblyPathsArg = string.Join(",", referenceAssemblyPaths);
+
+        AppendResponseFileCommand(args, "--reference-assembly-paths", referenceAssemblyPathsArg);
+        AppendResponseFileCommand(args, "--output-assembly-path", EffectiveOutputAssemblyItemSpec);
+        AppendResponseFileCommand(args, "--generated-assembly-directory", InteropAssemblyDirectory!);
+        AppendResponseFileOptionalCommand(args, "--debug-repro-directory", DebugReproDirectory);
+        AppendResponseFileCommand(args, "--use-windows-ui-xaml-projections", UseWindowsUIXamlProjections.ToString());
+        AppendResponseFileCommand(args, "--validate-winrt-runtime-assembly-version", ValidateWinRTRuntimeAssemblyVersion.ToString());
+        AppendResponseFileCommand(args, "--validate-winrt-runtime-dll-version-2-references", ValidateWinRTRuntimeDllVersion2References.ToString());
+        AppendResponseFileCommand(args, "--enable-incremental-generation", EnableIncrementalGeneration.ToString());
+        AppendResponseFileCommand(args, "--treat-warnings-as-errors", TreatWarningsAsErrors.ToString());
+        AppendResponseFileCommand(args, "--max-degrees-of-parallelism", MaxDegreesOfParallelism.ToString());
+
+        // Add any additional arguments that are not statically known
+        foreach (ITaskItem additionalArgument in AdditionalArguments ?? [])
+        {
+            _ = args.AppendLine(additionalArgument.ItemSpec);
+        }
+
+        return args.ToString();
+    }
+
+    /// <summary>
+    /// Appends a command line argument to the response file arguments, with the right format.
+    /// </summary>
+    /// <param name="args">The command line arguments being built.</param>
+    /// <param name="commandName">The command name to append.</param>
+    /// <param name="commandValue">The command value to append.</param>
+    private static void AppendResponseFileCommand(StringBuilder args, string commandName, string commandValue)
+    {
+        _ = args.Append($"{commandName} ").AppendLine(commandValue);
+    }
+
+    /// <summary>
+    /// Appends an optional command line argument to the response file arguments, with the right format.
+    /// </summary>
+    /// <param name="args">The command line arguments being built.</param>
+    /// <param name="commandName">The command name to append.</param>
+    /// <param name="commandValue">The optional command value to append.</param>
+    /// <remarks>This method will not append the command if <paramref name="commandValue"/> is <see langword="null"/>.</remarks>
+    private static void AppendResponseFileOptionalCommand(StringBuilder args, string commandName, string? commandValue)
+    {
+        if (commandValue is not null)
+        {
+            AppendResponseFileCommand(args, commandName, commandValue);
+        }
+    }
+}
diff --git a/src/Tasks/Microsoft.NET.Build.Tasks/targets/Microsoft.NET.Windows.targets b/src/Tasks/Microsoft.NET.Build.Tasks/targets/Microsoft.NET.Windows.targets
index 644d0faa4658..85c07b37e009 100644
--- a/src/Tasks/Microsoft.NET.Build.Tasks/targets/Microsoft.NET.Windows.targets
+++ b/src/Tasks/Microsoft.NET.Build.Tasks/targets/Microsoft.NET.Windows.targets
@@ -167,4 +167,178 @@ Copyright (c) .NET Foundation. All rights reserved.
                       and '$(UseUwp)' == 'true' ">
     <NetSdkError ResourceName="WindowsSDKXamlInvalidTfm" />
   </Target>
+
+  <!-- Setup common properties for '_RunCsWinRTGenerator' below -->
+  <PropertyGroup>
+
+    <!--
+      Running 'cswinrtgen' is required for CsWinRT 3.0, and it is currently in preview.
+      So the switch for it is currently opt-in. It can be changed to opt-out in the future.
+      We only enable this automatically if the project is explicitly targeting CsWinRT 3.0.
+    -->
+    <CsWinRTGenerateInteropAssembly Condition="'$(CsWinRTGenerateInteropAssembly)' == '' and '$(_TargetPlatformVersionUsesCsWinRT3)' == 'true'">true</CsWinRTGenerateInteropAssembly>
+    <CsWinRTGenerateInteropAssembly Condition="'$(CsWinRTGenerateInteropAssembly)' == ''">false</CsWinRTGenerateInteropAssembly>
+
+    <!--
+      Default property values for 'cswinrtgen'. Not setting 'CsWinRTToolsDirectory' and
+      'CsWinRTToolsArchitecture' because the task can handle their default values on its
+      own, and it will use that to automatically set the right directory and architecture.
+    -->
+    <CsWinRTGeneratorInteropAssemblyDirectory Condition="'$(CsWinRTGeneratorInteropAssemblyDirectory)' == ''">$(IntermediateOutputPath)</CsWinRTGeneratorInteropAssemblyDirectory>
+    <CsWinRTGeneratorValidateWinRTRuntimeAssemblyVersion Condition="'$(CsWinRTGeneratorValidateWinRTRuntimeAssemblyVersion)' == ''">true</CsWinRTGeneratorValidateWinRTRuntimeAssemblyVersion>
+    <CsWinRTGeneratorValidateWinRTRuntimeDllVersion2References Condition="'$(CsWinRTGeneratorValidateWinRTRuntimeDllVersion2References)' == ''">true</CsWinRTGeneratorValidateWinRTRuntimeDllVersion2References>
+    <CsWinRTGeneratorEnableIncrementalGeneration Condition="'$(CsWinRTGeneratorEnableIncrementalGeneration)' == ''">true</CsWinRTGeneratorEnableIncrementalGeneration>
+    <CsWinRTGeneratorTreatWarningsAsErrors Condition="'$(CsWinRTGeneratorTreatWarningsAsErrors)' == ''">false</CsWinRTGeneratorTreatWarningsAsErrors>
+    <CsWinRTGeneratorMaxDegreesOfParallelism Condition="'$(CsWinRTGeneratorMaxDegreesOfParallelism)' == ''">-1</CsWinRTGeneratorMaxDegreesOfParallelism>
+    <CsWinRTGeneratorStandardOutputImportance Condition="'$(CsWinRTGeneratorStandardOutputImportance)' == ''">High</CsWinRTGeneratorStandardOutputImportance>
+    <CsWinRTGeneratorStandardErrorImportance Condition="'$(CsWinRTGeneratorStandardErrorImportance)' == ''">High</CsWinRTGeneratorStandardErrorImportance>
+    <CsWinRTGeneratorLogStandardErrorAsError Condition="'$(CsWinRTGeneratorLogStandardErrorAsError)' == ''">true</CsWinRTGeneratorLogStandardErrorAsError>
+
+    <!-- Derived properties for 'cswinrtgen' tooling -->
+    <_CsWinRTGeneratorInteropAssemblyName>WinRT.Interop</_CsWinRTGeneratorInteropAssemblyName>
+    <_CsWinRTGeneratorInteropAssemblyFileName>$(_CsWinRTGeneratorInteropAssemblyName).dll</_CsWinRTGeneratorInteropAssemblyFileName>
+    <_CsWinRTGeneratorInteropAssemblyPath>$([MSBuild]::NormalizePath('$(CsWinRTGeneratorInteropAssemblyDirectory)', '$(_CsWinRTGeneratorInteropAssemblyFileName)'))</_CsWinRTGeneratorInteropAssemblyPath>
+
+    <!--
+      Set the path of the file with the hash of all input properties for 'cswinrtgen'.
+      This is needed to make the target incremental with respect to property changes.
+    -->
+    <_RunCsWinRTGeneratorPropertyInputsCachePath Condition="'$(_RunCsWinRTGeneratorPropertyInputsCachePath)' == ''">$(IntermediateOutputPath)$(MSBuildProjectName).cswinrtgen.cache</_RunCsWinRTGeneratorPropertyInputsCachePath>
+    <_RunCsWinRTGeneratorPropertyInputsCachePath>$([MSBuild]::NormalizePath('$(MSBuildProjectDirectory)', '$(_RunCsWinRTGeneratorPropertyInputsCachePath)'))</_RunCsWinRTGeneratorPropertyInputsCachePath>
+  </PropertyGroup>
+
+  <!--
+    ============================================================
+                        _ComputeRunCsWinRTGeneratorCache
+
+    Computes the cache file for '_RunCsWinRTGenerator' with the
+    hash of all input properties, to support incremental builds.
+    ============================================================
+  -->
+  <Target Name="_ComputeRunCsWinRTGeneratorCache" DependsOnTargets="ResolveAssemblyReferences">
+
+    <!--
+      If the user hasn't specified the 'CsWinRTToolsDirectory' property, we need to resolve the correct
+      tools path to use to find the 'cswinrtgen' binary that matches the 'WinRT.Runtime.dll' assembly in
+      use. To do so, we can leverage the assembly resolution logic that the .NET SDK is already doing.
+      We know that the right 'cswinrtgen' binary will always be in the '\tools' directory of whatever
+      package contains the 'WinRT.Runtime.dll' assembly (i.e. either 'Microsoft.Windows.SDK.NET.Ref' or
+      'Microsoft.Windows.CsWinRT'). So we can get the resolved assembly and compute the tools directory
+      path relative to it. We can use this value whenever 'CsWinRTToolsDirectory' isn't set.
+    -->
+    <ItemGroup>
+      <_WinRTRuntimeDllReferencePath
+        Include="@(ReferencePath)"
+        Condition="'%(Filename)%(Extension)' == 'WinRT.Runtime.dll'" />
+    </ItemGroup>
+    
+    <!-- Compute the implicit '\tools' path, and use that if 'CsWinRTToolsDirectory' isn't set -->
+    <PropertyGroup>
+      <_WinRTRuntimeDllDirectory>$([System.IO.Path]::GetDirectoryName('%(_WinRTRuntimeDllReferencePath.FullPath)'))</_WinRTRuntimeDllDirectory>
+      <_CsWinRTOrTargetingPackLibDirectory>$([System.IO.Path]::GetDirectoryName('$(_WinRTRuntimeDllDirectory)'))</_CsWinRTOrTargetingPackLibDirectory>
+      <_CsWinRTOrTargetingPackRootDirectory>$([System.IO.Path]::GetDirectoryName('$(_CsWinRTOrTargetingPackLibDirectory)'))</_CsWinRTOrTargetingPackRootDirectory>
+      <_CsWinRTOrTargetingPackToolsDirectory>$([System.IO.Path]::Combine('$(_CsWinRTOrTargetingPackRootDirectory)', 'tools'))</_CsWinRTOrTargetingPackToolsDirectory>
+
+      <CsWinRTEffectiveToolsDirectory>$(CsWinRTToolsDirectory)</CsWinRTEffectiveToolsDirectory>
+      <CsWinRTEffectiveToolsDirectory Condition="'$(CsWinRTEffectiveToolsDirectory)' == ''">$(_CsWinRTOrTargetingPackToolsDirectory)</CsWinRTEffectiveToolsDirectory>
+    </PropertyGroup>
+
+    <ItemGroup>
+      <_RunCsWinRTGeneratorInputsCacheToHash Include="$(CsWinRTEffectiveToolsDirectory)" />
+      <_RunCsWinRTGeneratorInputsCacheToHash Include="$(CsWinRTToolsArchitecture)" />
+      <_RunCsWinRTGeneratorInputsCacheToHash Include="$(CsWinRTGeneratorInteropAssemblyDirectory)" />
+      <_RunCsWinRTGeneratorInputsCacheToHash Include="$(CsWinRTGeneratorDebugReproDirectory)" />
+      <_RunCsWinRTGeneratorInputsCacheToHash Include="$(CsWinRTUseWindowsUIXamlProjections)" />
+      <_RunCsWinRTGeneratorInputsCacheToHash Include="$(CsWinRTGeneratorValidateWinRTRuntimeAssemblyVersion)" />
+      <_RunCsWinRTGeneratorInputsCacheToHash Include="$(CsWinRTGeneratorValidateWinRTRuntimeDllVersion2References)" />
+      <_RunCsWinRTGeneratorInputsCacheToHash Include="$(CsWinRTGeneratorEnableIncrementalGeneration)" />
+      <_RunCsWinRTGeneratorInputsCacheToHash Include="$(CsWinRTGeneratorTreatWarningsAsErrors)" />
+      <_RunCsWinRTGeneratorInputsCacheToHash Include="$(CsWinRTGeneratorMaxDegreesOfParallelism)" />
+      <_RunCsWinRTGeneratorInputsCacheToHash Include="@(CsWinRTGeneratorAdditionalArgument)" />
+      <_RunCsWinRTGeneratorInputsCacheToHash Include="$(CsWinRTGeneratorStandardOutputImportance)" />
+      <_RunCsWinRTGeneratorInputsCacheToHash Include="$(CsWinRTGeneratorStandardErrorImportance)" />
+      <_RunCsWinRTGeneratorInputsCacheToHash Include="$(CsWinRTGeneratorLogStandardErrorAsError)" />
+    </ItemGroup>
+
+    <Hash ItemsToHash="@(_RunCsWinRTGeneratorInputsCacheToHash)">
+      <Output TaskParameter="HashResult" PropertyName="_RunCsWinRTGeneratorInputsCacheHash" />
+    </Hash>
+
+    <WriteLinesToFile
+      Lines="$(_RunCsWinRTGeneratorInputsCacheHash)"
+      File="$(_RunCsWinRTGeneratorPropertyInputsCachePath)"
+      Overwrite="true"
+      WriteOnlyWhenDifferent="true" />
+  </Target>
+
+  <!--
+    ============================================================
+                        _RunCsWinRTGenerator
+
+    Runs 'cswinrtgen' to produce the 'WinRT.Interop.dll' assembly.
+    ============================================================
+  -->
+  <UsingTask Condition="'$(CsWinRTGeneratorTasksOverriden)' != 'true'" TaskName="RunCsWinRTGenerator" AssemblyFile="$(MicrosoftNETBuildTasksAssembly)" />
+  <Target
+    Name="_RunCsWinRTGenerator"
+    DependsOnTargets="CoreCompile;$(GetTargetPathDependsOn);$(GetTargetPathWithTargetPlatformMonikerDependsOn);_ComputeRunCsWinRTGeneratorCache"
+    BeforeTargets="GetTargetPath;GetTargetPathWithTargetPlatformMoniker;GenerateBuildDependencyFile;GeneratePublishDependencyFile;GetCopyToOutputDirectoryItems;GetCopyToPublishDirectoryItems"
+    Inputs="@(ReferencePath);@(IntermediateAssembly);$(_RunCsWinRTGeneratorPropertyInputsCachePath)"
+    Outputs="$(_CsWinRTGeneratorInteropAssemblyPath)"
+    Condition="'$(CsWinRTGenerateInteropAssembly)' == 'true'">
+
+    <!-- Invoke 'cswinrtgen' -->
+    <RunCsWinRTGenerator
+      ReferenceAssemblyPaths="@(ReferencePath)"
+      OutputAssemblyPath="@(IntermediateAssembly)"
+      InteropAssemblyDirectory="$(CsWinRTGeneratorInteropAssemblyDirectory)"
+      DebugReproDirectory="$(CsWinRTGeneratorDebugReproDirectory)"
+      CsWinRTToolsDirectory="$(CsWinRTEffectiveToolsDirectory)"
+      CsWinRTToolsArchitecture="$(CsWinRTToolsArchitecture)"
+      UseWindowsUIXamlProjections="$(CsWinRTUseWindowsUIXamlProjections)"
+      ValidateWinRTRuntimeAssemblyVersion="$(CsWinRTGeneratorValidateWinRTRuntimeAssemblyVersion)"
+      ValidateWinRTRuntimeDllVersion2References="$(CsWinRTGeneratorValidateWinRTRuntimeDllVersion2References)"
+      EnableIncrementalGeneration="$(CsWinRTGeneratorEnableIncrementalGeneration)"
+      TreatWarningsAsErrors="$(CsWinRTGeneratorTreatWarningsAsErrors)"
+      MaxDegreesOfParallelism="$(CsWinRTGeneratorMaxDegreesOfParallelism)"
+      AdditionalArguments="@(CsWinRTGeneratorAdditionalArgument)"
+      StandardOutputImportance="$(CsWinRTGeneratorStandardOutputImportance)"
+      StandardErrorImportance="$(CsWinRTGeneratorStandardErrorImportance)"
+      LogStandardErrorAsError="$(CsWinRTGeneratorLogStandardErrorAsError)" />
+
+    <!-- Set the metadata for the interop .dll item -->
+    <ItemGroup>
+      <CsWinRTGeneratorInteropAssemblyPath Include="$(_CsWinRTGeneratorInteropAssemblyPath)">
+        <AssemblyName>$(_CsWinRTGeneratorInteropAssemblyName)</AssemblyName>
+        <TargetFrameworkIdentifier>.NETCoreApp</TargetFrameworkIdentifier>
+        <ReferenceOutputAssembly>true</ReferenceOutputAssembly>
+        <IncludeRuntimeDependency>true</IncludeRuntimeDependency>
+        <Private>true</Private>
+        <MSBuildSourceTargetName>_RunCsWinRTGenerator</MSBuildSourceTargetName>
+        <Platforms>AnyCPU</Platforms>
+      </CsWinRTGeneratorInteropAssemblyPath>
+    </ItemGroup>
+
+    <!-- Add the interop .dll to the required output groups -->
+    <ItemGroup>
+
+      <!-- 'ReferencePath' handles adding the interop .dll to '.deps.json', which is needed for '[UnsafeAccessor]' to work -->
+      <ReferencePath Include="@(CsWinRTGeneratorInteropAssemblyPath)" />
+
+      <!-- '_SourceItemsToCopyToOutputDirectory' handles copying the interop .dll to the build output folder -->
+      <_SourceItemsToCopyToOutputDirectory
+        Include="@(CsWinRTGeneratorInteropAssemblyPath)"
+        TargetPath="$(_CsWinRTGeneratorInteropAssemblyFileName)" />
+
+      <!-- '_SourceItemsToCopyToPublishDirectory' handles copying the interop .dll to the publish output folder -->
+      <_SourceItemsToCopyToPublishDirectory
+        Include="@(CsWinRTGeneratorInteropAssemblyPath)"
+        TargetPath="$(_CsWinRTGeneratorInteropAssemblyFileName)" />
+    </ItemGroup>
+
+    <!-- Append to 'FileWrites' so the interop .dll will be removed on clean -->
+    <ItemGroup>
+      <FileWrites Include="@(CsWinRTGeneratorInteropAssemblyPath)"/>
+    </ItemGroup>
+  </Target>
 </Project>