Guix

Guix summary

Guix is a very powerful software package manager, available directly on Glicid, which gives you direct access to over 32,200 packages on its main channel (see https://packages.guix.gnu.org/), and several thousand scientific software programs on optional channels.

To clear up some persistent misunderstandings : under no circumstances is it mandatory to use Guix on GLiCID. It is an additional, particularly powerful tool made available to all users and highly recommended for independent development AND reproducible science. It adds numerous software packages and libraries that are ready to use, as well as custom packages for GLiCID, and also allows you to work on a common platform with other mesocenters and national centers (such as CINES).
However, it is not a magical tool. It requires reading the documentation, does not include every piece of scientific software written in the world, and is not suitable for every situation. Its nature, which is very different from other package management systems, may not suit all users.
It is entirely up to the user whether or not to use it.
On the nautilus-devel-001 machine, the guix module is optional and not loaded by default -and for good reason-.
It is absolutely not a good idea to load it by default (in .bashrc, for example), especially if you don’t update your profile from time to time. Above all, you risk encountering software version conflicts (an outdated version of Slurm, libraries that are no longer compatible with what’s deployed on GLiCID, etc.).
Load the guix module only when you’re fully aware of the implications and when you actually need it.

Guix manages software environments in a way that is very different from conventional environments. It is helpful to know a few details. This documentation is not a substitute for the official Guix documentation, which is available here: https://guix.gnu.org/manual/1.5.0/en/guix.htm

One of the Guix benefits is to make the user completely autonomous in the installation of software (no administrator rights required). This operating mode is practical for an in-depth and rapid testing phase: no waiting for administrators to install the necessary software.

Guix can be used as an additional source of software but also as a runtime environment (particularly for reproducible executions)

For this purpose, we have front-end machines dedicated to Guix application development (guix-devel machines). On these machines, only the bare minimum is installed (including Slurm); the rest depends on what is installed in the user’s profile.

Each user can install what they need and have a completely different set of software than other users.

Guix even allows you to install many different versions of the same software, ad-hoc execution environments, cf. this part of the Guix documentation, or go back in time as explained here.

Installing Guix

Guix works equally well on all GLiCID machines (Nautilus or Waves cluster). The installed software is specific to each user and independent of the underlying operating system, which makes the solution very interesting in the case of a heterogeneous cluster.

Guix installs personalized for each user. A profile is created during The very first guix pull command.
This very first guix pull must be carried out from a native guix machine (guix-devel-001 for example) (Not Nautilus Login-node).

Once this is done, the profile is created (directories ~/.config/guix, ~/.guix-profile among others). On this occasion, an error may appear regarding a directory in /var/guix. This is recreated automatically, all you have to do is rerun the command.

Software installation

Guix can be used on all machines. On non-native Guix machines (RedHat 8 on Nautilus), you must load the Guix profile before you can use it. On Nautilus login (nautilus-devel-001) you can invoke the module guix/latest :

module load guix/latest
Reminder, see Installing Guix, the guix commands will only work if a Guix profile has already been initialized.
It is often better to set up execution environments using guix shell rather than installing a lot of software in your main profile using guix install

To install software, the steps to follow are as follows:

  1. guix pull is the first command to perform. It allows you to retrieve the list of packages available at the time of ordering. This command can be considered similar to apt update or yum update for distributions based on Debian or RedHat.

    This command actually does a lot more, (it retrieves a version history of all software from all channels and captures all dependencies between them). This is a complex process, which explains why the execution time of this command is much longer than the usual equivalents (several minutes).
    At the end of the very first guix pull it is advisable to dislodge yourself from the front end, then relocate to take into account the new environment (and in particular the software specific to GLiCID). This only needs to be done the very first time.

  2. Install, with guix install, the minimum to compile software. For example, for software written in C: guix install gcc make glibc.

  3. Check what is installed in your current profile: guix package -I

  4. Check what is installable: guix package -A

  5. Check if software exists: guix search chemical to search in the description, guix package -A | grep -i gromacs to search the list of packages.

  6. Install the software if it is directly available from the Guix repositories: guix install gromacs. Otherwise, compile it.

  7. Run it with slurm: srun -p short my-software' or `sbatch my-batch.

Slurm is installed as standard on frontends and compute nodes.

Software installed in your Guix profile is shared and available across the cluster.

Software installation does not consume space on your /home. the software, just like user profiles, is stored in the Guix global store. On your /home there are only links to your profile (and these links point to the global store, which is common to everyone).

Guix allows much, much more. Refer to its complete documentation.

Channels

Guix uses Git repositories (called channels) to dynamically build the list of available and installable software. By default, there is an official repository that currently contains more than 32,200 available packages, all of which are open-source.

To expand the software offering, Guix can use additional channels, which may contain:

  • scientific software or libraries for specific purposes,

  • software whose distribution license is incompatible with a free license, or available only in binary format, such as CUDA,

  • specific libraries (such as the CRAN repository for R),

  • software customized for optimal performance on a specific computing cluster, etc.

These additional channels, known as third-party channels, are not officially maintained by the Guix project, but by a small community.

Until May 2026, these repositories were included by default on GLiCID machines, with the aim of easily providing an expanded software offering—for example, making CUDA usable via Guix.

Since May 22, 2026, a single “GLiCID” channel has been included: This channel is the base Guix channel, enhanced with some additional software for optimal use on GliCID clusters. The reasons are as follows :

  • Third-party channels are not maintained in the same way as the main Guix channel and may regularly cause errors,

  • Building build profiles (during a guix pull, guix shell, guix time-machine, etc.) can take a very long time when many channels are included.

It is always possible to add channels to include this additional software.

Add Channels

After May 2026, when refreshing a build profile (via guix pull, guix shell, or guix time-machine), some previously available software may be missing, particularly anything related to CUDA.

If this is the case, you must add these channels (which were previously included by default).

As a user, simply create the file ~/.config/guix/channels.scm:

and include the channels to be used for any Guix command. These changes only affect the user making them.) For example :

