carbonOS is a Linux distribution designed from the ground-up to be robust, modern, easy-to-use, and compatible with a wide range of software.


It forgoes some classical Linux concepts like a package manager, and instead relies on patterns seen on mobile/embedded operating systems. For example: the OS itself is read-only and the user has special writable space to store their data, which allows for clean factory resets. The OS is fully atomic, which means that installing updates is completely safe and can be undone. Apps are isolated from each other and from the rest of the system via sandboxing, meaning that an insecure app won’t necessarily give attackers full access to the system. All of these features (and many of the details not mentioned here) lead to an incredibly fault-tolerant and secure base to build applications on top of.

Modern & Simple

carbonOS is not only modern—providing first-class support for the latest the Linux stack has to offer—but it is designed to be simple internally. In other words, the various tasks that carbonOS needs to do in order to operate smoothly should be as straight forward as possible.

For example: popular Linux distributions tend to use heavily-patched versions of GRUB as their bootloader, which not only requires a lot of configuration but really does a lot more than they need it to. carbonOS uses systemd-boot, a tiny bootloader that follows modern standards (the Bootloader Configuration Spec.) and makes great use of the device’s firmware to do pretty much all of the heavy lifting; it does nothing more and nothing less than it needs to.

Another example: the standard model of package management requires a lot of delicate planning and management that carbonOS does not. Package managers need to keep track of which files belong to which program, which files were edited by the user, etc, etc. In carbonOS, the entire OS is one image and it is read-only, meaning that there is no need to keep track of anything really. This makes system updates much simpler too, since there’s no need to carefully take apart and reassemble a running system.

Easy to Use

The graphical interface of carbonOS is designed to be minimal and intuitive. It gets out of your way and lets you focus on your work. At the same time, it is very powerful when you need it: features like system-wide search and the control center make it very easy to do your work without opening other apps. Convergent UI makes apps usable at any size, and makes the experience of carbonOS consistent between the desktop and mobile editions.


TODO: Not a part of carbonOS yet

Apps on carbonOS run on top of “runtimes”, or standardized collections of libraries and other resources that they need of to run. This is very useful and provides many benefits in a lot of different ways, but perhaps the most powerful feature this provides is the concept of “compatability layers”. In carbonOS, whenever the user tries to run an incompatible program (for example, a legacy 32-bit binary, a Windows program, or a Java app), the needed runtime can be installed on-demand and the OS will be able to run it. This allows for carbonOS to have support for huge amounts of different kinds of software, without bloating the core of the system with all of the components necessary to run every kind of program.

Installation instructions

PSA: DO NOT DO THIS ON YOU MAIN MACHINE. carbonOS is PRE-ALPHA quality software and it will NOT be usable as a daily-driver OS just yet.

carbonOS’s installer ISO file can be found here. It’s only recommended that you run this on physical hardware or using GNOME Boxes as a VM. Other VM programs are untested and are not likely to work. To install carbonOS:

Setting up GNOME Boxes:

Build instructions

Current build instructions (temporary):

$ bst build system.bst
$ tools/commit system.bst os/base/x86_64
$ tools/install /dev/sdX                  # If you want to install it to a drive
$ tools/publish os/base/x86_64            # If you want to publish to an AWS bucket

or if you want a liveos image:

$ bst build liveos.bst
$ tools/checkout liveos.bst
[Image is now in result/installer.iso]

Future build instructions

First, you need to install build dependencies. If you are running carbonOS, this is simple:

$ updatectl switch --base=devel
[Enter administrator password at the prompt]

Your system should now be set up for carbonOS and carbonSHELL development. If you are not running carbonOS, you’ll need to install these packages:

Next, you need to decide a few things:

Now you can start by building the core OS. The core makes up most of the system; it is only missing device-specific packages, a kernel, and an initramfs. There are various flavors of the core for different purposes (for example, the mobile flavor includes apps for phone calls and text messages). To build the core, run:

$ bst build -o arch=ARCH groups/os/FLAVOR.bst

This will take a few hours, or longer depending on your hardware. Next, you’ll need to build a kernel+initramfs combo. This makes the core you just built bootable. Simply run:

$ bst build --max-jobs N -o arch=ARCH kernels/KERNEL/all.bst

Replace N with the number of CPU threads you want to allocate to this build. Since it is only building a kernel, it is better to allocate all of the CPU to one package instead of letting multiple packages build at once as we did with the core. To find out how many threads your CPU has available, run nproc.

Next, you’ll build a release image of the OS that you can flash onto an install medium or directly onto the device, depending on your needs (and on the device’s properties. Please see elements/images/DEVICE/ for details about the generated files and where they should go). Simply run:

$ bst build images/DEVICE/image.bst
$ tools/checkout images/DEVICE/image.bst
$ ls result/

[TODO: Finish this with uploading the files to an ostree remote]

[TODO: Figure out how to allow the builder to configure where their remote is]

Picking a kernel

Usually, KERNEL will be the same as DEVICE. However, this is not always the case. See elements/images/DEVICE/ to find out which kernel you should use for a given image. If you would like to make a custom combination, check out elements/images/template/ for more information.

Building everything

If you are redistributing carbonOS and want to build all available cores, kernels, and images, you can do so with this command:

$ bst build -o arch=ARCH everything.bst

Then, you can publish these binaries with:


Project structure