Skip to main content

Tools and Utilities

Open-source tools and libraries for programming the compute modules, building host applications, and working with Signaloid distributional (Ux) data.

note

All repositories are published under the Signaloid GitHub organization.

Python environment​

Several of the tools on this page are Python programs, including the flashing toolkits, the signaloid-python library, and the Python host applications used throughout the module guides. They all need Python 3.10 or later.

Check what you have before you start, because the interpreter a command finds is not always the one you expect. On macOS and Linux, run both of these.

python3 -c 'import sys; print(sys.version_info >= (3, 10), sys.executable)'
sudo python3 -c 'import sys; print(sys.version_info >= (3, 10), sys.executable)'

Each command prints whether that interpreter is new enough, and which interpreter it is. The first must print True. Run the second one as well, because the flashing toolkits need root to reach the module and sudo does not always pick the same interpreter as your shell. When the second one prints False, the Linux tab below shows how to name the interpreter you want.

If both print True, you are ready and the rest of this section does not apply to you.

Installing Python 3.10 or later​

macOS provides only the Command Line Tools Python, which is 3.9.6 and too old for these tools. Install a newer version alongside it and leave /usr/bin/python3 as it is.

We recommend using pyenv, which installs whichever versions you ask for and never touches the system interpreter.

brew install pyenv
pyenv install 3.12
pyenv global 3.12

Follow the shell setup that pyenv prints at the end of the install, open a new terminal, then run the check above again.

If you already use Homebrew or MacPorts for everything else, either can install Python directly instead.

brew install python@3.12

Homebrew installs that as python3.12 rather than as python3, so call it by its versioned name.

sudo port install python312
sudo port select --set python3 python312

Errors you might see​

error: externally-managed-environment, when you run pip install. Debian, Ubuntu, Fedora, Arch, and Homebrew all refuse to install packages into the system Python. Create a virtual environment instead, which is what the Signaloid host-application examples do. Do not pass --break-system-packages, and do not run sudo pip install, because both write into the interpreter that your package manager owns.

No module named pip, after installing a parallel interpreter. Install the matching pip package, for example with sudo dnf install python3.12-pip, and then use python3.12 -m pip rather than a bare pip, which still belongs to the system interpreter.

A virtual environment on the wrong Python version, after you create it with a bare python3. A virtual environment keeps whichever interpreter created it. Create it with the versioned binary, python3.12 -m venv .venv.

Toolchain and SDK​

Signaloid UxHw Toolchain and SDK​

Applies to:C0-microSDC0-microSD+C0-SD

You can compile UxHw applications for the compute modules on the Signaloid Cloud Compute Engine, which provides the compiler and the uxhw.h API matched to the C0 core you build for.

The Signaloid CLI is the command-line interface to the Signaloid Cloud Compute Engine. It connects a GitHub repository to your Signaloid account, starts builds of that repository on a Signaloid core, reports build status, and downloads the resulting binary, which you then flash to your module. A typical build uses the following commands.

CommandPurpose
signaloid-cli auth loginAuthenticate with your Signaloid API key.
signaloid-cli repos connectConnect a repository, branch, source directory, and target core ID.
signaloid-cli builds create:repoStart a build of the connected repository.
signaloid-cli builds watchFollow the build until it completes.
signaloid-cli builds binaryDownload the resulting binary.

The target core ID selects the C0 core to build for, which determines the distributional representation precision and whether the build tracks correlations. See the execution cores guide for the available cores, and the Signaloid CLI quick start for the end-to-end command-line workflow.

Prerequisites are a Signaloid account on the Signaloid Cloud Developer Platform (SCDP) with an API key, a GitHub account connected to it (see GitHub Login), and the CLI itself (see its installation and authentication documentation).

If you want to avoid invoking the command manually, the Signaloid-Compute-Module-Application-Template repository ships a Makefile that drives the CLI for you, so that a single make connects the repository, builds it, and downloads the binary, and make flash writes it to your module. For a working example on the C0-microSD, see Developing UxHw Applications.

UxHw toolchain for ONNX​

Applies to:C0-microSDC0-microSD+C0-SD

Integrated into the Signaloid command-line tools (signaloid-cli), the ONNX toolchain takes a pre-trained ONNX model and produces a binary that propagates full probability distributions across the network's layers during inference, with no retraining (it preserves the original weights and topology). Inputs can be arbitrarily-shaped empirical or parametric distributions, so you can see how the input distributions propagate to the trustworthiness of a model's outputs.

Device programming and host interfacing​

Signaloid-Compute-Module-Utilities​

Applies to:C0-microSDC0-microSD+C0-SDSD-Dev

C and Python libraries for building host applications, plus the flashing toolkits. C0_microSD_toolkit.py flashes bitstreams, firmware, and data to the C0-microSD over the SD interface and switches its operation modes; C0_SD_toolkit.py covers the C0-microSD+ (and the C0-SD); SD_Dev_toolkit.py manages the SD-Dev carrier board. The src/ tree provides the C Hardware Abstraction Layer behind the single include C0HAL.h, plus host-utility helpers used across the demos. The scripts require Python 3.10 or later and need no additional libraries. See Python Environment.

Signaloid Edge AI Accelerator App for ctrlX OS​

Applies to:C0-microSD+

The productized ctrlX OS integration lets you offload inference of a pre-trained ONNX model from the ctrlX CORE to a plugged-in Signaloid compute module and evaluate output trustworthiness with distribution arithmetic over real-time data streams. Use the signaloid-cli to generate the module firmware from an ONNX model plus a matching app configuration and ctrlX OS IDE / NodeRED templates. Flash the firmware with the app's device manager, then post-process the resulting Ux data with the provided Utilities REST API. For each connected module the app creates a Data Layer node at signaloid/<compute-module-type>/<block-device-name>.

AttributeDetail
Supported compute modulesSignaloid C0-microSD+
OS compatibilityctrlX OS 3.6 or later, requiring core22
Officially supported PLCBosch Rexroth ctrlX Core X3
Largest ONNX modelover 25k-parameter networks
Largest program (binary)320 KiB
Module access latency (read / write)0.8 ms / 6.0 ms
AvailabilityctrlX OS Store, Q2 2026

Custom FPGA configuration development​

LiteX integration​

Applies to:C0-microSD

An example RISC-V SoC on the C0-microSD FPGA (VexRISC-V-Lite with IM support, UART, 12 MHz clock, 128 KiB SRAM, 14 MiB SPI-flash storage) with Makefiles to build and flash both the FPGA bitstream and the firmware. A good starting point for using the C0-microSD as an open FPGA development board.

Working with Ux distributional data​

signaloid-python​

Python library and SDK for interacting with applications that use UxHw distributional arithmetic, for analyzing Ux data values, and for benchmarking applications against equivalent Monte Carlo methods. Requires Python 3.10 or later.

python -m pip install git+https://github.com/signaloid/signaloid-python

Ux Data tools (TypeScript)​

TypeScript/JavaScript tools for parsing and plotting Signaloid distributional data. Construct DistributionalValue objects from Ux strings or byte buffers. Distributed through GitHub Packages:

npm install @signaloid/uxdata-tools

Next steps​

Last updated on