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

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, 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 (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:

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

Generate the trimmable project list with:

./eng/scripts/GenerateProjectList.ps1

Update shipped public APIs using:

./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, 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, 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.

{
  "mcpServers": {
    "instagit": {
      "command": "npx",
      "args": ["-y", "instagit@latest"]
    }
  }
}