R - ArchWiki

Jump to content

# R

From ArchWiki

Related articles

- List of programming languages
- R package guidelines

From "What is R?" in the R FAQ:

  R is a system for statistical computation and graphics. It consists of a language plus a run-time environment with graphics, a debugger, access to certain system functions, and the ability to run programs stored in script files.

## Installation

Install the r package. The installation of external packages within the R environment may require gcc-fortran.

## Usage

To start an R session, open your terminal and type this command:

    $ R

Note

- Make sure to use a capital "R" for the command. Note that some shells use the lowercase `r` command to repeat the last entered command. Once in your R session, the prompt will change to `>`
- site refers to system-wide in R Documentation

Run `?Startup` to read the documentation about system file configuration, `help()` for the on-line help, `help.start()` for the HTML browser interface to help, `demo()` for some demos and `q()` to close the session and quit.

When closing the session, you will be prompted as follows:

    Save workspace image? [y/n/c]:

The workspace is your current working environment and include any user-defined objects, functions. The saved image is stored in `.RData` format and will be automatically reloaded the next time `R` is started. You can manually save the workspace at any time in the session with the `save.image(image.RData)` command, save as many images as you want (eg: image1.RData, image2.RData). You can load image with the `load.image(image.RData)` command at any time of your session.

Tip

- The `--quiet` option can be used to start R without a verbose startup message. Add `alias R="R --quiet"` to a startup file to use this behaviour by default.
- Running R from the command line will set R's working directory to the current directory. Opening the R GUI will set R's working directory to $HOME, unless explicitly defined in your configuration files (`.Renviron` or `.Rprofile`).

## Configuration

Whenever R starts, its configuration is controlled by several files. Please refer to Initialization at Start of an R Session to get a detailed understanding of startup process.

### Environment

R first loads site and user environment variable files. The name of the site file is controlled by the environment variable `R_ENVIRON` if it exists, and defaults to `/etc/R/Renviron.site`. The name of the user file is specified by `R_ENVIRON_USER`. If that is unset, it defaults to `.Renviron` in the current working directory if it exists, or `~/.Renviron` otherwise.

The most important variables can be found on Environment Variables R Documentation.

You may disable loading environment files with `--no-environ`

Lines in the `Renviron` file should be either comment lines starting with `#` or lines of the form `name=value`. Here is a very basic `.Renviron`:

    .Renviron

    R_HOME_USER = /path/to/your/r/directory
    R_PROFILE_USER = ${HOME}/.config/r/.Rprofile
    R_LIBS_USER = /path/to/your/r/library
    R_HISTFILE = /path/to/your/filename.Rhistory
    MYSQL_HOME = /var/lib/mysql

Alternatively, environment variables may be set from within your R session via the `Sys.setenv()` function. For instance, to set the time zone (`TZ`) environment variable to `"Europe/London"`:

    > Sys.setenv(TZ="Europe/London")

Tip Typically, R will throw 'out of memory' errors once it has exhausted your system's physical memory. Set the "maximal vector heap size" (`R_MAX_VSIZE`) environment variable in your `.Renviron` file to enable R to use more of your system's total (physical + virtual) available memory. The value set may either be a numerical value providing the number of bytes, e.g. `16000000000`, or a numerical value suffixed by ISO units, e.g. `16GB`.

### Profile

R then loads a `.Rprofile` file, which contains R code that is executed. These files are read in the following order of preference (only one file is loaded):

1. A file specified by the environment variable `R_PROFILE_USER`.
2. A `.Rprofile` file in the current working directory.
3. `$HOME/.Rprofile`.

A `.Rprofile` file can contain arbitrary R code, though best practice suggests that one should not load packages at startup, or execute any code that would hinder package upgrades and reproducibility.

    ~/.Rprofile

    # The .First function is called after everything else in .Rprofile is executed
    .First <- function() {
      # Print a welcome message
      message("Welcome back ", Sys.getenv("USER"),"!\n","Working directory is: ", getwd())
    }

    # Set default browser
    options(browser = "firefox")
    # Number of digits to print. Default is 7, max is 15
    options(digits = 12)
    # Penalty applied to inhibit the use of scientific notation
    options(scipen = 2)
    # Do not show stars indicating statistical significance in model outputs
    options(show.signif.stars = FALSE)
    local({
        # Detect the number of cores available for use in parallelisation
        n <- max(parallel::detectCores() - 2L, 1L)
        # Compile the different sources of a single package in parallel
        Sys.setenv(MAKEFLAGS = paste0("-j",n))
        # Install different packages passed to a single install.packages() call in parallel
        options(Ncpus = n)
        # Parallel apply-type functions via 'parallel' package
        options(mc.cores =  n)
    })
    # Post-mortem debugging facilities
    error <- quote(dump.frames("${R_HOME_USER}/testdump", TRUE))

