We are excited to announce the release of Rugpi version 0.6. 🎉 This release introduces significant enhancements to the image building pipeline, elevating its flexibility and power.

⚠️ With version 0.6 we introduced backwards-incompatible changes to the image building pipeline. Continue reading for details on the changes and a smooth upgrade process.

What's new?​

Version 0.6 comes with an overhauled and more powerful image building pipeline. In addition, it makes it much easier to share recipes with the community via Rugpi repositories.

(1) Layers.  With version 0.6, we introduce the concept of layers. Unlike previous versions of Rugpi, where customizations were limited to a single set of recipes, you can now create multiple layers, each with its own set of recipes and parameters. Layers offer more flexibility. For example, if you are working on different variants of a product, you can define a layer for each variant. Layers can also be build on top of each other, allowing you to establish a base layer and then create additional variants on top of it. Layers are cached and only rebuild if there are changes to their recipes, parameters, or parent layers.

(2) Explicit Recipes Enabling.  We have made a shift from recipes enabled by default to a more explicit approach. Recipes now always need to be explicitly enabled, providing greater control over the applied customizations. In particular, this means that modifications specific to Raspberry Pi will no longer be applied automatically. Instead, you now need to explicitly enable them via the core/raspberrypi recipe. In the future, this will allow us to support other boards than Raspberry Pi.

(3) Repositories.  It was an explicit goal from the beginning to facilitate the sharing of recipes within the community. With version 0.6, we introduce repositories, making it much easier to share recipes and layers. Repositories can be local directories, e.g., managed with Git submodules, or remote Git repositories. They can be included with a single line in your Rugpi Bakery configuration. For example:

[repositories]
rugpi-extra = { git = "https://github.com/silitics/rugpi-extra.git", branch = "v0.6" }

Repositories also provide a namespace for recipes thereby avoiding conflicts. For instance, the zsh recipe from the rugpi-extra repository is referred to by rugpi-extra/zsh.

(4) Multiple Images.  It is now possible to define multiple images. As a result, you can now easily build images for different boards which require different boot flows or architectures. Furthermore, different images can be based on different layers, providing even more flexibility.

(4) Simplified Building Process.  Building an image is now a one-liner:

./run-bakery bake image <image-name> build/<image-name>.img

This will download the required base image, apply all customizations as defined by the layers, and finally assemble the image, which is then ready to be flashed or installed.

Upgrading to v0.6​

Excited about the new features? 🚀 Upgrading to version 0.6 is easy:

1. Replace your run-bakery script with the latest version found in the template.
2. Create a layer configuration using core/raspios-bookworm (for Raspberry Pi OS Bookworm) as parent layer and move the set of enabled recipes and their parameters there.
3. Adapt the set of enabled recipes and their parameters. To this end, you need to prefix the recipes previously provided by Rugpi with core/, enable the core/raspberrypi recipe to get back the Raspberry Pi-specific modifications, add the rugpi-extra repository in case you are using any of the recipes which have been moved there, adjust the recipe names in the parameters section accordingly, and explicitly add local recipes you want to enable.
4. Move the image configuration into a respective images section.

Check out the new template for an example.

What's next?​

With the overhauled image building pipeline and layer system, we are now in a position to add support for other boards and fail-safe delta updates. We also aim to improve the command line interface and the Rugpi Admin web interface. Finally, another focus will be on reproducibility, compliance, and provenance tracking of the software components integrated into an image.

Got ideas or suggestions? Please open a discussion or issue on Github.

We are excited to announce the release of Rugpi version 0.5. 🎉

Version 0.5 signifies the end of Rugpi's experimental phase. We are confident that the foundational update mechanism is sound. From this point forward, we aim to maintain backwards-compatibility for updates. This means, if you deploy a system with Rugpi now, you should be able to update it remotely later. While the update process itself is stable, we are still iterating on the design of the image building pipeline and the CLI and APIs. What will change in the upcoming months is the way system images are build. We are planning to introduce layers, drawing inspiration from Docker. Layers will streamline the image-building process and enable fail-safe delta updates in the future.

What's new?​

On top of conducting further testing of the build and update process, this release also brings valuable new features over the initial prototype, which we introduced back in July.

