Ignite – The Future of Building rlxos

Our biggest update this year is Ignite, the build system behind rlxos. Ignite now ensures that every part of rlxos can be reproducible, meaning the same results can be created over and over, no matter where or when you build it and gave exactly same output which increase code trust and beneficial for system debugging.

And apart from various internal fixes, backend changes and core components updates below are few changes on users end.

Improved UI/UX – Look and Feel Better

We’ve made rlxos 2.0 not just powerful but also beautiful and easy to use.

Animations

The moment you start rlxos, you’ll notice smooth animations that make everything look and feel more polished.

Updated default Theme and New Fonts

We’ve improved various theming components like, drop-down menus and panel with better spacing and translucency.

We’ve also switched to Fira Code for monospace fonts, a great choice for developers with stylish coding ligatures.

Easier App Navigation

Finding and opening apps is now simpler with the new grid-based app menu. It’s more organized, visually appealing, and works well on both desktops and touchscreens.

Auto suggestions with default shell.

Default shell is replaced to zsh configured with auto-suggestions and other help full plugins for easy to access shell commands.

Software Management Made Simple

rlxos now comes with a graphical software manager, making it super easy to install, update, and manage Flatpak apps with just a few clicks.

Sysroot – Your New System Management Tool

We’ve replaced the old swupd (name collision) tool with sysroot, our powerful new system management tool that makes maintaining your system more flexible:

• Switch Update Channels: You can choose between a stable, reliable update channel or an unstable channel if you want the newest features faster.

• Add Extensions: Want more features? You can add extension packs like developer tools, virtualization with QEMU, or window managers like i3 and Sway. These extensions let you customize your rlxos experience to fit your needs.

  

Small but Important Improvements

Along with the big changes, we’ve also made smaller improvements that make a difference:

• Faster Setup: You can now search for your timezone during the initial setup, making it quicker to get started.

• Welcome App: The welcome app now helps you set up themes and HiDPI settings as soon as you install the system.

• Uniform Looks: libadwaita is patched to follow system theme.

• CA-Certificates Fix: No more issues with invalid certificates after system updates. Certificates are now included with the system and updated automatically.

Known Issues

While rlxos 2.0 brings many improvements, we want to be transparent about a couple of known issues you may encounter:

1. Initial Login on QEMU: When running rlxos on QEMU-based virtual machines, the initial login at login manager might fail. This issue does not appear on real hardware. If you experience this, simply retry the login.

2. Manuals and documentations: man pages and documentations might not available for some of the apps and commands.

3. Parole: Default video and music player parole might not play video properly on specific graphics hardware.

4. Sysroot Extensions at initial boot: While not a bug, this behavior might be a bit confusing for new users. Sysroot requires a "previous system state" in order to add extensions, but this state is not available on the very first boot. To resolve this, simply run a system update using sysroot. This will create the necessary previous state, and after rebooting into the updated system, you'll be able to add extensions seamlessly.

5. QEMU Extensions: Networking with virt-manager from QEMU extension might not work properly as default Network is not configured.

6. Sway on NVIDIA: Sway extension might fail to start or work improperly on system with NVIDIA GPUs.

7. Software Center Theme: On the first launch, the Software Center might use the Adwaita (light) theme instead of the rlxos default dark theme. This can be fixed by going to Settings -> Appearances and switching themes. We’ve patched libadwaita to use the system theme in future updates.

Why rlxos 2.0 Sankalpa?

rlxos 2.0 is built with determination to provide a better, safer, and more reliable Linux experience. Whether you’re a developer, a tech enthusiast, or just someone want to try something new, rlxos 2.0 is built for you.

Download rlxos 2.0 today and see what’s new!

Recall the command we used to create the installer ISO:

make ELEMENT=installer/image.yml

At a glance, it seems straightforward, but under the hood, there’s a symphony of operations conducted by Ignite. Here’s a snippet from our Makefile.

all: $(IGNITE) version.yml ostree-branch.yml channel.yml
ifdef ELEMENT
    $(IGNITE) cache-path=$(CACHE_PATH) build $(ELEMENT)
endif

Let’s break down what’s this command doing under the hood but before that let me introduce to the star of the house Ignite

Ignite: The Heart of our Build Process

