diff --git a/Roslyn.sln b/Roslyn.sln
index 34d550842ddc4..0198d339f7e60 100644
--- a/Roslyn.sln
+++ b/Roslyn.sln
@@ -569,6 +569,10 @@ Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "ExternalAccess", "ExternalA
 EndProject
 Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Microsoft.CodeAnalysis.LanguageServer.Protocol.Test.Utilities", "src\LanguageServer\Protocol.TestUtilities\Microsoft.CodeAnalysis.LanguageServer.Protocol.Test.Utilities.csproj", "{7465CE63-A7B7-475F-8C57-48D2F8BC665A}"
 EndProject
+Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "MSBuild", "MSBuild", "{CCEB94EC-E0BB-4A6E-861A-CAD7E9F082F8}"
+EndProject
+Project("{D954291E-2A0B-460D-934E-DC6B0785DB48}") = "WorkspacesMSBuildShared", "src\Workspaces\MSBuild\Shared\WorkspacesMSBuildShared.shproj", "{01A9F592-43BD-4B0D-949B-06DFA1A79599}"
+EndProject
 Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Microsoft.CodeAnalysis.LanguageServer.ExternalAccess.Copilot", "src\LanguageServer\ExternalAccess\Copilot\Microsoft.CodeAnalysis.LanguageServer.ExternalAccess.Copilot.csproj", "{900168D7-D982-86CE-5097-C5F173BA4D8B}"
 EndProject
 Project("{D954291E-2A0B-460D-934E-DC6B0785DB48}") = "Microsoft.CodeAnalysis.Threading", "src\Dependencies\Threading\Microsoft.CodeAnalysis.Threading.shproj", "{967723E8-4FDD-447B-99F6-4F8C47CB5433}"
@@ -1471,7 +1475,7 @@ Global
 		{E3FDC65F-568D-4E2D-A093-5132FD3793B7} = {55A62CFA-1155-46F1-ADF3-BEEE51B58AB5}
 		{909B656F-6095-4AC2-A5AB-C3F032315C45} = {FD0FAF5F-1DED-485C-99FA-84B97F3A8EEC}
 		{2E87FA96-50BB-4607-8676-46521599F998} = {55A62CFA-1155-46F1-ADF3-BEEE51B58AB5}
-		{96EB2D3B-F694-48C6-A284-67382841E086} = {55A62CFA-1155-46F1-ADF3-BEEE51B58AB5}
+		{96EB2D3B-F694-48C6-A284-67382841E086} = {CCEB94EC-E0BB-4A6E-861A-CAD7E9F082F8}
 		{21B239D0-D144-430F-A394-C066D58EE267} = {55A62CFA-1155-46F1-ADF3-BEEE51B58AB5}
 		{57CA988D-F010-4BF2-9A2E-07D6DCD2FF2C} = {55A62CFA-1155-46F1-ADF3-BEEE51B58AB5}
 		{1A3941F1-1E1F-4EF7-8064-7729C4C2E2AA} = {FD0FAF5F-1DED-485C-99FA-84B97F3A8EEC}
@@ -1565,7 +1569,7 @@ Global
 		{60166C60-813C-46C4-911D-2411B4ABBC0F} = {FD0FAF5F-1DED-485C-99FA-84B97F3A8EEC}
 		{FC2AE90B-2E4B-4045-9FDD-73D4F5ED6C89} = {C2D1346B-9665-4150-B644-075CF1636BAA}
 		{49E7C367-181B-499C-AC2E-8E17C81418D6} = {C2D1346B-9665-4150-B644-075CF1636BAA}
-		{037F06F0-3BE8-42D0-801E-2F74FC380AB8} = {55A62CFA-1155-46F1-ADF3-BEEE51B58AB5}
+		{037F06F0-3BE8-42D0-801E-2F74FC380AB8} = {CCEB94EC-E0BB-4A6E-861A-CAD7E9F082F8}
 		{2F11618A-9251-4609-B3D5-CE4D2B3D3E49} = {5CA5F70E-0FDB-467B-B22C-3CD5994F0087}
 		{CFA94A39-4805-456D-A369-FC35CCC170E9} = {C52D8057-43AF-40E6-A01B-6CDBB7301985}
 		{C52D8057-43AF-40E6-A01B-6CDBB7301985} = {3F40F71B-7DCF-44A1-B15C-38CA34824143}
@@ -1665,7 +1669,7 @@ Global
 		{09E88382-0D7B-4A15-B1AF-0B89A5B67227} = {8DBA5174-B0AA-4561-82B1-A46607697753}
 		{A833B11C-5072-4A1F-A32B-2700433B0D3D} = {806F0C6F-3640-4C92-8D55-6767B1535467}
 		{8988270E-393A-4B92-AC1A-534F903CFD34} = {8977A560-45C2-4EC2-A849-97335B382C74}
-		{B1481D94-682E-46EC-ADBE-A16EB46FEEE9} = {55A62CFA-1155-46F1-ADF3-BEEE51B58AB5}
+		{B1481D94-682E-46EC-ADBE-A16EB46FEEE9} = {CCEB94EC-E0BB-4A6E-861A-CAD7E9F082F8}
 		{09AEDEE4-6358-47C9-8022-3BD37A518070} = {5880FECB-91F1-4AB8-8726-75EAFA8A918E}
 		{5BABC440-4F1B-46E8-9068-DD7F02ED25D3} = {3E5FE3DB-45F7-4D83-9097-8F05D3B3AEC6}
 		{5762E483-75CE-4328-A410-511F30737712} = {3E5FE3DB-45F7-4D83-9097-8F05D3B3AEC6}
@@ -1682,6 +1686,8 @@ Global
 		{1AE9182D-B03E-4B00-B32E-37AE01715F57} = {EE97CB90-33BB-4F3A-9B3D-69375DEC6AC6}
 		{806F0C6F-3640-4C92-8D55-6767B1535467} = {D449D505-CC6A-4E0B-AF1B-976E2D0AE67A}
 		{7465CE63-A7B7-475F-8C57-48D2F8BC665A} = {D449D505-CC6A-4E0B-AF1B-976E2D0AE67A}
+		{CCEB94EC-E0BB-4A6E-861A-CAD7E9F082F8} = {55A62CFA-1155-46F1-ADF3-BEEE51B58AB5}
+		{01A9F592-43BD-4B0D-949B-06DFA1A79599} = {CCEB94EC-E0BB-4A6E-861A-CAD7E9F082F8}
 		{900168D7-D982-86CE-5097-C5F173BA4D8B} = {806F0C6F-3640-4C92-8D55-6767B1535467}
 		{5D60CF30-28A9-9F0F-7610-D90E4A69AE73} = {58A2876A-618D-4AE6-A136-E44B42BBDE11}
 		{967723E8-4FDD-447B-99F6-4F8C47CB5433} = {C2D1346B-9665-4150-B644-075CF1636BAA}
@@ -1696,6 +1702,7 @@ Global
 		src\Analyzers\VisualBasic\CodeFixes\VisualBasicCodeFixes.projitems*{0141285d-8f6c-42c7-baf3-3c0ccd61c716}*SharedItemsImports = 5
 		src\Workspaces\SharedUtilitiesAndExtensions\Workspace\VisualBasic\VisualBasicWorkspaceExtensions.projitems*{0141285d-8f6c-42c7-baf3-3c0ccd61c716}*SharedItemsImports = 5
 		src\Compilers\CSharp\csc\CscCommandLine.projitems*{0161e25c-918a-4dc8-9648-30fdcc8e31e9}*SharedItemsImports = 5
+		src\Workspaces\MSBuild\Shared\WorkspacesMSBuildShared.projitems*{01a9f592-43bd-4b0d-949b-06dfa1a79599}*SharedItemsImports = 13
 		src\Dependencies\Contracts\Microsoft.CodeAnalysis.Contracts.projitems*{0c2e1633-1462-4712-88f4-a0c945bad3a8}*SharedItemsImports = 5
 		src\Analyzers\Core\CodeFixes\CodeFixes.projitems*{1b6c4a1a-413b-41fb-9f85-5c09118e541b}*SharedItemsImports = 13
 		src\Compilers\Core\AnalyzerDriver\AnalyzerDriver.projitems*{1ee8cad3-55f9-4d91-96b2-084641da9a6c}*SharedItemsImports = 5
@@ -1754,6 +1761,7 @@ Global
 		src\Dependencies\Threading\Microsoft.CodeAnalysis.Threading.projitems*{8e2a252e-a140-45a6-a81a-2652996ea589}*SharedItemsImports = 5
 		src\Analyzers\VisualBasic\Analyzers\VisualBasicAnalyzers.projitems*{94faf461-2e74-4dbb-9813-6b2cde6f1880}*SharedItemsImports = 13
 		src\Compilers\Server\VBCSCompiler\VBCSCompilerCommandLine.projitems*{9508f118-f62e-4c16-a6f4-7c3b56e166ad}*SharedItemsImports = 5
