# What Is the Function of the eng Directory in ASP.NET Core?

> Discover the vital role of the aspnetcore eng directory. It houses build automation, MSBuild properties, and shared assets for CI, versioning, packaging, and project coordination.

- Repository: [.NET Platform/aspnetcore](https://github.com/dotnet/aspnetcore)
- Tags: internals
- Published: 2026-08-01

---

**The `eng` directory functions as the centralized build and release infrastructure for the ASP.NET Core repository, containing automation scripts, MSBuild properties, and shared assets that orchestrate continuous integration, version management, packaging, and cross-project coordination.**

The `eng` folder in the `dotnet/aspnetcore` repository serves as the engine room for the entire development pipeline. This directory houses the configuration files, shared tooling, and scripts that standardize how the codebase is compiled, tested, versioned, and shipped across different platforms. Understanding the function of the eng directory in ASP.NET Core is essential for contributors who need to interact with the repository’s build system or modify its engineering processes.

## Build Automation and Arcade Integration

The `eng/common` subdirectory contains files that are **managed by the Arcade automation system** and are overwritten by scripts during each build cycle. According to [`eng/common/README.md`](https://github.com/dotnet/aspnetcore/blob/main/eng/common/README.md), developers should never modify these files directly in the ASP.NET Core repository; instead, changes must be submitted to the Arcade repository itself. This design ensures that build logic remains consistent across all .NET repositories that share the Arcade infrastructure.

## Centralized Version and Dependency Management

Two critical files within the `eng` directory establish a **single source of truth** for all external dependencies:

- **`eng/Versions.props`** defines every external package version used across the repository, including properties like `AspNetCoreMajorVersion` and `MicrosoftPlaywrightVersion`. Projects import this file to ensure consistent versioning.
- **`eng/Dependencies.props`** lists the specific packages that can be updated via Dependabot and other automated tooling, working in tandem with `Versions.props` to keep dependencies synchronized.

## Build Orchestration Scripts

The `eng` directory contains the primary entry points for building the entire repository:

- **[`eng/build.sh`](https://github.com/dotnet/aspnetcore/blob/main/eng/build.sh)** (and its Windows equivalent) drives the complete repository build, handling restore, compilation, and packaging operations.
- **`eng/scripts/GenerateProjectList.ps1`** regenerates the list of projects used by the linker for trimming and source-build configurations.
- **`eng/scripts/mark-shipped.cmd`** updates public API files after a release, marking APIs as shipped based on the repository’s shipping definitions.

Run a full repository build from the root using:

```bash
./eng/build.sh -all -pack -configuration Release

```

Generate the trimmable project list with:

```powershell
./eng/scripts/GenerateProjectList.ps1

```

Update shipped public APIs using:

```cmd
./eng/scripts/mark-shipped.cmd

```

## Helix Test Execution Infrastructure

The `eng/helix` folder contains configuration for Microsoft’s Helix distributed test execution platform. The file `eng/helix/content/runtests.cmd` configures the **Helix test runner**, which submits test jobs to the Helix infrastructure during CI runs. This setup handles test timeouts, dump collection, and result aggregation across multiple machine configurations.

## Packaging, Signing, and Publishing Configuration

Several props files in the `eng` directory control how artifacts are produced and distributed:

- **`eng/Tools.props`** provides common MSBuild settings for tooling projects.
- **`eng/ShippingAssemblies.props`** controls which assemblies are included in the ASP.NET Core shared framework.
- **`eng/Signing.props`** defines the signing keys and certificates used for strong-naming assemblies.

## Source-Build Integration

Files such as `eng/SharedFramework.*.props` and `eng/TrimmableProjects.props` feed information into the **source-build pipeline**. These configurations allow the runtime to produce trimmed builds and shared framework artifacts that comply with the .NET source-build requirements, enabling distributions like Red Hat Enterprise Linux and Fedora to build ASP.NET Core from source.

## Summary

- The `eng` directory provides the **centralized build infrastructure** for the ASP.NET Core repository, driven by the Arcade automation system.
- **`eng/Versions.props`** and **`eng/Dependencies.props`** establish a single source of truth for package versions and automated updates.
- Scripts like **[`eng/build.sh`](https://github.com/dotnet/aspnetcore/blob/main/eng/build.sh)**, **`eng/scripts/GenerateProjectList.ps1`**, and **`eng/scripts/mark-shipped.cmd`** orchestrate builds, project list generation, and API shipping.
- The **`eng/helix`** folder configures distributed test execution through the Helix platform.
- Configuration files for **signing**, **packaging**, and **source-build** ensure consistent artifact production across all platforms.

## Frequently Asked Questions

### What is the primary purpose of the eng directory in ASP.NET Core?

The `eng` directory serves as the repository’s engineering infrastructure, containing all scripts, MSBuild properties, and shared assets required to build, test, version, and package the entire ASP.NET Core framework. It functions as the central nervous system for the development pipeline, ensuring consistency across local builds and CI environments.

### How does the eng directory manage package versions across the repository?

Version management is centralized through `eng/Versions.props`, which defines properties for every external dependency version (such as `MicrosoftPlaywrightVersion`). This file is imported by individual project files, ensuring that updating a version in one location propagates correctly throughout the entire codebase. The companion file `eng/Dependencies.props` identifies which packages can be updated via automated tooling like Dependabot.

### Why should developers avoid editing files in the eng/common directory?

Files within `eng/common` are automatically generated and overwritten by the Arcade automation system during each build. According to [`eng/common/README.md`](https://github.com/dotnet/aspnetcore/blob/main/eng/common/README.md), these files must not be modified directly in the ASP.NET Core repository; instead, changes should be submitted to the central Arcade repository. Direct modifications would be lost during the next Arcade update, potentially breaking the build pipeline.

### How does the eng directory support ASP.NET Core source builds?

The `eng` directory contains configuration files such as `SharedFramework.*.props` and `TrimmableProjects.props` that integrate with the .NET source-build pipeline. These files specify which projects should be included in trimmed builds and how the shared framework should be constructed, enabling Linux distributions and other parties to build ASP.NET Core entirely from source without relying on pre-built binaries.