Building CNA

CNA snapshot c1c316b9  ·  CMake ≥ 3.20  ·  C++23  ·  C17 for the optional C API

Step 1 - Install the toolchain and system packages

CNA needs a C++23 compiler and CMake 3.20 or newer. On Linux a windowed build also wants the X11, GL, Vulkan, ALSA and D-Bus development packages so the vendored SDL3 (and the native backends) get real drivers. FFmpeg is now optional.

# Debian / Ubuntu (24.04 is what CI uses, with g++-14)
sudo apt install build-essential cmake git pkg-config ninja-build g++-14 \
     libx11-dev libxext-dev libxrandr-dev libxi-dev libxcursor-dev libxfixes-dev \
     libxss-dev libxtst-dev libxkbcommon-dev \
     libgl1-mesa-dev libegl1-mesa-dev libgles2-mesa-dev libvulkan-dev \
     libasound2-dev libpulse-dev libudev-dev libdbus-1-dev libwayland-dev wayland-protocols

# Optional: FFmpeg, for Video / VideoPlayer on Linux and macOS
sudo apt install libavcodec-dev libavformat-dev libavutil-dev libswresample-dev

ninja-build is optional (the default generator is Makefiles). That package list follows what CNA's own Linux CI installs (minus test tooling such as ccache, xvfb and doxygen, with FFmpeg kept optional); libpulse-dev is included because every Linux CI job that builds the native vendored SDL installs it. The prebuilt SDL is not rebuilt when a package appears later, so install everything before the first configure. The minimal sufficient set was not measured. How to build SDL3 with both of its Linux video drivers, and which private servers (Xvfb, headless Weston) its window suites run on, is on Windows, X11 and Wayland.

Step 2 - Clone CNA and its sibling repositories

CNA does not vendor everything. Some dependencies must exist as sibling directories next to the CNA checkout, because CMake pulls them in with add_subdirectory(../<repo>). They are separate git checkouts, not submodules, and CMake will not fetch them for you.

mkdir cna-workspace && cd cna-workspace

# CNA and sharp-runtime: the apple/m4-stabilization branch of each (see the warning above)
git clone -b apple/m4-stabilization https://github.com/libcna/cna.git
git -C cna checkout c1c316b9c7a846ce8002809c151fcd1af14942c9
git clone -b apple/m4-stabilization https://github.com/libcna/sharp-runtime.git

# Needed by the default Linux renderer (OPENGLES3) and the other GL profiles:
# meta-gl has a branch of the same name; easy-gl uses its default branch (develop)
git clone https://github.com/libcna/easy-gl.git
git clone -b apple/m4-stabilization https://github.com/libcna/meta-gl.git

Alternatively, stay on any clone of CNA, fetch that branch and check out the exact snapshot: git checkout c1c316b9c7a846ce8002809c151fcd1af14942c9. CNA's CI clones the siblings shallowly (--depth 1) and picks the first branch that exists among the pushed branch, the target branch, next and develop — the same rule the commands above follow. The libcna/* and openeggbert/* organisation names resolve to identical repositories for these four; CNA’s sibling-cloning script uses libcna/, while some of its messages and one workflow still name openeggbert/.

Nothing else is a sibling. Other third-party code is either a git submodule (Step 3), vendored in-tree (enet, stb, dr_libs, cgltf), or fetched at configure time when the matching renderer or option is selected: FNA3D (for FNA3D and every compiled-effects option), wgpu-native (for WEBGPU) and SDL_shadercross (for SDL_GPU when CNA_SDL_GPU_SHADERCROSS is on).

Step 3 - Initialise the submodules

cd cna
git submodule update --init

This populates the five gitlinks: third_party/SDL, third_party/SDL_image and third_party/SDL_mixer (the SDL3 family, built from source by the CMake configure step, so no system SDL packages are required), third_party/draco (mesh decoding; needed unless you configure -DCNA_ENABLE_DRACO=OFF) and vendor/googletest (needed while CNA_BUILD_TESTS=ON). With -DCNA_ENABLE_SDL=OFF the three SDL submodules are never touched.

Step 4 - Configure and build

cmake -S . -B build
cmake --build build

That is the whole default build, and it is a big one: with tests and examples on it builds hundreds of executables. Which renderer it selects depends on the target: OPENGLES3 on Linux, WEBGL2 under Emscripten, and SDL_RENDERER everywhere else. For a first run, build just what you need:

