diff --git a/src/Microsoft.DotNet.Wpf/src/PresentationBuildTasks/Microsoft.WinFX.targets b/src/Microsoft.DotNet.Wpf/src/PresentationBuildTasks/Microsoft.WinFX.targets
index 3d7878a7c6e..5a626f211fb 100644
--- a/src/Microsoft.DotNet.Wpf/src/PresentationBuildTasks/Microsoft.WinFX.targets
+++ b/src/Microsoft.DotNet.Wpf/src/PresentationBuildTasks/Microsoft.WinFX.targets
@@ -383,12 +383,16 @@
                      CleanupTemporaryTargetAssembly
        </MarkupCompilePass2ForMainAssemblyDependsOn>
 
-       <_CompileTargetNameForLocalType Condition="'$(_CompileTargetNameForLocalType)' == ''">_CompileTemporaryAssembly</_CompileTargetNameForLocalType>
+        <_CompileTargetNameForLocalType Condition="'$(_CompileTargetNameForLocalType)' == ''">_CompileTemporaryAssembly</_CompileTargetNameForLocalType>
 
+        <!-- The updated .NET 5.0.2 GenerateTemporaryTargetAssembly behavior that supports source generators is off by default. --> 
+        <IncludePackageReferencesDuringMarkupCompilation Condition="'$(IncludePackageReferencesDuringMarkupCompilation)' == ''">false</IncludePackageReferencesDuringMarkupCompilation>
+        <_ResolveProjectReferencesTargetName Condition="'$(IncludePackageReferencesDuringMarkupCompilation)' != 'false'">ResolveProjectReferences</_ResolveProjectReferencesTargetName>
+        <_CompileTemporaryAssemblyDependsOn>BuildOnlySettings;ResolveKeySource;$(_ResolveProjectReferencesTargetName);CoreCompile</_CompileTemporaryAssemblyDependsOn>
 
   </PropertyGroup>
 
-  <Target Name="_CompileTemporaryAssembly"  DependsOnTargets="BuildOnlySettings;ResolveKeySource;CoreCompile" />
+  <Target Name="_CompileTemporaryAssembly"  DependsOnTargets="$(_CompileTemporaryAssemblyDependsOn)" />
 
 
   <Target Name="MarkupCompilePass2ForMainAssembly"
@@ -397,7 +401,6 @@
 
   </Target>
 
-
   <!--
 
                 ==========================================
@@ -407,12 +410,63 @@
                 Name : GenerateTemporaryTargetAssembly
 
   -->
+  <Target Name="GenerateTemporaryTargetAssembly" Condition="'$(_RequireMCPass2ForMainAssembly)' == 'true'"> 
+
+     <Message Text="MSBuildProjectFile is $(MSBuildProjectFile)" Condition="'$(MSBuildTargetsVerbose)' == 'true'" />
+         
+       <!-- Create a temporary target assembly project name with a random component. -->
+       <PropertyGroup Condition="'$(IncludePackageReferencesDuringMarkupCompilation)' != 'false'">
+            <_ParentProjectName>$([System.IO.Path]::GetFileNameWithoutExtension('$(MSBuildProjectFullPath)'))</_ParentProjectName>
+            <_ParentProjectExtension>$([System.IO.Path]::GetExtension($(MSBuildProjectFullPath)))</_ParentProjectExtension>
+            <_TemporaryTargetAssemblyProjectNameNoExtension>$([System.String]::Join("_", "$(_ParentProjectName)", "$([System.IO.Path]::GetFileNameWithoutExtension($([System.IO.Path]::GetRandomFileName())))", "wpftmp"))</_TemporaryTargetAssemblyProjectNameNoExtension>
+            <_TemporaryTargetAssemblyProjectName>$(_TemporaryTargetAssemblyProjectNameNoExtension)$(_ParentProjectExtension)</_TemporaryTargetAssemblyProjectName>
+       </PropertyGroup>
+
+      <!-- Collect the generated NuGet files from the parent project required to support PackageReferences. -->
+      <ItemGroup Condition="'$(IncludePackageReferencesDuringMarkupCompilation)' != 'false'">
+        <_SourceGeneratedNuGetPropsAndTargets Include="$(MSBuildProjectExtensionsPath)$(_ParentProjectName)$(_ParentProjectExtension).nuget.g.props"/>
+        <_SourceGeneratedNuGetPropsAndTargets Include="$(MSBuildProjectExtensionsPath)$(_ParentProjectName)$(_ParentProjectExtension).nuget.g.targets"/>
+        <_SourceGeneratedNuGetPropsAndTargets Include="$(MSBuildProjectExtensionsPath)$(_ParentProjectName)$(_ParentProjectExtension).nuget.dgspec.json"/>
+
+        <_DestGeneratedNuGetPropsAndTargets Include="$(MSBuildProjectExtensionsPath)$(_TemporaryTargetAssemblyProjectName).nuget.g.props"/>
+        <_DestGeneratedNuGetPropsAndTargets Include="$(MSBuildProjectExtensionsPath)$(_TemporaryTargetAssemblyProjectName).nuget.g.targets"/>
+        <_DestGeneratedNuGetPropsAndTargets Include="$(MSBuildProjectExtensionsPath)$(_TemporaryTargetAssemblyProjectName).nuget.dgspec.json"/>
+
+      </ItemGroup>
+
+      <!-- Copy the renamed outer project NuGet props/targets files to the MSBuildProjectExtensionsPath used by NuGet. -->
+      <Copy Condition="'$(IncludePackageReferencesDuringMarkupCompilation)' != 'false'"
+            SourceFiles="@(_SourceGeneratedNuGetPropsAndTargets)"
+            DestinationFiles="@(_DestGeneratedNuGetPropsAndTargets)" 
+       />
 
