[sweeter]

Its a Nixos based Linux distribution where the Nix config and Nix flake is written for you and configured using a GUI. It attempts to bring the benefits of Nix to people who don't care to learn the insanity that the Nix language is (I say this as a full-time nixos user)

a Nix Flake is basically just a file to pin packages against a specific version (ie go.mod cargo.lock etc...) you then write a config that defines your system state and packages that you want to be available.

[drdaeman]

> learn the insanity that the Nix language is

What's wrong with it? I'm not fond of the standard library (esp. the mkOverride and its friends), but the language itself feels fine. (Or am I just too used to it?)

Personally, I would've preferred statically-typed language with proper GADTs, but Nix is far from what I'd call "insanity". Malbodge is insanity, JavaScript is a mess (mainly because of its birth defects), Nix is... not a dream language, has a few odd bits that one needs to get used to, but feels quite okay.

[pasc1878]

I understand Nix the language if it is all in one file.

But try to call one file from another - it is confusing - the parameters are not explicit like a function call - they suddenly appear - adding more arguments is odd. Modules are not simple imports they add options and config to "help" you.

I do wish they had used a well documented language with some form of modules rather than invent their own idiosyncratic one.

[drdaeman]

Nix-the-language imports are dead simple: https://nixos.org/guides/nix-pills/05-functions-and-imports#... - `builtins.import ./foo.nix` makes it like we had `./foo.nix` copied and pasted in place of it. If we want to pass something, we make contents of `./foo.nix` a function (thus the frequently seen `import ./foo.nix {}` or `import ./foo.nix { inherit bar; }`).

It’s the nixpkgs’ module convention system that is a little bit less straightforward as it relies on some conventions: https://nixos.wiki/wiki/NixOS_modules#Module_Imports_vs_buil...

Oh, and Flakes have inputs (which are closer to built-in module system, as IIRC Flake support is baked into Nix itself rather than being a part of Nixpkgs like the module system), which is another different convention, but it all boils down to using `builtins.import` somewhere deep down the chain, all extra semantics in the libraries.

Again, I would've preferred a language with module system built-in but it's not a bad design either - it's just minimalistic. IMHO, Ruby and Perl can be more confusing than this - and they're still sane (if we don't intentionally start having fun with their metaprogramming capabilities). But then Flakes probably wouldn't be a thing, so minimal core has its advantages too. Or disadvantages, as it all depends on the viewer.

Either way, it’s all well documented. I still forget how it works now and then, but that’s my memory/attention span problem rather than a Nix/Nixpkgs issue.

[earthling8118]

The language is absolutely not the problem. It's not a particularly difficult or complex language at all. In fact, it's pretty elegant and easy to understand the language. It's the things built on top of it that are difficult.

[sweeter]

I like the core constructs and I think it looks beautiful, but it quickly becomes a mess. I agree though otherwise.