Install KISS

The installation is very similar to Gentoo’s stage 3 tarballs.

An archive is used which contains a full KISS system minus the boot-loader and kernel. The provided archive contains all of the tooling needed to rebuild itself as well as the remaining packages needed for an installation.

You will need an existing Linux distribution to use as a base for the installation. It does not matter what kind of distribution it is nor does it matter what libc it uses.

For the purpose of this guide I will be using another Linux distribution’s live-CD to bootstrap KISS. The live-CD must include tar (with xz support), mountpoint and other basic utilities.

From this point on, the guide assumes you have booted a live-CD and have an internet connection.


Setting up disks

Get the disks ready for the installation. This involves creating a partition table, partitions and the desired file-systems. This step will differ depending on whether or not you are doing a BIOS or UEFI installation.

The guide will not cover this step. If you require assistance with this step; read one of the links below. This step is not unique to KISS and there are tried and tested resources for all kinds of disk layouts online.

Install KISS

Your disks should be setup and fully mounted to /mnt.

Download the latest release

The download link below will always point to the latest version of KISS. If the checksums or signature fail to verify, contact me.

-> wget

This step verifies that the release matches the checksums generated upon its creation and also ensures that the download completed successfully. (What are checksums?)

-> wget
-> sha256sum kiss-chroot.tar.xz | diff kiss-chroot.tar.xz.sha256 - && echo good

This step verifies that the release was signed by Dylan Araps. If the live OS of your choice does not include gpg, this step can also be done on another machine. (What is gpg?)

-> wget

# Import my public key.
-> gpg --keyserver --recv-key 46D62DD9F1DE636E

# Verify the signature.
-> gpg --verify kiss-chroot.tar.xz.asc kiss-chroot.tar.xz

Download the chroot helper

This is a simple script to chroot into /mnt and set up the environment for the rest of the installation. (What is chroot?)

-> wget

# Inspect the script before you execute it below.
-> vi kiss-chroot

# Ensure the script is executable.
-> chmod +x kiss-chroot

Unpack the tarball

This step effectively installs KISS to /mnt. The tarball contains a full system minus the bootloader, kernel and optional utilities.

-> tar xvf kiss-chroot.tar.xz -C /mnt --strip-components 1

Enter the chroot

On execution of this step you will be running KISS! The next steps involve the kernel, software compilation and system setup.

-> ./kiss-chroot /mnt

Enable repository signing

This step is entirely optional and can also be done after the installation. See #60 for more information.

Repository signing ensures that all updates have been signed by (Dylan Araps) and further prevents any unsigned updates from reaching your system.

Build and install gnupg1

Welcome to the KISS package manager! These two commands are how individual packages are built and installed on a KISS system.

-> kiss build gnupg1
-> kiss install gnupg1

Import my (Dylan Araps) key

If the GNU keyserver fails on your network, you can try an alternative mirror ( for example).

# Import my public key.
-> gpg --keyserver --recv-key 46D62DD9F1DE636E

# Trust my public key.
-> echo trusted-key 0x46d62dd9f1de636e >> /root/.gnupg/gpg.conf

Enable signature verification

Repository signature verification uses a feature built into git itself (merge.verifySignatures)! (How does it work?)

This can be disabled at any time using the inverse of the git command below.

The same steps can also be followed with 3rd-party repositories if the owner signs their commits.

-> cd /var/db/kiss/repo
-> git config merge.verifySignatures true

Rebuild KISS

This step is entirely optional and you can just use the supplied binaries from the downloaded chroot. This step can also be done after the installation.

Modify compiler options (optional)

These options have been tested and work with every package in the repositories. If you’d like to play it safe, use -O2 or -Os instead of -O3.

If your system has a low amount of memory, omit -pipe. This option speeds up compilation but may use more memory.

If you intend to transfer packages between machines, omit -march=native. This option tells the compiler to use optimizations unique to your processor’s architecture.

The -jX option should match the number of CPU cores available. You can optionally omit this, however builds will then be limited to a single core.

# NOTE: The 'O' in '-O3' is the letter O and NOT 0 (ZERO).
-> export CFLAGS="-O3 -pipe -march=native"
-> export CXXFLAGS="-O3 -pipe -march=native"

# NOTE: '4' should be changed to match the number of CPU cores.
-> export MAKEFLAGS="-j4"

Update all base packages to the latest versions

This is how updates are performed on a KISS system. This command uses git to pull down changes from all enabled repositories and will then optionally handle the build/install process.

-> kiss update

Rebuild all packages

Running kiss build without specifying packages will start a rebuild of all installed packages on the system.

NOTE: The package manager will prompt for user input on completion before installing the build packages.

-> kiss build

Userspace tools

Each kiss action (build, install, etc) has a shorthand alias. From now on, kiss b and kiss i will be used in place of kiss build and kiss install.


# Ext2, Ext3 and Ext4.
-> kiss b e2fsprogs
-> kiss i e2fsprogs

# Open an issue for additional filesystem support.
# Additional filesystems will go here.

Device management

-> kiss b eudev
-> kiss i eudev

WiFi (optional)

-> kiss b wpa_supplicant
-> kiss i wpa_supplicant

Dynamic IP addressing (optional)

-> kiss b dhcpcd
-> kiss i dhcpcd

The Kernel

This step involves configuring and building your own Linux kernel. If you have not done this before, below are a few guides to get you started.

