Welcome to 2026: Building, Breaking, and Learning in the Saloon!

2026 Einstein's Saloon Building a Proxmox Cluster

Welcome, 2026! This year I’m going to get my hands a little dirtier by shifting from theory-heavy exploration into something more concrete: real hardware, real experiments, real mistakes—and the lessons that come from all of it.

This year started with three repurposed Lenovo 720q Tiny PCs. They’re not new; in fact, they’re e-waste from my job, since they’re too old to upgrade to Windows 11. But they are more than capable of becoming something useful! 

So I did what any Linux enthusiast with curiosity and a desire to set up a home lab would do. I turned them into a Proxmox cluster.

Why a Proxmox Cluster?

I’ve written about Linux systems from the perspective of a daily driver: desktops, workflows, tools, and configuration. But increasingly, my curiosity has shifted more towards infrastructure—how systems run behind the scenes.

Proxmox sits at an interesting intersection:

  • Linux-based
  • Open source
  • Widely used in homelabs and
  • Powerful enough to do real work

Rather than reading about Proxmox in the abstract, I wanted to learn it the only way that really sticks: by building something real and seeing what breaks.

The Cluster: Small Machines, Big Lessons

The cluster itself is modest:

  • Three Lenovo 720q Tiny PCs
  • Repurposed hardware instead of new purchases
  • Low-power draw
  • Quiet enough to live outside a data center
  • Just complex enough to be educational 

I plan to write about

  • Initial setup and configuration decisions
  • Storage choices and mistakes
  • Networking confusion
  • Clustering quirks
  • Backup strategies
  • Updates that go smoothly—and the ones that don’t
  • Things I wish I’d known earlier 

This won’t be a polished “how-to guide from an expert.”
It will be a learning journal—documenting what works, what doesn’t, and why.

Learning Proxmox the Honest Way

There’s a lot of Proxmox content online. Much of it assumes:

  • Prior virtualization experience
  • Comfort with enterprise terminology
  • A willingness to gloss over mistakes

That’s not how I learn, and it’s not how I want to write.

This year at Einstein’s Saloon, you’ll see:

  • Incremental progress
  • Honest missteps
  • Configuration experiments
  • Rebuilds
  • Revisions
  • “I broke this, and here’s what I learned” posts. 

If you’re curious about Proxmox but intimidated by it, this series is for you.

Expanding the Scope: 3D Printing Joins the Saloon

Alongside virtualization, another hands-on tool has become a bigger part of my daily tech life: 3D printing.

While it may not look like traditional Linux territory at first glance, 3D printing fits naturally into the same mindset:

  • Open-source software
  • Tinkering and iteration
  • Hardware meets software
  • Learning by doing
  • Solving real problems with tools you control 

In 2026, I’ll be writing about:

  • How I’m using my 3D printers
  • Practical projects
  • Lessons learned from failed prints
  • Workflow tweaks
  • 3D modeling
  • How open-source tools fit into the process
  • Why 3D printing isn’t just a novelty

I won’t be writing about flashy figurines, but about useful, repeatable outcomes—the same philosophy that drives everything else here.

What Einstein’s Saloon Will Be in 2026

This year, the site will lean into:

  • Real systems, not hypotheticals
  • Learning in public
  • Repurposing hardware
  • Open-source infrastructure
  • Practical experimentation
  • Honest documentation 

Less “perfect setups” and more “here’s what actually happened.”

Einstein’s Saloon remains the genius bar for the free and open-source community, but in 2026, the genius will look a little messier.

Looking Ahead

If you’re interested in

  • Proxmox without the enterprise gloss
  • Building useful systems from leftover hardware
  • Watching someone learn infrastructure from the ground up
  • Practical Linux-adjacent projects
  • 3D printing with purpose 

Then you’re in the right place.

Pull up a stool; let’s build, break, and learn together in 2026!

Why NixOS Is the Most Important Linux Distro You Haven’t Mastered Yet

[![NixOS Icon](/wp-content/uploads/2025/11/NixOS-Icon-02.png){.alignleft}](/wp-content/uploads/2025/11/NixOS-Icon-02.png)

For years, Linux enthusiasts, **including myself**, have chased the “perfect distro.” Some want stability. Some want bleeding-edge packages. Some want reproducibility. And some—let’s be honest—just want something cool to tinker with at 2 a.m.

But **NixOS** quietly sidesteps this entire debate. It doesn’t compete with Ubuntu, Fedora, or Arch in the traditional sense. Instead, it **redefines what a Linux distribution can be**. We warned, **NixOS does have a steep learning curve**, but if you haven’t tried it, you’re missing one of the most transformative distros in modern computing.