+		src\Workspaces\MSBuild\Shared\WorkspacesMSBuildShared.projitems*{96eb2d3b-f694-48c6-a284-67382841e086}*SharedItemsImports = 5
 		src\Dependencies\Threading\Microsoft.CodeAnalysis.Threading.projitems*{967723e8-4fdd-447b-99f6-4f8c47cb5433}*SharedItemsImports = 13
 		src\Compilers\VisualBasic\vbc\VbcCommandLine.projitems*{975cd834-45f4-4ea0-a395-cb60dbd0e214}*SharedItemsImports = 5
 		src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\WorkspaceExtensions.projitems*{99f594b1-3916-471d-a761-a6731fc50e9a}*SharedItemsImports = 13
@@ -1772,6 +1780,7 @@ Global
 		src\Dependencies\Collections\Microsoft.CodeAnalysis.Collections.projitems*{b1481d94-682e-46ec-adbe-a16eb46feee9}*SharedItemsImports = 5
 		src\Dependencies\Contracts\Microsoft.CodeAnalysis.Contracts.projitems*{b1481d94-682e-46ec-adbe-a16eb46feee9}*SharedItemsImports = 5
 		src\Dependencies\PooledObjects\Microsoft.CodeAnalysis.PooledObjects.projitems*{b1481d94-682e-46ec-adbe-a16eb46feee9}*SharedItemsImports = 5
+		src\Workspaces\MSBuild\Shared\WorkspacesMSBuildShared.projitems*{b1481d94-682e-46ec-adbe-a16eb46feee9}*SharedItemsImports = 5
 		src\Compilers\CSharp\CSharpAnalyzerDriver\CSharpAnalyzerDriver.projitems*{b501a547-c911-4a05-ac6e-274a50dff30e}*SharedItemsImports = 5
 		src\ExpressionEvaluator\Core\Source\ResultProvider\ResultProvider.projitems*{bb3ca047-5d00-48d4-b7d3-233c1265c065}*SharedItemsImports = 13
 		src\Dependencies\Contracts\Microsoft.CodeAnalysis.Contracts.projitems*{bd9539eb-aa5e-4e67-ac7f-97d7cbc4d0c9}*SharedItemsImports = 5
diff --git a/eng/Directory.Packages.props b/eng/Directory.Packages.props
index 4fcb5b88ff93a..9d090f28b0e17 100644
--- a/eng/Directory.Packages.props
+++ b/eng/Directory.Packages.props
@@ -116,7 +116,7 @@
     <PackageVersion Include="Nerdbank.Streams" Version="2.11.79" />
     <PackageVersion Include="Newtonsoft.Json" Version="13.0.3" />
     <PackageVersion Include="StreamJsonRpc" Version="2.20.8-beta" />
-    
+
     <!--
       VS Debugger
     -->
@@ -197,6 +197,7 @@
     <PackageVersion Include="System.Numerics.Vectors" Version="$(SystemNumericsVectorsVersion)" />
     <PackageVersion Include="System.Runtime.CompilerServices.Unsafe" Version="$(SystemRuntimeCompilerServicesUnsafeVersion)" />
     <PackageVersion Include="System.Resources.Extensions" Version="$(SystemResourcesExtensionsVersion)" />
+    <PackageVersion Include="System.Security.AccessControl" Version="6.0.0" />
     <PackageVersion Include="System.Security.Cryptography.ProtectedData" Version="$(SystemSecurityCryptographyProtectedDataVersion)" />
     <PackageVersion Include="System.Security.Permissions" Version="$(SystemSecurityPermissionsVersion)" />
     <PackageVersion Include="System.Text.Encoding.CodePages" Version="7.0.0" />
diff --git a/src/LanguageServer/Microsoft.CodeAnalysis.LanguageServer/HostWorkspace/LanguageServerProjectSystem.cs b/src/LanguageServer/Microsoft.CodeAnalysis.LanguageServer/HostWorkspace/LanguageServerProjectSystem.cs
index 9a6376252f3cf..a5fd1844ce121 100644
--- a/src/LanguageServer/Microsoft.CodeAnalysis.LanguageServer/HostWorkspace/LanguageServerProjectSystem.cs
+++ b/src/LanguageServer/Microsoft.CodeAnalysis.LanguageServer/HostWorkspace/LanguageServerProjectSystem.cs
@@ -102,17 +102,11 @@ public async Task OpenSolutionAsync(string solutionFilePath)
             _logger.LogInformation(string.Format(LanguageServerResources.Loading_0, solutionFilePath));
             _workspaceFactory.ProjectSystemProjectFactory.SolutionPath = solutionFilePath;
 
-            // We'll load solutions out-of-proc, since it's possible we might be running on a runtime that doesn't have a matching SDK installed,
-            // and we don't want any MSBuild registration to set environment variables in our process that might impact child processes.
+            // We'll load solutions out-of-proc, since it's possible we might be running on a runtime that doesn't have a matching SDK installed and
+            // we aren't deploying MSBuild with our server. We wouldn't want to use MSBuildLocator anyways in case that sets environment variables that
+            // cause problems for child processes.
             await using var buildHostProcessManager = new BuildHostProcessManager(globalMSBuildProperties: AdditionalProperties, loggerFactory: _loggerFactory);
