anchor.diff:  }
   ```
   
  -## <a id='offline'></a> Push an App in a Disconnected Environment
  -
  -For offline environments, Cloud Foundry recommends using the [Framework-Dependent Deployments](#framework-dependent)
  -workflow. This workflow enables the deployed app to use the latest runtime provided by the offline buildpack.
  -
  -## <a id='runtime-store'></a>Maintain ASP.NET Core Assemblies
  -
  -<p class="note"><strong>Note:</strong> This section applies only to source-based and framework-dependent deployments.</p>
  -
  -For maintaining ASP.NET Core assemblies, update your `.csproj` file with the following:
  -
  -```
  -<PropertyGroup>
  -  <PublishWithAspNetCoreTargetManifest>false</PublishWithAspNetCoreTargetManifest>
  -</PropertyGroup>
  -```
  -
  -This results in a fully vendored app that requires fewer buildpack updates.
  -
  -Alternatively, to keep your SDK up to date, you can set `buildpack.yml` to the .NET SDK line you want to use:
  -
  -```
  ----
  -dotnet-core:
  -	sdk: 2.0.x
  -```
  -
  -<p class="note"><strong>Note:</strong> <code>2.0.x</code> ASP.NET Core assemblies are released
  -in the <code>2.1.200</code>-<code>2.1.299</code> SDK versions,
  -and <code>2.1.x</code> assemblies are released in the <code>2.1.300</code> and above SDK versions.</p>
  -
  -## <a id='port'></a>Configure the Listen Port ##
  -
  -For your .NET Core app to work on <%= vars.product_windows %>,
  -you must modify the `Main` method to configure the app to listen on the port specified by the `$PORT` environment variable.
  -<%= vars.product_windows %> sets this environment variable automatically.
  -
  -1. Open the file that contains your `Main` method.
  -
  -1. Add a `using` statement to the top of the file.
  -
  -    ```c#
  -    using Microsoft.Extensions.Configuration;
  -    ```
  -
  -1. Add the following lines before the line `var host = new WebHostBuilder()`:
  -
  -    ```c#
  -    var config = new ConfigurationBuilder()
  -        .AddCommandLine(args)
  -        .Build();
  -    ```
  -1. Add the following line after `.UseKestrel()`:
  -
  -    ```c#
  -    .UseConfiguration(config)
  -    ```
  -
  -    This allows the buildpack to pass the correct port from `$PORT` to the app when running the initial startup command.
  -
  -1. Add `Microsoft.Extensions.Configuration.CommandLine` as a dependency in `*.csproj`:
  -
  -    ```
  -    <PackageReference Include="Microsoft.Extensions.Configuration.CommandLine">
  -      <Version>VERSION</Version>
  -    </PackageReference>
  -    ```
  -
  -    In the above example, replace `VERSION` with the version of the package to use.
  -    To find a list of valid versions, navigate to https://www.nuget.org.
  -
  -1. If your app requires any other files at runtime, such as JSON configuration files, add them to the `include` section of `copyToOutput`.
  -
  -1. Save your changes.
  -
  -With these changes, the `dotnet run` command copies your app `Views` to the build output where the .NET CLI can find them.
  -Refer to the following example `Main` method:
  -
  -```c#
  -public static void Main(string[] args)
  -{
  -    var config = new ConfigurationBuilder()
  -        .AddCommandLine(args)
  -        .Build();
  -
  -    var host = new WebHostBuilder()
  -        .UseKestrel()
  -        .UseConfiguration(config)
  -        .UseContentRoot(Directory.GetCurrentDirectory())
  -        .UseStartup<Startup>()
  -        .Build();
  -    host.Run();
  -}
  -```
  -
  -## <a id='custom-libraries'></a>Add Custom Libraries
  +## <a id='multiple-projects'></a>Deploy Apps with Multiple Projects
  +
  +To deploy an app that contains multiple projects, you must specify a main project for the buildpack to run. Create a `.deployment` file in the root folder of the app which sets the path to the main project as follows:
  +
  +```text
  +[config]
  +project = <main project>
  +```
  +
  +### project.json Apps
  +
  +If the app uses `project.json`, set `project` to the directory containing the `project.json` file of the main project.
  +
  +### MSBuild Apps
  +
  +If the app uses MSBuild, set `project` to the `*.csproj` or `*.fsproj` file of the main project.
  +
  +For example, if an app using MSBuild contains three projects in the `src` folder, the main project `MyApp.Web`, `MyApp.DAL`, and `MyApp.Services`, format the `.deployment` file as follows:
  +
  +```text
  +[config]
  +project = src/MyApp.Web/MyApp.Web.csproj
  +```
  +
  +In this example, the buildpack automatically compiles the `MyApp.DAL` and `MyApp.Services` projects if the `MyApp.Web.csproj` file of the main project lists them as dependencies, `MyApp.Web`. The buildpack attempts to execute the main project with `dotnet run -p src/MyApp.Web/MyApp.Web.csproj`.
  +
  +## <a id='disconnected-environments'></a>Push an App in a Disconnected Environment
  +
  +For offline use, you can cache the binaries in `manifest.yml` with the buildpack.
  +
  +You can push apps with their other dependencies following these steps:
  +
  +1. Publish the app by running `dotnet publish -r ubuntu.14.04-x64`.
  +
  +    <p class="note"><strong>Note</strong>: For this publish command to work, modify your app code so the .NET CLI publishes it as a self-contained app. For more information, see <a href="https://docs.microsoft.com/en-us/dotnet/articles/core/deploying/">.NET Core Application Deployment</a>.
  +    </p>
  +
  +1. Navigate to the `bin/<Debug|Release>/<framework>/<runtime>/publish` directory. Or, if your app uses a `manifest.yml`, specify a path to the publish output folder. This allows you to push your app from any directory.
  +
  +1. Push your app.
  +
  +## <a id='disabling-nuget'></a>Disabling the NuGet Package Cache
  +
  +You may need to disable NuGet package caching, or clear NuGet packages cached in the staging environment, in one of the following scenarios:
  +
  +* Your app fails to stage because it runs out of space, exceeding the maximum allowable disk quota.
  +* You have added pre-release packages to test a new feature, then decided to revert back to the main NuGet feed. You may need to remove the packages you changed from the cache to avoid conflicts.
  +
  +Disabling NuGet caching both clears any existing NuGet dependencies from the staging cache and prevents the buildpack from adding NuGet dependencies to the staging cache.
  +
  +To disable NuGet package caching, set the `CACHE_NUGET_PACKAGES` environment variable to `false`. If the variable is not set, or set to a different value, there is no change. Perform one of the following procedures to set `CACHE_NUGET_PACKAGES` to `false`:
  +
  +* Locate your app manifest, `manifest.yml`, and set the `CACHE_NUGET_PACKAGES` environment variable, following the format of the example below:
  +
  +    ```yml
  +    ---
  +    applications:
  +    - name: sample-aspnetcore-app
  +      memory: 512M
  +      env:
  +        CACHE_NUGET_PACKAGES: false
  +    ```
  +
  +* Use `cf set-env` to set the `CACHE_NUGET_PACKAGES` environment variable on the command line:
  +
  +    <pre class="terminal">$ cf set-env YOUR-APP CACHE_NUGET_PACKAGES false</pre>
  +
  +See the [Environment Variables](../../devguide/deploy-apps/manifest.html#env-block) section of the <em>Deploying with Application Manifests</em> topic for more information.
  +
  +## <a id='custom-libraries'></a>Add Custom Libraries ##
   
   If your app requires external shared libraries that are not provided by the rootfs or the buildpack, you must place the libraries in an `ld_library_path` directory at the app root.
   
  -<p class="note"><strong>Note</strong>: You must keep these libraries up to date. They do not update automatically.</p>
  +<p class="note"><strong>Note</strong>: You must keep these libraries up-to-date. They do not update automatically.</p>
   
   The .NET Core buildpack automatically adds the directory `<app-root>/ld_library_path` to `LD_LIBRARY_PATH` so that your app can access these libraries at runtime.
  
positive.code: 
  ## <a id='pushing-apps'></a> Push an App ##
  
  Follow the steps below to push your app.
  
  1. Run `cf push APP-NAME` command to push your app, where `APP-NAME` is the name you want to give your app. For example:
  
  
negative.code: <%= vars.product_windows_full %> automatically uses the .NET Core buildpack when one or more of the following conditions are met:
  
  - The pushed app contains one or more `*.csproj` or `*.fsproj` files.
  - The pushed app contains one or more `project.json` files.
  - The app is pushed from the output directory of the `dotnet publish` command.
  
  For information about deploying different types of .NET apps, follow the links in the table below.
  