cmake -S . -B build -DCNA_BUILD_TESTS=OFF
cmake --build build --target cna_demo_2d --parallel
cd build && ./cna_demo_2d          # run from the build directory: it finds the copied Content/

What you can build

The C++ framework has no install() rules, so you consume the source tree, not an installed package; that is why the library target is a CMake INTERFACE umbrella.

Build layout, speed and diagnostics

• libcna.so by default on native Linux. With a native ELF GNU or Clang toolchain and CMake 3.27 or newer, CNA_SHARED_LIBRARY defaults to ON: the engine is linked once into libcna.so and every executable links that, instead of carrying its own static copy. CNA's own measurement of the old layout was about 104 MB per Debug executable across 798 test and example executables (about 83 GB). Windows, macOS, Android and Emscripten keep the static link; ON there is a configure error. Set -DCNA_SHARED_LIBRARY=OFF for static linking.
• ccache is used automatically when installed (CNA_USE_CCACHE=ON); CNA_CCACHE_BASEDIR (default: $CCACHE_BASEDIR or the directory above the source) lets several build trees share cache hits.
• Sanitizers: -DCNA_SANITIZE=address,undefined (comma list; ASan+TSan and TSan+MSan are rejected; not available on MSVC or Emscripten), with CNA_SANITIZE_OPTIMIZATION (DEFAULT, O0–O3). They cover CNA, sharp-runtime and the tests, not the vendored SDL or ENet. Sanitizer binaries are large; build only the variant you need.
• Other build-quality options: CNA_DEBUG_INFO (FULL, LINE_TABLES, SPLIT), CNA_LINKER (AUTO, DEFAULT, LLD, MOLD; native ELF only), CNA_ENABLE_IPO, CNA_ENABLE_UNITY_BUILD and CNA_ENABLE_PCH (all off by default).
• Diagnostics and inspector: -DCNA_DIAGNOSTICS=STATS or FULL compiles in the profiler/diagnostics level (OFF by default); -DCNA_BUILD_INSPECTOR=ON builds the inspector agent, bridge and local browser UI (a configure error on Emscripten, Android and iOS). See Diagnostics and Inspector.
• Configure-time gates. The configure step also runs a platform "ratchet" (SDL must stay inside the platform module), a hot-path lint (both need Python 3 and are skipped without it), a renderer-descriptor gate and a source-partition validator. A failure names the rule.
• CNA_MAX_VENDORED_BUILD_JOBS (default 2) limits the parallelism of the configure-time SDL sub-builds.

Step 5 - Choose a renderer

A compact build compiles one of the 14 public renderer identities (12 implementation families; the three GL identities share one implementation, EasyGL). The long and option forms below are equivalent and must not be mixed:

# Long form: name the renderer
cmake -S . -B build -DCNA_GRAPHICS_RENDERER=VULKAN

# Option form: exactly one CNA_RENDERER_<NAME> may be ON
cmake -S . -B build -DCNA_RENDERER_VULKAN=ON

A few representative choices:

# Linux default - the OpenGL ES 3.0 profile of EasyGL (needs ../easy-gl and ../meta-gl)
cmake -S . -B build -DCNA_GRAPHICS_RENDERER=OPENGLES3

# 2D only, nothing beyond the vendored SDL3 required
cmake -S . -B build -DCNA_GRAPHICS_RENDERER=SDL_RENDERER

# Vulkan, driven directly
cmake -S . -B build -DCNA_GRAPHICS_RENDERER=VULKAN


# SDL3's own GPU API
cmake -S . -B build -DCNA_GRAPHICS_RENDERER=SDL_GPU

# CPU rasterizer - no GPU, no window; read pixels back with GetBackBufferData()
cmake -S . -B build -DCNA_GRAPHICS_RENDERER=SOFTWARE

# No pixel output at all - game logic only
cmake -S . -B build -DCNA_GRAPHICS_RENDERER=HEADLESS

Opt into several renderers

CNA_GRAPHICS_RENDERERS links a compatible semicolon-separated set. The singular option remains the default and must occur in the set:

cmake -S . -B build-multi -G Ninja \
  -DCNA_GRAPHICS_RENDERER=HEADLESS \
  -DCNA_GRAPHICS_RENDERERS="HEADLESS;SOFTWARE;STUB"

