Skip to content
Talk to us

Services

We take on two kinds of work. We do engineering on your embedded Linux and firmware, and we build the AI development system that your engineers use to ship it. Choose the one that matches your problem.

Which one do you need?

Start from the problem you have today. If two of these fit, tell us, and an engineer will say which one comes first.

If your problem is engineering

  • Your team is stretched, small, or new to embedded Linux. The work that blocks you is not the work you want to spend your time on.

    Development partner

    The way most customers work with us

    We work as part of your team. We pick up the embedded Linux work that is in your way, build it with your engineers, and review their changes. We leave them able to carry on, and you keep your attention on your product.

    Why it matters. Embedded Linux is a specialty. A partner who already knows the kernel, the bootloader and the build removes the bottleneck without a hiring plan.

    • Hands-on work in your repositories, task by task
    • Code review and enablement for your own engineers
    • An engineer who comes to know your product
    • From a few tasks to programs that run for years
  • You are starting a product, or the boards have not arrived.

    Start a new platform

    From silicon and module choice to first boot: board bring-up, bootloader, kernel, a Yocto build and an SDK your application developers can use.

    Why it matters. These early choices decide how long the product can be supported. They are expensive to reverse once boards are built.

  • Your system sits on an old toolchain, or you inherited one you did not choose.

    Migrate or take over a system

    Move between build systems in the direction that suits you: LTIB, Buildroot or a vendor SDK to the Yocto Project, or the other way. Bring an old vendor kernel to a long-term support kernel. Or take over a system, so you stop paying another supplier for support you do not need.

    Why it matters. A system that only one supplier can build, or that nobody can reproduce, puts every future release at risk. We tell you which target fits your team and your costs.

  • Your product has shipped, and the security fixes are piling up.

    Keep it secure and current

    Yocto Project release upgrades, kernel and bootloader updates, vulnerability (CVE) tracking and an SBOM. Your product stays patched, and you can show it.

    Why it matters. Connected products need security updates for years. Rules such as the EU Cyber Resilience Act turn that into an obligation.

  • Your devices are in the field, and you cannot visit them.

    Update and operate in the field

    Over-the-air updates, secure boot, remote access and production installers. A device is provisioned in the factory and stays safe in the field.

    Why it matters. A fix that needs a site visit costs far more than one sent over the air, as long as the update can fail safely.

If your problem is scaling your team's output

  • Your engineers want to ship faster with coding agents, and you want it under your control. Or your team has more ready work than engineers to do it.

    AI-Assisted Engineering

    We set up the development system around coding agents inside your repositories, with review and tests in place. Start with a Starter, or a Diagnostic if your case is not standard. Later, add an agent queue: agents take the issues that are ready, and your engineers review what comes back.

    Why it matters. Agents only speed a team up when access, review and tests are set up first. Your engineers stay in control of what ships.

AI-Assisted Engineering

Coding agents write, test and review the code. Your engineers decide what to build, and a person approves every merge.

We set up this system inside your repository, under version control, next to your code. You keep it if we stop. We started this work in 2025. Today it runs on our own products and on customer code in C, Rust and Go.

In every engagement

  • It lives in your repository. It is under version control, next to your code. You keep it if we stop.

  • A person approves every merge. Agents write, review and propose. Your engineers decide.

  • It works on hardware code. We use it on C, Rust and Go, in Yocto Project, Zephyr Project and UEFI firmware products.

  • Unattended agents stay sealed. Each run has a one-hour token for one repository, limits on time and cost, and a kill switch.

A legacy controller, moved to Go in 135 engineer hours

On a customer project

135 h
of tracked engineer time, less than four 40-hour weeks
22
porting tasks finished, of 23 planned
421
merged pull requests, and not one revert
40%
of the pull requests came from unattended agents
Read the case

What you can order

These are the pieces of engineering work we take on. Each one is an offer, and not a past project.

In service since 2002 · A commit in meta-freescale in every year since 2011

  • Board support packages

    We build the software layer between your hardware and your application. You get a kernel, a bootloader and a build that your own developers can run.

  • Migration to a current kernel

    Your product runs a vendor tree that nobody updates. We move it to a long-term support kernel, and then it receives security fixes again.

  • Build system migration

    We move a product from LTIB, Buildroot or LinuxLink PRO to the Yocto Project, so one build produces the same image every time.

  • Operating system customization

    We shape the operating system around the product: what starts, what is present, how large the image is, and how long it takes to boot.

  • Reproducible build environments

    We build your development and continuous integration environment with Nix and NixOS, so a build from two years ago still runs today.

  • Embedded systems consultancy

    We join the software to the hardware design while the hardware is still a decision, and not after the boards arrive.

Each of these runs for months, not days.

What we build and maintain

This is the software our engineers write and maintain today. Each row has a public record behind it.

  • AI-Assisted Engineering

    We build the agent system around your code. We run it on our own products and on customer code in C, Rust and Go.

  • Yocto Project

    We build custom Linux distributions with the Yocto Project. We have contributed to OpenEmbedded-Core since 2011.

  • Board support packages

    We maintain meta-freescale, the BSP layer for NXP i.MX platforms. We also build BSPs for other hardware.

  • Linux kernel

    We write kernel drivers and device trees. Our commits have been in the mainline tree since 2007.

  • Boot loader

    We port and configure U-Boot. We maintain three boards in the mainline U-Boot tree.

  • Zephyr Project

    We maintain six areas of the Zephyr Project, and the UpdateHub subsystem in it. We write this firmware in C and in C++, and we publish ZephyrBT, our behavior tree framework.

  • C, C++, Rust and Go

    We write device software in C, C++, Rust and Go. We reworked the Go support in OpenEmbedded-Core in 2017.

  • Simulation and automated tests

    We run the firmware in Renode, so a test needs no board. Twister and Robot Framework then drive those tests in continuous integration, on every pull request. We maintain the renode package in nixpkgs.

Why you can check our work

  • Named maintainer of meta-freescale

    A commit in every year since 2011, with no gap.

  • Maintainer of six Zephyr areas

    The repositories are public, so you can confirm it before you write to us.

  • Three boards in mainline U-Boot

    MX23EVK, ELGIN-RV1108 and PICO-IMX7D carry our maintainer entry in the mainline tree.

Questions we are asked

  • Which embedded Linux services does O.S. Systems offer?

    O.S. Systems offers six services. They are board support packages, migration to a current kernel, build system migration, operating system customization, reproducible build environments and embedded systems consultancy.

  • Can you move a product from Buildroot to the Yocto Project?

    Yes. We move products from LTIB, Buildroot, LinuxLink PRO or a vendor SDK to the Yocto Project. We also move them the other way, when that target fits your team and your costs.

  • Can you move a product off an old vendor kernel?

    Yes. We move a product from a vendor tree that nobody updates to a long-term support kernel. The product then receives security fixes again.

  • Can O.S. Systems work as part of our engineering team?

    Yes. Most customers work with us this way. We do hands-on work in your repositories, review your engineers' changes and leave them able to carry on.

Send us a message about your product

A few lines are enough: what the device does, which processor it uses and when it must ship.

For example

We make a gateway on an NXP i.MX 8M Plus. We need a Yocto BSP and secure updates in 3 months.

An engineer who does this work reads your message and answers you.