Kairos v4.0.0 is the result of a clear architecture path we have been building over time: first standardizing image creation with kairos-init, then making that flow easy to run anywhere with Kairos Factory and kairos-factory-action, and finally introducing Hadron.

In March 2025, we introduced kairos-init, a foundational shift that removed Dockerfile-heavy distro logic and standardized how we transform OCI bases into Kairos images.

From there, we focused on operationalizing that model so anyone could run it. With Kairos Factory, users can build and maintain their own Kairos pipelines using the same tooling we run in production.

In December 2025, we introduced Hadron, our upstream-first Linux base for immutable systems. In v4, Hadron artifacts are what the project publishes in its release flow.

At the same time, distro flexibility remains core to Kairos. This is visible in active community work such as Oracle Linux support in kairos-io/kairos#3987.

For additional migration and build context, read Hadron-Only Artifacts with Ongoing Distro Support.

Starting with Kairos v4, the Kairos project will publish Hadron-based artifacts only.

This decision allows us to reduce maintenance costs, focus engineering effort where it has the most impact, and ship improvements faster.

We are happy to welcome William Rizzo as a new Kairos maintainer.

William is a CNCF Ambassador and Linkerd Ambassador, and he currently works at Mirantis as a Global Field CTO. He helps organizations design, build, and run platforms across edge, AI, and platform engineering. His background spans engineering, product ownership, pre- and post-sales, and consulting, with experience in HPC, storage, and large-scale distributed systems.

Open source and cloud-native communities are a major part of William's professional identity. He actively volunteers in several Cloud Native groups and helps organize KCD Netherlands. He also brings public speaking experience from community talks. He is a strong addition to the team, bringing years of experience in the field and a collaborative, community-first approach.

The cloud-native and edge-computing world demands systems that are small, reliable, and predictable. For years, the Kairos project has empowered users to turn mainstream Linux distributions, such as Ubuntu, Alpine, Debian, Fedora and more, into immutable, image-based operating systems with secure, atomic A/B updates.

That mission remains core to us. But in transforming traditional distributions, we continually encountered friction: the inherited bloat of legacy package managers, sprawling dependency graphs, and downstream patches that increase image size and boot time.

Kairos has always been more than just a Linux distro—it's a bold idea: bring the power and flexibility of Kubernetes to the edge, with a truly immutable, secure, and cloud-native operating system anyone can use, contribute to, and trust.

Over the past few years, we've seen Kairos go from idea to implementation, and from experimentation to production. Today, it's running in large-scale, real-world deployments across diverse edge use cases. But more importantly—it's been growing as a community.

Today, we're excited to share a new milestone in that journey:
👉 Kairos now has official commercial support options available from Spectro Cloud.

Before we dive into what that means, let's take a step back and talk about what makes an open-source project reliable—especially when the stakes are high.

We're excited to announce the release of Kairos 3.5.0! This release represents a significant milestone for the broader Kairos ecosystem, marking the completion of several key features across multiple projects that work together to improve the overall Kairos experience.

Every now and then, a release isn't just a version bump—it’s a reset button. Kairos 3.4.0 is one of those releases.

In the last few months, we’ve been heads-down rethinking what makes Kairos powerful, approachable, and future-proof. The result is a foundational overhaul: a brand-new build system, native images for all major cloud providers, streamlined customization through system extensions, and a tighter Kubernetes story with built-in support for k0s. This release isn’t just packed with features—it reflects where the project is heading and how our community is shaping that direction.

Let’s walk through the biggest milestones in Kairos 3.4.0, how they work, and why they matter.

Kairos has always focused on making operating system deployments more predictable, reproducible, and manageable—especially in edge and embedded environments. But for all the benefits of immutability, one challenge has lingered:

How do you safely and easily customize a system after it’s built—without breaking the image or going full Dockerfile rebuild?

Today, we’re introducing a much cleaner answer: the new system extension management framework, now available via the Kairos Agent CLI and when Kairos 3.4.x releases.

Up until now, Kairos has shipped with first-class support for k3s out of the box. If you wanted something else? You had to rely on community-powered providers. And let’s be honest, while amazing in their own right, they’ve been... fragmented.

We’ve seen providers emerge for kubeadm, nodeadm, microk8s, and even another flavor of k3s. Each one added the ability to run Kubernetes on Kairos, but they were often self-contained efforts. Most didn’t plug into our cloud-init-style configuration, which meant you had to know your way around their specific setup to get them running. Power users and contributors made them work, but new users? Not so much.

Then there’s the provider-kairos, which offers a consistent configuration layer across setups and makes Kubernetes orchestration a breeze, especially for decentralized, peer-to-peer deployments powered by EdgeVPN. But it had one limitation: it only worked with k3s.

That is... until now.

🧱 Introduction​

Building Kairos has always been about more than assembling images — it's about shaping a flexible, powerful OS tailored for the edge. Over the past couple of years, we've learned a lot while navigating how to build and maintain Kairos across a growing list of base distributions, architectures, and board-specific targets.

Today, we’re excited to introduce something that marks a turning point in how Kairos is built: kairos-init.

This post isn't just about a new tool. It’s about simplifying complexity, rediscovering clarity, and embedding hard-earned lessons into something lean and extensible. If you've followed our journey, you'll know that we've gone from Dockerfiles to Earthly, and now to a new approach centered on declarative simplicity with Yip.

In this post, we’ll take you behind the scenes:

• Why the old ways worked (until they didn’t)
• How we outgrew our tooling
• What kairos-init changes — and why it matters

This is the story of how we rebuilt the foundation of Kairos, one layer at a time.