What is Reddit's opinion of
GNU Guix?
From 3.5 billion Reddit comments
➔ GNU Guix website
By popularity on Reddit, this Service is:
67 reviews of this app found across Reddit:
> […] virtually every distro available has to make systemd a hard dependency so that they can provide Gnome.
While there may be such a dependency, it is possible to have GNOME without systemd, as GuixSD has shown us.
> This is not software freedom. Freedom was the ability to choose valid alternatives that Linux traditionally had.
Actually, a very common definition is the freedom to use, study, share and modify the software as you wish. I feel like that's what would primarily be GNOME's definition, especially considering that it's a part of the GNU project.
I also wouldn't consider the availability of alternative software “freedom”; I would rather call it “convenience”. People have the ability to bring about this convenience once the software is free. (And GNOME is free software; it can be changed and it has been changed. Whether anyone makes those changes or implements them in the original project is a different matter. Besides, there are plenty of other desktop environments to choose from beyond it; the users are also free to do that.)
Unaware of programs but GuixSD, a functional distro, that your whole system is configured by using an init.el like file - config.scm.
So you can reproduce your distro installation and customization with just a central file!
You can configure just every aspect of the distro as software installed, users account, locale, system services, kernel modules, default folders and files in $HOME, even grub themes...
Its written and configured in an easy Lisp implemetaion, Guile Scheme!
Just amazing!
One cluster I use runs Scientific Linux 6 (RHEL 6), but has SCL, so I can do
scl enable devtoolset-4 bash
To get an environment with modern GCC. ("scl -l" to list the environments). If you are lucky it might be set up.
Another option I've used is Gentoo Prefix. It lets you install packages into a directory using the gentoo tools.
An option I've not yet tried is Guix
There is not need for that :) there is an script to do it automatically
https://www.gnu.org/software/guix/manual/en/html_node/Binary-Installation.html
Once installed, you can install packages with 'guix search package' and 'guix install package'
Side question, but maybe someone from the GNU Guix project will see it...
Most GNU projects require written copyright assignment paperwork before accepting patches. In contributing and HACKING I don't see any mention of it. Does GNU Guix not require copyright assignment?
From the nix about page:
>GNU Guix provides state-of-the-art package management features such as transactional upgrades and roll-backs, reproducible build environments, unprivileged package management, and per-user profiles. It uses low-level mechanisms from the Nix package manager, but packages are defined as native Guile modules, using extensions to the Scheme language—which makes it nicely hackable.
You can call it a "Derivative" if you would like, but i would argue most people would still consider nixos "the original" (also some would consider taking some low level part of a project that is not meant to be reused and developing on top of it a fork).
Follow the instructions here to install it on your existing distro, and the thread here for a few dotfiles pointers. Install some packages with it, play around with it, try to package something. The package definitions are only slightly more complicated than PKGBUILDs, except in Scheme instead of bash.
For me it is all about the control over the systems I depend on. It is in beta, but it is usable, liberating, dependable and hackable.
I don't use and don't have any plans to use any other distribution.
I initially liked the idea of Nix, but I didn't like NixOS. The implementation has accumulated some cruft. It's undergoing major refactorings now, so it will probably get much better.
My piece of advice is that you try GuixSD. It's very elegant. Some reasons I love it (most apply to Nix too):
My whole system configuration is a reproducible DSL (Scheme) file.
I can rollback to any system configuration. Thus, I can't break my system.
Containers are baked in (answers your question).
All packages are reproducible. I can challenge the binary I'm getting from a repo, rebuild it from source and see whether both match.
You can install multiple versions of any package. You get the best of both worlds: rolling and stable releases.
Since package builds are reproducible recipes, it's trivial to inherit from a given recipe (say Linux kernel), alter a few things (say change the repo to linux-zen and add a few flags). You get the best of both worlds: binary and source based distros.
Guix can use Nix packages and vice versa.
GNU Guix SD. GNU's own Linux distribution, stateless and fully hackable with Lisp API for system management.
GUIX https://www.gnu.org/software/guix/
It's a new breed packaging distro. Fully free and endorsed by the FSF. It's already got a lot of momentum behind it. A long way to go but it's exciting to watch.
Simply backing up the files in .guix-profile is a waste because it won't restore correctly. If you wanted, you could use guix archive to generate a closure of your profile which includes all dependencies recursively.
Even that's probably unnecessary though, because all the data in Guix can be regenerated if you know the Scheme code that produced it. If you install packages using a manifest, and you know about the channels that produced it (using guix describe -f channels), that's all you need in order to reproduce your profile on another machine.
You’re asking two different questions. R and Python are interpreted languages, they aren’t compiled directly into machine code and instead run on top of a runtime of some kind. The interpreter will usually compile the language to some kind of abstract bytecode and then execute that. C is a very popular and portable language, and it’s a common choice for implementing interpreters.
A compiled language like C or Rust is built using a process called bootstrapping. Developers will use another language to implement a bare minimum compiler, and eventually build an entirely separate compiler in the new language. This final compiler is called “self-hosting”. Self-hosting compilers are usually just built using distributed binaries. To build them from scratch usually means a lengthy process which compiles successive versions of the compiler with itself.
it's not a fork, it uses Nix inside
the added value is the EDSL in Scheme (they use Guile as interpreter) for describing packages etc. that sits on top.
Guix’s main contributions (from European Lisp Symposium slides)
Maybe this article on bootstrapping Rust from mrustc can help you https://www.gnu.org/software/guix/blog/2018/bootstrapping-rust/
Alternatively have a look over at r/playrust
Are you trying to run it via kurso4.sh? That seems to work for me on Parabola (derivative of Arch). It looks like there was a package named <code>libpng12-0</code> for Ubuntu 16.04, but I don't know if that's what you need. (If it is, maybe it could still work in 18.04?)
I don't know about any other packaging, although it would probably be for the best if someone made a Guix package for it. If your computer is somewhat performant, perhaps you could run an older GNU distribution (such as Ubuntu 14.04) in a virtual machine (such as gnome-boxes) and run Kurso de Esperanto there?
>Do you guys think your system port to ARM will be done by it's release?
I can't say because I haven't been involved in the port. All I know is that you aren't the only EOMA68-A20 backer that wants this. If I had to guess I would say it won't be done before it is released, but who knows.
>Also do you have any recommendations on resources for learning Guile's dialect of scheme?
Check out the "Hello, Scheme!"[0] and "Hello, Guile!"[1] sections of the Guile manual for starters. Once you are familiar with the basics, you should be well on your way to doing simple things within Guix, perhaps with some help by copy/pasting from other package recipes. To learn the Guix-specific APIs, visit the Guix manual.[2]
The #guix IRC channel on freenode is very active if you need help, and there is also the help-guix mailing list for longer, non-realtime conversations.
[0] https://www.gnu.org/software/guile/manual/html_node/Hello-Scheme_0021.html#Hello-Scheme_0021
[1] https://www.gnu.org/software/guile/manual/html_node/Hello-Guile_0021.html#Hello-Guile_0021
[2] https://www.gnu.org/software/guix/manual/html_node/Programming-Interface.html#Programming-Interface
GuixSD 0.15 est sorti, et le manuel a ete traduit en francais https://www.gnu.org/software/guix/blog/2018/gnu-guix-and-guixsd-0.15.0-released/
(ca me fait une excuse pour promouvoir cette belle distro)
Hi, I use Guix/GuixSD. It's pretty nice! I especially enjoy not having to install packages just to try out software.
On your laptop, you could opt to do the "foreign distro" installation. Instructions are https://www.gnu.org/software/guix/manual/html_node/Installation.html#Installation
If you need help or have questions, #guix on freenode is a friendly place :)
> - I find that I always have to run Guix as root
If you use GNU Guix as a package manager on top of some distribution, in your case Ubuntu, you should be able to run guix command to install software as a regular user. You must configure your distribution following (the instructions from the Installation section of the Guix manual)[https://www.gnu.org/software/guix/manual/guix.html#Installation].
> - And when I'm in root, I always need to run something like ... before running a Guix-installed program like ...
This should not be your workflow. If you followed the above mentioned Installation section you should have ability to install/run applications using guix without being the root user. Please make sure that you have guix-daemon running and that it is enabled to run (as a serivce) every time you start your system.
> - Besides using Guile, is there a big difference between Guix & Nix?
The main difference, besides using Guile, between the two systems is the fact that Guix as a project is committed to promotion of free (as freedom) software. This practically means that the project repository will not contain any non-free binary blobs. Guix enables its users to add their own packages. The user may choose to pollute their own system by adding packages that contain non-free binary blobs.
The above mentioned guix-daemon is the only component inherited/forked from the Nix project, it is written in C++. Both projects use the same functional distribution model based on this paper: http://nixos.org/~eelco/pubs/phd-thesis.pdf .
I understand that you asked these questions a few days ago, if you need faster response in the future please consider asking your questions in (the #guix IRC channel on irc.freenode.net)[https://webchat.freenode.net/?channels=%23guix] . IRC channel is the main place for getting help.
># 1 Introduction
>GNU Guix^1 is a package management tool for the GNU system. Guix makes it easy for unprivileged users to install, upgrade, or remove packages, to roll back to a previous package set, to build packages from source, and generally assists with the creation and maintenance of software environments.
Absolutely one of the right questions to ask. Some things I've noticed semi-recently but not really evaluated that could fit and aren't already mentioned above or in other comments:
I've been playing around with GNU Guix and so far I like what I see in it. In the future I intend to write about its design and what I feel are its pros and cons after I do some more research and spend some more time using it.
I'm confused. I'm pretty sure that several source based distributions have this feature... is this different than what guix has with guix build --target has, or the like?
Likewise, I remember using Gentoo years ago and playing around with their cross compiling support...
> I don't believe it shares any code with Nix
it does. eg it uses the nix build daemon. see the FOSDEM 2014 slides, slide 35
> lisp-like syntax
it's not lisp-like syntax, it's full power EDSL in Scheme (they interpret scheme by GNU Guile)
> ML-like syntax
the nix language syntax is not ML-like
> As someone who loves Haskell
EDSL in Haskell would be even better, but EDSL in any general purpose language (let alone the powerful Scheme) is still better than a custom language IMHO. AFAIK they have to resort to a lot of shell coding.
In GuixSD looks like extra-config in the <code>xorg-configuration</code> enables xorg config sections to added as a list of strings.
Add the following to /etc/config.scm to enable the TearFree option:
(set-xorg-configuration (xorg-configuration (extra-config '("Section \"Device\" Identifier \"Intel Graphics\" Driver \"intel\" Option \"TearFree\" \"true\" EndSection")) (keyboard-layout keyboard-layout))))
Reconfigure and reboot
# guix system reconfigure /etc/config.scm # reboot
Verify the option was loaded in the Xorg log
# grep -i tear /var/lib/gdm/.local/share/xorg/Xorg.0.log [ 17.766] (**) intel(0): Option "TearFree" "true"
Compiling Guix does take a long time, but when I run guix pull these days it doesn't usually compile the whole thing. It downloads most of Guix pre-compiled and only needs to build a small portion of it. It's like 10x faster than it used to be.
I don't know what's going wrong in your case, and there aren't very many people providing tech support on this subreddit. You'd probably have better luck asking for help on the mailing list.
One challenge that packagers face for self-hosting compilers is bootstrapping: if you want to build the compiler from source, you need to either trust some binary, or bootstrap from the non self-hosted version.
The Guix people wrote a post about how they bootstrap Rust. Fortunately they did not need to bootstrap all the way from OCaml because mrustc exists, but they still need to build 14 versions of the compiler to get to 1.34. One issue here is that rustc x builds with rustc x-1, and not with say, x-3, so you need to build all intermediate versions.
The Bootstrappable Builds project provides some advice for self-hosting compilers at http://bootstrappable.org/best-practises.html.
It's impossible to say what the Scheme code in Guix would look like without knowing how the program works in general. How would it work on another distribution? Is this an existing program you're looking to add to Guix, or a new project you intend to write?
Maybe it works like pulseaudio-dlna, which I intend to package for Guix very soon. In that case you just write a Guix service, or maybe a shepherd user service.
I think there's a way to get both. (Also, what do you mean "reliance on an internet connection"? Unless you mean that, e.g. it's hard to install a single .deb if it requires external dependencies, which is true.)
The Guix package manager lets you package any application into tarballs or Docker images, with all dependencies included. So a user can just unzip the tarball and run.
There are two slightly different things here:
• the functional Nix package manager – iirc you could use that even on top of arch (it's in the AUR), but probably not for all system configuration
• NixOS is a complete OS, where everything can be managed in a declarative/functional way.
Also there is GuixSD: same idea build upon lisp/scheme.
There are two branches wip-installer and wip-installer-2 in savannah guix git repository. The focus is on wip-installer-2 branch.
As far as I know the guile-ncurses installer was being planed for 1.0 release, it is being tested but I do not know current status. Branch wip-installer-2 should be merged/integrated in master branch soon, according to Ludo's comment (at guix-devel mailing list). For more details you should ask at #guix IRC channel.
> So my question is, do you think there are any future plans to compile the file to a standalone executable?
You can use guix pack, it's not an executable per se but offers a similar experience https://www.gnu.org/software/guix/blog/2018/tarballs-the-ultimate-container-image-format/
You will need to package your program as guix package tho. This might mean that your package is autotools based which is almost trivial for pure guile modules and only a little trickier for bindings. I don't know how to package C based Guile project...
> So would guile be a good fit for webdev?
Mostly, yes. There is really no postgresql bindings, but there some for sqlite (check guix -A guile-sqlite) and for rendering html you can use sxml [1].
CL is nice, might have more users or their more vocal and / or talended but it's a lisp-2 and I don't see a good reason for that. IMHO Scheme is a better foundation for good engineering. Guile is mostly batteries included, only racket competes with Guile AFAIK in terms of packages. Chez Scheme is fast.
[1] That is the entry point for requests and look at 'template' https://framagit.org/a-guile-mind/culturia.next/blob/master/culturia/web.scm#L460
Guix is a package manager that can be used on any distribution of GNU+Linux. (It shares website with GuixSD, the distribution built around it.) It comes with a default repository of packages.
Guix and GuixSD support transparent source/binary deployment, which means that it can either build things locally, or download pre-built items from a server.
The key phrase here is "transparent source/binary deployment". I can choose to build packages locally or I can authorize the use of independent servers which provide pre-built binary substitutes. And I can do this as a normal user and do not have to be the administrator (user in a wheel group). I have access to scheme as an underlying programming environment to configure my whole system (package recipes, package build instructions, service definitions, service run-time instructions).
This may be oversimplification but think about the level of control you get from Gentoo linux distribution but without the need to compile everything yourself.
This is very short description, I may have missed some useful details.
For more information please check guix help page.
-Stefan.
It just highlights how inadequate pip is as a package manager. There are other issues as well, such as it not being able to give proper error messages when interrupted but instead just giving the python stack trace. Then there is the whole mess if you install something from pip and your system package manager.
At least Guix is sort of trying to solve this whole language/software specific package manager mess with updaters.
E: and let's not forget that almost none of the packages on PyPI and other bullshit repositories have any kind of release signatures.
> https://www.gnu.org/software/guix/news/creating-bundles-with-guix-pack.html
that's awesome.
> guix pack guile
and the command returns in /gnu/store a good old tarball that contains binaries for Guile and all its dependencies. + cross compilation, docker support, composability,…
GNU Guix
Guix is a "functional" package manager. Packages are installed in a special directory instead of /usr. I think the "functional" comes from packages not having "side effects".
Guix packages are also reproducible, you can compile a package on multiple machines and get the same binary.
Since packages aren't installed in a similiar fashion to regular package managers you can have multiple versions of the same package installed.
Packages are defined in Guile Scheme
GuixSD
A libre distribution that uses the GNU Guix package manager, GNU Shepherd and other GNU software.
It is indeed (partially) automated. The built-in guix import command can create Guix recipes from several sources, including from Nixpkgs.
Seems to work reasonably well (it's not perfect, but it gets most of the way there), though you need to have a local copy of nixpkgs and you also need to have nix itself installed, if I'm not mistaken.
>But it lacks an init system for starters
To be fair, DMD exists and is being used by the Guix 'package manager/distro' project. Even that project, which at one time's goal was to become "the" GNU System -- is/was still moderately reliant on 3rd-paty (non-gnu) software to run to what one would expect as/for the duties of a modern operating system. That being said, I get why those who border the more extreme side of "Free Software" idealism support such a system classification/naming scheme (I used to be one of them) -- and as a device to force "Free Software" mindshare in an overwhelmingly "Open Source" world, it is a somewhat prosperous tactic to take. GNU has always been about the ethics of software, not technical merit, and for those who don't and/or haven't lived in that world (of ethically evaluating things such as computing, to almost a fault) it surely seems to be an absurd thing. In either case, at the very least as a leaping off point, this brand of idealism/extremism seemed to be useful in a "revolutionary" like sense. Anyways, just babbling at this point.
Guix is so young and developing at such a pace that it's difficult to keep track of everything that is happening. It is far from ready to be adopted as day-to-day operating system, although it's very usable right now as a non-system package manager.
- LVM and cryptsetup packages have landed, but is not integrated with GuixSD yet.
- They've introduced grafting, a concept I've long missed in NixOS
Bug report follows:
> The Guix System Distribution (GuixSD) and the GNU Guix package manager are free software projects developed by volunteers around the ~~work~~ under the umbrella of the GNU Project.
world
That's really unfortunate. ~~It looks like the constrain the snappy apps by controlling the stuff that goes into the repository (and which ones do not).~~ Someone please correct me here if my understanding here is wrong.
~~I wish the immutable packages was by design and not because Canonical decides what goes in and what does not.~~ This is not true - it looks like there are technical issues that make it complicated to have two "stores" - not sure what the issues are but looks like nixos has this limitation as well. That said, it seems like nixos makes it possible to combine nixpkgs and any private packages: http://sandervanderburg.blogspot.com/2014/07/managing-private-nix-packages-outside.html. Looks like Canonical wants to make this easier for companies - but will make it a commercial offering.
This is really huge for me - I was considering going for ubuntu snappy at my organization in the next 1 - 2 years, but it feels like my time would be better spent with Nix (http://nixos.org/) or GNU Guix (https://www.gnu.org/software/guix/)
Anyway, lot's to read up on. :)
Thanks for sharing btw.
That's not entirely true. While GNU/Linux is a term that refers to a family of operating systems, the GNU project does make their own GNU/Linux distribution. It's called Guix System: https://www.gnu.org/software/guix/
I just need this configuration (in other distros it is located in /etc/X11/xorg.conf.d/20-intel.conf):
Section "Device" Identifier "Intel Graphics" Driver "Intel" Option "TearFree" "true" EndSection
I've gone through the documentation, but I don't find the equivalent of these Xorg files for Guix.
You can use inferiors to keep certain packages on an older version while upgrading everything else. Really useful for packages like this that frequently get rebuilt and take a long time to compile.
I see manual instructions, but I'd assumed if the graphic installer couldn't recognize the ethernet port, that CLI tools wouldn't help.
I'll give it another try later. Were you ever able to get wifi working on your X40?
Yes it allows you to write recipes and share them, you can even create a stand alone package that won't need guix at all. Next browser uses this.
Check this https://www.gnu.org/software/guix/blog/2018/tarballs-the-ultimate-container-image-format/ for more info on stand alone packages without guix.
No this won't happen for several reasons. 1. Don't worry about your system guix won't touch or mess with it. 2. Guix is a functional package manager and you can have all those versions, I am not good enough to explain how or why, but here is a good explanation
https://www.gnu.org/software/guix/manual/en/html_node/Features.html#Features
The easiest way is to tell Guix about your other operating systems; I don't think it attempts any auto-detection yet. See this manual section about adding this to your system config.
Typed Racket is fascinating, and I have a decent understanding of PL theory and Lisps are very easy to implement, but I haven't used a Lisp professionally beyond configuring Emacs. There's also Guix, which is a NixOS-like OS that completely uses Scheme.
Also I think the blog was fake about exherbo:
Ok. this guy is a troll. He did not create Exherb...
https://www.gnu.org/software/guix/manual/en/html_node/Preparing-for-Installation.html
Here is talka about encryption and whole bunch of other stuff. Looking more into it seems like an extremely unique thing, best thing I can say is explore the manual
Practical like that https://www.greghendershott.com/2018/05/extramaze-llc-using-racket-postgresql-aws-but-no-ads-or-js.html or that www.schemespheres.org or http://www.lambdanative.org or https://www.gnu.org/software/guix/ ... or javascript creation, etc... ?
Oh, wait, so you want to pull a particular version of the Guix package definitions, and build the version of GHC that's defined in that? I must have misunderstood you - I thought you had wanted to build a particular commit of the GHC repository. Sorry about that.
There's no ready-made command to do what you want, but you could write a script to use an inferior at a particular Guix commit (see (guix) Inferiors in the manual) to generate a manifest that you could use guix package to turn into a profile. There's an example in that man page. This is a relatively new feature, though, so you might run into some problems. If you need help, you're likely to get more on the mailing list).
I think you are referring to this: https://www.gnu.org/software/guix/manual/en/html_node/X_002e509-Certificates.html.
Which OS are you running? GuixSD or a foreign distribution?
Does the bug only occur on guix refresh or also on other commands like guix pull and guix package -u? Against which package did you run guix refresh?
Check that your environment variables are correct (run env in a shell).
HAHAHA.
How did you install Guix? Its distro has either installing from sources or pre-built binaries
As a Debian user, Ive installed Guix this way: https://www.gnu.org/software/guix/manual/en/html_node/Binary-Installation.html
If you truly want more "freedom", also take a look at Parabola, a GNU distribution based on Arch, but it doesn't have any of the nonfree proprietary blobs in it's kernel (that is to say, it uses Linux-libre rather than Linux).
I like GuixSD personally, but the install is completely from a CLI and the distribution & package management (which is excellent btw) are still in beta.
Cases like boost-mpi and boost-python are use-cases that we haven't run into in Guix yet. We would need to add new packages for those. Once that is done, you could use command-line package rewriting to substitute mpi implementations. For more complicated package customization, Guix makes it easy to define your own local packages and treat them as first-class packages.
If you have more use-cases that you'd like to see addressed, just let me know.
> Best answer.
Do you mean the only answer?
> Would just the kernel matter in order to run them on say Arch or would you need a hypervisor to execute them? Are snap packages container basically?
I'm not intimately familiar with snaps but from the documentation and marketing material I've come to a few conclusions about it.
From what I gather snaps aren't really containers but just packages that contain all their libraries. In theory, as long as your kernel is binary compatible they should work. There are probably some other requirements like libc or something like that. They should work on Arch as long as you use a kernel from the same release, so if you want to use a snap from ubuntu you'd want to use the LTS kernel from Arch repos. Like for regular packages there is no hypervisor as there isn't another OS. So they aren't really containers, just packages that contain all (or most) of the required dependencies.
There are some security impliactions that including the dependencies will have so I wouldn't recommend embracing snaps until those are addressed. I think that Guix is the future of package managers, it also incorporates some container technologies (guix container).
I'm really disappointed in Nix' lack of focus on security so I wouldn't recommend that. Guix takes this much more seriously.
They have something called grafts, used for security updates. I don't use guix so I don't know how well it works, but you can read about it here
> Cargo lets packages run arbitrary code on startup. This is pretty useful and important. I wonder if we can use a sandbox model for this - don't let cargo scripts touch anything outside of the code directory. Still dangerous but at least you don't have arbitrary read/write access. I would imagine it is not idiomatic to install dependency packages for cargo scripts.
The Guix model of using chrooted environments solved this. It also means that you can't accidentally pull in system libraries which is a problem waiting to happen for a lot of people (cargo packages should build the underlying C libraries themselves so they have fine control over the underlying library).
Unfortunately people want Cargo to work on Windows and I think Microsoft has failed to address the lack of chroot style environments.
I'm definitely more of an old-school guy in that regard; my favorite language is C though I do like Lisp-y languages as well.
I don't claim to know a lot though; still just a freshman in college trying to learn what I can. I'm posting this message from GNU Guix and it's interesting to say the least. I like interesting OS projects like that so I would love to start contributing to that this summer.
Do you have any sort of computing / programming background?
Thanks for the response. I posted to the mailing list, and it turns out I didn't want to use guix package -f at all, but rather <code>guix package --manifest=file</code>. The upshot is that you don't want to define your own package if they already exist. And I think they do if you can guix package -i it.
> GuixSD is a GNU/Linux distribution committed to respecting and enhancing the freedom of its users. As such, it adheres to the GNU Free System Distribution Guidelines
from https://www.gnu.org/software/guix/about/
Podes usar um sistema operativo GNU sem usar o kernel Linux. "Em alternativa" tens o kernel GNU Hurd.
The concept is brillant, but I still dont understand why they created this DSL. Using an existing functional langage (Lisp?) would have been far more efficient.
Anyway, still love Nixos and I am not planning to go back :-)
Guix might be an improvment (did not try it)
That's what I was thinking too.
I just remembered there was a post recently about Guix. After watching part of the video and skimming the the documentation, this seems like a good place to start. Plus it'll be a good learning exercise.