Forem: Kate

Initializing C and C++ projects with cmake-init

Kate — Tue, 10 Feb 2026 18:12:37 +0000

When I was starting new C or C++ projects, my usual approach was either googling for a “C project template”, digging through my old templates saved on my PC (because I stored them, didn't I?) or just building a fresh project from scratch: like set up directories, add initial source files and write a simple CMake. After that, the project structure would evolve naturally as I added tests, CI/CD, and other features.

This setup used to take a large chunk of my time,
and sometimes configuring additional quality tools felt like a real challenge.
Yet, I had never heard of any real shortcuts beyond reusing my old templates.

Does it sound like you? If yes, I have something that will literally change how you kick off a new project.

Just use the CMake project initializer

It turns out the ideal solution has been around for four years, but I somehow didn't know about it, and I only just discovered it now.

Meet cmake-init — an awesome open-source project
that can completely tale care of creating your C/C++ projects with a professional structure, ready-made CMake setup, testing, and more.

What `cmake-init` can do

With a very short setup (just answer a few simple questions) we receive a perfect C or C++ project structure with:

Advanced CMake structure
Built-in versioning
Unit tests template
CI/CD on GitHub Actions running linters, coverage, sanitizers, and tests on Windows, Linux, and macOS
Debug and release builds
Doxygen documentation
Package manager integration

It’s basically everything you need to start developing your project without wasting time on setup.

What really surprised me was how smoothly it just worked.
Usually, my experience with random open-source tools is that they require a fair bit of fighting before anything actually works.
But this one just worked, effortlessly.

A quick setup note for Ubuntu 24.04

The instruction mentions to install cmake-init via the pip install command,
but Ubuntu 24.04 does not accept installing packages globally.

kate@kate-Legion-Y540-15IRH-PG0:~$ pip install cmake-init
error: externally-managed-environment

× This environment is externally managed
╰─> To install Python packages system-wide, try apt install
python3-xyz, where xyz is the package you are trying to
install.

    If you wish to install a non-Debian-packaged Python package,
    create a virtual environment using python3 -m venv path/to/venv.
    Then use path/to/venv/bin/python and path/to/venv/bin/pip. Make
    sure you have python3-full installed.

    If you wish to install a non-Debian packaged Python application,
    it may be easiest to use pipx install xyz, which will manage a
    virtual environment for you. Make sure you have pipx installed.

    See /usr/share/doc/python3.12/README.venv for more information.

note: If you believe this is a mistake, please contact your Python 
installation or OS distribution provider. You can override this, at 
the risk of breaking your Python installation or OS, by passing 
--break-system-packages.
hint: See PEP 668 for the detailed specification.

To install cmake-init, I had to create a python virtual environment and
install cmake-init inside it. My project didn't need python virtual environment, but
you only need to run cmake-init once, so it's not a big cost for what you get.

pip install cmake-init
source myenv/bin/activate
pip install cmake-init

The new project created with cmake-init is here: mini_armv6_emulator.

Testing embedded projects: automate builds and simulate execution with Github Actions and Wokwi simulator

Kate — Fri, 21 Nov 2025 18:25:16 +0000

Testing embedded projects often turns into a slow, manual routine—compile locally, flash hardware, then hope nothing breaks. And while hardware testing will always be important, developers shouldn’t need to rely on physical boards just to verify every small change.

Introducing automation into embedded project is life-changing!

In my full article, I show a practical workflow that automatically builds and tests Arduino projects using:

Arduino CLI for command-line builds
GitHub Actions for CI/CD
Wokwi for fast hardware simulation and automated behavior checks

This setup means every push to GitHub gets compiled and executed in a simulator—no more broken builds going unnoticed.

👉 Full tutorial: Running wokwi simulation on CI/CD

🛠️ What the Pipeline Does

Build Arduino firmware with Arduino CLI

GitHub Actions spins up a Linux runner, installs arduino-cli, grabs the board core (like arduino:avr), and compiles your sketch. If the build fails, you know immediately.

Run the firmware in Wokwi

Wokwi acts as a virtual Arduino Uno/Nano/Mega.
You can assert expected serial output—for example, passing only if the simulated device prints some expected output, or otherwise —
fail on some specific output.

Every commit is checked automatically.

🧩 Why This Approach Helps

No need to attach physical boards for quick checks
Immediate detection of broken commits
Easy to extend with more complex simulation setups

📝 Want the full version?

The complete article includes:

✔ full workflow YAML
✔ Wokwi project setup (wokwi.toml, diagram.json)
✔ command examples
✔ local simulation setup
✔ complete build/test pipeline

👉 Read the full guide here: Running wokwi simulation on CI/CD

Why using arduino-cli is better than building from Arduino IDE

Kate — Sun, 16 Nov 2025 10:13:53 +0000

Detailed version of this article is published on EmbeddedK8.

Did you know you don’t need the Arduino IDE to build and upload sketches? With the Arduino CLI, you can compile and upload directly from the command line—using the same underlying process as the IDE.

Why use Arduino CLI?

- Configuration flags and custom #define options

Control compiler flags, board settings, and custom #define values per project without touching configuration files. This allows fine-grained control for each board or sketch.

- Automated builds and CI/CD integration

Scripts for building, uploading, and testing can run on headless systems like Docker containers. This enables seamless integration into CI/CD pipelines for fully automated Arduino workflows.

- Reproducible builds across machines

Everyone on your team can build with the same setup and dependencies, eliminating the classic “it works on my machine” problem.

- IDE flexibility

Work in your favorite editor instead of the Arduino IDE.

- Per-project library version control

Specify exact library versions for each project, avoiding conflicts when multiple projects require different versions of the same library.

Example Makefile

# FQBN for your board (change if needed)
FQBN := arduino:renesas_uno:unor4wifi

# Serial port (change if needed)
PORT := /dev/ttyACM0

# Build dirs
BUILD_DEBUG := build/debug
BUILD_RELEASE := build/release

# Arduino CLI executable
ARDUINO_CLI := arduino-cli

# Default build release
all: release

debug:
    $(ARDUINO_CLI) compile \
        --fqbn $(FQBN) \
        --build-path $(BUILD_DEBUG) \
        --optimize-for-debug \
        --verbose

release:
    $(ARDUINO_CLI) compile \
        --fqbn $(FQBN) \
        --build-path $(BUILD_RELEASE) \
        --verbose

upload-debug: debug
    $(ARDUINO_CLI) upload \
        -p $(PORT) \
        --fqbn $(FQBN) \
        --input-dir $(BUILD_DEBUG)

upload-release: release
    $(ARDUINO_CLI) upload \
        -p $(PORT) \
        --fqbn $(FQBN) \
        --input-dir $(BUILD_RELEASE)

monitor:
    $(ARDUINO_CLI) monitor -p $(PORT)

clean:
    rm -rf build


.PHONY: all debug release upload-debug upload-release clean monitor

Using the Arduino CLI together with a simple Makefile makes building, uploading, and managing Arduino projects faster, more reproducible, and easier to automate. Whether you’re working solo or in a team, it gives you full control over compiler options, board settings, and dependencies—all without relying on the Arduino IDE.

Give it a try, and you’ll see how much smoother your Arduino workflow can become!

Understanding the Arduino IDE build process

Kate — Tue, 21 Oct 2025 06:42:28 +0000

Have you tried Arduino and already built your first sketch with a single click? Or maybe you’re just starting to explore embedded devices and see Arduino as the easiest way to begin. Either way, understanding the internals of the build process is a great way to boost your skills!

In this post, I’ll summarize the Arduino build process.

For the full article, check out my guide on my blog, which contains more detailed explanation.

The Arduino sketch build process follows the typical embedded/C++ application build steps, with additional Arduino-specifics.

Since the Arduino IDE 2.0, the IDE uses Arduino CLI underneath for the build process. Steps will be the same when building directly via CLI.

General C/C++ application build process

The general build process is shown below. Let’s take a closer look at how the Arduino environment adapts it.

1. Preprocessing – preparing the sketch

This stage includes most of the Arduino-specific steps, designed to make development as easy as possible for beginners.

Combining files: All .ino files in the sketch folder are merged into a single .cpp file.
Detecting used libraries: Libraries included via #include are identified and stored for compilation and linking. This saves you the need to manually configure used libraries, like in other embedded development environments.
Adding headers: If #include <Arduino.h> is missing, the Arduino environment adds it automatically.
Function prototypes: Missing prototypes are generated automatically. Thanks to this, you don't need to type them during development, and can add functions in any order.
Line directives: #line directives are added to maintain accurate line numbers in error messages. This is necessary because your code is written in .ino files, which are automatically converted into .cpp files during preprocessing, and the original line numbers are not matching the line numbers from post-processed ino.cpp file.
Expanding code: Expands macros and processes includes.

2. Compilation

Compilation is changing the human-readable code into assembly code, which later gets transformed into machine code. Modern compilers perform both compilation and assembly in one step.

Sketch compilation: The sketch is compiled using the board-specific compiler.
Library compilation: All libraries detected in previous step are compiled.
Core compilation: The Arduino core for the selected board is compiled.

3. Linking

All compiled object files, used libraries and the Arduino core libraries are linked into a single ELF file (Executable and Linkable Format).

4. Generating binary files

The ELF file is converted into HEX and BIN. The sketch is ready to upload to Arduino board.

Tip: To see detailed compilation steps, enable "Show verbose output" in Arduino IDE. This lets you track every step of the build process.