i might just switch back to linux mint

simplicity is king.

i use NixOS, a declarative linux distribution based on nix and nix combined to make nix. i've used this for at least an year.

it's really handy.

i've basically saved my entire system configuration -- packages, services, user information, drivers, other files, etc. -- in files that i can save in a github repository. for example, fufexan's dotfiles. if something happens or i change systems, i can get a comprehensive recreation of my system (only missing personal files and all). and the little language it comes with makes this a whole lot more powerful.

and each time you rebuild the system, a new generation is created -- a revision of a configuration -- and you can revert to previous generations. it's fearless iteration.

this fearless iteration is also slow. on my machine, adding a package, removing a package, heck- any revision, takes at least a minute. this fearless iteration is great; i set my login shell to nushell (terrible decision by the way) with an erroring config, which basically softlocked me, but i wasn't scared because i can select a prior generation and avoid that error.

sometimes things break across versions. and those errors sap a little life out of me everytime it does happen. sometimes packages rely on something that's insecure, so i have to whitelist that. sometimes they error for some forsaken reason, so i have to remove that. this only happens when i am rebuilding (it takes a minute or so in preparation for something or doing something), so changes take a lot more time than i wish it would.

it also grinds my system to a halt sometimes while it's updating, so that's great.

but on nixos, my repository, my configuration, is mine. but i am sloppy, messy, and impulsive, and the thing is a time sink. the files are disorganized and all over the place. folders that i'd rather not use but still rely on exist. some things are organized by type rather than purpose. going into nixos, you have to maintain your configuration and realize what sticks and what shouldn't. i've used flake-parts... but for what? for multiple cpu architectures? some packages are exclusive to certain architectures, so 9 times out of 10 it will probably not transition well. i feel like it complicates things.

nixpkgs (for nix: the package manager), boasts at least 120,000 packages. for most cases, you're bound to at least have what you're looking for. but in the cases that you don't, like laigter? nix, the language that you use to make the packages, works, but it feels ugly, looks ugly, and just, overall, not preferable to work in. this was a grievance for another user, and you can find a little more information there.

sometimes i don't use things because it actually just doesn't handle things well with the rest of the system. for instance, mimeapps.list.

i install so much software, and it often breaks the mimeapps.list by replacing it, so i either have to delete it or set up file extensions. but i can't just delete it; sometimes there's useful information in it. it sucks. i gave up and left it imperative.

nixos also takes up a good amount of storage but that actually may just be a me issue :3

linux mint, on the other hand, literally just works. there is a reason it's heralded for being one of the best introductory distros: it ships with good defaults and is simple. its default desktop environment, cinnamon, is simple and clean and very windows-like. its applications work and apply for most cases. and although it doesn't sidestep the terminal completely, you can manage your system well with just a gui.

i've switched away from it, but i won't let go the fact that it's actually just phenomenal. it's simple and exactly what i want: quick to use and little issues. i've grown to love it.

but nix does have its merits. it has a lot of benefits and things i genuinely enjoy, and it's hard for me to cover this because it's often subtle.

no boilerplate has a video on this.

going back to nixpkgs, (even though it's probably not as much as a selling point as i thought) you can basically be as stable or unstable as you want. it's great. that's a nice point. stable packages? unstable packages? whatever packages? just set the channel/commit/version to rely on. flakes, as stupid (confusing) as they are, makes things a little easy where you can add something like a github repository as an input and pin that version, so you can actually get the thing you're looking at at that moment.

something that switching away from linux mint, my first distro, did was force me to learn linux. force me to learn what the heck a filesystem hierachy standard is. force me to learn appimages and flatpaks. force me to learn desktop environments. force me to learn what a compositor is. force me to understand pulseaudio, pipewire, and alsa. force me to recognize mimeapps and xdg portals. force me to learn the command line and bash, nushell, and zsh. force me to learn power management tools. force me to interface with a variety of applications like ghostty and zathura. force me to learn what goes into a system. nixos, although indirectly, helped me in that regard.

the nixos options as well as home-manager options also do a really great job at abstracting away the little intricacies and complexities in configuration.

its declarative and reproducible nature allows me to have multiple different development environments with specific packages relevant to the project instead of having it globally installed using nix-shell. i don't often use tools for the entire system, like with this website! just by typing nix-shell, i create a development environment that includes chromium, node, and a little more. it's great.

let
  nixpkgs = builtins.fetchTarball {
    url = "https://github.com/NixOS/nixpkgs/archive/c69a9bffbecde46b4b939465422ddc59493d3e4d.tar.gz";
    sha256 = "16arw9ys4869lg3rwsp03dshcn1hidfr2aw904wpvl8baki1gmvm";
  };

  pkgs = import nixpkgs { config = {}; overlays = []; };
in pkgs.mkShell {
  buildInputs = with pkgs; [
    # tools
    git
    nodejs_22

    # browser testing
    firefox
    ungoogled-chromium

    # (oblivious to npm scripts)
    (writeShellScriptBin "11ty-clean" ''
      rm -r ./_site
    '')

    (writeShellScriptBin "11ty-serve" ''
      11ty-clean
      npx @11ty/eleventy --serve
    '')

    (writeShellScriptBin "11ty-build" ''
      11ty-clean
      npx @11ty/eleventy
    '')
  ];
}

allowing files and folder to be symlinked (or shortcutted) is a phenomenal thing so i can save it to github. home-manager is a great tool for symlinking this stuff without having to switch entirely with the benefits of nix until it broke my cinnamon desktop somehow (probably) :3

but i'll just settle for gnu stow, and i can just install the nix cli or guix. it's simpler that way and i get exactly what i want.

and probably due to the massive skill issue i've imposed onto myself, methinks i'll just switch away.