From 89befa39184c1643563f91f8ec669b1cd06565de Mon Sep 17 00:00:00 2001 From: Philipp Baumann Date: Thu, 19 Sep 2024 20:38:44 +0200 Subject: [PATCH] link runner instead of badge --- README.Rmd | 2 +- README.md | 482 +++++++++++++++++++++++++---------------------------- 2 files changed, 227 insertions(+), 257 deletions(-) diff --git a/README.Rmd b/README.Rmd index 3bf1500e..47d52d55 100644 --- a/README.Rmd +++ b/README.Rmd @@ -19,7 +19,7 @@ output: github_document - [Recommended reading](#recommended-reading) -[![R-hub v2](https://github.com/ropensci/rix/actions/workflows/rhub.yaml/badge.svg)](https://github.com/ropensci/rix/actions/workflows/rhub.yaml/badge.svg) +[![R-hub v2](https://github.com/ropensci/rix/actions/workflows/rhub.yaml/badge.svg)](https://github.com/ropensci/rix/actions/workflows/rhub.yaml/) [![runiverse-package rix](https://ropensci.r-universe.dev/badges/rix?scale=1&color=pink&style=round)](https://ropensci.r-universe.dev/rix) [![Docs](https://img.shields.io/badge/docs-release-blue.svg)](https://docs.ropensci.org/rix) [![Status at rOpenSci Software Peer Review](https://badges.ropensci.org/625_status.svg)](https://github.com/ropensci/software-review/issues/625) diff --git a/README.md b/README.md index 888ffd1c..84ff11fc 100644 --- a/README.md +++ b/README.md @@ -1,15 +1,15 @@ +--- +output: github_document +--- # rix: Reproducible Environments with Nix -- [Reproducible Environments with - Nix](#reproducible-environments-with-nix) +- [Reproducible Environments with Nix](#reproducible-environments-with-nix) - [Introduction](#introduction) - [Quick start for returning users](#quick-start-for-returning-users) - [Getting started for new users](#getting-started-for-new-users) - [Docker](#docker) - - [How is Nix different from - Docker+renv/{groundhog}/{rang}/(Ana/Mini)Conda/Guix? or Why - Nix?](#how-is-nix-different-from-dockerrenvgroundhogranganaminicondaguix-or-why-nix) + - [How is Nix different from Docker+renv/{groundhog}/{rang}/(Ana/Mini)Conda/Guix? or Why Nix?](#how-is-nix-different-from-dockerrenvgroundhogranganaminicondaguix-or-why-nix) - [Docker and renv](#docker-and-renv) - [Ana/Miniconda and Mamba](#anamini-conda-and-mamba) - [How is Nix different from Guix?](#how-is-nix-different-from-guix) @@ -19,124 +19,112 @@ - [Recommended reading](#recommended-reading) - -[![R-hub -v2](https://github.com/ropensci/rix/actions/workflows/rhub.yaml/badge.svg)](https://github.com/ropensci/rix/actions/workflows/rhub.yaml/badge.svg) -[![runiverse-package -rix](https://ropensci.r-universe.dev/badges/rix?scale=1&color=pink&style=round)](https://ropensci.r-universe.dev/rix) +[![R-hub v2](https://github.com/ropensci/rix/actions/workflows/rhub.yaml/badge.svg)](https://github.com/ropensci/rix/actions/workflows/rhub.yaml/) +[![runiverse-package rix](https://ropensci.r-universe.dev/badges/rix?scale=1&color=pink&style=round)](https://ropensci.r-universe.dev/rix) [![Docs](https://img.shields.io/badge/docs-release-blue.svg)](https://docs.ropensci.org/rix) -[![Status at rOpenSci Software Peer -Review](https://badges.ropensci.org/625_status.svg)](https://github.com/ropensci/software-review/issues/625) +[![Status at rOpenSci Software Peer Review](https://badges.ropensci.org/625_status.svg)](https://github.com/ropensci/software-review/issues/625) + + ## Introduction -`{rix}` is an R package that leverages [Nix](https://nixos.org/), a -powerful package manager focusing on reproducible builds. With Nix, it -is possible to create project-specific environments that contain a -project-specific version of R and R packages (as well as other tools or -languages, if needed). This project-specific environment will also -include all the required system-level dependencies that can be difficult -to install, such as `GDAL` for packages for geospatial analysis for -example. Nix installs software as a complete “bundle” that include all -of the software’s dependencies, and all of the dependencies’ -dependencies and so on. Nix is an incredibly useful piece of software -for ensuring reproducibility of projects, in research or otherwise. - -Some other use cases include, for example, running web applications like -Shiny apps or `{plumber}` APIs in a controlled environment, or executing -`{targets}` pipelines with the right version of R and dependencies, or -use environments managed by Nix to work interactively using an IDE. - -In essence, this means that you can use `{rix}` and Nix to replace -`{renv}` and Docker with one single tool, but the approach is quite -different: `{renv}` records specific versions of individual packages, -while `{rix}` provides a complete snapshot of the R ecosystem at a -specific point in time, but also snapshots all the required dependencies -to make your project-specific R environment work. In contrast, to ensure -complete reproducibility with `{renv}`, it must be combined with Docker, -in order to include system-level dependencies (like `GDAL`, as per the -example above). - -Nix has a fairly steep learning curve though. Nix is a complex piece of -software that comes with its own programming language, which is also -called Nix. Its purpose is to solve a complex problem: defining -instructions on how to build software packages and manage configurations -in a declarative way, using functional programming principles. This -makes sure that software gets installed in a fully reproducible manner, -on any operating system or hardware, but with the caveat that users must -learn the Nix programming language and get into the “functional -programming approach to software management” mindset, which is unusual. - -`{rix}` provides functions to help you write Nix expressions (written in -the Nix language). These expressions will be the inputs for the Nix -package manager, to build sets of software packages and provide them in -a reproducible development environment. These environments can be used -for interactive data analysis, or reproduced when running pipelines in -CI/CD systems. The [Nixpkgs -collection](https://github.com/nixos/nixpkgs) includes currently more -than 100.000 pieces of software available through the Nix package -manager. - -With `{rix}`, you can define development environments, or shells, that -contain the required tools needed to analyze data using R. These -environments are isolated from each other and project-specific: this -means that a project can use one version of R and R packages, and -another environment another version of R and R packages. However, extra -care is required if you already have R installed through the usual -method for your operating system, as these development environments are -not totally isolated from the rest of your system. Unlike Docker, where -a running container cannot acces anything from the host system, unless -explicitely configured to do so, Nix development shells are nothing but -environments that add more software to the list of already available -software (the so-called `PATH`). As such, it is possible to access -anything (files and software) already present on the system from a -running Nix shell. Thus, `{rix}` also provides a function called -`rix_init()` that helps isolate R sessions running inside Nix -environments from the rest of your system. This avoids clashes between -the Nix-specific library of R packages and the user library of R -packages should you already have R installed and managed by the usual -method for your operating system. - -It is also possible to add any other software package available on -Nixpkgs to a Nix environment, for example IDEs such as RStudio or VS -Code. The Nix R ecosystem currently includes almost the entirety of CRAN -and Bioconductor packages (there is around a hundred CRAN or -Biocondcuctor packages that are unavailable through Nix). Like with any -other programming language or software, it is also possible to install -older releases of R packages, or install packages from GitHub at defined -states, as well as local packages in the `.tar.gz` format. - -The Nix package manager is extremely powerful. Not only does it handle -all the dependencies of any package extremely well in a deterministic -manner, it is also possible with it to reproduce environments containing -old releases of software. It is thus possible to build environments -containing R version 4.0.0 (for example) to run an old project that was -originally developed on that version of R. - -If you need other tools or languages like Python or Julia, this can also -be done easily. Nix is available for Linux, macOS and Windows (via WSL2) -and `{rix}` comes with the following features: - -- define complete development environments as code and use them - anywhere; -- install project-specific complete R environments, which can be - different from each other; +`{rix}` is an R package that leverages [Nix](https://nixos.org/), a powerful +package manager focusing on reproducible builds. With Nix, it is possible to +create project-specific environments that contain a project-specific version of +R and R packages (as well as other tools or languages, if needed). This +project-specific environment will also include all the required system-level +dependencies that can be difficult to install, such as `GDAL` for packages for +geospatial analysis for example. Nix installs +software as a complete "bundle" that include all of the software's dependencies, and all of +the dependencies' dependencies and so on. Nix is an incredibly useful piece of +software for ensuring reproducibility of projects, in research or otherwise. + +Some other use cases include, for example, running web applications like Shiny apps or `{plumber}` APIs +in a controlled environment, or executing `{targets}` pipelines with the right version +of R and dependencies, or use environments managed by Nix to work interactively using an IDE. + +In essence, this means that you can use `{rix}` and Nix to replace `{renv}` and +Docker with one single tool, but the approach is quite different: `{renv}` +records specific versions of individual packages, while `{rix}` provides a +complete snapshot of the R ecosystem at a specific point in time, but also +snapshots all the required dependencies to make your project-specific R +environment work. In contrast, to ensure complete reproducibility with `{renv}`, it must be +combined with Docker, in order to include system-level dependencies (like `GDAL`, +as per the example above). + +Nix has a fairly steep learning curve though. Nix is a complex piece of software that +comes with its own programming language, which is also called Nix. Its purpose +is to solve a complex problem: defining instructions on how to build software +packages and manage configurations in a declarative way, using functional programming +principles. This makes sure that software gets installed in a fully reproducible manner, +on any operating system or hardware, but with the caveat that users must learn the Nix +programming language and get into the "functional programming approach to software management" +mindset, which is unusual. + +`{rix}` provides functions to help you write Nix expressions (written in the Nix +language). These expressions will be the inputs for the Nix package manager, to +build sets of software packages and provide them in a reproducible development +environment. These environments can be used for interactive data analysis, or +reproduced when running pipelines in CI/CD systems. The [Nixpkgs +collection](https://github.com/nixos/nixpkgs) includes currently more than +100.000 pieces of software available through the Nix package manager. + +With `{rix}`, you can define development environments, or shells, that contain +the required tools needed to analyze data using R. These environments are +isolated from each other and project-specific: this means that a project can use +one version of R and R packages, and another environment another version of R +and R packages. However, extra care is required if you already have R installed +through the usual method for your operating system, as these development +environments are not totally isolated from the rest of your system. Unlike +Docker, where a running container cannot acces anything from the host system, +unless explicitely configured to do so, Nix development shells are nothing but +environments that add more software to the list of already available software +(the so-called `PATH`). As such, it is possible to access anything (files and +software) already present on the system from a running Nix shell. Thus, `{rix}` +also provides a function called `rix_init()` that helps isolate R sessions +running inside Nix environments from the rest of your system. This avoids +clashes between the Nix-specific library of R packages and the user library of R +packages should you already have R installed and managed by the usual method for +your operating system. + +It is also possible to add any other software package available on Nixpkgs to a +Nix environment, for example IDEs such as RStudio or VS Code. The Nix R +ecosystem currently includes almost the entirety of CRAN and Bioconductor +packages (there is around a hundred CRAN or Biocondcuctor packages that are +unavailable through Nix). Like with any other programming language or software, +it is also possible to install older releases of R packages, or install packages +from GitHub at defined states, as well as local packages in the `.tar.gz` +format. + +The Nix package manager is extremely powerful. Not only does it handle all the +dependencies of any package extremely well in a deterministic manner, it is also +possible with it to reproduce environments containing old releases of software. +It is thus possible to build environments containing R version 4.0.0 (for +example) to run an old project that was originally developed on that version of +R. + +If you need other tools or languages like Python or Julia, this can also be done +easily. Nix is available for Linux, macOS and Windows (via WSL2) and `{rix}` +comes with the following features: + +- define complete development environments as code and use them anywhere; +- install project-specific complete R environments, which can be different from each other; - run single R functions (and objects in the call stack) in a different - environment (potentially with a different R version and R packages) - for an interactive R session, and get back the output of that function - using + environment (potentially with a different R version and R packages) for an + interactive R session, and get back the output of that function using [`with_nix()`](https://docs.ropensci.org/rix/reference/with_nix.html); `{rix}` does not require Nix to be installed on your system to generate -expressions. This means that you can generate expressions on a system on -which you cannot easily install software, and then use these expressions -on the cloud or on a CI/CD environment to build the project there. +expressions. This means that you can generate expressions on a system on which +you cannot easily install software, and then use these expressions on the cloud +or on a CI/CD environment to build the project there. + +If you have R installed, you can start straight away from your R session by +first installing `{rix}`: -If you have R installed, you can start straight away from your R session -by first installing `{rix}`: ``` r install.packages("rix", repos = c( @@ -149,6 +137,7 @@ library("rix") Now try to build an expression using `rix()`: + ``` r library(rix) @@ -166,12 +155,11 @@ rix( ) ``` -This generates a file called `default.nix` in the path -`path_default_nix` with the correct expression to build this -environment. To build the environment, the Nix package manager must be -installed. If you have Nix installed, you can build the expression above -using the `nix-build` terminal command and then enter the environment -using `nix-shell`. The vignettes included in the package walk you +This generates a file called `default.nix` in the path `path_default_nix` with +the correct expression to build this environment. To build the environment, +the Nix package manager must be installed. If you have Nix installed, you can +build the expression above using the `nix-build` terminal command and then enter +the environment using `nix-shell`. The vignettes included in the package walk you through the whole workflow. ## Quick start for returning users @@ -179,15 +167,14 @@ through the whole workflow. *If you are not familiar with Nix or `{rix}` skip to the next section.*
- -Click to expand - -If you are already familiar with Nix and R, and simply want to get -started as quickly as possible, you can start by installing Nix using -the installer from [Determinate -Systems](https://determinate.systems/posts/determinate-nix-installer) a -company that provides services and tools built on Nix: +Click to expand +If you are already familiar with Nix and R, and simply want to get started as +quickly as possible, you can start by installing Nix using the installer from +[Determinate +Systems](https://determinate.systems/posts/determinate-nix-installer) a company +that provides services and tools built on Nix: + ``` sh curl --proto '=https' --tlsv1.2 -sSf \ @@ -195,11 +182,11 @@ curl --proto '=https' --tlsv1.2 -sSf \ sh -s -- install ``` -You can check that everything works well by trying to build the Nix -expression that ships with `{rix}`. Nix expressions are typically saved -into files with the name `default.nix` or `shell.nix`. This expression -installs the latest version of R and `{rix}` in a separate, reproducible -environment: +You can check that everything works well by trying to build the Nix expression +that ships with `{rix}`. Nix expressions are typically saved into files with the +name `default.nix` or `shell.nix`. This expression installs the latest version +of R and `{rix}` in a separate, reproducible environment: + ``` r file.copy( @@ -213,32 +200,35 @@ nix_build(project_path = ".") ``` If everything worked well, you should see a file called `result` next to -`default.nix`. You can now enter this newly built development -environment by opening a terminal in that folder and typing `nix-shell`. -You should be immediately dropped into an interactive R session. +`default.nix`. You can now enter this newly built development environment by +opening a terminal in that folder and typing `nix-shell`. You should +be immediately dropped into an interactive R session. -If you don’t have R installed, but have the Nix package manager -installed, you can run a temporary R session with R using this command -(it will build the same environment as the one above): +If you don't have R installed, but have the Nix package manager installed, you +can run a temporary R session with R using this command (it will build the same +environment as the one above): - nix-shell --expr "$(curl -sl https://raw.githubusercontent.com/ropensci/rix/main/inst/extdata/default.nix)" +``` +nix-shell --expr "$(curl -sl https://raw.githubusercontent.com/ropensci/rix/main/inst/extdata/default.nix)" +``` -You can then create new development environment definitions, build them, -and start using them. +You can then create new development environment definitions, build them, and +start using them.
## Getting started for new users -To get started with `{rix}` and Nix, you should read the following -vignette `vignette("a-getting-started")` ([online -documentation](https://docs.ropensci.org/rix/articles/a-getting-started.html)). -The vignettes are numbered to get you to learn how to use `{rix}` and -Nix smoothly. There’s a lot of info, so take your time reading the -vignettes. Don’t hesitate to open an issue if something is not clear. +To get started with `{rix}` and Nix, you should read the following vignette +`vignette("a-getting-started")` +([online documentation](https://docs.ropensci.org/rix/articles/a-getting-started.html)). +The vignettes are numbered to get you to learn +how to use `{rix}` and Nix smoothly. There’s a lot of info, so take your time +reading the vignettes. Don’t hesitate to open an issue if something is not +clear. ### Docker -You can also try out Nix inside Docker. To know more, read +You can also try out Nix inside Docker. To know more, read `vignette("z-advanced-topic-using-nix-inside-docker")` [link](https://github.com/ropensci/rix/blob/HEAD/vignettes/z-advanced-topic-using-nix-inside-docker.Rmd). @@ -246,105 +236,96 @@ You can also try out Nix inside Docker. To know more, read ### Docker and renv -Let’s start with arguably the most popular combo for reproducibility in -the R ecosystem, Docker+`{renv}`. +Let's start with arguably the most popular combo for reproducibility in the R +ecosystem, Docker+`{renv}`. -{renv} snapshots the state of the library of R packages for a project, -nothing more, nothing less, unless you also use `{rspm}` or `{bspm}` in +{renv} snapshots the state of the library of R packages for a project, nothing +more, nothing less, unless you also use `{rspm}` or `{bspm}` in combination to `{renv}`: this will install the required system-level -dependencies automatically. `{renv}` can then be used to restore the -library of packages on another machine, but it is the user’s -responsibility to ensure that the right version of R and system-level -dependencies are available on that other machine. This is why `{renv}` -is often coupled with a versioned Docker image, such as the images from -the [Rocker project](https://hub.docker.com/r/rocker/r-ver). Combining -both provides a very robust way to serve applications such as Shiny -apps, but it can be awkward to develop interactively with this setup, -which is why most of the time, people work on their current setup, and -*dockerize* the setup once when they’re done. However, you need to make -sure to keep updating the image, as the underlying operating system will -eventually reach end of life. Eventually, you might even have to update -the whole stack as it could become impossible to install the version of -R and R packages you used on a recent Docker image. This can be a good -thing actually; it could be the opportunity to update your app and make -sure that it benefits from the latest security patches. However for -reproducibility in research, this is not something that you should be -doing because it could have an impact on historical results. - -What we suggest instead, is to keep using Docker if you are already -invested in the ecosystem, and continue to use it to deploy and serve -applications and archive research. But instead of using `{renv}` to get -the right packages, you combine Docker and Nix. This way, you have a -nice separation of concerns: Docker will only be used as a platter to -serve code, while the environment will be handled by Nix. You could even -use an image that gets continuously updated such as `ubuntu:latest` as a -base: it doesn’t matter that the image is always changing, since the -environment that will be doing the heavy lifting inside the container is -completely reproducible thanks to Nix. - -Exactly the same reasoning can be applied to `{groundhog}`, `{rang}` or -the CRAN snapshots of Posit in combination to Docker instead of -`{renv}`. +dependencies automatically. `{renv}` can then be used to restore the library of packages on +another machine, but it is the user's responsibility to ensure that the right +version of R and system-level dependencies are available on that other machine. +This is why `{renv}` is often coupled with a versioned Docker image, such as the +images from the [Rocker project](https://hub.docker.com/r/rocker/r-ver). +Combining both provides a very robust way to serve applications such as Shiny +apps, but it can be awkward to develop interactively with this setup, which is +why most of the time, people work on their current setup, and *dockerize* the +setup once when they're done. However, you need to make sure to keep updating +the image, as the underlying operating system will eventually reach end of life. +Eventually, you might even have to update the whole stack as it could become +impossible to install the version of R and R packages you used on a recent +Docker image. This can be a good thing actually; it could be the opportunity to +update your app and make sure that it benefits from the latest security patches. +However for reproducibility in research, this is not something that you should +be doing because it could have an impact on historical results. + +What we suggest instead, is to keep using Docker if you are already invested in +the ecosystem, and continue to use it to deploy and serve applications and +archive research. But instead of using `{renv}` to get the right packages, you +combine Docker and Nix. This way, you have a nice separation of concerns: Docker +will only be used as a platter to serve code, while the environment will be +handled by Nix. You could even use an image that gets continuously updated such +as `ubuntu:latest` as a base: it doesn’t matter that the image is always +changing, since the environment that will be doing the heavy lifting inside the +container is completely reproducible thanks to Nix. + +Exactly the same reasoning can be applied to `{groundhog}`, `{rang}` or the CRAN +snapshots of Posit in combination to Docker instead of `{renv}`. ### Ana/Mini-conda and Mamba -Anaconda, Miniconda, Mamba, Micromamba… (henceforth we’ll refer to these -as Conda) and Nix have much in common: they are multiplatform package -managers and both can be used to setup reproducible development -environments for many languages, such as R or Python. Using +Anaconda, Miniconda, Mamba, Micromamba... (henceforth we'll refer to these as +Conda) and Nix have much in common: they are multiplatform package managers and +both can be used to setup reproducible development environments for many +languages, such as R or Python. Using [conda-lock](https://github.com/conda/conda-lock) one can generate fully -reproducible lock files that can then be used by Conda to build the -environment as defined in the lock file. The main difference between -Conda and Nix is conceptual and might not seem that important for -end-users: Conda is a procedural package manager, while Nix is a -functional package manager. In practice this means that environments -managed by Conda are mutable and users are not prevented from changing -their environment interactively, and then re-generate the lock file. -This is quite comfortable when working interactively, but can lead to -issues where dependency management might get borked. - -In the case of Nix however, environments are immutable: you cannot add -software into a running Nix environment. You will need to stop working, -re-define the environment, rebuild it and then use it. While this might -sound more tedious (it is) it forces users to work more “cleanly” and -avoids many issues from dynamically changing an environment. If it is -not possible to build that environment, it fails as early as possible -and forces you to deal with the issue. A mutating environment could lead -you into a false sense of security. - -Another major difference is that Conda does not include the entirety of -CRAN nor Bioconductor, which is the case for Nix. According to -[Anaconda’s +reproducible lock files that can then be used by Conda to build the environment +as defined in the lock file. The main difference between Conda and Nix is +conceptual and might not seem that important for end-users: Conda is a +procedural package manager, while Nix is a functional package manager. In +practice this means that environments managed by Conda are mutable and users are +not prevented from changing their environment interactively, and then +re-generate the lock file. This is quite comfortable when working interactively, +but can lead to issues where dependency management might get borked. + +In the case of Nix however, environments are immutable: you cannot add software +into a running Nix environment. You will need to stop working, re-define the +environment, rebuild it and then use it. While this might sound more tedious (it +is) it forces users to work more "cleanly" and avoids many issues from +dynamically changing an environment. If it is not possible to build that +environment, it fails as early as possible and forces you to deal with the +issue. A mutating environment could lead you into a false sense of security. + +Another major difference is that Conda does not include the entirety of CRAN nor +Bioconductor, which is the case for Nix. According to [Anaconda's Documentation](https://docs.anaconda.com/working-with-conda/packages/using-r-language/) -6000 CRAN packages are available through Conda (as of writing in July -2024, CRAN has 21’000+ packages). Nix also includes almost all of -Bioconductor packages, and Conda includes them trough the Bioconda -project, however, we were not able to find if Bioconda contains all of -Bioconductor. According to Bioconda’s FAQ, [Bioconductor data packages -are not +6000 CRAN packages are available through Conda (as of writing in July 2024, CRAN +has 21'000+ packages). Nix also includes almost all of Bioconductor packages, +and Conda includes them trough the Bioconda project, however, we were not able +to find if Bioconda contains all of Bioconductor. According to Bioconda's FAQ, +[Bioconductor data packages are not included.](https://bioconda.github.io/faqs.html#why-are-bioconductor-data-packages-failing-to-install) ### How is Nix different from Guix? -Just like Nix, Guix is a functional package manager with a focus on -reproducible builds. We won’t go into technical -differences/similarities, but only to pratical ones for end-users of the -R programming language. If you want to know about technical aspects, -read this -[https://news.ycombinator.com/item?id=18910683](Hackernews%20post%20by%20one%20of%20the%20authors%20of%20Guix). -The main shortcoming of Guix for R users is that not all CRAN or -Bioconductor packages are included, nor is Guix available on Windows or +Just like Nix, Guix is a functional package manager with a focus on reproducible +builds. We won't go into technical differences/similarities, but only to +pratical ones for end-users of the R programming language. If you want to know +about technical aspects, read this +[https://news.ycombinator.com/item?id=18910683](Hackernews post by one of the +authors of Guix). The main shortcoming of Guix for R users is that not all CRAN +or Bioconductor packages are included, nor is Guix available on Windows or macOS. ### Is {rix} all there is? -No, there are other tools that you might want to check out, especially -if you want to set up polyglot environments (even though it is possible -to use `{rix}` to set up an environment with R and Python packages for -example). +No, there are other tools that you might want to check out, especially if +you want to set up polyglot environments (even though it is possible to +use `{rix}` to set up an environment with R and Python packages for example). -Take a look at and if you -want to explore other tools that make using Nix easier! +Take a look at [https://devenv.sh/](https://devenv.sh/) and +[https://prefix.dev/](https://prefix.dev/) if you want to explore other tools +that make using Nix easier! ## Contributing @@ -356,41 +337,30 @@ project, you agree to abide by its terms. ## Thanks -Thanks to the [Nix community](https://nixos.org/community/) for making -Nix possible, and thanks to the community of R users on Nix for their -work packaging R and CRAN/Bioconductor packages for Nix (in particular -[Justin Bedő](https://github.com/jbedo), [Rémi -Nicole](https://github.com/minijackson), +Thanks to the [Nix community](https://nixos.org/community/) for making Nix +possible, and thanks to the community of R users on Nix for their work +packaging R and CRAN/Bioconductor packages for Nix (in particular [Justin +Bedő](https://github.com/jbedo), [Rémi Nicole](https://github.com/minijackson), [nviets](https://github.com/nviets), [Chris Hammill](https://github.com/cfhammill), [László Kupcsik](https://github.com/Kupac), [Simon Lackerbauer](https://github.com/ciil), -[MrTarantoga](https://github.com/MrTarantoga) and every other person -from the [Matrix Nixpkgs R channel](https://matrix.to/#/#r:nixos.org)). +[MrTarantoga](https://github.com/MrTarantoga) and every other person from the +[Matrix Nixpkgs R channel](https://matrix.to/#/#r:nixos.org)). -Finally, thanks to [David Solito](https://x.com/dsolito) for creating -`{rix}`’s logo! +Finally, thanks to [David Solito](https://x.com/dsolito) for creating `{rix}`'s logo! ## Recommended reading - [NixOS’s website](https://nixos.org/) - [Nixpkgs’s GitHub repository](https://github.com/NixOS/nixpkgs) -- [Nix for R series from Bruno’s - blog](https://www.brodrigues.co/tags/nix/). Or, in case you like video - tutorials, watch [this one on Reproducible R development environments - with Nix](https://www.youtube.com/watch?v=c1LhgeTTxaI) -- [nix.dev - tutorials](https://nix.dev/tutorials/first-steps/towards-reproducibility-pinning-nixpkgs#pinning-nixpkgs) -- [INRIA’s Nix - tutorial](https://nix-tutorial.gitlabpages.inria.fr/nix-tutorial/installation.html) +- [Nix for R series from Bruno's blog](https://www.brodrigues.co/tags/nix/). Or, in case you like video tutorials, watch [this one on Reproducible R development environments with Nix](https://www.youtube.com/watch?v=c1LhgeTTxaI) +- [nix.dev tutorials](https://nix.dev/tutorials/first-steps/towards-reproducibility-pinning-nixpkgs#pinning-nixpkgs) +- [INRIA's Nix tutorial](https://nix-tutorial.gitlabpages.inria.fr/nix-tutorial/installation.html) - [Nix pills](https://nixos.org/guides/nix-pills/) -- [Nix for Data - Science](https://github.com/nix-community/nix-data-science) -- [NixOS explained](https://christitus.com/nixos-explained/): NixOS is - an entire Linux distribution that uses Nix as its package manager. -- [Blog post: Nix with R and - devtools](https://rgoswami.me/posts/nix-r-devtools/) -- [Blog post: Statistical Rethinking and - Nix](https://rgoswami.me/posts/rethinking-r-nix/) -- [Blog post: Searching and installing old versions of Nix - packages](https://lazamar.github.io/download-specific-package-version-with-nix/) +- [Nix for Data Science](https://github.com/nix-community/nix-data-science) +- [NixOS explained](https://christitus.com/nixos-explained/): NixOS is an entire Linux distribution that uses Nix as its package manager. +- [Blog post: Nix with R and devtools](https://rgoswami.me/posts/nix-r-devtools/) +- [Blog post: Statistical Rethinking and Nix](https://rgoswami.me/posts/rethinking-r-nix/) +- [Blog post: Searching and installing old versions of Nix packages](https://lazamar.github.io/download-specific-package-version-with-nix/) +