Guix Blog

I'm a NixOS user and I know Gobolinux is a few years older, this blogpost (from 2011) was actually useful for me at the time when I decided to pick NixOS for my workstations: https://sandervanderburg.blogspot.com/2011/12/evaluation-and-compariso… Nowadays I'm also playing with Guix as well, I kinda love that everything can be unified in a more decent language (Guile Scheme) than Nix: https://guix.gnu.org/

If you're interested in what's going on with GNU in general, GUIX is awesome. It's a package manager like Nix but purely GNU (using GNU Guile scheme). It's developed in tandem with the GNU Shepherd init system (instead of sysvinit/systemd/openrc/etc.) and there are distributions based on GNU Hurd kernel (or the Linux-libre kernel). Wikipedia has a pretty good rundown [3] but I recommend booting up a VM image. It's actually quite beautiful. I love the purity of GNOME on a GNU/Hurd system with GUIX and Shepherd where the whole thing is configured in guile[4]. There's just something very aesthetic about the combination. I wish I could use it as my daily driver. 1. https://guix.gnu.org/ 2. https://www.gnu.org/software/shepherd/manual/shepherd.html 3. https://en.wikipedia.org/wiki/GNU_Guix 4. https://www.gnu.org/software/guile/

> So what we are missing now is a 500GB framework that can write the config file for the programming language that is writing a config file for the actual program I wish to use. That exists since 1960. It's called LISP. The e.g. https://guix.gnu.org/ uses with great success, the Guile Scheme dialect of LISP, to be precise. And FYI the "framework" is: $ ls --human-readable --size $(readlink $(which guile)) 16K /gnu/store/1gd9nsy4cps8fnrd1avkc9l01l7ywiai-guile-3.0.9/bin/guile Yes, only sixteen kilos, not gigas.

I don’t think GUIX will ever die, it seems to be the GNU Foundation’s favorite. It’s the only GNU-approved distro whose website is a sub domain of gnu.org. GNU seems to be unofficially standardizing on GUIX. https://www.gnu.org/distros/free-distros.html https://guix.gnu.org/

For those who like the concept of Nix, but don't like the Nix language, the Guix package manager [0] might also be worth a try. It's an official GNU project, inspired by Nix, and it uses Guile Scheme instead of Nix language. [0] https://guix.gnu.org/

Obligatory link to its cousin: https://guix.gnu.org/ A package manager or a full distro. I use the package manager on top of Debian, it's great, it allows me to get recent package versions the most straightforward way (like the latest Emacs), in exchange of disk space (easily some GB before a `guix gc` cleanup).

> I've only heard of this approach for zig and Jonathan Blow's language It's the same approach used by nix and guix. Nix is moderately successful. I'm typing this on a laptop running nixos :) https://nixos.org/ https://guix.gnu.org/ If you're interested in this sort of thing, this is an excellent paper on build system design, although it focuses more on the properties of the build graph than on how the graph is constructed: https://www.microsoft.com/en-us/research/uploads/prod/2018/03/build-sy…

This reminds me a bit of hyperfiddle[0], which I've looked at a few times but never really explored. I know the author (dustingetz) hangs out around here, and I wonder if any of this interface builder stuff was prior art. In any case, I wish we had more tools for interactivity these days. I use emacs and it's given me a taste for what's possible, and I'm excited to see Guix[1] mature because it has fantastic sympathies with emacs. But it seems destined to be niche, even though it's such a wonderful vision of what computing could be. [0]http://www.hyperfiddle.net/ [1]https://guix.gnu.org/