(list (channel
        (name 'glicid)
        (url "https://gitlab.univ-nantes.fr/glicid-public/guix-glicid.git")
        (branch "main")
      )
      (channel
        (name 'glicid-addons)
        (url "https://gitlab.univ-nantes.fr/glicid-public/guix-glicid-addons.git")
        (branch "main")
      )
)

The guix-glicid-addons channel relies on guix-science, guix-science-nonfree, and nonguix, which are frequently used channels.

Special cases related to Guix for running jobs on the cluster.

If you are developing your own code—even if you rely solely on software available in Guix—you can use pure Guix environments. This ensures consistent behavior over time (and execution on other computing clusters).

In this specific case, it is recommended that you go to the guix-devel-001 frontend, develop your code, and run it from that machine.

Indeed, the software installed in your Guix profile OR included in ad-hoc runtime environment guix shell is completely autonomous and independent of the underlying system. The user’s Guix profile is available on all machines in the cluster. This allows all software in YOUR Guix profile ( The software programs that appear with the guix package -I command) or the runtime environment to run smoothly.

The exception is: software that is not in YOUR guix profile will not be available on redhat like machines. This may seem counterintuitive, but the basic frontend software (bash), common commands like ps or ls or even srun will not be. If the slurm submission scripts use such commands, then you must install them in ad-hoc execution environment using : guix shell bash coreutils procps slurm-glicid-client (rest of dependencies) — mycommand for example).
To find out if a program comes from the user profile or the underlying system, type which program. If it comes from /home/user/.guix-profile…, then it comes from the user’s profile and will work on all machines in the cluster. If it comes from /run/current-system/profile/ then it NOT comes from the user’s guix profile and will NOT work on other systems.

Illustration

$ which rsync
/home/dupont-y@univ-nantes.fr/.guix-profile/bin/rsync (1)

$ which ps
/run/current-system/profile/bin/ps (2)
1 is in the user profile
2 comes from the underlying system (and will not work on RedHat machines) 
~$ srun -p standard -q quick rsync --version
srun: job 2044 queued and waiting for resources
srun: job 2044 has been allocated resources
rsync  version 3.2.7  protocol version 31 (1)
Copyright (C) 1996-2022 by Andrew Tridgell, Wayne Davison, and others.
Web site: https://rsync.samba.org/
[...]


$ srun -p standard -q quick ps --version
srun: job 2047 queued and waiting for resources
srun: job 2047 has been allocated resources
slurmstepd: error: execve(): ps: No such file or directory (2)
srun: error: budbud015: task 0: Exited with exit code 2

[...]

srun -p standard -q quick guix shell procps -- ps --version (3)
ps from procps-ng 4.0.3


[...]

$ guix install procps (4)
The following package will be installed:
   procps 4.0.3
[...]

$ srun -p standard -q quick ps--version
srun: job 2050 queued and waiting for resources
srun: job 2050 has been allocated resources
ps from procps-ng 4.0.3 (4)
1 The software is available as expected
2 ps is not available in the user profile and therefore not found on CentOS machines
3 here , program is added in ad-hoc execution environment, without pollutin user profile
4 if program is permanently installed in the user profile, everything works as expected. Note that option 3 is often preferable.

Find the source of the missing software

In Guix, all installed software is invariable, independent from others AND stored in a global repository, common to the entire cluster. Sometimes package names are self-explanatory, sometimes not. In case software is available in the system, it is easy to see where it comes from:

$ which tail
/run/current-system/profile/bin/tail (1)

$ ls -al /run/current-system/profile/bin/tail
lrwxrwxrwx 1 root root 66 Jan  1  1970 /run/current-system/profile/bin/tail -> /gnu/store/yr39rh6wihd1wv6gzf7w4w687dwzf3vb-coreutils-9.1/bin/tail (2)

$ guix install coreutils (3)
The following package will be installed:
   coreutils 9.1

The following derivation will be built:
  /gnu/store/lpza4apps2g660glzb00rb185q99dvdc-profile.drv

building [...]

$ which tail
/home/dupont-y@univ-nantes.fr/.guix-profile/bin/tail (3)
1 the tail command comes from the system, not the user profile
2 the tail command comes from the coreutils package
3 by installing this package in its profile, the commands included in coreutils (including tail) will become usable across the entire cluster

Minimum profile to compile software in C with guix

guix shell gcc-toolchain glibc binutils make — bash. Enough for compil a little «hello world».

you must understand that in reality, you do not install this software in your HOME, you just make them available in this execution profile.

cuda projects

Cuda is a proprietary, non-free library, only available in binary format, by the will of the company that develops it (nvidia). This library is therefore not available as standard in Guix. As noted in the Channels chapter, you need to specify additional channels to simplify the installation of such software. Once done, cuda is therefore easily installable:
guix install cuda-toolkit or

guix shell cuda-toolkit rest-of-neccessary-dependancies -- mycommand
gpu nodes work under REDHAT 8.10. Programs compiled on frontends with Guix work perfectly provided you add a LD_LIBRARY_PATH path.

cf. the following example to launch a gromacs compiled with cuda (package gromacs+gpu):

LD_PRELOAD=/usr/lib64/libcuda.so.1 srun -p short -C gpu_a100 gmx -version

Detailed explaination

CUDA has a library component, which the application uses, and a hardware-related component (the GPU driver). It is possible to use different versions of CUDA for these two components (as long as backward compatibility is maintained).

See the explanation at https://docs.nvidia.com/deploy/cuda-compatibility/forward-compatibility.html (just the beginning of the page).

Regardless of which version of CUDA you use, you simply need to use the correct library that interfaces with the driver loaded by the machine’s Linux kernel: this library must match the version of the driver being used.

In the context of an application developed with Guix, this means:

  • Use a version of cuda-toolkit that meets the software’s requirements AND is compatible with the drivers deployed on the target machines (on both Nautilus and Waves, these are currently version 575 drivers, compatible with CUDA 12.9),

  • Use the correct version of libcuda.so.1 (the library that acts as a bridge to the kernel driver) and, consequently, currently version 575.

In the context of Guix, which allows development independent of any system library, this would therefore require additionally installing a version 575 of libcuda.so.1 in the runtime profile.

It is easier and future-proof to preload the library from the machine on which the code will run, hence the LD_PRELOAD=/usr/lib64/libcuda.so.1 . Doing so ensures that we have the version that matches the current NVIDIA driver deployed on our machines (which may change over time).

openmpi projects

It is recommended to use the openMPI strain specially usable on all GLiCID machines: openmpi-glicid

If the srun software is to be launched in a sbatch running on non-native Guix machines (budbud, gnodes…), you must also install the slurm package: guix shell slurm-glicid. The reason is explained in the “[software_profile_system]” chapter.

FAQ

NAUTILUS

If you use Guix on GLiCID, AND Slurm is installed in your personal profile, AND your profile was not updated recently, it may remains at an old version and will give you error messages like:

«Invalid Protocol Version 10752 from uid… Incompatible versions of client and server code»

or

«sbatch --version
sbatch: error: _parse_next_key: Parsing error at unrecognized key: MetricsType
sbatch: error: _parse_next_key: Parsing error at unrecognized key: NamespaceType
»

If this is your case :

  • you can upgrade your profile : guix pull ; guix upgrade : slurm-glicid will be upgraded.

  • you can remove slurm from your personal profile and only use it for specific runtime environment using guix shell slurm-glicid …

  • you may simply not need it if you’re not running a pure guix environment and thus, remove it from the personal profile guix remove slurm-glicid