Embedded Systems & Product Development Consultancy · London, UK

Embedded Linux and Yocto

Linux on your own hardware, built to be reproduced, updated and supported for years. We create Yocto and Buildroot distributions, board support packages, kernel drivers and the update system around them for NXP i.MX and other application processors.

Talk to an engineer Board bring-up service

A Linux image that only one laptop can build

Getting Linux to boot on an evaluation kit takes a day. Turning it into a product image that builds the same way every time, starts quickly and updates safely takes engineering.

Images built by hand on one engineer’s machine, with no record of what went into them.
Vendor BSPs pinned to an old kernel and a Yocto release that no longer gets fixes.
Boot times measured in tens of seconds because nothing was trimmed.
No safe update path, so a power cut during an update can leave a unit that won’t start.
Root filesystems that slowly fill up or corrupt because everything is writable.
Security patches that never reach the devices already in the field.

We treat the Linux image as product firmware: versioned, reproducible and maintained.

From board support to application

Yocto and Buildroot distributions. Custom layers and image recipes that build reproducibly in CI, with licence manifests and a software bill of materials.
Board support packages. U-Boot, device tree and kernel configuration for custom boards built around NXP i.MX and similar processors. →
Kernel and user-space drivers. Drivers for displays, touch, keypads, motors, sensors, cellular and GPS modules, exposed cleanly to the application.
Application layer. Services in C, C++ and Python managed by systemd, with logging, watchdogs and clean start-up and shutdown.
Field updates and security. A/B updates with rollback, secure boot and signed images, so units can be patched safely for years. →
Real-time and AI on Linux. PREEMPT_RT where control loops need it, and accelerated vision models on NPU-equipped processors. →

Keeping a Linux product maintainable

Pick the processor and the release. Processor, module or chip-down design, and a Yocto LTS release with a support window that matches the product.
Bring up the board. Bootloader, device tree, memory, storage and every peripheral checked on the first prototypes.
Build the image in CI. Layers and recipes under version control, so any engineer can rebuild any release.
Harden and trim. Read-only root filesystem, minimal packages, faster boot and debug ports locked down for production.
Plan the updates. An update system, a process for kernel and security patches, and documentation for the team that maintains it.

Processors, build systems and update tools

Processors: NXP i.MX 6, i.MX 8M and i.MX 93, STM32MP1, Raspberry Pi Compute Module, NVIDIA Jetson

Build and boot: Yocto Project, Buildroot, U-Boot, device tree, mainline and vendor kernels

Runtime: systemd, BusyBox, C, C++ and Python, Qt and LVGL for displays, PREEMPT_RT

Updates and security: SWUpdate, RAUC, Mender, secure boot, signed images

Linux in products that run unattended

Client names stay private. The engineering doesn’t.

Yocto Linux for an electronic lock on an i.MX 6 module

View case studies

Secure provisioning and OTA updates for a wearable medical device

Read the case study

More Linux work

Linux images, drivers and update systems for products under NDA, which we can talk through on a call.

Ask about this work

Frequently asked embedded Linux questions

Yocto or Buildroot?

Buildroot is simpler and quicker for a small, fixed image. Yocto takes longer to learn but scales better: layers, package feeds, SDKs and long-term support releases suit products with several variants or a long life. We’ll recommend one based on your product, not preference.

Can you work with our vendor’s BSP?

Yes. Most projects start from the processor or module vendor’s BSP. We move it onto a supported Yocto release, keep your changes in your own layer and keep them small, so future upgrades stay manageable.

How do you handle updates in the field?

With an A/B or recovery-partition scheme, signed images and automatic rollback if the new version fails to start. Updates can come over the network, from a USB stick or through your own cloud service.

How long will the platform be supported?

That depends on the processor vendor and the Yocto release. We choose long-term support releases, track security advisories and plan kernel updates, so the product isn’t stuck on an old base.

Can Linux meet our real-time needs?

Often, with PREEMPT_RT, which is now part of the mainline kernel. Where hard deadlines matter, we keep the tightest loops on a microcontroller next to the Linux processor.

Do you also design the hardware?

Yes. We design carrier boards for system-on-modules and chip-down boards, with schematics, layout and bring-up handled by the same team.

Bringing Linux up on your hardware?

Tell us the processor, the board and what the product has to run.

An engineer will read it and reply within one business day.

Talk to an engineer