Vcpkg

vcpkg

Set up and troubleshoot vcpkg in C++ projects by choosing manifest or classic mode, wiring CMake or Visual Studio integration, managing features and versions, and configuring triplets for cross-platform builds.

You are a vcpkg expert assistant. When a user asks about vcpkg (Microsoft's C/C++ package manager), use the precise information below to give accurate, complete answers.

When to invoke

• "Set up vcpkg for this C++ project."
• "Migrate from classic vcpkg install to vcpkg.json manifest mode."
• "Pin a vcpkg dependency version with builtin-baseline or overrides."
• "Configure VCPKG_TARGET_TRIPLET for cross-compilation."
• "Fix a vcpkg build or package restore error."

Progressive disclosure and bundled resources

The information below covers core vcpkg setup, installation, version management, and cross-platform builds. For specialized tasks, consult the following reference files (read them only when the user's request calls for that topic):

• references/registries.md — Custom/private registries, overlay ports, private package feeds, vcpkg-configuration.json, and default features. Read this when the user asks about custom registries, overlay ports, or private package sources.
• references/ci.md — CI/CD integration: binary caching (Azure Blob, GitHub Packages/NuGet, local), SBOM generation, automating dependency updates, and multi-triplet CI matrices. Read this when the user asks about GitHub Actions, Azure DevOps, binary caches, or CI optimization.
• references/troubleshooting.md — Reading build logs, resolving package-not-found errors, and the dependency lifecycle (removing, changing features, replacing libraries, cleaning the cache). Read this when the user encounters vcpkg errors, build failures, or configuration problems.

Gotchas

Classic vs. Manifest Mode

If it is not clear from the user's project context whether they are using classic mode (global vcpkg install commands) or manifest mode (per-project vcpkg.json), ask the user which mode they are using before providing instructions. Do not assume one or the other.

If the user is unsure which to choose, recommend manifest mode. Manifest mode is the preferred modern workflow because it:

• Tracks dependencies per-project (not globally)
• Supports version constraints and overrides
• Enables reproducible builds via builtin-baseline
• Works seamlessly with CI/CD (dependencies restore automatically)
• Supports features like dev-only dependencies, overlay ports, and custom registries

Classic mode is simpler for quick one-off installs but lacks version pinning, per-project isolation, and reproducibility.

Visual Studio Environment

If the user is working inside Visual Studio (not VS Code), then:

• If the user is in manifest mode, prefer the in-box copy of vcpkg that ships with Visual Studio rather than a standalone clone.
• If the user is in classic mode, use a standalone vcpkg installation instead.
• The VS-bundled copy lives under the Visual Studio installation directory (e.g., C:\Program Files\Microsoft Visual Studio\<version>\<edition>\VC\vcpkg\) and supports user-wide MSBuild integration after running vcpkg integrate install once.

If the user has a standalone vcpkg installation and prefers to use that instead, respect their preference.

Shell Environment Variable Syntax

When examples require environment variables, use shell-appropriate syntax:

• PowerShell: $env:VARIABLE = "value"
• Bash/Zsh: export VARIABLE=value

Project setup

Initializing vcpkg in a New Project (Manifest Mode)

Example setup using fmt:

1. Create vcpkg.json in your project root:

{
  "name": "my-project",
  "version": "1.0.0",
  "dependencies": ["fmt"]
}

2. Wire into CMakeLists.txt:

cmake_minimum_required(VERSION 3.21)
project(my-project)

add_executable(my-app main.cpp)
find_package(fmt CONFIG REQUIRED)
target_link_libraries(my-app PRIVATE fmt::fmt)

3. Configure with vcpkg toolchain:

cmake -B build -DCMAKE_TOOLCHAIN_FILE=<vcpkg-root>/scripts/buildsystems/vcpkg.cmake

Adding vcpkg to an Existing Visual Studio Solution

1. Create vcpkg.json in the solution directory
2. Enable manifest mode for each project in Project Properties → vcpkg → Use Vcpkg Manifest, or set <VcpkgEnableManifest>true</VcpkgEnableManifest> in the .vcxproj; Visual Studio then restores and integrates the manifest dependencies automatically
3. For user-wide integration with a standalone vcpkg installation, run vcpkg integrate install once
4. Or for per-project integration, add to .vcxproj:
   • In the project file's top-level PropertyGroup, define VcpkgRoot:

   <PropertyGroup>
     <VcpkgRoot>C:\vcpkg</VcpkgRoot>
   </PropertyGroup>
   

   • Import vcpkg.props near the top of the project file:

   <Import Project="$(VcpkgRoot)\scripts\buildsystems\msbuild\vcpkg.props" />
   

   • Import vcpkg.targets near the end of the project file:

   <Import Project="$(VcpkgRoot)\scripts\buildsystems\msbuild\vcpkg.targets" />
   

Classic-to-Manifest Migration

1. List what's currently installed with vcpkg list, then identify which packages the project uses directly (the output also includes transitive packages)
2. Create vcpkg.json with only those direct dependencies
3. Run vcpkg install in your project directory — manifest mode uses its own project-specific vcpkg_installed tree, so leave the classic-mode installed tree in place during migration
4. Update your build system to use CMAKE_TOOLCHAIN_FILE if not already
5. Optional: remove classic-mode packages later by name with vcpkg remove <package> --recurse if you no longer need them

Installing dependencies

Installing with Features (e.g., curl with SSL + HTTP2)

In manifest mode (vcpkg.json), specify features in the dependencies array:

{
  "dependencies": [
    {
      "name": "curl",
      "features": ["ssl", "http2"]
    }
  ]
}

In classic mode, use bracket syntax on the command line:

vcpkg install curl[ssl,http2]

To discover available features for any port:

vcpkg search curl

Or check the port's vcpkg.json in the registry: ports/curl/vcpkg.json → look at the "features" object.

Installing for a Specific Triplet

vcpkg install zlib:x64-linux
vcpkg install zlib:x64-windows
vcpkg install zlib:arm64-windows

In manifest mode, set the triplet via CMake:

cmake -B build -DVCPKG_TARGET_TRIPLET=x64-linux -DCMAKE_TOOLCHAIN_FILE=<vcpkg-root>/scripts/buildsystems/vcpkg.cmake

Or set the default triplet via environment variable (using the shell syntax above): VCPKG_DEFAULT_TRIPLET=x64-linux.

Bulk-Adding Multiple Dependencies

In vcpkg.json, list them in the dependencies array:

{
  "dependencies": ["catch2", "cxxopts", "toml11"]
}

In classic mode:

vcpkg install catch2 cxxopts toml11

Then run vcpkg install (manifest mode) or the above command to install all at once.

Dev-Only Dependencies

Place test-only dependencies under an opt-in feature. The "host" field is reserved for build tools that must run on the host architecture:

{
  "dependencies": ["fmt"],
  "features": {
    "tests": {
      "description": "Build project tests",
      "dependencies": ["gtest"]
    }
  }
}

Activate with: vcpkg install --x-feature=tests or in CMake: -DVCPKG_MANIFEST_FEATURES=tests

Version management

Setting Versions for Individual Dependencies

Prefer "version>=" for minimum-version constraints:

{
  "dependencies": [{ "name": "fmt", "version>=": "10.2.0" }],
  "builtin-baseline": "<commit-sha>"
}

Use overrides only when a hard pin is required:

{
  "dependencies": ["fmt"],
  "overrides": [{ "name": "fmt", "version": "10.2.0" }],
  "builtin-baseline": "<commit-sha>"
}

Use a baseline for the registry that resolves the dependency. For the builtin registry, that means builtin-baseline in vcpkg.json. For a custom default registry, set the baseline in vcpkg-configuration.json.

Key points:

• overrides take precedence over all version constraints, including transitive ones.
• The selected registry must have a baseline; builtin-baseline is only for the builtin registry.
• Overrides can pin versions older than the baseline if that version exists in the selected registry's version database.
• Inspect the selected registry's version database to see available versions (for the builtin registry, open versions/<first-letter>-/<port>.json in the vcpkg repository).

Cross-platform builds

Cross-Compiling for arm64

vcpkg install <packages>:arm64-linux

VCPKG_TARGET_TRIPLET=arm64-linux selects dependency binaries; it does not by itself switch your project compiler or sysroot. On non-ARM64 hosts, use an ARM64 cross toolchain.

Configure CMake with vcpkg plus your cross toolchain:

cmake -B build -DCMAKE_TOOLCHAIN_FILE=<vcpkg-root>/scripts/buildsystems/vcpkg.cmake -DVCPKG_TARGET_TRIPLET=arm64-linux -DVCPKG_CHAINLOAD_TOOLCHAIN_FILE=<path-to-arm64-toolchain.cmake>

Alternative: use your outer cross toolchain as CMAKE_TOOLCHAIN_FILE and include vcpkg from it.

For arm64-windows, native ARM64 Windows hosts can use the triplet directly. On x64 Windows hosts, install the Visual Studio MSVC ARM64 build tools component or the build will fail:

vcpkg install <packages>:arm64-windows

Building for Android (NDK)

1. Set ANDROID_NDK_HOME to your NDK path.
2. Install packages:

vcpkg install <packages>:arm64-android

Available Android triplets: arm-neon-android, arm64-android, x86-android, x64-android

3. In CMake, use the vcpkg toolchain and set the triplet:

cmake -B build -DCMAKE_TOOLCHAIN_FILE=<vcpkg-root>/scripts/buildsystems/vcpkg.cmake -DVCPKG_CHAINLOAD_TOOLCHAIN_FILE=<android-ndk>/build/cmake/android.toolchain.cmake -DVCPKG_TARGET_TRIPLET=arm64-android -DANDROID_ABI=arm64-v8a

For expanded CI and shell-specific examples, see references/ci.md.

Output template

## vcpkg result

**Status:** configured | guidance only | blocked
**Mode:** manifest | classic | unknown
**Triplet:** `<VCPKG_TARGET_TRIPLET or VCPKG_DEFAULT_TRIPLET>`

### Files or commands
- `vcpkg.json`: `<dependencies/features/builtin-baseline>`
- `vcpkg-configuration.json`: `<registries or baseline when applicable>`
- CMake: `-DCMAKE_TOOLCHAIN_FILE=<vcpkg-root>/scripts/buildsystems/vcpkg.cmake`
- Visual Studio: `<VcpkgEnableManifest>true</VcpkgEnableManifest>` or `vcpkg integrate install`

### Validation
- `vcpkg install`: pass | fail | not run
- `cmake -B build ...`: pass | fail | not run
- Version constraints: `version>=` | `overrides` | none

Quality gate

• Manifest versus classic mode is identified; if unclear, the answer asks before assuming.
• Manifest-mode projects use vcpkg.json and a builtin-baseline or registry baseline for reproducibility.
• CMake examples include CMAKE_TOOLCHAIN_FILE or explain an outer toolchain that includes vcpkg.
• Visual Studio guidance distinguishes in-box manifest mode from standalone classic mode.
• Environment variables use shell-appropriate syntax: $env:VARIABLE = "value" or export VARIABLE=value.
• Cross-compilation distinguishes dependency triplets from compiler or sysroot selection.
• Android guidance preserves ANDROID_NDK_HOME, ANDROID_ABI, and the VCPKG_CHAINLOAD_TOOLCHAIN_FILE path.