-   <Target Name="GenerateTemporaryTargetAssembly"
-               Condition="'$(_RequireMCPass2ForMainAssembly)' == 'true' " >
+       <!--
+        Undo TargetFramework and RID append set in Microsoft.NET.RuntimeIdentifierInference.targets to prevent
+        a duplicate target framework and runtime identifier in the IntermediateOutputPath when the new BuildEngine 
+        instance runs. 
 
-      <Message Text="MSBuildProjectFile is $(MSBuildProjectFile)" Condition="'$(MSBuildTargetsVerbose)' == 'true'" />
+        'Append $(RuntimeIdentifier) to directory to output and intermediate paths to prevent bin clashes between
+        targets. But do not append the implicit default runtime identifier for .NET Framework apps as that would 
+        append a RID the user never mentioned in the path and do so even in the AnyCPU case.'
+       -->
 
+      <PropertyGroup>
+          <_IntermediateOutputPathNoTargetFrameworkOrRID>$(IntermediateOutputPath)</_IntermediateOutputPathNoTargetFrameworkOrRID>
+      </PropertyGroup>
+
+      <PropertyGroup Condition="'$(IncludePackageReferencesDuringMarkupCompilation)' != 'false' and
+          '$(AppendRuntimeIdentifierToOutputPath)' == 'true' and '$(RuntimeIdentifier)' != '' and 
+          '$(_UsingDefaultRuntimeIdentifier)' != 'true'">
+        <_IntermediateOutputPathNoTargetFrameworkOrRID>$([System.Text.RegularExpressions.Regex]::Replace($(_IntermediateOutputPathNoTargetFrameworkOrRID), "$(RuntimeIdentifier)\\$",, System.Text.RegularExpressions.RegexOptions.IgnoreCase))</_IntermediateOutputPathNoTargetFrameworkOrRID>
+      </PropertyGroup>
+      
+      <PropertyGroup Condition="'$(IncludePackageReferencesDuringMarkupCompilation)' != 'false' and 
+          '$(AppendTargetFrameworkToOutputPath)' == 'true' and '$(TargetFramework)' != '' and 
+          '$(_UnsupportedTargetFrameworkError)' != 'true'">
+          <_IntermediateOutputPathNoTargetFrameworkOrRID>$([System.Text.RegularExpressions.Regex]::Replace($(_IntermediateOutputPathNoTargetFrameworkOrRID), "$(TargetFramework)\\$",, System.Text.RegularExpressions.RegexOptions.IgnoreCase))</_IntermediateOutputPathNoTargetFrameworkOrRID>
+      </PropertyGroup>
+
+       <!--  Use the legacy .NET Framework/.NET Core 3.0 GenerateTemporaryTargetAssembly path if 'IncludePackageReferencesDuringMarkupCompilation' is 'false',. --> 
        <GenerateTemporaryTargetAssembly
                 CurrentProject="$(MSBuildProjectFullPath)"
                 MSBuildBinPath="$(MSBuildBinPath)"
@@ -420,10 +474,14 @@
                 CompileTypeName="Compile"
                 GeneratedCodeFiles="@(_GeneratedCodeFiles)"
                 ReferencePath="@(ReferencePath)"
