Back to Blog

Running Atomic Linux on Framework 16 with Bazzite

My experience running Bazzite, an immutable Fedora-based OS, on a Framework 16 laptop for development and systems work.

LinuxBazziteFrameworkFedora

When I got my Framework 16, I had a choice to make about the operating system. After years of using traditional mutable Linux distributions, I decided to try something different: Bazzite, an immutable Fedora-based distribution built on rpm-ostree.

The experience taught me a lot about where Linux is heading and how atomic systems change the way you think about your workstation.

What Is Atomic Linux

Traditional Linux distributions let you modify the base system freely. Install packages with apt or dnf, change system files, and the OS accumulates state over time. This is flexible but can lead to drift—two machines with the same base install might behave differently after months of updates and modifications.

Atomic (or immutable) distributions take a different approach:

  • The base system is read-only
  • Updates are atomic: you boot into a new version or stay on the old one
  • System modifications happen through layering, not mutation
  • Applications run in containers or sandboxes

Bazzite applies this model to a gaming and productivity-focused desktop, built on Fedora's atomic foundations.

Why Bazzite on Framework

The Framework 16 is designed for Linux. Drivers work out of the box, the hardware is documented, and the community is active. Bazzite specifically targets the hardware enthusiast and gaming crowd, making it a natural fit.

What attracted me:

  • Stability: Atomic updates mean broken updates don't break my system
  • Rollback: If something goes wrong, I boot the previous deployment
  • Gaming support: Built-in Steam, Proton, and driver optimization
  • Modern desktop: GNOME or KDE with current packages

The Workflow Shift

Using an atomic system requires adjusting how you think about your workstation.

Package Management

You can't just dnf install whatever you want. Instead:

  • Layered packages: Use rpm-ostree install for system-level packages
  • Flatpak: Most desktop applications come from Flatpak
  • Containers: Development tools run in Distrobox or Toolbx containers
  • Bottles: Windows applications work through Bottles

At first, this felt limiting. But I realized it enforces good hygiene—system changes are intentional and documented.

Development Environment

My development tools live in containers. I run a Fedora or Ubuntu container through Distrobox that has all my language runtimes, compilers, and CLI tools. The container is mutable, so I can install whatever I need, but it's isolated from the base system.

This separation has benefits:

  • Multiple environments for different projects
  • The base system stays clean
  • I can destroy and recreate development environments without affecting anything else

Updates and Rollback

Updates work differently than traditional distros:

  1. rpm-ostree upgrade downloads the new image
  2. Reboot to activate the new deployment
  3. Previous deployment remains available for rollback

If an update breaks something, I select the previous deployment at boot and I'm back to a working system. No debugging, no restoring from backup, just boot the known-good version.

Hardware Experience

The Framework 16 runs well on Bazzite:

Performance

The AMD GPU drivers work out of the box. Gaming performance is solid, and the system handles my development workload without issues.

Power Management

Battery life is reasonable for a laptop of this size and capability. Suspend and resume work reliably—something that hasn't always been true for Linux laptops.

Hardware Monitoring

I monitor thermals and system health through standard Linux tools. The Framework's modularity means I can see fan curves and component temperatures clearly.

Lessons Learned

Running an atomic Linux system taught me:

  1. Immutability is a feature, not a limitation - Constraints force better practices
  2. Containers are the right model for development - Isolation and reproducibility over convenience
  3. Rollback capability is underrated - The confidence to update without fear is valuable
  4. Modern Linux desktops work - Gaming, productivity, development—it all works

The Trade-Offs

Atomic systems aren't for everyone:

  • Learning curve: Different mental model than traditional Linux
  • Package availability: Not everything is on Flatpak; some layering required
  • Disk space: Multiple deployments consume more storage
  • Niche tools: Very specialized software might require workarounds

For my use case—development, systems administration, and occasional gaming—Bazzite on Framework 16 is an excellent combination.

Looking Forward

The atomic Linux model feels like the future. The stability, rollback capability, and clean separation between system and applications solve real problems that traditional distributions struggle with.

If you're building a new workstation and want to try something modern, consider an atomic distribution. The workflow adjustments pay off in reliability and maintainability.