Udemy
Turn what you know into an opportunity and reach millions around the world.
Learn More
Your cart is empty.
Keep shopping
Embedded Linux Development with Yocto Project
New

Embedded Linux Development with Yocto Project

Build your own Linux for a vehicle gateway with Yocto: recipes, layers, a kernel driver, systemd and security, in QEMU
Created byAnil Kumar
Last updated 11/2026
English

What you'll learn

  • Build a complete embedded Linux from source with the Yocto Project and boot it on a virtual ARM board in QEMU
  • Understand how BitBake parses recipes, runs tasks, and reuses shared state to make rebuilds fast
  • Write recipes for a C program and a CMake project from git, with dependencies, licenses and patches
  • Create your own layer, image, package group and distro with systemd, and check what goes into the image
  • Change the Linux kernel with a configuration fragment and a patch, and write a real character device driver
  • Bring a virtual CAN bus to life and send engine readings from a driver to a gateway program
  • Turn a program into a systemd service that starts at boot, and debug it when it fails on purpose
  • Change code safely with devtool and keep every change as a clean patch in your layer
  • Build an SDK and cross compile programs for the board outside of Yocto
  • Secure an image with real passwords, a read-only root filesystem and no remote login
  • Generate an SBOM, read the license manifest and check the image for known CVEs
  • Read real build errors and boot logs line by line, and know how to fix them

Course content

14 sections • 53 lectures • 5h 28m total length
  • An Embedded Board That Needs Its Own Linux7:58
  • Three Ways to Put Linux on Embedded Hardware6:37
  • Meet the Yocto Team6:19
  • What We Build in This Course5:50

Requirements

  • A PC with Ubuntu (22.04 or newer) or Windows 10/11 with WSL2; Section 2 sets up the build machine step by step
  • At least 12 GB of memory and about 150 GB of free disk space (a Yocto build is large); the first build takes about 1.5 hours
  • Basic Linux terminal use: moving between folders, running commands, editing a file.
  • Basic C reading helps for the driver and program lectures; every line is explained.

Description

This course contains the use of artificial intelligence

Linux runs inside cars, trucks, routers and factory machines. On a small embedded board you do not install Linux: you build it, with exactly the programs, kernel and settings the product needs. The Yocto Project is how the industry does that. This course teaches it by building one real product from the first command to the last check: a vehicle gateway that reads an engine sensor, sends readings over a CAN bus, checks them, and starts by itself at boot.

No board to buy. Everything runs on a virtual ARM board in QEMU on your own PC, so you can learn Yocto, develop, break things and boot your real images safely, then move to real hardware when you are ready.

Every hands-on lecture is a real terminal session: real builds, real errors, real boot logs, read line by line. Nothing is faked or shortened: when a build fails, you see the real error and the real fix.


You build:

  • Your build machine and your first complete Linux image, booted in QEMU.

  • An understanding of BitBake from the inside: parsing, variables, tasks, the task graph, stamps and shared state.

  • Your first recipe for a C program, and the four mistakes everyone makes, made on purpose and fixed.

  • Real-world recipes: fetching from git, build and run-time dependencies, classes, PACKAGECONFIG, .bbappend and devtool.

  • Your own layer, image, package group and distro with systemd, inspected with buildhistory.

  • Kernel work: a configuration fragment for virtual CAN, a kernel patch, and a real character device driver for an engine sensor.

  • The vehicle network: engine readings sent as CAN frames and checked by the gateway program.

  • A systemd service that starts the gateway at boot, and what happens when it fails.

  • An SDK, and cross compiling outside of Yocto.

  • Security: real passwords and a normal user, a read-only root filesystem, an SBOM, the license manifest and a CVE check.

At the end, the capstone boots the finished gateway and checks it item by item, and follows one engine reading from the driver, over the CAN bus, into the gateway.

How the course is taught

  • Concept first: every idea starts as an animated workflow diagram, explained in plain words, with every new term defined.

  • Real sessions: you watch real directories, real files opened in the editor, real builds and real boots.

  • Line by line: recipes, configuration files, C code and logs are read part by part.

  • One project: every section adds a real piece to the same vehicle gateway.

  • Focused lectures of 5–9 minutes.


What you need

A PC with Linux, or Windows with WSL2, at least 12 GB of memory and about 150 GB of free disk space. Basic Linux terminal use and basic C reading help. No hardware board is needed.

By the end, you will be able to build, change, debug and secure a complete embedded Linux system with the Yocto Project.


Yocto Project is a trademark of the Linux Foundation. This course is not affiliated with or endorsed by the Yocto Project or the Linux Foundation.


Who this course is for:

  • Software developers moving into embedded Linux.
  • Engineering students who want real, hands-on Yocto skills for embedded and automotive jobs.
  • Embedded engineers who used ready-made images and now need to build and maintain their own.
  • Linux users who want to understand how a complete Linux system is built from source.