r/NixOS

So some of you might know I shared a AI written config couple days ago and it turned out to be bad so I decided that I would rewrite on my own .I read about modules and now trying to migrate my config so that it uses modules instead of just splitting code into different files ...

I already have my nixos config that i wrote when i installed nixos for first time, I came across nixos modules
https://wiki.nixos.org/wiki/NixOS_modules
https://youtu.be/vYc6IzKvAJQ?si=zm3yvPqySKOD-_v5

so I moved modules directory which atm only had normal nix function and not really module out of hosts into separate module dir .

however now I am confused on which things should I extract out into a separate module and which not to . kind of like which file to keep where and what things to extract out into separate module .

for example https://github.com/devnchill/dotNix/blob/enhancement/rewrite/modules/os/services/default.nix is file containing almost all of my services, I moved it outside host but now what things should i move out and make modules and what things not to ?

for reference this is how my old/current config looks : https://github.com/devnchill/dotNix
this is how it's lookin now WIP : https://github.com/devnchill/dotNix/tree/enhancement/rewrite

Reminder: SECRETS ARE GIT ENCRYPTED USING GIT CRYPT AND YES I WILL SOON SWITCH TO SOPS.NIX , THAT IS GOAL OF THIS REWRITE TOO ...

The quintessential CI pipeline is a shell script wrapped in YAML, running inside a Docker image that silently changes underneath you. But, as all practitioners of Docker-based CI secretly know, a disturbing number of failures come down to environment variance, not actual bugs. In this talk, we will trace the migration of a real F# and Rust application from GitLab CI through self-hosted Forgejo to Garnix, replacing mutable Docker images with content-addressed derivations, as well as replacing 200 lines of workflow YAML with `nix flake check`. The talk assumes no Nix background, only a passing familiarity with pure functions.

and felt my mind ramping up

Most recently I finally polished setting up disko and preservation onto my system, and honestly i love NixOS so much. I've been using it for about 4 months straight now give or take and I literally cannot imagine using another distro ever again. My config is at a really nice state for me right now and I'm honestly still constantly looking for new things to add to my flake. My flake manages my systems `athena-nixos` (Desktop), `circe-nixos` (Laptop), and `nyx-nixos` (Server/HomeLab) and it's been a dream. The next major thing I may try again is moving to a dendritic layout since it has always looked and sounded super neat, but feels like so much work and refactoring 😭 but maybe one day....

Also obligatory here is my repo config repo :3

https://dawn.wine/foxtrottt/olympus-nixos.git

EDIT: I forgot to include pictures of my desktop! niri + noctalia-shell my beloved.

https://preview.redd.it/2in33hk72e2h1.png?width=3440&format=png&auto=webp&s=576cd1f4748b668dd8cd85eceb0a4fe9dde968cb

https://preview.redd.it/okmyp27a2e2h1.png?width=1318&format=png&auto=webp&s=f96d7653b7101208d02f438b21b18eda24f6204a