-                IntermediateOutputPath="$(IntermediateOutputPath)"
+                BaseIntermediateOutputPath="$(BaseIntermediateOutputPath)"
+                IntermediateOutputPath="$(_IntermediateOutputPathNoTargetFrameworkOrRID)"
                 AssemblyName="$(AssemblyName)"
                 CompileTargetName="$(_CompileTargetNameForLocalType)"
                 GenerateTemporaryTargetAssemblyDebuggingInformation="$(GenerateTemporaryTargetAssemblyDebuggingInformation)"
+                IncludePackageReferencesDuringMarkupCompilation="$(IncludePackageReferencesDuringMarkupCompilation)"
+                Analyzers="$(Analyzers)" 
+                TemporaryTargetAssemblyProjectName="$(_TemporaryTargetAssemblyProjectName)"
                  >
 
        </GenerateTemporaryTargetAssembly>
@@ -432,8 +490,13 @@
                <Output TaskParameter="Include" ItemName="AssemblyForLocalTypeReference" />
        </CreateItem>
 
-  </Target>
-
+       <!-- Remove generated NuGet props/targets files. -->
+       <Delete
+           Condition="'$(IncludePackageReferencesDuringMarkupCompilation)' != 'false' 
+            and '$(GenerateTemporaryTargetAssemblyDebuggingInformation)' != 'true'"
+            Files="@(_DestGeneratedNuGetPropsAndTargets)" />
+        
+   </Target>
 
   <!--
 
diff --git a/src/Microsoft.DotNet.Wpf/src/PresentationBuildTasks/Microsoft/Build/Tasks/Windows/GenerateTemporaryTargetAssembly.cs b/src/Microsoft.DotNet.Wpf/src/PresentationBuildTasks/Microsoft/Build/Tasks/Windows/GenerateTemporaryTargetAssembly.cs
index 81866984433..1ed40bfbe97 100644
--- a/src/Microsoft.DotNet.Wpf/src/PresentationBuildTasks/Microsoft/Build/Tasks/Windows/GenerateTemporaryTargetAssembly.cs
+++ b/src/Microsoft.DotNet.Wpf/src/PresentationBuildTasks/Microsoft/Build/Tasks/Windows/GenerateTemporaryTargetAssembly.cs
@@ -19,6 +19,7 @@
 using System;
 using System.IO;
 using System.Collections;
+using System.Collections.Generic;
 
 using System.Globalization;
 using System.Diagnostics;
