nixpkgs VS nixos-config

That's what nixpkgs does for Nix/NixOS. The package set is continuously built by a CI system and made publicly available: https://github.com/NixOS/nixpkgs#continuous-integration-and-...

Agreed. NixOS is a marvel of engineering to me, and kind of hard to go back from once you get used to it. Automatic snapshotting on every configuration change, the entire system state being configurable through text files and therefore never being ambiguous, being able to temporarily install stuff without it polluting your path for forever by using nix-shells, clearly being able to see and define stuff like boot parameters and kernel modules are just insanely wonderful things, all while still using (I think) a vanilla kernel and really no runtime overhead, allowing you to make an insanely lean system without ever being unsure if you're missing something. In my mind about as close to an "objectively better" way to handle an OS (at least for people who are technical). I have no desire to go back to any other distro for my server.

But the Nix language itself is really quite annoying. I mean, I've more or less gotten used to its annoyances, and I do think that some of the DSLs it has are excellent (I really like the Nginx and systemd configuration stuff, for example), and a lot of the configs are just `services.myservice.enable = true` which is fine, but a lot of the time I'm kind of confused about what syntax is allowed and how loops work and the like. It's not horrible or anything, just a bit annoying because I'll occasionally have to do a nixos-rebuild like three or four times because I messed up some subtle syntax, and it's especially annoying if I have to go dig at the root Nix package to find out what I did wrong [1].

I think decentralizing stuff in the form of flakes might be able to help with this, if for no other reason the area in which you'd be forced to look for configuration stuff could be reduced, but I do think NixOS would benefit from some rearchitecture.

[1] Which happened yesterday with an ethernet card configuration: https://github.com/NixOS/nixpkgs/blob/nixos-24.05/nixos/modu...

I agree NixOS + docker/podman-compose is a good compromise but one has to be aware NixOS still run podman as root (1) [0]. What is very scary and defeat the purpose of rootless container.

- [0] https://github.com/NixOS/nixpkgs/issues/259770

I don't think there's a right way to do it, you are correct in that learning NixOS is pretty tedious.

Re: flakes, my personal opinion is to use flakes. While Flakes are imperfect, they still provide a lot of functionality that Nix doesn't otherwise have. In my mind, it's like Nix's equivalent of "Go modules" or something like that. I do feel like people who do not like flakes make many valid points (the boilerplate, the fact that the top-level flake expression is a subset of Nix for some reason, etc.) but the argument isn't that those problems shouldn't be solved, it's that flakes are a sub-optimal design. Since they're so proliferated throughout the ecosystem though, it is quite unlikely that Nix or any prominent fork will outright drop flakes support any time in the near future. For better or worse, Flakes are part of the Nix ecosystem for the foreseeable future. In my opinion, one may as well take advantage of that.

If you haven't already, I'd get your feet wet with installing Nix on a non-NixOS machine first, and please feel free to ask questions about Nix in the NixOS Discourse "Help" section.

I have some recommendations:

1. https://github.com/nix-community/nix-direnv - Since Nix derivations usually wrap around other build systems, the entire derivation is recomputed when any file in it changes; using direnv, you can just get your normal dev tools upon cd'ing into your project directories. This gives you a lot of the benefits of Nix during local development, but with your normal stack, and without needing to globally install anything.

2. If you are trying to build something, chances are you can find inspiration in Nixpkgs. Are you curious how you might package a Bevy game? No problem: literally search "bevy" on the Nixpkgs GitHub repo and see what comes up. I found a derivation that does: https://github.com/NixOS/nixpkgs/blob/master/pkgs/games/jump...

3. If you use flakes, you should keep the flake "schema" handy. There are a lot of different kinds of flake outputs and there are different ways to specify the same thing, which is somewhat needlessly confusing; keeping the flake schema handy will make it easier to understand what Nix is looking for in a flake, which might make it easier to see what's going on (especially if it's obfuscated.) The most important takeaway here: A command like `nix run flake#attr` will try multiple different attributes. https://nixos.wiki/wiki/flakes#Flake_schema