You can add more global options to customize your R environment. See this post for more examples of user configurations.

### Locale

Aspects of the Locale are accessed by the functions `Sys.getlocale` and `Sys.localeconv` within the R session. Locales will be the one defined in your system.

## Managing R packages

There are many add-on R packages which can be browsed on CRAN package repository.

### With pacman

There are some packages available on the AUR with the prefix r-.

Note Some R packages link to files provided by system packages. These packages will need to be reinstalled when these files are updated.

You can mix and match installing R packages with pacman and through R (see below), but if you do so, you should let pacman manage system packages (those that reside at `/usr/lib/R/library`) and let R manage user-installed packages elsewhere (e.g. `~/R/library`).

The desolve (deprecated, use BioArchLinux) repository also provides a set of pre-built R packages. For requests, please see the repository's Git repository.

BioArchLinux setup at: https://wiki.bioarchlinux.org/index.php?title=Usage, integrate install.package and BioArchLinux with pacman using bspm with suppressMessages(bspm::enable()). Set it by default adding the line to ~/.Rprofile or /etc/R/Rprofile.site for systemwide. example: install.packages("tidyverse") will pull r-tidyverse from pacman

### With R

Packages can be installed from within R using the `install.packages(c("pkgname"))` command.

By default, packages will be installed in the directory corresponding to the first element returned by `.libPaths()`, which in turn defaults to the value of the environment variable `R_LIBS_USER`.

You can change the directory in which packages will be installed with the `lib` argument of `install.packages`.

While this approach maximizes the number of available packages (i.e. you can get everything from CRAN and other repositories), a potential downside is long compilation time for some packages. This can be ameliorated by using a source with prebuilt packages.

You should use a local library and let pacman manage files that reside under `/usr/lib/R/library`.

Note

You can disable graphical pop-ups like this by running:

      > options(menu.graphics=FALSE)

  To make this change permanent, add the above command to your Rprofile.

Within your R session, run this command to check that your user library exists and is set correctly:

    > Sys.getenv("R_LIBS_USER")

    [1] "/path/to/directory/R/packages"

Alternatively, you may install from the command line like so:

    $ R CMD INSTALL -l $R_LIBS_USER pkg1 pkg2 ...

### With Guix and `guix.install`

While compiled binaries of some R packages are available through Arch repositories and the AUR, there are many which are not packaged. This can mean long compilation times (which need to be repeated when R is updated).

One way to get access to prebuilt R packages is by using the Guix package manager which provides a way to get fully reproducible builds of packages through "substitutes". See the Guix page and manual for how to set up Guix.

After you have a working installation of Guix, you can install R packages that will be used.

To emulate the `install.packages(...)` workflow with Guix one can use the `guix.install` function from the guix.install package.

#### Upgrading R packages

##### Within an R session

    > update.packages(ask=FALSE)

Or when you also need to rebuild packages which were built for an older version:

    > update.packages(ask=FALSE, checkBuilt=TRUE)

