.NET Core to .NET branding changes (#33694)

Contributes to #33680

README.md

@@ -3,10 +3,10 @@
 [![Build Status](https://dnceng.visualstudio.com/public/_apis/build/status/dotnet/runtime/runtime?branchName=master)](https://dnceng.visualstudio.com/public/_build/latest?definitionId=686&branchName=master)
 [![Gitter](https://badges.gitter.im/Join%20Chat.svg)](https://gitter.im/dotnet/runtime)
 
-This repo contains the code to build the .NET Core runtime, libraries and shared host (`dotnet`) installers for
-all supported platforms, as well as the sources to .NET Core runtime and libraries.
+This repo contains the code to build the .NET runtime, libraries and shared host (`dotnet`) installers for
+all supported platforms, as well as the sources to .NET runtime and libraries.
 
-## What is .NET Core?
+## What is .NET?
 
 Official Starting Page: https://dotnet.microsoft.com/
 
@@ -33,11 +33,11 @@ Also see info about related [Microsoft .NET Core and ASP.NET Core Bug Bounty Pro
 
 ## Filing issues
 
-This repo should contain issues that are tied to the runtime, the class libraries and frameworks, the installation of the `dotnet` binary (sometimes known as the `muxer`) and installation of the .NET Core runtime and libraries.
+This repo should contain issues that are tied to the runtime, the class libraries and frameworks, the installation of the `dotnet` binary (sometimes known as the `muxer`) and installation of the .NET runtime and libraries.
 
 For other issues, please use the following repos:
 
-- For overall .NET Core SDK issues, file in the [dotnet/sdk](https://github.com/dotnet/sdk) repo
+- For overall .NET SDK issues, file in the [dotnet/sdk](https://github.com/dotnet/sdk) repo
 - For ASP.NET issues, file in the [dotnet/aspnetcore](https://github.com/dotnet/aspnetcore) repo.
 
 ## Useful Links
@@ -49,7 +49,7 @@ For other issues, please use the following repos:
 
 ## .NET Foundation
 
-.NET Core is a [.NET Foundation](https://www.dotnetfoundation.org/projects) project.
+.NET Runtime is a [.NET Foundation](https://www.dotnetfoundation.org/projects) project.
 
 There are many .NET related projects on GitHub.
 

THIRD-PARTY-NOTICES.TXT

-.NET Core uses third-party libraries or other resources that may be
-distributed under licenses different than the .NET Core software.
+.NET Runtime uses third-party libraries or other resources that may be
+distributed under licenses different than the .NET Runtime software.
 
 In the event that we accidentally failed to list a required notice, please
 bring it to our attention. Post an issue or email us:

docs/coding-guidelines/api-guidelines/nullability.md

 # Nullability annotations
 
-C# 8 provides an opt-in feature that allows for the compiler to  track reference type nullability in order to catch potential null dereferences.  We are adopting that feature across .NET Core's libraries, working up from the bottom of the stack.  We're doing this for three primary reasons, in order of importance:
+C# 8 provides an opt-in feature that allows for the compiler to  track reference type nullability in order to catch potential null dereferences.  We are adopting that feature across .NET's libraries, working up from the bottom of the stack.  We're doing this for three primary reasons, in order of importance:
 
-- **To annotate the .NET Core surface area with appropriate nullability annotations.**  While this could be done solely in the reference assemblies, we're doing it first in the implementation to help validate the selected annotations.
+- **To annotate the .NET surface area with appropriate nullability annotations.**  While this could be done solely in the reference assemblies, we're doing it first in the implementation to help validate the selected annotations.
 - **To help validate the nullability feature itself.**  With millions of lines of C# code, we have a very large and robust codebase with which to try out the feature and find areas in which it shines and areas in which we can improve it.  The work to annotate System.Private.CoreLib in .NET Core 3.0 helped to improve the feature as shipped in C# 8, and annotating the rest of the libraries will continue to be helpful in this regard.
-- **To find null-related bugs in .NET Core itself.** We expect to find relatively few meaningful bugs, due to how relatively well-tested the codebases are and how long they've been around.
+- **To find null-related bugs in .NET Runtime itself.** We expect to find relatively few meaningful bugs, due to how relatively well-tested the codebases are and how long they've been around.
 
 ## Breaking Change Guidance
 

docs/coding-guidelines/cross-platform-performance-and-eventing.md

@@ -252,7 +252,7 @@ Given the significant work required to bring all of this infrastructure up, this
 
 We’ll use the following scenarios when defining priorities:
 
-- P1: Performance analysis in support of bring-up of the .NET Core runtime and framework on Linux and OS X.
+- P1: Performance analysis in support of bring-up of the .NET runtime and framework on Linux and OS X.
 - P2: Performance analysis of ASP.NET running on .NET Core on Linux and OS X.
 
 To support these scenarios, we need the following capabilities:

docs/design/features/assemblyloadcontext.md

@@ -13,7 +13,7 @@ In .NET Core, we have exposed a [managed API surface](https://github.com/dotnet/
 ## Types of LoadContext
 ### Default LoadContext
 
-Every .NET Core app has a **LoadContext** instance created during .NET Core Runtime startup that we will refer to as the *Default LoadContext*. All application assemblies (including their transitive closure) are loaded within this **LoadContext** instance.
+Every .NET app has a **LoadContext** instance created during .NET Runtime startup that we will refer to as the *Default LoadContext*. All application assemblies (including their transitive closure) are loaded within this **LoadContext** instance.
 
 ### Custom LoadContext
 For scenarios that wish to have isolation between loaded assemblies, applications can create their own **LoadContext** instance by deriving from **System.Runtime.Loader.AssemblyLoadContext** type and loading the assemblies within that instance.
@@ -46,7 +46,7 @@ If the *Default LoadContext* fallback also did not resolve the load (or was not
 
 ## Constraints
 
-* **System.Private.CoreLib.dll** is only loaded once, and into the **Default LoadContext**, during the .NET Core Runtime startup as it is a logical extension of the same. It cannot be loaded into **Custom LoadContext**.
+* **System.Private.CoreLib.dll** is only loaded once, and into the **Default LoadContext**, during the .NET Runtime startup as it is a logical extension of the same. It cannot be loaded into **Custom LoadContext**.
 * Currently, custom **LoadContext** cannot be unloaded once created. This is a feature we are looking into for a future release.
 * If an attempt is made to load a [Ready-To-Run (R2R)](https://github.com/dotnet/runtime/blob/master/docs/design/coreclr/botr/readytorun-overview.md) image from the same location in multiple load context's, then precompiled code can only be used from the first image that got loaded. The subsequent images will have their code JITted. This happens because subsequent loading binaries from the same location results in OS mapping them to the same memory as the previous one was mapped to and thus, could corrupt internal state information required for use precompiled code.
 

docs/design/features/host-components.md

@@ -30,7 +30,7 @@ The main reason to split the entry-point host and the `hostfxr` is to allow for
 ## Host Policy
 The host policy library implements all the policies to actually load the runtime, apply configuration, resolve all app's dependencies and calls the runtime to run the app or load the required component.
 
-The host policy library lives in the runtime folder and is versioned alongside it. Which version is used is specified by the app as it specifies which version of the .NET Core runtime to use (done directly or indirectly by referencing the `Microsoft.NETCore.App` framework, or carrying everything app-local).
+The host policy library lives in the runtime folder and is versioned alongside it. Which version is used is specified by the app as it specifies which version of the .NET runtime to use (done directly or indirectly by referencing the `Microsoft.NETCore.App` framework, or carrying everything app-local).
 
 Host policy library reads the `.deps.json` file of the app (and the `.deps.json` of all the referenced frameworks). It resolves all the assemblies specified in the `.deps.json` for the app and frameworks and creates a list of assembly paths (also called TPA). It does a similar thing for native dependencies as well.
 

docs/design/features/host-download-urls.md

@@ -9,14 +9,14 @@ The host uses different URLs for different scenarios. These different URLs are d
 
 This URL is part of the output of `dotnet --info`:
 ```console
-To install additional .NET Core runtimes or SDKs:
+To install additional .NET runtimes or SDKs:
   https://aka.ms/dotnet-download
 ```
 
 It's also part of the error when an SDK command is executed and there's no SDK installed:
 ```
-  It was not possible to find any installed .NET Core SDKs
-  Did you mean to run .NET Core SDK commands? Install a .NET Core SDK from:
+  It was not possible to find any installed .NET SDKs
+  Did you mean to run .NET SDK commands? Install a .NET SDK from:
       https://aka.ms/dotnet-download
 ```
 

docs/design/features/host-error-codes.md

@@ -46,7 +46,7 @@ For example the `hostfxr` may look at its location and try to deduce the locatio
 
 * `LibHostInitFailure` (`0x8000808e`) - Initialization of the `hostpolicy` library failed. The `corehost_load` method takes a structure with lot of initialization parameters. If the version of this structure doesn't match the expected value, this error code is returned. This would in general mean incompatibility between the `hostfxr` and `hostpolicy`, which should really only happen if somehow a newer `hostpolicy` is used by older `hostfxr`. This typically means corrupted installation.
 
-* `LibHostSdkFindFailure` (`0x80008091`) - Failure to find the requested SDK. This happens in the `hostfxr` when an SDK (also called CLI) command is used with `dotnet`. In this case the hosting layer tries to find an installed .NET Core SDK to run the command on. The search is based on deduced install location and on the requested version from potential `global.json` file. If either no matching SDK version can be found, or that version exists, but it's missing the `dotnet.dll` file, this error code is returned.
+* `LibHostSdkFindFailure` (`0x80008091`) - Failure to find the requested SDK. This happens in the `hostfxr` when an SDK (also called CLI) command is used with `dotnet`. In this case the hosting layer tries to find an installed .NET SDK to run the command on. The search is based on deduced install location and on the requested version from potential `global.json` file. If either no matching SDK version can be found, or that version exists, but it's missing the `dotnet.dll` file, this error code is returned.
 
 * `LibHostInvalidArgs` (`0x80008092`) - Arguments to `hostpolicy` are invalid. This is used in three unrelated places in the `hostpolicy`, but in all cases it means the component calling `hostpolicy` did something wrong:
   * Command line arguments for the app - the failure would typically mean that wrong argument was passed or such. For example if the application main assembly is not specified on the command line. On its own this should not happen as `hostfxr` should have parsed and validated all command line arguments.

docs/design/features/localization-options.md

@@ -2,7 +2,7 @@
 
 The .NET Core host and runtime contain messages that can be displayed to both end-users and developers. Currently, all such messages are displayed in English.
 
-Other managed components built on top of .NET Core (e.g. SDK, WinForms, WPF) have already been localized, so a process already exists for handling translation and localizing assets, while the .NET Core runtime handles satellite assembly loading. The host and runtime are different in that they have messages that originate from native components and must continue to do so. While the runtime does contain some managed resources, this document focusses on localization of native resources.
+Other managed components built on top of .NET Runtime (e.g. SDK, WinForms, WPF) have already been localized, so a process already exists for handling translation and localizing assets, while the runtime handles satellite assembly loading. The host and runtime are different in that they have messages that originate from native components and must continue to do so. While the runtime does contain some managed resources, this document focusses on localization of native resources.
 
 The goal is to support:
 
@@ -63,7 +63,7 @@ Some infrastructure is in place for loading of resources on Windows, but is not
 
 Each host component will include English resource strings by default. If the resource for the appropriate locale could not be found, the host components can always fall back to English.
 
-`dotnet`, `hostfxr`, and `hostpolicy` will each have separate resources that will be installed by the .NET Core runtime. These components can be different versions, so their resources must be separate.
+`dotnet`, `hostfxr`, and `hostpolicy` will each have separate resources that will be installed by the .NET runtime. These components can be different versions, so their resources must be separate.
 
 `apphost` will have a single localized message. All languages will be included in the executable itself. The message will direct the user to a URL that will contain localized content.
 
@@ -109,7 +109,7 @@ Possible options for hosts:
   - If the hosts are newer than installed runtime, new messages would not be localized
   - Issues:
     - Compatibility concerns for resource IDs / format values
-    - Awkward split deployment since `*host` components are not normally part of the .NET Core runtime install
+    - Awkward split deployment since `*host` components are not normally part of the .NET runtime install
 
   - Options:
     1. Separate resource for each host
@@ -121,7 +121,7 @@ Possible options for hosts:
 
 `comhost`, `ijwhost`, `winrthost`, and `nethost` are designed to be consumed by a component that .NET Core does not own and intentionally do not show messages to the user. As such, they sit at a low priority for localization support.
 
-`apphost` is the end-user-facing host. The amount of logic and messaging in `apphost` is intentionally limited. The most important message it contains for an end-user is for the missing .NET Core runtime scenario, so it should not rely on resources installed via the .NET Core runtime. 
+`apphost` is the end-user-facing host. The amount of logic and messaging in `apphost` is intentionally limited. The most important message it contains for an end-user is for the missing .NET runtime scenario, so it should not rely on resources installed via the .NET runtime. 
 
 Embedding resources in the `apphost` would make for the most stream-lined user experience (particularly around deployment). Since the `apphost` is sensitive to size, the number of messages will be pared down to one generic localized message which directs the user to a URL.
 
@@ -167,10 +167,10 @@ It is also an option to create tooling directly integrated in the dotnet/runtime
 Each platform has its own standard way and file formats for handling localization. There are two main approaches that can be taken here:
   1. Convert a base format to platform-specific localization formats and use platform-specific localization support
       - Requires a tool/script to convert file formats at build time
-      - Uses platform support and standard localization methods that the .NET Core team will not need to maintain
+      - Uses platform support and standard localization methods that the .NET team will not need to maintain
       - Different method for handling localized resources on each platform
   2. Create a custom solution: storage format for string resources, tools for generation from the [translated assets (.xlf)](#translated-assets), and implementation for reading
-      - Requires design of completely custom support that will need to be maintained by the .NET Core team on all platforms
+      - Requires design of completely custom support that will need to be maintained by the .NET team on all platforms
       - Allows support for both string resources from file or memory
       - All platforms could use the same method for handling localized resources
 

docs/design/features/native-hosting.md

 # Native hosting
 
-Native hosting is the ability to host the .NET Core runtime in an arbitrary process, one which didn't start from .NET Core produced binaries.
+Native hosting is the ability to host the .NET runtime in an arbitrary process, one which didn't start from .NET Core produced binaries.
 
 #### Terminology
 * "native host" - the code which uses the proposed APIs. Can be any non .NET Core application (.NET Core applications have easier ways to perform these scenarios).
@@ -18,21 +18,21 @@ App (native or .NET Core both) which needs to use some of the other services pro
 
 ## Existing support
 * **C-style ABI in `coreclr`**
-`coreclr` exposes ABI to host the .NET Core runtime and run managed code already using C-style APIs. See this [header file](https://github.com/dotnet/runtime/blob/master/src/coreclr/src/hosts/inc/coreclrhost.h) for the exposed functions.
-This API requires the native host to locate the runtime and to fully specify all startup parameters for the runtime. There's no inherent interoperability between these APIs and the .NET Core SDK.
+`coreclr` exposes ABI to host the .NET runtime and run managed code already using C-style APIs. See this [header file](https://github.com/dotnet/runtime/blob/master/src/coreclr/src/hosts/inc/coreclrhost.h) for the exposed functions.
+This API requires the native host to locate the runtime and to fully specify all startup parameters for the runtime. There's no inherent interoperability between these APIs and the .NET SDK.
 * **COM-style ABI in `coreclr`**
-`coreclr` exposes COM-style ABI to host the .NET Core runtime and perform a wide range of operations on it. See this [header file](https://github.com/dotnet/runtime/blob/master/src/coreclr/src/pal/prebuilt/inc/mscoree.h) for more details.
+`coreclr` exposes COM-style ABI to host the .NET runtime and perform a wide range of operations on it. See this [header file](https://github.com/dotnet/runtime/blob/master/src/coreclr/src/pal/prebuilt/inc/mscoree.h) for more details.
 Similarly to the C-style ABI the COM-style ABI also requires the native host to locate the runtime and to fully specify all startup parameters.
-There's no inherent interoperability between these APIs and the .NET Core SDK.
+There's no inherent interoperability between these APIs and the .NET SDK.
 The COM-style ABI is deprecated and should not be used going forward.
 * **`hostfxr` and `hostpolicy` APIs**
 The hosting layer of .NET Core already exposes some functionality as C-style ABI on either the `hostfxr` or `hostpolicy` libraries. These can execute application, determine available SDKs, determine native dependency locations, resolve component dependencies and so on.
-Unlike the above `coreclr` based APIs these don't require the caller to fully specify all startup parameters, instead these APIs understand artifacts produced by .NET Core SDK making it much easier to consume SDK produced apps/libraries.
+Unlike the above `coreclr` based APIs these don't require the caller to fully specify all startup parameters, instead these APIs understand artifacts produced by .NET SDK making it much easier to consume SDK produced apps/libraries.
 The native host is still required to locate the `hostfxr` or `hostpolicy` libraries. These APIs are also designed for specific narrow scenarios, any usage outside of these bounds is typically not possible.
 
 
 ## Scope
-This document focuses on hosting which cooperates with the .NET Core SDK and consumes the artifacts produced by building the managed app/libraries directly. It completely ignores the COM-style ABI as it's hard to use from some programming languages.
+This document focuses on hosting which cooperates with the .NET SDK and consumes the artifacts produced by building the managed app/libraries directly. It completely ignores the COM-style ABI as it's hard to use from some programming languages.
 
 As such the document explicitly excludes any hosting based on directly loading `coreclr`. Instead it focuses on using the existing .NET Core hosting layer in new ways. For details on the .NET Core hosting components see [this document](https://github.com/dotnet/runtime/tree/master/docs/design/features/host-components.md).
 
@@ -61,7 +61,7 @@ At the same time add the ability to pass additional runtime properties when star
 ## New host binary for finding `hostfxr`
 New library `nethost` which provides a way to locate the right `hostfxr`.
 This is a dynamically loaded library (`.dll`, `.so`, `.dylib`). For ease of use there is a header file for C/C++ apps as well as `.lib` for easy linking on Windows.
-Native hosts ship this library as part of the app. Unlike the `apphost`, `comhost` and `ijwhost`, the `nethost` will not be directly supported by the .NET Core SDK since it's target usage is not from .NET Core apps.
+Native hosts ship this library as part of the app. Unlike the `apphost`, `comhost` and `ijwhost`, the `nethost` will not be directly supported by the .NET SDK since it's target usage is not from .NET Core apps.
 
 The `nethost` is part of the `Microsoft.NETCore.DotNetAppHost` package. Users are expected to either download the package directly or rely on .NET SDK to pull it down.
 

docs/design/features/net-core-applications.md

-# .NET Core Applications
-
-NETCoreApp is the [target framework](https://docs.nuget.org/Create/TargetFrameworks) that represents .NET Core applications
-
-Property | Value
----------|---------
-Target framework identifier | `.NETCoreApp`
-Target framework version | `3.0`
-Target framework moniker | `.NETCoreApp,Version=v3.0`
-Friendly name | .NET Core Application
-NuGet folder name | `netcoreapp3.0`
-NETStandard version supported | `netstandard2.1`
-
-## FAQ
-**Q: What is a .NET Core application?**  
-**A:** A .NET Core application is an application that can run on any .NET Core runtime: CoreCLR (current), Mono (future). It can run on one of many .NET core platforms (Windows, OSX, Linux).  It relies on the host provided by the given runtime.  It's a composable framework built from the packages on which the application depends.  Its assembly loading policy permits newer versions of dependencies without any application configuration (e.g.: BindingRedirects are not required).
-
-**Q: Can I share source between a .NET Core application, and other target frameworks?**  
-**A:** Yes.  Most of the API supported by .NET Core application is also part of .NET Standard.  That source could be compiled as a .NET Standard library and shared with a .NET Core application and a .NET Framework application as a binary.  Alternatively, the source could be shared and cross-compiled between a .NET Core application and a .NET Framework application.
-
-**Q: Can a .NET Core application depend on more packages than just those in the `Microsoft.NETCore.App` package?**  
-**A:** Yes.  The contents of `Microsoft.NETCore.App` at a particular version are guaranteed to run on every platform where that version .NET Core is released.  Packages outside this set can be used but don't come with that guarantee.  For instance, if a package is not part of `Microsoft.NETCore.App` and needs to be cross-compiled specifically for a new OS, there is no guarantee that it will be re-released when .NET Core supports that new OS.
-
-**Q: Can a .NET Core application depend on platform specific packages like `Microsoft.Win32.Registry`?**  
-**A:** Yes, but it will only run on the platforms that support those packages.
-
-**Q: How is this different than `.NETCore`?**  
-**A:** The `.NETCore` target framework represents Windows 8, Windows 8.1, and Universal Windows Platform applications.  For compatibility purposes this moniker cannot be reused for “.NET Core applications”.  The branding overlap is unfortunate.
-
-**Q: How is this different than `.NETStandard`?**  
-**A:** The `NETStandard` target framework is an abstract target framework that represents API surface of many frameworks and platforms.  As such `NETStandard` assemblies can run on any platform that supports the `NETStandard` targeted by that assembly, for example: .NET Desktop, Windows Phone, Universal Windows Platform applications, .NET Core applications, etc.  `NETCoreApplication` is a concrete target framework that represents a single platform with both API surface and implementation.  .NET Core applications are runnable on their own.  .NETStandard libraries must be published-for or consumed-by a specific concrete target framework to be used in that type of application.
-
-**Q: How is this different than `.NETFramework`, AKA: Full .NET, Desktop .NET, Big .NET, old .NET?**  
-**A:** `.NETFramework` is another concrete framework like `.NETCoreApp` but has a different implementation and runtime and supports a different set of API.  Both `.NETFramework` and `.NETCoreApp` support a common version of `.NETStandard` and the API it exposes.  As such a `.NETStandard` assembly can be used by both `.NETFramework` and `.NETCoreApp`, but a `.NETCoreApp` assembly is not meant to run on `.NETFramework`, nor is a `.NETFramework` assembly meant to run on `.NETCoreApp`.

docs/design/features/tiered-compilation-guide.md

@@ -22,7 +22,7 @@ Tiered Compilation allows the .NET runtime to substitute different assembly code
 
 Tiered compilation is enabled by default from .NET Core 2.2 preview 2 and in 3.0 daily builds.
 
-- Download the .NET Core SDK from the [download archives](https://www.microsoft.com/net/download/archives)
+- Download the .NET SDK from the [download archives](https://www.microsoft.com/net/download/archives)
   - For the latest pre-release installers, download a [daily build](https://github.com/dotnet/core/blob/master/daily-builds.md)
 - For .NET Core 2.1 and 2.2 preview 1, tiered compilation may be enabled in any of the following ways ([instructions](https://github.com/aspnet/JitBench/blob/tiered_compilation_demo/README.md#16-run-the-app-with-tiered-compilation-enabled)):
   - In `<app>.csproj` before the build
@@ -30,7 +30,7 @@ Tiered compilation is enabled by default from .NET Core 2.2 preview 2 and in 3.0
   - With an environment variable before running the app (in a console, or at user or system level)
 - Ensure that the `<app>.csproj` is targeting the correct `TargetFramework` and `RuntimeFrameworkVersion`
   - `TargetFramework` should be `netcoreapp3.0` or `netcoreapp2.2`, etc.
-  - `RuntimeFrameworkVersion` should be a .NET Core runtime version corresponding to the above
+  - `RuntimeFrameworkVersion` should be a .NET runtime version corresponding to the above
     - `dotnet --info` lists the available runtimes versions, use the version for Microsoft.NETCore.App
     - For .NET Core 2.2 preview 2, it is `2.2.0-preview2-26905-02`
 - Run the app, and see [the demo](https://github.com/aspnet/JitBench/blob/tiered_compilation_demo/README.md#part-2---exploring-the-application-behavior) about how to see tiered compilation in action

docs/project/copyright.md

 Copyright
 =========
 
-The .NET Core copyright is held by ".NET Foundation and Contributors".
+The .NET project copyright is held by ".NET Foundation and Contributors".
 
 The [.NET Foundation](http://www.dotnetfoundation.org/) is an independent organization that encourages open development and collaboration around the .NET ecosystem.
 
 Source License
 --------------
 
-The .NET Core project uses multiple licenses for the various project repositories.
+The .NET project uses multiple licenses for the various project repositories.
 
-- The [MIT License](https://opensource.org/licenses/MIT) is used by most repositories for [code](https://github.com/dotnet/runtime/).
-- The  [Apache 2 License](https://opensource.org/licenses/Apache-2.0) is also used by some projects for [code](https://github.com/dotnet/roslyn/).
+- The [MIT License](https://opensource.org/licenses/MIT) is used for [code](https://github.com/dotnet/runtime/).
 - The [Creative Commons Attribution 4.0 International Public License (CC-BY)](https://creativecommons.org/licenses/by/4.0/) is used for [documentation](https://github.com/dotnet/docs/) and [swag](https://github.com/dotnet/swag).
 
 Binary License
 --------------
 
-.NET Core distributions are licensed with a variety of licenses, dependent on the content. By default, the MIT license is used, the exact same as the [source license](https://github.com/dotnet/core/blob/master/LICENSE.TXT), with the same copyright holder. There are some cases where that isn't possible because a given component includes a proprietary Microsoft binary. This is typically only the case for Windows distributions.
+.NET distributions are licensed with a variety of licenses, dependent on the content. By default, the MIT license is used, the exact same as the [source license](https://github.com/dotnet/core/blob/master/LICENSE.TXT), with the same copyright holder. There are some cases where that isn't possible because a given component includes a proprietary Microsoft binary. This is typically only the case for Windows distributions.
 
 The following rules are used for determining the binary license:
 
-- .NET Core binary distributions (zips, nuget packages, …) are licensed as MIT (identical to the [.NET Core source license](https://github.com/dotnet/core/blob/master/LICENSE.TXT)).
-- The license link (if there is one) should point to the repository where the file came from, for example: [dotnet/corefx](https://github.com/dotnet/runtime/blob/master/LICENSE.TXT).
-- If the contained binaries are built from multiple .NET Core repositories, the license should point to [dotnet/core](https://github.com/dotnet/core/blob/master/LICENSE.TXT).
+- .NET binary distributions (zips, nuget packages, …) are licensed as MIT (identical to the [.NET source license](https://github.com/dotnet/core/blob/master/LICENSE.TXT)).
+- The license link (if there is one) should point to the repository where the file came from, for example: [dotnet/runtime](https://github.com/dotnet/runtime/blob/master/LICENSE.TXT).
+- If the contained binaries are built from multiple .NET repositories, the license should point to [dotnet/core](https://github.com/dotnet/core/blob/master/LICENSE.TXT).
 - If the contents are not 100% open source, the distribution should be licensed with the [.NET Library license](https://www.microsoft.com/net/dotnet_library_license.htm).
-- It is OK for licensing to be asymmetric for a single distribution type. For example, it’s possible that the .NET Core SDK distribution might be fully open source for Linux but include a closed-source component on Windows. In this case, the SDK would be licensed as MIT on Linux and use the .NET Library License on Windows. It is better to have more open licenses than less.
+- It is OK for licensing to be asymmetric for a single distribution type. For example, it’s possible that the .NET SDK distribution might be fully open source for Linux but include a closed-source component on Windows. In this case, the SDK would be licensed as MIT on Linux and use the .NET Library License on Windows. It is better to have more open licenses than less.
 - It is OK for the source and binary licenses not to match. For example, the source might be Apache 2 but ships as an MIT binary.  The third party notices file should capture the Apache 2 license. This only works for a permissive licenses, however, we have limited the project to that class of licenses already. The value of this approach is that binary licenses are uniform.
 
 Patents

docs/project/dogfooding.md

 # How to get up and running on .NET Core
 
 This document provides the steps necessary to consume a nightly build of
-.NET Core runtime and SDK.
+.NET runtime and SDK.
 
 Please note that these steps are likely to change as we're simplifying
 this experience. Make sure to consult this document often.
 
 ## Install prerequisites
 
-1. Acquire the latest nightly .NET Core SDK by downloading the zip or tarball listed in https://github.com/dotnet/core-sdk#installers-and-binaries (for example, https://dotnetcli.blob.core.windows.net/dotnet/Sdk/master/dotnet-sdk-latest-win-x64.zip ) into a new folder, for instance `C:\dotnet`.
+1. Acquire the latest nightly .NET SDK by downloading the zip or tarball listed in https://github.com/dotnet/core-sdk#installers-and-binaries (for example, https://dotnetcli.blob.core.windows.net/dotnet/Sdk/master/dotnet-sdk-latest-win-x64.zip ) into a new folder, for instance `C:\dotnet`.
 
 2. By default, the dotnet CLI will use the globally installed SDK if it matches the major/minor version you request and has a higher revision. To force it to use the locally installed SDK, you must set an environment variable `DOTNET_MULTILEVEL_LOOKUP=0` in your shell. You can use `dotnet --info` to verify what version of the Shared Framework it is using.
 
-3. Reminder: if you are using a local copy of the dotnet CLI, take care that when you type `dotnet` you do not inadvertently pick up a different copy that you may have in your path. On Windows, for example, if you use a Command Prompt, a global copy may be in the path, so use the fully qualified path to your local `dotnet` (e.g. `C:\dotnet\dotnet.exe`). If you receive an error "error NETSDK1045: The current .NET SDK does not support targeting .NET Core 3.0." then you may be executing an older `dotnet`.
+3. Reminder: if you are using a local copy of the dotnet CLI, take care that when you type `dotnet` you do not inadvertently pick up a different copy that you may have in your path. On Windows, for example, if you use a Command Prompt, a global copy may be in the path, so use the fully qualified path to your local `dotnet` (e.g. `C:\dotnet\dotnet.exe`). If you receive an error "error NETSDK1045:  The current .NET SDK does not support targeting .NET Core 5.0." then you may be executing an older `dotnet`.
 
 After setting up dotnet you can verify you are using the dogfooding version by executing `dotnet --info`. Here is an example output at the time of writing:
 ```
 >dotnet --info
 .NET Core SDK (reflecting any global.json):
- Version:   3.0.100-preview-009844
- Commit:    fa073dacc4
+ Version:   5.0.100-preview.1.20167.6
+ Commit:    00255dd10b
 
 Runtime Environment:
  OS Name:     Windows
- OS Version:  10.0.17134
+ OS Version:  10.0.18363
  OS Platform: Windows
  RID:         win10-x64
- Base Path:   C:\dotnet\sdk\3.0.100-preview-009844\
+ Base Path:   c:\dotnet\sdk\5.0.100-preview.1.20167.6\
 
 Host (useful for support):
-  Version: 3.0.0-preview-27218-01
-  Commit:  d40b87f29d
+  Version: 5.0.0-preview.1.20120.5
+  Commit:  3c523a6a7a
 
 .NET Core SDKs installed:
-  3.0.100-preview-009844 [C:\dotnet\sdk]
+  5.0.100-preview.1.20167.6 [c:\dotnet\sdk]
 
 .NET Core runtimes installed:
-  Microsoft.AspNetCore.App 3.0.0-preview-18579-0056 [C:\dotnet\shared\Microsoft.AspNetCore.App]
-  Microsoft.NETCore.App 3.0.0-preview-27218-01 [C:\dotnet\shared\Microsoft.NETCore.App]
-  Microsoft.WindowsDesktop.App 3.0.0-alpha-27218-3 [C:\dotnet\shared\Microsoft.WindowsDesktop.App]
+  Microsoft.AspNetCore.App 5.0.0-preview.1.20124.5 [c:\dotnet\shared\Microsoft.AspNetCore.App]
+  Microsoft.NETCore.App 5.0.0-preview.1.20120.5 [c:\dotnet\shared\Microsoft.NETCore.App]
+  Microsoft.WindowsDesktop.App 5.0.0-preview.1.20127.5 [c:\dotnet\shared\Microsoft.WindowsDesktop.App]
 
 To install additional .NET Core runtimes or SDKs:
   https://aka.ms/dotnet-download
@@ -82,18 +82,17 @@ Rinse and repeat!
 ## Advanced Scenario - Using a nightly build of Microsoft.NETCore.App
 
 When using the above instructions, your application will run against the same
-.NET Core runtime that comes with the SDK. That works fine to get up and
+.NET runtime that comes with the SDK. That works fine to get up and
 running quickly. However, there are times when you need to use a nightly build
 of Microsoft.NETCore.App which hasn't made its way into the SDK yet. To enable
 this, there are two options you can take.
 
 ### Option 1: Framework-dependent
 
-This is the default case for applications - running against an installed .NET Core
-runtime.
+This is the default case for applications - running against an installed .NET runtime.
 
-1. You still need to install the prerequisite .NET Core SDK from above.
-2. Optionally, install the specific .NET Core runtime you require:
+1. You still need to install the prerequisite .NET SDK from above.
+2. Optionally, install the specific .NET runtime you require:
     - https://github.com/dotnet/core-sdk#installers-and-binaries
 3. Modify your .csproj to reference the nightly build of Microsoft.NETCore.App
 
@@ -101,9 +100,9 @@ runtime.
   <PropertyGroup>
     <OutputType>Exe</OutputType>
     <!-- Ensure that the target framework is correct e.g. 'netcoreapp5.0' -->
-    <TargetFramework>netcoreapp3.0</TargetFramework>
-    <!-- modify version in this line with one reported by `dotnet --info` under ".NET Core runtimes installed" -> Microsoft.NETCore.App -->
-    <RuntimeFrameworkVersion>3.0.0-preview-27225-1</RuntimeFrameworkVersion>
+    <TargetFramework>netcoreapp5.0</TargetFramework>
+    <!-- modify version in this line with one reported by `dotnet --info` under ".NET runtimes installed" -> Microsoft.NETCore.App -->
+    <RuntimeFrameworkVersion>5.0.0-preview.1.20120.5</RuntimeFrameworkVersion>
   </PropertyGroup>
 ```
 
@@ -114,9 +113,9 @@ $ dotnet run
 
 ### Option 2: Self-contained
 
-In this case, the .NET Core runtime will be published along with your application.
+In this case, the .NET runtime will be published along with your application.
 
-1. You still need to install the prerequisite .NET Core SDK from above.
+1. You still need to install the prerequisite .NET SDK from above.
 2. Modify your .csproj to reference the nightly build of Microsoft.NETCore.App *and*
 make it self-contained by adding a RuntimeIdentifier (RID).
 
@@ -124,10 +123,10 @@ make it self-contained by adding a RuntimeIdentifier (RID).
   <PropertyGroup>
     <OutputType>Exe</OutputType>
     <!-- Ensure that the target framework is correct e.g. 'netcoreapp5.0' -->
-    <TargetFramework>netcoreapp3.0</TargetFramework>
-    <!-- modify build in this line with version reported by `dotnet --info` as above under ".NET Core runtimes installed" -> Microsoft.NETCore.App -->
+    <TargetFramework>netcoreapp5.0</TargetFramework>
+    <!-- modify build in this line with version reported by `dotnet --info` as above under ".NET runtimes installed" -> Microsoft.NETCore.App -->
     <!-- moreover, this can be any valid Microsoft.NETCore.App package version from https://dotnetfeed.blob.core.windows.net/dotnet-core/index.json -->
-    <RuntimeFrameworkVersion>3.0.0-preview-27218-01</RuntimeFrameworkVersion>
+    <RuntimeFrameworkVersion>5.0.0-preview.1.20120.5</RuntimeFrameworkVersion>
     <RuntimeIdentifier>win-x64</RuntimeIdentifier> <!-- RID to make it self-contained -->
   </PropertyGroup>
 ```
@@ -135,7 +134,7 @@ make it self-contained by adding a RuntimeIdentifier (RID).
 ```
 $ dotnet restore
 $ dotnet publish
-$ bin\Debug\netcoreapp3.0\win-x64\publish\App.exe
+$ bin\Debug\netcoreapp5.0\win-x64\publish\App.exe
 ```
 
 ## More Advanced Scenario - Using your local CoreFx build

docs/project/linux-performance-tracing.md

@@ -246,7 +246,7 @@ The current prerequisites are:
 
 
 
-# EventPipe and dotnet-trace (.NET Core 3.0 Preview 5 or later)
+# EventPipe and dotnet-trace (.NET Core 3.0 or later)
 
 ## Intro ##
 EventPipe is a new cross-platform tracing mechanism we built into the runtime from .NET Core 3.0. It works the same across all platforms we support (Windows, macOS, and Linux), and we have built various diagnostics tools on top of it. dotnet-trace is a dotnet CLI tool that allows you to trace your .NET application using EventPipe.
@@ -254,7 +254,7 @@ EventPipe is a new cross-platform tracing mechanism we built into the runtime fr
 ## Installing dotnet-trace ##
 dotnet-trace can be installed by using the dotnet CLI:
 ```
-dotnet tool install --global dotnet-trace --version 1.0.4-preview6.19311.1
+dotnet tool install --global dotnet-trace
 ```
 
 ## Collecting a trace ##

docs/project/porting.md

-# Porting to .NET Core
-
-The purpose of this document is to share the plans on how we're going to port more APIs to .NET Core.
-
-## Summary
-
-Compared to other .NET stacks, specifically the .NET Framework, Mono, Unity, and Xamarin the .NET Core platform doesn't expose enough APIs. This makes porting assets to .NET Core quite challenging, especially for areas which don't have replacements.
-
-So we want to bring more APIs to .NET Core. In order to keep our promise of being open and transparent, we want to:
-
-* Clearly communicate what we plan on porting, how we prioritize, what we don't want to port, and how we're thinking of cross-platform and compatibility.
-* Avoid being the bottleneck by allowing community members to help with porting.
-
-## Prioritization
-
-As of today, .NET Core supports three app models:
-
-* **ASP.NET apps and services**
-* **Console apps**
-* **Universal Windows Platform (UWP) apps**
-
-We'll prioritize APIs that affect the ability to write those kind of apps over app models that .NET Core currently doesn't support (such as building desktop applications). Please note that this doesn't mean that we'll never port the other APIs -- it just means those rank lower.
-
-The same is true for platforms: the implementation of .NET Framework only runs on Windows. Our goal for .NET Core is to support the following platforms:
-
-* Windows
-* OS X
-* Linux
-
-(Please note that the specific version numbers, editions, and distros aren't fully finalized yet.)
-
-While we try to be mindful of other ports actively happening (such a BSD Unix), we prioritize those three platforms. It's also worth pointing out that we generally don't prioritize within these platforms; in other words we consider them all as equals. Of course, we start from a Windows implementation so the support is currently more complete there. Also, we're mindful of the ways developers are most likely to use the platforms as well. For instance, many web developers debug and test on OS X but deploy to Linux. This guides us when prioritizing work to address point-in-time issues.
-
-We determine which APIs are critical by leveraging various data sources:
-
-* **Community feedback** (such as GitHub, UserVoice)
-* **Partner feedback** (1st party and 3rd party applications)
-* **API usage of existing applications** (such as submissions from API Port, ASP.NET applications, and Silverlight based phone apps)
-
-We obviously aren't going to use a fixed formula to determine the stack rank of an API. We'll also leverage the experience from long term members on the team and combine it with the data and feedback to make intelligent decisions. For the sake of transparency we'll share all the data we have and the factors that lead to a specific decision. So if a decision we make is problematic for a part of the .NET ecosystem, such as not including the interfaces of ADO.NET for ORM providers, we can adjust as we go.
-
-## Mechanics
-
-For the most part, the source code for .NET Framework and .NET Core is disjoint. In other words, porting code to .NET Core isn't an exercise of checking a box -- it requires active work.
-
-Here is the summary of the activities involved:
-
-* Decide which APIs should go into .NET Core
-* Assess implications on componentization (see guidelines for more details)
-* Assess cross-platform impact. If necessary, find out how, and even if, the current design can be supported on all supported platforms
-* Get the code onto GitHub (this includes some minor clean up, such as running the code formatting tool)
-* Produce packages
-* Port corresponding tests
-
-## Porting Guidelines
-
-Here are the high level guidelines:
-
-* **Do not** port APIs of technologies we don't want to support moving forward (see list below).
-* **Do not** port APIs marked as obsolete.
-* **Consider** porting APIs even if considered legacy, problematic, or otherwise inadequate.
-* **Do** factor assemblies appropriately in order to preserve the componentization, specifically:
-	- **Do not** add dependencies from non-legacy to legacy components.
-	- **Do not** expose Windows-only technologies in otherwise fully portable assemblies.
-	- **Do** factor large chunks of functionality that cannot be supported everywhere into their own assemblies.
-	- **Do** consider using tester-doer patterns if only a very small number of APIs cannot be supported in all environments.
-* **Consider** using extension methods and partial facades to accelerate bringing revised APIs to the .NET Framework.
-* **Avoid** making changes that result in loss of binary and/or source compatibility between the .NET Framework and .NET Core.
-* **Avoid** "franken-designs" with extension methods and partial facades purely for the sake of .NET Framework compatibility.
-
-## Unsupported Technologies
-
-Feature owners reserve the right to call out what they don't want to support on .NET Core. Since .NET Core is a new platform, we don't want to penalize our ability to build a componentized and cross-platform stack by signing up for technologies that are expensive to bring into this world and we don't think are sensible for today's needs.
-
-This list, while not complete, is meant as a reference point. We'll add to it as we refine our porting plan. Also, just because something is currently not implemented, doesn't imply it's intentionally unsupported. Feel free to [file an issue](https://github.com/dotnet/runtime/issues/new) to ask for specific APIs and technologies. Porting requests are generally marked as [port-to-core](https://github.com/dotnet/runtime/issues?q=is%3Aopen+is%3Aissue+label%3Aport-to-core).
-
-Binary Serialization is supported post 1.1, however we do not support cross-platform binary serialization. For new code you may want to consider other serialization approaches such as data contract serialization, XML serialization, JSON.NET, and protobuf-net.
-
-Technology                 | More information
----------------------------|-----------------------------------
-AppDomains                 | [Details](#app-domains)
-Remoting                   | [Details](#remoting)
-Code Access Security (CAS) | [Details](#code-access-security-cas)
-Security Transparency      | [Details](#security-transparency)
-
-### App Domains
-
-**Justification**. AppDomains require runtime support and are generally quite expensive. They are not implemented in .NET Core. We do not plan on adding this capability in future.
-
-**Replacement**. AppDomains were used for different features; for isolation we recommend processes and/or containers. For dynamic loading, we provide `AssemblyLoadContext`. Information (such as the name and base directory) is provided by APIs on other types, for instance `AppContext.BaseDirectory`. Some scenarios, such as getting the list of loaded assemblies are unsupported as they are inherently fragile.
-
-To make code migration from .NET Framework easier, we have exposed some of the `AppDomain` API surface in .NET Core. Some of the APIs work fine (e.g. `UnhandledException`), some of them do nothing (e.g. `SetCachePath`) and some of them throw `PlatformNotSupportedException` (e.g. `CreateDomain`). See more details about particular API differences in [TODO](https://github.com/dotnet/corefx/issues/18405).
-
-### Remoting
-
-**Justification**. The idea of .NET remoting -- which is transparent remote procedure calls -- has been identified as a problematic architecture. Outside of that realm, it's also used for cross AppDomain communication which is no longer supported. On top of that, remoting requires runtime support and is quite heavyweight.
-
-**Replacement**. For communication across processes, inter-process communication (IPC) should be used, such as pipes or memory mapped files. Across machines, you should use a network based solution, preferably `System.Net.Sockets` (see sample - [TODO](https://github.com/dotnet/corefx/issues/18394)).
-
-### Code Access Security (CAS)
-
-**Justification**. Sandboxing, i.e. relying on the runtime or the framework to constrain which resources a managed application or library can run is [not supported on .NET Framework](https://msdn.microsoft.com/en-us/library/c5tk9z76(v=vs.110).aspx) and therefore is also not supported on .NET Core. We believe that there are simply too many pieces in the .NET Framework and runtime that can result in elevation of privileges. Thus we don't treat [CAS as security boundary](https://msdn.microsoft.com/en-us/library/c5tk9z76(v=vs.110).aspx) anymore. On top of that, it makes the implementation more complicated and often has correctness performance implications for applications that don’t intend to use it.
-
-**Replacement**. Use operating system provided security boundaries, such as virtualization, containers, or user accounts for running processes with the least set of privileges.
-
-### Security Transparency
-
-**Justification**. Similar to CAS, this feature allows separating sandboxed code from security critical code in a declarative fashion, but is [no longer supported as a security boundary](https://msdn.microsoft.com/en-us/library/ee191569(v=vs.110).aspx). This feature was heavily used by Silverlight. 
-
-**Replacement**. Use operating system provided security boundaries, such as virtualization, containers, or user accounts for running processes with the least set of privileges.

docs/project/profiling-api-status.md

 # Status of CoreCLR Profiler APIs
 
-The .NET Core project started with the codebase from the desktop CoreCLR/Silverlight so all the profiler APIs present there are also present in the code here. This is the status of our testing and porting efforts for these APIs.
+The CoreCLR project started with the codebase from the .NET Framework so all the profiler APIs present there are also present in the code here. This is the status of our testing and porting efforts for these APIs.
 
 ## Platform test coverage
 

docs/workflow/building/coreclr/crossgen.md

@@ -6,7 +6,7 @@ Introduction
 
 When you create a .NET assembly using C# compiler, your assembly contains only MSIL code.
 When the app runs, the JIT compiler translates the MSIL code into native code, before the CPU can execute them.
-This execution model has some advantages. For example, your assembly code can be portable across all platforms and architectures that support .NET Core.
+This execution model has some advantages. For example, your assembly code can be portable across all platforms and architectures that support .NET.
 However, this portability comes with a performance cost. Your app starts up more slowly because the JIT compiler has to spend time to translate the code.
 
 To help make your app start up faster, CoreCLR includes a tool called CrossGen, which can pre-compile the MSIL code into native code.

docs/workflow/building/libraries/README.md

@@ -171,7 +171,7 @@ For libraries that have multiple target frameworks the target frameworks will be
 
 **Examples**
 
-- Build project for Linux for .NET Core
+- Build project for Linux
 ```
 dotnet build System.Net.NetworkInformation.csproj /p:TargetOS=Linux
 ```

docs/workflow/debugging/libraries/unix-instructions.md

@@ -21,7 +21,7 @@ error: no such file
 
 ## Debugging core dumps with lldb
 
-It is also possible to debug .NET Core crash dumps using lldb and SOS. In order to do this, you need all of the following:
+It is also possible to debug .NET crash dumps using lldb and SOS. In order to do this, you need all of the following:
 
 - The crash dump file.
 - On Linux, there is an utility called `createdump` (see [doc](../../../design/coreclr/botr/xplat-minidump-generation.md "doc")) that can be setup to generate core dumps when a managed app throws an unhandled exception or faults.'

docs/workflow/debugging/libraries/windows-instructions.md

 Debugging CoreFX on Windows
 ==========================
 
-You can Debug .NET Core via Visual Studio or WinDBG.
+You can Debug .NET via Visual Studio or WinDBG.
 
 For Visual Studio debugging, follow the instructions at [Debugging tests in Visual Studio](../../testing/libraries/testing-vs.md) to run and debug tests.
 For bugs that cannot be reproduced within Visual Studio (certain low-probability race conditions, SafeHandle life-time problems, etc) you will need to use WinDBG.

docs/workflow/editing-and-debugging.md

@@ -24,7 +24,7 @@ what are in the repository. In particular
    associated with the repository, including
      * `coreclr` - This is the main runtime DLL (the GC, class loader, interop are all here)
      * `corjit` - This is the Just In Time (JIT) compiler that compiles .NET Intermediate language to native code.
-     * `corerun` - This is the simple host program that can load the CLR and run a .NET Core application
+     * `corerun` - This is the simple host program that can run a .NET application
      * `crossgen` - This is the host program that runs the JIT compiler and produces .NET Native images (`*.ni.dll`)
      for C# code.
 
@@ -38,7 +38,7 @@ Thus you can only launch this solution after you have built at least once.
 
 # See Also
 
-Before you make modifications, you probably want to learn more about the general architecture of .NET Core.
+Before you make modifications, you probably want to learn more about the general architecture of .NET Runtime.
 See the following docs for more.
 
- * [Documentation on the .NET Core Runtime](../README.md)
+ * [Documentation on the .NET Runtime](../README.md)

docs/workflow/requirements/windows-requirements.md

@@ -65,11 +65,11 @@ The dotnet/runtime repository requires at least Git 2.22.0.
 - Ensure that `powershell.exe` is accessible via the PATH environment variable. Typically this is `%SYSTEMROOT%\System32\WindowsPowerShell\v1.0\` and its automatically set upon Windows installation.
 - Powershell version must be 3.0 or higher. Use `$PSVersionTable.PSVersion` to determine the engine version.
 
-## DotNet Core SDK
+## .NET SDK
 
-While not strictly needed to build or test the .NET Core repository, having the .NET Core SDK installed lets you use the dotnet.exe command to run .NET Core applications in the 'normal' way.
+While not strictly needed to build or test this repository, having the .NET SDK installed lets you use the dotnet.exe command to run .NET applications in the 'normal' way.
 We use this in the [Using Your Build](../testing/using-your-build.md) instructions.
-Visual Studio should have installed the .NET Core SDK, but in case it did not you can get it from the [Installing the .NET Core SDK](https://dotnet.microsoft.com/download) page.
+Visual Studio should have installed the .NET SDK, but in case it did not you can get it from the [Installing the .NET SDK](https://dotnet.microsoft.com/download) page.
 
 ## Adding to the default PATH variable
 

docs/workflow/testing/coreclr/testing.md

-# Running .NET Core Tests
+# Running Tests
 
 Details on test metadata can be found in [test-configuration.md](test-configuration.md).
 

docs/workflow/testing/libraries/testing.md

@@ -10,7 +10,7 @@ To build the tests and run them you can call the libraries build script.
 libraries -buildtests
 ```
 
-- The following builds and runs all tests for .NET Core in release configuration:
+- The following builds and runs all tests in release configuration:
 ```
 libraries -test -c Release
 ```

docs/workflow/testing/using-corerun.md

 
-# Using corerun To Run .NET Core Application
+# Using corerun To Run .NET Application
 
-In page [Using your .NET Core Runtime Build with dotnet cli](../using-dotnet-cli.md) gives detailed instructions on using the standard
-command line host and SDK, dotnet.exe to run a .NET application with the modified build of the
-.NET Core runtime built here.   This is the preferred mechanism for you to officially deploy
+In page [Using your .NET Runtime Build with dotnet cli](../using-dotnet-cli.md) gives detailed instructions on using the standard
+command line host and SDK, dotnet.exe to run an application with the modified build of the
+.NET Runtime built here.   This is the preferred mechanism for you to officially deploy
 your changes to other people since dotnet.exe and Nuget insure that you end up with a consistent
 set of DLLs that can work together.
 
@@ -12,7 +12,7 @@ you are in the tight code-build-debug loop these extra steps are an issue.
 
 For this situation there is an alternative host to dotnet.exe called corerun.exe that is well suited
 for this.   It does not know about Nuget at all, and has very simple rules.  It needs to find the
-.NET Core runtime (that is coreclr.dll) and additionally any class library DLLs (e.g. System.Runtime.dll  System.IO.dll ...).
+.NET runtime (that is coreclr.dll) and additionally any class library DLLs (e.g. System.Runtime.dll  System.IO.dll ...).
 
 It does this by looking at two environment variables.
 

docs/workflow/testing/using-your-build.md

 
-# Using your .NET Core Runtime Build
+# Using your .NET Runtime Build
 
 We assume that you have successfully built CoreCLR repository and thus have files of the form
 ```
     ~/runtime/artifacts/bin/coreclr/<OS>.<arch>.<flavor>/
 ```
 
-To run your newly built .NET Core Runtime in addition to the application itself, you will need
-a 'host' program that will load the Runtime as well as all the other .NET Core Framework
+To run your newly built .NET Runtime in addition to the application itself, you will need
+a 'host' program that will load the Runtime as well as all the other .NET libraries
 code that your application needs. The easiest way to get all this other stuff is to simply use the
-standard 'dotnet' host that installs with .NET Core SDK.
+standard 'dotnet' host that installs with .NET SDK.
 
 The released version of 'dotnet' tool may not be compatible with the live CoreCLR repository. The following steps
 assume use of a dogfood build of the .NET SDK.
 
-## Acquire the latest nightly .NET Core SDK
+## Acquire the latest nightly .NET SDK
 
 - [Win 64-bit Latest](https://dotnetcli.blob.core.windows.net/dotnet/Sdk/master/dotnet-sdk-latest-win-x64.zip)
 - [macOS 64-bit Latest](https://dotnetcli.blob.core.windows.net/dotnet/Sdk/master/dotnet-sdk-latest-osx-x64.tar.gz)
@@ -27,7 +27,7 @@ After setting up dotnet you can verify you are using the newer version by:
 
 `dotnet --info` -- the version should be greater than 3.0.0-*
 
-For another small walkthrough see [Dogfooding .NET Core SDK](https://github.com/dotnet/runtime/blob/master/docs/project/dogfooding.md).
+For another small walkthrough see [Dogfooding .NET SDK](https://github.com/dotnet/runtime/blob/master/docs/project/dogfooding.md).
 
 ## Create sample self-contained application
 
@@ -61,7 +61,7 @@ needed.
 dotnet publish
 ```
 
-**Note:** If publish fails to restore runtime packages you need to configure custom NuGet feeds. This is because you are using a dogfood .NET Core SDK: its dependencies are not yet on the regular NuGet feed. To do so you have to:
+**Note:** If publish fails to restore runtime packages you need to configure custom NuGet feeds. This is because you are using a dogfood .NET SDK: its dependencies are not yet on the regular NuGet feed. To do so you have to:
 
 1. run `dotnet new nugetconfig`
 2. go to the `NuGet.Config` file and replace the content with:
@@ -90,7 +90,7 @@ After you publish you will find you all the binaries needed to run your applicat
 ## Update CoreCLR from raw binary output
 
 Updating CoreCLR from raw binary output is easier for quick one-off testing which is what this set of instructions
-outline but for consuming in a real .NET Core application you should use the nuget package instructions below.
+outline but for consuming in a real .NET application you should use the nuget package instructions below.
 
 The 'dotnet publish' step above creates a directory that has all the files necessary to run your app
 including the CoreCLR and the parts of CoreFX that were needed. You can use this fact to skip some steps if
@@ -154,15 +154,15 @@ Something like this happens if you copied coreclr.dll but not System.Private.Cor
 Assert failure(PID 13452 [0x0000348c], Thread: 10784 [0x2a20]): Consistency check failed: AV in clr at this callstack:
 ```
 
-## Using DotNetCli to run your .NET Core Application
+## Using .NET SDK to run your .NET Application
 
 If you don't like the idea of copying files manually you can follow [these instructions](../using-dotnet-cli.md) to use dotnet cli to do this for you.
 However the steps described here are the simplest and most commonly used by CoreCLR developers for ad-hoc testing.
 
-## Using CoreRun to run your .NET Core Application
+## Using CoreRun to run your .NET Application
 
-Generally using dotnet.exe tool to run your .NET Core application is the preferred mechanism to run .NET Core Apps.
-However there is a simpler 'host' for .NET Core applications called 'CoreRun' that can also be used.   The value
+Generally using dotnet.exe tool to run your .NET application is the preferred mechanism to run .NET Apps.
+However there is a simpler 'host' for .NET applications called 'CoreRun' that can also be used.   The value
 of this host is that it is simpler (in particular it knows nothing about NuGet), but precisely because of this
 it can be harder to use (since you are responsible for insuring all the dependencies you need are gather together)
-See [Using CoreRun To Run .NET Core Application](using-corerun.md) for more.
+See [Using CoreRun To Run .NET Application](using-corerun.md) for more.

docs/workflow/using-dotnet-cli.md

 
-# Using your .NET Core Runtime Build with dotnet cli
+# Using your .NET Runtime build with .NET SDK
 
-This walkthrough explains how to run against your local CoreCLR build using `dotnet cli` only.
+This walkthrough explains how to run against your local CoreCLR build using .NET SDK only.
 
 For other walkthroughs see:
 
 - [Using Your Build - Update CoreCLR from raw binary output](./testing/using-your-build.md)
-- [Using CoreRun To Run .NET Core Application](./testing/using-corerun.md)
-- [Dogfooding .NET Core SDK](https://github.com/dotnet/runtime/blob/master/docs/project/dogfooding.md).
+- [Using CoreRun To Run .NET Application](./testing/using-corerun.md)
+- [Dogfooding .NET SDK](https://github.com/dotnet/runtime/blob/master/docs/project/dogfooding.md).
 
 ## Prerequisites
 
@@ -17,7 +17,7 @@ For other walkthroughs see:
     artifacts\bin\coreclr\<OS>.<arch>.<flavor>\.nuget\pkg\runtime.<OS>-<arch>.Microsoft.NETCore.Runtime.CoreCLR.<version>.nupkg
 ```
 
-2. Acquired the latest nightly .NET Core SDK from [here](https://github.com/dotnet/cli/blob/master/README.md#installers-and-binaries) and added it's root folder to your [path](requirements/windows-requirements.md#adding-to-the-default-path-variable)
+2. Acquired the latest nightly .NET SDK from [here](https://github.com/dotnet/cli/blob/master/README.md#installers-and-binaries) and added it's root folder to your [path](requirements/windows-requirements.md#adding-to-the-default-path-variable)
 
 ## First Run
 
@@ -29,7 +29,7 @@ From now on all instructions relate to this folder as "app folder".
 
 ### 2. Create NuGet.Config file
 
-The build script creates NuGet packages and puts them to `artifacts\bin\coreclr\<OS>.<arch>.<flavor>\.nuget\pkg\`. dotnet cli has no idea about its existence and we need to tell it where to search for the packages.
+The build script creates NuGet packages and puts them to `artifacts\bin\coreclr\<OS>.<arch>.<flavor>\.nuget\pkg\`. .NET SDK has no idea about its existence and we need to tell it where to search for the packages.
 
 Please run `dotnet new nugetconfig` in the app folder and update the created `NuGet.Config` file:
 

eng/Versions.props

 <Project>
   <PropertyGroup>
-    <!-- The .NET Core product branding version -->
+    <!-- The .NET product branding version -->
     <ProductVersion>5.0.0</ProductVersion>
     <!-- File version numbers -->
     <MajorVersion>5</MajorVersion>

eng/pipelines/coreclr/corefx-jitstress.yml

@@ -21,7 +21,7 @@ jobs:
     jobTemplate: /eng/pipelines/coreclr/templates/build-job.yml
     buildConfig: checked
     platforms:
-    # TODO: add Windows_NT_arm64, when we have hardware available, and .NET Core supports it. Note: platform-matrix.yml needs to enable a Helix queue for this.
+    # TODO: add Windows_NT_arm64, when we have hardware available. Note: platform-matrix.yml needs to enable a Helix queue for this.
     - Linux_arm
     - Linux_arm64
     - Linux_x64
@@ -36,7 +36,7 @@ jobs:
     jobTemplate: /eng/pipelines/coreclr/templates/run-test-job.yml
     buildConfig: checked
     platforms:
-    # TODO: add Windows_NT_arm64, when we have hardware available, and .NET Core supports it. Note: platform-matrix.yml needs to enable a Helix queue for this.
+    # TODO: add Windows_NT_arm64, when we have hardware available. Note: platform-matrix.yml needs to enable a Helix queue for this.
     - Linux_arm
     - Linux_arm64
     - Linux_x64

eng/pipelines/coreclr/corefx-jitstress2-jitstressregs.yml

@@ -21,7 +21,7 @@ jobs:
     jobTemplate: /eng/pipelines/coreclr/templates/build-job.yml
     buildConfig: checked
     platforms:
-    # TODO: add Windows_NT_arm64, when we have hardware available, and .NET Core supports it. Note: platform-matrix.yml needs to enable a Helix queue for this.
+    # TODO: add Windows_NT_arm64, when we have hardware available. Note: platform-matrix.yml needs to enable a Helix queue for this.
     - Linux_arm
     - Linux_arm64
     - Linux_x64
@@ -36,7 +36,7 @@ jobs:
     jobTemplate: /eng/pipelines/coreclr/templates/run-test-job.yml
     buildConfig: checked
     platforms:
-    # TODO: add Windows_NT_arm64, when we have hardware available, and .NET Core supports it. Note: platform-matrix.yml needs to enable a Helix queue for this.
+    # TODO: add Windows_NT_arm64, when we have hardware available. Note: platform-matrix.yml needs to enable a Helix queue for this.
     - Linux_arm
     - Linux_arm64
     - Linux_x64

eng/pipelines/coreclr/corefx-jitstressregs.yml

@@ -21,7 +21,7 @@ jobs:
     jobTemplate: /eng/pipelines/coreclr/templates/build-job.yml
     buildConfig: checked
     platforms:
-    # TODO: add Windows_NT_arm64, when we have hardware available, and .NET Core supports it. Note: platform-matrix.yml needs to enable a Helix queue for this.
+    # TODO: add Windows_NT_arm64, when we have hardware available. Note: platform-matrix.yml needs to enable a Helix queue for this.
     - Linux_arm
     - Linux_arm64
     - Linux_x64
@@ -36,7 +36,7 @@ jobs:
     jobTemplate: /eng/pipelines/coreclr/templates/run-test-job.yml
     buildConfig: checked
     platforms:
-    # TODO: add Windows_NT_arm64, when we have hardware available, and .NET Core supports it. Note: platform-matrix.yml needs to enable a Helix queue for this.
+    # TODO: add Windows_NT_arm64, when we have hardware available. Note: platform-matrix.yml needs to enable a Helix queue for this.
     - Linux_arm
     - Linux_arm64
     - Linux_x64

eng/pipelines/coreclr/corefx.yml

@@ -21,7 +21,7 @@ jobs:
     jobTemplate: /eng/pipelines/coreclr/templates/build-job.yml
     buildConfig: checked
     platforms:
-    # TODO: add Windows_NT_arm64, when we have hardware available, and .NET Core supports it. Note: platform-matrix.yml needs to enable a Helix queue for this.
+    # TODO: add Windows_NT_arm64, when we have hardware available. Note: platform-matrix.yml needs to enable a Helix queue for this.
     - Linux_arm
     - Linux_arm64
     - Linux_x64
@@ -36,7 +36,7 @@ jobs:
     jobTemplate: /eng/pipelines/coreclr/templates/run-test-job.yml
     buildConfig: checked
     platforms:
-    # TODO: add Windows_NT_arm64, when we have hardware available, and .NET Core supports it. Note: platform-matrix.yml needs to enable a Helix queue for this.
+    # TODO: add Windows_NT_arm64, when we have hardware available. Note: platform-matrix.yml needs to enable a Helix queue for this.
     - Linux_arm
     - Linux_arm64
     - Linux_x64

eng/pipelines/coreclr/templates/format-job.yml

@@ -36,7 +36,7 @@ jobs:
     steps:
     - task: UseDotNet@2
       # This should match what jitutils YML uses to build.
-      displayName: 'Install .NET Core SDK'
+      displayName: 'Install .NET SDK'
       inputs:
         packageType: 'sdk'
         version: '3.x'

eng/versioning.targets

@@ -42,9 +42,9 @@
     <Description Condition="'$(Description)' == ''">$(AssemblyName)</Description>
 
     <!-- SDK sets product to assembly but we want it to be our product name -->
-    <Product>Microsoft%AE .NET Core</Product>
+    <Product>Microsoft%AE .NET</Product>
 
-    <!-- Use the .NET Core product branding version for informational version description -->
+    <!-- Use the .NET product branding version for informational version description -->
     <InformationalVersion>$(ProductVersion)</InformationalVersion>
     <InformationalVersion Condition="'$(VersionSuffix)' != ''">$(InformationalVersion)-$(VersionSuffix)</InformationalVersion>
   </PropertyGroup>
@@ -97,4 +97,4 @@
       <FileWrites Include="$(AssemblyInfoFile)" />
     </ItemGroup>
   </Target>
-</Project>
\ No newline at end of file
+</Project>

src/coreclr/Directory.Build.targets

@@ -6,9 +6,9 @@
 
   <PropertyGroup>
     <!-- SDK sets product to assembly but we want it to be our product name -->
-    <Product>Microsoft%AE .NET Core</Product>
+    <Product>Microsoft%AE .NET</Product>
 
-    <!-- Use the .NET Core product branding version for informational version description -->
+    <!-- Use the .NET product branding version for informational version description -->
     <InformationalVersion>$(ProductVersion)</InformationalVersion>
     <InformationalVersion Condition="'$(VersionSuffix)' != ''">$(InformationalVersion)-$(VersionSuffix)</InformationalVersion>
   </PropertyGroup>

src/coreclr/src/Directory.Build.props

@@ -8,6 +8,6 @@
   <!-- Properties that should be defined for all managed product assemblies -->
   <PropertyGroup>
     <Company>Microsoft Corporation</Company>
-    <Product>Microsoft%AE .NET Core</Product>
+    <Product>Microsoft%AE .NET</Product>
   </PropertyGroup>
 </Project>

src/coreclr/src/ToolBox/SOS/SOS_README.md

-SOS and other diagnostic tools now ship out of band and work with any version of the .NET Core runtime.
+SOS and other diagnostic tools now ship out of band and work with any version of the .NET runtime.
 
 SOS has moved to the diagnostics repo here: https://github.com/dotnet/diagnostics.git.
 

src/coreclr/src/pal/prebuilt/inc/fxverstrings.h

@@ -3,7 +3,7 @@
 // See the LICENSE file in the project root for more information.
 
 #ifndef VER_PRODUCTNAME_STR
-        #define VER_PRODUCTNAME_STR      L"Microsoft\256 .NET Core"
+        #define VER_PRODUCTNAME_STR      L"Microsoft\256 .NET"
 #endif
 
 #ifndef VER_LEGALCOPYRIGHT_STR

src/coreclr/src/vm/eventreporter.cpp

@@ -111,11 +111,11 @@ EventReporter::EventReporter(EventReporterType type)
         }
     }
 
-    // Log the .NET Core Version if we can get it
+    // Log the .NET Version if we can get it
     LPCWSTR fxProductVersion = Configuration::GetKnobStringValue(W("FX_PRODUCT_VERSION"));
     if (fxProductVersion != nullptr)
     {
-        m_Description.Append(W(".NET Core Version: "));
+        m_Description.Append(W(".NET Version: "));
         m_Description.Append(fxProductVersion);
         m_Description.Append(W("\n"));
     }

src/coreclr/tests/scripts/crossgen_comparison.py

@@ -137,7 +137,7 @@ def build_argument_parser():
     framework_parser.add_argument('--result_dir', dest='result_dirname', required=True)
     framework_parser.set_defaults(func=crossgen_framework)
 
-    dotnet_sdk_parser_description = "Unpack .NET Core SDK archive file and runs crossgen on each assembly."
+    dotnet_sdk_parser_description = "Unpack .NET SDK archive file and runs crossgen on each assembly."
     dotnet_sdk_parser = subparsers.add_parser('crossgen_dotnet_sdk', description=dotnet_sdk_parser_description)
     dotnet_sdk_parser.add_argument('--crossgen', dest='crossgen_executable_filename', required=True)
     dotnet_sdk_parser.add_argument('--il_corelib', dest='il_corelib_filename', required=True)

src/coreclr/tests/src/Interop/PInvoke/SizeParamIndex/ReversePInvoke/PassingByRef/PassingByRefTest.cs

@@ -167,7 +167,7 @@ public static void RunTestByRef()
         Assert.IsTrue(DoCallBack_MarshalSbyteArray_AsParam_AsByRef(new DelSbyteArrByRefAsCdeclCaller(TestMethodForSbyteArray_AsReversePInvokeByRef_AsCdecl)));
         Console.WriteLine("\t\tMarshalSbyteArray_AsReversePInvokeByRef_AsCdecl Passed!");
 
-        // We don't support exception interop in .NET Core off-Windows.
+        // We don't support exception interop in .NET off-Windows.
         if (RuntimeInformation.IsOSPlatform(OSPlatform.Windows))
         {
             Console.WriteLine("\tScenario 3 : short ==> SHORT, Array_Size = -1, Return_Array_Size = 20");

src/coreclr/tests/src/Interop/WinRT/NETClients/Primitives/StringTests.cs

@@ -11,7 +11,7 @@ public static void RunTest()
         {
             Component.Contracts.IStringTesting target = (Component.Contracts.IStringTesting)WinRTNativeComponent.GetObjectFromNativeComponent("Component.Contracts.StringTesting");
             string left = "Hello C++/WinRT";
-            string right = " from .NET Core";
+            string right = " from .NET";
             Assert.AreEqual(string.Concat(left, right), target.ConcatStrings(left, right));
         }
     }

src/coreclr/tests/src/sizeondisk/sodbench/THIRD-PARTY-NOTICES.TXT

-.NET Core uses third-party libraries or other resources that may be
-distributed under licenses different than the .NET Core software.
+.NET uses third-party libraries or other resources that may be
+distributed under licenses different than the .NET software.
 
 Attributions and license notices for test cases originally authored by
 third parties can be found in the respective test directories.

src/installer/Directory.Build.props

@@ -37,7 +37,7 @@
     <SharedFrameworkName>Microsoft.NETCore.App</SharedFrameworkName>
     <NETCoreAppFrameworkIdentifier>.NETCoreApp</NETCoreAppFrameworkIdentifier>
     <NETCoreAppFrameworkMoniker>$(NETCoreAppFrameworkIdentifier),Version=v$(NETCoreAppFrameworkVersion)</NETCoreAppFrameworkMoniker>
-    <NETCoreAppFrameworkBrandName>.NET Core $(NETCoreAppFrameworkVersion)</NETCoreAppFrameworkBrandName>
+    <NETCoreAppFrameworkBrandName>.NET $(NETCoreAppFrameworkVersion)</NETCoreAppFrameworkBrandName>
   </PropertyGroup>
 
   <!-- Platform detection -->

src/installer/corehost/build.proj

@@ -49,25 +49,25 @@
     <!-- Generate Version files -->
     <ItemGroup>
       <HostFiles Include="dotnet">
-       <FileDescription>.NET Core Host</FileDescription>
+       <FileDescription>.NET Host</FileDescription>
       </HostFiles>
       <HostFiles Include="hostfxr">
-        <FileDescription>.NET Core Host Resolver - $(HostResolverVersion)</FileDescription>
+        <FileDescription>.NET Host Resolver - $(HostResolverVersion)</FileDescription>
       </HostFiles>
       <HostFiles Include="hostpolicy">
-        <FileDescription>.NET Core Host Policy - $(HostPolicyVersion)</FileDescription>
+        <FileDescription>.NET Host Policy - $(HostPolicyVersion)</FileDescription>
       </HostFiles>
       <HostFiles Include="comhost">
-        <FileDescription>.NET Core COM Host</FileDescription>
+        <FileDescription>.NET COM Host</FileDescription>
       </HostFiles>
       <HostFiles Include="ijwhost">
-        <FileDescription>.NET Core IJW Host</FileDescription>
+        <FileDescription>.NET IJW Host</FileDescription>
       </HostFiles>
       <HostFiles Include="winrthost">
-        <FileDescription>.NET Core WinRT Host</FileDescription>
+        <FileDescription>.NET WinRT Host</FileDescription>
       </HostFiles>
       <HostFiles Include="nethost">
-        <FileDescription>.NET Core Component Host</FileDescription>
+        <FileDescription>.NET Component Host</FileDescription>
       </HostFiles>
     </ItemGroup>
 

src/installer/corehost/cli/apphost/apphost.windows.cpp

@@ -40,7 +40,7 @@ namespace
         auto eventSource = ::RegisterEventSourceW(nullptr, _X(".NET Runtime"));
         const DWORD traceErrorID = 1023; // Matches CoreCLR ERT_UnmanagedFailFast
         pal::string_t message;
-        message.append(_X("Description: A .NET Core application failed.\n"));
+        message.append(_X("Description: A .NET application failed.\n"));
         message.append(_X("Application: ")).append(executable_name).append(_X("\n"));
         message.append(_X("Path: ")).append(executable_path).append(_X("\n"));
         message.append(_X("Message: ")).append(g_buffered_errors).append(_X("\n"));
@@ -61,7 +61,7 @@ namespace
         if (pal::getenv(_X("DOTNET_DISABLE_GUI_ERRORS"), &gui_errors_disabled) && pal::xtoi(gui_errors_disabled.c_str()) == 1)
             return;
 
-        pal::string_t dialogMsg = _X("To run this application, you must install .NET Core.\n\n");
+        pal::string_t dialogMsg = _X("To run this application, you must install .NET.\n\n");
         pal::string_t url;
         const pal::string_t url_prefix = _X("  - ") DOTNET_CORE_APPLAUNCH_URL _X("?");
         if (error_code == StatusCode::CoreHostLibMissingFailure)

src/installer/corehost/cli/fxr/command_line.cpp

@@ -289,21 +289,21 @@ void command_line::print_muxer_info(const pal::string_t &dotnet_root)
     trace::println(_X("  Commit:  %s"), commit.substr(0, 10).c_str());
 
     trace::println();
-    trace::println(_X(".NET Core SDKs installed:"));
+    trace::println(_X(".NET SDKs installed:"));
     if (!sdk_info::print_all_sdks(dotnet_root, _X("  ")))
     {
         trace::println(_X("  No SDKs were found."));
     }
 
     trace::println();
-    trace::println(_X(".NET Core runtimes installed:"));
+    trace::println(_X(".NET runtimes installed:"));
     if (!framework_info::print_all_frameworks(dotnet_root, _X("  ")))
     {
         trace::println(_X("  No runtimes were found."));
     }
 
     trace::println();
-    trace::println(_X("To install additional .NET Core runtimes or SDKs:"));
+    trace::println(_X("To install additional .NET runtimes or SDKs:"));
     trace::println(_X("  %s"), DOTNET_CORE_DOWNLOAD_URL);
 }
 
@@ -335,6 +335,6 @@ void command_line::print_muxer_usage(bool is_sdk_present)
         trace::println();
         trace::println(_X("Common Options:"));
         trace::println(_X("  -h|--help                           Displays this help."));
-        trace::println(_X("  --info                              Display .NET Core information."));
+        trace::println(_X("  --info                              Display .NET information."));
     }
-}
\ No newline at end of file
+}

src/installer/corehost/cli/fxr/fx_muxer.cpp

@@ -1009,11 +1009,11 @@ int fx_muxer_t::handle_cli(
             return StatusCode::Success;
         }
 
-        trace::error(_X("Could not execute because the application was not found or a compatible .NET Core SDK is not installed."));
+        trace::error(_X("Could not execute because the application was not found or a compatible .NET SDK is not installed."));
         trace::error(_X("Possible reasons for this include:"));
-        trace::error(_X("  * You intended to execute a .NET Core program:"));
+        trace::error(_X("  * You intended to execute a .NET program:"));
         trace::error(_X("      The application '%s' does not exist."), app_candidate.c_str());
-        trace::error(_X("  * You intended to execute a .NET Core SDK command:"));
+        trace::error(_X("  * You intended to execute a .NET SDK command:"));
         resolver.print_resolution_error(host_info.dotnet_root, _X("      "));
 
         return StatusCode::LibHostSdkFindFailure;
@@ -1023,7 +1023,7 @@ int fx_muxer_t::handle_cli(
 
     if (!pal::file_exists(sdk_dotnet))
     {
-        trace::error(_X("Found .NET Core SDK, but did not find dotnet.dll at [%s]"), sdk_dotnet.c_str());
+        trace::error(_X("Found .NET SDK, but did not find dotnet.dll at [%s]"), sdk_dotnet.c_str());
         return StatusCode::LibHostSdkFindFailure;
     }
 
@@ -1035,7 +1035,7 @@ int fx_muxer_t::handle_cli(
     new_argv.push_back(sdk_dotnet.c_str());
     new_argv.insert(new_argv.end(), argv + 1, argv + argc);
 
-    trace::verbose(_X("Using .NET Core SDK dll=[%s]"), sdk_dotnet.c_str());
+    trace::verbose(_X("Using .NET SDK dll=[%s]"), sdk_dotnet.c_str());
 
     int new_argoff;
     pal::string_t sdk_app_candidate;

src/installer/corehost/cli/fxr/sdk_resolver.cpp

@@ -89,19 +89,19 @@ pal::string_t sdk_resolver::resolve(const pal::string_t& dotnet_root, bool print
 void sdk_resolver::print_resolution_error(const pal::string_t& dotnet_root, const pal::char_t *prefix) const
 {
     bool sdk_exists = false;
-    const pal::char_t *no_sdk_message = _X("It was not possible to find any installed .NET Core SDKs.");
+    const pal::char_t *no_sdk_message = _X("It was not possible to find any installed .NET SDKs.");
     if (!version.is_empty())
     {
         pal::string_t requested = version.as_str();
         if (!global_file.empty())
         {
-            trace::error(_X("%sA compatible installed .NET Core SDK for global.json version [%s] from [%s] was not found."), prefix, requested.c_str(), global_file.c_str());
-            trace::error(_X("%sInstall the [%s] .NET Core SDK or update [%s] with an installed .NET Core SDK:"), prefix, requested.c_str(), global_file.c_str());
+            trace::error(_X("%sA compatible installed .NET SDK for global.json version [%s] from [%s] was not found."), prefix, requested.c_str(), global_file.c_str());
+            trace::error(_X("%sInstall the [%s] .NET SDK or update [%s] with an installed .NET SDK:"), prefix, requested.c_str(), global_file.c_str());
         }
         else
         {
-            trace::error(_X("%sA compatible installed .NET Core SDK version [%s] was not found."), prefix, requested.c_str());
-            trace::error(_X("%sInstall the [%s] .NET Core SDK or create a global.json file with an installed .NET Core SDK:"), prefix, requested.c_str());
+            trace::error(_X("%sA compatible installed .NET SDK version [%s] was not found."), prefix, requested.c_str());
+            trace::error(_X("%sInstall the [%s] .NET SDK or create a global.json file with an installed .NET SDK:"), prefix, requested.c_str());
         }
 
         sdk_exists = sdk_info::print_all_sdks(dotnet_root, pal::string_t{prefix}.append(_X("  ")));
@@ -115,7 +115,7 @@ void sdk_resolver::print_resolution_error(const pal::string_t& dotnet_root, cons
 
     if (!sdk_exists)
     {
-        trace::error(_X("%sInstall a .NET Core SDK from:"), prefix);
+        trace::error(_X("%sInstall a .NET SDK from:"), prefix);
         trace::error(_X("%s  %s"), prefix, DOTNET_CORE_DOWNLOAD_URL);
     }
 }
@@ -130,7 +130,7 @@ sdk_resolver sdk_resolver::from_nearest_global_file(bool allow_prerelease)
     }
     else
     {
-        trace::verbose(_X("--- Resolving .NET Core SDK with working dir [%s]"), cwd.c_str());
+        trace::verbose(_X("--- Resolving .NET SDK with working dir [%s]"), cwd.c_str());
     }
     return from_nearest_global_file(cwd, allow_prerelease);
 }
@@ -145,7 +145,7 @@ sdk_resolver sdk_resolver::from_nearest_global_file(const pal::string_t& cwd, bo
         resolver = sdk_resolver{ allow_prerelease };
 
         trace::warning(
-            _X("Ignoring SDK settings in global.json: the latest installed .NET Core SDK (%s prereleases) will be used"),
+            _X("Ignoring SDK settings in global.json: the latest installed .NET SDK (%s prereleases) will be used"),
             resolver.allow_prerelease ? _X("including") : _X("excluding"));
     }
 

src/installer/corehost/cli/fxr_resolver.cpp

@@ -118,7 +118,7 @@ bool fxr_resolver::try_get_path(const pal::string_t& root_path, pal::string_t* o
             dotnet_root_env_var_name.c_str(),
             self_registered_message.c_str());
         trace::error(_X(""));
-        trace::error(_X("The .NET Core runtime can be found at:"));
+        trace::error(_X("The .NET runtime can be found at:"));
         trace::error(_X("  - %s&apphost_version=%s"), get_download_url().c_str(), _STRINGIFY(COMMON_HOST_PKG_VER));
         return false;
     }

src/installer/corehost/cli/fxr_resolver.h

@@ -49,7 +49,7 @@ int load_fxr_and_get_delegate(hostfxr_delegate_type type, THostPathToConfigCallb
         if (!pal::load_library(&fxr_path, &fxr))
         {
             trace::error(_X("The library %s was found, but loading it from %s failed"), LIBFXR_NAME, fxr_path.c_str());
-            trace::error(_X("  - Installing .NET Core prerequisites might help resolve this problem."));
+            trace::error(_X("  - Installing .NET prerequisites might help resolve this problem."));
             trace::error(_X("     %s"), DOTNET_CORE_INSTALL_PREREQUISITES_URL);
             return StatusCode::CoreHostLibLoadFailure;
         }

src/installer/corehost/cli/ijwhost/ijwthunk.cpp

@@ -125,11 +125,11 @@ extern "C" std::uintptr_t __stdcall start_runtime_and_get_target_address(std::ui
     if (status != StatusCode::Success)
     {
         // If we ignore the failure to patch bootstrap thunks we will come to this same
-        // function again, causing an infinite loop of "Failed to start the .NET Core runtime" errors.
+        // function again, causing an infinite loop of "Failed to start the .NET runtime" errors.
         // As we were taken here via an entry point with arbitrary signature,
         // there's no way of returning the error code so we just throw it.
 
-        trace::error(_X("Failed to start the .NET Core runtime. Error code %d"), status);
+        trace::error(_X("Failed to start the .NET runtime. Error code %d"), status);
 
 #pragma warning (push)
 #pragma warning (disable: 4297)

src/installer/corehost/corehost.cpp

@@ -166,7 +166,7 @@ int exe_start(const int argc, const pal::char_t* argv[])
         trace::println();
         trace::println(_X("Options:"));
         trace::println(_X("  -h|--help         Display help."));
-        trace::println(_X("  --info            Display .NET Core information."));
+        trace::println(_X("  --info            Display .NET information."));
         trace::println(_X("  --list-sdks       Display the installed SDKs."));
         trace::println(_X("  --list-runtimes   Display the installed runtimes."));
         trace::println();
@@ -193,7 +193,7 @@ int exe_start(const int argc, const pal::char_t* argv[])
     if (!pal::load_library(&fxr_path, &fxr))
     {
         trace::error(_X("The library %s was found, but loading it from %s failed"), LIBFXR_NAME, fxr_path.c_str());
-        trace::error(_X("  - Installing .NET Core prerequisites might help resolve this problem."));
+        trace::error(_X("  - Installing .NET prerequisites might help resolve this problem."));
         trace::error(_X("     %s"), DOTNET_CORE_INSTALL_PREREQUISITES_URL);
         return StatusCode::CoreHostLibLoadFailure;
     }
@@ -221,7 +221,7 @@ int exe_start(const int argc, const pal::char_t* argv[])
             if (trace::get_error_writer() != nullptr && rc == static_cast<int>(StatusCode::FrameworkMissingFailure) && !set_error_writer_fn)
             {
                 pal::string_t url = get_download_url();
-                trace::error(_X("  _ To run this application, you need to install a newer version of .NET Core."));
+                trace::error(_X("  _ To run this application, you need to install a newer version of .NET."));
                 trace::error(_X(""));
                 trace::error(_X("  - %s"), url.c_str());
             }

src/installer/managed/Microsoft.NET.HostModel/Microsoft.NET.HostModel.csproj

@@ -2,7 +2,7 @@
 
   <PropertyGroup>
     <TargetFramework>netstandard2.0</TargetFramework>
-    <Description>Abstractions for modifying .net core host-binaries</Description>
+    <Description>Abstractions for modifying .NET host binaries</Description>
     <IsShipping>false</IsShipping>
   </PropertyGroup>
 

src/installer/pkg/Directory.Build.targets

@@ -36,7 +36,7 @@
     </PropertyGroup>
 
     <PropertyGroup>
-      <ProductBrandPrefix Condition="'$(ProductBrandPrefix)' == ''">Microsoft .NET Core</ProductBrandPrefix>
+      <ProductBrandPrefix Condition="'$(ProductBrandPrefix)' == ''">Microsoft .NET</ProductBrandPrefix>
       <ProductBrandSuffix>$(ProductionVersion)</ProductBrandSuffix>
       <ProductBrandSuffix Condition="'$(ReleaseBrandSuffix)'!=''">$(ProductionVersion) $(ReleaseBrandSuffix)</ProductBrandSuffix>
 

src/installer/pkg/packaging/deb/dotnet-hostfxr-debian_config.json

 {
-    "maintainer_name":".NET Core Team",
+    "maintainer_name":".NET Team",
     "maintainer_email": "dotnetpackages@dotnetfoundation.org",
 
     "package_name": "%HOSTFXR_DEBIAN_PACKAGE_NAME%",
     "install_root": "/usr/share/dotnet",
 
     "short_description": "%HOSTFXR_BRAND_NAME% %HOSTFXR_NUGET_VERSION%",
-    "long_description": ".NET Core is a development platform that you can use to build command-line applications, microservices and modern websites. It is open source, cross-platform and is supported by Microsoft. We hope you enjoy using it! If you do, please consider joining the active community of developers that are contributing to the project on GitHub (https://github.com/dotnet/core). We happily accept issues and PRs.",
+    "long_description": ".NET is a development platform that you can use to build command-line applications, microservices and modern websites. It is open source, cross-platform and is supported by Microsoft. We hope you enjoy using it! If you do, please consider joining the active community of developers that are contributing to the project on GitHub (https://github.com/dotnet/core). We happily accept issues and PRs.",
     "homepage": "https://dot.net/core",
 
     "release":{

src/installer/pkg/packaging/deb/dotnet-runtime-deps-debian_config.json

 {
-    "maintainer_name":".NET Core Team",
+    "maintainer_name":".NET Team",
     "maintainer_email": "dotnetpackages@dotnetfoundation.org",
 
     "package_name": "%RUNTIME_DEPS_DEBIAN_PACKAGE_NAME%",
     "install_root": "/usr/share/dotnet",
 
     "short_description": "%RUNTIME_DEPS_DEBIAN_PACKAGE_NAME% %RUNTIME_DEPS_VERSION%",
-    "long_description": ".NET Core is a development platform that you can use to build command-line applications, microservices and modern websites. This package installs all the system dependencies for .NET Core Runtime.",
+    "long_description": ".NET is a development platform that you can use to build command-line applications, microservices and modern websites. This package installs all the system dependencies for .NET Runtime.",
     "homepage": "https://dot.net/core",
 
     "release":{

src/installer/pkg/packaging/deb/dotnet-sharedframework-debian_config.json

 {
-    "maintainer_name":".NET Core Team",
+    "maintainer_name":".NET Team",
     "maintainer_email": "dotnetpackages@dotnetfoundation.org",
 
     "package_name": "%SHARED_FRAMEWORK_DEBIAN_PACKAGE_NAME%",
     "install_root": "/usr/share/dotnet",
 
     "short_description": "%SHARED_FRAMEWORK_BRAND_NAME% %SHARED_FRAMEWORK_NUGET_NAME% %SHARED_FRAMEWORK_NUGET_VERSION%",
-    "long_description": ".NET Core is a development platform that you can use to build command-line applications, microservices and modern websites. It is open source, cross-platform and is supported by Microsoft. We hope you enjoy using it! If you do, please consider joining the active community of developers that are contributing to the project on GitHub (https://github.com/dotnet/core). We happily accept issues and PRs.",
+    "long_description": ".NET is a development platform that you can use to build command-line applications, microservices and modern websites. It is open source, cross-platform and is supported by Microsoft. We hope you enjoy using it! If you do, please consider joining the active community of developers that are contributing to the project on GitHub (https://github.com/dotnet/core). We happily accept issues and PRs.",
     "homepage": "https://dot.net/core",
 
     "release":{

src/installer/pkg/packaging/deb/dotnet-sharedhost-debian_config.json

 {
-    "maintainer_name":".NET Core Team",
+    "maintainer_name":".NET Team",
     "maintainer_email": "dotnetpackages@dotnetfoundation.org",
 
     "package_name": "dotnet-host",
     "install_root": "/usr/share/dotnet",
 
     "short_description": "%SHARED_HOST_BRAND_NAME%",
-    "long_description": ".NET Core is a development platform that you can use to build command-line applications, microservices and modern websites. It is open source, cross-platform and is supported by Microsoft. We hope you enjoy using it! If you do, please consider joining the active community of developers that are contributing to the project on GitHub (https://github.com/dotnet/core). We happily accept issues and PRs.",
+    "long_description": ".NET is a development platform that you can use to build command-line applications, microservices and modern websites. It is open source, cross-platform and is supported by Microsoft. We hope you enjoy using it! If you do, please consider joining the active community of developers that are contributing to the project on GitHub (https://github.com/dotnet/core). We happily accept issues and PRs.",
     "homepage": "https://dot.net/core",
 
     "release":{

src/installer/pkg/packaging/deb/package.targets

@@ -318,7 +318,7 @@
       </SharedFrameworkTokenValue>
 
       <!--
-        In every runtime deps Deb package, include alternatives known to work with .NET Core.
+        In every runtime deps Deb package, include alternatives known to work with .NET.
         Specifying these as "or" dependencies lets us create one package that works on many distros.
       -->
       <SharedFrameworkTokenValue

src/installer/pkg/packaging/osx/hostfxr/resources/cs.lproj/conclusion.html

@@ -3,17 +3,17 @@
 <html lang="en">
 <head>
     <meta charset="utf-8" />
-    <title styles="color:white">Congratulations! You've successfully installed .NET Core CLI!</title>
+    <title styles="color:white">Congratulations! You've successfully installed .NET CLI!</title>
 </head>
 <body>
         <div align="center" style="font-family: Helvetica;">  
             <h1>The installation was successful.</h1>
-            <p>.NET Core CLI was successfully installed.</p>
+            <p>.NET CLI was successfully installed.</p>
         <h2>
             Install dependencies
         </h2>
         <p>
-        In order to be able to use .NET Core on OS X, you need to install <b>OpenSSL</b> version <b>1.0.1/1.0.2</b>. 
+        In order to be able to use .NET on OS X, you need to install <b>OpenSSL</b> version <b>1.0.1/1.0.2</b>. 
         There are many ways to install/update your libssl. Using <a href="https://brew.sh">Homebrew</a> is the easiest. 
         You can view the instructions <a href="http://brewformulas.org/Openssl">here</a> or if you're updating, <a href="https://github.com/dotnet/runtime/blob/master/docs/workflow/building/coreclr/osx-instructions.md#openssl">on this page</a>.
         </p>

src/installer/pkg/packaging/osx/hostfxr/resources/cs.lproj/welcome.html

@@ -2,18 +2,18 @@
 <html lang="en">
 <head>
     <meta charset="utf-8" />
-    <title styles="color:white">Welcome to the .NET Core CLI installer.</title>
+    <title styles="color:white">Welcome to the .NET CLI installer.</title>
 </head>
 <body>
     <font face="Helvetica">
         <h3>
-            Microsoft .NET Core CLI
+            Microsoft .NET CLI
         </h3>
         <p>
-            .NET Core is a development platform that you can use to build command-line applications, microservices and modern websites. It is open source, cross-platform and is supported by Microsoft. We hope you enjoy using it! If you do, please consider joining the active community of developers that are contributing to the project on GitHub (https://github.com/dotnet/core). We happily accept issues and PRs.
+            .NET is a development platform that you can use to build command-line applications, microservices and modern websites. It is open source, cross-platform and is supported by Microsoft. We hope you enjoy using it! If you do, please consider joining the active community of developers that are contributing to the project on GitHub (https://github.com/dotnet/core). We happily accept issues and PRs.
         </p>
         <p>
-            This package contains all the tools you will need to start writing applications with .NET Core. It includes the several tools, including the C# compiler and the NuGet package manager, and a copy of .NET Core for both you and the tools to use. 
+            This package contains all the tools you will need to start writing applications with .NET. It includes the several tools, including the C# compiler and the NuGet package manager, and a copy of .NET for both you and the tools to use. 
         </p>
     </font>
 </body>

src/installer/pkg/packaging/osx/hostfxr/resources/de.lproj/conclusion.html

@@ -3,17 +3,17 @@
 <html lang="en">
 <head>
     <meta charset="utf-8" />
-    <title styles="color:white">Congratulations! You've successfully installed .NET Core CLI!</title>
+    <title styles="color:white">Congratulations! You've successfully installed .NET CLI!</title>
 </head>
 <body>
         <div align="center" style="font-family: Helvetica;">  
             <h1>The installation was successful.</h1>
-            <p>.NET Core CLI was successfully installed.</p>
+            <p>.NET CLI was successfully installed.</p>
         <h2>
             Install dependencies
         </h2>
         <p>
-        In order to be able to use .NET Core on OS X, you need to install <b>OpenSSL</b> version <b>1.0.1/1.0.2</b>. 
+        In order to be able to use .NET on OS X, you need to install <b>OpenSSL</b> version <b>1.0.1/1.0.2</b>. 
         There are many ways to install/update your libssl. Using <a href="https://brew.sh">Homebrew</a> is the easiest. 
         You can view the instructions <a href="http://brewformulas.org/Openssl">here</a> or if you're updating, <a href="https://github.com/dotnet/runtime/blob/master/docs/workflow/building/coreclr/osx-instructions.md#openssl">on this page</a>.
         </p>

src/installer/pkg/packaging/osx/hostfxr/resources/de.lproj/welcome.html

@@ -2,18 +2,18 @@
 <html lang="en">
 <head>
     <meta charset="utf-8" />
-    <title styles="color:white">Welcome to the .NET Core CLI installer.</title>
+    <title styles="color:white">Welcome to the .NET CLI installer.</title>
 </head>
 <body>
     <font face="Helvetica">
         <h3>
-            Microsoft .NET Core CLI
+            Microsoft .NET CLI
         </h3>
         <p>
-            .NET Core is a development platform that you can use to build command-line applications, microservices and modern websites. It is open source, cross-platform and is supported by Microsoft. We hope you enjoy using it! If you do, please consider joining the active community of developers that are contributing to the project on GitHub (https://github.com/dotnet/core). We happily accept issues and PRs.
+            .NET is a development platform that you can use to build command-line applications, microservices and modern websites. It is open source, cross-platform and is supported by Microsoft. We hope you enjoy using it! If you do, please consider joining the active community of developers that are contributing to the project on GitHub (https://github.com/dotnet/core). We happily accept issues and PRs.
         </p>
         <p>
-            This package contains all the tools you will need to start writing applications with .NET Core. It includes the several tools, including the C# compiler and the NuGet package manager, and a copy of .NET Core for both you and the tools to use. 
+            This package contains all the tools you will need to start writing applications with .NET. It includes the several tools, including the C# compiler and the NuGet package manager, and a copy of .NET for both you and the tools to use. 
         </p>
     </font>
 </body>

src/installer/pkg/packaging/osx/hostfxr/resources/en.lproj/conclusion.html

@@ -3,17 +3,17 @@
 <html lang="en">
 <head>
     <meta charset="utf-8" />
-    <title styles="color:white">Congratulations! You've successfully installed .NET Core CLI!</title>
+    <title styles="color:white">Congratulations! You've successfully installed .NET CLI!</title>
 </head>
 <body>
         <div align="center" style="font-family: Helvetica;">  
             <h1>The installation was successful.</h1>
-            <p>.NET Core CLI was successfully installed.</p>
+            <p>.NET CLI was successfully installed.</p>
         <h2>
             Install dependencies
         </h2>
         <p>
-        In order to be able to use .NET Core on OS X, you need to install <b>OpenSSL</b> version <b>1.0.1/1.0.2</b>. 
+        In order to be able to use .NET on OS X, you need to install <b>OpenSSL</b> version <b>1.0.1/1.0.2</b>. 
         There are many ways to install/update your libssl. Using <a href="https://brew.sh">Homebrew</a> is the easiest. 
         You can view the instructions <a href="http://brewformulas.org/Openssl">here</a> or if you're updating, <a href="https://github.com/dotnet/runtime/blob/master/docs/workflow/building/coreclr/osx-instructions.md#openssl">on this page</a>.
         </p>

src/installer/pkg/packaging/osx/hostfxr/resources/en.lproj/welcome.html

@@ -2,18 +2,18 @@
 <html lang="en">
 <head>
     <meta charset="utf-8" />
-    <title styles="color:white">Welcome to the .NET Core CLI installer.</title>
+    <title styles="color:white">Welcome to the .NET CLI installer.</title>
 </head>
 <body>
     <font face="Helvetica">
         <h3>
-            Microsoft .NET Core CLI
+            Microsoft .NET CLI
         </h3>
         <p>
-            .NET Core is a development platform that you can use to build command-line applications, microservices and modern websites. It is open source, cross-platform and is supported by Microsoft. We hope you enjoy using it! If you do, please consider joining the active community of developers that are contributing to the project on GitHub (https://github.com/dotnet/core). We happily accept issues and PRs.
+            .NET is a development platform that you can use to build command-line applications, microservices and modern websites. It is open source, cross-platform and is supported by Microsoft. We hope you enjoy using it! If you do, please consider joining the active community of developers that are contributing to the project on GitHub (https://github.com/dotnet/core). We happily accept issues and PRs.
         </p>
         <p>
-            This package contains all the tools you will need to start writing applications with .NET Core. It includes the several tools, including the C# compiler and the NuGet package manager, and a copy of .NET Core for both you and the tools to use. 
+            This package contains all the tools you will need to start writing applications with .NET. It includes the several tools, including the C# compiler and the NuGet package manager, and a copy of .NET for both you and the tools to use. 
         </p>
     </font>
 </body>

src/installer/pkg/packaging/osx/hostfxr/resources/es.lproj/conclusion.html

@@ -3,17 +3,17 @@
 <html lang="en">
 <head>
     <meta charset="utf-8" />
-    <title styles="color:white">Congratulations! You've successfully installed .NET Core CLI!</title>
+    <title styles="color:white">Congratulations! You've successfully installed .NET CLI!</title>
 </head>
 <body>
         <div align="center" style="font-family: Helvetica;">  
             <h1>The installation was successful.</h1>
-            <p>.NET Core CLI was successfully installed.</p>
+            <p>.NET CLI was successfully installed.</p>
         <h2>
             Install dependencies
         </h2>
         <p>
-        In order to be able to use .NET Core on OS X, you need to install <b>OpenSSL</b> version <b>1.0.1/1.0.2</b>. 
+        In order to be able to use .NET on OS X, you need to install <b>OpenSSL</b> version <b>1.0.1/1.0.2</b>. 
         There are many ways to install/update your libssl. Using <a href="https://brew.sh">Homebrew</a> is the easiest. 
         You can view the instructions <a href="http://brewformulas.org/Openssl">here</a> or if you're updating, <a href="https://github.com/dotnet/runtime/blob/master/docs/workflow/building/coreclr/osx-instructions.md#openssl">on this page</a>.
         </p>

src/installer/pkg/packaging/osx/hostfxr/resources/es.lproj/welcome.html

@@ -2,18 +2,18 @@
 <html lang="en">
 <head>
     <meta charset="utf-8" />
-    <title styles="color:white">Welcome to the .NET Core CLI installer.</title>
+    <title styles="color:white">Welcome to the .NET CLI installer.</title>
 </head>
 <body>
     <font face="Helvetica">
         <h3>
-            Microsoft .NET Core CLI
+            Microsoft .NET CLI
         </h3>
         <p>
-            .NET Core is a development platform that you can use to build command-line applications, microservices and modern websites. It is open source, cross-platform and is supported by Microsoft. We hope you enjoy using it! If you do, please consider joining the active community of developers that are contributing to the project on GitHub (https://github.com/dotnet/core). We happily accept issues and PRs.
+            .NET is a development platform that you can use to build command-line applications, microservices and modern websites. It is open source, cross-platform and is supported by Microsoft. We hope you enjoy using it! If you do, please consider joining the active community of developers that are contributing to the project on GitHub (https://github.com/dotnet/core). We happily accept issues and PRs.
         </p>
         <p>
-            This package contains all the tools you will need to start writing applications with .NET Core. It includes the several tools, including the C# compiler and the NuGet package manager, and a copy of .NET Core for both you and the tools to use. 
+            This package contains all the tools you will need to start writing applications with .NET. It includes the several tools, including the C# compiler and the NuGet package manager, and a copy of .NET for both you and the tools to use. 
         </p>
     </font>
 </body>

src/installer/pkg/packaging/osx/hostfxr/resources/fr.lproj/conclusion.html

@@ -3,17 +3,17 @@
 <html lang="en">
 <head>
     <meta charset="utf-8" />
-    <title styles="color:white">Congratulations! You've successfully installed .NET Core CLI!</title>
+    <title styles="color:white">Congratulations! You've successfully installed .NET CLI!</title>
 </head>
 <body>
         <div align="center" style="font-family: Helvetica;">  
             <h1>The installation was successful.</h1>
-            <p>.NET Core CLI was successfully installed.</p>
+            <p>.NET CLI was successfully installed.</p>
         <h2>
             Install dependencies
         </h2>
         <p>
-        In order to be able to use .NET Core on OS X, you need to install <b>OpenSSL</b> version <b>1.0.1/1.0.2</b>. 
+        In order to be able to use .NET on OS X, you need to install <b>OpenSSL</b> version <b>1.0.1/1.0.2</b>. 
         There are many ways to install/update your libssl. Using <a href="https://brew.sh">Homebrew</a> is the easiest. 
         You can view the instructions <a href="http://brewformulas.org/Openssl">here</a> or if you're updating, <a href="https://github.com/dotnet/runtime/blob/master/docs/workflow/building/coreclr/osx-instructions.md#openssl">on this page</a>.
         </p>

src/installer/pkg/packaging/osx/hostfxr/resources/fr.lproj/welcome.html

@@ -2,18 +2,18 @@
 <html lang="en">
 <head>
     <meta charset="utf-8" />
-    <title styles="color:white">Welcome to the .NET Core CLI installer.</title>
+    <title styles="color:white">Welcome to the .NET CLI installer.</title>
 </head>
 <body>
     <font face="Helvetica">
         <h3>
-            Microsoft .NET Core CLI
+            Microsoft .NET CLI
         </h3>
         <p>
-            .NET Core is a development platform that you can use to build command-line applications, microservices and modern websites. It is open source, cross-platform and is supported by Microsoft. We hope you enjoy using it! If you do, please consider joining the active community of developers that are contributing to the project on GitHub (https://github.com/dotnet/core). We happily accept issues and PRs.
+            .NET is a development platform that you can use to build command-line applications, microservices and modern websites. It is open source, cross-platform and is supported by Microsoft. We hope you enjoy using it! If you do, please consider joining the active community of developers that are contributing to the project on GitHub (https://github.com/dotnet/core). We happily accept issues and PRs.
         </p>
         <p>
-            This package contains all the tools you will need to start writing applications with .NET Core. It includes the several tools, including the C# compiler and the NuGet package manager, and a copy of .NET Core for both you and the tools to use. 
+            This package contains all the tools you will need to start writing applications with .NET. It includes the several tools, including the C# compiler and the NuGet package manager, and a copy of .NET for both you and the tools to use. 
         </p>
     </font>
 </body>

src/installer/pkg/packaging/osx/hostfxr/resources/it.lproj/conclusion.html

@@ -3,17 +3,17 @@
 <html lang="en">
 <head>
     <meta charset="utf-8" />
-    <title styles="color:white">Congratulations! You've successfully installed .NET Core CLI!</title>
+    <title styles="color:white">Congratulations! You've successfully installed .NET CLI!</title>
 </head>
 <body>
         <div align="center" style="font-family: Helvetica;">  
             <h1>The installation was successful.</h1>
-            <p>.NET Core CLI was successfully installed.</p>
+            <p>.NET CLI was successfully installed.</p>
         <h2>
             Install dependencies
         </h2>
         <p>
-        In order to be able to use .NET Core on OS X, you need to install <b>OpenSSL</b> version <b>1.0.1/1.0.2</b>. 
+        In order to be able to use .NET on OS X, you need to install <b>OpenSSL</b> version <b>1.0.1/1.0.2</b>. 
         There are many ways to install/update your libssl. Using <a href="https://brew.sh">Homebrew</a> is the easiest. 
         You can view the instructions <a href="http://brewformulas.org/Openssl">here</a> or if you're updating, <a href="https://github.com/dotnet/runtime/blob/master/docs/workflow/building/coreclr/osx-instructions.md#openssl">on this page</a>.
         </p>

src/installer/pkg/packaging/osx/hostfxr/resources/it.lproj/welcome.html

@@ -2,18 +2,18 @@
 <html lang="en">
 <head>
     <meta charset="utf-8" />
-    <title styles="color:white">Welcome to the .NET Core CLI installer.</title>
+    <title styles="color:white">Welcome to the .NET CLI installer.</title>
 </head>
 <body>
     <font face="Helvetica">
         <h3>
-            Microsoft .NET Core CLI
+            Microsoft .NET CLI
         </h3>
         <p>
-            .NET Core is a development platform that you can use to build command-line applications, microservices and modern websites. It is open source, cross-platform and is supported by Microsoft. We hope you enjoy using it! If you do, please consider joining the active community of developers that are contributing to the project on GitHub (https://github.com/dotnet/core). We happily accept issues and PRs.
+            .NET is a development platform that you can use to build command-line applications, microservices and modern websites. It is open source, cross-platform and is supported by Microsoft. We hope you enjoy using it! If you do, please consider joining the active community of developers that are contributing to the project on GitHub (https://github.com/dotnet/core). We happily accept issues and PRs.
         </p>
         <p>
-            This package contains all the tools you will need to start writing applications with .NET Core. It includes the several tools, including the C# compiler and the NuGet package manager, and a copy of .NET Core for both you and the tools to use. 
+            This package contains all the tools you will need to start writing applications with .NET. It includes the several tools, including the C# compiler and the NuGet package manager, and a copy of .NET for both you and the tools to use. 
         </p>
     </font>
 </body>

src/installer/pkg/packaging/osx/hostfxr/resources/ja.lproj/conclusion.html

@@ -3,17 +3,17 @@
 <html lang="en">
 <head>
     <meta charset="utf-8" />
-    <title styles="color:white">Congratulations! You've successfully installed .NET Core CLI!</title>
+    <title styles="color:white">Congratulations! You've successfully installed .NET CLI!</title>
 </head>
 <body>
         <div align="center" style="font-family: Helvetica;">  
             <h1>The installation was successful.</h1>
-            <p>.NET Core CLI was successfully installed.</p>
+            <p>.NET CLI was successfully installed.</p>
         <h2>
             Install dependencies
         </h2>
         <p>
-        In order to be able to use .NET Core on OS X, you need to install <b>OpenSSL</b> version <b>1.0.1/1.0.2</b>. 
+        In order to be able to use .NET on OS X, you need to install <b>OpenSSL</b> version <b>1.0.1/1.0.2</b>. 
         There are many ways to install/update your libssl. Using <a href="https://brew.sh">Homebrew</a> is the easiest. 
         You can view the instructions <a href="http://brewformulas.org/Openssl">here</a> or if you're updating, <a href="https://github.com/dotnet/runtime/blob/master/docs/workflow/building/coreclr/osx-instructions.md#openssl">on this page</a>.
         </p>

src/installer/pkg/packaging/osx/hostfxr/resources/ja.lproj/welcome.html

@@ -2,18 +2,18 @@
 <html lang="en">
 <head>
     <meta charset="utf-8" />
-    <title styles="color:white">Welcome to the .NET Core CLI installer.</title>
+    <title styles="color:white">Welcome to the .NET CLI installer.</title>
 </head>
 <body>
     <font face="Helvetica">
         <h3>
-            Microsoft .NET Core CLI
+            Microsoft .NET CLI
         </h3>
         <p>
-            .NET Core is a development platform that you can use to build command-line applications, microservices and modern websites. It is open source, cross-platform and is supported by Microsoft. We hope you enjoy using it! If you do, please consider joining the active community of developers that are contributing to the project on GitHub (https://github.com/dotnet/core). We happily accept issues and PRs.
+            .NET is a development platform that you can use to build command-line applications, microservices and modern websites. It is open source, cross-platform and is supported by Microsoft. We hope you enjoy using it! If you do, please consider joining the active community of developers that are contributing to the project on GitHub (https://github.com/dotnet/core). We happily accept issues and PRs.
         </p>
         <p>
-            This package contains all the tools you will need to start writing applications with .NET Core. It includes the several tools, including the C# compiler and the NuGet package manager, and a copy of .NET Core for both you and the tools to use. 
+            This package contains all the tools you will need to start writing applications with .NET. It includes the several tools, including the C# compiler and the NuGet package manager, and a copy of .NET for both you and the tools to use. 
         </p>
     </font>
 </body>

src/installer/pkg/packaging/osx/hostfxr/resources/ko.lproj/conclusion.html

@@ -3,17 +3,17 @@
 <html lang="en">
 <head>
     <meta charset="utf-8" />
-    <title styles="color:white">Congratulations! You've successfully installed .NET Core CLI!</title>
+    <title styles="color:white">Congratulations! You've successfully installed .NET CLI!</title>
 </head>
 <body>
         <div align="center" style="font-family: Helvetica;">  
             <h1>The installation was successful.</h1>
-            <p>.NET Core CLI was successfully installed.</p>
+            <p>.NET CLI was successfully installed.</p>
         <h2>
             Install dependencies
         </h2>
         <p>
-        In order to be able to use .NET Core on OS X, you need to install <b>OpenSSL</b> version <b>1.0.1/1.0.2</b>. 
+        In order to be able to use .NET on OS X, you need to install <b>OpenSSL</b> version <b>1.0.1/1.0.2</b>. 
         There are many ways to install/update your libssl. Using <a href="https://brew.sh">Homebrew</a> is the easiest. 
         You can view the instructions <a href="http://brewformulas.org/Openssl">here</a> or if you're updating, <a href="https://github.com/dotnet/runtime/blob/master/docs/workflow/building/coreclr/osx-instructions.md#openssl">on this page</a>.
         </p>

src/installer/pkg/packaging/osx/hostfxr/resources/ko.lproj/welcome.html

@@ -2,18 +2,18 @@
 <html lang="en">
 <head>
     <meta charset="utf-8" />
-    <title styles="color:white">Welcome to the .NET Core CLI installer.</title>
+    <title styles="color:white">Welcome to the .NET CLI installer.</title>
 </head>
 <body>
     <font face="Helvetica">
         <h3>
-            Microsoft .NET Core CLI
+            Microsoft .NET CLI
         </h3>
         <p>
-            .NET Core is a development platform that you can use to build command-line applications, microservices and modern websites. It is open source, cross-platform and is supported by Microsoft. We hope you enjoy using it! If you do, please consider joining the active community of developers that are contributing to the project on GitHub (https://github.com/dotnet/core). We happily accept issues and PRs.
+            .NET is a development platform that you can use to build command-line applications, microservices and modern websites. It is open source, cross-platform and is supported by Microsoft. We hope you enjoy using it! If you do, please consider joining the active community of developers that are contributing to the project on GitHub (https://github.com/dotnet/core). We happily accept issues and PRs.
         </p>
         <p>
-            This package contains all the tools you will need to start writing applications with .NET Core. It includes the several tools, including the C# compiler and the NuGet package manager, and a copy of .NET Core for both you and the tools to use. 
+            This package contains all the tools you will need to start writing applications with .NET. It includes the several tools, including the C# compiler and the NuGet package manager, and a copy of .NET for both you and the tools to use. 
         </p>
     </font>
 </body>

src/installer/pkg/packaging/osx/hostfxr/resources/pl.lproj/conclusion.html

@@ -3,17 +3,17 @@
 <html lang="en">
 <head>
     <meta charset="utf-8" />
-    <title styles="color:white">Congratulations! You've successfully installed .NET Core CLI!</title>
+    <title styles="color:white">Congratulations! You've successfully installed .NET CLI!</title>
 </head>
 <body>
         <div align="center" style="font-family: Helvetica;">  
             <h1>The installation was successful.</h1>
-            <p>.NET Core CLI was successfully installed.</p>
+            <p>.NET CLI was successfully installed.</p>
         <h2>
             Install dependencies
         </h2>
         <p>
-        In order to be able to use .NET Core on OS X, you need to install <b>OpenSSL</b> version <b>1.0.1/1.0.2</b>. 
+        In order to be able to use .NET on OS X, you need to install <b>OpenSSL</b> version <b>1.0.1/1.0.2</b>. 
         There are many ways to install/update your libssl. Using <a href="https://brew.sh">Homebrew</a> is the easiest. 
         You can view the instructions <a href="http://brewformulas.org/Openssl">here</a> or if you're updating, <a href="https://github.com/dotnet/runtime/blob/master/docs/workflow/building/coreclr/osx-instructions.md#openssl">on this page</a>.
         </p>

src/installer/pkg/packaging/osx/hostfxr/resources/pl.lproj/welcome.html

@@ -2,18 +2,18 @@
 <html lang="en">
 <head>
     <meta charset="utf-8" />
-    <title styles="color:white">Welcome to the .NET Core CLI installer.</title>
+    <title styles="color:white">Welcome to the .NET CLI installer.</title>
 </head>
 <body>
     <font face="Helvetica">
         <h3>
-            Microsoft .NET Core CLI
+            Microsoft .NET CLI
         </h3>
         <p>
-            .NET Core is a development platform that you can use to build command-line applications, microservices and modern websites. It is open source, cross-platform and is supported by Microsoft. We hope you enjoy using it! If you do, please consider joining the active community of developers that are contributing to the project on GitHub (https://github.com/dotnet/core). We happily accept issues and PRs.
+            .NET is a development platform that you can use to build command-line applications, microservices and modern websites. It is open source, cross-platform and is supported by Microsoft. We hope you enjoy using it! If you do, please consider joining the active community of developers that are contributing to the project on GitHub (https://github.com/dotnet/core). We happily accept issues and PRs.
         </p>
         <p>
-            This package contains all the tools you will need to start writing applications with .NET Core. It includes the several tools, including the C# compiler and the NuGet package manager, and a copy of .NET Core for both you and the tools to use. 
+            This package contains all the tools you will need to start writing applications with .NET. It includes the several tools, including the C# compiler and the NuGet package manager, and a copy of .NET for both you and the tools to use. 
         </p>
     </font>
 </body>

src/installer/pkg/packaging/osx/hostfxr/resources/pt-br.lproj/conclusion.html

@@ -3,17 +3,17 @@
 <html lang="en">
 <head>
     <meta charset="utf-8" />
-    <title styles="color:white">Congratulations! You've successfully installed .NET Core CLI!</title>
+    <title styles="color:white">Congratulations! You've successfully installed .NET CLI!</title>
 </head>
 <body>
         <div align="center" style="font-family: Helvetica;">  
             <h1>The installation was successful.</h1>
-            <p>.NET Core CLI was successfully installed.</p>
+            <p>.NET CLI was successfully installed.</p>
         <h2>
             Install dependencies
         </h2>
         <p>
-        In order to be able to use .NET Core on OS X, you need to install <b>OpenSSL</b> version <b>1.0.1/1.0.2</b>. 
+        In order to be able to use .NET on OS X, you need to install <b>OpenSSL</b> version <b>1.0.1/1.0.2</b>. 
         There are many ways to install/update your libssl. Using <a href="https://brew.sh">Homebrew</a> is the easiest. 
         You can view the instructions <a href="http://brewformulas.org/Openssl">here</a> or if you're updating, <a href="https://github.com/dotnet/runtime/blob/master/docs/workflow/building/coreclr/osx-instructions.md#openssl">on this page</a>.
         </p>

src/installer/pkg/packaging/osx/hostfxr/resources/pt-br.lproj/welcome.html

@@ -2,18 +2,18 @@
 <html lang="en">
 <head>
     <meta charset="utf-8" />
-    <title styles="color:white">Welcome to the .NET Core CLI installer.</title>
+    <title styles="color:white">Welcome to the .NET CLI installer.</title>
 </head>
 <body>
     <font face="Helvetica">
         <h3>
-            Microsoft .NET Core CLI
+            Microsoft .NET CLI
         </h3>
         <p>
-            .NET Core is a development platform that you can use to build command-line applications, microservices and modern websites. It is open source, cross-platform and is supported by Microsoft. We hope you enjoy using it! If you do, please consider joining the active community of developers that are contributing to the project on GitHub (https://github.com/dotnet/core). We happily accept issues and PRs.
+            .NET is a development platform that you can use to build command-line applications, microservices and modern websites. It is open source, cross-platform and is supported by Microsoft. We hope you enjoy using it! If you do, please consider joining the active community of developers that are contributing to the project on GitHub (https://github.com/dotnet/core). We happily accept issues and PRs.
         </p>
         <p>
-            This package contains all the tools you will need to start writing applications with .NET Core. It includes the several tools, including the C# compiler and the NuGet package manager, and a copy of .NET Core for both you and the tools to use. 
+            This package contains all the tools you will need to start writing applications with .NET. It includes the several tools, including the C# compiler and the NuGet package manager, and a copy of .NET for both you and the tools to use. 
         </p>
     </font>
 </body>

src/installer/pkg/packaging/osx/hostfxr/resources/ru.lproj/conclusion.html

@@ -3,17 +3,17 @@
 <html lang="en">
 <head>
     <meta charset="utf-8" />
-    <title styles="color:white">Congratulations! You've successfully installed .NET Core CLI!</title>
+    <title styles="color:white">Congratulations! You've successfully installed .NET CLI!</title>
 </head>
 <body>
         <div align="center" style="font-family: Helvetica;">  
             <h1>The installation was successful.</h1>
-            <p>.NET Core CLI was successfully installed.</p>
+            <p>.NET CLI was successfully installed.</p>
         <h2>
             Install dependencies
         </h2>
         <p>
-        In order to be able to use .NET Core on OS X, you need to install <b>OpenSSL</b> version <b>1.0.1/1.0.2</b>. 
+        In order to be able to use .NET on OS X, you need to install <b>OpenSSL</b> version <b>1.0.1/1.0.2</b>. 
         There are many ways to install/update your libssl. Using <a href="https://brew.sh">Homebrew</a> is the easiest. 
         You can view the instructions <a href="http://brewformulas.org/Openssl">here</a> or if you're updating, <a href="https://github.com/dotnet/runtime/blob/master/docs/workflow/building/coreclr/osx-instructions.md#openssl">on this page</a>.
         </p>

src/installer/pkg/packaging/osx/hostfxr/resources/ru.lproj/welcome.html

@@ -2,18 +2,18 @@
 <html lang="en">
 <head>
     <meta charset="utf-8" />
-    <title styles="color:white">Welcome to the .NET Core CLI installer.</title>
+    <title styles="color:white">Welcome to the .NET CLI installer.</title>
 </head>
 <body>
     <font face="Helvetica">
         <h3>
-            Microsoft .NET Core CLI
+            Microsoft .NET CLI
         </h3>
         <p>
-            .NET Core is a development platform that you can use to build command-line applications, microservices and modern websites. It is open source, cross-platform and is supported by Microsoft. We hope you enjoy using it! If you do, please consider joining the active community of developers that are contributing to the project on GitHub (https://github.com/dotnet/core). We happily accept issues and PRs.
+            .NET is a development platform that you can use to build command-line applications, microservices and modern websites. It is open source, cross-platform and is supported by Microsoft. We hope you enjoy using it! If you do, please consider joining the active community of developers that are contributing to the project on GitHub (https://github.com/dotnet/core). We happily accept issues and PRs.
         </p>
         <p>
-            This package contains all the tools you will need to start writing applications with .NET Core. It includes the several tools, including the C# compiler and the NuGet package manager, and a copy of .NET Core for both you and the tools to use. 
+            This package contains all the tools you will need to start writing applications with .NET. It includes the several tools, including the C# compiler and the NuGet package manager, and a copy of .NET for both you and the tools to use. 
         </p>
     </font>
 </body>

src/installer/pkg/packaging/osx/hostfxr/resources/tr.lproj/conclusion.html

@@ -3,17 +3,17 @@
 <html lang="en">
 <head>
     <meta charset="utf-8" />
-    <title styles="color:white">Congratulations! You've successfully installed .NET Core CLI!</title>
+    <title styles="color:white">Congratulations! You've successfully installed .NET CLI!</title>
 </head>
 <body>
         <div align="center" style="font-family: Helvetica;">  
             <h1>The installation was successful.</h1>
-            <p>.NET Core CLI was successfully installed.</p>
+            <p>.NET CLI was successfully installed.</p>
         <h2>
             Install dependencies
         </h2>
         <p>
-        In order to be able to use .NET Core on OS X, you need to install <b>OpenSSL</b> version <b>1.0.1/1.0.2</b>. 
+        In order to be able to use .NET on OS X, you need to install <b>OpenSSL</b> version <b>1.0.1/1.0.2</b>. 
         There are many ways to install/update your libssl. Using <a href="https://brew.sh">Homebrew</a> is the easiest. 
         You can view the instructions <a href="http://brewformulas.org/Openssl">here</a> or if you're updating, <a href="https://github.com/dotnet/runtime/blob/master/docs/workflow/building/coreclr/osx-instructions.md#openssl">on this page</a>.
         </p>

src/installer/pkg/packaging/osx/hostfxr/resources/tr.lproj/welcome.html

@@ -2,18 +2,18 @@
 <html lang="en">
 <head>
     <meta charset="utf-8" />
-    <title styles="color:white">Welcome to the .NET Core CLI installer.</title>
+    <title styles="color:white">Welcome to the .NET CLI installer.</title>
 </head>
 <body>
     <font face="Helvetica">
         <h3>
-            Microsoft .NET Core CLI
+            Microsoft .NET CLI
         </h3>
         <p>
-            .NET Core is a development platform that you can use to build command-line applications, microservices and modern websites. It is open source, cross-platform and is supported by Microsoft. We hope you enjoy using it! If you do, please consider joining the active community of developers that are contributing to the project on GitHub (https://github.com/dotnet/core). We happily accept issues and PRs.
+            .NET is a development platform that you can use to build command-line applications, microservices and modern websites. It is open source, cross-platform and is supported by Microsoft. We hope you enjoy using it! If you do, please consider joining the active community of developers that are contributing to the project on GitHub (https://github.com/dotnet/core). We happily accept issues and PRs.
         </p>
         <p>
-            This package contains all the tools you will need to start writing applications with .NET Core. It includes the several tools, including the C# compiler and the NuGet package manager, and a copy of .NET Core for both you and the tools to use. 
+            This package contains all the tools you will need to start writing applications with .NET. It includes the several tools, including the C# compiler and the NuGet package manager, and a copy of .NET for both you and the tools to use. 
         </p>
     </font>
 </body>

src/installer/pkg/packaging/osx/hostfxr/resources/zh-hans.lproj/conclusion.html

@@ -3,17 +3,17 @@
 <html lang="en">
 <head>
     <meta charset="utf-8" />
-    <title styles="color:white">Congratulations! You've successfully installed .NET Core CLI!</title>
+    <title styles="color:white">Congratulations! You've successfully installed .NET CLI!</title>
 </head>
 <body>
         <div align="center" style="font-family: Helvetica;">  
             <h1>The installation was successful.</h1>
-            <p>.NET Core CLI was successfully installed.</p>
+            <p>.NET CLI was successfully installed.</p>
         <h2>
             Install dependencies
         </h2>
         <p>
-        In order to be able to use .NET Core on OS X, you need to install <b>OpenSSL</b> version <b>1.0.1/1.0.2</b>. 
+        In order to be able to use .NET on OS X, you need to install <b>OpenSSL</b> version <b>1.0.1/1.0.2</b>. 
         There are many ways to install/update your libssl. Using <a href="https://brew.sh">Homebrew</a> is the easiest. 
         You can view the instructions <a href="http://brewformulas.org/Openssl">here</a> or if you're updating, <a href="https://github.com/dotnet/runtime/blob/master/docs/workflow/building/coreclr/osx-instructions.md#openssl">on this page</a>.
         </p>

src/installer/pkg/packaging/osx/hostfxr/resources/zh-hans.lproj/welcome.html

@@ -2,18 +2,18 @@
 <html lang="en">
 <head>
     <meta charset="utf-8" />
-    <title styles="color:white">Welcome to the .NET Core CLI installer.</title>
+    <title styles="color:white">Welcome to the .NET CLI installer.</title>
 </head>
 <body>
     <font face="Helvetica">
         <h3>
-            Microsoft .NET Core CLI
+            Microsoft .NET CLI
         </h3>
         <p>
-            .NET Core is a development platform that you can use to build command-line applications, microservices and modern websites. It is open source, cross-platform and is supported by Microsoft. We hope you enjoy using it! If you do, please consider joining the active community of developers that are contributing to the project on GitHub (https://github.com/dotnet/core). We happily accept issues and PRs.
+            .NET is a development platform that you can use to build command-line applications, microservices and modern websites. It is open source, cross-platform and is supported by Microsoft. We hope you enjoy using it! If you do, please consider joining the active community of developers that are contributing to the project on GitHub (https://github.com/dotnet/core). We happily accept issues and PRs.
         </p>
         <p>
-            This package contains all the tools you will need to start writing applications with .NET Core. It includes the several tools, including the C# compiler and the NuGet package manager, and a copy of .NET Core for both you and the tools to use. 
+            This package contains all the tools you will need to start writing applications with .NET. It includes the several tools, including the C# compiler and the NuGet package manager, and a copy of .NET for both you and the tools to use. 
         </p>
     </font>
 </body>

src/installer/pkg/packaging/osx/hostfxr/resources/zh-hant.lproj/conclusion.html

@@ -3,17 +3,17 @@
 <html lang="en">
 <head>
     <meta charset="utf-8" />
-    <title styles="color:white">Congratulations! You've successfully installed .NET Core CLI!</title>
+    <title styles="color:white">Congratulations! You've successfully installed .NET CLI!</title>
 </head>
 <body>
         <div align="center" style="font-family: Helvetica;">  
             <h1>The installation was successful.</h1>
-            <p>.NET Core CLI was successfully installed.</p>
+            <p>.NET CLI was successfully installed.</p>
         <h2>
             Install dependencies
         </h2>
         <p>
-        In order to be able to use .NET Core on OS X, you need to install <b>OpenSSL</b> version <b>1.0.1/1.0.2</b>. 
+        In order to be able to use .NET on OS X, you need to install <b>OpenSSL</b> version <b>1.0.1/1.0.2</b>. 
         There are many ways to install/update your libssl. Using <a href="https://brew.sh">Homebrew</a> is the easiest. 
         You can view the instructions <a href="http://brewformulas.org/Openssl">here</a> or if you're updating, <a href="https://github.com/dotnet/runtime/blob/master/docs/workflow/building/coreclr/osx-instructions.md#openssl">on this page</a>.
         </p>

src/installer/pkg/packaging/osx/hostfxr/resources/zh-hant.lproj/welcome.html

@@ -2,18 +2,18 @@
 <html lang="en">
 <head>
     <meta charset="utf-8" />
-    <title styles="color:white">Welcome to the .NET Core CLI installer.</title>
+    <title styles="color:white">Welcome to the .NET CLI installer.</title>
 </head>
 <body>
     <font face="Helvetica">
         <h3>
-            Microsoft .NET Core CLI
+            Microsoft .NET CLI
         </h3>
         <p>
-            .NET Core is a development platform that you can use to build command-line applications, microservices and modern websites. It is open source, cross-platform and is supported by Microsoft. We hope you enjoy using it! If you do, please consider joining the active community of developers that are contributing to the project on GitHub (https://github.com/dotnet/core). We happily accept issues and PRs.
+            .NET is a development platform that you can use to build command-line applications, microservices and modern websites. It is open source, cross-platform and is supported by Microsoft. We hope you enjoy using it! If you do, please consider joining the active community of developers that are contributing to the project on GitHub (https://github.com/dotnet/core). We happily accept issues and PRs.
         </p>
         <p>
-            This package contains all the tools you will need to start writing applications with .NET Core. It includes the several tools, including the C# compiler and the NuGet package manager, and a copy of .NET Core for both you and the tools to use. 
+            This package contains all the tools you will need to start writing applications with .NET. It includes the several tools, including the C# compiler and the NuGet package manager, and a copy of .NET for both you and the tools to use. 
         </p>
     </font>
 </body>

src/installer/pkg/packaging/osx/sharedframework/resources/cs.lproj/welcome.html

@@ -6,11 +6,11 @@
 <body>
         <br>
         <div align="left" style="font-family: Helvetica;padding-left:10px">  
-            <h2>.NET Core Runtime</h2>
-            <p>.NET Core is a development platform that you can use to build command-line applications, microservices and modern websites.It is open source, cross-platform, and supported by Microsoft. We hope you enjoy it!</p>
+            <h2>.NET Runtime</h2>
+            <p>.NET is a development platform that you can use to build command-line applications, microservices and modern websites.It is open source, cross-platform, and supported by Microsoft. We hope you enjoy it!</p>
         </div>
         <div align="left" style="font-family: Helvetica">
-        <h2 style="padding-left:10px">Learn more about .NET Core</h2>
+        <h2 style="padding-left:10px">Learn more about .NET</h2>
         <ul>
           <li><a href="https://aka.ms/dotnet-docs">Documentation</a></li>
           <li><a href="https://aka.ms/dev-privacy">Privacy Statement</a></li>

src/installer/pkg/packaging/osx/sharedframework/resources/de.lproj/welcome.html

@@ -6,11 +6,11 @@
 <body>
         <br>
         <div align="left" style="font-family: Helvetica;padding-left:10px">  
-            <h2>.NET Core Runtime</h2>
-            <p>.NET Core is a development platform that you can use to build command-line applications, microservices and modern websites.It is open source, cross-platform, and supported by Microsoft. We hope you enjoy it!</p>
+            <h2>.NET Runtime</h2>
+            <p>.NET is a development platform that you can use to build command-line applications, microservices and modern websites.It is open source, cross-platform, and supported by Microsoft. We hope you enjoy it!</p>
         </div>
         <div align="left" style="font-family: Helvetica">
-        <h2 style="padding-left:10px">Learn more about .NET Core</h2>
+        <h2 style="padding-left:10px">Learn more about .NET</h2>
         <ul>
           <li><a href="https://aka.ms/dotnet-docs">Documentation</a></li>
           <li><a href="https://aka.ms/dev-privacy">Privacy Statement</a></li>

src/installer/pkg/packaging/osx/sharedframework/resources/en.lproj/welcome.html

@@ -6,11 +6,11 @@
 <body>
         <br>
         <div align="left" style="font-family: Helvetica;padding-left:10px">  
-            <h2>.NET Core Runtime</h2>
-            <p>.NET Core is a development platform that you can use to build command-line applications, microservices and modern websites.It is open source, cross-platform, and supported by Microsoft. We hope you enjoy it!</p>
+            <h2>.NET Runtime</h2>
+            <p>.NET is a development platform that you can use to build command-line applications, microservices and modern websites.It is open source, cross-platform, and supported by Microsoft. We hope you enjoy it!</p>
         </div>
         <div align="left" style="font-family: Helvetica">
-        <h2 style="padding-left:10px">Learn more about .NET Core</h2>
+        <h2 style="padding-left:10px">Learn more about .NET</h2>
         <ul>
           <li><a href="https://aka.ms/dotnet-docs">Documentation</a></li>
           <li><a href="https://aka.ms/dev-privacy">Privacy Statement</a></li>

src/installer/pkg/packaging/osx/sharedframework/resources/es.lproj/welcome.html

@@ -6,11 +6,11 @@
 <body>
         <br>
         <div align="left" style="font-family: Helvetica;padding-left:10px">  
-            <h2>.NET Core Runtime</h2>
-            <p>.NET Core is a development platform that you can use to build command-line applications, microservices and modern websites.It is open source, cross-platform, and supported by Microsoft. We hope you enjoy it!</p>
+            <h2>.NET Runtime</h2>
+            <p>.NET is a development platform that you can use to build command-line applications, microservices and modern websites.It is open source, cross-platform, and supported by Microsoft. We hope you enjoy it!</p>
         </div>
         <div align="left" style="font-family: Helvetica">
-        <h2 style="padding-left:10px">Learn more about .NET Core</h2>
+        <h2 style="padding-left:10px">Learn more about .NET</h2>
         <ul>
           <li><a href="https://aka.ms/dotnet-docs">Documentation</a></li>
           <li><a href="https://aka.ms/dev-privacy">Privacy Statement</a></li>

src/installer/pkg/packaging/osx/sharedframework/resources/fr.lproj/welcome.html

@@ -6,11 +6,11 @@
 <body>
         <br>
         <div align="left" style="font-family: Helvetica;padding-left:10px">  
-            <h2>.NET Core Runtime</h2>
-            <p>.NET Core is a development platform that you can use to build command-line applications, microservices and modern websites.It is open source, cross-platform, and supported by Microsoft. We hope you enjoy it!</p>
+            <h2>.NET Runtime</h2>
+            <p>.NET is a development platform that you can use to build command-line applications, microservices and modern websites.It is open source, cross-platform, and supported by Microsoft. We hope you enjoy it!</p>
         </div>
         <div align="left" style="font-family: Helvetica">
-        <h2 style="padding-left:10px">Learn more about .NET Core</h2>
+        <h2 style="padding-left:10px">Learn more about .NET</h2>
         <ul>
           <li><a href="https://aka.ms/dotnet-docs">Documentation</a></li>
           <li><a href="https://aka.ms/dev-privacy">Privacy Statement</a></li>

src/installer/pkg/packaging/osx/sharedframework/resources/it.lproj/welcome.html

@@ -6,11 +6,11 @@
 <body>
         <br>
         <div align="left" style="font-family: Helvetica;padding-left:10px">  
-            <h2>.NET Core Runtime</h2>
-            <p>.NET Core is a development platform that you can use to build command-line applications, microservices and modern websites.It is open source, cross-platform, and supported by Microsoft. We hope you enjoy it!</p>
+            <h2>.NET Runtime</h2>
+            <p>.NET is a development platform that you can use to build command-line applications, microservices and modern websites.It is open source, cross-platform, and supported by Microsoft. We hope you enjoy it!</p>
         </div>
         <div align="left" style="font-family: Helvetica">
-        <h2 style="padding-left:10px">Learn more about .NET Core</h2>
+        <h2 style="padding-left:10px">Learn more about .NET</h2>
         <ul>
           <li><a href="https://aka.ms/dotnet-docs">Documentation</a></li>
           <li><a href="https://aka.ms/dev-privacy">Privacy Statement</a></li>

src/installer/pkg/packaging/osx/sharedframework/resources/ja.lproj/welcome.html

@@ -6,11 +6,11 @@
 <body>
         <br>
         <div align="left" style="font-family: Helvetica;padding-left:10px">  
-            <h2>.NET Core Runtime</h2>
-            <p>.NET Core is a development platform that you can use to build command-line applications, microservices and modern websites.It is open source, cross-platform, and supported by Microsoft. We hope you enjoy it!</p>
+            <h2>.NET Runtime</h2>
+            <p>.NET is a development platform that you can use to build command-line applications, microservices and modern websites.It is open source, cross-platform, and supported by Microsoft. We hope you enjoy it!</p>
         </div>
         <div align="left" style="font-family: Helvetica">
-        <h2 style="padding-left:10px">Learn more about .NET Core</h2>
+        <h2 style="padding-left:10px">Learn more about .NET</h2>
         <ul>
           <li><a href="https://aka.ms/dotnet-docs">Documentation</a></li>
           <li><a href="https://aka.ms/dev-privacy">Privacy Statement</a></li>

src/installer/pkg/packaging/osx/sharedframework/resources/ko.lproj/welcome.html

@@ -6,11 +6,11 @@
 <body>
         <br>
         <div align="left" style="font-family: Helvetica;padding-left:10px">  
-            <h2>.NET Core Runtime</h2>
-            <p>.NET Core is a development platform that you can use to build command-line applications, microservices and modern websites.It is open source, cross-platform, and supported by Microsoft. We hope you enjoy it!</p>
+            <h2>.NET Runtime</h2>
+            <p>.NET is a development platform that you can use to build command-line applications, microservices and modern websites.It is open source, cross-platform, and supported by Microsoft. We hope you enjoy it!</p>
         </div>
         <div align="left" style="font-family: Helvetica">
-        <h2 style="padding-left:10px">Learn more about .NET Core</h2>
+        <h2 style="padding-left:10px">Learn more about .NET</h2>
         <ul>
           <li><a href="https://aka.ms/dotnet-docs">Documentation</a></li>
           <li><a href="https://aka.ms/dev-privacy">Privacy Statement</a></li>

src/installer/pkg/packaging/osx/sharedframework/resources/pl.lproj/welcome.html

@@ -6,11 +6,11 @@
 <body>
         <br>
         <div align="left" style="font-family: Helvetica;padding-left:10px">  
-            <h2>.NET Core Runtime</h2>
-            <p>.NET Core is a development platform that you can use to build command-line applications, microservices and modern websites.It is open source, cross-platform, and supported by Microsoft. We hope you enjoy it!</p>
+            <h2>.NET Runtime</h2>
+            <p>.NET is a development platform that you can use to build command-line applications, microservices and modern websites.It is open source, cross-platform, and supported by Microsoft. We hope you enjoy it!</p>
         </div>
         <div align="left" style="font-family: Helvetica">
-        <h2 style="padding-left:10px">Learn more about .NET Core</h2>
+        <h2 style="padding-left:10px">Learn more about .NET</h2>
         <ul>
           <li><a href="https://aka.ms/dotnet-docs">Documentation</a></li>
           <li><a href="https://aka.ms/dev-privacy">Privacy Statement</a></li>

src/installer/pkg/packaging/osx/sharedframework/resources/pt-br.lproj/welcome.html

@@ -6,11 +6,11 @@
 <body>
         <br>
         <div align="left" style="font-family: Helvetica;padding-left:10px">  
-            <h2>.NET Core Runtime</h2>
-            <p>.NET Core is a development platform that you can use to build command-line applications, microservices and modern websites.It is open source, cross-platform, and supported by Microsoft. We hope you enjoy it!</p>
+            <h2>.NET Runtime</h2>
+            <p>.NET is a development platform that you can use to build command-line applications, microservices and modern websites.It is open source, cross-platform, and supported by Microsoft. We hope you enjoy it!</p>
         </div>
         <div align="left" style="font-family: Helvetica">
-        <h2 style="padding-left:10px">Learn more about .NET Core</h2>
+        <h2 style="padding-left:10px">Learn more about .NET</h2>
         <ul>
           <li><a href="https://aka.ms/dotnet-docs">Documentation</a></li>
           <li><a href="https://aka.ms/dev-privacy">Privacy Statement</a></li>

src/installer/pkg/packaging/osx/sharedframework/shared-framework-distribution-template.xml

@@ -15,13 +15,13 @@
         <line choice="{SharedHostComponentId}.pkg" />
         <line choice="{HostFxrComponentId}.pkg" />
     </choices-outline>
-    <choice id="{SharedFxComponentId}.pkg" visible="true" title="{SharedFxBrandName} (x64)" description="The .NET Core Shared Framework">
+    <choice id="{SharedFxComponentId}.pkg" visible="true" title="{SharedFxBrandName} (x64)" description="The .NET Shared Framework">
         <pkg-ref id="{SharedFxComponentId}.pkg" />
     </choice>
-    <choice id="{HostFxrComponentId}.pkg" visible="true" title="{HostFxrBrandName} (x64)" description="The .NET Core HostFxr">
+    <choice id="{HostFxrComponentId}.pkg" visible="true" title="{HostFxrBrandName} (x64)" description="The .NET HostFxr">
         <pkg-ref id="{HostFxrComponentId}.pkg" />
     </choice>
-    <choice id="{SharedHostComponentId}.pkg" visible="true" title="{SharedHostBrandName} (x64)" description="The .NET Core Shared Host." >
+    <choice id="{SharedHostComponentId}.pkg" visible="true" title="{SharedHostBrandName} (x64)" description="The .NET Shared Host." >
         <pkg-ref id="{SharedHostComponentId}.pkg" />
     </choice>
     <pkg-ref id="{SharedFxComponentId}.pkg">{SharedFxComponentId}.pkg</pkg-ref>