The post started as a simple explainer on standardized dev environments and turned into something more interesting: a direct comparison between how containers and Nix-style environments actually achieve (or don't achieve) reproducibility.

The short version: containers correlate isolation with reproducibility, but they're not the same thing. A Dockerfile is a procedural recipe that calls out to mutable external systems. Package indexes, install scripts, base image tags. node:22 is a mutable reference. The practical unit of reproducibility ends up being the digest-pinned image, not the Dockerfile that produces it.

Nix, Guix, and Flox approach it differently. Reproducibility is a function of the declared input graph, the lockfile, and the realized store closure. Running flox activate or nix develop against the same definition realizes the same cryptographically-hashed store paths, on any machine, at any time.

To make this concrete, we built the same Python 3.14 + Node.js 25 dev environment four ways: Dockerfile, Guix manifest, Nix flake, and Flox manifest, then walked through how each one resolves (or doesn't) to a reproducible output. The Nix flake and Flox sections include the actual flake.nix and manifest.toml, along with the lockfile behavior.

(Disclosure: this is the Flox account)

I wanted to try something timely instead of configuring Neovim or other typical nix activities, so I ended up vibe nixing.

I have to say I'm not taken by it, but also impressed.
NixOS can just spin up fully configured services, point to an LLM locally, setup bridges etc etc. 1 prompt, 1 rebuild command.

If you have some old laptop or mini PC lying around, I highly recommend trying it out.

I added this module to my nixos configuration:

{ nixpkgs, pkgs, lib, ...}:
let upstreamRegistry = pkgs.fetchurl {
  url = "https://raw.githubusercontent.com/NixOS/flake-registry/refs/heads/master/flake-registry.json";
  hash = "sha256-e56aGI09taupUuZbn3ocfEe4EyOWjWwr/sl8oByiBIw=";
};
upstreamRegistryNix = builtins.fromJSON (builtins.readFile upstreamRegistry); in
{
  nix.settings.flake-registry = pkgs.writeText "registry.json" ( builtins.toJSON {
    version = upstreamRegistryNix.version;
    flakes = upstreamRegistryNix.flakes ++ [ 
      { exact = true;
      from.id = "local-nixpkgs";
        from.type = "indirect";
        to = {
          type = "path";
          path = nixpkgs.outPath;
        } // lib.filterAttrs (n: _: n == "lastModified" || n == "rev" || n == "narHash") nixpkgs;
      }
    ]; });
}

Now I can use:

inputs.nixpkgs.url = "flake:nixpkgs-local"

for building my profile and have my profile use the same version of nixpkgs as my system. Someday someone will make a convincing argument to me why having flakes stop accepting the system registry entries was a Good Thing (surely lockfiles are sufficient?), but until then, I will work around it.

I have a Dell Wyse 5010 with 2GB RAM and 8GB storage, and I intend to run it as a PiHole.

However, I would also prefer to have my entire homelab in a Nix flake.

Is this possible, or is 2GB/8GB just too little? I'm happy to actually build everything on my main PC.

When using the new Steam Controller, Steam will try to check whether a firmware update is available every time the controller is turned on, plugged in, or Steam is started, and on NixOS (and other distros), it'll fail every time.

The issue is that the Steam client uses hidapi for this communication, which isn't installed by default. Here's the fix, if you don't already have hidapi installed in systemPackages:

programs.steam = {
  enable = true;
  extraPackages = [
    pkgs.hidapi
  ];
};

UPDATE: This is no-longer an issue with the beta version of the Steam client. For now, the stable version still needs it.

EDIT: Removed redundant steam-hardware option - as vaibhavsagar pointed out, it's already set by programs.steam.

yeah thats exactly what i mean but with all 100% not the packetmanager alone .

hey there, i am currently setting up my new dwm config with picom, and I wanted to use the FT-Labs fork, so i looked online, and realized that its not in official repos, so I checked its repo, and found out that it only provides a flake.nix, but I do not understand how I could turn that flake into a package for me to use, please help!

Started with Ubuntu, then got bored with the slow update cycle (don’t get me wrong — Ubuntu is still a great distro for its purpose).

Moved to Arch Linux and got excited by the bleeding-edge capabilities, but also spent a lot of time troubleshooting instability issues. I even had a dedicated USB just for Timeshift recovery.

Finally landed on NixOS.

After using it daily for more than a year, my biggest question is:

Why aren’t more people talking about it?

The declarative approach makes systems much easier to audit and maintain, even for a single machine. Rollbacks completely changed how comfortable I feel experimenting with my setup.

Another underrated advantage is that NixOS is extremely LLM-friendly, especially when using one long centralized config file. Explaining your setup, debugging issues, or generating configs becomes surprisingly efficient.

I’m a programmer with fair knowledge of the Nix language now, and I’m planning to start contributing to Nixpkgs next year.

Honestly, NixOS changed the way I think about operating systems entirely.

I love NixOS. Biggest gripe / speed bump is managing updates. I commonly find myself running into “oh, I need to update program X, let me do nix flake update and then NixOS-rebuild switch.” However, lots of the time this step has broken packages, takes a really long time, and it makes me reluctant to even use those apps that need to be updated.

How do people handle this pain point? Do people allow rebuild to continue with partial failures? Any auto-update / cachix things I should know about?

I currently have 1 flake.nix with all my sources and everything is nix modules across multiple hosts.