@@ -88,6 +89,29 @@ public GenerateTemporaryTargetAssembly()
         /// <remarks>Catching all exceptions in this method is appropriate - it will allow the build process to resume if possible after logging errors</remarks>
         [System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1031:DoNotCatchGeneralExceptionTypes")]
         public override bool Execute()
+        {
+            if (string.Compare(IncludePackageReferencesDuringMarkupCompilation, "false", StringComparison.OrdinalIgnoreCase) != 0)
+            {
+                return ExecuteGenerateTemporaryTargetAssemblyWithPackageReferenceSupport();
+            }
+            else
+            {
+                return ExecuteLegacyGenerateTemporaryTargetAssembly();
+            }
+        }
+
+        /// <summary>
+        /// ExecuteLegacyGenerateTemporaryTargetAssembly 
+        ///
+        /// Creates a project file based on the parent project and compiles a temporary assembly. 
+        ///
+        /// Passes IntermediateOutputPath, AssemblyName, and TemporaryTargetAssemblyName as global properties.
+        ///
+        /// </summary>
+        /// <returns></returns>
+        /// <remarks>Catching all exceptions in this method is appropriate - it will allow the build process to resume if possible after logging errors</remarks>
+        [System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1031:DoNotCatchGeneralExceptionTypes")]
+        private bool ExecuteLegacyGenerateTemporaryTargetAssembly()
         {
             bool retValue = true;
 
@@ -186,6 +210,104 @@ public override bool Execute()
             return retValue;
         }
 
+        /// <summary>
+        /// ExecuteGenerateTemporaryTargetAssemblyWithPackageReferenceSupport 
+        ///
+        /// Creates a project file based on the parent project and compiles a temporary assembly. 
+        ///
+        /// Receives the temporary project name as a parameter and writes properties in to the project file itself.
+        ///
+        /// No global properties are set.  
+        ///
+        /// </summary>
+        /// <returns></returns>
+        /// <remarks>Catching all exceptions in this method is appropriate - it will allow the build process to resume if possible after logging errors</remarks>
+        [System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1031:DoNotCatchGeneralExceptionTypes")]
+        private bool ExecuteGenerateTemporaryTargetAssemblyWithPackageReferenceSupport()
+        {
+            bool retValue = true;
+
+            //
+            // Create the temporary target assembly project
+            // 
+            try
+            {
+                XmlDocument xmlProjectDoc = null;
+
+                xmlProjectDoc = new XmlDocument( );
+                xmlProjectDoc.Load(CurrentProject);
+
+                // remove all the WinFX specific item lists
+                // ApplicationDefinition, Page, MarkupResource and Resource
+                RemoveItemsByName(xmlProjectDoc, APPDEFNAME);
+                RemoveItemsByName(xmlProjectDoc, PAGENAME);
+                RemoveItemsByName(xmlProjectDoc, MARKUPRESOURCENAME);
+                RemoveItemsByName(xmlProjectDoc, RESOURCENAME);
+
+                // Replace the Reference Item list with ReferencePath
+                RemoveItemsByName(xmlProjectDoc, REFERENCETYPENAME);
+                AddNewItems(xmlProjectDoc, ReferencePathTypeName, ReferencePath);
+
+                // Add GeneratedCodeFiles to Compile item list.
+                AddNewItems(xmlProjectDoc, CompileTypeName, GeneratedCodeFiles);
+
+                // Replace implicit SDK imports with explicit SDK imports
+                ReplaceImplicitImports(xmlProjectDoc); 
+
+                // Add properties required for temporary assembly compilation
+                var properties = new List<(string PropertyName, string PropertyValue)> 
+                {
+                    ( nameof(AssemblyName), AssemblyName ),
+                    ( nameof(IntermediateOutputPath), IntermediateOutputPath ),
+                    ( nameof(BaseIntermediateOutputPath), BaseIntermediateOutputPath ),
+                    ( "_TargetAssemblyProjectName", Path.GetFileNameWithoutExtension(CurrentProject)),
+                    ( nameof(Analyzers), Analyzers )
+                };
+
+                AddNewProperties(xmlProjectDoc, properties);
+
+                // Save the xmlDocument content into the temporary project file.
+                xmlProjectDoc.Save(TemporaryTargetAssemblyProjectName);
+
+                // Disable conflicting Arcade SDK workaround that imports NuGet props/targets
+                Hashtable globalProperties = new Hashtable(1);
+                globalProperties["_WpfTempProjectNuGetFilePathNoExt"] = "";
+
+                //
+                //  Compile the temporary target assembly project
+                //
+                retValue = BuildEngine.BuildProjectFile(TemporaryTargetAssemblyProjectName, new string[] { CompileTargetName }, globalProperties, null);
+
+                // Delete the temporary project file and generated files unless diagnostic mode has been requested
+                if (!GenerateTemporaryTargetAssemblyDebuggingInformation)
+                {
+                    try
+                    {
+                        File.Delete(TemporaryTargetAssemblyProjectName);
+
+                        DirectoryInfo intermediateOutputPath = new DirectoryInfo(IntermediateOutputPath);
+                        foreach (FileInfo temporaryProjectFile in intermediateOutputPath.EnumerateFiles(string.Concat(Path.GetFileNameWithoutExtension(TemporaryTargetAssemblyProjectName), "*")))
+                        {
+                            temporaryProjectFile.Delete();
+                        }
+                    }
+                    catch (IOException e)
+                    {
+                        // Failure to delete the file is a non fatal error
+                        Log.LogWarningFromException(e);
+                    }
+                }
+
+            }
+            catch (Exception e)
+            {
+                Log.LogErrorFromException(e);
+                retValue = false;
+            }
+
+            return retValue;
+        }
+
         #endregion Public Methods
         
         //------------------------------------------------------
@@ -333,6 +455,50 @@ public bool GenerateTemporaryTargetAssemblyDebuggingInformation
             set { _generateTemporaryTargetAssemblyDebuggingInformation = value; } 
         }
 
+        /// <summary>
+        /// Analyzers 
+        /// 
+        /// Required for Source Generator support. May be null.
+        /// 
+        /// </summary>
+        public string Analyzers 
+        { get; set; }
+
+        /// <summary>
+        /// BaseIntermediateOutputPath
+        /// 
+        /// Required for Source Generator support. May be null.
+        /// 
+        /// </summary>
+        public string BaseIntermediateOutputPath
+        {
+            get; set;
+        }
+
+        /// <summary>
+        /// IncludePackageReferencesDuringMarkupCompilation 
+        /// 
+        /// Required for Source Generator support. May be null.
+        ///
+        /// Set this property to 'false' to use the .NET Core 3.0 behavior for this task. 
+        ///
+        /// </summary>
+        public string IncludePackageReferencesDuringMarkupCompilation 
+        { get; set; }
+
+        /// <summary>
+        /// TemporaryTargetAssemblyProjectName 
+        ///
+        /// Required for PackageReference support.
+        ///
+        /// This property may be null if 'IncludePackageReferencesDuringMarkupCompilation' is 'false'.
+        ///
+        /// The file name with extension of the randomly generated project name for the temporary assembly
+        ///
+        /// </summary>
+        public string TemporaryTargetAssemblyProjectName 
+        { get; set; }
+
         #endregion Public Properties
   
         //------------------------------------------------------
@@ -504,6 +670,94 @@ private void AddNewItems(XmlDocument xmlProjectDoc, string sItemName, ITaskItem[
             }
         }
 
+        private void AddNewProperties(XmlDocument xmlProjectDoc, List<(string PropertyName, string PropertyValue)> properties )
+        {
+            if (xmlProjectDoc == null || properties == null )
+            {
+                // When the parameters are not valid, simply return it, instead of throwing exceptions.
+                return;
+            }
+
+            XmlNode root = xmlProjectDoc.DocumentElement;
+
+            // Create a new PropertyGroup element
+            XmlNode nodeItemGroup = xmlProjectDoc.CreateElement("PropertyGroup", root.NamespaceURI);
+            root.PrependChild(nodeItemGroup);
+
+            // Append this new ItemGroup item into the list of children of the document root.
+            foreach(var property in properties)
+            {
+                // Skip empty properties
+                if (!string.IsNullOrEmpty(property.PropertyValue))
+                {
+                    // Create an element for the given propertyName
+                    XmlElement nodeItem = xmlProjectDoc.CreateElement(property.PropertyName, root.NamespaceURI);
+                    nodeItem.InnerText = property.PropertyValue;
+
+                    // Add current item node into the PropertyGroup 
+                    nodeItemGroup.AppendChild(nodeItem);
+                }
+            }
+        }
+
+        //
+        // Replace implicit SDK imports with explicit imports 
+        //
+        static private void ReplaceImplicitImports(XmlDocument xmlProjectDoc)
+        {
+            if (xmlProjectDoc == null)
+            {
+                // When the parameters are not valid, simply return it, instead of throwing exceptions.
+                return;
+            }
+
+            XmlNode root = xmlProjectDoc.DocumentElement;
+          
+            for (int i = 0; i < root.Attributes.Count; i++)
+            {
+                XmlAttribute xmlAttribute = root.Attributes[i] as XmlAttribute;
+
+                if (xmlAttribute.Name.Equals("Sdk", StringComparison.OrdinalIgnoreCase))
+                {
+                    // <Project Sdk="Microsoft.NET.Sdk">
+
+                    // Remove Sdk attribute
+                    var sdkValue = xmlAttribute.Value;
+                    root.Attributes.Remove(xmlAttribute);
+
+                    //
+                    // Add explicit top import
+                    //
+                    //  <Import Project = "Sdk.props" Sdk="Microsoft.NET.Sdk" />
+                    //
+                    XmlNode nodeImportProps = xmlProjectDoc.CreateElement("Import", root.NamespaceURI);
+                    XmlAttribute projectAttribute = xmlProjectDoc.CreateAttribute("Project", root.NamespaceURI);
+                    projectAttribute.Value = "Sdk.props";
+                    nodeImportProps.Attributes.Append(projectAttribute);
+                    nodeImportProps.Attributes.Append(xmlAttribute);
+
+                    // Prepend this Import to the root of the XML document
+                    root.PrependChild(nodeImportProps);
+
+                    //
+                    // Add explicit bottom import
+                    //
+                    //  <Import Project = "Sdk.targets" Sdk="Microsoft.NET.Sdk" 
+                    //                
+                    XmlNode nodeImportTargets = xmlProjectDoc.CreateElement("Import", root.NamespaceURI);
+                    XmlAttribute projectAttribute2 = xmlProjectDoc.CreateAttribute("Project", root.NamespaceURI);
+                    projectAttribute2.Value = "Sdk.targets";
+                    XmlAttribute projectAttribute3 = xmlProjectDoc.CreateAttribute("Sdk", root.NamespaceURI);
+                    projectAttribute3.Value = sdkValue;
+                    nodeImportTargets.Attributes.Append(projectAttribute2);
+                    nodeImportTargets.Attributes.Append(projectAttribute3);
+
+                    // Append this Import to the end of the XML document
+                    root.AppendChild(nodeImportTargets);
+                }
+            }
+        }
+
         #endregion Private Methods