Installing Tools

Installing Tools

Building a CDX application needs an Arm compiler, CMake, Ninja and a licensed Ginmake. Programming a display needs GEMS Dash Design. MATLAB is needed only to generate code from your own Simulink models.

The Quickstart runs the install script and builds the starter. This page covers the script’s options, manual installation and compiler selection.

Install Tools Script

From the project root, run the signed installer supplied with the runtime:

1.\cdx-runtime\install-tools.ps1

From Command Prompt, or if PowerShell scripts are blocked, run cdx-runtime\install-tools.cmd instead.

The script:

  • Lists every ARM GNU compiler it finds on PATH and in common folders such as C:\SysGCC and C:\Tools.
  • If GCC 15.3.1 is missing, offers to download Arm GNU Toolchain 15.3.rel2 from the GEMS mirror, verify its SHA256 and extract it to C:\Tools\arm-gcc-15.3.rel2. It offers this even if an older compiler is installed, such as GCC 10.3 from VisualGDB or an earlier runtime.
  • Offers to set the ARM_GCC_15_3_REL2 user environment variable.
  • Explains how to select the compiler in Dash Design CDX Project Tools, a terminal or CMakePresets.json.
  • Offers to install missing CMake and Ninja through winget.
  • Reports Ginmake and MATLAB only.

It never changes or removes existing compilers.

Option Effect
-CheckOnly Report only. Install and change nothing. Exit code 1 if GCC 15.3.1 is missing.
-Yes Accept every offer without prompting.
-ToolchainRoot D:\Tools\arm-gcc-15.3.rel2 Install the compiler to another empty folder.
-CompilerArchive <zip> Install from an already downloaded copy of the exact compiler ZIP.

The script does not edit PATH or the execution policy. Restart terminals, VS Code and Dash Design after changing environment variables or installing tools. The table below lists the same tools for manual installation.

Tool Requirements

Run cdx doctor --operation build to check tool availability before installation. It does not prove that the compiler version, Ninja or a Ginmake licence is usable. The first build checks these. A missing objcopy usually means the compiler’s bin directory is not on PATH.

You can install some tools from the terminal with winget, as shown below.

Tool Location / Details
ARM Toolchain 15.3.rel2 GEMS mirror
15.3.rel2 source (optional) GEMS mirror
CMake 3.21+ winget install Kitware.CMake or CMake
Ninja build system winget install Ninja-build.Ninja or Ninja
GEMS Ginmake Version 2.88+ recommended. Requires a Ginmake Simulink licence. Obtain both from GEMS and install licences using GEMS Dash Design. Ginmake generates code for Simulink model integration.
GEMS Dash Design GEMS downloads. Required for programming the CD6 display and editing display setups. See the Dash Design manual.
MATLAB (optional) MATLAB, Simulink, Simulink Coder and Embedded Coder. Needed only to generate code from your own Simulink models.
Visual Studio Code (optional) winget install Microsoft.VisualStudioCode or VS Code. Recommended for editing and managing development. Extensions support CMake, C/C++ and Git integration.

Tool Locations

You can configure tool locations instead of adding them to PATH. For CLI workflows, put shared CMake/Ginmake paths in cdx-project.json and machine-specific overrides in the ignored cdx-project.local.json. Paths can use Windows %VAR% environment references. Configure Ninja and the compiler through CMake.

Tool Alternative to PATH
CMake Set tools.cmake in the CLI project configuration.
Ginmake Set tools.ginmake in the CLI project configuration. The CLI passes it to CMake.
Ninja Set CMAKE_MAKE_PROGRAM in the CMake preset/cache. There is no tools.ninja setting.
ARM compiler Set CDX_RT_TOOLCHAIN_BIN in the CMake preset/cache.

Running CMake directly does not read the CLI’s project configuration. If cmake is not on PATH, invoke it by its full path. See Project configuration for the CLI settings.

Alternatively, add the tools’ executable directories to your user PATH using installer options or the Windows PATH settings. For a self-contained setup, set PATH only in the current terminal. Prefer this when you have multiple compiler versions or toolchains. Close and reopen your terminal after changing the system PATH.

Install The Compiler Manually

  1. Extract the compiler ZIP to a dedicated folder, such as C:\Tools\arm-gcc-15.3.rel2. The ZIP has bin at its root.
  2. Add C:\Tools\arm-gcc-15.3.rel2\bin to your terminal’s PATH. This is the directory containing arm-none-eabi-gcc.exe.
  3. Check that arm-none-eabi-gcc -dumpfullversion prints 15.3.1 and arm-none-eabi-gcc -dumpmachine prints arm-none-eabi.

mingw-w64-i686 describes the Windows host, not the target CPU. This compiler builds Cortex-M4 firmware with the supplied Thumb, FPv4-SP-D16, hard-float settings.

For example, in PowerShell:

1$env:PATH = "C:\Tools\arm-gcc-15.3.rel2\bin;$env:PATH"
2arm-none-eabi-gcc -dumpfullversion
3ninja --version

The corresponding Arm GNU Toolchain 15.3.rel2 source snapshot (GEMS mirror) is provided alongside the binary for GPLv3 corresponding-source access. It is not required to compile your application. Retain the bundled licenses\toolchain\license.txt, including the GCC Runtime Library Exception and newlib notices, when redistributing firmware.

Use a fresh application build directory when changing compiler versions so CMake selects the new compiler. The manifest’s compiler_version records which compiler built the bundled runtime. It does not restrict your application compiler. The application compiler must still be GNU for arm-none-eabi and use the required Cortex-M4 hard-float ABI settings.

Optional: Use A Version-Specific Compiler Variable

If you have multiple compiler releases, you can define an environment variable for each installation:

  1. Set ARM_GCC_15_3_REL2 to the 15.3.rel2 installation root, not its bin directory:
1$env:ARM_GCC_15_3_REL2 = "C:\Tools\arm-gcc-15.3.rel2"
  1. In your application’s CMakePresets.json, add this entry to the cm4-release preset’s existing cacheVariables object. Keep its other entries. The example’s cm4-debug preset inherits this setting:
1"CDX_RT_TOOLCHAIN_BIN": "$env{ARM_GCC_15_3_REL2}\\bin"

The variable is not recognised automatically. The preset entry connects it to the toolchain configuration. Define the variable before configuring or building.

This records the compiler release while letting each developer choose an installation folder. Multiple releases can coexist without changing the global PATH. CLI, direct CMake and VS Code builds share the selection if they use these presets and inherit the variable.

The PowerShell assignment above affects only that terminal and its child processes. For regular use, define a Windows user environment variable and restart terminals and VS Code so they inherit it. Changing the variable does not replace a cached compiler. Use a fresh configuration/build directory when switching installations.

The CLI’s doctor checks do not read CDX_RT_TOOLCHAIN_BIN. Keep the selected compiler’s bin directory on the terminal’s PATH, or set tools.objcopy in cdx-project.local.json to the full path of its arm-none-eabi-objcopy.exe.

Visual Studio Code

Install Microsoft’s C/C++ and CMake Tools extensions, open the application folder, select the cm4-release or cm4-debug preset and build. Set CDX_RT_TOOLCHAIN_BIN locally if the compiler is not on PATH.