Building Embedded Systems That Last Decades with NixOS

Many of today’s embedded systems are desigend for lifetimes of a decade or more. X-Ray machines have design times of 5-10 years, then they are sold as the same product for 15+ years. This means that from the start of the design phase to EOL of the product we are already looking at 25 years. The last device sold will be in service for another 15 years. And probably even longer when factoring in the second hand market. As a result we are talking about a total lifetime of more than 40 years.

Today’s software systems are supported for an order of magnitude less than that. There is a number of challenges to support systems for a longer time:

Modern devices need to factor in security concepts. These are connected “smart” devices, exposed to networks.
The eco-system around the devices evolves. Changing hardware availability, such as discontinued processors; changing regulations, such as the Cyber Resilience Act or NIS-2; changing best practices. Even devices that have a static function need to evolve with their environment.
Software systems are complex and change at a fast pace. Even though the intent or function of a system may be static the implementation may change to incorporate changes in the environment.

NixOS: A Game-Changer for Embedded Systems

NixOS is a Linux distribution that comes with reproducibility, declarative configuration and vendor independence: All the necessary ingredients to deal with these challenges. NixOS is built on the package manager Nix that allows to reproduce builds as long as the source code can still be accessed. It has a declarative module system, that allows to describe the intended state of the system. And it is open-source, which ensures users are not held back by vendor lock-in.

How NixOS Ensures Build Reproducibility for Decades

When designing any system it is important to be able to build the system during its entire life-time, for example when tracking down issues. This is an especially hard problem when the life-time is measured in decades.

One needs to make sure that all dependencies can be built in the correct version as well. Fortunately Nix is the perfect tool for this, as it’s prime feature is the so-called “pinning” of dependencies. Pinning ensures that in all versions of the system, all dependencies are known with their exact version. This way the exact state of the system can be reproduced many years later, even when the dependency packages themselves have changed significantly.

Simplify Embedded System Management with Declarative Modules

When designing a system there is often a high-level requirement that needs to be ensured during operations. For example when the system serves a web interface for users to interact with there should be a secure connection and a valid certificate that allows users to correctly identify the system.

In many Linux distributions this requires someone, usually an engineer, to install a web server, deploy the correct configuration, generate a private key and get a certificate for it and finally deploy the correct certificate. Of course this is not done manually but with a configuration management tool, such as Ansible or — in the old days — plain shell scripts.

The issue with those tools is that they work in a way where the engineer lays out the steps to get to the correct system. Contrast that with a declarative system where the engineers defines that they want a webserver and a certificate for the chosen URL. The declarative system has multiple advantages:

The intended state is clearly visible and easy to reason about: This makes it simple to audit the system and improves quality.
When the implementation changes, for example there is a need for a new webserver the system ensures that the new server is deployed and the old server is removed. There is no configuration drift.
The systems can be tested in an automated fashion. NixOS has a really great test system that scales from testing simple modules to whole systems.

Get Started with NixOS for Embedded Systems Today

If you’re building embedded systems Nix and NixOS are great tools to help achieve long lifetimes and avoid some of the headaches that usually exist with other Linux distributions, such as Ubuntu or Debian. NixOS ensures your system can be built with all dependencies, even 15 years from now. Its module system helps avoid configuration drift, simplifies audits, certifications and testing scenarios.

NixOS reduces long-term maintenance costs, enables compliance with evolving standards and minimizes downtime with reliable updates.

Need help getting started? We offer a comprehensive package of NixOS long-term support, a packaging service and all the infrastructure needed to build and manage fleets of NixOS-based systems. Need Over-The-Air (OTA) Updates? Need a way to roll-back failed updates or A/B updates? Join our Beta or Talk to us to learn more!