R

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, environmental variables may be set from within your R session via the
Sys.setenv()
function. For instance, to set the time zone (
TZ
) environmental 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
) environmental 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):
A file specified by the environment variable
R_PROFILE_USER
.
A
.Rprofile
file in the current working directory.
$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
||
radian
AUR
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
(
jamovi-git
AUR
[
broken link
: package not found]
) provides a menu-driven interface for common statistical analysis using R as the backend. A
Flatpak
package is also 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-bin
AUR
.
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.1
AUR
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-git
AUR
. 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-ess
AUR
package.
Nvim-R and R.nvim
The
nvim-r
AUR
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-bin
AUR
.
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
architect
AUR
.
Radiant
Radiant
is a platform-independent browser-based interface for business analytics in R, based on the Shiny package.
Install
r-radiant.data
AUR
.
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-mkl
AUR
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-standalone
AUR
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-aocc
AUR
or
blas-aocl-gcc
AUR
package (requires downloading AOCL tarballs from
upstream
), and enable the libraries systemwide using either
env-modules
AUR
, 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-v8
AUR
?
[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
v8
AUR
[
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.