Cyanview OS: Custom Linux System Design with Yocto

2022-01-01

For Cyanview, I designed a custom Linux operating system tailored to the specific needs of our hardware, and Yocto became the backbone of this project.

Why Yocto?

Before settling on Yocto, I explored other options: Buildroot, Android, and Ubuntu Core. Each had its merits, but none provided the flexibility and maintainability we needed for our diverse hardware ecosystem.

Buildroot

Buildroot is an excellent choice if you’re looking for a quick, one-off custom OS for a single architecture and application. However, if you need variations for multiple architectures, Buildroot becomes more complex. Customizing or backporting features is also harder because its build system is based on make, which can get tricky to maintain as your project grows.

Android

Android excels when the focus is on application development, especially for hardware with smartphone-like features (e.g., touchscreens). But just like Buildroot, maintaining Android for multiple architectures is a challenge, and the development tools are more suited for app layers rather than system layers.

Ubuntu Core

Ubuntu Core initially seems promising. If you’re already familiar with Ubuntu, it feels familiar and user-friendly. However, it doesn’t bring much to the table that Yocto or Buildroot doesn’t already offer. While it's great for proofs of concept (POCs), especially when using pre-configured machines, it shares many of the same limitations when scaling to different architectures or making heavy customizations.

Why Yocto Stood Out

Ultimately, Yocto was the best fit for several reasons:

• Support for multiple architectures : We needed to build for ARMv7, Aarch64, and Zynq—all of which Yocto handles efficiently.
• Extensive customization : Yocto allows us to tailor every aspect of the OS, from bootloader to user-space applications. With full recipes or bbappend, custom config, etc.
• Maintainability : Once the system is in place, Yocto makes it simple to maintain and update the OS over time.

The Yocto Learning Curve

Yocto is powerful, but it’s not easy to get started with. The documentation is extensive, and you really need to know what you’re looking for to make sense of it all. It can be slow at the beginning since you’re essentially customizing the base OS to fit your needs.

However, once the groundwork is laid, Yocto becomes extremely maintainable:

• Upgrading or adding libraries?¨ Easy.
• Cross-compiling for multiple architectures? Straightforward.
• Adding existing library? You can find a lot of existing on internet, on openembedded, for example.
• Adding custom tool/library not available in OpenEmbedded? With Yocto’s flexibility and bitbake (the build tool), integrating new libraries or tools is painless.
• Customizing tool/library? it's a breeze, with the bbappends, custom config file, custom compilation options, etc.
• Supporting a new machine? Define the BSP (Board Support Package), including the bootloader, kernel config, and device tree. Many manufacturers now provide these, simplifying the process.

Key Features of Cyanview’s OS

With Yocto, we were able to implement several important features for Cyanview’s hardware:

• Application updates delivered via DEB packages
• OS updates using SWUpdate (SWU) for reliable system updates
• Recovery using SD card, USB, etc. based on WIC images
• Dual-copy OS setup for fail-safe updates, ensuring high reliability
• Cross-compilation and on-target compilation to support different development needs
• SDK for OEMs, allowing third parties to develop custom applications

Supporting Multiple Architectures

The system was developed for a variety of architectures, including:

• ARMv7
• Aarch64
• Zynq

This allowed deployment across Cyanview’s core devices, including:

• RCP
• RIO
• NIO
• VP4

Each device had specific requirements, and Yocto’s flexibility made it easy to adapt to the unique hardware profiles.

And most importantly, reuse what we did in the past.

CI/CD Integration

One of the most significant improvements I implemented was a comprehensive CI/CD pipeline. Every commit triggered an automated build and release process, generating a complete OS release in under 15 minutes. This pipeline allowed us to streamline development cycles, ensuring that updates and new features were continuously integrated and tested.

Final Thoughts

Choosing Yocto was not an easy decision, but it was the right one. It required upfront investment in both time and effort, but the payoffs—customizability, maintainability, and cross-platform support—made it invaluable to Cyanview’s OS development.

If you're in a similar situation where you need a flexible, scalable, and maintainable solution for a multi-architecture environment, Yocto is worth the effort. The initial setup may be challenging, but once in place, it becomes a powerful tool for embedded Linux development.