> I started because I wanted Claude Code to manage my system, not just my code. I have two reactions to this. First: respectfully, this is hilarious. LLMs are good at many things, but judgement is not one of them. At the outset, this was firmly in the "terrible ideas" category. (EDIT: ugh; I misread you. I thought you said Claude Code wanted to manage your system. I need more coffee...) Second: sometimes from terrible ideas come great creativity. (I'm actually not sure what epistemic basis creativity flows from, if not simply the habit of adding entropy to a search path, and you sure chose a high entropy path!) I don't know anything about the stack you chose, but I've spent many hours almost being enticed by https://guix.gnu.org/ and this sounds similar. And the part where you have recovered from a borked system about 15 times is genuine evidence that you're doing something right. I applaud your grit and hope you're having as much fun as it sounds like you are.

I'm a huge fan of Nix, and I'm glad to have stuck with the often times daunting process of getting into it - and I have to agree with the author's point regarding the documentation. That's not a fault of the people who actually did sit down and document their process, or distill their learning path into a tutorial - I myself understand it well enough to use it, but not well enough to really explain it without confusing people even more, but it's still a pity that finding good, exhaustive documentation for Nix is really difficult. Another pitfall is the usage of flakes, which, on the one hand are (imho) great, recommended everywhere and often times even assumed to be used implicitly, but on the other hand are still experimental. I myself started using flakes not because of the promised benefit (although I did realize the benefit later on) but just because multiple tutorials I've read gave me the feeling that flakes were the de facto way to do Nix from now on - and mind you, that was in late 2020. I'm using Nix for setting up my work machine (Mac via nix-darwin), my private machines (NixOS), selfhosting that's not in my k8s (also NixOS), and some private projects (dependencies, ci, and containers) - where the issues I've described don't really bother me, but for professional projects, where I'd have to convince and/or instruct colleagues, Nix feels a bit too rough around the edges for me right now. Edit: I also think it's important to distinguish between Nix the technology…

If you like Nix than probably try GNU Guix [1] and if possible use Guix System on server side. This is one of the most modern development in operating systems. In the modern security conscious world where most companies run their workloads on virtual machines controlled by other companies, it's imperative that applications are deployed on such predictable, secure and reproducible operating systems. Guix supports transactional upgrades and roll-backs, unprivileged package management, and more. When used as a standalone distribution, Guix supports declarative system configuration for transparent and reproducible operating systems. I still think Amazon, Google and Azure will take a decade or two to build and offer something like this to it's customers. Indeed Google's Fuschia is trying to do the same, but I feel it's at least a decade away. It has one of the best wonderful documentation [2] to get started and explore with all the details. [1] https://guix.gnu.org/ [2] https://guix.gnu.org/manual/en/html_node/

I am going to be hated and downvoted for that but let's go... Bazel, like Bucks and other, try to bring on table a build system / deployment system that is multi-language, multi-platform and developer oriented. A holy Graal that many developer ( like me ) looked for decade and that many (large) organizations more or less tried to do one day (and most failed) It is a good idea. It is a required tool to improve productivity. However, if the idea is good on paper, in the implementation, Bazel is damn wrong. - Bazel is centered around "mono-repo" culture, making it much harder to integrated with multi-source, multi-repo, multi-version projects like many of us have. If I have no doubt that it is great at Google, the external world is not google. - Bazel is made in JAVA, requires the JVM and this is a problem. That make Bazel not a "light" tool easy to deploy in a fresh VM or in a container. - Bazel mix the concepts Build System ( like Make, ant, co ) and Deployment System like ( rpm, pkgsrc, etc). That makes Bazel pretty hard to integrate with projects that have existing build system, and almost impossible to integrate INSIDE an other Deployment System (usual package manager, deployment pipeline). The problem that Bazel faces with some languages ( python, go ) is a cause of that. - Bazel venerates and follows the cult of "DO NOT INSTALL": compile and execute in workspace, there is no "make install", not installation phase. If "convenient" in mono-repo, this is often a…

Alternatively, you can use the guix package manager. See here: https://guix.gnu.org/ Configuration is in scheme (guile) so that may be a turn off though.

I have slowly been migrating my Nix configuration to Guix as there is just so much to like about Guix such as Scheme and full-source bootstrap. I am also very happy about the move to Codeberg which hopefully results in more contributors. The new Rust packaging process is also worth reading about: https://guix.gnu.org/tr/blog/2025/a-new-rust-packaging-model/

> Does every service have hooks for possible extensions? What if a new service doesn't fit existing extension hooks? No, only few services define service extensions. It's more common for services to be configured solely via their configuration struct. See the following for docs: * https://guix.gnu.org/manual/en/html_node/Service-Composition.html * https://guix.gnu.org/manual/en/html_node/Service-Types-and-Services.ht… This is less flexible-by-default than NixOS module, where any module can modify any other module. That is by design. The Guix developers see NixOS's approach as failing the principle-of-least-authority, where any arbitrary module (even those imported via flakes) can add a root SSH key. I use NixOS, but it's an interesting tradeoff.

You could take a look at guix [1], it's very much like nix, but is available as a package manager for other distros. [1] https://guix.gnu.org/

Agreed - although I came to the same sorts of realisations through Guix, the fundaments of the projects are the same (as I presume and hope you and other Nix people know). So the answer is Nix and its spiritual sibling, Guix, and any other project that attempts to implement the meat of that thesis there (which I hadn't seen actually - thank you!). I feel there's a surprisingly strong standoffishness between the two communities of users, but that's a side point. On topic though, for example, https://guix.gnu.org/en/blog/2020/reproducible-computations-with-guix/… and there are other excellent posts on the Guix blog going in to great detail on the topic of reproducibility and the efforts they are putting in there.

Guix is a Nix-like package manager and distro that is almost entirely written in Guile Scheme: https://guix.gnu.org/ I would guess it's by far the most active Guile project.

I mean.. that is absolutely something the bootstrap/reproducibility folks would flag as a problem. Heck, https://guix.gnu.org/en/blog/2023/the-full-source-bootstrap-building-f… went to great extremes to bootstrap a C compiler through the all-important gcc 4.9 (which comes up constantly in these efforts because it was the last gcc that builds without a C++ compiler).

I play around with quicklisp to develop and tinker. To test and deploy, I generally use Guix [0] to express a package for my application which pins dependencies to exact versions and optionally can run in a container. I have Guix installed on top of Ubuntu. This is hobbyist and experimental work so it's not battle-tested. [0] https://guix.gnu.org/

Isn't it time to use GNU Guix package manager ? https://guix.gnu.org/

One good thing that would come from limiting Rust in the Linux kernel today is a clearer path to bootstrappable and reproducible builds. GuixSD has done some amazing work on full-source bootstrapping systems using the linux-libre kernel: https://guix.gnu.org/en/blog/2023/the-full-source-bootstrap-building-f… A requirement for a rust toolchain complicates this significantly and I'm not sure if now is the right time to have rust be a hard requirement.

Unfortunately they don't talk about Bootstrappable builds: https://lwn.net/Articles/841797/ Guix and others in the GNU community were able to bootstrap Guix from 357-byte program last year. https://guix.gnu.org/en/blog/2023/the-full-source-bootstrap-building-f… Great story and super interesting stuff!

Guix seems the best when it comes to reproducibility https://guix.gnu.org/en/blog/2024/identifying-software/

There's also been a greater focus on reproducibility: https://guix.gnu.org/en/blog/2023/the-full-source-bootstrap-building-f…

> inventing a brand new purely functional language programming language. ISTM that if you dislike that, then there's GUIX. https://guix.gnu.org/ Very briefly, AFAICT, it's "Nix but using Scheme".

I've been playing with a lispy thing that might be: (grocery_list (fruit "apple") (fruit "banana") (fruit "pear")) That's pretty much exactly XML. Alternatively: (grocery_list (fruits "apple" "banana" "pear")) but the semantics are different. My motivation is expressing docker-compose.yaml in the "best" way I can imagine, as a design exercise. In that case, I'd rather have a bunch of (service ...) forms, instead of a "services" object. Not sure why. Maybe it's a pun on interpreter-driven formats like that used by [guix][1]. [1]: https://guix.gnu.org/manual/en/html_node/Shepherd-Services.html

I think a "competitor" to Lua would be Guile [1], but I am not sure if it gets close to Lua in terms of lightweightness... it was designed to be used in the GNU project, with similar objects as Lua: to be light, easily embeddable. It's a Scheme (Lisp) so maybe not for everyone's taste... its "coolest" use i know of is for configuring Guix [2] (the GNU version of Nix). [1] https://www.gnu.org/software/guile/ [2] https://guix.gnu.org

GNU Guix seems to be an alternative that I've been interested in. The configuration is done with Scheme. I haven't tried it. https://guix.gnu.org/

Well GNU Guix is publicly against the current structure of the FSF and especially RMS.[1] So Guix as an example is not really a great defense of FSF and the GNU Project's operating structure. 1: https://guix.gnu.org/blog/2019/joint-statement-on-the-gnu-project/