# e - Interactive use

## 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-upstream",
      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-upstream",
        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-upstream",
      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.