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.ps1From 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
PATHand in common folders such asC:\SysGCCandC:\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_REL2user 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
- Extract the compiler ZIP to a dedicated folder, such as
C:\Tools\arm-gcc-15.3.rel2. The ZIP hasbinat its root. - Add
C:\Tools\arm-gcc-15.3.rel2\binto your terminal’sPATH. This is the directory containingarm-none-eabi-gcc.exe. - Check that
arm-none-eabi-gcc -dumpfullversionprints15.3.1andarm-none-eabi-gcc -dumpmachineprintsarm-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 --versionThe 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:
- Set
ARM_GCC_15_3_REL2to the 15.3.rel2 installation root, not itsbindirectory:
1$env:ARM_GCC_15_3_REL2 = "C:\Tools\arm-gcc-15.3.rel2"- In your application’s
CMakePresets.json, add this entry to thecm4-releasepreset’s existingcacheVariablesobject. Keep its other entries. The example’scm4-debugpreset 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.