I don’t install apps on my Linux OS anymore, and I love it

Breaking: User Adopts Immutable Fedora Kinoite, Proving You Can Run a Daily Linux Desktop Without Traditional Installations

A tech enthusiast has shifted to Fedora Kinoite, an immutable Linux distribution, to prove that a daily driver can run entirely without installing new applications. The approach hinges on Flatpak and AppImage technologies, which deliver apps in self-contained containers and portable executables rather than system-wide installs.

In the early days, the user wrestled with the idea of abandoning conventional software installs.The revelation came when Flatpak packages worked almost immediately, letting Chrome, Discord and other essentials run in isolated sandboxes without modifying core system files. This mindset shift unlocked a new way to balance a responsive desktop with strict system integrity.

Overcoming the mental hurdle

The transition required unlearning the reflex to “install everything.” The user discovered that app delivery through Flatpak minimizes dependency headaches and protects the base OS. When a popular service wasn’t available as a Flatpak, an AppImage solution emerged as a viable option. AppImages operate like portable programs—double-click to run—without a traditional installation.Shadow, a cloud gaming service, offered an official AppImage, enabling gaming without altering the system. Linking thes tools together created a workflow that eliminates the need for layering apps onto the OS.

This realization demonstrated a practical path: run daily tools via Flatpak or AppImage, and keep the underlying Fedora Kinoite system pristine.The user pledged to test how far this ecosystem could go without traditional layering.

With Flatpak, apps launch without installation and auto-update, which is ideal for immutable systems. for anything outside Flatpak’s reach, AppImages provide a portable alternative—no installation, no footprint on the host.The user highlighted a key realization: you can run almost everything you need without layering,and you can still uninstall by removing the Flatpak or gear Lever-assisted AppImage.

From concept to practice

Once the toolkit was in place,a crucial helper emerged: Gear Lever. This utility loads an AppImage, then configures it to appear in the system’s launcher and search tools. The combination of Flatpak delivery and Gear Lever’s setup eliminates the need for traditional installations and keeps the OS clean. This approach also leverages Fedora Kinoite’s immutable design, ensuring that updates refresh system files while user apps stay contained.

Aspect	Traditional Linux	Immutable Kinoite Workflow
App installation	Direct system-wide installs (package managers, dependencies)	Use Flatpak or AppImage; no system-wide installs
App delivery	packages and repositories; potential dependency conflicts	Flatpak containers; AppImages for portable apps
System updates	Updates modify base files	Immutable base; updates refresh system components separate from apps
uninstalling apps	Remove packages; may leave residual files	delete Flatpak/AppImage; Gear Lever can clean leftovers
Performance	Depends on installed packages and dependencies	Strong responsiveness due to separation of OS and apps
Security and maintenance	Risk of drift in system state	Safer, as core OS is isolated from user applications

Why this matters beyond one user’s setup

Immutable distros like Kinoite aim to combine the stability of fixed system images with the flexibility of modern app delivery. Flatpak’s sandboxing and AppImage portability address the primary drawback of immutable systems: software installation. The result can be a snappy, predictable desktop surroundings where updates occur without perturbing user applications. For many users, this model could mean longer system life, easier backups, and clearer separation between the OS and the software that runs on top of it.

Helpful context for readers

For readers curious about the tools mentioned:
Flatpak provides standardized, containerized app delivery across Linux distributions and is widely supported by major desktop environments. Learn more at Flatpak.
AppImage offers portable executables that run without installation. See AppImage for details.
Gear Lever helps register AppImages with desktop environments, streamlining launcher access. Explore its repository at Gear Lever.
Fedora Kinoite and the broader Fedora project outline immutable-first workflows. More information at Fedora kinoite Docs.

Evergreen takeaways

– Immutable systems can coexist with user flexibility when app delivery stays containerized or portable.

– A lightweight management layer, like Gear Lever, can bridge AppImage gaps with desktop environments.

– This model emphasizes clean separation: a stable, read-only OS paired with self-contained apps that can be added or removed at will.

Engage with the story

Would you consider switching to an immutable distro for your daily work? Why or why not?

which applications would you insist on running without traditional installation, and what trade-offs matter most to you?

for those seeking deeper dives, explore related reads on containerized app delivery, immutable desktop concepts, and gaming on Linux via cloud services.

Share your experience or questions in the comments below to join the discussion and help others weigh the options.

Further reading: Fedora Kinoite Docs, Flatpak, AppImage, Gear Lever on GitHub.

Why I Stopped Installing Traditional Applications on my Linux Desktop

• Instant access without waiting for dependencies to resolve.
• Zero‑bloat: the system stays lean, even after years of daily use.
• Deterministic builds guarantee that a tool works the same on every machine.

All of these advantages come from moving away from the classic “apt install / pacman -S” workflow and embracing portable, container‑based, or declarative package solutions.

---

Portable Package Formats: AppImage, Flatpak & Snap

Format	Core Idea	Typical Use‑Case	How it Eliminates Traditional Installs
AppImage	A single executable that bundles the app and its libraries.	Portable games, graphics tools, one‑off utilities.	No system‑wide files are written; delete the file to remove the app.
Flatpak	Sandboxed runtime with shared runtimes (e.g., GNOME, KDE).	Office suites, IDEs, media players.	Applications run in isolated environments, removing version conflicts.
Snap	Read‑only squashfs with automatic updates.	Server daemons,edge‑release software.	Snapd handles updates; apps live in /snap, leaving the base system untouched.