Rugpi now supports all models of Raspberry Pi and 32-bit Raspberry Pi OS. We have tested the images on various models. A big shout out and many thanks go to Reuben Miller, who helped significantly with testing. In particular, Rugpi is known to work on Raspberry Pi Zero 2 W, a low-cost but still powerful variant of Raspberry Pi. Having extended support beyond the latest boards by integrating with U-Boot, we are now also confident that Rugpi can be brought to other boards than Raspberry Pi. While building a seamless, optimized experience for Raspberry Pi clearly remains our focus, feel free to contact us in case you like Rugpi and want to use it with a different single-board computer.

In addition to support for all models of Raspberry Pi, Rugpi now also supports streaming updates directly to the underlying storage. Furthermore, there is now an option to persist the writeable overlay by default making it easier to apply user-defined customizations in the field.

What's next?​

Having validated Rugpi's foundational design, we now aim to further extend its features. In particular, we plan to introduce a layer system to Rugpi. Layers will be cached and shared between different variants of a system image. Furthermore, they will enable a crucial feature, fail-safe delta updates. We also plan to introduce recipe collections and making it easier to share recipes, collections, and layers.

Industry Adoption and Collaboration​

We saw great positive resonance to our initial prototype. With thin-edge.io we are proud to have found a partner spearheading the way to industry adoption. Thin-edge.io officially supports Rugpi to build and deploy images. To learn more, checkout the thin-edge.io Rugpi reference repository.

If you're planning to adopt Rugpi or have feedback to share, we want to hear from you! Your contributions and insights are invaluable as we continue to shape the future of Rugpi. Join the community and share your experiences with Rugpi by opening a discussion on GitHub.

We are thrilled to introduce Rugpi, the first open-source platform that empowers you to create innovative products based on Raspberry Pi. 🎉 At its core, Rugpi is designed to streamline the process of building commercial-grade, customized variants of Raspberry Pi OS for your projects. Developed out of the need for a reliable platform for our customers, Rugpi boasts three core features:

(1) Modern Build Workflow with Rugpi Bakery​

Instead of a manual golden-image workflow, Rugpi comes with a Docker-based toolchain, coined Rugpi Bakery, for building customized images based on a set of recipes. Recipes allow you to cherry-pick and install only the software and configurations you need. You can build images locally or via a CI system such as GitHub Actions or GitLab CI/CD. This eliminates all the hassels and chores that come with a manual golden-image workflow, and streamlines development as well as deployment. Furthermore, recipes can be shared with the community enabling reusability and composability.

(2) Robust Over-the-Air Updates​

One of the most difficult challenges in maintaining embedded devices is ensuring seamless updates with minimal interruptions and without corrupting any data or leaving the system in a bricked state. Rugpi tackles this challenge head-on with its robust over-the-air update feature. With rollback support for the entire system, including firmware files, you can update your devices remotely with complete peace of mind. This allows you to deliver the latest features and enhancements to your product in a snap, without worrying about costly downtimes or potential damages due to incomplete updates.

(3) Managed State​

Rugpi's managed state feature ensures that the important state of a device is preserved across reboots and updates. At the same time, it safeguards against accidental state corrupting the system and makes implementing reliable factory resets or state backups a breeze.

Next Step: Becoming Production-Ready​

While the core features are there already, Rugpi is still experimental. We plan to further fine-tune the design and welcome any feedback or suggestions from the community. For now, our primary goal is to make Rugpi production-ready by consolidating its design and conducting thorough testing.

Stay tuned for future updates by staring or watching the project on GitHub! 📣

Commercial Support and Applications​

Rugpi is and will stay open-source under the permissive MIT and Apache 2.0 licenses. This is great for hobby projects and also minimizes risks for commercial applications. Rugpi is backed by my company, Silitics, and we offer commercial support as well as development and consulting services. If you plan to built a commercial product with Rugpi, we are here to ensure your success.

Technical Details in a Nutshell​

For those curious about the technical details, here is a sneak peak. For OTA updates, we use the recently introduced tryboot feature of Raspberry Pi's bootloader, enabling a fail-safe A/B update schema. For state management and controlling OTA updates and rollbacks, we have developed custom software in Rust, ensuring reliable functionality. Rugpi replaces the init process and uses overlay and bind mounts to set everything up before handing the controls over to Systemd. While the system partition is mounted read-only at all times, preventing corruption, a writeable overlay and bind mounts are used to selectively persist important state across reboots and updates, and to discard any accidental state. For further details, read the user guide and checkout the source code on GitHub.

Try it Today!​

We invite you to try Rugpi. Checkout the quick-start guide to built your first image and share your recipes, questions, projects, ideas, and suggestions by opening discussions on GitHub. 🚀