Yocto Project Consulting Services for Embedded Linux

What does Yocto BSP development include?

The core of a Yocto BSP is the build system that turns your hardware into a reproducible, maintainable distribution – and that build system is what we develop and maintain end to end.

Built on BitBake and OpenEmbedded, we define your distribution as a versioned, traceable blueprint:

• A custom meta-layer with cleanly structured recipes (.bb, .bbappend)
• Image and distro definition – only the packages your product actually needs
• kas-based layer configuration for declarative, version-controlled builds
• Reproducible CI builds that produce an identical image on every commit
• SBOM (SPDX) and license compliance straight out of the build
• LTS maintenance and controlled version bumps (for example to Scarthgap), including upstreaming

The low-level foundation – board bring-up, device trees, kernel and drivers – belongs to our Embedded Linux system; in the BSP we integrate those building blocks into your distribution rather than stitching them together at the seam.

Why a custom Yocto distribution instead of a ready-made vendor image?

A tailored image gives you full control over what ships on the device – and with it control over security, size and maintainability across the whole product lifetime.

Ready-made vendor images are meant for a fast start, not for a long-lived product. They often carry packages you never use, enlarge the attack surface and tie you to the vendor’s release cycle. A custom Yocto distribution turns that around:

• A smaller attack surface and leaner image, because only what you defined is included
• Reproducibility and auditability – every build is traceable
• No vendor lock-in and long-term maintainability instead of dependency
• License compliance and transparency via an automatically generated bill of materials (SBOM)

That keeps your product maintainable in five or ten years – without having to re-roll the entire software stack for every update.

How do you keep fielded devices secure and updatable?

An updatable device starts with image design – the distribution has to bring an OTA-ready layout from the start.

We shape the image so a secure update path is possible: an SBOM (SPDX) and ongoing CVE tracking keep known vulnerabilities in view, and the image and partition layout is prepared for an OTA framework from the outset. The full depth of the secure update path – OTA frameworks such as RAUC, SWUpdate or Mender, A/B partitions, secure boot and a read-only root filesystem – belongs to the low-level platform and is described in detail on our Embedded Linux development page.

How do you make builds reproducible and keep the BSP maintained?

Reproducible builds come from firmly pinned layers and an automated pipeline – not from one developer’s build directory.

We set up Yocto builds with kas to capture layer configuration and versions declaratively and under version control. A CI/CD build pipeline then produces an identical, traceable image on every commit. The configuration is documented, so a build never hinges on a single person.

For long-term care we handle controlled version bumps and LTS upgrades – for example to a long-term-support release such as Scarthgap – so your product keeps receiving security updates for years. Where it makes sense, adaptations flow back into the respective layers through upstreaming, so your BSP grows with future releases instead of drifting apart from them. That is the foundation for durable, long-lived systems rather than throwaway prototypes.

Which hardware and platforms does this cover?

The Yocto Project is hardware-agnostic and covers common ARM and x86 SoCs and SoMs.

Typical target platforms are SoM and SoC families such as NXP i.MX or Raspberry Pi (including the Compute Module) and other ARM- and x86-based boards – Yocto supports them through their respective BSP layers, which we extend with custom recipes and board-specific adaptations where needed. For devices with a user interface we bring Qt on EGLFS to the platform and migrate existing HMIs from Qt 5 to Qt 6; more on that on our Qt & QML development page. You’ll find concrete reference projects in our portfolio.

How do we work with your team?

We work as a sparring partner at eye level – from understanding your requirements through design and delivery to hand-over.

It starts with a clear picture of hardware, requirements and product lifetime. From there we derive the BSP, update and build architecture and implement it. Whether as a clearly scoped project or as augmentation of your existing team, we adapt the engagement model to your situation. Knowledge transfer matters to us: we document the BSP so your team can maintain it independently. We’re based in Lörrach in the tri-border region, bring many years of experience in hardware-related software, and work remote-first in German and English.