Installation

How to install LinkR, on R or from a Docker image

Several installation methods are available:


  • The simplest (no programming knowledge required): use Docker Desktop
  • Command line: you can run the Docker image from a terminal or install the package via an R console.
  • For developers: Clone the Git repository to be able to edit the source code.

This method is the simplest and requires no programming knowledge.

Install Docker on Windows or macOS

  1. Download Docker Desktop
  2. Install and launch Docker Desktop

In the left menu, click on Docker Hub, this will allow you to search for and install the LinkR image.

Search for interhop/linkr in the search bar.

Click on this image.

On the right side of the screen, select the latest image (latest), and click on Pull to install it.

Return to the Images page on the left of the screen. You will see the list of locally installed images.

From the interhop/linkr image, click on the Play image in the Actions column.

You will then have this screen.

Expand the Optional settings menu.

You will need to modify this:

  • Host port: enter 3838
  • Host path: this is the local folder where the files for the application’s operation will be installed
  • Container path: you must enter /root

Then click on Run, open your browser and copy the following URL: localhost:3838.

Discover how to install your first project.

Command line installation

Via Docker

Install Docker Desktop as described above.

Verify that Docker works by opening a terminal (PowerShell or CMD on Windows) and running:

docker --version

Copy the Docker image from Docker Hub.

docker pull interhop/linkr:latest

Launch a container from this image.

docker run -p 3838:3838 interhop/linkr:latest

You can now access LinkR via the address localhost:3838.

You can also launch LinkR by changing the arguments of the run_app function (see next paragraph).

docker run \
    -p 3838:3838 \
    interhop/linkr:latest \
    R -e "linkr::run_app(language = 'en', app_folder = '/root')"

Here are the arguments for run_app:

Argument Description
language Application language. Can be "fr" for French or "en" for English. (character)
app_folder Folder where application files will be stored in the container. (character)
authentication Enable or disable user authentication (TRUE or FALSE). (logical)
username Username to use for automatic login when authentication = FALSE. Ignored if authentication is enabled. (character)
local If TRUE, the application runs in local mode without loading external files (e.g., from GitHub). (logical)
log_level Log levels to display. Can include "info", "error", "event", or "none" to disable logs. (character vector)
log_target Log destination: "console" or "app". (character)
port Port used to run the Shiny application. (integer)
host Host address to run the application (default "0.0.0.0"). (character)
loading_options List of startup options (page, project, filter, etc.): can include named elements like page, project_id, load_data_page, subset_id, person_id. (list)


To allow the container to access a specific folder on your host system (for example, /my_personal_folder/linkr), you can mount this folder in the container. This is done with the -v option when launching the container.

docker run \
    -p 3838:3838 \
    -v /my_personal_folder/linkr:/root \
    interhop/linkr:latest \
    R -e "linkr::run_app(language = 'en', app_folder = '/root')"

Here we have properly configured the app_folder argument of the run_app function to save the application files in the /root folder, which will actually be the folder on your system that you specified with the -v option.

Via RStudio / R Console

The remotes library will be necessary for LinkR installation. You can install it with this command:

install.packages("remotes")

Stable version

Install the latest stable version with this command:

remotes::install_gitlab("interhop/linkr/linkr", host = "framagit.org")

Development version

To install the latest development version, add @dev at the end of the git repository link.

remotes::install_gitlab("interhop/linkr/linkr@dev", host = "framagit.org")

Important - shiny.fluent version

Version 0.3.0 of shiny.fluent is required


You must also install version 0.3.0 of shiny.fluent.

By default, version 0.4.0 is installed but it has unresolved bugs.

remotes::install_github('Appsilon/shiny.fluent', ref = 'dd1c956')

Start LinkR

To launch LinkR from RStudio or from an R console, execute the linkr function.

linkr::run_app()

See above for the arguments that the function can take.

Installation for developers

Clone the official LinkR Git repository from Framagit:

git clone git@framagit.org:interhop/linkr/linkr.git
cd linkr

Make sure you have configured an SSH key to access Framagit. Otherwise, you can also use the HTTPS URL:
https://framagit.org/interhop/linkr/linkr.git

Switch to the dev branch:

git checkout dev

Open the project folder in RStudio or Visual Studio Code (with the R extension enabled).

Load the package with devtools, by running this in the R console:

install.packages("devtools")  # If not already done
devtools::load_all(".")

Launch the application by running this:

linkr::run_app()