Ignite is the powerhouse that drives the rlxos build system. When we kick off the build process, Ignite embarks on a meticulous journey to create a binary component.

1. Ignite starts by reading and parsing the element file specified at elements/$(ELEMENT). In our case, this is elements/installer/image.yml. This YAML file is like a recipe, detailing the ingredients (components and dependencies) and the steps required to create and specific component.

2. Next, Ignite constructs a detailed dependency tree. Think of this as mapping out every ingredient needed, along with any sub-ingredients, to ensure nothing is missing. The YAML file outlines these dependencies, ensuring that the build includes every necessary component.

3. Ignite then sets up a temporary root filesystem at $(CACHE_PATH)/temp/<element-id>-<hash>/. The <hash> is a unique identifier generated from a cryptographic hash of all dependencies, environment variables, and the element file data. This hash ensures build purity by guaranteeing that any change in the dependencies or environment triggers a complete rebuild of all affected components.

4. With the root filesystem ready, Ignite uses Bubblewrap to run a containerized environment within this filesystem. Bubblewrap is a sand-boxing tool that creates an isolated environment, ensuring that the build process is consistent and free from external influences.

5. Each YAML file includes a script: configuration. This can be written explicitly or generated at runtime using build classes, source code, or other configurations. These scripts guide Ignite on how to compile the source code or execute the necessary steps to build each component. This flexibility allows for precise control over the build process, accommodating various build requirements and conditions.

6. Once all compilation steps are completed successfully, Ignite caches the build artifacts. These artifacts are the outputs of the build process and can be used directly or by other build processes. The cached artifacts are stored at $(CACHE_PATH)/cache/<element-id>-<version>-<hash>.pkg. The <hash> used here is the same as in the environment setup, ensuring that the cache precisely matches the required environment. This guarantees that cached artifacts are reliable and reusable.

Ensuring Purity and Bit to Bit reproducibility.

One of the standout features of Ignite is its commitment to build purity and reproducibility. The cryptographic hash system ensures that any modification in the build environment or dependencies results in a full rebuild of all dependent components. This mechanism prevents inconsistencies and guarantees a clean, reliable build every time independent on the environment.

Additional commands

In addition to its primary role in the build process, Ignite offers several other commands that enhance its functionality and streamline the workflow:

• Status: You can use the command make status ELEMENT=<ELEMENT> to check whether an element is already cached or if it needs a rebuild. This command is incredibly useful for quickly assessing the state of your build environment without initiating a full build.

• Filepath: The command make filepath ELEMENT=<ELEMENT> prints the filepath of the cached artifact for the specified element. This allows you to easily locate and use the cached files, facilitating integration with other tools or processes.

• Checkout: The make checkout ELEMENT=<ELEMENT> command, which you might have already used in previous blog, is used to checkout the cached artifact to $(DESTDIR).

Conclusion

In this part of our series, we ventured deep into the intricate workings of the rlxos 2.0 build process, with Ignite at the helm. We explored how Ignite work. Understanding these steps is crucial for anyone looking to contribute to rlxos or enhance its functionality. Stay tuned for Part 3, where we’ll dive into advanced topics like customizing elements, optimizing the build process, and troubleshooting common issues. The journey through rlxos 2.0 continues to unfold, revealing more of its inner workings and the elegance of its design.

Hold on a sec, ever heard of RLXOS? It's not just your average operating system – it's an open-source, independent, and immutable securely mutable distribution. Picture this: it's like taking the best parts of Android security and workflow and bringing them to your desktop. Cool, right? (Also keep in mind that RLXOS is newer Linux distribution and can lack features and occasional instability)

If you're curious, you can dive into RLXOS 2.0 and explore all its features right here. It's a neat way to learn about building and tinkering with operating systems. Visit the Project website to learn more about the project and take a test drive of it.

Hardware Requirements

Building RLXOS doesn't demand a high-end system. But you'll need at least 100 GiB of storage space, a x86_64 multi-core system, and a minimum of 8 GiB of memory (consider adding swap space if you plan to build LLVM and Webkitgtk-like tools). In essence, you can compile RLXOS on your laptop overnight.

Compilation times vary depending on your system configuration, ranging from 2 days to 6 hours. For instance, it took me 52 hours to compile RLXOS from source on the lowest configuration Contabo Cloud VPS 1, and nearly 6 hours on Contabo Intel 10-Core.