Or when you also need to select a specific mirror (https://cran.r-project.org/mirrors.html) to download the packages from (changing the URL as needed):

    > update.packages(ask=FALSE, checkBuilt=TRUE, repos="https://cran.ma.imperial.ac.uk/")

Tip Upgrading packages from your R session can quickly be a pain if you have too many loaded packages at start up. For packages to be upgraded, they cannot be loaded, so do not load packages from your Rprofile.

##### Within a shell

You can use `Rscript`, which comes with r to update packages from a shell:

    $ Rscript -e "update.packages()"

### Makevars

The Makevars file can be used to set the default make options when installing packages. An example optimized Makevars file is as follow:

    ~/.R/Makevars

    CFLAGS=-O3 -Wall -pedantic -march=native -mtune=native -pipe
    CXXFLAGS=-O3 -Wall -pedantic -march=native -mtune=native -pipe

## Alternative shells

As an alternative to the default R program, the following shell is also available:

- radian — An alternative console for the R program with multiline editing and rich syntax highlight.

  https://github.com/randy3k/radian || radianAUR

## Adding a graphical frontend to R

R does not include a point-and-click graphical user interface for statistics or data manipulation. However, third-party user interfaces for R are available, such as R Commander and Rattle.

### R Commander frontend

R Commander(CRAN repo) is a popular user interface to R. There is no Arch Linux package available to install R Commander, but it is an R package so it can be installed easily from within R. R Commander requires tk and gcc-fortran to be installed.

To install R Commander, run `R` from the command line. Then type:

    > install.packages("Rcmdr", dependencies=TRUE)

This can take some time.

You can then start R Commander from within R using the library command:

    > library("Rcmdr")

### Rattle frontend

Rattle is a popular user interface to R with focus on data mining. There is no Arch Linux package available but it can be installed easily from within R.

To install Rattle, run `R` from the command line. Then type:

    > install.packages("rattle", dependencies=TRUE)

This can take some time.

You can then start Rattle from within R using the library command:

    > library("rattle")
    > rattle()

### JASP

jasp-desktop provides a menu-driven interface for common statistical analysis using R as the backend. A Flatpak package is also available.

### jamovi

jamovi provides a menu-driven interface for common statistical analysis using R as the back-end. A Flatpak is available.

## Editors, IDEs, and notebooks with R support

### RKWard IDE

RKWard is an IDE developed by KDE, which allows for data import and browsing as well as running common statistical tests and plots. You can install rkward from the official Arch repositories.

### RStudio IDE

RStudio is an open-source R IDE. It includes many modern conveniences such as parentheses matching, tab-completion, tool-tip help popups, and a spreadsheet-like data viewer.

Install rstudio-desktop-binAUR.

The R library path is often configured with the `R_LIBS` environment variable. RStudio ignores this, so the user must set `R_LIBS_USER` in `~/.Renviron`, as documented above.

RStudio uses a four-pane layout by default. However, if only the taskbar and toolbar located at the vertical top of an otherwise blank screen are visible, create with elevated privileges the following file and populate it with contents as shown below:

    /usr/lib/qt/libexec/qt.conf

    [Paths]
    Prefix = /usr/lib/qt
    Data = /usr/share/qt
    Translations = /usr/share/qt/translations

Restart RStudio and observe the expected split-screen layout with four panes. See RStudio does not show any pane on Stack Overflow and https://github.com/rstudio/rstudio/issues/5961 for more information.

If, at startup, RStudio throws at you the following error:

    /usr/lib/rstudio/resources/app/bin/rsession: error while loading shared libraries: libssl.so.1.1: cannot open shared object file: No such file or directory

you need to install the openssl-1.1AUR package.

### RStudio server

RStudio Server enables you to provide a browser based interface to a version of R running on a remote Linux server.

Install rstudio-server-gitAUR. The two main configuration files are `/etc/rstudio/rserver.conf` and `/etc/rstudio/rsession.conf`. They are not created during the install, so you will need to create and edit them.

To start the server, please enable and start the `rstudio-server.service` unit file provided with the package.

### Emacs Speaks Statistics

Emacs users can interact with R via the emacs-essAUR package.

### Nvim-R and R.nvim

The nvim-rAUR[broken link: package not found] package helps vim users to code in R, by including editing and rendering of R markdown (.Rmd) files, execution of R code in a separate pane, inspection of variables, and integrated help panes.

neovim users should use R.nvim instead.

### Cantor

cantor is a notebook application developed by KDE that includes support for R.

### Visual Studio Code

The Visual Studio Code (code) editor has plugin support for R.

### Positron

Positron is a Data Science IDE built by Posit PBC (formerly known as RStudio, the company behind the respectively named IDE) based on Visual Studio Code. It is configured out of the box with options and plugins suited for a Data Science workflow, and maintains compatibility with VS Code plugins.

Install positron-ide-devel-binAUR.

### Jupyter notebook

Jupyter is a browser based notebook with support for many programming languages. R support can be added by installing the IRkernel.

### Architect

Architect is an integrated development environment (IDE) that focuses specifically on the needs of the data scientist. Install architectAUR.

### Radiant

Radiant is a platform-independent browser-based interface for business analytics in R, based on the Shiny package.

Install r-radiant.dataAUR.

## Tips and tricks

### Optimized packages

The numerical libraries that come with the r package (lapack and consequently blas) do not have multithreading capabilities. Replacing the reference blas package with an optimized BLAS can produce dramatic speed increases for many common computations in R. See these threads for an overview of the potential speed increases:

- https://github.com/tmolteno/necpp/issues/18
- http://blog.nguyenvq.com/blog/2014/11/10/optimized-r-and-python-standard-blas-vs-atlas-vs-openblas-vs-mkl/
- https://freddie.witherden.org/pages/blas-gemm-bench/
- https://nghiaho.com/?p=1726

To find out which numerical libraries R is using, call `sessionInfo()` or `extSoftVersion()` within an R session.

#### OpenBLAS

openblas can replace the reference blas.

This article or section is out of date.

Reason: It no longer seems the case that R uses openblas automatically if installed. (Discuss in Talk:R)

If you are using the regular r package from the extra repository, no further configuration is needed; R is configured to use the system BLAS and will use OpenBLAS once it is installed.

If that does not work, use the ropenblas package to compile, install and use the latest version of openblas:

    install.packages("ropenblas")
    ropenblas::ropenblas()

#### Intel MKL

If your processors are Intel, you can use the Intel Math Kernel Library. The MKL, beyond the capabilities of multithreading, also has specific optimizations for Intel processors.

Warning Usage of Intel MKL can potentially interfere with the standard R functionality for parallel processing.
Warning Previous versions of Intel MKL were bugged and could lead to numerical instability and wrong results.

Please first install the intel-oneapi-mkl, then the r-mklAUR package.

Note

- If you install the r-mkl package with R already installed, you will be prompted to remove R. Once r-mkl is installed, please run on R console the following command:

      > update.packages(checkBuilt=TRUE)

- Here are elapsed time in seconds from computing 15 tests with default GCC build and icc/MKL build: 274.93 sec for GCC build, 21.01 sec for icc/MKL build. See this post for more information.

#### Intel Advisor

Intel Advisor delivers top application performance with C, C++ and Fortran compilers, libraries and analysis tools.

Install the intel-advisor-standaloneAUR package.

#### AMD AOCL

AMD Optimizing CPU Libraries are a set of numerical libraries optimized for AMD processors, and is essentially AMD's counterpart to Intel's Math Kernel Library.

Install the blas-aocl-aoccAUR or blas-aocl-gccAUR package (requires downloading AOCL tarballs from upstream), and enable the libraries systemwide using either env-modulesAUR, or manually.

### Set CRAN mirror across R sessions

Instead of having R ask which CRAN mirror to use every time you install or update a package, you can set the mirror in the `.Rprofile` file. https://cloud.r-project.org/ should be a good default for everywhere as it redirects to your closest CRAN mirror:

    ~/.Rprofile

    ## Set CRAN Mirror:
    local({
      r <- getOption("repos")
      r["CRAN"] <- "https://cloud.r-project.org/"
      options(repos = r)
    })

### Inhibit "Save workspace image?" prompt

Upon executing `q()` in R to exit, you will typically be greeted by the following prompt:

    > q()

    Save workspace image? [y/n/c]:

On face value, this may seem convenient, but using workspace images will render your code less portable. The "Save workspace image?" prompt may be disabled by creating a hidden environment (`.env`), adding a new version of the `q()` function to it in which the default value for the `save` argument has been altered to `"no"`, then attaching the hidden environment. This will mask the `q()` function of R's base package, effectively switching off the prompt. To make this change permanent, add the following code to your `.Rprofile` file:

    ~/.Rprofile

    ## Create hidden environment
    .env <- new.env()

    ## Define new q() function
    .env$q <- function(save = "no", ...) {

      quit(save = save, ...)

    }

    ## Attach hidden environment
    attach(.env, warn.conflicts = FALSE)

The above will make `q()` exit R without displaying a prompt, but it will not have an effect on quitting with `Ctrl+D`.

If you never want to see the save workspace prompt, it is more convenient to start R with `--no-save`. Add `alias R="R --no-save"` to e.g. `.bashrc` to make the change persistent.

### Running R from a shell

This article or section needs expansion.

Reason: Mention `Rscript` as an alternative since it is apparently preferred over the older `R CMD BATCH` [1]. "An Introduction to R" says otherwise [2]. It may be better to just link to "An Introduction to R" instead of duplicating information here. (Discuss in Talk:R)

Run the following command to execute R code from a command-line shell:

    $ R CMD BATCH script.R

This command will return a .Rout file with results from `script.R`. The .Rout file will always contain a `proc.time()` call at the end as a benchmark. `sessionInfo()` can be added to the end of the R code to keep a record of packages and versions.

### Installing V8 package

This article or section is out of date.

Reason: What about r-v8AUR?[3] (Discuss in Talk:R)

To install the V8 R package you need the V8 engine installed on your system.

To do so, you can install the v8AUR[broken link: package not found] package (warning: compiled from source, long compilation time).

As compilation of the V8 package is a substantial and resource-intensive undertaking, a means to avoid it was added by the package maintainer(s). Explanation of this is provided in the package GitHub page. To summarise, to force the use of a pre-compiled libv8:

    Sys.setenv(DOWNLOAD_STATIC_LIBV8 = 1)
    install.packages("V8")

## Troubleshooting

### Unable to load stringi.so

The following error may be encountered when running R code that depends on the stringi CRAN package:

    unable to load shared object 'R_LIBS_USER/stringi/libs/stringi.so':
    libicui18n.so.MAJOR: cannot open shared object file: No such file or directory

This often occurs following a soname bump to the library (provided by icu). `stringi` will need to be rebuilt in R by installing the package again.

## See also

- Official website
  - The R Manuals
- RSeek A Google Custom Search Engine for R related material.
- R-bloggers Aggregation site for (English) blogs related to R.
- /r/rstats on Reddit is the main R-related subreddit. Other subreddits exists but it has been agreed in early 2026 that most of the conversation should be on rstats.

Categories:

- Science
- Programming languages

Hidden categories:

- Pages with broken package links
- Pages or sections flagged with Template:Out of date
- Pages or sections flagged with Template:Expansion

R
Add topic