A Linux device is a system, not a distribution.

Overview

A Linux device is a system, not a distribution

Choosing Linux for a product is a systems decision. It brings drivers, networking, filesystems and tooling, and in exchange it asks for a boot chain that works every time, a kernel configured for the hardware, a reproducible build and a way to update devices safely in the field.

We engineer that whole chain: bootloader configuration, device tree, kernel and driver work for the board as designed, a userspace containing what the product needs and nothing else, and a build system that produces the same image twice.

Startup time, storage wear, power behaviour and recovery from a failed update are treated as product requirements, because for an embedded device they are.

Linux scope

What embedded Linux engineering covers

From the first instruction after reset to a maintainable image you can ship.

  1. Board support

    Bootloader configuration, device tree development and kernel setup for the board as actually designed, not a reference variant of it.

  2. Kernel and drivers

    Driver development and kernel-side integration for peripherals that have no usable upstream support.

  3. Build systems

    Reproducible image builds with a defined package set, version pinning and a pipeline your team can run without tribal knowledge.

  4. Userspace applications

    Application services, init and supervision strategy, logging and the interfaces the product exposes.

  5. Update strategy

    Image or package update mechanisms with integrity verification, rollback and a defined behaviour for a power loss mid-update.

  6. System hardening

    Reduced attack surface, sensible service and permission configuration, read-only filesystems where appropriate and credential handling.

Platform process

Bringing a Linux platform up on new hardware

Ordered so that each layer is proven before the next one depends on it.

  1. Platform assessment

    SoC, memory, storage, peripherals and boot media reviewed against what the product has to do and how fast it must start.

  2. Boot chain

    Bootloader configured and verified, including boot media, failure behaviour and the recovery path.

  3. Kernel and device tree

    Kernel configured for the hardware, device tree written for the board and peripherals verified individually.

  4. Driver work

    Drivers developed or adapted where upstream support is missing or does not match the hardware as built.

  5. Build pipeline

    Reproducible image build established with pinned versions and documented build instructions.

  6. Userspace and services

    Application services, supervision, logging and interfaces implemented and tested on target.

  7. Update and maintenance

    Update mechanism implemented and exercised, including interrupted updates and rollback.

Technical illustration of an embedded Linux stack from bootloader and kernel to userspace applications
Embedded Linux stack

Lifecycle

Reproducible today, buildable in three years

An image that only one machine can build is a liability. Pinned versions, a documented pipeline and a build anyone on the team can run are what make a Linux product maintainable.

The update path is engineered with the same seriousness: verified, interruptible and recoverable.

Applications

Where embedded Linux fits

Where Linux fits

  • Gateways and edge devices handling networking and data
  • Products with graphical or web-based interfaces
  • Devices performing substantial local data processing
  • Equipment integrating multiple communication interfaces
  • Platforms shared across a family of related products
  • Existing Linux products needing kernel, security or lifecycle updates

Platform work

  • Bootloaders
  • Kernel configuration
  • Device tree
  • Driver development
  • Build systems
  • OTA update
  • Hardening

FAQ

Embedded Linux questions

What usually determines whether Linux is the right platform for a product.

Ask our team

Next step

Custom board that needs a Linux platform it can ship on?

Tell us the SoC, the peripherals and the startup and update requirements. We will scope the board support work.