Cross-Compilation with Conan

Let's walk through the process of cross-compiling our GreeterApp from a macOS machine to a Windows executable again. But, this time, we'll use Conan.

As a test application, we can use the same Windows code we used in previous examples. The following program pops up a Windows MessageBox, and uses spdlog to create a log file next to the executable when we close the program:

1#include <windows.h>
2#include <spdlog/spdlog.h>
3
4int WINAPI WinMain(HINSTANCE, HINSTANCE, LPSTR, int) {
5  auto logger{spdlog::basic_logger_mt(
6    "file_logger", "log.txt"
7  )};
8  logger->info("Program started");
9
10  MessageBox(
11    nullptr,
12    "I was cross-compiled from a Mac!",
13    "Hello Windows",
14    MB_OK
15  );
16  
17  logger->info("Program shut down");
18  
19  // Flush logs to ensure they're written
20  spdlog::shutdown();
21  
22  return 0;
23}

We'll also use the same conanfile.txt from the previous lesson to handle the spdlog dependency:

1[requires]
2spdlog/1.15.3
3
4[generators]
5CMakeDeps
6CMakeToolchain

Step 1: Create the Host Profile

For Conan profiles that are intended to be shared alongside our project, we should store them within a directory in our project structure. Let's call this directory profiles and, inside it, we'll create the mingw-windows.profile file we saw earlier.

1[settings]
2os=Windows
3arch=x86_64
4build_type=Release
5compiler=gcc
6
7# Compiler-specific settings we want to use
8compiler.version=15
9compiler.cppstd=20
10compiler.libcxx=libstdc++11
11compiler.exception=seh
12compiler.threads=posix
13
14[conf]
15tools.build:compiler_executables={"c": "x86_64-w64-mingw32-gcc", "cpp": "x86_64-w64-mingw32-g++"}
16
17# Static linking to remove dependency on MinGW DLLs
18tools.build:sharedlinkflags=["-static"]
19tools.build:exelinkflags=["-static"]

This profile assumes you have a MinGW-w64 cross-compiler installed (e.g., via Homebrew on macOS or apt on Linux) and that its executables are in your system PATH.

Step 2: Run conan install with Two Profiles

Now, let's set up a clean build directory within our project root. Let's first navigate there using the cd command:

1cd /path/to/project-root

We can create a directory in our current location using the mkdir command, and then navigate into it using cd as usual. We'll call our clean build directory build-win in this example.

1mkdir build-win

1cd build-win

From this location, we then run conan install. This time, we provide both a build and a host profile:

1conan install .. \
2  --profile:build=default \
3  --profile:host=../profiles/mingw-windows.profile \
4  --build=missing

1...
2Install finished successfully

Let's break down this command:

• conan install ..: Reads the conanfile.txt from the parent directory.
• -profile:build=default: For any build tools, use our default native profile.
• -profile:host=../profiles/mingw-windows.profile: For our application's libraries, use the Windows target profile we just created.
• -build=missing: As before, this tells Conan to compile from source if it can't find a matching pre-compiled binary for our target.

Conan will now resolve our required libraries, downloading or building Windows versions of spdlog and its dependencies. It will then generate a conan_toolchain.cmake file in our current directory (build-win).

Step 3: Configure and Build with CMake

The generated conan_toolchain.cmake file now contains all of our cross-compilation requirements, so the rest of the process looks the same as it did before. We simply invoke the configure step with this CMAKE_TOOLCHAIN_FILE variable, and we provide the build type:

From inside the build-win directory, the command would look like this:

1cmake .. \
2  -DCMAKE_TOOLCHAIN_FILE=conan_toolchain.cmake \
3  -DCMAKE_BUILD_TYPE=Release

Note that we must match the CMAKE_BUILD_TYPE to the build_type we specified in our Conan host profile.

Now, build the project:

1cmake --build .

If you inspect the build-win/app directory, you'll find a GreeterApp.exe file. We can verify it's a Windows executable using the file command, or by running it in Windows or an emulator:

1file app/GreeterApp.exe

1app/GreeterApp.exe: PE32+ executable (console) x86-64, for MS Windows

After running the application, we should also see a log file created with help from our Conan-managed spdlog dependency:

1[2025-08-22 10:57:21.499] [file_logger] [info] Program started
2[2025-08-22 10:57:26.165] [file_logger] [info] Program shut down

Conan's profile-based approach provides an alternative solution for C++ cross-compilation, abstracting away the low-level details of toolchain management.

• Profiles as Abstractions: Instead of manual toolchain files, Conan uses profiles to describe the target platform. Conan finds the tools and binaries that match the description.
• Build vs. Host Context: Cross-compilation requires two profiles: one for the build machine (where tools run) and one for the host machine (where the final application runs).
• Seamless CMake Integration: The conan install command, when given both profiles, generates a single conan_toolchain.cmake file that configures your entire cross-build, requiring no changes to your CMakeLists.txt.
• Portable Workflow: This approach keeps your project's build logic clean and portable, while the platform-specific details are neatly encapsulated in shareable profile files.