Nimmake offers a Python-based build route for ARM and RISC-V firmware

A new build tool called Nimmake has been introduced on dev.to, aimed at developers building C and C++ firmware for ARM and RISC-V microcontrollers. The Python-based tool installs through pip and is positioned as a modern replacement for Makefiles that have grown large and difficult to maintain.

How it works

According to the announcement post, Nimmake compiles C and C++ source for ARM, RISC-V and a broad selection of mainstream microcontrollers. Its central idea is configuration reuse: the tool ships with built-in MCU and toolchain definitions that generate the required compiler flags automatically. External code is added as third-party libraries rather than by registering source files, header paths and preprocessor macros one at a time, and dependencies can be declared between those libraries — a mechanism the post brands the Party System.

Speed is the headline claim

Performance is the main selling point, though the claims come from the project itself rather than independent benchmarks. Four mechanisms are listed:

• Incremental builds that work out which files changed and recompile only those
• Multi-process parallel compilation, with the job count set through a -j flag
• An optional Ninja backend, enabled with -n or --ninja
• A build cache, switched on with --cache, that reuses compiled artifacts

The post says combining these roughly doubles build speed, which matters on firmware projects where full rebuilds are slow enough to disrupt iteration.

Toolchains and bundled libraries

Three compiler families are supported: armgcc, the classic ARM GNU toolchain; LLVM/Clang, which the post highlights for better error diagnostics; and armclang, ARM's commercial compiler. One codebase can switch between them. On the library side, prebuilt modules exist for FreeRTOS, LVGL, FatFS, EasyLogger, CherryUSB and FreeModbus, which the post says require no manual setup to use.

The workflow in practice

Getting started follows a short path: install with pip install nimmake, verify with nimmake --version, clone the project's GitHub repository and its ARM32 sample, then run nimmake. Build definitions are short Python scripts. The post demonstrates an STM32F407 build in roughly a dozen lines: a Cortex-M4 chip configuration is applied, the toolchain path and the arm-none-eabi- prefix are set, source modules are declared through the Party System with the core module depending on the driver module, and a program target is registered as the default.

Other conveniences include a dry-run mode that previews the build plan before anything executes, a --compiledb option that emits compile_commands. for IntelliSense and static analysis in editors such as VS Code and CLion, and a short nmmk command alias. Because everything is driven from the command line, the post also points to CI/CD pipelines and team scenarios where a shared build definition removes environment drift between developers.

Why it matters

Embedded build setups remain a persistent friction point: vendor IDEs are heavy, hand-written Makefiles accumulate special cases, and every new library brings another round of flag and path editing. A pip-installable tool that derives flags from built-in chip definitions lowers the cost of starting a prototype, and compile_commands. output lets it slot into standard editor tooling instead of locking developers into a particular IDE. The Party System targets the most tedious part of MCU work — folding third-party code into a build — by making it a declared dependency rather than a configuration chore. Nimmake arrives in a field where CMake, PlatformIO and Meson are already well established, so its traction will depend on whether the speed and zero-configuration claims hold up beyond the project's own examples. As a lightweight, Python-native option for ARM and RISC-V firmware, though, it is a reasonable candidate for anyone whose Makefile has outgrown them.