Request a firmware review
Menu
Startups building gateways, cameras, robots and other Linux-class devices

Embedded Linux images you can rebuild and update

A Linux-based device is a small distribution that you now maintain. We build it so it can be rebuilt from source, updated as a whole image with rollback, and kept current after launch.

Key characteristics

Build systems
Yocto Project or Buildroot
Updates
A/B images with RAUC, SWUpdate or Mender
You provide
Module or board, vendor BSP, licensing constraints
You receive
Layers, image recipes, update integration, SBOM per image

Some products need more than a microcontroller: a camera pipeline, a gateway that talks to dozens of sensors, a robot with a planner and a screen. Embedded Linux is the usual answer, and it changes the job. Instead of one firmware image you ship a bootloader, a kernel, a device tree and a root file system built from hundreds of packages, and each of those packages will receive security fixes over the life of your product.

We build that system so it is reproducible from source, updatable as a whole image with rollback, and small enough for your team to understand. Then we plan how it stays current.

Yocto Project or Buildroot

Both build a complete Linux system from source for your hardware. They suit different products.

Yocto Project Buildroot
How it works Layers of recipes assemble a custom distribution A configuration selects packages and builds one root file system image
Fits Many packages, several hardware variants, vendor BSP layers, package feeds Smaller single-purpose images where a simple, fast build matters
Release rhythm Major releases every six months (April and October); a long-term support release every two years, supported for four years Releases every three months; since 2025.02, the first release of each odd-numbered year is a long-term support release supported for three years
SBOM Generated by default in SPDX through the create-spdx class A CycloneDX SBOM can be generated from the build

If your module vendor already ships a Yocto layer for the part, that is often the quickest start, and we keep vendor layers separate from your own so they can be upgraded later. If the device does one job and the team is small, Buildroot is often easier to live with. We make the call with you in the firmware review and write down why.

Device trees and kernel drivers

The Linux kernel learns what is on your board from a device tree: which buses exist, which chips sit on them and how pins are wired. We write the device tree for your carrier board, port or write drivers for parts the vendor kernel does not cover, and keep every change as a patch on a named kernel version, so it can be carried forward when the kernel moves. Where a driver would help others, we can prepare it for submission upstream with your agreement, which leaves fewer patches for you to carry later.

Vendor kernels are often several versions behind mainline. We record which kernel you are on, what it costs to stay there and what it would take to move, before that becomes urgent.

A/B system updates

On Linux the update unit is usually the whole root file system. Two copies, A and B, sit on storage. The device runs from one and writes the new image to the other; the bootloader switches on the next boot, and switches back if the new system never confirms that it is healthy. Three open-source frameworks cover most products:

  • RAUC is a lightweight update client for the device plus a host tool for building update bundles. It supports symmetric A/B and asymmetric recovery layouts, and signs and verifies bundles with X.509 certificates, with keys optionally held in a hardware security module.
  • SWUpdate is a framework that updates from local storage or the network. It is often used in a single-copy layout from an initial RAM disk and can be set up for double copy. Images are authenticated and verified before they are installed.
  • Mender has a client with a built-in dual redundant (A/B) scheme: it writes the inactive partition, verifies a checksum and rolls back if the device reboots before the update is committed. Its client works with a hosted or self-hosted server.

We choose with you based on your bootloader, storage, update server and how much of the plumbing you want to own. Whatever the choice, we test it the way we test microcontroller updates: power pulled during the write, a new image that fails its health check, a bundle signed with the wrong key, and an update from the oldest version still in the field. The update path in general is covered in over-the-air updates.

Keeping the image maintained

A Linux image is never finished. A product that ships on a Yocto long-term support release and stays in the field for more than a few years will outlive that release’s four years of support, and for products in its scope sold in the EU, the Cyber Resilience Act will require security updates over a support period of at least five years in most cases (see firmware security). Planning for that is part of the build, not an afterthought:

  • Pinned revisions for every layer and package source, so a build from two years ago can be reproduced exactly.
  • An SBOM for every image, produced by the build itself, so you can see which components a new vulnerability report touches.
  • A review rhythm for security fixes, and a dated plan for moving to the next long-term support release before the current one ends.
  • A read-only root file system where the product allows it, with writable data kept on its own partition, so an update replaces software without touching user data.

Sustaining releases is how we keep doing that work after launch, if you want us to.

What you receive

  • A layer or BSP repository and image recipes, pinned to recorded revisions.
  • The device tree and kernel patches, with notes on why each exists.
  • A/B update integration with test records from the failure cases above.
  • An SBOM for each image.
  • Build documentation that takes a new engineer from a fresh machine to a signed image, and a CI build that follows it.

Where to start

If you have a vendor evaluation image, a carrier board and a deadline, start with a firmware review: we look at the board, the vendor BSP, your storage layout and your update plan, and tell you in writing which build system and update framework fit, and what the first months of work look like. Request a firmware review, or read more in the updates and releases section of Field Update.

Send us your board and your plan.

A firmware review reads your schematics, code, flash layout and update plan, and ends with a written plan: what to build first, what could go wrong in the field and how updates will reach your devices.

Request a firmware review

Or email sales@fumbar.com, or call (720) 675-4202.