An empty plural option is ordinary single-renderer mode. Multi-renderer builds increase dependency and binary size. One combination rule is enforced at configure time: identities gated to different operating systems cannot be mixed. In a multi-renderer binary the CNA_GRAPHICS_RENDERER environment variable chooses at run time. See Runtime Renderer Selection.

Choose platform and audio independently

# Defaults shown explicitly
cmake -S . -B build \
  -DCNA_PLATFORM=SDL3 \
  -DCNA_AUDIO_PLATFORM=SDL3 \
  -DCNA_GRAPHICS_RENDERER=OPENGLES3

# Deterministic display-free build
cmake -S . -B build-headless \
  -DCNA_PLATFORM=HEADLESS \
  -DCNA_AUDIO_PLATFORM=NULL \
  -DCNA_GRAPHICS_RENDERER=HEADLESS

# No SDL anywhere (windowless), ALSA audio through CNA's own mixer
cmake -S . -B build-sdl-free -G Ninja \
  -DCNA_ENABLE_SDL=OFF \
  -DCNA_PLATFORM=HEADLESS \
  -DCNA_AUDIO_PLATFORM=ALSA \
  -DCNA_GRAPHICS_RENDERER=HEADLESS

CNA_PLATFORM accepts three values: SDL3 (default, and the one windowing implementation — Windows, X11, Wayland, macOS, iOS, Android and the web through SDL’s video drivers), HEADLESS and TERMINAL (POSIX only; CPU renderers only). CNA_AUDIO_PLATFORM accepts three: SDL3 (default), NULL and ALSA (Linux only). Any other platform value, and the reserved audio names OPENAL and WASAPI, fail rather than falling back. Only the SDL3 and ALSA audio values define SOUND_ENABLED and provide a mixer (SDL3_mixer, or CNA's own for ALSA); Null selects low-level device code but is not a feature-equivalent game-audio backend.

The axes are independent; -DCNA_ENABLE_SDL=OFF refuses any selection that genuinely needs SDL (the SDL3 platform and audio values, and the SDL_RENDERER, SDL_GPU and FNA3D renderers), so an SDL-free build is windowless, and TERMINAL accepts only the CPU renderers. See Platforms.

Several renderers are hard-gated and refuse to configure off their platform: 2 are Windows-only (DIRECTX9 and DIRECTX11), METAL is Apple-only (macOS and iOS), WEBGL2 is Emscripten-only, and OPENGLES3 / OPENGL33 cannot be selected under Emscripten. On iOS only SDL_RENDERER and METAL are allowed. Graphics Renderers lists all 14 identities with their scope, platform gate and dependency.

Compiled-effects options

Compiled Effect Framework (.fxb) bytecode support is opt-in per renderer family, through eight options that all default to OFF: CNA_EASYGL_COMPILED_EFFECTS, CNA_VULKAN_COMPILED_EFFECTS, CNA_WEBGPU_COMPILED_EFFECTS, CNA_SOFTWARE_COMPILED_EFFECTS, CNA_DIRECTX9_COMPILED_EFFECTS, CNA_DIRECTX11_COMPILED_EFFECTS, CNA_METAL_COMPILED_EFFECTS and CNA_SDL_GPU_COMPILED_EFFECTS. FNA3D always supports compiled effects and has no option; CNA_EASYGL_COMPILED_EFFECTS enables all three GL identities at once. With the options on, 11 of the 14 identities (in 9 families) support them. Any of them (and FNA3D) fetches FNA3D with its MojoShader patch series at configure time. A default configure reports compiled effects as supported on FNA3D only (unsupported on 13 of the 14 identities). See Shader Effects and Effects System.

CMake presets

The repository ships 17 visible configure presets (plus a hidden base-ninja parent: Ninja, ccache, compile_commands.json) and 17 build presets; no test, workflow or package presets. Each preset chooses its own build directory, ${sourceDir}/cmake-build-<preset>, so drive the build with cmake --build --preset <name> rather than guessing the path. Several are maintainer tooling; the ones most readers want are tests, web, multi-renderer, macos, ios, ios-simulator, cnaext and unit.

cmake --preset tests
cmake --build --preset tests

The dev, unit and release-* presets choose the STUB renderer and turn off video, Draco and networking, which makes them the lightest way to compile the framework itself. They still use the default SDL3 platform, so the SDL submodules and prebuilt SDL are needed.

Cross-compiling

Windows, from Linux

sudo apt install g++-mingw-w64-x86-64

cmake -S . -B build-win \
      -DCMAKE_TOOLCHAIN_FILE=cmake/toolchains/mingw-w64.cmake \
      -DCNA_GRAPHICS_RENDERER=DIRECTX9
cmake --build build-win

# Direct3D 11 in an SDL3 window (the default platform)
cmake -S . -B build-win11 -G Ninja \
      -DCMAKE_TOOLCHAIN_FILE=cmake/toolchains/mingw-w64.cmake \
      -DCNA_GRAPHICS_RENDERER=DIRECTX11

The 2 Windows-gated renderers require CMAKE_SYSTEM_NAME=Windows, which the MinGW-w64 toolchain file supplies (x86_64, falling back to i686; there is one toolchain file, cmake/toolchains/mingw-w64.cmake). The window comes from SDL3’s windows driver, which hands the renderer its HWND. The repository includes manual Wine + DXVK execution paths. In CI, Windows builds (Direct3D 11, the SDL3 platform suite, the content pipeline) are manual-dispatch MSVC workflows. Native MSVC builds use the same options.

Web (Emscripten)

# 1. Install and activate the Emscripten SDK (CI pins emsdk 6.0.3)
git clone https://github.com/emscripten-core/emsdk.git
cd emsdk
./emsdk install latest
./emsdk activate latest
source ./emsdk_env.sh
cd ../cna

# 2. Configure and build through the bundled preset (WEBGL2)
emcmake cmake --preset web
cmake --build --preset web

# Or build WEBGL2 and WEBGPU into one bundle and choose at run time
emcmake cmake -S . -B build-web-multi \
      -DCNA_GRAPHICS_RENDERER=WEBGL2 -DCNA_GRAPHICS_RENDERERS="WEBGL2;WEBGPU"
cmake --build build-web-multi

Only emsdk 6.0.3 is used by CI's workflows; older versions are unproven. Output is .html, .js and .wasm; serve it from a local web server, because browsers block direct file:// access. Draco is off by default under Emscripten, and exceptions are JS-lowered with Asyncify for application executables. Three web caveats matter before you ship anything: saves persist only through the browser’s IndexedDB mounts (a threaded build needs -DCNA_EMSCRIPTEN_USE_WASMFS=OFF for that), the video types throw at run time (no FFmpeg on the web), and an external final executable that uses blocking Game::Run() must link CNA::EmscriptenAsyncify (your Game no longer has to be heap-allocated). Platforms explains each.

Android

cmake -S . -B build-android \
      -DCMAKE_TOOLCHAIN_FILE=$ANDROID_NDK/build/cmake/android.toolchain.cmake \
      -DANDROID_ABI=arm64-v8a \
      -DANDROID_PLATFORM=android-24 \
      -DCNA_BUILD_TESTS=OFF \
      -DCNA_BUILD_EXAMPLES=OFF \
      -DCNA_GRAPHICS_RENDERER=SDL_RENDERER
cmake --build build-android

The Android code paths and NDK sensor implementations are real, but there is no CMake preset, no workflow and no CMake API-level check for Android. The only Android build project in the repository is the packaged Devices demo (Gradle, minSdk 24, NDK 30.0.14904198, arm64-v8a), not a reusable general-game template. CNA's own Android status note, last edited before alpha.1, records an NDK cross-build failing in two sibling sharp-runtime files; we did not re-run it against the current sibling. Treat this command as the framework cross-build shape and validate the build and final APK packaging yourself.

macOS and iOS

# macOS (Apple floor 13.3)
cmake --preset macos
cmake --build cmake-build-macos

# iOS device / simulator (Apple floor 16.3; SDL_RENDERER only)
cmake --preset ios
cmake --preset ios-simulator

iOS is experimental: the Apple workflow is configured to final-link a device smoke app and to install and launch a simulator smoke app for one frame (CNA_BUILD_APPLE_SMOKE_APP, on by default for iOS). Other renderers need -DCNA_APPLE_ALLOW_UNVALIDATED_RENDERER=ON, which is an experiment switch, not a support claim.

CMake options reference

Running the tests

cmake -S . -B build -DCNA_BUILD_TESTS=ON
cmake --build build --target CnaTests
./build/CnaTests                         # from the repository root: run the binary directly
ctest --test-dir build -N                # inspect registrations; do not run unfiltered after building only CnaTests

This snapshot contains 813 C++ test source files (781 of which contain a counted macro) and 11,380 statically declared GoogleTest-family definitions, counted by the same method as alpha.1's 568 files and 8,263 definitions. There are also 781 standalone examples/**/*_test.cpp pixel programs that are not in those figures, and no CTest total is derivable from the sources. Those are source inventory figures, not a promise that one executable instantiates or runs that many cases: conditional compilation, parameterized tests, renderer families and build options change both GoogleTest and CTest inventories. Use ctest -N in the configured build to see that build's registrations, then run the labels relevant to its selected renderer and platform.

CI's workflows cover focused subsets across Linux, macOS and a headless browser (some of those lanes pin an older sharp-runtime; see Platforms). The general job configures OPENGLES3, runs a full default build and an unfiltered ctest under Xvfb, and tolerates a single known failure (its ctest step is continue-on-error, then a classification step fails the job on anything else); the alpha.1 defect of configuring a removed renderer identity is fixed. The GPU pixel/oracle matrix is not continuously gated. See Platforms for exactly which workflows fire and what they cover.

Running the demos

# 2D demo (run from the build directory so it finds Content/)
cmake --build build --target cna_demo_2d
(cd build && ./cna_demo_2d)

# House 3D demo (created only when the default renderer is OPENGLES3/OPENGL33/WEBGL2, VULKAN, WEBGPU or FNA3D)
cmake --build build --target cna_house3d_demo
(cd build && ./cna_house3d_demo)

# A short non-interactive run, useful over SSH or in CI
(cd build && ./cna_demo_2d --smoke 6)

Using CNA from your own project

C API prerequisites

• -DCNA_BUILD_C_API=ON requires -DCNA_ENABLE_NET=ON (the default). Configuring with networking off fails immediately with a named error, instead of failing later on a missing include as in alpha.1.
• A C17 compiler; CNA turns on CMAKE_C_EXTENSIONS for the vendored C sources it compiles, while its own C API sources stay strict C17. The static archive (CNA_C_API_BUILD_STATIC) is Linux-only and needs Python 3. The build enables -fPIC for everything the shared library absorbs.
• The C ABI version is 0.46.0 (experimental; alpha.1 was 0.7.0), with a release gate that currently reports “not ready” (631 planned public C++ declarations still have no C mapping). Language bindings pin an exact ABI version, so a binding built for one ABI does not work against another; CNA.NET admits exactly 0.46.0 (admitted after a compatibility review recorded by CNA’s Apple campaign).
• No CI workflow builds the C API library (its workflows check headers, coverage and the release gate). The alpha.1 compile blocker in the renderer map is gone in the source, but we did not build the library, so treat it as unverified. See Experimental C API.

Troubleshooting

sharp-runtime not found

CNA requires sharp-runtime as a sibling directory:

cna-workspace/
├── cna/
└── sharp-runtime/

Clone it next to CNA (git clone -b apple/m4-stabilization) and re-run the configure step, or point -DCNA_SHARP_RUNTIME_ROOT= at your checkout. If configure finds the directory but fails while resolving Sharp Runtime components (Resources, Xml.Serialization), the checkout is on the wrong branch: check out its apple/m4-stabilization branch. (We did not reproduce that exact failure text.)

easy-gl or meta-gl not found

The three GL-profile renderers — including OPENGLES3, the Linux default — are built on the easy-gl sibling, which itself expects meta-gl next to it. Clone both alongside CNA, or select a renderer that does not use EasyGL, such as -DCNA_GRAPHICS_RENDERER=SDL_RENDERER.

Missing vendored SDL, googletest or Draco

The message tells you to run git submodule update --init (non-recursive). A ZIP or tarball export of the repository cannot contain submodule content. If you do not want Draco, configure -DCNA_ENABLE_DRACO=OFF; if you do not want tests, -DCNA_BUILD_TESTS=OFF; with -DCNA_ENABLE_SDL=OFF the SDL submodules are not needed.

"Unknown graphics renderer"

The message reads "CNA: unknown graphics renderer '<name>' (requested through CNA_GRAPHICS_RENDERER)" and lists the supported names. The value you passed is not one of the 14 public identities. The usual cause is an old name: EASYGL, D3D9, D3D11, DX3 or ASCII. A name that used to exist but has been removed gets a separate message saying it "has been retired and is no longer supported". See the translation callout in Step 5 above, or the full list on Graphics Renderers.

"renderer only builds when targeting Windows"

You selected one of the 2 Windows-gated renderers on a non-Windows target. Either build natively on Windows, or use the repository's cross-compile path with -DCMAKE_TOOLCHAIN_FILE=cmake/toolchains/mingw-w64.cmake and run the result under Wine + DXVK. The full-engine cross-build is not an automatic CI lane.

WEBGL2 refuses to configure

It needs the browser’s WebGL 2 and is Emscripten-only. Configure through emcmake cmake or emcmake cmake --preset web; it cannot be selected on a native target (use OPENGLES3 or OPENGL33 there).

Configure stops on a CNA_PLATFORM value

CNA_PLATFORM takes SDL3, HEADLESS or TERMINAL; any other value stops the configure step, and the message names SDL3 as the platform for a windowed build on Windows, X11 or Wayland. TERMINAL on Windows is refused as not implemented there. If SDL3 does not open a window on your Linux session, check that the X11 or Wayland development packages were installed before the vendored SDL3 was first configured. See Windows, X11 and Wayland.

"CNA_ENABLE_SDL=OFF, but this configuration genuinely requires SDL"

Something in your selection needs SDL: a platform or audio value of SDL3 (remember the default audio is SDL3, so pass -DCNA_AUDIO_PLATFORM=NULL or ALSA), or one of the renderers SDL_RENDERER, SDL_GPU, FNA3D. The message lists which. Choose a native platform, a non-SDL audio value and a non-SDL renderer.

Vulkan: no Vulkan device found

The VULKAN renderer needs Vulkan headers, a loader and a driver ICD. On Debian/Ubuntu install libvulkan-dev (and mesa-vulkan-drivers for a software driver) and check with vulkaninfo. Virtual machines without GPU passthrough usually have no usable Vulkan device.

OPENGLES3: OpenGL context creation failed

The GL profiles need a working GL/GLES driver and a display server. On a headless machine, force a software GL implementation (for example LIBGL_ALWAYS_SOFTWARE=1 with Mesa's llvmpipe) or run under xvfb-run -a, or switch to SOFTWARE, HEADLESS or STUB — none of which need a GPU at all (and none of which opens a window, whichever window system SDL3 would use).

The program starts but shows no window

You most likely built a CPU renderer (SOFTWARE, HEADLESS or STUB). On windowing platforms these render off-screen by design. Build with a GL-family renderer or VULKAN for a visible window, or use CNA_PLATFORM=TERMINAL with SOFTWARE to see frames in a terminal.

--target CNA fails with "No rule to make target"

Expected. CNA is an INTERFACE library with no sources. Drop the --target argument, or name CnaTests or a demo target instead.

Configure fails on libavcodec / libavformat / libavutil / libswresample

This only happens if you asked for it: -DCNA_ENABLE_VIDEO=ON requires all four FFmpeg development packages and fails configure when one is missing (and on Windows, MinGW, Emscripten, Android and iOS, where FFmpeg is never built). With the default AUTO, missing packages simply mean a build without video. Install libavcodec-dev, libavformat-dev, libavutil-dev and libswresample-dev (or your distribution's equivalents), or drop the option.

Video: NotSupportedException at run time

The build has no FFmpeg backend. On Linux and macOS install the four FFmpeg development packages and reconfigure with -DCNA_ENABLE_VIDEO=ON (or leave AUTO); on Windows, Emscripten, Android and iOS there is no FFmpeg build, so playback is unavailable. Nothing fails at link time.

sharp-runtime on the wrong branch: the message to look for

When the sibling directory exists but is sharp-runtime's main or develop branch, the configure stops inside sharp-runtime's own CMake, before CNA prints its sharp-runtime shape message. CNA hands its component closure to the sibling in SHARP_RUNTIME_COMPONENTS, and the sibling's registry rejects the first name it does not know. Reading both repositories (the failing configure was not run), the message has the form:

CMake Error at …/sharp-runtime/cmake/SharpRuntimeComponents.cmake:<line> (message):
  Unknown Sharp Runtime component 'Resources'. Available components: Core.Base, …, All

Resources is reported first because it precedes Xml.Serialization in CNA's list (cmake/SharpRuntimeConsumption.cmake); both exist only on sharp-runtime's apple/m4-stabilization branch. The fix is the one above: git -C ../sharp-runtime checkout apple/m4-stabilization (or clone with -b apple/m4-stabilization), then reconfigure. How the component selection works on both sides is on sharp-runtime components and consumption.