## A Paradigm Shift, Not a Distro Hop

Most distributions configure the system through a web of package managers, shell scripts, and config files. NixOS ignores all of that and says: *”What if your entire system was a single, declarative, version-controlled document?”*

With NixOS, your system _is_ code. Not metaphorically, but literally. One file (*configuration.nix*, or a *flake*) describes:

– Installed software
– System services
– Users and groups
– Networking
– Hardware support
– Desktop environment
– Custom system tweaks

Change the file → rebuild the system → done.
If you can manage a Git repo, you can manage your entire OS.

## Reproducibility: The Superpower Other Distros Wish They Had

Imagine the following scenario: You set up the perfect workstation, terminal tools, development environments, fonts, and drivers. Then your SSD dies. Typically, you’d spend hours reinstalling.

On NixOS: **Git clone → nixos-rebuild switch → your entire system is back.**
Not just installed packages—the **entire configured system**, down to the kernel modules and systemd services.

## Below are some reasons why NixOS has a cult following among:
– DevOps engineers
– Software developers
– Homelabbers
– HPC folks
– Tinkerers and power users

### The Nix Package Manager

Nix, the package manager behind NixOS, is a beast—beautiful, powerful, and occasionally intimidating.

Here’s why it matters:
#### 1. Atomic upgrades

If an update breaks something, you can roll back your entire system in seconds.
#### 2. Zero dependency hell

Packages are built in isolated environments, so no more:

– Library conflicts
– Version clashes
– ABI breakage
– “This requires Python 3.12, but your system is on 3.11.”

#### 3. Multiple versions of the same software

Need Python 3.10 **and** Python 3.12?
Need two versions of Node?
Want three versions of GCC?

*No problem with Nix.* This flexibility makes NixOS feel like Linux in cheat mode.

## Home Manager: Your Dotfiles, Evolved

If NixOS handles system configuration, **Home Manager** handles user-level configuration—dotfiles, packages, shells, editors, theming, and more.

Home Manager lets you:

– Version-control your dotfiles
– Reproduce them on any machine
– Avoid “dotfile drift” across systems
– Switch between laptops/workstations effortlessly

Example:

home.username = {
programs.zsh.enable = true;
programs.starship.enable = true;
home.packages = [ pkgs.fastfetch pkgs.bat pkgs.exa ];
};

Rebuild → your environment is instantly standardized.

##### Home Manager is so good that even non-NixOS users install it. But on NixOS? It’s a match made in config-management heaven.

## Flakes: The Future of NixOS (and Why You Should Care)

Flakes add:

– Inputs (like package sources)
– Outputs (like your system config)
– Pinning (so updates never surprise you)
– Reproducibility across machines

Example:

nixosConfigurations.nixos = {   system = “x86_64-linux”;   modules = [ ./configuration.nix ]; };

Flakes lets you share your system between machines, maintain multiple configurations, and track changes.

## Why NixOS Feels Like Magic for Power Users

You’ll love NixOS if any of these statements hit home:

– “I want my whole system in Git.”
– “I want to rebuild a machine in 10 minutes.”
– “I’m tired of fixing dependency issues.”
– “I want the same environment on every machine.”
– “I want to understand _exactly_ how my system is built.”

NixOS gives you **control without chaos**, **flexibility without breakage**, and **power without fragility**.

## The Learning Curve: Real but Worth It

NixOS isn’t plug-and-play like **Pop!OS** or **Linux Mint**.

You will have to:

– Read docs
– Learn the Nix language
– Debug your configuration, and
– Occasionally mutter “Why isn’t this service starting?”

But once you get past the initial bump, something flips in your brain. You realize: *”This isn’t just a distro, but a better way to run computers.”*

## So, why haven’t you mastered it yet?

Not because it’s too hard—because it’s too _different_.

It asks you to let go of the old way of managing Linux.

But if you’re a Linux enthusiast, a sysadmin, or anyone who wants a smarter, reproducible, future-proof workflow, then NixOS isn’t just worth learning—it’s essential.

## Final Thoughts

I believe **NixOS** is the most important distro you haven’t mastered yet because it represents the next evolution of Linux use. Declarative systems, reproducibility, atomic upgrades, isolated builds, multiple versions, and Git-managed everything.

NixOS doesn’t just add features; it solves problems other distros have lived with for decades.

If you want a Linux environment that’s efficient, elegant, and engineered for power users, it’s time to give NixOS the attention it deserves.

And as always—welcome to the Saloon. Pull up a stool, grab a coffee, and let’s build your next great Linux system together!