-            var buildHost = await buildHostProcessManager.GetBuildHostAsync(BuildHostProcessKind.NetCore, CancellationToken.None);
-
-            // If we don't have a .NET Core SDK on this machine at all, try .NET Framework
-            if (!await buildHost.HasUsableMSBuildAsync(solutionFilePath, CancellationToken.None))
-            {
-                var kind = RuntimeInformation.IsOSPlatform(OSPlatform.Windows) ? BuildHostProcessKind.NetFramework : BuildHostProcessKind.Mono;
-                buildHost = await buildHostProcessManager.GetBuildHostAsync(kind, CancellationToken.None);
-            }
+            var (buildHost, _) = await buildHostProcessManager.GetBuildHostWithFallbackAsync(GetKindForCurrentProcess(), solutionFilePath, CancellationToken.None);
 
             foreach (var project in await buildHost.GetProjectsInSolutionAsync(solutionFilePath, CancellationToken.None))
             {
diff --git a/src/NuGet/VS.ExternalAPIs.Roslyn.Package/VS.ExternalAPIs.Roslyn.Package.csproj b/src/NuGet/VS.ExternalAPIs.Roslyn.Package/VS.ExternalAPIs.Roslyn.Package.csproj
index 33d9538cb027a..f83c83caf5d3f 100644
--- a/src/NuGet/VS.ExternalAPIs.Roslyn.Package/VS.ExternalAPIs.Roslyn.Package.csproj
+++ b/src/NuGet/VS.ExternalAPIs.Roslyn.Package/VS.ExternalAPIs.Roslyn.Package.csproj
@@ -96,10 +96,9 @@
       <_File Include="$(ArtifactsBinDir)Microsoft.CodeAnalysis.VisualBasic.Features\$(Configuration)\netstandard2.0\Microsoft.CodeAnalysis.VisualBasic.Features.dll" TargetDir="" />
       <_File Include="$(ArtifactsBinDir)Microsoft.CodeAnalysis.VisualBasic.Workspaces\$(Configuration)\netstandard2.0\Microsoft.CodeAnalysis.VisualBasic.Workspaces.dll" TargetDir="" />
       <_File Include="$(ArtifactsBinDir)Microsoft.CodeAnalysis.VisualBasic\$(Configuration)\netstandard2.0\Microsoft.CodeAnalysis.VisualBasic.dll" TargetDir="" />
-      <_File Include="$(ArtifactsBinDir)Microsoft.CodeAnalysis.Workspaces.MSBuild\$(Configuration)\net472\Microsoft.CodeAnalysis.Workspaces.MSBuild.dll" TargetDir="" />
-      <_File Include="$(ArtifactsBinDir)Microsoft.CodeAnalysis.Workspaces.MSBuild.BuildHost\$(Configuration)\net472\Microsoft.CodeAnalysis.Workspaces.MSBuild.BuildHost.exe" TargetDir="" />
       <_File Include="$(ArtifactsBinDir)Microsoft.CodeAnalysis.Workspaces\$(Configuration)\netstandard2.0\Microsoft.CodeAnalysis.Workspaces.dll" TargetDir="" />
       <_File Include="$(ArtifactsBinDir)Microsoft.CodeAnalysis.Workspaces.Desktop\$(Configuration)\net472\Microsoft.CodeAnalysis.Workspaces.Desktop.dll" TargetDir="" />
+      <_File Include="$(ArtifactsBinDir)Microsoft.CodeAnalysis.Workspaces.MSBuild\$(Configuration)\netstandard2.0\Microsoft.CodeAnalysis.Workspaces.MSBuild.dll" TargetDir="" />
       <_File Include="$(ArtifactsBinDir)Microsoft.VisualStudio.LanguageServices.CSharp\$(Configuration)\net472\Microsoft.VisualStudio.LanguageServices.CSharp.dll" TargetDir="" />
       <_File Include="$(ArtifactsBinDir)Microsoft.VisualStudio.LanguageServices.Implementation\$(Configuration)\net472\Microsoft.VisualStudio.LanguageServices.Implementation.dll" TargetDir="" />
       <_File Include="$(ArtifactsBinDir)Microsoft.VisualStudio.LanguageServices.LiveShare\$(Configuration)\net472\Microsoft.VisualStudio.LanguageServices.LiveShare.dll" TargetDir="" />
diff --git a/src/Tools/SemanticSearch/ReferenceAssemblies/Apis/Microsoft.CodeAnalysis.CSharp.txt b/src/Tools/SemanticSearch/ReferenceAssemblies/Apis/Microsoft.CodeAnalysis.CSharp.txt
index 3075a24a86c70..2bdd939afa897 100644
--- a/src/Tools/SemanticSearch/ReferenceAssemblies/Apis/Microsoft.CodeAnalysis.CSharp.txt
+++ b/src/Tools/SemanticSearch/ReferenceAssemblies/Apis/Microsoft.CodeAnalysis.CSharp.txt
@@ -1177,6 +1177,7 @@ Microsoft.CodeAnalysis.CSharp.ForEachStatementInfo.get_GetEnumeratorMethod
 Microsoft.CodeAnalysis.CSharp.ForEachStatementInfo.get_IsAsynchronous
 Microsoft.CodeAnalysis.CSharp.ForEachStatementInfo.get_MoveNextMethod
 Microsoft.CodeAnalysis.CSharp.InterceptableLocation
+Microsoft.CodeAnalysis.CSharp.InterceptableLocation.Equals(Microsoft.CodeAnalysis.CSharp.InterceptableLocation)
 Microsoft.CodeAnalysis.CSharp.InterceptableLocation.Equals(System.Object)
 Microsoft.CodeAnalysis.CSharp.InterceptableLocation.GetDisplayLocation
 Microsoft.CodeAnalysis.CSharp.InterceptableLocation.GetHashCode
diff --git a/src/VisualStudio/Setup/Roslyn.VisualStudio.Setup.csproj b/src/VisualStudio/Setup/Roslyn.VisualStudio.Setup.csproj
index b95e19e642ebc..a15a0f2183038 100644
--- a/src/VisualStudio/Setup/Roslyn.VisualStudio.Setup.csproj
+++ b/src/VisualStudio/Setup/Roslyn.VisualStudio.Setup.csproj
@@ -170,7 +170,6 @@
       <!-- Make sure we include ContentFilesProjectOutputGroup so we get the BuildHosts deployed into the VSIX -->
       <IncludeOutputGroupsInVSIX>BuiltProjectOutputGroup;SatelliteDllsProjectOutputGroup;ContentFilesProjectOutputGroup</IncludeOutputGroupsInVSIX>
       <ForceIncludeInVSIX>true</ForceIncludeInVSIX>
-      <AdditionalProperties>TargetFramework=net472</AdditionalProperties>
       <PkgDefEntry>BindingRedirect</PkgDefEntry>
 
       <!-- Disable ngen. If we don't set this, ngen is enabled for all binaries coming from this ProjectReference, which includes the build hosts coming in as content.
diff --git a/src/Workspaces/MSBuild/BuildHost/BuildHost.cs b/src/Workspaces/MSBuild/BuildHost/BuildHost.cs
index c74d8ff18494f..21c46e304cd57 100644
--- a/src/Workspaces/MSBuild/BuildHost/BuildHost.cs
+++ b/src/Workspaces/MSBuild/BuildHost/BuildHost.cs
@@ -2,6 +2,7 @@
 // The .NET Foundation licenses this file to you under the MIT license.
 // See the LICENSE file in the project root for more information.
 
+using System;
 using System.Collections.Immutable;
 using System.Diagnostics.CodeAnalysis;
 using System.Linq;
@@ -145,11 +146,22 @@ private void EnsureMSBuildLoaded(string projectFilePath)
         // WARNING: do not use a lambda in this function, as it internally will be put in a class that contains other lambdas used in
         // TryEnsureMSBuildLoaded; on Mono this causes type load errors.
 
+        var projectFilter = ImmutableHashSet<string>.Empty;
+        if (SolutionFilterReader.IsSolutionFilterFilename(solutionFilePath))
+            (solutionFilePath, projectFilter) = SolutionFilterReader.Read(solutionFilePath);
+
         var builder = ImmutableArray.CreateBuilder<(string ProjectPath, string ProjectGuid)>();
 
         foreach (var project in SolutionFile.Parse(solutionFilePath).ProjectsInOrder)
         {
-            if (project.ProjectType != SolutionProjectType.SolutionFolder)
+            if (project.ProjectType == SolutionProjectType.SolutionFolder)
+            {
+                continue;
+            }
+
+            // Load project if we have an empty project filter and the project path is present.
+            if (projectFilter.IsEmpty ||
+                projectFilter.Contains(project.AbsolutePath))
             {
                 builder.Add((project.AbsolutePath, project.ProjectGuid));
             }
diff --git a/src/Workspaces/MSBuild/BuildHost/Microsoft.CodeAnalysis.Workspaces.MSBuild.BuildHost.csproj b/src/Workspaces/MSBuild/BuildHost/Microsoft.CodeAnalysis.Workspaces.MSBuild.BuildHost.csproj
index 9b1558f7d9866..c280d98f90a9a 100644
--- a/src/Workspaces/MSBuild/BuildHost/Microsoft.CodeAnalysis.Workspaces.MSBuild.BuildHost.csproj
+++ b/src/Workspaces/MSBuild/BuildHost/Microsoft.CodeAnalysis.Workspaces.MSBuild.BuildHost.csproj
@@ -7,8 +7,6 @@
     <TargetFrameworks>$(NetRoslynBuildHostNetCoreVersion);net472</TargetFrameworks>
     <!-- We'll always be running our build host with the same host that is used to launch the language server process directly, so we don't need to create another one -->
     <UseAppHost>false</UseAppHost>
-    <!-- Set to false since it's also set in Microsoft.CodeAnalysis.LanguageServer -->
-    <SelfContained>false</SelfContained>
     <!-- We don't ship a regular NuGet package for this (it gets included in the Workspaces.MSBuild package directly), but we still need to publish symbols -->
     <IsSymbolPublishingPackage>true</IsSymbolPublishingPackage>
     <!-- Explicitly mark ourselves as AnyCPU; if we don't do this, since this project is an executable targeting net472, the SDK has logic that assumes we're targeting Windows
@@ -47,6 +45,7 @@
     <PackageReference Include="System.Collections.Immutable" />
     <PackageReference Include="Newtonsoft.Json" />
     <PackageReference Include="Microsoft.IO.Redist" Condition="'$(TargetFrameworkIdentifier)' != '.NETCoreApp'" />
+    <PackageReference Include="System.Text.Json" Condition="'$(TargetFrameworkIdentifier)' != '.NETCoreApp'" />
     <PackageReference Include="System.Threading.Tasks.Extensions" Condition="'$(TargetFrameworkIdentifier)' != '.NETCoreApp'" />
   </ItemGroup>
   <ItemGroup>
@@ -80,18 +79,15 @@
     <PublicAPI Include="PublicAPI.Shipped.txt" />
     <PublicAPI Include="PublicAPI.Unshipped.txt" />
   </ItemGroup>
-  
+
   <ItemGroup>
-    <InternalsVisibleTo Include="Microsoft.CodeAnalysis.LanguageServer" />
-    <InternalsVisibleTo Include="Microsoft.CodeAnalysis.Workspaces.MSBuild" />
     <InternalsVisibleTo Include="Microsoft.CodeAnalysis.Workspaces.MSBuild.UnitTests" />
-    <InternalsVisibleTo Include="DynamicProxyGenAssembly2" Key="$(MoqPublicKey)" LoadsWithinVisualStudio="false" />
   </ItemGroup>
-  
+
   <ItemGroup>
     <None Include="Rpc\Readme.md" />
   </ItemGroup>
-  
+
   <ItemGroup>
     <EmbeddedResource Update="WorkspaceMSBuildBuildHostResources.resx" GenerateSource="true" />
   </ItemGroup>
@@ -110,5 +106,6 @@
   <Import Project="..\..\..\Dependencies\PooledObjects\Microsoft.CodeAnalysis.PooledObjects.projitems" Label="Shared" />
   <Import Project="..\..\..\Dependencies\Collections\Microsoft.CodeAnalysis.Collections.projitems" Label="Shared" />
   <Import Project="..\..\..\Dependencies\Contracts\Microsoft.CodeAnalysis.Contracts.projitems" Label="Shared" />
-  <Import Project="$(RepositoryEngineeringDir)targets\PackageDownloadAndReference.targets" />
+  <Import Project="$(RepositoryEngineeringDir)targets\PackageDownloadAndReference.targets"/>
+  <Import Project="..\Shared\WorkspacesMSBuildShared.projitems" Label="Shared" />
 </Project>
diff --git a/src/Workspaces/MSBuild/BuildHost/Program.cs b/src/Workspaces/MSBuild/BuildHost/Program.cs
index 6f12720481727..79a032dc0f6c2 100644
--- a/src/Workspaces/MSBuild/BuildHost/Program.cs
+++ b/src/Workspaces/MSBuild/BuildHost/Program.cs
@@ -51,6 +51,10 @@ internal static async Task Main(string[] args)
 
         var pipeServer = NamedPipeUtil.CreateServer(pipeName, PipeDirection.InOut);
         await pipeServer.WaitForConnectionAsync().ConfigureAwait(false);
+        if (!NamedPipeUtil.CheckClientElevationMatches(pipeServer))
+        {
+            throw new Exception("Ownership of BuildHost pipe client is incorrect.");
+        }
 
         var server = new RpcServer(pipeServer);
 
diff --git a/src/Workspaces/MSBuild/BuildHost/SolutionFilterReader.cs b/src/Workspaces/MSBuild/BuildHost/SolutionFilterReader.cs
new file mode 100644
index 0000000000000..6f54c123f13a5
--- /dev/null
+++ b/src/Workspaces/MSBuild/BuildHost/SolutionFilterReader.cs
@@ -0,0 +1,64 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+using System;
+using System.Collections.Immutable;
+using System.IO;
+using System.Text.Json;
+using Roslyn.Utilities;
+
+namespace Microsoft.CodeAnalysis.MSBuild;
+
+internal static class SolutionFilterReader
+{
+    public static bool IsSolutionFilterFilename(string filename)
+    {
+        return Path.GetExtension(filename).Equals(".slnf", StringComparison.OrdinalIgnoreCase);
+    }
+
+    private static string GetAbsolutePath(string path, string baseDirectory)
+        => FileUtilities.NormalizeAbsolutePath(FileUtilities.ResolveRelativePath(path, baseDirectory) ?? path);
+
+    public static (string solutionFileName, ImmutableHashSet<string> projects) Read(string filterFilename)
+    {
+        using var document = JsonDocument.Parse(File.ReadAllText(filterFilename));
+        var solution = document.RootElement.GetProperty("solution");
+        // Convert directory separators to the platform's default, since that is what MSBuild provide us.
+        var solutionPath = solution.GetProperty("path").GetString()?.Replace('\\', Path.DirectorySeparatorChar);
+        if (solutionPath is null)
+            throw new Exception("No solution path found in the solution filter file.");
+
+        if (Path.GetDirectoryName(filterFilename) is not string baseDirectory)
+            throw new Exception("No directory could be found containing the solution filter.");
+
+        var solutionFilename = GetAbsolutePath(solutionPath, baseDirectory);
+
+        if (!File.Exists(solutionFilename))
+            throw new Exception($"The solution file '{solutionFilename}' does not exist.");
+
+        // The base directory for projects is the solution folder.
+        baseDirectory = Path.GetDirectoryName(solutionFilename)!;
+        RoslynDebug.AssertNotNull(baseDirectory);
+
+        var filterProjects = ImmutableHashSet.CreateBuilder<string>(StringComparer.OrdinalIgnoreCase);
+        foreach (var project in solution.GetProperty("projects").EnumerateArray())
+        {
+            // Convert directory separators to the platform's default, since that is what MSBuild provide us.
+            var projectPath = project.GetString()?.Replace('\\', Path.DirectorySeparatorChar);
+            if (projectPath is null)
+            {
+                continue;
+            }
+
+            // Fill the filter with the absolute project paths.
+            var absoluteProjectPath = GetAbsolutePath(projectPath, baseDirectory);
+            if (File.Exists(absoluteProjectPath))
+            {
+                filterProjects.Add(absoluteProjectPath);
+            }
+        }
+
+        return (solutionFilename, filterProjects.ToImmutable());
+    }
+}
diff --git a/src/Workspaces/MSBuild/Core/MSBuild/BuildHostProcessManager.cs b/src/Workspaces/MSBuild/Core/MSBuild/BuildHostProcessManager.cs
index 057a90fafd4bb..e2ee2708a68e9 100644
--- a/src/Workspaces/MSBuild/Core/MSBuild/BuildHostProcessManager.cs
+++ b/src/Workspaces/MSBuild/Core/MSBuild/BuildHostProcessManager.cs
@@ -10,6 +10,7 @@
 using System.IO.Pipes;
 using System.Linq;
 using System.Runtime.InteropServices;
+using System.Security.Principal;
 using System.Text;
 using System.Threading;
 using System.Threading.Tasks;
@@ -62,16 +63,26 @@ public async Task<RemoteBuildHost> GetBuildHostWithFallbackAsync(string projectF
 
         var buildHost = await GetBuildHostAsync(buildHostKind, cancellationToken).ConfigureAwait(false);
 
-        // If this is a .NET Framework build host, we may not have have build tools installed and thus can't actually use it to build.
-        // Check if this is the case. Unlike the mono case, we have to actually ask the other process since MSBuildLocator only allows
-        // us to discover VS instances in .NET Framework hosts right now.
-        if (buildHostKind == BuildHostProcessKind.NetFramework)
+        // We might have a process but we need to check if it actually has a usable MSBuild. In the case of .NET Framework, you also have
+        // to have either Visual Studio or the Build Tools for Visual Studio installed. In the case of .NET Core, you have to have the SDK installed.
+        // Since we can't use MSBuildLocator in-process to discover the other "kinds" of MSBuild instances, we just have to ask the other process.
+        if (buildHostKind is BuildHostProcessKind.NetFramework or BuildHostProcessKind.NetCore)
         {
             if (!await buildHost.HasUsableMSBuildAsync(projectOrSolutionFilePath, cancellationToken).ConfigureAwait(false))
             {
-                // It's not usable, so we'll fall back to the .NET Core one.
-                _logger?.LogWarning($"An installation of Visual Studio or the Build Tools for Visual Studio could not be found; {projectOrSolutionFilePath} will be loaded with the .NET Core SDK and may encounter errors.");
-                return (await GetBuildHostAsync(BuildHostProcessKind.NetCore, cancellationToken).ConfigureAwait(false), actualKind: BuildHostProcessKind.NetCore);
+                if (buildHostKind == BuildHostProcessKind.NetCore)
+                {
+                    buildHostKind = GetKindForNetFrameworkCompatibleDependingOnOperatingSystem();
+                    _logger?.LogWarning($"An installation of the .NET SDK could not be found; {projectOrSolutionFilePath} will be loaded with the .NET Framework and may encounter errors.");
+
+                }
+                else
+                {
+                    buildHostKind = BuildHostProcessKind.NetCore;
+                    _logger?.LogWarning($"An installation of Visual Studio or the Build Tools for Visual Studio could not be found; {projectOrSolutionFilePath} will be loaded with the .NET Core SDK and may encounter errors.");
+                }
+
+                return (await GetBuildHostAsync(buildHostKind, cancellationToken).ConfigureAwait(false), actualKind: buildHostKind);
             }
         }
 
@@ -286,6 +297,29 @@ private static void AddArgument(ProcessStartInfo processStartInfo, string argume
         DtdProcessing = DtdProcessing.Prohibit,
     };
 
+    /// <summary>
+    /// Returns either .NET Framework or Mono depending on the operating system.
+    /// </summary>
+    private static BuildHostProcessKind GetKindForNetFrameworkCompatibleDependingOnOperatingSystem()
+    {
+        return RuntimeInformation.IsOSPlatform(OSPlatform.Windows) ? BuildHostProcessKind.NetFramework : BuildHostProcessKind.Mono;
+    }
+
+    /// <summary>
+    /// Returns a kind that matches the current process.
+    /// </summary>
+    /// <remarks>
+    /// There's a few times when we want to create a build host process, but we don't actually need it to be a specific kind; in this case if we know we're running on .NET Core
+    /// or .NET Framework, we can just use that kind rather than trying to use the other kind and discovering that doesn't work.
+    /// </remarks>
+    public static BuildHostProcessKind GetKindForCurrentProcess()
+    {
+        if (RuntimeInformation.FrameworkDescription.StartsWith(".NET Framework"))
+            return GetKindForNetFrameworkCompatibleDependingOnOperatingSystem();
+        else
+            return BuildHostProcessKind.NetCore;
+    }
+
     public static BuildHostProcessKind GetKindForProject(string projectFilePath)
     {
         // In Source Build builds, we don't have a net472 host at all, so the answer is simple. We unfortunately can't create a net472 build because there's no
@@ -298,8 +332,6 @@ public static BuildHostProcessKind GetKindForProject(string projectFilePath)
         // we'll load the XML of the project directly, and inspect for certain elements.
         XDocument document;
 
-        var frameworkHostType = RuntimeInformation.IsOSPlatform(OSPlatform.Windows) ? BuildHostProcessKind.NetFramework : BuildHostProcessKind.Mono;
-
         try
         {
             // Read the XML, prohibiting DTD processing due the the usual security concerns there.
@@ -312,11 +344,7 @@ public static BuildHostProcessKind GetKindForProject(string projectFilePath)
             // We were unable to read the file; rather than having callers of the build process manager have to deal with this special case
             // we'll instead just give them a host that corresponds to what they are running as; we know that host unquestionably exists
             // and the rest of the code can deal with this cleanly.
-#if NET
-            return BuildHostProcessKind.NetCore;
-#else
-            return frameworkHostType;
-#endif
+            return GetKindForCurrentProcess();
         }
 
         // If we don't have a root, doesn't really matter which. This project is just malformed.
@@ -341,7 +369,7 @@ public static BuildHostProcessKind GetKindForProject(string projectFilePath)
             return BuildHostProcessKind.NetCore;
 
         // Nothing that indicates it's an SDK-style project, so use our .NET framework host
-        return frameworkHostType;
+        return GetKindForNetFrameworkCompatibleDependingOnOperatingSystem();
 
 #endif
     }
@@ -382,9 +410,10 @@ public BuildHostProcess(Process process, string pipeName, ILoggerFactory? logger
 
             _process.ErrorDataReceived += Process_ErrorDataReceived;
 
-            var pipeClient = NamedPipeUtil.CreateClient(".", pipeName, PipeDirection.InOut, PipeOptions.Asynchronous);
+            // Inlined NamedPipeUtil.CreateClient because it does not support netstandard tfm due to using runtime specific functionality.
+            var pipeClient = new NamedPipeClientStream(".", GetPipeNameOrPath(pipeName), PipeDirection.InOut, GetPipeOptions());
             pipeClient.Connect(TimeOutMsNewProcess);
-            if (!NamedPipeUtil.CheckPipeConnectionOwnership(pipeClient))
+            if (!CheckPipeConnectionOwnership(pipeClient))
             {
                 throw new Exception("Ownership of BuildHost pipe is incorrect.");
             }
@@ -396,6 +425,44 @@ public BuildHostProcess(Process process, string pipeName, ILoggerFactory? logger
 
             // Call this last so our type is fully constructed before we start firing events
             _process.BeginErrorReadLine();
+
+            static string GetPipeNameOrPath(string pipeName) => PlatformInformation.IsUnix
+                ? Path.Combine("/tmp", pipeName)
+                : pipeName;
+
+            static PipeOptions GetPipeOptions()
+            {
+                const int CurrentUserOnlyValue = 0x20000000;
+
+                // Mono supports CurrentUserOnly even though it's not exposed on the reference assemblies for net472. This
+                // must be used because ACL security does not work.
+                return PlatformInformation.IsRunningOnMono || IsNetCore()
+                    ? PipeOptions.Asynchronous | (PipeOptions)CurrentUserOnlyValue
+                    : PipeOptions.Asynchronous;
+            }
+
+            // Check if the runtime is .NET 5 or higher.
+            // This method is borrowed from https://github.com/dotnet/runtime/blob/7e9343be8e693f23d8a7a5c00d6f668668dc7769/src/libraries/Common/tests/TestUtilities/System/PlatformDetection.cs#L29
+            static bool IsNetCore() => Environment.Version.Major >= 5
+                || RuntimeInformation.FrameworkDescription.StartsWith(".NET Core", StringComparison.OrdinalIgnoreCase);
+
+            // Check to ensure that the named pipe server we connected to is owned by the same
+            // user.
+            static bool CheckPipeConnectionOwnership(NamedPipeClientStream pipeStream)
+            {
+                if (PlatformInformation.IsWindows && !IsNetCore())
+                {
+                    var currentIdentity = WindowsIdentity.GetCurrent();
+                    var currentOwner = currentIdentity.Owner!;
+                    var remotePipeSecurity = pipeStream.GetAccessControl();
+                    var remoteOwner = remotePipeSecurity.GetOwner(typeof(SecurityIdentifier));
+                    return currentOwner.Equals(remoteOwner);
+                }
+
+                // Client side validation isn't necessary on NetCore or supported on Unix. The model relies on
+                // the server side security here.
+                return true;
+            }
         }
 
         private void Process_Exited(object? sender, EventArgs e)
diff --git a/src/Workspaces/MSBuild/Core/MSBuild/MSBuildProjectLoader.SolutionFilterReader.cs b/src/Workspaces/MSBuild/Core/MSBuild/MSBuildProjectLoader.SolutionFilterReader.cs
deleted file mode 100644
index 56186e3b66f35..0000000000000
--- a/src/Workspaces/MSBuild/Core/MSBuild/MSBuildProjectLoader.SolutionFilterReader.cs
+++ /dev/null
@@ -1,85 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-// See the LICENSE file in the project root for more information.
-
-using System;
-using System.Collections.Immutable;
-using System.Diagnostics.CodeAnalysis;
-using System.IO;
-using System.Text.Json;
-using Roslyn.Utilities;
-
-namespace Microsoft.CodeAnalysis.MSBuild
-{
-    public partial class MSBuildProjectLoader
-    {
-        private static class SolutionFilterReader
-        {
-            public static bool IsSolutionFilterFilename(string filename)
-            {
-                return Path.GetExtension(filename).Equals(".slnf", StringComparison.OrdinalIgnoreCase);
-            }
-
-            public static bool TryRead(string filterFilename, PathResolver pathResolver, [NotNullWhen(true)] out string? solutionFilename, out ImmutableHashSet<string> projectFilter)
-            {
-                try
-                {
-                    using var document = JsonDocument.Parse(File.ReadAllText(filterFilename));
-                    var solution = document.RootElement.GetProperty("solution");
-                    // Convert directory separators to the platform's default, since that is what MSBuild provide us.
-                    var solutionPath = solution.GetProperty("path").GetString()?.Replace('\\', Path.DirectorySeparatorChar);
-                    if (solutionPath is null || Path.GetDirectoryName(filterFilename) is not string baseDirectory)
-                    {
-                        solutionFilename = string.Empty;
-                        projectFilter = [];
-                        return false;
-                    }
-
-                    if (!pathResolver.TryGetAbsoluteSolutionPath(solutionPath, baseDirectory, DiagnosticReportingMode.Throw, out solutionFilename))
-                    {
-                        // TryGetAbsoluteSolutionPath should throw before we get here.
-                        solutionFilename = string.Empty;
-                        projectFilter = [];
-                        return false;
-                    }
-
-                    if (!File.Exists(solutionFilename))
-                    {
-                        projectFilter = [];
-                        return false;
-                    }
-
-                    // The base directory for projects is the solution folder.
-                    baseDirectory = Path.GetDirectoryName(solutionFilename)!;
-                    RoslynDebug.AssertNotNull(baseDirectory);
-
-                    var filterProjects = ImmutableHashSet.CreateBuilder<string>(StringComparer.OrdinalIgnoreCase);
-                    foreach (var project in solution.GetProperty("projects").EnumerateArray())
-                    {
-                        // Convert directory separators to the platform's default, since that is what MSBuild provide us.
-                        var projectPath = project.GetString()?.Replace('\\', Path.DirectorySeparatorChar);
-                        if (projectPath is null)
-                        {
-                            continue;
-                        }
-
-                        // Fill the filter with the absolute project paths.
-                        if (pathResolver.TryGetAbsoluteProjectPath(projectPath, baseDirectory, DiagnosticReportingMode.Throw, out var absoluteProjectPath))
-                        {
-                            filterProjects.Add(absoluteProjectPath);
-                        }
-                    }
-
-                    projectFilter = filterProjects.ToImmutable();
-                    return true;
-                }
-                catch
-                {
-                    solutionFilename = string.Empty;
-                    projectFilter = [];
-                    return false;
-                }
-            }
-        }
-    }
-}
diff --git a/src/Workspaces/MSBuild/Core/MSBuild/MSBuildProjectLoader.cs b/src/Workspaces/MSBuild/Core/MSBuild/MSBuildProjectLoader.cs
index 50971a42caf27..8932ce68f605b 100644
--- a/src/Workspaces/MSBuild/Core/MSBuild/MSBuildProjectLoader.cs
+++ b/src/Workspaces/MSBuild/Core/MSBuild/MSBuildProjectLoader.cs
@@ -173,55 +173,31 @@ public async Task<SolutionInfo> LoadSolutionInfoAsync(
                 return null!;
             }
 
-            var projectFilter = ImmutableHashSet<string>.Empty;
-            if (SolutionFilterReader.IsSolutionFilterFilename(absoluteSolutionPath) &&
-                !SolutionFilterReader.TryRead(absoluteSolutionPath, _pathResolver, out absoluteSolutionPath, out projectFilter))
-            {
-                throw new Exception(string.Format(WorkspaceMSBuildResources.Failed_to_load_solution_filter_0, solutionFilePath));
-            }
-
             using (_dataGuard.DisposableWait(cancellationToken))
             {
                 this.SetSolutionProperties(absoluteSolutionPath);
             }
 
-            var solutionFile = MSB.Construction.SolutionFile.Parse(absoluteSolutionPath);
             var reportingMode = GetReportingModeForUnrecognizedProjects();
 
             var reportingOptions = new DiagnosticReportingOptions(
                 onPathFailure: reportingMode,
                 onLoaderFailure: reportingMode);
 
-            var projectPaths = ImmutableArray.CreateBuilder<string>();
-
-            // load all the projects
-            foreach (var project in solutionFile.ProjectsInOrder)
-            {
-                cancellationToken.ThrowIfCancellationRequested();
-
-                if (project.ProjectType == MSB.Construction.SolutionProjectType.SolutionFolder)
-                {
-                    continue;
-                }
-
-                // Load project if we have an empty project filter and the project path is present.
-                if (projectFilter.IsEmpty ||
-                    projectFilter.Contains(project.AbsolutePath))
-                {
-                    projectPaths.Add(project.RelativePath);
-                }
-            }
-
             var buildHostProcessManager = new BuildHostProcessManager(Properties, loggerFactory: _loggerFactory);
             await using var _ = buildHostProcessManager.ConfigureAwait(false);
 
+            // load all the projects
+            var (buildHostForSolution, _) = await buildHostProcessManager.GetBuildHostWithFallbackAsync(BuildHostProcessManager.GetKindForCurrentProcess(), absoluteSolutionPath, cancellationToken).ConfigureAwait(false);
+            var projectsInSolution = await buildHostForSolution.GetProjectsInSolutionAsync(absoluteSolutionPath, cancellationToken).ConfigureAwait(false);
+
             var worker = new Worker(
                 _solutionServices,
                 _diagnosticReporter,
                 _pathResolver,
                 _projectFileExtensionRegistry,
                 buildHostProcessManager,
-                projectPaths.ToImmutable(),
+                projectsInSolution.SelectAsArray(static p => p.ProjectPath),
                 // TryGetAbsoluteSolutionPath should not return an invalid path
                 baseDirectory: Path.GetDirectoryName(absoluteSolutionPath)!,
                 Properties,
diff --git a/src/Workspaces/MSBuild/Core/Microsoft.CodeAnalysis.Workspaces.MSBuild.csproj b/src/Workspaces/MSBuild/Core/Microsoft.CodeAnalysis.Workspaces.MSBuild.csproj
index 0b4d11ad2192c..9fcd7d8407f07 100644
--- a/src/Workspaces/MSBuild/Core/Microsoft.CodeAnalysis.Workspaces.MSBuild.csproj
+++ b/src/Workspaces/MSBuild/Core/Microsoft.CodeAnalysis.Workspaces.MSBuild.csproj
@@ -4,7 +4,7 @@
   <PropertyGroup>
     <OutputType>Library</OutputType>
     <RootNamespace>Microsoft.CodeAnalysis.MSBuild</RootNamespace>
-    <TargetFrameworks>$(NetRoslynSourceBuild);net472</TargetFrameworks>
+    <TargetFrameworks>$(NetRoslynSourceBuild);netstandard2.0</TargetFrameworks>
     <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
     <!-- NuGet -->
     <IsPackable>true</IsPackable>
@@ -22,21 +22,13 @@
     </PackageDescription>
   </PropertyGroup>
   <ItemGroup>
-    <PackageReference Include="Microsoft.Build" />
-    <PackageReference Include="Microsoft.Build.Tasks.Core" />
+    <PackageReference Include="Microsoft.Build.Framework" />
     <PackageReference Include="Microsoft.Extensions.Logging" />
+    <PackageReference Include="System.IO.Pipes.AccessControl" />
     <PackageReference Include="Newtonsoft.Json" />
   </ItemGroup>
   <ItemGroup>
     <ProjectReference Include="..\..\Core\Portable\Microsoft.CodeAnalysis.Workspaces.csproj" />
-
-    <!-- For the following package we directly include the binary into this NuGet package because we don't want/need a separate NuGet package
-         for it. PrivateAssets="all" is needed to prevent this reference from becoming a package reference in the package, as a workaround for
-         https://github.com/NuGet/Home/issues/3891.
-         -->
-    <ProjectReference Include="..\BuildHost\Microsoft.CodeAnalysis.Workspaces.MSBuild.BuildHost.csproj" PrivateAssets="all" ReferenceOutputAssembly="false">
-      <IncludeOutputInThisPackage>true</IncludeOutputInThisPackage>
-    </ProjectReference>
     <ProjectReference Include="..\..\..\Tools\ExternalAccess\RazorCompiler\Microsoft.CodeAnalysis.ExternalAccess.RazorCompiler.csproj" PrivateAssets="all">
       <IncludeOutputInThisPackage>true</IncludeOutputInThisPackage>
     </ProjectReference>
@@ -49,9 +41,9 @@
     <Compile Include="..\..\..\Compilers\Shared\GlobalAssemblyCacheHelpers\GlobalAssemblyCacheLocation.cs">
       <Link>InternalUtilities\GlobalAssemblyCache.cs</Link>
     </Compile>
-    <Compile Include="..\..\..\Compilers\Shared\NamedPipeUtil.cs" Link="InternalUtilities\NamedPipeUtil.cs" />
     <Compile Include="..\BuildHost\Rpc\Contracts\*.cs" Link="Rpc\Contracts\%(FileName).cs"/>
   </ItemGroup>
+  <Import Project="..\Shared\WorkspacesMSBuildShared.projitems" Label="Shared" />
   <ItemGroup>
     <None Include="..\BuildHost\Rpc\Readme.md" Link="Rpc\Readme.md" />
   </ItemGroup>
@@ -64,18 +56,6 @@
     <InternalsVisibleTo Include="Microsoft.CodeAnalysis.Workspaces.MSBuild.UnitTests" />
     <InternalsVisibleTo Include="DynamicProxyGenAssembly2" Key="$(MoqPublicKey)" LoadsWithinVisualStudio="false" />
   </ItemGroup>
-  <!--
-    Include certain project reference binaries into this package in lib/ regular library.
-    -->
-  <PropertyGroup>
-    <TargetsForTfmSpecificBuildOutput>$(TargetsForTfmSpecificBuildOutput);GetAdditionalBinariesToPackage</TargetsForTfmSpecificBuildOutput>
-  </PropertyGroup>
-  <Target Name="GetAdditionalBinariesToPackage" DependsOnTargets="ResolveReferences">
-    <ItemGroup>
-      <BuildOutputInPackage Include="@(ReferencePath)" Condition="'%(ReferencePath.IncludeOutputInThisPackage)' == 'true'" />
-    </ItemGroup>
-  </Target>
-
   <!--
     Deploy a net472 and $(NetRoslynBuildHostNetCoreVersion) version of the BuildHost process which will be used depending on the type of project. We will use the deployed version even if
     it matches the runtime type of the caller of MSBuildWorkspace since we still need the separate process for dependency isolation and in the case of the .NET Core
diff --git a/src/Workspaces/MSBuild/Core/Rpc/RpcClient.cs b/src/Workspaces/MSBuild/Core/Rpc/RpcClient.cs
index cc93ceb6ba251..42095623efe52 100644
--- a/src/Workspaces/MSBuild/Core/Rpc/RpcClient.cs
+++ b/src/Workspaces/MSBuild/Core/Rpc/RpcClient.cs
@@ -20,7 +20,7 @@ namespace Microsoft.CodeAnalysis.MSBuild;
 /// </summary>
 /// <remarks>
 /// The RPC system implemented here is pretty close to something like JSON-RPC; however since we need the Build Host to be usable in Source Build
-/// scenarios, we are limited to using only what is either in .NET or can be easily made buildable in Source Build. Thus existing solutions like StreamJsonRpc 
+/// scenarios, we are limited to using only what is either in .NET or can be easily made buildable in Source Build. Thus existing solutions like StreamJsonRpc
 /// are out. If at some point there is a standard RPC mechanism exposed in .NET or Source Build, we should delete this and use that instead.
 /// </remarks>
 internal sealed class RpcClient
diff --git a/src/Workspaces/MSBuild/BuildHost/Rpc/Contracts/DiagnosticLogItem.cs b/src/Workspaces/MSBuild/Shared/Rpc/DiagnosticLogItem.cs
similarity index 100%
rename from src/Workspaces/MSBuild/BuildHost/Rpc/Contracts/DiagnosticLogItem.cs
rename to src/Workspaces/MSBuild/Shared/Rpc/DiagnosticLogItem.cs
diff --git a/src/Workspaces/MSBuild/BuildHost/Rpc/Contracts/DocumentFileInfo.cs b/src/Workspaces/MSBuild/Shared/Rpc/DocumentFileInfo.cs
similarity index 99%
rename from src/Workspaces/MSBuild/BuildHost/Rpc/Contracts/DocumentFileInfo.cs
rename to src/Workspaces/MSBuild/Shared/Rpc/DocumentFileInfo.cs
index a040cce7fbdfd..3aa4c6d60aad4 100644
--- a/src/Workspaces/MSBuild/BuildHost/Rpc/Contracts/DocumentFileInfo.cs
+++ b/src/Workspaces/MSBuild/Shared/Rpc/DocumentFileInfo.cs
@@ -28,7 +28,7 @@ internal sealed class DocumentFileInfo(string filePath, string logicalPath, bool
         public string LogicalPath { get; } = logicalPath;
 
         /// <summary>
-        /// True if the document has a logical path that differs from its 
+        /// True if the document has a logical path that differs from its
         /// absolute file path.
         /// </summary>
         [DataMember(Order = 2)]
diff --git a/src/Workspaces/MSBuild/BuildHost/Rpc/Contracts/FileGlobs.cs b/src/Workspaces/MSBuild/Shared/Rpc/FileGlobs.cs
similarity index 100%
rename from src/Workspaces/MSBuild/BuildHost/Rpc/Contracts/FileGlobs.cs
rename to src/Workspaces/MSBuild/Shared/Rpc/FileGlobs.cs
diff --git a/src/Workspaces/MSBuild/BuildHost/Rpc/Contracts/IBuildHost.cs b/src/Workspaces/MSBuild/Shared/Rpc/IBuildHost.cs
similarity index 100%
rename from src/Workspaces/MSBuild/BuildHost/Rpc/Contracts/IBuildHost.cs
rename to src/Workspaces/MSBuild/Shared/Rpc/IBuildHost.cs
diff --git a/src/Workspaces/MSBuild/BuildHost/Rpc/Contracts/IProjectFile.cs b/src/Workspaces/MSBuild/Shared/Rpc/IProjectFile.cs
similarity index 100%
rename from src/Workspaces/MSBuild/BuildHost/Rpc/Contracts/IProjectFile.cs
rename to src/Workspaces/MSBuild/Shared/Rpc/IProjectFile.cs
diff --git a/src/Workspaces/MSBuild/BuildHost/Rpc/Contracts/JsonSettings.cs b/src/Workspaces/MSBuild/Shared/Rpc/JsonSettings.cs
similarity index 100%
rename from src/Workspaces/MSBuild/BuildHost/Rpc/Contracts/JsonSettings.cs
rename to src/Workspaces/MSBuild/Shared/Rpc/JsonSettings.cs
diff --git a/src/Workspaces/MSBuild/BuildHost/Rpc/Contracts/PackageReference.cs b/src/Workspaces/MSBuild/Shared/Rpc/PackageReference.cs
similarity index 100%
rename from src/Workspaces/MSBuild/BuildHost/Rpc/Contracts/PackageReference.cs
rename to src/Workspaces/MSBuild/Shared/Rpc/PackageReference.cs
diff --git a/src/Workspaces/MSBuild/BuildHost/Rpc/Contracts/ProjectFileInfo.cs b/src/Workspaces/MSBuild/Shared/Rpc/ProjectFileInfo.cs
similarity index 96%
rename from src/Workspaces/MSBuild/BuildHost/Rpc/Contracts/ProjectFileInfo.cs
rename to src/Workspaces/MSBuild/Shared/Rpc/ProjectFileInfo.cs
index f792098d8f47b..88e857a70ca25 100644
--- a/src/Workspaces/MSBuild/BuildHost/Rpc/Contracts/ProjectFileInfo.cs
+++ b/src/Workspaces/MSBuild/Shared/Rpc/ProjectFileInfo.cs
@@ -54,13 +54,13 @@ internal sealed class ProjectFileInfo
 
         /// <summary>
         /// The default namespace of the project ("" if not defined, which means global namespace),
-        /// or null if it is unknown or not applicable. 
+        /// or null if it is unknown or not applicable.
         /// </summary>
         /// <remarks>
-        /// Right now VB doesn't have the concept of "default namespace". But we conjure one in workspace 
-        /// by assigning the value of the project's root namespace to it. So various feature can choose to 
+        /// Right now VB doesn't have the concept of "default namespace". But we conjure one in workspace
+        /// by assigning the value of the project's root namespace to it. So various feature can choose to
         /// use it for their own purpose.
-        /// In the future, we might consider officially exposing "default namespace" for VB project 
+        /// In the future, we might consider officially exposing "default namespace" for VB project
         /// (e.g. through a "defaultnamespace" msbuild property)
         /// </remarks>
         [DataMember]
diff --git a/src/Workspaces/MSBuild/BuildHost/Rpc/Contracts/ProjectFileReference.cs b/src/Workspaces/MSBuild/Shared/Rpc/ProjectFileReference.cs
similarity index 96%
rename from src/Workspaces/MSBuild/BuildHost/Rpc/Contracts/ProjectFileReference.cs
rename to src/Workspaces/MSBuild/Shared/Rpc/ProjectFileReference.cs
index 7a27a20ea17c1..9d118e8a9b1b2 100644
--- a/src/Workspaces/MSBuild/BuildHost/Rpc/Contracts/ProjectFileReference.cs
+++ b/src/Workspaces/MSBuild/Shared/Rpc/ProjectFileReference.cs
@@ -15,7 +15,7 @@ namespace Microsoft.CodeAnalysis.MSBuild
     internal sealed class ProjectFileReference
     {
         /// <summary>
-        /// The path on disk to the other project file. 
+        /// The path on disk to the other project file.
         /// This path may be relative to the referencing project's file or an absolute path.
         /// </summary>
         [DataMember(Order = 0)]
diff --git a/src/Workspaces/MSBuild/BuildHost/Rpc/Contracts/Request.cs b/src/Workspaces/MSBuild/Shared/Rpc/Request.cs
similarity index 100%
rename from src/Workspaces/MSBuild/BuildHost/Rpc/Contracts/Request.cs
rename to src/Workspaces/MSBuild/Shared/Rpc/Request.cs
diff --git a/src/Workspaces/MSBuild/BuildHost/Rpc/Contracts/Response.cs b/src/Workspaces/MSBuild/Shared/Rpc/Response.cs
similarity index 100%
rename from src/Workspaces/MSBuild/BuildHost/Rpc/Contracts/Response.cs
rename to src/Workspaces/MSBuild/Shared/Rpc/Response.cs
diff --git a/src/Workspaces/MSBuild/BuildHost/Rpc/Contracts/MonoMSBuildDiscovery.cs b/src/Workspaces/MSBuild/Shared/Utilities/MonoMSBuildDiscovery.cs
similarity index 99%
rename from src/Workspaces/MSBuild/BuildHost/Rpc/Contracts/MonoMSBuildDiscovery.cs
rename to src/Workspaces/MSBuild/Shared/Utilities/MonoMSBuildDiscovery.cs
index 99a376391a654..19980492868d3 100644
--- a/src/Workspaces/MSBuild/BuildHost/Rpc/Contracts/MonoMSBuildDiscovery.cs
+++ b/src/Workspaces/MSBuild/Shared/Utilities/MonoMSBuildDiscovery.cs
@@ -143,7 +143,7 @@ private static IEnumerable<string> GetSearchPaths()
             if (!monoMSBuildDir.Exists)
                 return null;
 
-            // Inside this is either a Current directory or a 15.0 directory, so find it; the previous code at 
+            // Inside this is either a Current directory or a 15.0 directory, so find it; the previous code at
             // https://github.com/OmniSharp/omnisharp-roslyn/blob/dde8119c40f4e3920eb5ea894cbca047033bd9aa/src/OmniSharp.Host/MSBuild/Discovery/MSBuildInstanceProvider.cs#L48-L58
             // ensured we had a correctly normalized path in case the underlying file system might have been case insensitive.
             var versionDirectory =
diff --git a/src/Workspaces/MSBuild/BuildHost/Rpc/Contracts/TextReaderExtensions.cs b/src/Workspaces/MSBuild/Shared/Utilities/TextReaderExtensions.cs
similarity index 100%
rename from src/Workspaces/MSBuild/BuildHost/Rpc/Contracts/TextReaderExtensions.cs
rename to src/Workspaces/MSBuild/Shared/Utilities/TextReaderExtensions.cs
diff --git a/src/Workspaces/MSBuild/Shared/WorkspacesMSBuildShared.projitems b/src/Workspaces/MSBuild/Shared/WorkspacesMSBuildShared.projitems
new file mode 100644
index 0000000000000..80877b997bfc8
--- /dev/null
+++ b/src/Workspaces/MSBuild/Shared/WorkspacesMSBuildShared.projitems
@@ -0,0 +1,26 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <PropertyGroup>
+    <MSBuildAllProjects Condition="'$(MSBuildVersion)' == '' Or '$(MSBuildVersion)' &lt; '16.0'">$(MSBuildAllProjects);$(MSBuildThisFileFullPath)</MSBuildAllProjects>
+    <HasSharedItems>true</HasSharedItems>
+    <SharedGUID>01a9f592-43bd-4b0d-949b-06dfa1a79599</SharedGUID>
+  </PropertyGroup>
+  <PropertyGroup Label="Configuration">
+    <Import_RootNamespace>Shared</Import_RootNamespace>
+  </PropertyGroup>
+  <ItemGroup>
+    <Compile Include="$(MSBuildThisFileDirectory)Rpc\DiagnosticLogItem.cs" />
+    <Compile Include="$(MSBuildThisFileDirectory)Rpc\DocumentFileInfo.cs" />
+    <Compile Include="$(MSBuildThisFileDirectory)Rpc\FileGlobs.cs" />
+    <Compile Include="$(MSBuildThisFileDirectory)Rpc\IBuildHost.cs" />
+    <Compile Include="$(MSBuildThisFileDirectory)Rpc\IProjectFile.cs" />
+    <Compile Include="$(MSBuildThisFileDirectory)Rpc\JsonSettings.cs" />
+    <Compile Include="$(MSBuildThisFileDirectory)Rpc\PackageReference.cs" />
+    <Compile Include="$(MSBuildThisFileDirectory)Rpc\ProjectFileInfo.cs" />
+    <Compile Include="$(MSBuildThisFileDirectory)Rpc\ProjectFileReference.cs" />
+    <Compile Include="$(MSBuildThisFileDirectory)Rpc\Request.cs" />
+    <Compile Include="$(MSBuildThisFileDirectory)Rpc\Response.cs" />
+    <Compile Include="$(MSBuildThisFileDirectory)Utilities\MonoMSBuildDiscovery.cs" />
+    <Compile Include="$(MSBuildThisFileDirectory)Utilities\TextReaderExtensions.cs" />
+  </ItemGroup>
+</Project>
\ No newline at end of file
diff --git a/src/Workspaces/MSBuild/Shared/WorkspacesMSBuildShared.shproj b/src/Workspaces/MSBuild/Shared/WorkspacesMSBuildShared.shproj
new file mode 100644
index 0000000000000..982513b976ce5
--- /dev/null
+++ b/src/Workspaces/MSBuild/Shared/WorkspacesMSBuildShared.shproj
@@ -0,0 +1,13 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project ToolsVersion="15.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <PropertyGroup Label="Globals">
+    <ProjectGuid>01a9f592-43bd-4b0d-949b-06dfa1a79599</ProjectGuid>
+    <MinimumVisualStudioVersion>14.0</MinimumVisualStudioVersion>
+  </PropertyGroup>
+  <Import Project="$(MSBuildExtensionsPath)\$(MSBuildToolsVersion)\Microsoft.Common.props" Condition="Exists('$(MSBuildExtensionsPath)\$(MSBuildToolsVersion)\Microsoft.Common.props')" />
+  <Import Project="$(MSBuildExtensionsPath32)\Microsoft\VisualStudio\v$(VisualStudioVersion)\CodeSharing\Microsoft.CodeSharing.Common.Default.props" />
+  <Import Project="$(MSBuildExtensionsPath32)\Microsoft\VisualStudio\v$(VisualStudioVersion)\CodeSharing\Microsoft.CodeSharing.Common.props" />
+  <PropertyGroup />
+  <Import Project="WorkspacesMSBuildShared.projitems" Label="Shared" />
+  <Import Project="$(MSBuildExtensionsPath32)\Microsoft\VisualStudio\v$(VisualStudioVersion)\CodeSharing\Microsoft.CodeSharing.CSharp.targets" />
+</Project>
diff --git a/src/Workspaces/MSBuild/Test/Microsoft.CodeAnalysis.Workspaces.MSBuild.UnitTests.csproj b/src/Workspaces/MSBuild/Test/Microsoft.CodeAnalysis.Workspaces.MSBuild.UnitTests.csproj
index aecbc94604a02..d4d512cf62563 100644
--- a/src/Workspaces/MSBuild/Test/Microsoft.CodeAnalysis.Workspaces.MSBuild.UnitTests.csproj
+++ b/src/Workspaces/MSBuild/Test/Microsoft.CodeAnalysis.Workspaces.MSBuild.UnitTests.csproj
@@ -16,7 +16,8 @@
     <EmbeddedResource Include="Resources\**\*.*" />
   </ItemGroup>
   <ItemGroup>
-    <Compile Include="..\BuildHost\Rpc\RpcServer.cs" Link="Rpc\RpcServer.cs"/>
+    <Compile Include="..\..\..\Compilers\Shared\NamedPipeUtil.cs" Link="Utilities\NamedPipeUtil.cs" />
+    <Compile Include="..\BuildHost\Rpc\RpcServer.cs" Link="Rpc\RpcServer.cs" />
     <Compile Remove="Resources\**\*.*" />
   </ItemGroup>
   <ItemGroup>
diff --git a/src/Workspaces/MSBuild/Test/VisualStudioMSBuildWorkspaceTests.cs b/src/Workspaces/MSBuild/Test/VisualStudioMSBuildWorkspaceTests.cs
index a266d2f7995c8..02cad0b98a8b8 100644
--- a/src/Workspaces/MSBuild/Test/VisualStudioMSBuildWorkspaceTests.cs
+++ b/src/Workspaces/MSBuild/Test/VisualStudioMSBuildWorkspaceTests.cs
@@ -3169,7 +3169,7 @@ public async Task TestOpenSolution_ProjectReferencesWithUnconventionalOutputPath
 
             var solutionFilePath = GetSolutionFileName(@"TestVB2.sln");
 
-            // The reference assemblies for .NETFramework,Version=v3.5 were not found To resolve this, install the Developer Pack 
+            // The reference assemblies for .NETFramework,Version=v3.5 were not found To resolve this, install the Developer Pack
             using var workspace = CreateMSBuildWorkspace(throwOnWorkspaceFailed: false);
             var solution = await workspace.OpenSolutionAsync(solutionFilePath);
 
@@ -3290,7 +3290,7 @@ public async Task TestInvalidSolutionFilterDoesNotLoad()
             var solutionFilePath = GetSolutionFileName(@"InvalidSolutionFilter.slnf");
 
             using var workspace = CreateMSBuildWorkspace();
-            var exception = await Assert.ThrowsAsync<Exception>(() => workspace.OpenSolutionAsync(solutionFilePath));
+            var exception = await Assert.ThrowsAnyAsync<Exception>(() => workspace.OpenSolutionAsync(solutionFilePath));
 
             Assert.Equal(0, workspace.CurrentSolution.ProjectIds.Count);
         }