diff --git a/azure-pipelines-integration-scouting.yml b/azure-pipelines-integration-scouting.yml
index 346f4dbfe0d38..2c95d62c434db 100644
--- a/azure-pipelines-integration-scouting.yml
+++ b/azure-pipelines-integration-scouting.yml
@@ -9,6 +9,7 @@ schedules:
   branches:
     include:
     - main
+    exclude:
     - main-vs-deps
 
 variables:
diff --git a/azure-pipelines-integration.yml b/azure-pipelines-integration.yml
index afddf6a20c094..c3d9607fa8cca 100644
--- a/azure-pipelines-integration.yml
+++ b/azure-pipelines-integration.yml
@@ -3,11 +3,12 @@ trigger:
   branches:
     include:
     - main
-    - main-vs-deps
     - release/*
     - features/*
     - demos/*
     exclude:
+    - main-vs-deps
+    - release/dev18.0
     # Since the version of VS on the integration VM images are a moving target,
     # we are unable to reliably run integration tests on servicing branches.
     - release/dev17.8
@@ -19,11 +20,11 @@ pr:
   branches:
     include:
     - main
-    - main-vs-deps
     - release/*
     - features/*
     - demos/*
     exclude:
+    - main-vs-deps
     # Since the version of VS on the integration VM images are a moving target,
     # we are unable to reliably run integration tests on servicing branches.
     - release/dev17.8
diff --git a/eng/Versions.props b/eng/Versions.props
index 1b9a360b33402..4e753f3df38a0 100644
--- a/eng/Versions.props
+++ b/eng/Versions.props
@@ -6,9 +6,9 @@
   -->
   <PropertyGroup>
     <MajorVersion>4</MajorVersion>
-    <MinorVersion>14</MinorVersion>
+    <MinorVersion>15</MinorVersion>
     <PatchVersion>0</PatchVersion>
-    <PreReleaseVersionLabel>3</PreReleaseVersionLabel>
+    <PreReleaseVersionLabel>1</PreReleaseVersionLabel>
     <VersionPrefix>$(MajorVersion).$(MinorVersion).$(PatchVersion)</VersionPrefix>
     <!--
       By default the assembly version in official builds is "$(MajorVersion).$(MinorVersion).0.0".
diff --git a/eng/pipelines/test-integration-helix.yml b/eng/pipelines/test-integration-helix.yml
index 606d675c72751..4709be392b8a2 100644
--- a/eng/pipelines/test-integration-helix.yml
+++ b/eng/pipelines/test-integration-helix.yml
@@ -33,6 +33,7 @@ stages:
       buildArguments: -msbuildEngine vs /p:Projects='"$(Build.Repository.LocalPath)\src\VisualStudio\IntegrationTest\IntegrationTestBuildProject.csproj"'
 
 - stage: ${{ parameters.configuration }}_Integration
+  condition: and(succeeded(), notIn(variables['System.PullRequest.TargetBranchName'], 'main-vs-deps', 'release/dev18.0'))
   dependsOn: Windows_${{ parameters.configuration }}_Build
   variables:
   - name: XUNIT_LOGS
diff --git a/src/VisualStudio/CSharp/Impl/CSharpPackage.cs b/src/VisualStudio/CSharp/Impl/CSharpPackage.cs
index be4d8b5ee2bf5..4be646d2ac30f 100644
--- a/src/VisualStudio/CSharp/Impl/CSharpPackage.cs
+++ b/src/VisualStudio/CSharp/Impl/CSharpPackage.cs
@@ -58,13 +58,17 @@ internal sealed class CSharpPackage : AbstractPackage<CSharpPackage, CSharpLangu
         private ObjectBrowserLibraryManager? _libraryManager;
         private uint _libraryManagerCookie;
 
-        protected override async Task InitializeAsync(CancellationToken cancellationToken, IProgress<ServiceProgressData> progress)
+        protected override void RegisterInitializationWork(PackageRegistrationTasks packageRegistrationTasks)
+        {
+            base.RegisterInitializationWork(packageRegistrationTasks);
+
+            packageRegistrationTasks.AddTask(isMainThreadTask: false, task: PackageInitializationBackgroundThreadAsync);
+        }
+
+        private Task PackageInitializationBackgroundThreadAsync(IProgress<ServiceProgressData> progress, PackageRegistrationTasks packageRegistrationTasks, CancellationToken cancellationToken)
         {
             try
             {
-                await base.InitializeAsync(cancellationToken, progress).ConfigureAwait(true);
-                await JoinableTaskFactory.SwitchToMainThreadAsync(cancellationToken);
-
                 this.RegisterService<ICSharpTempPECompilerService>(async ct =>
                 {
                     var workspace = this.ComponentModel.GetService<VisualStudioWorkspace>();
@@ -75,6 +79,8 @@ protected override async Task InitializeAsync(CancellationToken cancellationToke
             catch (Exception e) when (FatalError.ReportAndPropagateUnlessCanceled(e, ErrorSeverity.General))
             {
             }
+
+            return Task.CompletedTask;
         }
 
         protected override void RegisterObjectBrowserLibraryManager()
diff --git a/src/VisualStudio/Core/Def/ColorSchemes/ColorSchemeApplier.cs b/src/VisualStudio/Core/Def/ColorSchemes/ColorSchemeApplier.cs
index 04e21d0fe143c..c4e60eaf3b735 100644
--- a/src/VisualStudio/Core/Def/ColorSchemes/ColorSchemeApplier.cs
+++ b/src/VisualStudio/Core/Def/ColorSchemes/ColorSchemeApplier.cs
@@ -14,11 +14,9 @@
 using Microsoft.CodeAnalysis.Options;
 using Microsoft.CodeAnalysis.Shared.TestHooks;
 using Microsoft.CodeAnalysis.Threading;
-using Microsoft.VisualStudio;
+using Microsoft.VisualStudio.LanguageServices.Implementation.LanguageService;
 using Microsoft.VisualStudio.Settings;
 using Microsoft.VisualStudio.Shell;
-using Microsoft.VisualStudio.Shell.Interop;
-using Microsoft.VisualStudio.Threading;
 using Task = System.Threading.Tasks.Task;
 
 namespace Microsoft.CodeAnalysis.ColorSchemes;
@@ -42,7 +40,6 @@ internal sealed partial class ColorSchemeApplier
     [Obsolete(MefConstruction.ImportingConstructorMessage, error: true)]
     public ColorSchemeApplier(
         IThreadingContext threadingContext,
-        IVsService<SVsFontAndColorStorage, IVsFontAndColorStorage> fontAndColorStorage,
         IGlobalOptionService globalOptions,
         SVsServiceProvider serviceProvider,
         IAsynchronousOperationListenerProvider listenerProvider)
@@ -60,7 +57,7 @@ public ColorSchemeApplier(
             threadingContext.DisposalToken);
     }
 
-    public async Task InitializeAsync(CancellationToken cancellationToken)
+    public void RegisterInitializationWork(PackageRegistrationTasks packageRegistrationTasks)
     {
         lock (_gate)
         {
@@ -70,15 +67,16 @@ public async Task InitializeAsync(CancellationToken cancellationToken)
             _isInitialized = true;
         }
 
-        // We need to update the theme whenever the Editor Color Scheme setting changes.
-        await TaskScheduler.Default;
+        packageRegistrationTasks.AddTask(isMainThreadTask: false, task: PackageInitializationBackgroundThreadAsync);
+    }
+
+    private async Task PackageInitializationBackgroundThreadAsync(IProgress<ServiceProgressData> progress, PackageRegistrationTasks packageRegistrationTasks, CancellationToken cancellationToken)
+    {
         var settingsManager = await _asyncServiceProvider.GetServiceAsync<SVsSettingsPersistenceManager, ISettingsManager>(_threadingContext.JoinableTaskFactory).ConfigureAwait(false);
 
-        await _threadingContext.JoinableTaskFactory.SwitchToMainThreadAsync(cancellationToken);
+        // We need to update the theme whenever the Editor Color Scheme setting changes.
         settingsManager.GetSubset(ColorSchemeOptionsStorage.ColorSchemeSettingKey).SettingChangedAsync += ColorSchemeChangedAsync;
 
-        await TaskScheduler.Default;
-
         // Try to migrate the `useEnhancedColorsSetting` to the new `ColorSchemeName` setting.
         _settings.MigrateToColorSchemeSetting();
 
diff --git a/src/VisualStudio/Core/Def/Implementation/AbstractOleCommandTarget.Execute.cs b/src/VisualStudio/Core/Def/Implementation/AbstractOleCommandTarget.Execute.cs
index 8fe6698fc9793..a5a1723045c67 100644
--- a/src/VisualStudio/Core/Def/Implementation/AbstractOleCommandTarget.Execute.cs
+++ b/src/VisualStudio/Core/Def/Implementation/AbstractOleCommandTarget.Execute.cs
@@ -35,10 +35,6 @@ public virtual int Exec(ref Guid pguidCmdGroup, uint commandId, uint executeInfo
             {
                 return ExecuteVisualStudio2000(ref pguidCmdGroup, commandId, executeInformation, pvaIn, pvaOut);
             }
-            else if (pguidCmdGroup == VSConstants.GUID_VSStandardCommandSet97)
-            {
-                return ExecuteVisualStudio97(ref pguidCmdGroup, commandId, executeInformation, pvaIn, pvaOut);
-            }
             else
             {
                 return NextCommandTarget.Exec(ref pguidCmdGroup, commandId, executeInformation, pvaIn, pvaOut);
@@ -50,61 +46,8 @@ public virtual int Exec(ref Guid pguidCmdGroup, uint commandId, uint executeInfo
         }
     }
 
-    private int ExecuteVisualStudio97(ref Guid pguidCmdGroup, uint commandId, uint executeInformation, IntPtr pvaIn, IntPtr pvaOut)
-    {
-        switch ((VSConstants.VSStd97CmdID)commandId)
-        {
-            case VSConstants.VSStd97CmdID.Paste:
-            case VSConstants.VSStd97CmdID.Delete:
-            case VSConstants.VSStd97CmdID.SelectAll:
-            case VSConstants.VSStd97CmdID.Undo:
-            case VSConstants.VSStd97CmdID.Redo:
-            case VSConstants.VSStd97CmdID.MultiLevelUndo:
-            case VSConstants.VSStd97CmdID.MultiLevelRedo:
-                GCManager.UseLowLatencyModeForProcessingUserInput();
-                return NextCommandTarget.Exec(ref pguidCmdGroup, commandId, executeInformation, pvaIn, pvaOut);
-
-            default:
-                return NextCommandTarget.Exec(ref pguidCmdGroup, commandId, executeInformation, pvaIn, pvaOut);
-        }
-    }
-
     protected virtual int ExecuteVisualStudio2000(ref Guid pguidCmdGroup, uint commandId, uint executeInformation, IntPtr pvaIn, IntPtr pvaOut)
     {
-        switch ((VSConstants.VSStd2KCmdID)commandId)
-        {
-            case VSConstants.VSStd2KCmdID.TYPECHAR:
-            case VSConstants.VSStd2KCmdID.RETURN:
-            case VSConstants.VSStd2KCmdID.TAB:
-            case VSConstants.VSStd2KCmdID.BACKTAB:
-            case VSConstants.VSStd2KCmdID.HOME:
-            case VSConstants.VSStd2KCmdID.END:
-            case VSConstants.VSStd2KCmdID.BOL:
-            case VSConstants.VSStd2KCmdID.BOL_EXT:
-            case VSConstants.VSStd2KCmdID.EOL:
-            case VSConstants.VSStd2KCmdID.EOL_EXT:
-            case VSConstants.VSStd2KCmdID.SELECTALL:
-            case VSConstants.VSStd2KCmdID.OPENLINEABOVE:
-            case VSConstants.VSStd2KCmdID.OPENLINEBELOW:
-            case VSConstants.VSStd2KCmdID.UP:
-            case VSConstants.VSStd2KCmdID.DOWN:
-            case VSConstants.VSStd2KCmdID.BACKSPACE:
-            case VSConstants.VSStd2KCmdID.DELETE:
-            case VSConstants.VSStd2KCmdID.ECMD_INSERTCOMMENT:
-            case VSConstants.VSStd2KCmdID.COMPLETEWORD:
-            case VSConstants.VSStd2KCmdID.SHOWMEMBERLIST:
-            case VSConstants.VSStd2KCmdID.PARAMINFO:
-            case VSConstants.VSStd2KCmdID.RENAME:
-            case VSConstants.VSStd2KCmdID.EXTRACTINTERFACE:
-            case VSConstants.VSStd2KCmdID.EXTRACTMETHOD:
-            case VSConstants.VSStd2KCmdID.PASTE:
-            case VSConstants.VSStd2KCmdID.INSERTSNIPPET:
-            case VSConstants.VSStd2KCmdID.SURROUNDWITH:
-                GCManager.UseLowLatencyModeForProcessingUserInput();
-                return NextCommandTarget.Exec(ref pguidCmdGroup, commandId, executeInformation, pvaIn, pvaOut);
-
-            default:
-                return NextCommandTarget.Exec(ref pguidCmdGroup, commandId, executeInformation, pvaIn, pvaOut);
-        }
+        return NextCommandTarget.Exec(ref pguidCmdGroup, commandId, executeInformation, pvaIn, pvaOut);
     }
 }
diff --git a/src/VisualStudio/Core/Def/Implementation/GCManager.cs b/src/VisualStudio/Core/Def/Implementation/GCManager.cs
deleted file mode 100644
index efa797441fc1e..0000000000000
--- a/src/VisualStudio/Core/Def/Implementation/GCManager.cs
+++ /dev/null
@@ -1,115 +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.
-
-#nullable disable
-
-using System.Runtime;
-using System.Threading.Tasks;
-using Microsoft.CodeAnalysis.Editor.Shared.Utilities;
-using Microsoft.CodeAnalysis.Shared.TestHooks;
-using Microsoft.VisualStudio.Shell;
-using Microsoft.VisualStudio.Shell.Interop;
-using Roslyn.Utilities;
-
-namespace Microsoft.VisualStudio.LanguageServices.Implementation;
-
-/// <summary>
-/// This class manages setting the GC mode to SustainedLowLatency.
-/// 
-/// It is safe to call from any thread, but is intended to be called from
-/// the UI thread whenever user keyboard or mouse input is received.
-/// </summary>
-internal static class GCManager
-{
-    // The default delay can be overridden by setting <VS Registry>\Performance : SustainedLowLatencyDuration
-    private static int s_delayMilliseconds = 0;
-    private const int DefaultDelayMilliseconds = 5000;
-
-    private static ResettableDelay s_delay;
-
-    static GCManager()
-    {
-        // Allow disabling SustainedLowLatency by setting the reg key value to 0
-        System.Threading.Tasks.Task.Run(() =>
-        {
-            using (var root = VSRegistry.RegistryRoot(__VsLocalRegistryType.RegType_UserSettings))
-            {
-                if (root != null)
-                {
-                    using var key = root.OpenSubKey("Performance");
-                    const string name = "SustainedLowLatencyDuration";
-                    if (key != null && key.GetValue(name) != null && key.GetValueKind(name) == Microsoft.Win32.RegistryValueKind.DWord)
-                    {
-                        s_delayMilliseconds = (int)key.GetValue(name, s_delayMilliseconds);
-                        return;
-                    }
-                }
-            }
-
-            s_delayMilliseconds = DefaultDelayMilliseconds;
-        });
-    }
-
-    /// <summary>
-    /// Turn off low latency GC mode.
-    /// 
-    /// if there is a pending low latency mode request, Latency mode will go back to its original status as
-    /// pending request timeout. once it goes back to its original status, it will not go back to low latency mode again.
-    /// </summary>
-    internal static void TurnOffLowLatencyMode()
-    {
-        // set delay to 0 to turn off the use of sustained low latency
-        s_delayMilliseconds = 0;
-    }
-
-    /// <summary>
-    /// Call this method to suppress expensive blocking Gen 2 garbage GCs in
-    /// scenarios where high-latency is unacceptable (e.g. processing typing input).
-    /// 
-    /// Blocking GCs will be re-enabled automatically after a short duration unless 
-    /// UseLowLatencyModeForProcessingUserInput is called again.
-    /// </summary>
-    internal static void UseLowLatencyModeForProcessingUserInput()
-    {
-        if (s_delayMilliseconds <= 0)
-        {
-            // The registry key to opt out of Roslyn's SustainedLowLatency is set, or
-            // we haven't yet initialized the value.
-            return;
-        }
-
-        var currentMode = GCSettings.LatencyMode;
-        var currentDelay = s_delay;
-        if (currentMode != GCLatencyMode.SustainedLowLatency)
-        {
-            GCSettings.LatencyMode = GCLatencyMode.SustainedLowLatency;
-
-            // Restore the LatencyMode a short duration after the last UseLowLatencyModeForProcessingUserInput.
-            currentDelay = new ResettableDelay(s_delayMilliseconds, AsynchronousOperationListenerProvider.NullListener);
-            RestoreGCLatencyModeWhenCompleteAsync(currentDelay.Task, currentMode).ReportNonFatalErrorAsync();
-            s_delay = currentDelay;
-        }
-
-        currentDelay?.Reset();
-        return;
-
-        async Task RestoreGCLatencyModeWhenCompleteAsync(Task task, GCLatencyMode latencyMode)
-        {
-            try
-            {
-                await task.ConfigureAwait(false);
-            }
-            finally
-            {
-                RestoreGCLatencyMode(latencyMode);
-            }
-        }
-    }
-
-    private static void RestoreGCLatencyMode(GCLatencyMode originalMode)
-    {
-        GCSettings.LatencyMode = originalMode;
-        s_delay = null;
-    }
-}
diff --git a/src/VisualStudio/Core/Def/Implementation/VirtualMemoryNotificationListener.cs b/src/VisualStudio/Core/Def/Implementation/VirtualMemoryNotificationListener.cs
deleted file mode 100644
index dd75a8e9169b7..0000000000000
--- a/src/VisualStudio/Core/Def/Implementation/VirtualMemoryNotificationListener.cs
+++ /dev/null
@@ -1,183 +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.Runtime;
-using System.Threading;
-using System.Threading.Tasks;
-using Microsoft.CodeAnalysis;
-using Microsoft.CodeAnalysis.Editor.Shared.Utilities;
-using Microsoft.CodeAnalysis.ErrorReporting;
-using Microsoft.CodeAnalysis.Host;
-using Microsoft.CodeAnalysis.Internal.Log;
-using Microsoft.CodeAnalysis.Options;
-using Microsoft.CodeAnalysis.SolutionCrawler;
-using Microsoft.CodeAnalysis.Telemetry;
-using Microsoft.VisualStudio.LanguageServices.Implementation;
-using Microsoft.VisualStudio.LanguageServices.Implementation.Utilities;
-using Microsoft.VisualStudio.Shell.Interop;
-using IAsyncServiceProvider = Microsoft.VisualStudio.Shell.IAsyncServiceProvider;
-
-namespace Microsoft.VisualStudio.LanguageServices;
-
-/// <summary>
-/// Listens to broadcast notifications from the Visual Studio Shell indicating that the application is running
-/// low on available virtual memory.
-/// </summary>
-internal sealed class VirtualMemoryNotificationListener : IVsBroadcastMessageEvents
-{
-    // memory threshold to turn off full solution analysis - 200MB
-    private const long MemoryThreshold = 200 * 1024 * 1024;
-
-    // low vm more info page link
-    private const string LowVMMoreInfoLink = "https://go.microsoft.com/fwlink/?LinkID=799402&clcid=0x409";
-    private readonly IGlobalOptionService _globalOptions;
-    private readonly VisualStudioWorkspace _workspace;
-    private readonly WorkspaceCacheService? _workspaceCacheService;
-
-    private bool _alreadyLogged;
-    private bool _infoBarShown;
-
-    private VirtualMemoryNotificationListener(
-        IVsShell shell,
-        IGlobalOptionService globalOptions,
-        VisualStudioWorkspace workspace)
-    {
-        _globalOptions = globalOptions;
-        _workspace = workspace;
-        _workspaceCacheService = workspace.Services.GetService<IWorkspaceCacheService>() as WorkspaceCacheService;
-
-        if (GCSettings.IsServerGC)
-        {
-            // Server GC has been explicitly enabled, which tends to run with higher memory pressure than the
-            // default workstation GC. Allow this case without triggering frequent feature shutdown.
-            return;
-        }
-
-        _workspace.WorkspaceChanged += OnWorkspaceChanged;
-
-        // Note: We never unhook this event sink. It lives for the lifetime of the host.
-        ErrorHandler.ThrowOnFailure(shell.AdviseBroadcastMessages(this, out var cookie));
-    }
-
-    public static async Task<VirtualMemoryNotificationListener> CreateAsync(
-        VisualStudioWorkspace workspace,
-        IThreadingContext threadingContext,
-        IAsyncServiceProvider serviceProvider,
-        IGlobalOptionService globalOptions,
-        CancellationToken cancellationToken)
-    {
-        await threadingContext.JoinableTaskFactory.SwitchToMainThreadAsync(cancellationToken);
-
-        var shell = (IVsShell?)await serviceProvider.GetServiceAsync(typeof(SVsShell)).ConfigureAwait(true);
-        Assumes.Present(shell);
-
-        return new VirtualMemoryNotificationListener(shell, globalOptions, workspace);
-    }
-
-    /// <summary>
-    /// Called by the Visual Studio Shell to notify components of a broadcast message.
-    /// </summary>
-    /// <param name="msg">The message identifier.</param>
-    /// <param name="wParam">First parameter associated with the message.</param>
-    /// <param name="lParam">Second parameter associated with the message.</param>
-    /// <returns>S_OK always.</returns>
-    public int OnBroadcastMessage(uint msg, IntPtr wParam, IntPtr lParam)
-    {
-        switch (msg)
-        {
-            case VSConstants.VSM_VIRTUALMEMORYLOW:
-            case VSConstants.VSM_VIRTUALMEMORYCRITICAL:
-            case VSConstants.VSM_MEMORYHIGH:
-            case VSConstants.VSM_MEMORYEXCESSIVE:
-                {
-                    if (!_alreadyLogged)
-                    {
-                        // record that we had hit critical memory barrier
-                        Logger.Log(FunctionId.VirtualMemory_MemoryLow, KeyValueLogMessage.Create(m =>
-                        {
-                            // which message we are logging and memory left in bytes when this is called.
-                            m["MSG"] = msg;
-                            m["MemoryLeft"] = (long)wParam;
-                        }));
-
-                        _alreadyLogged = true;
-                    }
-
-                    _workspaceCacheService?.FlushCaches();
-
-                    if (ShouldDisableBackgroundAnalysis((long)wParam))
-                    {
-                        DisableBackgroundAnalysis();
-                        ShowInfoBarIfRequired();
-                    }
-
-                    // turn off low latency GC mode.
-                    // once we hit this, not hitting "Out of memory" exception is more important than typing being smooth all the time.
-                    // once it is turned off, user will hit time to time keystroke which responsive time is more than 50ms. in our own perf lab,
-                    // about 1-2% was over 50ms with this off when we first introduced this GC mode.
-                    GCManager.TurnOffLowLatencyMode();
-
-                    break;
-                }
-        }
-
-        return VSConstants.S_OK;
-    }
-
-    private bool ShouldDisableBackgroundAnalysis(long availableMemory)
-    {
-        // conditions
-        // 1. Available memory is less than the threshold and 
-        // 2. Background analysis is not already minimal and
-        // 3. Background analysis memory monitor is on (user can set it off using registry to prevent turning off background analysis)
-
-        return availableMemory < MemoryThreshold &&
-            !SolutionCrawlerOptionsStorage.LowMemoryForcedMinimalBackgroundAnalysis &&
-            _globalOptions.GetOption(VirtualMemoryNotificationListenerOptionsStorage.BackgroundAnalysisMemoryMonitor);
-    }
-
-    private static void DisableBackgroundAnalysis()
-    {
-        // Force low VM minimal background analysis for the current VS session.
-        SolutionCrawlerOptionsStorage.LowMemoryForcedMinimalBackgroundAnalysis = true;
-    }
-
-    private void RenableBackgroundAnalysis()
-    {
-        // Revert forced low VM minimal background analysis for the current VS session.
-        SolutionCrawlerOptionsStorage.LowMemoryForcedMinimalBackgroundAnalysis = false;
-    }
-
-    private void ShowInfoBarIfRequired()
-    {
-        if (_infoBarShown)
-        {
-            return;
-        }
-
-        // Show info bar.
-        _workspace.Services.GetRequiredService<IErrorReportingService>()
-            .ShowGlobalErrorInfo(
-                message: ServicesVSResources.Visual_Studio_has_suspended_some_advanced_features_to_improve_performance,
-                TelemetryFeatureName.VirtualMemoryNotification,
-                exception: null,
-                new InfoBarUI(ServicesVSResources.Re_enable, InfoBarUI.UIKind.Button, RenableBackgroundAnalysis),
-                new InfoBarUI(ServicesVSResources.Learn_more, InfoBarUI.UIKind.HyperLink,
-                    () => VisualStudioNavigateToLinkService.StartBrowser(new Uri(LowVMMoreInfoLink)), closeAfterAction: false));
-
-        _infoBarShown = true;
-    }
-
-    private void OnWorkspaceChanged(object sender, WorkspaceChangeEventArgs e)
-    {
-        if (e.Kind != WorkspaceChangeKind.SolutionAdded)
-        {
-            return;
-        }
-
-        // For newly opened solution, reset the info bar state.
-        _infoBarShown = false;
-    }
-}
diff --git a/src/VisualStudio/Core/Def/LanguageService/AbstractPackage.cs b/src/VisualStudio/Core/Def/LanguageService/AbstractPackage.cs
index 64ff1b7dde1fb..6b1c8955c2c3e 100644
--- a/src/VisualStudio/Core/Def/LanguageService/AbstractPackage.cs
+++ b/src/VisualStudio/Core/Def/LanguageService/AbstractPackage.cs
@@ -4,11 +4,11 @@
 
 using System;
 using System.Threading;
+using System.Threading.Tasks;
 using Microsoft.CodeAnalysis.Options;
 using Microsoft.VisualStudio.ComponentModelHost;
 using Microsoft.VisualStudio.Shell;
 using Microsoft.VisualStudio.Threading;
-using Task = System.Threading.Tasks.Task;
 
 namespace Microsoft.VisualStudio.LanguageServices.Implementation.LanguageService;
 
@@ -25,20 +25,42 @@ internal IComponentModel ComponentModel
         }
     }
 
-    protected override async Task InitializeAsync(CancellationToken cancellationToken, IProgress<ServiceProgressData> progress)
+    protected virtual void RegisterInitializationWork(PackageRegistrationTasks packageRegistrationTasks)
     {
-        await base.InitializeAsync(cancellationToken, progress).ConfigureAwait(true);
+        // This treatment of registering work on the bg/main threads is a bit unique as we want the component model initialized at the beginning
+        // of whichever context is invoked first. The current architecture doesn't execute any of the registered tasks concurrently,
+        // so that isn't a concern for running calculating or setting _componentModel_doNotAccessDirectly multiple times.
+        packageRegistrationTasks.AddTask(isMainThreadTask: false, task: EnsureComponentModelAsync);
+        packageRegistrationTasks.AddTask(isMainThreadTask: true, task: EnsureComponentModelAsync);
 
-        await JoinableTaskFactory.SwitchToMainThreadAsync(cancellationToken);
+        async Task EnsureComponentModelAsync(IProgress<ServiceProgressData> progress, PackageRegistrationTasks packageRegistrationTasks, CancellationToken token)
+        {
+            if (_componentModel_doNotAccessDirectly == null)
+            {
+                _componentModel_doNotAccessDirectly = (IComponentModel?)await GetServiceAsync(typeof(SComponentModel)).ConfigureAwait(false);
+                Assumes.Present(_componentModel_doNotAccessDirectly);
+            }
+        }
+    }
 
-        _componentModel_doNotAccessDirectly = (IComponentModel?)await GetServiceAsync(typeof(SComponentModel)).ConfigureAwait(true);
-        Assumes.Present(_componentModel_doNotAccessDirectly);
+    /// This method is called upon package creation and is the mechanism by which roslyn packages calculate and
+    /// process all package initialization work. Do not override this sealed method, instead override RegisterInitializationWork
+    /// to indicate the work your package needs upon initialization.
+    protected sealed override async Task InitializeAsync(CancellationToken cancellationToken, IProgress<ServiceProgressData> progress)
+    {
+        var packageRegistrationTasks = new PackageRegistrationTasks(JoinableTaskFactory);
+
+        // Request all initially known work, classified into whether it should be processed on the main or
+        // background thread. These lists can be modified by the work itself to add more work for subsequent processing.
+        // Requesting this information is useful as it lets us batch up work on these threads, significantly
+        // reducing thread switches during package load.
+        RegisterInitializationWork(packageRegistrationTasks);
+
+        await packageRegistrationTasks.ProcessTasksAsync(progress, cancellationToken).ConfigureAwait(false);
     }
 
     protected override async Task OnAfterPackageLoadedAsync(CancellationToken cancellationToken)
     {
-        await base.OnAfterPackageLoadedAsync(cancellationToken).ConfigureAwait(false);
-
         // TODO: remove, workaround for https://devdiv.visualstudio.com/DevDiv/_workitems/edit/1985204
         var globalOptions = ComponentModel.GetService<IGlobalOptionService>();
         if (globalOptions.GetOption(SemanticSearchFeatureFlag.Enabled))
diff --git a/src/VisualStudio/Core/Def/LanguageService/AbstractPackage`2.cs b/src/VisualStudio/Core/Def/LanguageService/AbstractPackage`2.cs
index c1afbf754dc74..4c40f1eff0d0a 100644
--- a/src/VisualStudio/Core/Def/LanguageService/AbstractPackage`2.cs
+++ b/src/VisualStudio/Core/Def/LanguageService/AbstractPackage`2.cs
@@ -34,16 +34,21 @@ protected AbstractPackage()
     {
     }
 
-    protected override async Task InitializeAsync(CancellationToken cancellationToken, IProgress<ServiceProgressData> progress)
+    protected override void RegisterInitializationWork(PackageRegistrationTasks packageRegistrationTasks)
     {
-        await base.InitializeAsync(cancellationToken, progress).ConfigureAwait(true);
+        base.RegisterInitializationWork(packageRegistrationTasks);
 
-        await JoinableTaskFactory.SwitchToMainThreadAsync(cancellationToken);
+        packageRegistrationTasks.AddTask(isMainThreadTask: true, task: PackageInitializationMainThreadAsync);
+    }
+
+    private async Task PackageInitializationMainThreadAsync(IProgress<ServiceProgressData> progress, PackageRegistrationTasks packageRegistrationTasks, CancellationToken cancellationToken)
+    {
+        // This code uses various main thread only services, so it must run completely on the main thread
+        // (thus the CA(true) usage throughout)
+        Contract.ThrowIfFalse(JoinableTaskFactory.Context.IsOnMainThread);
 
         var shell = (IVsShell7?)await GetServiceAsync(typeof(SVsShell)).ConfigureAwait(true);
-        var solution = (IVsSolution?)await GetServiceAsync(typeof(SVsSolution)).ConfigureAwait(true);
         Assumes.Present(shell);
-        Assumes.Present(solution);
 
         _shell = (IVsShell?)shell;
         Assumes.Present(_shell);
@@ -53,25 +58,41 @@ protected override async Task InitializeAsync(CancellationToken cancellationToke
             RegisterEditorFactory(editorFactory);
         }
 
-        RegisterLanguageService(typeof(TLanguageService), async cancellationToken =>
-        {
-            // Ensure we're on the BG when creating the language service.
-            await TaskScheduler.Default;
+        var miscellaneousFilesWorkspace = this.ComponentModel.GetService<MiscellaneousFilesWorkspace>();
 
-            // Create the language service, tell it to set itself up, then store it in a field
-            // so we can notify it that it's time to clean up.
-            _languageService = CreateLanguageService();
-            await _languageService.SetupAsync(cancellationToken).ConfigureAwait(false);
+        // awaiting an IVsTask guarantees to return on the captured context
+        await shell.LoadPackageAsync(Guids.RoslynPackageId);
 
-            return _languageService.ComAggregate!;
-        });
+        packageRegistrationTasks.AddTask(
+             isMainThreadTask: false,
+             task: (IProgress<ServiceProgressData> progress, PackageRegistrationTasks packageRegistrationTasks, CancellationToken cancellationToken) =>
+             {
+                 RegisterLanguageService(typeof(TLanguageService), async cancellationToken =>
+                 {
+                     // Ensure we're on the BG when creating the language service.
+                     await TaskScheduler.Default;
 
-        await shell.LoadPackageAsync(Guids.RoslynPackageId);
+                     // Create the language service, tell it to set itself up, then store it in a field
+                     // so we can notify it that it's time to clean up.
+                     _languageService = CreateLanguageService();
+                     await _languageService.SetupAsync(cancellationToken).ConfigureAwait(false);
 
-        var miscellaneousFilesWorkspace = this.ComponentModel.GetService<MiscellaneousFilesWorkspace>();
-        RegisterMiscellaneousFilesWorkspaceInformation(miscellaneousFilesWorkspace);
+                     return _languageService.ComAggregate!;
+                 });
+
+                 RegisterMiscellaneousFilesWorkspaceInformation(miscellaneousFilesWorkspace);
+
+                 return Task.CompletedTask;
+             });
+    }
+
+    protected override async Task OnAfterPackageLoadedAsync(CancellationToken cancellationToken)
+    {
+        await base.OnAfterPackageLoadedAsync(cancellationToken).ConfigureAwait(false);
+
+        await JoinableTaskFactory.SwitchToMainThreadAsync(cancellationToken);
 
-        if (!_shell.IsInCommandLineMode())
+        if (_shell != null && !_shell.IsInCommandLineMode())
         {
             // not every derived package support object browser and for those languages
             // this is a no op
diff --git a/src/VisualStudio/Core/Def/LanguageService/PackageRegistrationTasks.cs b/src/VisualStudio/Core/Def/LanguageService/PackageRegistrationTasks.cs
new file mode 100644
index 0000000000000..247f6d18bdb61
--- /dev/null
+++ b/src/VisualStudio/Core/Def/LanguageService/PackageRegistrationTasks.cs
@@ -0,0 +1,74 @@
+// 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.Concurrent;
+using System.Threading;
+using System.Threading.Tasks;
+using Microsoft.VisualStudio.Shell;
+using Microsoft.VisualStudio.Threading;
+
+namespace Microsoft.VisualStudio.LanguageServices.Implementation.LanguageService;
+
+using WorkTask = Func<IProgress<ServiceProgressData>, PackageRegistrationTasks, CancellationToken, Task>;
+
+/// <summary>
+/// Provides a mechanism for registering work to be done during package initialization. Work is registered
+/// as either main thread or background thread appropriate. This allows processing of these work items
+/// in a batched manner, reducing the number of thread switches required during the performance sensitive
+/// package loading timeframe.
+/// 
+/// Note that currently the processing of these tasks isn't done concurrently. A future optimization may
+/// allow parallel background thread task execution, or even concurrent main and background thread work.
+/// </summary>
+internal sealed class PackageRegistrationTasks(JoinableTaskFactory jtf)
+{
+    private readonly ConcurrentQueue<WorkTask> _backgroundThreadWorkTasks = [];
+    private readonly ConcurrentQueue<WorkTask> _mainThreadWorkTasks = [];
+    private readonly JoinableTaskFactory _jtf = jtf;
+
+    public void AddTask(bool isMainThreadTask, WorkTask task)
+    {
+        var workTasks = GetWorkTasks(isMainThreadTask);
+        workTasks.Enqueue(task);
+    }
+
+    public async Task ProcessTasksAsync(IProgress<ServiceProgressData> progress, CancellationToken cancellationToken)
+    {
+        // prime the pump by doing the first group of bg thread work if the initiating thread is not the main thread
+        if (!_jtf.Context.IsOnMainThread)
+            await PerformWorkAsync(isMainThreadTask: false, progress, cancellationToken).ConfigureAwait(false);
+
+        // Continue processing work until everything is completed, switching between main and bg threads as needed.
+        while (!_mainThreadWorkTasks.IsEmpty || !_backgroundThreadWorkTasks.IsEmpty)
+        {
+            await PerformWorkAsync(isMainThreadTask: true, progress, cancellationToken).ConfigureAwait(false);
+            await PerformWorkAsync(isMainThreadTask: false, progress, cancellationToken).ConfigureAwait(false);
+        }
+    }
+
+    private ConcurrentQueue<WorkTask> GetWorkTasks(bool isMainThreadTask)
+        => isMainThreadTask ? _mainThreadWorkTasks : _backgroundThreadWorkTasks;
+
+    private async Task PerformWorkAsync(bool isMainThreadTask, IProgress<ServiceProgressData> progress, CancellationToken cancellationToken)
+    {
+        var workTasks = GetWorkTasks(isMainThreadTask);
+        if (workTasks.IsEmpty)
+            return;
+
+        // Ensure we're invoking the task on the right thread
+        if (isMainThreadTask)
+            await _jtf.SwitchToMainThreadAsync(cancellationToken);
+        else if (_jtf.Context.IsOnMainThread)
+            await TaskScheduler.Default;
+
+        while (workTasks.TryDequeue(out var work))
+        {
+            // CA(true) is important here, as we want to ensure that each iteration is done in the same
+            // captured context. Thus, even poorly behaving tasks (ie, those that do their own thread switching)
+            // don't effect the next loop iteration.
+            await work(progress, this, cancellationToken).ConfigureAwait(true);
+        }
+    }
+}
diff --git a/src/VisualStudio/Core/Def/Options/VisualStudioSettingsOptionPersister.cs b/src/VisualStudio/Core/Def/Options/VisualStudioSettingsOptionPersister.cs
index 59334831acaa5..957dcd788842c 100644
--- a/src/VisualStudio/Core/Def/Options/VisualStudioSettingsOptionPersister.cs
+++ b/src/VisualStudio/Core/Def/Options/VisualStudioSettingsOptionPersister.cs
@@ -35,7 +35,7 @@ internal sealed class VisualStudioSettingsOptionPersister
         = ImmutableDictionary<string, (OptionKey2, string)>.Empty;
 
     /// <remarks>
-    /// We make sure this code is from the UI by asking for all <see cref="IOptionPersister"/> in <see cref="RoslynPackage.InitializeAsync"/>
+    /// We make sure this code is from the UI by asking for all <see cref="IOptionPersister"/> in <see cref="RoslynPackage.OnAfterPackageLoadedAsync"/>
     /// </remarks>
     public VisualStudioSettingsOptionPersister(Action<OptionKey2, object?> refreshOption, ImmutableDictionary<string, Lazy<IVisualStudioStorageReadFallback, OptionNameMetadata>> readFallbacks, ISettingsManager settingsManager)
     {
diff --git a/src/VisualStudio/Core/Def/ProjectSystem/MetadataReferences/VisualStudioMetadataReferenceManager.cs b/src/VisualStudio/Core/Def/ProjectSystem/MetadataReferences/VisualStudioMetadataReferenceManager.cs
index b623f91df8704..028d88b893c29 100644
--- a/src/VisualStudio/Core/Def/ProjectSystem/MetadataReferences/VisualStudioMetadataReferenceManager.cs
+++ b/src/VisualStudio/Core/Def/ProjectSystem/MetadataReferences/VisualStudioMetadataReferenceManager.cs
@@ -5,6 +5,7 @@
 using System;
 using System.Collections.Generic;
 using System.Collections.Immutable;
+using System.Composition;
 using System.Diagnostics;
 using System.Diagnostics.CodeAnalysis;
 using System.IO;
@@ -15,7 +16,9 @@
 using System.Threading;
 using Microsoft.CodeAnalysis;
 using Microsoft.CodeAnalysis.Host;
+using Microsoft.CodeAnalysis.Host.Mef;
 using Microsoft.CodeAnalysis.Shared.Collections;
+using Microsoft.VisualStudio.Shell;
 using Microsoft.VisualStudio.Shell.Interop;
 using Roslyn.Utilities;
 
@@ -31,6 +34,7 @@ namespace Microsoft.VisualStudio.LanguageServices.Implementation.ProjectSystem;
 /// that can be passed to the compiler. These snapshot references serve the underlying metadata blobs from a VS-wide storage, if possible, 
 /// from <see cref="ITemporaryStorageServiceInternal"/>.
 /// </remarks>
+[ExportWorkspaceService(typeof(VisualStudioMetadataReferenceManager), ServiceLayer.Host), Shared]
 internal sealed partial class VisualStudioMetadataReferenceManager : IWorkspaceService, IDisposable
 {
     private static readonly ConditionalWeakTable<Metadata, object> s_lifetimeMap = new();
@@ -66,9 +70,11 @@ internal sealed partial class VisualStudioMetadataReferenceManager : IWorkspaceS
     /// </summary>
     private IVsSmartOpenScope? SmartOpenScopeServiceOpt { get; set; }
 
+    [ImportingConstructor]
+    [Obsolete(MefConstruction.ImportingConstructorMessage, error: true)]
     public VisualStudioMetadataReferenceManager(
-        IServiceProvider serviceProvider,
-        TemporaryStorageService temporaryStorageService)
+        SVsServiceProvider serviceProvider,
+        VisualStudioWorkspace workspace)
     {
         _runtimeDirectories = GetRuntimeDirectories();
 
@@ -78,7 +84,8 @@ public VisualStudioMetadataReferenceManager(
         SmartOpenScopeServiceOpt = (IVsSmartOpenScope)serviceProvider.GetService(typeof(SVsSmartOpenScope));
         Assumes.Present(SmartOpenScopeServiceOpt);
 
-        _temporaryStorageService = temporaryStorageService;
+        // If we're in VS we know we must be able to get a TemporaryStorageService
+        _temporaryStorageService = (TemporaryStorageService)workspace.Services.GetRequiredService<ITemporaryStorageServiceInternal>();
         Assumes.Present(_temporaryStorageService);
     }
 
diff --git a/src/VisualStudio/Core/Def/ProjectSystem/MetadataReferences/VisualStudioMetadataReferenceManagerFactory.cs b/src/VisualStudio/Core/Def/ProjectSystem/MetadataReferences/VisualStudioMetadataReferenceManagerFactory.cs
deleted file mode 100644
index 373bc843d89f3..0000000000000
--- a/src/VisualStudio/Core/Def/ProjectSystem/MetadataReferences/VisualStudioMetadataReferenceManagerFactory.cs
+++ /dev/null
@@ -1,34 +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.Composition;
-using System.Threading;
-using Microsoft.CodeAnalysis.Host;
-using Microsoft.CodeAnalysis.Host.Mef;
-using Microsoft.VisualStudio.Shell;
-
-namespace Microsoft.VisualStudio.LanguageServices.Implementation.ProjectSystem;
-
-// TODO: Remove this type. This factory is needed just to instantiate a singleton of VisualStudioMetadataReferenceProvider.
-// We should be able to MEF-instantiate a singleton of VisualStudioMetadataReferenceProvider without creating this factory.
-[ExportWorkspaceServiceFactory(typeof(VisualStudioMetadataReferenceManager), ServiceLayer.Host), Shared]
-[method: ImportingConstructor]
-[method: Obsolete(MefConstruction.ImportingConstructorMessage, error: true)]
-internal class VisualStudioMetadataReferenceManagerFactory(SVsServiceProvider serviceProvider) : IWorkspaceServiceFactory
-{
-    private VisualStudioMetadataReferenceManager? _singleton;
-
-    public IWorkspaceService CreateService(HostWorkspaceServices workspaceServices)
-    {
-        if (_singleton == null)
-        {
-            // If we're in VS we know we must be able to get a TemporaryStorageService
-            var temporaryStorage = (TemporaryStorageService)workspaceServices.GetRequiredService<ITemporaryStorageServiceInternal>();
-            Interlocked.CompareExchange(ref _singleton, new VisualStudioMetadataReferenceManager(serviceProvider, temporaryStorage), null);
-        }
-
-        return _singleton;
-    }
-}
diff --git a/src/VisualStudio/Core/Def/ProjectSystem/MiscellaneousFilesWorkspace.cs b/src/VisualStudio/Core/Def/ProjectSystem/MiscellaneousFilesWorkspace.cs
index 81b34d0a5b3f7..b52774a0f090e 100644
--- a/src/VisualStudio/Core/Def/ProjectSystem/MiscellaneousFilesWorkspace.cs
+++ b/src/VisualStudio/Core/Def/ProjectSystem/MiscellaneousFilesWorkspace.cs
@@ -3,12 +3,13 @@
 // See the LICENSE file in the project root for more information.
 
 using System;
+using System.Collections.Concurrent;
 using System.Collections.Generic;
 using System.Collections.Immutable;
 using System.ComponentModel.Composition;
 using System.IO;
 using System.Linq;
-using System.Threading.Tasks;
+using System.Threading;
 using Microsoft.CodeAnalysis;
 using Microsoft.CodeAnalysis.Editor;
 using Microsoft.CodeAnalysis.Editor.Shared.Extensions;
@@ -17,11 +18,9 @@
 using Microsoft.CodeAnalysis.Host.Mef;
 using Microsoft.CodeAnalysis.MetadataAsSource;
 using Microsoft.CodeAnalysis.Text;
-using Microsoft.VisualStudio.Shell;
 using Microsoft.VisualStudio.Shell.Interop;
 using Microsoft.VisualStudio.Text;
 using Microsoft.VisualStudio.TextManager.Interop;
-using Microsoft.VisualStudio.Threading;
 using Roslyn.Utilities;
 
 namespace Microsoft.VisualStudio.LanguageServices.Implementation.ProjectSystem;
@@ -34,7 +33,7 @@ internal sealed partial class MiscellaneousFilesWorkspace : Workspace, IOpenText
     private readonly OpenTextBufferProvider _openTextBufferProvider;
     private readonly IMetadataAsSourceFileService _fileTrackingMetadataAsSourceService;
 
-    private readonly Dictionary<Guid, LanguageInformation> _languageInformationByLanguageGuid = [];
+    private readonly ConcurrentDictionary<Guid, LanguageInformation> _languageInformationByLanguageGuid = [];
 
     /// <summary>
     /// <see cref="WorkspaceRegistration"/> instances for all open buffers being tracked by by this object
@@ -50,8 +49,6 @@ internal sealed partial class MiscellaneousFilesWorkspace : Workspace, IOpenText
 
     private readonly ImmutableArray<MetadataReference> _metadataReferences;
 
-    private IVsTextManager? _textManager;
-
     [ImportingConstructor]
     [Obsolete(MefConstruction.ImportingConstructorMessage, error: true)]
     public MiscellaneousFilesWorkspace(
@@ -72,12 +69,6 @@ public MiscellaneousFilesWorkspace(
         _openTextBufferProvider.AddListener(this);
     }
 
-    public async Task InitializeAsync()
-    {
-        await TaskScheduler.Default;
-        _textManager = await _textManagerService.GetValueAsync().ConfigureAwait(false);
-    }
-
     void IOpenTextBufferEventListener.OnOpenDocument(string moniker, ITextBuffer textBuffer, IVsHierarchy? _) => TrackOpenedDocument(moniker, textBuffer);
 
     void IOpenTextBufferEventListener.OnCloseDocument(string moniker) => TryUntrackClosingDocument(moniker);
@@ -116,9 +107,12 @@ public void RegisterLanguage(Guid languageGuid, string languageName, string scri
 
     private LanguageInformation? TryGetLanguageInformation(string filename)
     {
+        _threadingContext.ThrowIfNotOnUIThread();
+
         LanguageInformation? languageInformation = null;
 
-        if (_textManager != null && ErrorHandler.Succeeded(_textManager.MapFilenameToLanguageSID(filename, out var fileLanguageGuid)))
+        var textManager = _threadingContext.JoinableTaskFactory.Run(() => _textManagerService.GetValueOrNullAsync(CancellationToken.None));
+        if (textManager != null && ErrorHandler.Succeeded(textManager.MapFilenameToLanguageSID(filename, out var fileLanguageGuid)))
         {
             _languageInformationByLanguageGuid.TryGetValue(fileLanguageGuid, out languageInformation);
         }
diff --git a/src/VisualStudio/Core/Def/ProjectSystem/VisualStudioWorkspaceImpl.cs b/src/VisualStudio/Core/Def/ProjectSystem/VisualStudioWorkspaceImpl.cs
index 5fca03239d60e..27dc927d56ae0 100644
--- a/src/VisualStudio/Core/Def/ProjectSystem/VisualStudioWorkspaceImpl.cs
+++ b/src/VisualStudio/Core/Def/ProjectSystem/VisualStudioWorkspaceImpl.cs
@@ -96,8 +96,6 @@ internal abstract partial class VisualStudioWorkspaceImpl : VisualStudioWorkspac
     /// </summary>
     private readonly Dictionary<string, UIContext?> _languageToProjectExistsUIContext = [];
 
-    private VirtualMemoryNotificationListener? _memoryListener;
-
     private OpenFileTracker? _openFileTracker;
     internal IFileChangeWatcher FileChangeWatcher { get; }
 
@@ -195,7 +193,6 @@ public async Task InitializeUIAffinitizedServicesAsync(IAsyncServiceProvider asy
         solutionClosingContext.UIContextChanged += (_, e) => ProjectSystemProjectFactory.SolutionClosing = e.Activated;
 
         var openFileTracker = await OpenFileTracker.CreateAsync(this, ProjectSystemProjectFactory, asyncServiceProvider).ConfigureAwait(true);
-        var memoryListener = await VirtualMemoryNotificationListener.CreateAsync(this, _threadingContext, asyncServiceProvider, _globalOptions, _threadingContext.DisposalToken).ConfigureAwait(true);
 
         // Update our fields first, so any asynchronous work that needs to use these is able to see the service.
         // WARNING: if we do .ConfigureAwait(true) here, it means we're trying to transition to the UI thread while
@@ -203,7 +200,6 @@ public async Task InitializeUIAffinitizedServicesAsync(IAsyncServiceProvider asy
         using (await _gate.DisposableWaitAsync().ConfigureAwait(false))
         {
             _openFileTracker = openFileTracker;
-            _memoryListener = memoryListener;
         }
 
         await _threadingContext.JoinableTaskFactory.SwitchToMainThreadAsync(_threadingContext.DisposalToken);
diff --git a/src/VisualStudio/Core/Def/RoslynPackage.cs b/src/VisualStudio/Core/Def/RoslynPackage.cs
index 9742018a5ac9a..5ed69a6ef73da 100644
--- a/src/VisualStudio/Core/Def/RoslynPackage.cs
+++ b/src/VisualStudio/Core/Def/RoslynPackage.cs
@@ -47,8 +47,6 @@
 namespace Microsoft.VisualStudio.LanguageServices.Setup;
 
 [Guid(Guids.RoslynPackageIdString)]
-
-// The option page configuration is duplicated in PackageRegistration.pkgdef
 [ProvideToolWindow(typeof(ValueTracking.ValueTrackingToolWindow))]
 [ProvideToolWindow(typeof(StackTraceExplorerToolWindow))]
 internal sealed class RoslynPackage : AbstractPackage
@@ -142,48 +140,65 @@ protected override void OnSaveOptions(string key, Stream stream)
         base.OnSaveOptions(key, stream);
     }
 
-    protected override async Task InitializeAsync(CancellationToken cancellationToken, IProgress<ServiceProgressData> progress)
+    protected override void RegisterInitializationWork(PackageRegistrationTasks packageRegistrationTasks)
     {
-        await base.InitializeAsync(cancellationToken, progress).ConfigureAwait(true);
-
-        await JoinableTaskFactory.SwitchToMainThreadAsync(cancellationToken);
+        base.RegisterInitializationWork(packageRegistrationTasks);
 
-        cancellationToken.ThrowIfCancellationRequested();
-
-        // Ensure the options persisters are loaded since we have to fetch options from the shell
-        LoadOptionPersistersAsync(this.ComponentModel, cancellationToken).Forget();
-
-        await InitializeColorsAsync(cancellationToken).ConfigureAwait(true);
+        packageRegistrationTasks.AddTask(isMainThreadTask: false, task: PackageInitializationBackgroundThreadAsync);
+    }
 
-        // load some services that have to be loaded in UI thread
-        LoadComponentsInUIContextOnceSolutionFullyLoadedAsync(cancellationToken).Forget();
+    private Task PackageInitializationBackgroundThreadAsync(IProgress<ServiceProgressData> progress, PackageRegistrationTasks packageRegistrationTasks, CancellationToken cancellationToken)
+    {
+        _colorSchemeApplier = ComponentModel.GetService<ColorSchemeApplier>();
+        _colorSchemeApplier.RegisterInitializationWork(packageRegistrationTasks);
 
         // We are at the VS layer, so we know we must be able to get the IGlobalOperationNotificationService here.
         var globalNotificationService = this.ComponentModel.GetService<IGlobalOperationNotificationService>();
         Assumes.Present(globalNotificationService);
 
-        _solutionEventMonitor = new SolutionEventMonitor(globalNotificationService);
-        TrackBulkFileOperations(globalNotificationService);
-
         var settingsEditorFactory = this.ComponentModel.GetService<SettingsEditorFactory>();
-        RegisterEditorFactory(settingsEditorFactory);
 
-        // Misc workspace has to be up and running by the time our package is usable so that it can track running
-        // doc events and appropriately map files to/from it and other relevant workspaces (like the
-        // metadata-as-source workspace).
-        await this.ComponentModel.GetService<MiscellaneousFilesWorkspace>().InitializeAsync().ConfigureAwait(false);
+        packageRegistrationTasks.AddTask(
+            isMainThreadTask: true,
+            task: async (progress, packageRegistrationTasks, cancellationToken) =>
+            {
+                _solutionEventMonitor = new SolutionEventMonitor(globalNotificationService);
+                TrackBulkFileOperations(globalNotificationService);
+
+                RegisterEditorFactory(settingsEditorFactory);
+
+                // Proffer in-process service broker services
+                var serviceBrokerContainer = await this.GetServiceAsync<SVsBrokeredServiceContainer, IBrokeredServiceContainer>(this.JoinableTaskFactory).ConfigureAwait(false);
+
+                serviceBrokerContainer.Proffer(
+                    WorkspaceProjectFactoryServiceDescriptor.ServiceDescriptor,
+                    (_, _, _, _) => ValueTaskFactory.FromResult<object?>(new WorkspaceProjectFactoryService(this.ComponentModel.GetService<IWorkspaceProjectContextFactory>())));
 
-        // Proffer in-process service broker services
-        var serviceBrokerContainer = await this.GetServiceAsync<SVsBrokeredServiceContainer, IBrokeredServiceContainer>(this.JoinableTaskFactory).ConfigureAwait(false);
+                // Must be profferred before any C#/VB projects are loaded and the corresponding UI context activated.
+                serviceBrokerContainer.Proffer(
+                    ManagedHotReloadLanguageServiceDescriptor.Descriptor,
+                    (_, _, _, _) => ValueTaskFactory.FromResult<object?>(new ManagedEditAndContinueLanguageServiceBridge(this.ComponentModel.GetService<EditAndContinueLanguageService>())));
 
-        serviceBrokerContainer.Proffer(
-            WorkspaceProjectFactoryServiceDescriptor.ServiceDescriptor,
-            (_, _, _, _) => ValueTaskFactory.FromResult<object?>(new WorkspaceProjectFactoryService(this.ComponentModel.GetService<IWorkspaceProjectContextFactory>())));
+                // Misc workspace has to be up and running by the time our package is usable so that it can track running
+                // doc events and appropriately map files to/from it and other relevant workspaces (like the
+                // metadata-as-source workspace).
+                var miscellaneousFilesWorkspace = this.ComponentModel.GetService<MiscellaneousFilesWorkspace>();
+            });
 
-        // Must be profferred before any C#/VB projects are loaded and the corresponding UI context activated.
-        serviceBrokerContainer.Proffer(
-            ManagedHotReloadLanguageServiceDescriptor.Descriptor,
-            (_, _, _, _) => ValueTaskFactory.FromResult<object?>(new ManagedEditAndContinueLanguageServiceBridge(this.ComponentModel.GetService<EditAndContinueLanguageService>())));
+        return Task.CompletedTask;
+    }
+
+    protected override async Task OnAfterPackageLoadedAsync(CancellationToken cancellationToken)
+    {
+        await base.OnAfterPackageLoadedAsync(cancellationToken).ConfigureAwait(false);
+
+        // Ensure the options persisters are loaded since we have to fetch options from the shell
+        LoadOptionPersistersAsync(this.ComponentModel, cancellationToken).Forget();
+
+        await JoinableTaskFactory.SwitchToMainThreadAsync(cancellationToken);
+
+        // load some services that have to be loaded in UI thread
+        LoadComponentsInUIContextOnceSolutionFullyLoadedAsync(cancellationToken).Forget();
     }
 
     private async Task LoadOptionPersistersAsync(IComponentModel componentModel, CancellationToken cancellationToken)
@@ -208,13 +223,6 @@ private async Task LoadOptionPersistersAsync(IComponentModel componentModel, Can
         }
     }
 
-    private async Task InitializeColorsAsync(CancellationToken cancellationToken)
-    {
-        await TaskScheduler.Default;
-        _colorSchemeApplier = ComponentModel.GetService<ColorSchemeApplier>();
-        await _colorSchemeApplier.InitializeAsync(cancellationToken).ConfigureAwait(false);
-    }
-
     protected override async Task LoadComponentsAsync(CancellationToken cancellationToken)
     {
         await TaskScheduler.Default;
diff --git a/src/VisualStudio/Setup.Dependencies/Roslyn.VisualStudio.Setup.Dependencies.csproj b/src/VisualStudio/Setup.Dependencies/Roslyn.VisualStudio.Setup.Dependencies.csproj
index b2f087b84e51f..32fd2ee48b690 100644
--- a/src/VisualStudio/Setup.Dependencies/Roslyn.VisualStudio.Setup.Dependencies.csproj
+++ b/src/VisualStudio/Setup.Dependencies/Roslyn.VisualStudio.Setup.Dependencies.csproj
@@ -25,10 +25,22 @@
     <PackageReference Include="Microsoft.Bcl.AsyncInterfaces" IncludeInVsix="true" PkgDefEntry="BindingRedirect" />
     <PackageReference Include="Microsoft.DiaSymReader" IncludeInVsix="true" PkgDefEntry="BindingRedirect" />
     <PackageReference Include="Microsoft.DiaSymReader.PortablePdb" IncludeInVsix="true" PkgDefEntry="BindingRedirect" />
+    <PackageReference Include="Microsoft.VisualStudio.Threading" IncludeInVsix="true" PkgDefEntry="BindingRedirect" />
     <PackageReference Include="System.Buffers" IncludeInVsix="true" PkgDefEntry="BindingRedirect" />
     <PackageReference Include="System.CodeDom" IncludeInVsix="true" PkgDefEntry="BindingRedirect" />
     <PackageReference Include="System.Collections.Immutable" IncludeInVsix="true" PkgDefEntry="BindingRedirect" />
     <PackageReference Include="System.Configuration.ConfigurationManager" IncludeInVsix="true" PkgDefEntry="BindingRedirect" />
+    
+    <!-- Include System.Composition until the 9.0 version is included in Visual Studio. Our MSBuild support for IncludeInVsix only looks at the direct contents
+         of that package and doesn't include any dependencies, which is unfortunate here: System.Composition is a metapackage, and all the actual stuff is in other
+         packages. We workaround that here by listing all of the "real" packages. I'm using VersionOverride here rather than creating a bunch of new entries in
+         our Directories.props files, because eventually we can go and delete these and it keeps the hack self-contained. -->
+    <PackageReference Include="System.Composition.AttributedModel" IncludeInVsix="true" PkgDefEntry="BindingRedirect" VersionOverride="$(SystemCompositionVersion)" />
+    <PackageReference Include="System.Composition.Convention" IncludeInVsix="true" PkgDefEntry="BindingRedirect" VersionOverride="$(SystemCompositionVersion)" />
+    <PackageReference Include="System.Composition.Hosting" IncludeInVsix="true" PkgDefEntry="BindingRedirect" VersionOverride="$(SystemCompositionVersion)" />
+    <PackageReference Include="System.Composition.Runtime" IncludeInVsix="true" PkgDefEntry="BindingRedirect" VersionOverride="$(SystemCompositionVersion)" />
+    <PackageReference Include="System.Composition.TypedParts" IncludeInVsix="true" PkgDefEntry="BindingRedirect" VersionOverride="$(SystemCompositionVersion)" />
+    
     <PackageReference Include="System.Drawing.Common" IncludeInVsix="true" PkgDefEntry="BindingRedirect" />
     <PackageReference Include="System.IO.Pipelines" IncludeInVsix="true" PkgDefEntry="BindingRedirect" />
     <PackageReference Include="System.Memory" IncludeInVsix="true" PkgDefEntry="BindingRedirect" />
@@ -42,7 +54,6 @@
     <PackageReference Include="System.Threading.Tasks.Extensions" IncludeInVsix="true" PkgDefEntry="BindingRedirect" />
     <PackageReference Include="Nerdbank.Streams" IncludeInVsix="true" PkgDefEntry="BindingRedirect" />
     <PackageReference Include="StreamJsonRpc" IncludeInVsix="true" PkgDefEntry="BindingRedirect" />
-    <PackageReference Include="Microsoft.VisualStudio.Threading" IncludeInVsix="true" PkgDefEntry="BindingRedirect" />
   </ItemGroup>
   <ItemGroup>
     <None Include="source.extension.vsixmanifest">
diff --git a/src/VisualStudio/TestUtilities2/ProjectSystemShim/Framework/TestEnvironment.vb b/src/VisualStudio/TestUtilities2/ProjectSystemShim/Framework/TestEnvironment.vb
index bde25c3691429..882c0cb290ff9 100644
--- a/src/VisualStudio/TestUtilities2/ProjectSystemShim/Framework/TestEnvironment.vb
+++ b/src/VisualStudio/TestUtilities2/ProjectSystemShim/Framework/TestEnvironment.vb
@@ -63,7 +63,7 @@ Namespace Microsoft.VisualStudio.LanguageServices.UnitTests.ProjectSystemShim.Fr
                 GetType(CPSProjectFactory),
                 GetType(VisualStudioRuleSetManagerFactory),
                 GetType(VisualStudioMetadataServiceFactory),
-                GetType(VisualStudioMetadataReferenceManagerFactory),
+                GetType(VisualStudioMetadataReferenceManager),
                 GetType(MockWorkspaceEventListenerProvider),
                 GetType(HierarchyItemToProjectIdMap),
                 GetType(DiagnosticAnalyzerService))
diff --git a/src/VisualStudio/VisualBasic/Impl/LanguageService/VisualBasicPackage.vb b/src/VisualStudio/VisualBasic/Impl/LanguageService/VisualBasicPackage.vb
index 3df609cae372b..ed4859ac01a77 100644
--- a/src/VisualStudio/VisualBasic/Impl/LanguageService/VisualBasicPackage.vb
+++ b/src/VisualStudio/VisualBasic/Impl/LanguageService/VisualBasicPackage.vb
@@ -3,7 +3,6 @@
 ' See the LICENSE file in the project root for more information.
 
 Imports System.Runtime.InteropServices
-Imports System.Threading
 Imports Microsoft.CodeAnalysis
 Imports Microsoft.CodeAnalysis.ErrorReporting
 Imports Microsoft.CodeAnalysis.Options
@@ -64,23 +63,29 @@ Namespace Microsoft.VisualStudio.LanguageServices.VisualBasic
             _comAggregate = Implementation.Interop.ComAggregate.CreateAggregatedObject(Me)
         End Sub
 
-        Protected Overrides Async Function InitializeAsync(cancellationToken As CancellationToken, progress As IProgress(Of ServiceProgressData)) As Task
-            Try
-                Await MyBase.InitializeAsync(cancellationToken, progress).ConfigureAwait(True)
-                Await JoinableTaskFactory.SwitchToMainThreadAsync(cancellationToken)
-
-                RegisterLanguageService(GetType(IVbCompilerService), Function() Task.FromResult(_comAggregate))
-
-                RegisterService(Of IVbTempPECompilerFactory)(
-                    Async Function(ct)
-                        Dim workspace = Me.ComponentModel.GetService(Of VisualStudioWorkspace)()
-                        Await JoinableTaskFactory.SwitchToMainThreadAsync(ct)
-                        Return New TempPECompilerFactory(workspace)
-                    End Function)
-            Catch ex As Exception When FatalError.ReportAndPropagateUnlessCanceled(ex)
-                Throw ExceptionUtilities.Unreachable
-            End Try
-        End Function
+        Protected Overrides Sub RegisterInitializationWork(packageRegistrationTasks As PackageRegistrationTasks)
+
+            MyBase.RegisterInitializationWork(packageRegistrationTasks)
+
+            packageRegistrationTasks.AddTask(
+                isMainThreadTask:=False,
+                task:=Function(progress, packageRegistrationTasks2, cancellationToken) As Task
+                          Try
+                              RegisterLanguageService(GetType(IVbCompilerService), Function() Task.FromResult(_comAggregate))
+
+                              RegisterService(Of IVbTempPECompilerFactory)(
+                            Async Function(ct)
+                                Dim workspace = Me.ComponentModel.GetService(Of VisualStudioWorkspace)()
+                                Await JoinableTaskFactory.SwitchToMainThreadAsync(ct)
+                                Return New TempPECompilerFactory(workspace)
+                            End Function)
+                          Catch ex As Exception When FatalError.ReportAndPropagateUnlessCanceled(ex)
+                              Throw ExceptionUtilities.Unreachable
+                          End Try
+
+                          Return Task.CompletedTask
+                      End Function)
+        End Sub
 
         Protected Overrides Sub RegisterObjectBrowserLibraryManager()
             Dim workspace As VisualStudioWorkspace = ComponentModel.GetService(Of VisualStudioWorkspace)()