Runnah

Sovereignty and decentralization

Runnah helps the public to take a step away from large tech monopolies and closer to the Fediverse and alternative decentralized architectures and strategies. It also promotes data ownership at the personal and community level.

Privacy and security

All applications provided by the official Runnah Hub will be packaged with data privacy and security in mind, first. No tracking, no cloud IDs, zero calls back home.

Technology commons and libre software

The purpose of the Runnah Shell is to empower individuals and groups of people. It will therefore always be libre software, free to use and modify.

Resiliency

By allowing non-technical users to run advanced server applications in any device and in different networking configurations - including local networks, Runnah can contribute to the public's resiliency in situations such as natural disasters, lack of connectivity, censorship etc.

Sustainability and accessibility

Runnah can make self-hosting accessible to individuals and groups that might not have that ability otherwise. For example, somebody might not have the funds to pay a large sum per year for a dedicated server, or even access to a central electrical grid or internet connection, but with, for example, solar power, a cheap device and a local network could provide software for the needs of a small neighborhoud or community.

Simplicity

One of the main objectives of Runnah is to make running containerized applications a breeze for non-technical users. This is reflected in several architectural decisions, such as exposing all runtime settings as simple as a set of key/value pairs that anybody can configure, given basic documentation.

Flexibility

Users should be able to easily personalize their use of each application without restrictions. This should apply to all application runtime settings such as file system and other permissions, capabilities, networking etc. so that the applications can be run in different ways depending on the intended purpose e.g. run it just as a local application, expose it to your LAN, or publicly to the internet or in a VPN.

Portability

Runnah should be available on as many operating systems and devices as possible. It should be installable on all Linux, BSD, MacOS and Windows systems, and in theory even on Android. It is not intended only for use in home servers; users should be able to run it anywhere, even on mobile devices. Initial efforts focus on Linux and BSD systems though. Support for proprietary systems will be left for the community, as deman arises.

Runnah supports application templates. An application provider can define multiple templates for the same application. For example:

stalwart/personal

A small mail server for personal use with minimizing complexity and resource consumption in mind e.g. using RocksDB for all stores.

stalwart/team

A full mail server for more users configured with advanced functionality in mind e.g. using FoundationDB as the main data store, Redis as the cache store, and Elastic Search as the search engine.

wiki.js/mobile

A minimal installation of Wiki JS for personal use on mobile devices. That is, optimized for lower disk space, CPU and memory constraints, background jobs disabled etc.

wiki.js/team

A full installation of Wiki JS intended to run as a server for the frontend app, which is accessible to multiple users via a VPN.

Running multiple instances of the same application is a breeze with Runnah. Just run the runnah create command with a different instance ID than the existing installation, or add it to a different group.

This allows, for example, running an instance of LibreWolf to use specifically for internet banking, and another one for all your social media activities. Essentially, Firefox containers applied to the browser of your choice without installing an add on, and with the ability to run it with a different profile, theme and preferences for each instance.

Runnah provides an additional organizational level for grouping together applications. For example, a user can have a set of applications installed in a personal group, another set installed in a family group configured to be available on the LAN, and another in a work group configured to be accessible to a team of co-workers from anywhere via a VPN.

Runnah uses Podman, an open source container runtime. It is a drop-in replacement for Docker. It supports Pods, making it a lightweight alternative to Kubernetes and related, cloud-focused technologies. Runnah contains each application to its own pod by default, providing filesystem and network isolation from other applications - unless specifically requested otherwise by the user.

Using Restic, Runnah supports automatically backing up and restoring all persistent application data with minimal configuration required from the user i.e. destination storage. Restic gives easy access to encryption, deduplication, support for multiple local and remote storage types, and other advanced features for power users.

Runnah supports defining different runtime contexts for an application. Contexts are sets of runtime settings that determine how the application is run. For example, which folders and files it has access to, whether it is allowed to reach out to the internet or to communicate with other apps, etc. The same application can be run in different contexts as desired. For example, the default context might deny internet access to an application, but in a particular instance the application can be run in a context that allows internet access in order to execute a specific task.

