Introduction
This vignette describes interactive use of environments built with rix using a GUI editor like RStudio. We will discuss three scenarios: one in which you already have R and RStudio installed on your operating system using the usual installation method for your operating system, another in which you used Nix to install R and RStudio, and finally the last scenario assumes you use another IDE than RStudio, for example VS Code, Emacs, Vim…
It is also possible to evaluate single functions inside a dedicated,
separate, environment from another, main, interactive R session. For
more details regarding this, refer to the vignette
vignette("z-advanced-topic-running-r-or-shell-code-in-nix-from-r")
.
Scenario 1: you installed R and RStudio using the usual installers
Let’s suppose that you are already running R and RStudio and that you
wish to start using rix to define reproducible
environments for your new projects starting today. These environments
will get built using the Nix package manager and will not only include
the required R packages for your project but also a specific version of
R, and any required system-level dependency as well. If you are used to
using RStudio, then you also need to install RStudio using Nix in these
project-specific environments. This is because RStudio re-defines many
environment variables and as such, a version of RStudio installed using
the usual installer for your operating system will not be able “to see”
an R interpreter installed with Nix. As stated in the macOS-specific
vignette vignette("b2-setting-up-and-using-rix-on-macos")
,
RStudio is not available on macOS through nixpkgs
. The
following instructions are thus only applicable to Linux and Windows. If
you’re on macOS, read the macOS-specific vignette if that’s not done
already, and then come back here and skip to the “scenario 3” of this
vignette.
To run a project-specific version of RStudio and R, you will first
need to create a default.nix
file and build the environment
defined therein using Nix. Once this is done, you then need to activate
the environment before running this project-specific version of RStudio.
Suppose for example that you generated a default.nix
file
for a project called “kmeans”, and suppose that this project is in the
following path: ~/Documents/kmeans
(on Windows it would be
something like C:\Users\Billy\Documents\kmeans
). For
example, here is how you could use rix to generate the
default.nix
for this environment:
library(rix)
path_to_project <- "~/Documents/kmeans"
rix(
r_ver = "latest",
r_pkgs = c("dplyr", "ggplot2"),
system_pkgs = NULL,
git_pkgs = NULL,
ide = "rstudio",
project_path = path_to_project,
overwrite = TRUE,
print = TRUE
)
Because you also have R installed through the usual method for your
operating system, you also have a system or user library of packages.
This library of packages will interfere with the library of packages of
your R environments managed by Nix. To avoid this, running
rix()
not only writes a default.nix
file in
your project’s path, but also a custom .Rprofile
file as
well by calling rix_init()
. This .Rprofile
will prevent clashes between your user library of packages and the Nix
environments’ library of packages.
Navigate to that folder using your terminal, and then run
nix-build
to build the environment, and then
nix-shell
. You will then be dropped into a Nix
shell. You can also use nix-shell --pure
instead, if you
want to increase the isolation of your Nix-R environments. The
difference is that in an environment started with
nix-shell
, you will still be able to access programs from
your system, while with nix-shell --pure
, only programs
installed for that Nix-R environment will be available. Try something
like which wget
from a shell started with
nix-shell
and then from a shell started with
nix-shell --pure
as an example (replace wget
by any other tool you have installed on your computer).
Once in the shell, you can type rstudio
to run this
project specific version of R and RStudio with all the required packages
for this project, in this case dplyr and
ggplot2. If you get an error
qt.glx: qglx_findConfig: Failed to finding...
qt.glx: qglx_findConfig: Failed to finding...
Could not initialize GLX
Aborted (core dumped)
then you might need to run this before typing
rstudio
:
export QT_XCB_GL_INTEGRATION=none
This should solve the issue. In any case, we would be thankful if you opened an issue if you encountered this bug and if the fix worked for you.
You can then work on it as usual.
You can also define a shortcut to a project that will take care of activating the environment and launching RStudio. This way, you don’t need to start a terminal in that folder and drop into the Nix environment each time you want to work on this project. For example, you could define a bash alias like this:
alias kmeans='nix-shell ~/Documents/kmeans/default.nix --run rstudio
which would then execute RStudio in the right project by simply
typing kmeans
in a terminal. It’s also possible to create
an executable script that you can save in your PATH:
#!/usr/bin/env nix-shell
#!nix-shell /home/Billy/Document/kmeans/default.nix -i bash
rstudio
(if needed, add the export QT_XCB_GL_INTEGRATION=none
line before rstudio
). Name this script something like
kmeans_project
, make it executable (using
chmod +x kmeans_project
), and now you can run RStudio
within this environment from anywhere.
Scenario 2: you don’t have any regular R and RStudio installation yet
If you don’t have R installed you cannot use the rix
package to generate new expressions. In this case you might consider
installing Nix first, and then run the following command inside your
terminal to get dropped into a temporary Nix shell, which you can then
use to generate new default.nix
files:
nix-shell --expr "$(curl -sl https://raw.githubusercontent.com/ropensci/rix/main/inst/extdata/default.nix)"
Running the command above will download R and rix and then start an R session inside your terminal. You can now run something like this:
rix(r_ver = "latest",
r_pkgs = c("dplyr", "ggplot2"),
system_pkgs = NULL,
git_pkgs = NULL,
ide = "rstudio",
# change to a project's path or leave it if you're in the right folder already
project_path = ".",
overwrite = TRUE)
to generate a default.nix
, and then use that file to
generate an environment with R, Rstudio, dplyr and
ggplot2. If you need to add packages for your project,
rerun the command above, but add the needed packages to
r_pkgs
. If you need to create a new environment, you could
rerun the command above, or you could install rix in that
environment to generate new default.nix
files. Here, there
is no need to use rix_init()
as there won’t be any clash
between your user library of R packages (since you don’t have any), and
the R environments managed by Nix.
Scenario 3: you use some IDE other than RStudio
VS Code, Positron and Emacs have been tested and unlike RStudio, you
can use a version of VS Code, Positron or Emacs installed through the
usual means on your system with development environments built with Nix.
But there’s nothing stopping you from installing a project-specific
version of VS Code or Emacs as well if you wish. Configuration and
settings should be accessible across every version from every
environment, since these are globally defined at the level of your
system. This means that to work on a project using VS Code, you would
use a call to rix()
like so:
rix(
r_ver = "latest",
r_pkgs = c("dplyr", "ggplot2"),
system_pkgs = NULL,
git_pkgs = NULL,
ide = "code",
project_path = ".",
overwrite = TRUE
)
Notice the ide = "code"
argument. This will not install
VS Code from Nix, but will install the languageserver
package that is needed for using R with VS Code. If you want to also
install a project-specific version of VS Code, then use
system_pkgs = "vscode"
or
system_pkgs = "vscodium"
if you prefer VS Codium over VS
Code. For any other editor such as Emacs or Vim, set
ide = "other"
. Also use ide = "other"
if you
want to run scripts non-interactively, for example on a CI/CD
service.
Conclusion
You now know the basics of Nix and rix and can start using it for your projects! There are still some more vignettes that we recommend you read which cover advanced topics.