Reproducibility of a research study in computer science has always been a complex matter. One of the biggest challenges is to recreate the original software environment. The latter is often built manually or using modules [1], especially on high-performance computing (HPC) platforms. The main issue with this approach is that modules and building instructions are likely to vary from one machine to another depending on system configuration and available software. Some package managers such as Spack [2] allow users to define their own package variants and leave them the choice of the configuration, the dependencies or the compiler. However, as the package manager still depends on compilers and other components provided by the underlying system, the reproducibility of software environments remains threatened. From this point of view, the container solutions such us Singularity [3] or Docker [4] are more robust but they do not make updating or management of multiple environment variants very easy. For example, if we want to use a different version of one or more packages, we either have to modify the container interactively, which would make it even less reproducible, or re-build it, which can take lot of time if performed regularly. Moreover, because the container is often based on an existing Linux distribution, we are limited to the versions of various core packages (compilers, MPI¹, BLAS², …) provided by that particular distribution in that particular release unless we want to manually re-build and re-configure a significant portion of the software environment. In the aim to cope with these limitations, take total control over our software environments and be able to adapt and reproduce them easily, we propose to explore and practice Guix [5], [6].

Another challenge to the reproducibility of an experimental research study is the ability to rerun the associated computational experiments. We often need to repeat experiments more than once, using different software versions and algorithmic options, possibly months or even years apart. The importance of maintaining a complete and well-structured documentation—allowing both ourselves and others to recreate the experimental software environment, rerun all the experiments, and post-process the results—is therefore critical. While a detailed README file and thoroughly commented source code address this need to some extent, we propose going further by adopting literate programming [7], a paradigm that combines source code with a natural language narrative. Among the many literate programming tools available, we will present Org mode [8], [9] for the Emacs editor. With Org mode, we can write a document that combines formatted text, images, and figures with blocks of source code. These code blocks can be extracted as files [10], for example to be compiled, or evaluated on the fly [11]. The results of the evaluation—such as a figure or the return value of a computation—can then be included directly in the document. We can export this document in various formats [12], and share it with the community, whether as a scientific publication, a research report, or a simple web page.

Finally, we will discuss the long-term availability of the elements of a research study and the associated source code, including external dependencies. Even when hosted in version-controlled repositories on a source code forge such as Inria Forge or BitBucket, they can suddenly become unavailable—for example, due to a repository migration or the permanent shutdown of the platform. We will therefore introduce the Software Heritage [13] and the Zenodo [14] projects, which are dedicated to the long-term archival of source code, experimental datasets and other artifacts.

The main focus of this tutorial is on the reproducibility of an experimental software environment. After a brief tour of Guix, Nix and other possible solutions, participants will learn the basics of software deployment with Guix by the means of a hands-on session.

Then, participants will use Guix to reproduce the experimental software environment of an existing research study and be able to observe its advantages over the aforementioned approaches.

Finally, participants will use Guix to build a reproducible experimental software environment from scratch.

Following the hands-on session, we will discuss how to improve the reproducibility of an experimental research study even further thanks to the association of a package manager such as Guix, the literate programming paradigm and an adapted long-term archival solution.

This tutorial is intended for scientists and engineers looking for a complete software framework that enables them to:

• create reproducible software environments, whether for high-performance computing (HPC) experiments, to achieve reproducible research results, or to share development environments,
• maintain complete and structured documentation that makes it possible to reproduce a set of computational experiments along with the associated software environment,
• ensure the long-term availability of the components of an experimental scientific study.

A basic knowledge of GNU/Linux is required: processes, command line, and software installation.

The hands-on session can take place:

• on participants’ laptops, provided they have installed GNU Guix version 1.5.0 in advance by following the instructions; approximately 20 GiB of free space on the root partition (/) will be needed during the hands-on session;
• on the Grid'5000 experimental testbed [15] accessible to participants via SSH; in that case, participants will need to have an SSH client and know how to use it.

For the needs of the tutorial, we have created a special project group, namely Publish a reproducible result (JRFRR 2026), on GitLab.com with the following structure:

Publish a reproducible result (JRFRR 2026)
  ├── Channel
  ├── Slides
  ├── Study
  └── Tutorial

We address the Channel repository later in Section 6.4. The Tutorial repository contains the sources of the present document and Slides the sources of the companion slides (accessible by clicking the button on the left-side panel of this page). We do not report further on these two repositories.

Finally, the Studies repository contains an example experimental resarch study assessing the performance of minisolver [16], a simple application for solving dense linear systems arising from aeroacoustic simulations, by the means of a set of numerical experiments.

During the hands-on session, participants will work on the Studies repository which has the following structure:

Study
  ├── .guix
  │   ├── channels.scm
  │   └── manifest.scm
  ├── .gitattributes
  ├── .gitignore
  ├── .gitlab-ci.yml
  ├── AUTHORS
  ├── LICENSE
  ├── README.md
  ├── benchmarks.csv
  ├── cylinder.png
  ├── plot.py
  ├── references.bib
  ├── results.csv (LFS)
  └── study.tex

The .guix folder contains everything one needs to reproduce the experimental software environment of the study using Guix. The environment contains the necessary software packages to:

• run the set of numerical experiments involving minisolver according to the parameters defined in benchmarks.csv, where each line represents one experiment, and store the results into results.csv;
• post-process results.csv, i.e., format data and draw plots, using the plot.py Python script;
• produce the PDF version of a manuscript presenting and analyzing the experimental results of the study by compiling its LaTeX source files, i.e., study.tex and references.bib.

In the first place, we will put the experimental studies aside and familiarize ourselves with Guix.

In addition to the bibliography at the end of the document, the following pointers may be of interest for those who would like to learn further on how to use Guix, Org mode for Emacs or long-term archival solutions:

• https://guix-org-tutorial-compas-2025.gitlab.io/tutorial/ (Guix and Org mode tutorial, ComPAS'2025, Bordeaux, France)
• https://felsoci.sk/blog/posts.html (blog of Marek Felšöci with posts on Guix and Org mode usage - for work and for home)
• https://hpc.guix.info/ (Guix-HPC, reproducible software deployment for high-performance computing: channels, packages, events, …)
• https://cours-mf.gitlabpages.inria.fr/is328/tuto-chameleon.html (tutorial on how to use Guix or Singularity images produced by Guix on HPC platforms such as PlaFRIM)