4. Likewise, I really recommend reading up on what NixOS modules are. NixOS modules are the basis for configurations on NixOS, and having a clear understanding of what is even going on with them is a good idea. For example, you should understand the difference between the Nix language's `import` directive, and using the NixOS modules `imports` attribute to import other NixOS modules. Understanding how the configuration merge works saves a lot of headache, makes it easier to understand how people's configurations works, and also makes it easier to modularize your own NixOS configurations, too. https://nixos.wiki/wiki/NixOS_modules

Unfortunately though, there's just no way to make it "click", and I can't guarantee that it's worth all of the effort. For me, I felt it was, but yes, there's no one correct way to do it.

But please feel free to ask questions if anything seems confusing.

This will drop you into a shell where `tracexec` is installed.

[1]: https://github.com/NixOS/nixpkgs/pull/310158

I don't think so. The article is probably intended for the Nix community, so the author doesn't need to convince HN that something is going on. If as an outsider you are interested then you need to look into it yourself, the community has no obligation to make their internal conflicts legible to the outside world.

As an outsider myself, it certainly looks like something is going on as more than 20 Nixpkg maintainers left in a week: https://github.com/NixOS/nixpkgs/issues?q=label%3A%228.has%3...

https://github.com/NixOS/nixpkgs/commits?author=neon-sunset

I see two signers in the top 6 displayed on https://github.com/NixOS/nixpkgs/graphs/contributors

For a single file script, nix can make the package management quite easy: https://github.com/NixOS/nixpkgs/blob/master/doc/languages-f...

For example,

```

I’ve been using Nix directly on MacOS with minimal issues for a few years now. Works great.

I hate using docker on Mac and have since replaced it with flakes and devenv.

My configuration with a step by step guide (600+ stars): https://github.com/dustinlyons/nixos-config

I tried to make Nix as easy to adopt as possible by creating Nix commands and a step by step guide: https://github.com/dustinlyons/nixos-config

I love Nix. I use it every day to manage multiple local dev environments. And I use devenv instead of docker for sharing project-specific environments with others.

Felt (still am, actually) this problem too. Started with the same approach (Vanilla Emacs) a few years back in order to really learn the ins-and-outs after giving DOOM and others a shot and feeling like I didn't have the faintest what was really going on with all the magic. I somehow did end up falling in love with Emacs again[^1].

Won't lie... there was a fair amount of cursing involved and, despite the love, I wouldn't recommend many to venture down this road[^2].

Now I have gone the literate config way in my dotfiles https://github.com/vidbina/dotfiles/tree/main/emacs and I jump between Cursor (vscode-based), Neovim and Emacs for different tasks on a daily. I also found dustinlyons/nixos-config (https://github.com/dustinlyons/nixos-config/blob/main/module...) just a few days ago and figured that could be a fun resource when you're building yours up.

Take it as a hobby. There are a bunch of nice things that I picked up from Emacs (a. literate configs, b. comfort around working with LISPs, c. bigger appreciation for parts of the GNU ecosystem, d. more in-depth understanding of how my editor works which helps me debug issues in Neovim or vscode when I see them) but I still think that I'm cursed by wanting to go down this road so badly. Wish I could just vscode my way through live and build dope stuff, unencumbered.

1: Used Emacs heavily in college over 12 years ago when I would boot the Windows + Novell groupware school computers into my own Ubuntu config with my Emacs and embedded dev toolchain from my pendrive.

2: The single-threaded-ness and related ocassional unresponsiveness/hangups still grind my gears.

Here is my flake using home manager on Mac: https://github.com/dustinlyons/nixos-config

What do I need to do to switch from an official Nix install to using nix-installer on macOS? Just uninstall the current nix and install using nix-installer?

My config is loosely based off https://github.com/dustinlyons/nixos-config if this matters. Using nix-darwin.

My configuration uses Nix.

Not my personal notes, but how I do my writing and organize my thoughts. This is my Nix configuration that powers my Macbook, Linux PC, and home lab server. Emacs + org-roam to capture everything. https://github.com/dustinlyons/nixos-config