Lesson

Introduction to the Yocto Project

From your first build to a maintainable embedded Linux product.

Practical Yocto Project DevelopmentGetting StartedLesson 1 of 26

The Yocto Project, powered by OpenEmbedded, is a framework for building a custom Linux distribution around your actual product requirements:

• your hardware
• your kernel configuration
• the packages you need
• only the packages you need

This course is not just a quick tour of the first successful build. Getting an image to compile is useful, but it is only the beginning of the work. A real Yocto project has to be structured so that the BSP, distribution policy, recipes, applications, SDKs, and release images can all be changed without the whole thing turning into a pile of local fixes and half-remembered build commands.

The aim is to build the habits and understanding needed to work on a professional Yocto project. That means creating a project structure you can maintain, learning how BitBake metadata is interpreted, knowing where customisation belongs, and being able to investigate the build when something does not behave the way you expected.

Yocto will give you a lot of rope. This course is partly about learning which bits of rope are useful and which bits you should avoid wrapping around your own ankles.

The final part of the course also looks at what happens after the image builds: reproducible releases, build infrastructure, shared caches, CI evidence, licensing, SBOMs, and vulnerability management. Those are not extra paperwork on a real product. They are part of knowing what you shipped and being able to maintain it later.

By the end of the course, you should be able to:

• create and structure a Yocto project
• create a custom distribution
• create and modify recipes
• understand variables, overrides, and metadata
• configure a machine and understand BSP boundaries
• customise the kernel and boot process
• diagnose build problems using the evidence BitBake gives you
• use devtool effectively while developing or modifying recipes
• understand package generation and dependency handling
• create disk images
• generate and use SDKs
• structure and maintain a Yocto project for production use

Why Create a Yocto Project?

The main reason is that it has become the industry standard for creating embedded Linux distributions. Most hardware vendors provide a board support package layer for their hardware.

Compliance

There are many regulated industries, such as Automotive or Medical, where detailed records of the system need to be kept.

A Yocto project eases some of the burden by including a detailed Software Bill of Materials (SBOM) by default.

Also, because just about all of the packages are built from source, it is therefore possible to trace the full build of a system all the way through from the source location to the final product.

Reproducible Builds

If a problem is found with a product many years after release, as long as there is a good git history and the sources have been cached, it is possible to recreate the exact build that was used. This means that bugs can be patched and fixes released more easily.

The Reality of a Yocto Project

Yocto is not hard only because it is complex. It is hard because it is unforgiving of poor setup.

What is What?

BitBake

This is the build engine itself. It contains the main bitbake script along with the supporting tools used to execute builds.

OpenEmbedded Core

This provides the core metadata and recipes needed to start a project.

While it is possible to build a project with just these two components, it will not be very useful. Additional layers will be required to add machine definitions or additional software.

What about Poky?

Before 2025, this was always a source of confusion, because Poky referred both to the core setup used to get started and to a reference distribution.

In 2025, this was split into two separate repositories:

• bitbake
  • the build tools and setup
• meta-yocto, which contains two layers
  • meta-poky - the Poky reference distribution
  • meta-yocto-bsp - configuration for reference hardware
    • generic x86
    • generic Arm
    • BeagleBone Black

Hopefully, this split will reduce the confusion and make future maintenance easier.

What about OpenEmbedded?

A Yocto Project is the name of the Linux Foundation Collaborative Project. It makes use of the OpenEmbedded build framework to create Linux distributions, mainly for embedded devices.

In short:

The Yocto Project uses OpenEmbedded to get the job done.

Summary

The Yocto Project gives you a structured way to build a Linux distribution that is tailored to your hardware, software, and long-term maintenance needs.

The main ideas from this lesson are:

• the Yocto Project is a framework for creating custom Linux distributions
• BitBake is the build engine that executes the build tasks
• OpenEmbedded Core provides the base metadata and recipes
• Poky is a reference starting point and should not be the final production distro
  • With a modern setup, you do not even need Poky
• success with Yocto depends heavily on good structure and discipline

Check your understanding

Quick quiz: introduction

A few checks on the core Yocto concepts from this lesson.

Question 1What is BitBake in a Yocto-based workflow?

The package manager used on the target deviceThe build engine that executes tasks and recipesA board support package layer for reference hardware

Question 2What does OpenEmbedded Core provide?

The base metadata and recipes used to start a projectOnly QEMU machine definitionsA hosted binary package feed for all Yocto builds

Question 3Why should `poky` usually not be your final production distro?

Because it only works on x86 hardwareBecause it cannot build SDKsBecause it is a reference starting point rather than your product policy

Check answers