Software Requirements

To successfully compile RLXOS, ensure you have a native Linux system installed. Additionally, install the following tools and libraries:

• GNU C++20 compiler

• libostree

• bwrap

• bsdtar or libarchive-tools

Obtaining Source Code

Simply fork my GitHub repository at https://github.com/itsManjeet/rlxos/ containing the meta-configuration files for building RLXOS. Your star would be much appreciated to support my work.

If you're not on GitHub, clone the project using:

git clone --recurse-submodules --branch stable https://github.com/itsManjeet/rlxos

Project Structure

Ignite! the build process🔥

Now that we have the source code, let's build our first RLXOS distribution. You'll understand why I call it Ignite! the build process later.

Firstly, create your own GPG key to sign the updates

Begin by removing the default rlxos.gpg key:

rm -v files/rlxos.gpg

Then generate a new one:

make file/rlxos.gpg

This action will create a public key at files/rlxos.gpg and a private key at ostree-gpg/. The private key is utilized to sign the OTA updates, while the public key is provided to users within the release ISO to verify OTA updates.

Execute:

make ELEMENT=installer/image.yml

Now, sit back and watch HIMYM to know how Ted meets his children's mother. Yes, it may take that long (unless you're Barney with NASA's hardware).

Testing the output

Once the build process concludes, check out the artifact by executing:

make checkout ELEMENT=installer/image.yml DESTDIR=out

This will check out the installer/image.yml component inside the out directory (essentially the ISO file).

out
├── rlxos-stable-installer.iso
└── rlxos-stable-installer.iso.sha265sum

0 directories, 2 files

You can use any other virtual machine or even real hardware to test the built ISO.

I prefer to use QEMU with KVM for nearly native-like performance. First, create a hard disk image by:

qemu-img create -f qcow2 disk.img 16G

This will create a dynamically allocated 16G disk image where you can virtually install RLXOS without impacting your system..

Now, execute the command to boot into the RLXOS ISO:

qemu-system-x86_64 -cdrom out/rlxos-stable-installer.iso \
    -m 2G -smp 2 -enable-kvm -cpu host \
    -soundhw hda -vga virtio \
    -drive "file=disk.img,format=qcow2"

I reckon that's sufficient for this part. You now have the RLXOS source code and know how to build and test it. You're all set to explore the project source code and various files.

In the upcoming parts, I'll delve into:

• Setting up update mechanisms and managing different update channels

• Establishing CI/CD Pipelines for continuous deployment

• Contributing to the project

• Customizing components, theming, and creating your own custom RLXOS distribution

• Adding support for other Desktop Environments

• Writing element files and porting packages to RLXOS

• Or we can delve deeper into the build process

Until then, please like the post, follow the blog, and star my GitHub repository. Your support keeps me motivated. Feel free to leave a comment if you encounter any doubts or hurdles. 🌟

PKGUPD is a better package manager and successor of appctl in rlxos, PKGUPD aims to be a modular/extensible package manager whose functionality can be increase using the modules

Working

PKGUPD uses YAML configuration files named recipe file that contains a minimal set of information about the specific package or sub-packages. As per the information, PKGUPD performs the tasks and calls the specified modules.

PKGUPD support 2 types of extensions:

• pack: This plugin provides a method to pack and unpack the binary packages that PKGUPD use to perform installations and package generation.
• plugin: (I know bad naming) This provided methods to compile the source codes.

PKGUPD currently provided 4 plugins:

• auto: Compilation plugin that can detect autogen.sh, configure, Makefile, CMakeLists.txt, meson.build and python setup.py
• port: Another compilation plugin that uses appctl port (like PKGBUILD files in arch linux).
• rlx: Packaging plugin that pack the binary packages in rlxos package format
• app: Another packaging plugin for AppImages format.

Example Recipe file

id: example.package
version: 0.1.0
about: |
   Description about the package

pack: rlx
packages:
   - id: subpackage
     sources:
        - https://url.to/source/codes.tar.gz
        - custom-name.tar.xz::https://url.to/another/package.tar.gz
    dir: code
    plugin: auto
    flags:
        - id: configure
           value: >
               --enable-some-feature

Packages

Installation

sudo appctl sync
sudo appctl install pkgupd