All Runnah settings that provide the application context and determine various runtime options are configured as environment variables, taking advantage of their simplicity, flexibility and portability. Being simple key/value pairs - instead of structured Docker/Podman Compose YAML files or complex Kubernetes Helm Charts, they:

• make application packaging simpler for developers.
• make configuration approachable to non-technical users.
• make it easy to expose a user interface for editing.
• support different ways of defining and overriding the environment.

Almost everything in Runnah is managed via enironment variables, making most customizations as simple as editing key/value pairs.

You may want to run a "light" packaged version of Nextcloud for your personal use running locally, and the default version exposed via a VPN for your family or team.

# ~/.runnah/nextcloud/runnah.env
TEMPLATE=nextcloud/light
NETWORKS=_

# ~/.runnah/nextcloud-team/runnah.env
TEMPLATE=nextcloud
VPNS=team_vpn

Runnah Shell is the CLI application that runs all operations, such as installing and running an application, taking backups etc. It is where most of the development focuses on.

The Runnah Hub is the official collection of application templates, kind of an app store.

Flatpak is a great solution for sandboxing and distributing "desktop applications". The Flatpak model has in some ways influenced the direction that Runnah intends to go in its next sptes.

Flatpak is not designed for running "server applications" with multiple components isolated in containers yet communicating with each other. That is, you cannot run a NextCloud frontend (browser or electron-based application), the backend PHP application and a Solr search engine, in a Flatpak. You also cannot expose them as a service to your LAN or VPN, nor does it support any of the features outlined in the Features section (and more) due to the limitations of its design, objectives, and technologies used.

Olares is a collection of open source programs bundled together to create an operating system ready to install for self-hosting. It is a great project and it has some similarities in its objectives with Runnah. However, its target audience is the enterprise and buyers of machines with their operating system pre-installed.

This is reflected by the fact that they use a very complex architecture and advanced components that are tailored to complex deployments e.g. Kubernetes, Helm Charts etc. To run their CLI you are required to have Node installed on your device, which is also required to meet quite significant resource specifications.

It also seems to come with strings attached: Olares ID i.e. you have to register with their cloud services, and it is developed and advertised as AI-native - which is a direction that Runnah has intentionally avoided (see section on large language models).

It may be an option for the small/medium enterprise that requires more reliability (and when they don't mind being restricted to the particular operating system and cloud provider), but it is unnecessary complicated for the non-technical audience that Runnah is designed for.

As a user:

• I want to deploy a simple Wiki JS or LinkWarden application without needing to deploy Node and a Kubernetes cluster - and be tied to commercial support when things go wrong.
• I want minimal resource consumption by the container orchestration system so that I can have more resources for my applications to run - especially on low-spec devices including mobile.

As a developer:

• I want a simple way to package my applications without having to understand Helm Charts.
• I want the ability to install on any device/operating system without having to spend countless hours trying to understand the Olares architecture and individual components - only to risk regressions in the next update on unsupported systems.

Self Privacy is a NixOS configuration/installer for self-hosting on the cloud, coupled with a management application. It is restricted to a specific operating system (with its strengths and weaknesses), it runs on the cloud with support for limited number of hosting providers, and it only provides a few server applications. Runnah is designed from the ground up to provide full freedom: install on any operating system, run on any device, at home or on the cloud, and it can run any application that runs in containers - which is the majority of all server applications out there. Runnah can be used for self-hosting locally or publicly, or just to run applications for personal use - like Flatpak does.

UmbrelOS is a couple of frontend apps written in TypeScript packaged as an operating system. Its backend is really just Docker Compose. These mean that you cannot easily install it in your system - you rather have to install their operating system, and it does not provide the additional layers and operations that the Runnah Shell does - as described in the Features and CLI Reference section, and more.

These are tools tailored mostly to software developers, so that they can define the application templates and runtime settings. Runnah provides the extra layers required to reach non-technical users. Support for a format like Docker Compose or even Helm Charts could be added to Runnah to facilitate more complex applications and setups. That is, they have different objectives, they operate at different levels, and they could work hand-in-hand.

However, after years of using Runnah for professional software development and self-hosting, no significant limitations have been reached yet, and such integrations are currently not the priority. The environment variable-based system that Runnah uses needs to be in the core of the mechanism to achieve the design objectives of simplicity, flexibility and portability.