diff --git a/aspnetcore/blazor/components/integration.md b/aspnetcore/blazor/components/integration.md
index b6e6bfd6b3e4..8da12d79a4b4 100644
--- a/aspnetcore/blazor/components/integration.md
+++ b/aspnetcore/blazor/components/integration.md
@@ -16,15 +16,216 @@ uid: blazor/components/integration
 
 -->
 
-This article explains Razor component integration scenarios for ASP.NET Core apps, including prerendering of Razor components on the server.
+This article explains Razor component integration scenarios for ASP.NET Core apps.
 
-Razor components can be integrated into Razor Pages and MVC apps. When the page or view is rendered, components can be prerendered at the same time. Prerendering can improve [Search Engine Optimization (SEO)](https://developer.mozilla.org/docs/Glossary/SEO) by rendering content for the initial HTTP response that search engines can use to calculate page rank.
+Razor components can be integrated into Razor Pages, MVC, and other types of ASP.NET Core apps. Razor components can also be integrated into any web app, including apps not based on ASP.NET Core, as [custom HTML elements](xref:blazor/components/js-spa-frameworks#blazor-custom-elements).
 
 Use the guidance in the following sections depending on the project's requirements:
 
+<!-- * Blazor support can be [added to an ASP.NET Core app](#add-blazor-support-to-an-aspnet-core-app). -->
 * For interactive components that aren't directly routable from user requests, see the [Use non-routable components in pages or views](#use-non-routable-components-in-pages-or-views) section. Follow this guidance when the app embeds components into existing pages and views with the [Component Tag Helper](xref:mvc/views/tag-helpers/builtin-th/component-tag-helper).
 * For interactive components that are directly routable from user requests, see the [Use routable components](#use-routable-components) section. Follow this guidance when visitors should be able to make an HTTP request in their browser for a component with an [`@page`](xref:mvc/views/razor#page) directive.
 
+<!-- HOLD
+
+## Add Blazor support to an ASP.NET Core app
+
+This section covers adding Blazor support to an ASP.NET Core app.
+
+> [!NOTE]
+> For the examples in this section, the example app's name and namespace is `AspNetCoreApp`.
+
+1. Add a package reference for the [`Microsoft.AspNetCore.Components.WebAssembly.Server`](https://www.nuget.org/packages/Microsoft.AspNetCore.Components.WebAssembly.Server) NuGet package to the app.
+
+   [!INCLUDE[](~/includes/package-reference.md)]
+
+UPDATE 8.0 'Interactivity type' will change to 'Interactive render mode' at RTM
+
+1. Create a donor Blazor Web App, which will provide assets to the app. Follow the guidance in the <xref:blazor/tooling> article, selecting support for the following template features when generating the Blazor Web App.
+
+   > [!IMPORTANT]
+   > For the app's name, use the same name as the ASP.NET Core app, which results in matching app name markup in components and matching namespaces in code. Using the same name/namespace isn't strictly required, as namespaces can be adjusted after assets are moved from the donor app to the ASP.NET Core app. However, time is saved by matching the namespaces at the outset, so that assets can be moved from the donor app to the ASP.NET Core app and used without spending time making manual namespace adjustments.
+
+   * For **Interactivity type**, select **Auto (Server and WebAssembly)** for Visual Studio or use the `-int Auto` option if using the .NET CLI.
+   * Set the **Interactivity location** to **Per page/component** for Visual Studio or ***avoid*** using the `-ai|--all-interactive` option when using the .NET CLI.
+
+1. From the donor Blazor Web App, copy Bootstrap and Blazor styles into the ASP.NET Core project's `wwwroot` folder:
+
+   * `wwwroot/bootstrap` folder
+   * `app.css`
+
+1. From the donor Blazor Web App, copy the entire `.Client` project into the solution folder of the ASP.NET Core app.
+
+   > [!IMPORTANT]
+   > **Don't copy the `.Client` folder into the ASP.NET Core project's folder.** The best approach for organizing .NET solutions is to place each project of the solution into its own folder inside of a top-level solution folder. If a solution folder above the ASP.NET Core project's folder doesn't exist, create one. Next, copy the `.Client` project's folder from the donor Blazor Web App into the solution folder. The final project folder structure should have the following layout:
+   >
+   > * `AspNetCoreAppSolution` (top-level solution folder)
+   >   * `AspNetCoreApp` (original ASP.NET Core project)
+   >   * `AspNetCoreApp.Client` (`.Client` project folder from the donor Blazor Web App)
+   >
+   > For the ASP.NET Core solution file, you can leave it in the ASP.NET Core project's folder. Alternatively, you can move the solution file or create a new one in the top-level solution folder as long as the project references correctly point to the project files (`.csproj`) of the two projects in the solution folder.
+
+1. From the donor Blazor Web App, copy the entire `Components` folder into the ASP.NET Core project folder.
+
+1. In the ASP.NET Core project's `Components` folder, delete the following components from the `Components/Pages` folder:
+
+   * `Home` component (`Home.razor`)
+   * `Weather` component (`Weather.razor`)
+
+1. If you named the donor Blazor Web App when you created the donor project the same as the ASP.NET Core app, the namespaces used by the donated assets match those in the ASP.NET Core app. You shouldn't need to take further steps to match namespaces. If you used a different namespace when creating the donor Blazor Web App project, you must adjust the namespaces across the donated assets to match if you intend to use the rest of this guidance exactly as presented. If the namespaces don't match, ***either*** adjust the namespaces before proceeding ***or*** adjust the namespaces as you following the remaining guidance in this section.
+
+1. Delete the donor Blazor Web App, as it has no further use in this process.
+
+1. Add the `.Client` project to the solution:
+
+   In Visual Studio, right-click the solution in **Solution Explorer** and select **Add** > **Existing Project**. Navigate to the `.Client` folder and select the project file (`.csproj`).
+
+   If using the .NET CLI, use the [`dotnet sln add` command](/dotnet/core/tools/dotnet-sln#add) to add the `.Client` project to the solution.
+
+1. Add a project reference to the ASP.NET Core project for the client project:
+
+   In Visual Studio, right-click the ASP.NET Core project and select **Add** > **Project Reference**. Select the `.Client` project and select **OK**.
+
+   If using the .NET CLI, from the ASP.NET Core project's folder, use the following command:
+
+   ```dotnetcli
+   dotnet add reference ../AspNetCoreApp.Client/AspNetCoreApp.Client.csproj
+   ```
+
+   > [!NOTE]
+   > The preceding command assumes the following:
+   >
+   > * The project file name is `AspNetCoreApp.Client.csproj`.
+   > * The `.Client` project is in a `AspNetCoreApp.Client` folder inside the solution folder. The `.Client` folder is side-by-side with the ASP.NET Core project's folder.
+   >
+   > For more information on the `dotnet add reference` command, see [`dotnet add reference` (.NET documentation)](/dotnet/core/tools/dotnet-add-reference).
+
+1. In the ASP.NET Core project's `Program` file, add a `using` statement to the top of the file for the project's components:
+
+   ```csharp
+   using AspNetCoreApp.Components;
+   ```
+
+   Add the interactive component services (`AddInteractiveServerComponents` and `AddInteractiveWebAssemblyComponents`) with Razor component services (`AddRazorComponents`) before the app is built (the line that calls `builder.Build()`):
+
+   ```csharp
+   builder.Services.AddRazorComponents()
+       .AddInteractiveServerComponents()
+       .AddInteractiveWebAssemblyComponents();
+   ```
+
+   Add [Antiforgery Middleware](xref:blazor/security/index#antiforgery-support) to the request processing pipeline after the call to `app.UseRouting`. If there are calls to `app.UseRouting` and `app.UseEndpoints`, the call to `app.UseAntiforgery` must go between them. A call to `app.UseAntiforgery` must be placed after calls to `app.UseAuthentication` and `app.UseAuthorization`.
+
+   ```csharp
+   app.UseAntiforgery();
+   ```
+
+   Add the interactive render modes (`AddInteractiveServerRenderMode` and `AddInteractiveWebAssemblyRenderMode`) and additional assemblies for the `.Client` project with `MapRazorComponents` before the app is run (the line that calls `app.Run`):
+
+   ```csharp
+   app.MapRazorComponents<App>()
+       .AddInteractiveServerRenderMode()
+       .AddInteractiveWebAssemblyRenderMode()
+       .AddAdditionalAssemblies(typeof(AspNetCoreApp.Client._Imports).Assembly);
+   ```
+
+1. As you add Razor components to the solution, either in the ASP.NET Core project or the `.Client` project, configure the render mode of each component.
+
+   The donor Blazor Web App supplies a `Counter` component to the solution (`Pages/Counter.razor` in the `AspNetCoreApp.Client` project), which can be used for development testing.
+
+   Notice that the `Counter` component in the `.Client` project adopts the Auto render mode either using the `@attribute` ***or*** `@rendermode` directive:
+
+   ```razor
+   @attribute [RenderModeInteractiveAuto]
+   ```
+
+   ```razor
+   @rendermode InteractiveAuto
+   ```
+
+   For any of your ASP.NET Core app components that should also adopt the Auto render mode, place them in the `.Client` project's `Pages` folder (or `Shared` folder for non-routable, shared components) and provide the routable components in the `Pages` folder with ***either*** of the preceding directives, noting that a shared component typically inherits its render mode and doesn't require a directive.
+   
+   Such components render on the server first, then render on the client after the Blazor bundle has been downloaded and the Blazor runtime activates. Keep in mind that component code is ***not*** private using the Auto render mode.
+
+   To further test in development with an interactive server `Counter` component, make a copy of the `Client` project's `Counter` component and change its file name to `Counter2.razor`. Place the file in the ASP.NET Core app (`Pages/Counter2.razor` in the `AspNetCoreApp` project).
+   
+   Open the `Counter2.razor` file and change the route to avoid a conflict with the existing `Counter` component:
+   
+   ```diff
+   - @page "/counter"
+   + @page "/counter-2"
+   ```
+
+   Change the interactive render mode using ***either*** of the following lines:
+   
+   ```razor
+   @attribute [RenderModeInteractiveServer]
+   ```
+
+   ```razor
+   @rendermode InteractiveServer
+   ```
+
+   Change the page title and heading markup to reflect that this is the 2nd counter component in the app:
+
+   ```razor
+   <PageTitle>Counter 2</PageTitle>
+
+   <h1>Counter 2</h1>
+   ```
+
+   Add the `Counter2` component to the `NavMenu` component (`Pages/Layout/NavMenu.razor`):
+
+   ```razor
+   <div class="nav-item px-3">
+       <NavLink class="nav-link" href="counter-2">
+           <span class="bi bi-plus-square-fill" aria-hidden="true"></span> Counter 2
+       </NavLink>
+   </div>
+   ```
+
+   Remove the `Weather` component navigation menu entry from the `NavMenu` component:
+
+   ```diff
+   - <div class="nav-item px-3">
+   -     <NavLink class="nav-link" href="weather">
+   -         <span class="bi bi-list-nested" aria-hidden="true"></span> Weather
+   -     </NavLink>
+   - </div>
+   ```
+
+   For components that should also strictly adopt the interactive server render mode, add ***either*** of the preceding directives to them and leave them in the ASP.NET Core project's `Pages`/`Shared` folders. Such components only ever render on the server. Component code is kept private on the server using the interactive server render mode.
+
+   When the app is run in the next step, navigate to each of the counter components (`/counter` and `/counter-2`) to inspect how they render.
+   
+   If any of your server-side components should also disable prerendering, see <xref:blazor/components/render-modes#prerendering>.
+
+   For any components that should strictly adopt the interactive WebAssembly render mode in the `.Client` project (`Pages` folder of the `AspNetCoreApp.Client` project), explicitly configure the render mode:
+
+   ```razor
+   @attribute [RenderModeInteractiveWebAssembly]
+   ```
+
+   ```razor
+   @rendermode InteractiveWebAssembly
+   ```
+
+   Such components only render on the client after the Blazor bundle has been downloaded and the Blazor runtime activates. Keep in mind that component code is ***not*** private using the interactive WebAssembly render mode.
+
+   For additional information on applying render modes to components, see <xref:blazor/components/render-modes>.
+
+1. Run the solution from the ***ASP.NET Core app*** project:
+
+   For Visual Studio, confirm that the ASP.NET Core project is selected in **Solution Explorer** when running the app.
+   
+   If using the .NET CLI, run the project from the ASP.NET Core project's folder.
+
+   For the `Counter` component of the `.Client` project, navigate to `/counter`.
+
+   If you added the `Counter2` component, which is strictly configured for interactive server rendering, navigate to `/counter-2`.
+
+-->
+
 ## Use non-routable components in pages or views
 
 Use the following guidance to integrate Razor components into pages and views of an existing Razor Pages or MVC app with the [Component Tag Helper](xref:mvc/views/tag-helpers/builtin-th/component-tag-helper).
diff --git a/aspnetcore/migration/70-80.md b/aspnetcore/migration/70-80.md
index f2573c5c3698..c67f885aec3e 100644
--- a/aspnetcore/migration/70-80.md
+++ b/aspnetcore/migration/70-80.md
@@ -26,9 +26,9 @@ This article explains how to update an existing ASP.NET Core 7.0 project to ASP.
 
 ---
 
-## Update .NET Core SDK version in global.json
+## Update the .NET SDK version in `global.json`
 
-If you rely on a [global.json](/dotnet/core/tools/global-json) file to target a specific .NET Core SDK version, update the `version` property to the .NET 8.0 SDK version that's installed. For example:
+If you rely on a [`global.json`](/dotnet/core/tools/global-json) file to target a specific .NET Core SDK version, update the `version` property to the .NET 8.0 SDK version that's installed. For example:
 
 ```diff
 {
@@ -56,7 +56,7 @@ Update the project file's [Target Framework Moniker (TFM)](/dotnet/standard/fram
 
 ## Update package references
 
-In the project file, update each [Microsoft.AspNetCore.*](https://www.nuget.org/packages?q=Microsoft.AspNetCore.*), [Microsoft.EntityFrameworkCore.*](https://www.nuget.org/packages?q=Microsoft.EntityFrameworkCore.*), [Microsoft.Extensions.*](https://www.nuget.org/packages?q=Microsoft.Extensions.*), and [System.Net.Http.Json](https://www.nuget.org/packages/System.Net.Http.Json) package reference's `Version` attribute to 8.00 or later. For example:
+In the project file, update each [`Microsoft.AspNetCore.*`](https://www.nuget.org/packages?q=Microsoft.AspNetCore.*), [`Microsoft.EntityFrameworkCore.*`](https://www.nuget.org/packages?q=Microsoft.EntityFrameworkCore.*), [`Microsoft.Extensions.*`](https://www.nuget.org/packages?q=Microsoft.Extensions.*), and [`System.Net.Http.Json`](https://www.nuget.org/packages/System.Net.Http.Json) package reference's `Version` attribute to 8.00 or later. For example:
 
 ```diff
 <ItemGroup>
@@ -73,64 +73,301 @@ In the project file, update each [Microsoft.AspNetCore.*](https://www.nuget.org/
 
 ## Blazor
 
-We hope to have the Blazor section of this article updated soon.<!--In the meantime, see the following resources: -->
+<!-- UPDATE 8.0 Add API cross-links after RTM -->
 
-### Adopt .NET 8 features
+The following migration scenarios are covered:
 
-After following the guidance earlier in this article to update an app to 8.0, adopt specific features by following the links in <xref:aspnetcore-8#blazor>.
+* [Adopt Blazor Web App conventions](#adopt-blazor-web-app-conventions)
+* [Convert a Blazor Server app into a Blazor Web App](#convert-a-blazor-server-app-into-a-blazor-web-app)
+* [Convert a hosted Blazor WebAssembly app into a Blazor Web App](#convert-a-hosted-blazor-webassembly-app-into-a-blazor-web-app)
 
-<!-- UPDATE 8.0 
+For guidance on adding Blazor support to an ASP.NET Core app, see <xref:blazor/components/integration#add-blazor-support-to-an-aspnet-core-app>.
 
-To adopt all of the [new 8.0 features for Blazor apps](xref:aspnetcore-7#blazor), we recommend the following process:
+## Adopt Blazor Web App conventions
 
-* Create a new 8.0 Blazor project from one of the Blazor project templates. For more information, see <xref:blazor/tooling>.
-* Move the app's components and code to the 8.0 app making modifications to adopt the new 8.0 features. -->
+To optionally adopt all of the new Blazor Web App conventions, we recommend the following process:
 
-<!-- HOLD: See https://github.com/dotnet/AspNetCore.Docs/issues/27848
+* Create a new app from the Blazor Web App project template. For more information, see <xref:blazor/tooling>.
+* Move the your app's components and code to the new Blazor Web App app, making modifications to adopt new features.
+* Update the layout and styles of the Blazor Web App.
 
-### Simplify component parameter binding
+New .NET 8 features are covered in <xref:aspnetcore-8#blazor>. When updating an app from .NET 6 or earlier, see the migration and release notes (*What's new* articles) for intervening releases.
 
-In prior Blazor releases, binding across multiple components required binding to properties with `get`/`set` accessors.
+### Convert a Blazor Server app into a Blazor Web App
 
-In .NET 6 and earlier:
+Blazor Server apps are supported in .NET 8 without any code changes. Use the following guidance to convert a Blazor Server app into an equivalent .NET 8 Blazor Web App, which makes all of the [new .NET 8 features](xref:aspnetcore-8#blazor) available.
 
-```razor
-<NestedGrandchild @bind-GrandchildMessage="BoundValue" />
+> [!IMPORTANT]
+> This section focuses on the minimal changes required to convert a .NET 7 Blazor Server app into a .NET 8 Blazor Web App. To adopt all of the new Blazor Web App conventions, follow the guidance in the [Adopt Blazor Web App conventions](#adopt-blazor-web-app-conventions) section. 
 
-@code {
-    ...
+1. Follow the guidance in the first three sections of this article:
 
-    private string BoundValue
-    {
-        get => ChildMessage ?? string.Empty;
-        set => ChildMessageChanged.InvokeAsync(value);
-    }
-}
-```
+   * [Update the .NET SDK version in `global.json`](#update-the-net-sdk-version-in-globaljson)
+   * [Update the target framework](#update-the-target-framework)
+   * [Update package references](#update-package-references)
 
-In .NET 7, you can use the new `@bind:get` and `@bind:set` modifiers to support two-way data binding and simplify the binding syntax:
+1. Move the contents of the `App` component (`App.razor`) to a new `Routes` component file (`Routes.razor`) added to the project's root folder. Leave the empty `App.razor` file in the app in the project's root folder.
 
-```razor
-<NestedGrandchild @bind-GrandchildMessage:get="ChildMessage" 
-    @bind-GrandchildMessage:set="ChildMessageChanged" />
-```
+1. Add an entry to the `_Imports.razor` file to make shorthand render modes available to the app:
+
+   ```razor
+   @using static Microsoft.AspNetCore.Components.Web.RenderMode
+   ```
+
+1. Move the content in the `_Host` page (`Pages/_Host.cshtml`) to the empty `App.razor` file. Proceed to make the following changes to the `App` component.
+
+   > [!NOTE]
+   > In the following example, the project's namespace is `BlazorServerApp`. Adjust the namespace to match your project.
+
+   Remove the following lines from the top of the file and replace them with a line that injects an <xref:Microsoft.Extensions.Hosting.IHostEnvironment> instance:
+
+   ```diff
+   - @page "/"
+   - @using Microsoft.AspNetCore.Components.Web
+   - @namespace BlazorServerApp.Pages
+   - @addTagHelper *, Microsoft.AspNetCore.Mvc.TagHelpers
+   ```
+
+   ```razor
+   @inject IHostEnvironment Env
+   ```
+
+   Remove the tilde (`~`) from the `href` of the `<base>` tag and replace with the base path for your app:
+
+   ```diff
+   - <base href="~/" />
+   + <base href="/" />
+   ```
+
+   Remove the Component Tag Helper for the `HeadOutlet` component and replace it with the `HeadOutlet` component:
+
+   ```diff
+   - <component type="typeof(HeadOutlet)" render-mode="ServerPrerendered" />
+   ```
+
+   ```razor
+   <HeadOutlet @rendermode="InteractiveServer" />
+   ```
+
+   Remove the Component Tag Helper for the `App` component and replace it with the `Routes` component:
+
+   ```diff
+   - <component type="typeof(App)" render-mode="ServerPrerendered" />
+   ```
+
+   ```razor
+   <Routes @rendermode="InteractiveServer" />
+   ```
+
+   > [!NOTE]
+   > The preceding configuration assumes that the app's components adopt interactive server rendering. For more information, including how to adopt static server rendering, see <xref:blazor/components/render-modes>.
+
+   Remove the Environment Tag Helpers for error UI and replace them with the following Razor markup:
+
+   ```diff
+   - <environment include="Staging,Production">
+   -     An error has occurred. This application may no longer respond until reloaded.
+   - </environment>
+   - <environment include="Development">
+   -     An unhandled exception has occurred. See browser dev tools for details.
+   - </environment>
+   ```
+
+   ```razor
+   @if (Env.IsDevelopment())
+   {
+       <text>
+           An unhandled exception has occurred. See browser dev tools for details.
+       </text>
+   }
+   else
+   {
+       <text>
+           An error has occurred. This app may no longer respond until reloaded.
+       </text>
+   }
+   ```
+
+   Change the Blazor script from `blazor.server.js` to `blazor.web.js`:
+
+   ```diff
+   - <script src="_framework/blazor.server.js"></script>
+   + <script src="_framework/blazor.web.js"></script>
+   ```
+
+1. Delete the `Pages/_Host.cshtml` file.
+
+1. Update `Program.cs`:
+
+   > [!NOTE]
+   > In the following example, the project's namespace is `BlazorServerApp`. Adjust the namespace to match your project.
+
+   Add a `using` statement to the top of the file for the project's namespace:
+
+   ```csharp
+   using BlazorServerApp;
+   ```
+  
+   Replace `AddServerSideBlazor` with `AddRazorComponents` and a chained call to `AddInteractiveServerComponents`.
+   
+   Remove the following line and replace it with Razor component and interactive server component services:
+
+   ```diff
+   - builder.Services.AddServerSideBlazor();
+   ```
+
+   ```csharp
+   builder.Services.AddRazorComponents()
+       .AddInteractiveServerComponents();
+   ```
+
+   Remove the following line and replace it with a call to `MapRazorComponents`, supplying the `App` component as the root component type, and add a chained call to `AddInteractiveServerRenderMode`:
+  
+   ```diff
+   - app.MapBlazorHub();
+   ```
+
+   ```csharp
+   app.MapRazorComponents<App>()
+       .AddInteractiveServerRenderMode();
+   ```
+
+   Remove the following line:
+   
+   ```diff
+   - app.MapFallbackToPage("/_Host");
+   ```
+
+   Add [Antiforgery Middleware](xref:blazor/security/index#antiforgery-support) to the request processing pipeline after the call to `app.UseRouting`. If there are calls to `app.UseRouting` and `app.UseEndpoints`, the call to `app.UseAntiforgery` must go between them. A call to `app.UseAntiforgery` must be placed after calls to `app.UseAuthentication` and `app.UseAuthorization`.
+
+   ```csharp
+   app.UseAntiforgery();
+   ```
+
+1. If the Blazor Server app was configured to disable prerendering, you can continue to disable prerendering for the updated app. In the `App` component, change the value assigned to the `@rendermode` Razor directive attributes for the `HeadOutlet` and `Routes` components.
+
+   Remove the following from the `HeadOutlet` and `Routes` components and replace them with the following `@rendermode` that disables prerendering:
+
+   ```diff
+   - @rendermode="InteractiveServer"
+   ```
+
+   ```razor
+   @rendermode="new InteractiveServerRenderMode(prerender: false)"
+   ```
+
+   For more information, see <xref:blazor/components/render-modes?view=aspnetcore-8.0&preserve-view=true#prerendering>.
+
+### Convert a hosted Blazor WebAssembly app into a Blazor Web App
+
+Blazor WebAssembly apps are supported in .NET 8 without any code changes. Use the following guidance to convert an ASP.NET Core hosted Blazor WebAssembly app into an equivalent .NET 8 Blazor Web App, which makes all of the [new .NET 8 features](xref:aspnetcore-8#blazor) available.
 
 > [!IMPORTANT]
-> The `@bind:get` and `@bind:set` features are receiving further updates at this time. To take advantage of the latest updates, confirm that you've installed the [latest SDK](https://dotnet.microsoft.com/download/dotnet/7.0).
->
-> Using an event callback parameter (`[Parameter] public EventCallback<string> ValueChanged { get; set; }`) isn't supported. Instead, pass an <xref:System.Action>-returning or <xref:System.Threading.Tasks.Task>-returning method to `@bind:set`.
->
-> For more information, see the following resources:
->
-> * [Blazor `@bind:after` not working on .NET 7 RTM release (dotnet/aspnetcore #44957)](https://github.com/dotnet/aspnetcore/issues/44957)
-> * [`BindGetSetAfter701` sample app (javiercn/BindGetSetAfter701 GitHub repository)](https://github.com/javiercn/BindGetSetAfter701)
+> This section focuses on the minimal changes required to convert a .NET 7 ASP.NET Core hosted Blazor WebAssembly app into a .NET 8 Blazor Web App. To adopt all of the new Blazor Web App conventions, follow the guidance in the [Adopt Blazor Web App conventions](#adopt-blazor-web-app-conventions) section. 
+
+1. Follow the guidance in the first three sections of this article:
+
+   * [Update the .NET SDK version in `global.json`](#update-the-net-sdk-version-in-globaljson)
+   * [Update the target framework](#update-the-target-framework)
+   * [Update package references](#update-package-references)
+
+   > [!IMPORTANT]
+   > Using the preceding guidance, update the `Client`, `Server`, and `Shared` projects of the solution.
+
+1. Move the file content from the `Client/wwwroot/index.html` file to a new `App` component file (`App.razor`) created at the root of the `Server` project. After you move the file's contents, delete the `index.html` file.
+
+1. Rename `App.razor` in the `Client` project to `Routes.razor`.
+
+1. In `Routes.razor`, update the value of the `AppAssembly` attribute to `typeof(Program).Assembly`.
+
+1. Add an entry to the `_Imports.razor` file to make shorthand render modes available to the app:
+
+   ```razor
+   @using static Microsoft.AspNetCore.Components.Web.RenderMode
+   ```
+
+1. Make a copy of the `_Imports.razor` file and add it to the `Server` project.
+
+1. Make the following changes to the `App.razor` file:
+
+   Replace the `<title>` tag with the `HeadOutlet` component. Start by removing the `<title>` tag: 
+
+   ```diff
+   - <title>...</title>
+   ```
+
+   Add the `HeadOutlet` component at the end of the `<head>` content with the interactive WebAssembly render mode and prerendering disabled:
+
+   ```razor
+   <HeadOutlet @rendermode="new InteractiveWebAssemblyRenderMode(prerender: false)" />
+   ```
+
+   Replace the following `div` tag with the `Routes` component using the interactive WebAssembly render mode and prerendering disabled:
+   
+   ```diff
+   - <div id="app">
+   -     ...
+   - </div>
+   ```
+
+   ```razor
+   <Routes @rendermode="new InteractiveWebAssemblyRenderMode(prerender: false)"
+   ```
+
+   Update the `blazor.webassembly.js` script to `blazor.web.js`:
+
+   ```diff
+   - <script src="_framework/blazor.webassembly.js"></script>
+   + <script src="_framework/blazor.web.js"></script>
+   ```
+
+1. Remove the following lines from `Client/Program.cs`:
+
+   ```diff
+   - builder.RootComponents.Add<App>("#app");
+   - builder.RootComponents.Add<HeadOutlet>("head::after");
+   ```
+   
+1. Update `Server/Program.cs`:
+
+   Add Razor component and interactive WebAssembly component services to the project. Call `AddRazorComponents` with a chained call to `AddInteractiveWebAssemblyComponents`:
+
+   ```csharp
+   builder.Services.AddRazorComponents()
+       .AddInteractiveWebAssemblyComponents();
+   ```
+
+   Add [Antiforgery Middleware](xref:blazor/security/index#antiforgery-support) to the request processing pipeline immediately after the call to `app.UseRouting`. If there are calls to `app.UseRouting` and `app.UseEndpoints`, the call to `app.UseAntiforgery` must go between them. Calls to `app.UseAntiforgery` must be placed after calls to `app.UseAuthentication` and `app.UseAuthorization`.
+
+   ```csharp
+   app.UseAntiforgery();
+   ```
+
+   Remove the following line:
+   
+   ```diff
+   - app.UseBlazorFrameworkFiles();
+   ```
+
+   Remove the following line and replace it with a call to `MapRazorComponents`, supplying the `App` component as the root component type, and add chained calls to `AddInteractiveWebAssemblyRenderMode` and `AddAdditionalAssemblies`:
+   
+   ```diff
+   - app.MapFallbackToFile("index.html");
+   ```
+
+   ```csharp
+   app.MapRazorComponents<App>()
+       .AddInteractiveWebAssemblyRenderMode()
+       .AddAdditionalAssemblies(typeof({CLIENT APP NAMESPACE}._Imports).Assembly);
+   ```
 
-For more information, see the following content in the *Data binding* article:
+   In the preceding example, the `{CLIENT APP NAMESPACE}` placeholder is the namespace of the `Client` project (for example, `HostedBlazorApp.Client`). Replace the placeholder with the `Client` project's namespace.
 
-* [Introduction](xref:blazor/components/data-binding?view=aspnetcore-7.0)
-* [Bind across more than two components](xref:blazor/components/data-binding?view=aspnetcore-7.0#bind-across-more-than-two-components)
+1. Run the solution from the `Server` project:
 
--->
+   For Visual Studio, confirm that the `Server` project is selected in **Solution Explorer** when running the app.
+   
+   If using the .NET CLI, run the project from the `Server` project's folder.
 
 ## Update Docker images
 
diff --git a/aspnetcore/release-notes/aspnetcore-8.0.md b/aspnetcore/release-notes/aspnetcore-8.0.md
index 8de1edc69330..8b03dc2e32dc 100644
--- a/aspnetcore/release-notes/aspnetcore-8.0.md
+++ b/aspnetcore/release-notes/aspnetcore-8.0.md
@@ -22,8 +22,8 @@ This article is under development and not complete. More information may be foun
 * [What's new in .NET 8 Preview 6](https://devblogs.microsoft.com/dotnet/asp-net-core-updates-in-dotnet-8-preview-6/)
 * [What's new in .NET 8 Preview 7](https://devblogs.microsoft.com/dotnet/asp-net-core-updates-in-dotnet-8-preview-7/)
 * [What's new in .NET 8 Release Candidate 1](https://devblogs.microsoft.com/dotnet/asp-net-core-updates-in-dotnet-8-rc-1/)
-<!--
 * [What's new in .NET 8 Release Candidate 2](https://devblogs.microsoft.com/dotnet/asp-net-core-updates-in-dotnet-8-rc-2/)
+<!--
 * [Announcing ASP.NET Core in .NET 8](https://devblogs.microsoft.com/dotnet/announcing-asp-net-core-in-dotnet-8/)
 -->