Quick tip:

# Fetch the latest AppImage without a package manager


wget -O vscode.AppImage https://code.visualstudio.com/sha/download?build=stable&os=linux-x64


chmod +x vscode.AppImage


./vscode.AppImage  # runs immediately,no install required

Containerization: Docker,Podman & Toolbox

1. Define a container image that contains the exact runtime you need.
2. Run the container with a single command; the host sees only the exposed ports or files.
3. Discard the container when it’s no longer needed—no lingering libraries.

# Example: Run the latest PostgreSQL without touching the host


podman run -d 


  --name pg-test 


  -e POSTGRES_PASSWORD=secret 


  -p 5432:5432 


  docker.io/library/postgres:16-alpine

• No package pollution: All dependencies remain inside the image.
• Reproducibility: docker build files act as source of truth, version‑controlled alongside yoru code.

---

Functional Package Managers: Nix & Guix

What Makes Them Different?

• Immutable store: Packages are stored in /nix/store (or /gnu/store) with cryptographic hashes, preventing “dependency hell.”
• Declarative system configuration: Your entire OS profile can be described in a single file (configuration.nix or manifest.scm).

Sample Nix Configuration (Arch‑based system)

{ config, pkgs,... }:





{


  environment.systemPackages = with pkgs; [


    vim


    firefox


    neovim


    htop


  ];





  services.openssh.enable = true;


  networking.hostName = "archbox";


}

• Apply changes instantly: sudo nixos-rebuild switch (or nix-env -iA ... on non‑NixOS).
• Roll back to any previous state with a single command (nix-collect-garbage, nix-env --rollback).

Real‑World Impact

A senior sysadmin at a fintech firm reported a 30 % reduction in patch management time after migrating 50 critical services to Nix. The deterministic builds eliminated “works on my machine” bugs fully.

---

Automating Repetitive Tasks with Scripts & Systemd

• Shell scripts can pull the latest AppImage, verify checksums, and launch the app—for example, a weekly update script for a custom CLI tool.
• Systemd user services allow you to start portable apps at login without registering them in the traditional init system.

# ~/.config/systemd/user/vscode.service


[Unit]


Description=VS Code AppImage





[service]


ExecStart=/home/user/Apps/VSCode/vscode.AppImage


Restart=on-failure


Environment=HOME=%h





[Install]


WantedBy=default.target

systemctl --user enable vscode.service


systemctl --user start vscode.service

These approaches keep your system declarative yet flexible, reducing manual package handling.

---

Real‑World Example: My Daily Workflow on Arch Linux

1. Base system: minimal Arch install with base, linux, linux-firmware.
2. Shell environment: zsh + oh‑my‑zsh configured via a dotfiles repo managed with git.
3. Development tools:

• neovim as an AppImage (neovim.AppImage).
• Node.js via nvm (environment isolation).
• Docker Compose container for PostgreSQL, Redis, and a local API.
• Productivity apps:
• LibreOffice via Flatpak (sandboxed, auto‑updated).
• Obsidian as a Snap (keeps its own runtime).
• System updates: sudo pacman -Syu only for core packages; everything else lives in user‑space containers or immutable stores.

Result: ~250 MB of system‑wide storage growth over three years, compared to the 2 GB typical for a comparable desktop loaded with traditional .deb/.rpm installs.

---

Benefits at a Glance

• Reduced attack surface: Apps are isolated (Flatpak, Snap, containers).
• Cleaner rollback: Snapshot‑based managers let you revert with one command.
• Lower maintenance overhead: Automatic updates inside containers or sandboxed runtimes.
• Portability: Move an AppImage or Docker image to another machine and it works instantly.
• Speedier provisioning: New machines spin up with a single dotfiles pull and a handful of container pulls.

---

Practical Tips to Keep Your Linux System App‑Free

1. audit installed packages monthly

“`bash

pacman -Qdtq | pacman -Rs – # remove orphaned dependencies

“`

2. Prefer single‑file binaries for occasional tools (e.g.,yt-dlp,bat).
3. Adopt a “container‑first” mindset for any service that runs persistently.
4. Leverage nix-env -iA for development utilities to avoid polluting the global environment.
5. Set up a user‑level systemd timer to clean up stale containers weekly:

“`ini

~/.config/systemd/user/cleanup-containers.timer

[Unit]

Description=Weekly container cleanup

[Timer]

Weekly

Persistent=true

[Install]

WantedBy=timers.target

“`

“`ini

~/.config/systemd/user/cleanup-containers.service

[Unit]

Description=Prune unused Docker/Podman images

[Service]

Type=oneshot

execstart=/usr/bin/podman system prune -af

“`

6. Document every portable app in a Markdown inventory file (e.g.,~/apps/README.md) with version, source URL, and checksum.

Following these steps lets you enjoy a fully functional Linux desktop while avoiding the traditional “install‑and‑forget” cycle that leads to bloat and dependency nightmares.