TermOS is a Linux distribution that combines Fedora, Ubuntu and Nix, and also runs Windows, macOS and BSD apps.

The name doesn't mean anything. It's not a terminal OS. TermOS is just a cool name.

Current release: TermOS v0.1, the first release, based on Fedora 45. See CHANGELOG.md for what's in it.

Website: https://developer1-vd.github.io/TermOS/ (the site's source is in docs/).

Every edition is on the releases page. Files over 2 GiB come in parts (.part0, .part1, ...): download them all and join them with cat, as the release notes show.

ARM editions are the same TermOS (Fedora, KDE Plasma, Nix, Distrobox and the TermOS look), minus what only exists for x86-64 PCs: Fedora doesn't build Wine for ARM, so Windows apps need an x86-64 PC, and Darling (macOS apps) is x86-64 only. FEX runs x86-64 Linux programs on ARM instead.

The board image has no installer: write it to an SD card or disk, and the first boot asks for your user name and password (KDE's Plasma Setup):

xz -d TermOS-0.1-aarch64-board.raw.xz

sudo arm-image-installer --image=TermOS-0.1-aarch64-board.raw --media=/dev/sdX --resizefs

(arm-image-installer is Fedora's; Fedora Media Writer or dd work too, without growing the root file system to fill the card.)

On any Linux, iso/flash-board.sh from this repository does the same, straight from the .raw.xz: it writes the image, and with --grow makes the root file system fill the card:

sudo iso/flash-board.sh --grow TermOS-0.1-aarch64-board.raw.xz /dev/sdX

A Raspberry Pi finds its U-Boot inside the image. An Orange Pi loads U-Boot from a fixed place at the start of the card, so it has to be put there when the card is written. flash-board.sh does that when you name the board; the U-Boot comes from the image itself (Fedora's build for that board):

sudo iso/flash-board.sh --grow TermOS-0.1-aarch64-board.raw.xz /dev/sdX orangepi_zero3

"Supported" means Fedora 45 has both the U-Boot and the kernel device tree for the board. The small boards (512 MB to 1 GB of memory) are slow with KDE Plasma: termos-desktop install xfce or lxqt gives them a lighter desktop.

Why Rockchip boards are different: their U-Boot is 9 MB and would overwrite the start of the image's first partition. flash-board.sh refuses to write it and leaves the image intact, rather than produce a card that can't boot. sudo iso/flash-board.sh --list IMAGE shows every board the image has U-Boot for.

The Build ISO workflow checks all of this on every board image: each Allwinner U-Boot fits before the first partition, a too-big one is refused, and with an Orange Pi U-Boot written the partitions are byte-for-byte unchanged and the image still boots. None of it has been tested on an Orange Pi itself yet.

The Dragon boards are Qualcomm boards with UEFI firmware (Radxa's "BIOS") on their own flash chip, which passes the board's device tree to the OS. TermOS boots on them like on a PC:

1. Update the board's firmware to Radxa's latest first (see Radxa's Dragon docs; newer firmware is what generic distributions need).
2. Write the ARM64 ISO to a USB stick, pick it in the firmware's Boot Manager, and choose Start TermOS 0.1 on a Qualcomm board. That entry adds clk_ignore_unused pd_ignore_unused, which Qualcomm boards need, and the installer keeps them on the installed system. Install to the board's NVMe, UFS or eMMC.
3. Or write the board image to a microSD card, UFS module or NVMe drive. Its boot entries don't have those two arguments; if it stops during boot, press e in the GRUB menu, add them to the linux line, and once booted make them permanent:

sudo grubby --update-kernel=ALL --args="clk_ignore_unused pd_ignore_unused"

These boards haven't been tested on hardware with TermOS yet; the ISO and board image are tested in an emulated ARM machine.

The phone edition is different underneath: phones need kernels and drivers made for each phone, which Fedora doesn't have, so it's built on Nura (formerly postmarketOS) with KDE Plasma Mobile, plus TermOS's Matrix wallpaper (phone sizes), termos-fetch (Matrix and termite modes) and the TermOS fortunes. Each phone's file has its image(s) and a FLASHING.txt; log in as termos with the PIN 837667 (TERMOS on a phone keypad) and change it afterwards. Flashing erases the phone. Check the phone's page on the Nura wiki first. Phones marked "testing" in phone/devices.txt work, but with rough edges.

Not possible: iPhones (Apple locks the bootloader, so no Linux runs on them) and the Samsung Galaxy Z Fold series (there's no Linux port for them).

Because Fedora is the base, dnf is the system package manager. Nix and the Ubuntu container are extra layers you can install software from, and they don't replace it.

sudo dnf install htop                    # Fedora (system)
nix profile install nixpkgs#ripgrep      # Nix (per-user, reproducible)
distrobox enter ubuntu -- sudo apt install cowsay   # Ubuntu (container)

TermOS comes with KDE Plasma. termos-desktop adds any of Fedora's other desktops next to it:

termos-desktop

termos-desktop install gnome

Installing a desktop removes nothing and leaves your login screen as it is. To use the new desktop, log out and pick it from the session menu on the login screen; it remembers your choice, and you can switch back the same way. dnf shows what it will download (often 1 to 2 GB) and asks before installing. termos-desktop check NAME only checks that a desktop can be installed. GNOME, Budgie, Cinnamon and MATE get the TermOS wallpaper as their default.

This works on the PC and ARM editions. The phone edition has Plasma Mobile only.

termos-run runs Windows, macOS, BSD, Nix, Ubuntu and Linux apps. It checks what you gave it and sends it to the right place:

termos-run notepad++.exe
termos-run ./SomeTool.app
termos-run ./freebsd-tool --help
termos-run nix:cowsay moo
termos-run github:owner/repo

About macOS: Darling is a compatibility layer for macOS apps, much like Wine is for Windows apps. The TermOS ISO comes with it preinstalled (from the community medzik/darling COPR, since Darling isn't in Fedora's own repos). It's still experimental: command-line tools work best, and most graphical apps don't run yet. If Darling isn't installed, termos-run copies the app to a real Mac and runs it there over SSH. Set TERMOS_MAC_HOST to that Mac's SSH host (default: termos-mac). TermOS doesn't ship a macOS virtual machine, because Apple's license only allows macOS to run on Apple hardware.

About BSD: BSD programs can't run on the Linux kernel. Linux has no compatibility layer for them, so TermOS runs them on a real BSD system in a VM. Create a FreeBSD (or other BSD) guest in virt-manager (preinstalled on the ISO), enable SSH, and set TERMOS_BSD_HOST to its SSH host (default: termos-bsd). Many BSD tools are also packaged for Linux, so check dnf search or nixpkgs first.

About Nix: termos-run nix:<name> runs any package from nixpkgs without installing it, and any flake reference (nixpkgs#hello, github:owner/repo) or local folder with a flake.nix works too. To install Nix on Fedora, see nixos.org/download.

sudo dnf install wine distrobox openssh-clients

TermOS has two logos, and which one you see depends on how you run the system-info tool.

fastfetch, neofetch and termos-fetch all show TermOS's logo, which is green Matrix-style digital rain:

 1   0 1    0   1  0    1
 0 1 1 0  1 1 0 1  1  0 1
 1 0 0 1  0 0 1 0  0  1 1
 0 1   0  1   0 1  1  0 0
 1 0 1 1  0 1 1 0  0  1 0
   1 0 0  1 0   1  1  0 1
 0 0 1 1  0 1 0 0  1    1
 1 1 0    1 0 1 1  0  1 0
 0   1 0  0 1 0    1  0 1
 1 0 0 1    1 1 0  0  1
   1 1 0  1 0   1  1    0
 0     1    0   0     1

Pipe fortune into it and TermOS turns into a termite, and every stat becomes a fortune:

fortune | termos-fetch

        \     /       termite@TermOS
         \___/        -----------------
       .-(o o)-.      OS: You will be fortunate.
      /  `-^-'  \     Host: Beware of low-flying butterflies.
     /|  (___)  |\    Kernel: A closed mouth gathers no foot.
    / |  (   )  | \   Uptime: You will soon meet a termite.
      |  (___)  |     Packages: Today is a good day to compile.
     /   (   )   \    Shell: The bug is in the other file.
    /    (___)    \   Terminal: Nothing is as permanent as a temporary fix.
          ( )         CPU: Your lucky number is 0x1F.
          `-'         Memory: You forgot something. You'll remember later.

The fortunes above are examples. termos-fetch --fortune does the same thing and runs fortune itself. If you pipe in fewer fortunes than there are stats, it gets more from fortune (or repeats yours if fortune isn't installed).

TermOS has its own wallpaper, boot splash and GRUB theme, all green Matrix-style rain behind the TermOS logo.

• Wallpaper: comes in desktop sizes (3840×2160 and 1920×1080) and phone sizes (1440×3200 and 1080×2400). On the ISO it's the default for the KDE desktop and the lock screen, and KDE picks the right size for each screen, including portrait ones. The phone sizes in branding/wallpaper/contents/images/ work as phone wallpapers too.

• Boot splash: a Plymouth theme where the rain keeps falling while the system boots, with a progress bar under the logo and a matching prompt for encrypted disks.

• GRUB theme: the boot menu gets the same look, with the TermOS logo over the rain, a framed green menu and a countdown bar. The theme turns on GRUB's graphical mode and keeps the menu visible for 5 seconds, since Fedora normally hides it.

The images are generated by branding/make-art.py. Run make art to rebuild them after changing it.

To use them on an existing Fedora install:

sudo dnf install plymouth-plugin-script plymouth-plugin-label

sudo make install install-splash

sudo dnf install grub2-tools-extra dejavu-sans-mono-fonts

sudo make install-grub

Then choose TermOS in System Settings → Wallpaper.

TermOS has a few easter eggs hidden around the system. Hint: follow the white rabbit, and don't forget to check the date.

TermOS builds a bootable live ISO from Fedora with a kickstart file (iso/termos.ks.in) and Fedora's livemedia-creator. The live session boots into KDE Plasma. To install TermOS to disk, double-click Install TermOS on the desktop.

TermOS installs with Fedora's own installer, Anaconda, using its web UI (on KDE it runs in Slitherer, a small Qt web view). Double-click Install TermOS on the live desktop. It walks you through language, disks (including encryption) and creating your user, then copies the live system to disk.

Anaconda takes care of the details that make an install boot on any machine: the disk layout (with a BIOS boot partition on BIOS machines and an EFI partition on UEFI ones), boot menu entries that match the installed disk, and SELinux labels. The installed system keeps the TermOS boot splash, GRUB theme, wallpaper, name and preinstalled apps, and the temporary live user isn't copied to it.

Preinstalled on the ISO:

Darling is built by the community, not Fedora. If it can't be installed when the ISO is built, the build carries on without it and prints a warning. To leave it out on purpose, set TERMOS_DARLING=0.

On Fedora:

sudo dnf install lorax anaconda-tui

make iso

On any Linux with Podman or Docker (builds inside a Fedora container):

make iso-container

The ISO is written to build/out/TermOS-<version>-x86_64.iso (for v0.1, TermOS-0.1-x86_64.iso). A build needs root (or a privileged container), about 15 GB of free disk space and a network connection to the Fedora mirrors. The build machine's kernel also needs loop devices and FAT (vfat) support, which normal Fedora installs and GitHub's runners have; some minimal VMs and sandboxes don't, and the build then fails at the mkefiboot step.

TermOS v0.1 is based on Fedora 45. To try a different Fedora release, set TERMOS_RELEASE:

TERMOS_RELEASE=46 make iso-container

To write the ISO to a USB stick, use Fedora Media Writer, or dd (this erases the stick, so double-check the device name):

sudo dd if=build/out/TermOS-0.1-x86_64.iso of=/dev/sdX bs=4M status=progress oflag=sync

You can also build ISOs from GitHub: run the Build ISO workflow from the Actions tab, and it uploads the ISO as a workflow artifact.

The same script builds the ARM editions. The build runs natively, so run it on an ARM64 machine (GitHub's ubuntu-24.04-arm runners work):

TERMOS_ARCH=aarch64 make iso-container

make board

The first writes build/out/TermOS-0.1-aarch64.iso; the second (TERMOS_IMAGE=disk) writes the board image, build/out/TermOS-0.1-aarch64-board.raw.xz. The board image is a 22 GB disk (write it to a 32 GB card or bigger) with an MBR partition table, the Raspberry Pi firmware and U-Boot on its EFI partition, and GRUB.

make phone DEVICE=oneplus-enchilada

phone/build-phone.sh builds one phone's image with Nura's pmbootstrap. It packages TermOS's files as termos-phone, an Alpine package added to Nura's package tree. It runs as a normal user with sudo, on an ARM64 machine, and writes build/out/TermOS-0.1-phone-<codename>.tar.xz. The phone list and each phone's Nura codename are in phone/devices.txt.

Build ISO (Actions tab) builds the editions you pick (all, pc, arm or phones). It installs each live ISO with Anaconda and boots it in QEMU (BIOS and UEFI on x86-64, UEFI on ARM), and boots the board image as it is. With publish, it uploads everything to the release only if all of that passed. Phone images are built, but can't be boot-tested without the phones.

On Fedora (or any Linux):

sudo dnf install fastfetch fortune-mod file

sudo make install

This installs termos-fetch and termos-run to /usr/local/bin and the logos and configs to /usr/local/share/termos. Use PREFIX= to install somewhere else, and sudo make uninstall to remove them.

With Nix:

nix run github:developer1-vd/TermOS

nix profile install github:developer1-vd/TermOS

The Nix package brings fastfetch, fortune and its other helpers with it.

make lint      # bash -n, shellcheck and ksvalidator
make ks        # write the generated kickstart to build/termos.ks
make clean     # remove build/

nix develop opens a shell with the lint tools. CI runs make lint and builds the Nix package on every push.

tests/install-test.sh installs TermOS onto a virtual disk with its installer, Anaconda, running unattended from a kickstart (automatic partitioning, like the web UI's "use the entire disk"). Then it boots the disk in QEMU and passes when the system reaches a login prompt with no failed services:

sudo tests/install-test.sh build/out/lmc-disk-*.img build/itest/disk.img

The first argument is the live system's root filesystem, such as the disk image livemedia-creator leaves in build/out/. An optional fourth argument, bios (the default) or uefi, picks the firmware to install for and boot with; uefi needs a machine that boots with UEFI. On an ARM64 machine it tests the ARM ISO the same way (UEFI only). Given the board image (.raw or .raw.xz) instead, it checks the image and boots it as it is. Run it in a Fedora container or VM; the script's header lists the packages it needs. The Build ISO workflow runs all of these. It tests Anaconda's install engine, not the web UI's screens.

bin/termos-fetch               fetch wrapper (matrix mode / termite mode)
bin/termos-run                 run Windows, macOS, BSD, Nix, Ubuntu or Linux apps
bin/termos-desktop             choose your desktop (GNOME, Xfce, Cinnamon, ...)
branding/desktops/             TermOS wallpaper default for the other desktops
branding/logo-matrix.txt       Matrix logo
branding/logo-termite.txt      termite logo
config/fastfetch/config.jsonc  fastfetch config using the Matrix logo
config/neofetch/config.conf    neofetch config using the Matrix logo
branding/wallpaper/            KDE wallpaper package (desktop + phone sizes)
branding/plymouth/termos/      Plymouth boot splash theme
branding/grub/                 GRUB theme, its install script and a GRUB easter egg
branding/icons/                TermOS logo icon, installed in place of Fedora's logo
branding/os-release/           keeps /etc/os-release branded as TermOS (Fedora's ID kept)
branding/kde/                  KDE defaults (wallpaper, lock screen)
branding/installer/            "Install TermOS" icon on the live desktop
branding/fortune/termos        TermOS fortunes (easter egg)
branding/make-art.py           generates the wallpaper, splash, GRUB and icon images
iso/termos.ks.in               kickstart template for the live ISOs and the ARM board image
iso/build-iso.sh               ISO and board image builder
iso/flash-board.sh             write the board image to a card (with U-Boot for Orange Pi boards)
phone/build-phone.sh           phone edition builder (Nura + Plasma Mobile)
phone/devices.txt              the phones the phone edition is built for
flake.nix                      Nix package, apps and dev shell
docs/                          the GitHub Pages website
tests/install-test.sh          install onto a virtual disk and boot it in QEMU
tests/desktop-test.sh          check every termos-desktop desktop against Fedora
Makefile                       install, iso, board, phone, lint and clean targets
VERSION                        the TermOS version (0.1)
CHANGELOG.md                   what changed in each release
.github/workflows/             CI (lint, Nix build) and the manual build of every edition

TermOS is licensed under the GNU General Public License v3.0. See LICENSE for details.