The Linux kernel is not managed by the package manager. The kernel is managed manually by the user.

NOTE: KISS does not support booting using an initramfs. When configuring your kernel ensure that all required file-system, disk controller and USB drivers are built with [*] (Yes) and not [m] (Module).

Download the kernel sources

The following commands imply the 5.4 vanilla kernel. If you have chosen a different kernel, the commands are identical minus naming differences.

More kernel releases:

A larger list of kernels can be found on the Arch Wiki.

-> wget

# Extract the kernel sources.
-> tar xvf linux-5.4.tar.xz
-> cd linux-5.4

Download firmware blobs (if required)

To keep the KISS repositories entirely FOSS, the proprietary kernel firmware is omitted. This also makes sense as the kernel itself is manually managed by the user.

NOTE: This step is only required if your hardware utilizes these drivers.


# Download and extract the firmware.
-> wget
-> tar xvf linux-firmware-20191022.tar.gz

# Copy the required drivers to '/usr/lib/firmware'.
mkdir -p /usr/lib/firmware
cp -R ./path/to/driver /usr/lib/firmware

Configure the kernel

You can determine which drivers you need by searching the web for your hardware and the Linux kernel.

NOTE: If you require firmware blobs, the drivers you enable must be enabled as [m] (modules). You can also optionally include the firmware in the kernel itself.

# Generate a default config with *most* drivers
# compiled as `[*]` (not modules).
-> make defconfig

# Open an interactive menu to edit the generated
# config, enabling anything extra you may need.
# NOTE: You may need 'ncurses' to run 'menuconfig'.
#       Run 'kiss b ncurses && kiss i ncurses'.
-> make menuconfig

# Store the generated config for reuse later.
-> cp .config /path/to/somewhere

Build the kernel

This may take a while to complete. The compilation time depends on your hardware and kernel configuration.

# '-j $(nproc)' does a parallel build using all cores.
-> make -j "$(nproc)"

Install the kernel

NOTE: Ignore the LILO error, it’s harmless.

# Install the built modules.
# This installs directly to `/lib` (symlink to `/usr/lib`).
-> make modules_install

# Install the built kernel.
# This installs directly to `/boot`.
-> make install

# Rename the kernel.
# Substitute VERSION for the kernel version you have built.
# Example: 'vmlinuz-5.4'
-> mv /boot/vmlinuz /boot/vmlinuz-VERSION
-> mv /boot/ /boot/

The bootloader

The default bootloader is grub (though nothing prevents you from using whatever bootloader you desire).

This bootloader was chosen as most people are familiar with it, both BIOS and UEFI are supported and vast amounts of documentation for it exists.

NOTE: If using UEFI, the efivars filesystem may need to be mounted. See: Mounting UEFI variables

RECOMMENDED: Create an /etc/fstab by UUID and additionally pass the PARTUUID as a kernel parameter.

Build and install grub

-> kiss b grub
-> kiss i grub

# Required for UEFI.
-> kiss b efibootmgr
-> kiss i efibootmgr

Setup grub

-> grub-install --target=i386-pc /dev/sdX
-> grub-mkconfig -o /boot/grub/grub.cfg

# UEFI (replace 'esp' with the EFI mount point).
-> grub-install --target=x86_64-efi --efi-directory=esp --bootloader-id=GRUB
-> grub-mkconfig -o /boot/grub/grub.cfg

Install init scripts

The default init is busybox init (though nothing ties you to it). The below commands install the bootup and shutdown scripts as well as the default inittab config.

Source code:

-> kiss b baseinit
-> kiss i baseinit
-> adduser USERNAME

Enable the community repository

The KISS community repository is maintained by users of the distribution and contains packages which aren’t in the main repositories. This repository is disabled by default as it is not maintained by the KISS developers.

# Clone the repository to a location of your choosing.
-> git clone

# Add the repository to the system-wide 'KISS_PATH'.
# The 'KISS_PATH' variable works exactly like 'PATH'.
# Each repository is split by ':' and is checked in
# the order they're written.
# Add the full path to the repository you cloned
# above.
# NOTE: The subdirectory must also be added.
# Example: export KISS_PATH=/var/db/kiss/repo/core:/var/db/kiss/repo/extra:/var/db/kiss/repo/xorg:/path/to/community/community
-> vi /etc/profile.d/

# Spawn a new login shell to access this repository
# immediately.
-> sh -l

Install Xorg (optional)

To install Xorg, the input drivers and a basic default set of fonts, run the following commands.

-> kiss b xorg-server xinit xf86-input-libinput

# Installing a base font is recommended as Xorg
# and applications require fonts to function.
-> kiss b liberation-fonts
-> kiss i liberation-fonts

Add your user to the relevant groups

NOTE: This groups based permissions model may not be suitable if KISS will be used as a multi-seat system. Further configuration can be done at your own discretion.

# Replace 'USERNAME' with the name of the
# user created above.
-> addgroup USERNAME video
-> addgroup USERNAME input
-> addgroup USERNAME audio

Further steps

You should now be able to reboot into your KISS installation. Typical configuration should follow (hostname, creation of users, service configuration, installing a window manager, terminal etc).

If you encountered any issues, don’t hesitate to open an issue on one of our GitHub repositories, post on the subreddit or join the IRC server.

See: Get in touch See: The Wiki