Usage

pkgupd-0.1.0: an extensible package manager for rlxos

Usage: pkgupd [Sub] <pkgid> <Args>

Sub:
  install             install specified package from recipe dir
  depends             Resolve required dependencies
  remove              Remove specified application from system
  info                Print Information about pkgid
  require             Check which package require specified package
  sync                Synchronize local database with repositories

Args:
  --help              
  --debug             
  --compile           force pkgupd to compile package from source code
  --force             force task to do
  --no-depends        skip dependencies resolvement
  --all               Set ALL flag

File Hierarchy

AppImages Integration

AppImages are not integrating automatically on hot directories.

• /Applications
• /opt
• $HOME/Applications
• $HOME/Download

Reason

The most possible reason for this is that appimaged (the daemon that is responsible to integrate AppImages into the system) is inactive. To confirm the reason execute the below command.

systemctl status appimaged --user

To Fix

If it's showing the Active state as inactive (dead) then execute the following commands to enable and activate it.

systemctl enable --now appimaged --user

AppImages are not working

Some users report that the most common appimages like LibreOffice-fresh are not working out of the box in rlxos.

Reason

Missing libfuse2.so library

To Fix

Install fuse2 package which provides libfuse2.so

sudo appctl sync
sudo appctl install fuse2

Cover Photo by JESHOOTS.COM on Unsplash

Prerequisites

• PC with Linux installed (no any WSL shit)
• Latest rlxos ISO Here
• An Empty Partition of size at least 5GiB

Preparing Partition

We need to have 2 directories in the empty partition where we paste our root filesystem image and kernel file.

Steps

• Extract the ISO

We only require 3 files from the ISO

• rootfs.img
• boot/vmlinuz

• boot/initrd

• Copy rootfs.img into rlxos/system and rename it with version mentioned on the ISO.

• Now copy vmlinuz, initrd to boot (boot directory of our empty partition)

• Installation is completed from the rlxos side, now we need to do some hacks so that os-prober of your installed Linux system will able to detect the rlxos partition.
  • Create a directory lib in empty partition.
  • Create a empty file ld-linux.so in that directory

and your final directory hierarchy should look like this

rlxos will not use this ld-linux library but the one which is present inside the system image, so don't worry.

• Now update the grub configurations

  sudo update-grub
  

and make sure either rlxos or (some unknown Linux distro) get detected by os-prober

And a last Complication Step Now one Important thing, you need to add a flag system= (where is release version of rlxos) inside the menuentry of rlxos in /boot/grub/grub.cfg of your installed system

or add the flag from the grub menu during the boot, for that follow the below steps

• Reboot the system and press E on rlxos entry.

• And add the flags to make it look like this.

Last Second line,

linux /boot/vmlinuz root=/dev/sd?? system=2106

• Press 'ctrl-x' or F10 to start rlxos.

Enjoy!

Prerequisites

• Adding rlxbot daily build repository in /etc/appctl.conf

sudo gedit /etc/appctl

and enter following line below [url.pkg] section

testing = https://rlxos.cloudtb.online/testing

it will look like something this

Sync the repository

sudo appctl sync

Install rlxbot

sudo appctl install bot

Enable and start service

systemctl enable rlxbot --user
systemctl start rlxbot --user

Play with bot

start the bot with 'bot' command (of course)

bot

Teach Bot

Of-course, what's the meaning of AI bot if its not learn new things

!learn <quest> : <ans>    # to teach new things

😅 not much good to reply, but its fun, right ? More DATA better response

Learn From data

you can provide data directly to rlxbot as file, rlxbot select random replies to the most nearest query

how are you
- i am fine
- i am ok, and you ?
what are you doing
- eating your ram
- nothing
- something secret

!learnfrom <path/to/datafile>

Enjoy

Steam is a video game digital distribution service by Valve. It was launched as a standalone software client in September 2003 as a way for Valve to provide automatic updates for their games, and expanded to include games from third-party publishers. Wikipedia

To Install steam on rlxos you need to have flatpak installed into you system, if not please follow the guide

Installing Steam via flatpak

sudo flatpak install com.valvesoftware.Steam

Lauch Steam

You can launch steam either by flatpak

flatpak run com.valvesoftware.Steam

or from All apps

Enjoy