Configuring Positron and nix on Windows WSL

[atsyplenkov]

Hey guys, looking for some help and advice. I cannot connect to a custom R installation on Positron v2025.01.0-39 when connecting to a remote machine via SSH (Ubuntu 24 on WSL2).

I am trying to configure the Nix environment with the help of the rix package. The problem arises when Positron cannot find the R executable, which is stored in a non-standard location. Setting positron.r.customBinaries doesn't seem to help.

I am running a fresh install of Ubuntu 24.04.1 LTS on WSL2, and Positron connects via SSH, configured on WSL with openssh-server. Apart from system dependencies like libcurl4-openssl-dev and curl, everything was configured with Nix. Below is the content of the default.nix file.

# This file was generated by the {rix} R package v0.14.3 on 2025-01-14
# with following call:
# >rix(r_ver = "4.4.2",
#  > r_pkgs = c("dplyr",
#  > "ggplot2"),
#  > system_pkgs = NULL,
#  > git_pkgs = NULL,
#  > ide = "code",
#  > project_path = ".",
#  > overwrite = TRUE)
# It uses the `rstats-on-nix` fork of `nixpkgs` which provides improved
# compatibility with older R versions and R packages for Linux/WSL and
# Apple Silicon computers.
# Report any issues to https://github.com/ropensci/rix
let
 pkgs = import (fetchTarball "https://github.com/rstats-on-nix/nixpkgs/archive/2024-12-14.tar.gz") {};
 
  rpkgs = builtins.attrValues {
    inherit (pkgs.rPackages) 
      dplyr
      ggplot2
      languageserver;
  };
    
  system_packages = builtins.attrValues {
    inherit (pkgs) 
      glibcLocales
      nix
      R;
  };
  
in

pkgs.mkShell {
  LOCALE_ARCHIVE = if pkgs.system == "x86_64-linux" then "${pkgs.glibcLocales}/lib/locale/locale-archive" else "";
  LANG = "en_US.UTF-8";
   LC_ALL = "en_US.UTF-8";
   LC_TIME = "en_US.UTF-8";
   LC_MONETARY = "en_US.UTF-8";
   LC_PAPER = "en_US.UTF-8";
   LC_MEASUREMENT = "en_US.UTF-8";

  buildInputs = [  rpkgs  system_packages   ];
  
}

After running nix-build and nix-shell, I am able to run R in nix-shell in my terminal, but not in the Positron Console, which is expected, as R was installed into /nix/store/lw2scvxw0vfgzva4qmglh03vk27yxaqg-R-4.4.2/bin/R, which is not the default location. While, I can configure positron.r.customBinaries in the remote machine's Positron settings to look at and run R from the Nix store. But how can I run R in the Positron console from nix-shell?

In other words, these settings work, and I can run at least some R:

"positron.r.customBinaries": "/nix/store/lw2scvxw0vfgzva4qmglh03vk27yxaqg-R-4.4.2/bin/R"

However, I want to run R from nix-shell; therefore, I tried to configure a shell script, which can then be passed to the positron.r.customBinaries:

#!/usr/bin/env bash
nix-shell /mnt/c/Users/TsyplenkovA/Desktop/temp_project/default.nix --run "R"

and don't forget to make it executable with chmod +x nixr.sh. So now my Positron settings look like:

{
    "positron.r.customBinaries": [
        "~/nixr.sh",
        "/nix/store/lw2scvxw0vfgzva4qmglh03vk27yxaqg-R-4.4.2/bin/R"
    ],
    "positron.r.trace.server": "messages"
}

The output console shows me, that it ignores my shell script, and just using the nix/store version:

2025-01-15 11:01:25.093 [info] Log level: Debug
2025-01-15 11:01:25.093 [info] Refreshing testthat status
2025-01-15 11:01:25.093 [info] Not working in an R package
2025-01-15 11:01:25.093 [info] Context key 'testthatIsConfigured' is 'false'
2025-01-15 11:01:25.093 [info] Context key 'testthatHasTests' is 'false'
2025-01-15 11:01:25.525 [info] Candidate R binary at C:\Program Files\R\R-4.4.1patched\bin\x64\R.exe
2025-01-15 11:01:25.588 [info] User-specified R binaries:
[
  "~/nixr.sh",
  "/nix/store/lw2scvxw0vfgzva4qmglh03vk27yxaqg-R-4.4.2/bin/R"
]
2025-01-15 11:01:25.588 [info] Skipping registry check on non-Windows platform
2025-01-15 11:01:25.616 [info] Candidate R binary at /nix/store/lw2scvxw0vfgzva4qmglh03vk27yxaqg-R-4.4.2/bin/R
2025-01-15 11:01:25.616 [info] R installation discovered: {
  "valid": true,
  "supported": true,
  "binpath": "/nix/store/lw2scvxw0vfgzva4qmglh03vk27yxaqg-R-4.4.2/bin/R",
  "homepath": "/nix/store/lw2scvxw0vfgzva4qmglh03vk27yxaqg-R-4.4.2/lib/R",
  "semVersion": {
    "options": {},
    "loose": false,
    "includePrerelease": false,
    "raw": "4.4.2",
    "major": 4,
    "minor": 4,
    "patch": 2,
    "prerelease": [],
    "build": [],
    "version": "4.4.2"
  },
  "version": "4.4.2",
  "arch": "x86_64",
  "current": false,
  "orthogonal": true
}
2025-01-15 11:01:31.026 [info] Creating Positron R 4.4.2 language client (port 43108)
2025-01-15 11:01:31.026 [info] ARK (R 4.4.2) language client state changed uninitialized => starting
2025-01-15 11:01:31.046 [info] ARK (R 4.4.2) language client init successful
2025-01-15 11:01:31.046 [info] ARK (R 4.4.2) language client state changed starting => running

So the question is, how can I make Positron work within the Nix environment on remote machines? Is it even possible?

To repdroduce the issue from scratch

wsl --install -d Ubuntu-24.04 --web-download

Setup username and password

# Update and install dependencies
sudo apt-get update && sudo apt-get upgrade -y
sudo apt-get install curl libcurl4-openssl-dev -y

# Install nix (https://docs.ropensci.org/rix/articles/b1-setting-up-and-using-rix-on-linux-and-windows.html#using-the-determinate-systems-installer)
curl --proto '=https' --tlsv1.2 -sSf -L https://install.determinate.systems/nix | sh -s -- install
# reopen shell
nix-env -iA cachix -f https://cachix.org/api/v1/install
# get root access to wsl user
echo "trusted-users = root atsyp" | sudo tee -a /etc/nix/nix.conf && sudo pkill nix-daemon
cachix use rstats-on-nix

Configure Positron ssh connection

# Install open-ssh server
sudo apt install openssh-server -y
# Configure settings
sudo nano /etc/ssh/sshd_config

Then, add to the end of the file the following lines:

# Configure server to connect from Windows
Port 2222
ListenAddress 0.0.0.0 # <LISTEN ADDRESS>

Start and enable openssh server

sudo systemctl start ssh.service
sudo systemctl enable ssh.service

Edit on Windows your WSL config located at %USERPROFILE%\.ssh\config by adding:

Host Ubuntu
    HostName 172.27.59.242
    Port 2222
    User atsyp

Connect in Positron via remote-ssh extension and wait while positron insalls its server. So, since there is no R installed on the WSL, Positron will not run any interpreters. I was installing R using nix following this

# Create temp project
mkdir nix_project && cd nix_project
# Install R
nix-shell --expr "$(curl -sl https://raw.githubusercontent.com/ropensci/rix/master/inst/extdata/default.nix)"
# Find R executable
nix-shell --expr "$(which R)"
#> /nix/store/lw2scvxw0vfgzva4qmglh03vk27yxaqg-R-4.4.2/bin/R

Then, create a nixr.sh script in home location (~/) and make it executable.

[b-rodrigues]

Hi Anatolii

I don’t use Positron nor Windows, so I don’t know if I’ll be able to help. However, I do have a few thoughts:

• you could install Positron using Nix in WSL2, and from there start the shell using nix-shell, and then Positron. This should (I said should, because I have no idea) start Positron from the activated shell (but it’s going to be the Linux version, not your already installed Windows one). To install Positron, add positron-bin to the system_pkgs and I also recommend to use the very latest date I’ve added yesterday, so use rix(date = "2025-01-14"...., system_pkgs = "positron-bin", ...).

• you could try to make the nix-shell global: I have never tried it, so I don’t know how or if it works, but there’s this discussion here that you might find interesting. From what I understand, activating the shell by editing the .profile should make it always activate as soon as a terminal is spawned.

• you could try to use Nix in combination with Docker and the Visual Studio Code Dev Containers extension. From what I could gather, this allows VS Code / Positron to connect to a running Docker container, and this container could have all the packages you need. Using Nix, you could set up a Docker image that contains all you need. Here is an example Dockerfile that sets up an environment using Nix:

FROM ubuntu:latest

RUN apt update -y

RUN apt install curl -y

# We don't have R nor {rix} in this image, so we can bootstrap it by downloading
# the default.nix file that comes with {rix}. You can also download it beforehand
# and then copy it to the Docker image
RUN curl -O https://raw.githubusercontent.com/ropensci/rix/main/inst/extdata/default.nix

# The next 4 lines install Nix inside Docker. See the Determinate Systems installer's documentation
RUN curl --proto '=https' --tlsv1.2 -sSf -L https://install.determinate.systems/nix | sh -s -- install linux \
  --extra-conf "sandbox = false" \
  --init none \
  --no-confirm

# Adds Nix to the path, as described by the Determinate Systems installer's documentation
ENV PATH="${PATH}:/nix/var/nix/profiles/default/bin"
ENV user=root

# Set up rstats-on-nix cache
# This will download binaries of packages instead of building
# them from source
RUN nix-shell --run "Rscript -e 'rix::setup_cachix()'"

# Generate default.nix that defines environment
RUN nix-shell --run "R -e \"library(rix); rix(date = '2025-01-14', r_pkgs = c('dplyr', 'ggplot2', 'languageserver'), project_path = '.', overwrite = TRUE)\""

# We now build the environment
RUN nix-build

# Finally, we run `nix-shell`. This will get executed when running
# containers from this image. You can of course put anything in here
CMD nix-shell

my guess is that you could then "ssh into" a running container from this image with the right dependencies.

[atsyplenkov]

Thanks, Bruno, for such a detailed answer. I commend you for providing such extensive options.

• The first one will definitely work, i.e., installing Positron inside WSL and running its GUI using WSLg. However, I personally don't prefer this option as it is a bit slower—if you work enough with WSLg, you will start to notice small millisecond freezes, which are, TBH, starting to drive you nuts. Also, language input methods switching is a bit of a pain (need to configure ibus and etc).

• I like the idea of containerization and globalization, and you gave me a thought that I probably need to install an OpenSSH server inside nix-shell. I am not sure how easy it would be to configure and forward the ports, but I'll give it a try.

• I'll also want to try running NixOS on WSL or in a container.

We'll keep this thread updated for future references!

[atsyplenkov]

BTW, Visual Studio Code Dev Containers extension does work only in VS Code as it needs a proprietary server to run inside containers. So, for Positron/VS Codium and other Code OSS-based IDEs, the open-remote-ssh is like the only option.

UPD: It turns out that Cursor supports Dev Containers extension on some machines. Or at least it's possible to connect to a running container configured in VS Code

[b-rodrigues]

I just tried Positron via WSLg and it mees to be fairly fine. Maybe with extensive testing I would also encounter these microfreezes you mention, I don’t know. I also tried Positron directly installed on Windows and try to connect it to WSL using the Open Remote extension, and then use the direnv extension to dynamically load nix shells, but that doesn’t work. It seems that Positron wants to lead R or Python interpreters at startup time, and doesn’n (easily) allow for dynamic reloading.

But if you’re willing to use VSCode (or Codium) instead, that setup works fine:

• Code on Windows with open remote and direnv extension and of course the REditorSupport extension
• Add the {languageserver} R package to your Nix default.nix
• Install direnv on the WSL VM (don’t forget step2)
• Create a file called .envrc in the folder of your project, next to the default.nix and write use nix in it. Run direnv allow in the terminal (from WSL).
• Start VSCode and wait for it to load. You might be prompted to restart.

Enjoy!

[b-rodrigues]

Can you share the setup so that I can try to replicate with Nix ? (R, R packages, etc )

I'll also try to setup a docker container with Nix in it and ssh into it using positron to try. Do you have some guide on hand I could follow to setup Positron with Docker containers? is it the same as for vscode?

[atsyplenkov]

Ha! I am in the process of writing a blog post on this topic!

It's not exactly the same, as you must use the open-remote-ssh extension and Debian 12+/Ubuntu 22+ or RHEL9 (see here).

Currently, my project setup is as follows. Below are the README.md file I am providing to the client and the Dockerfile. My main focus is on creating an isolated computing environment while keeping the data stored on my local machine. The renv is mostly tidyverse, polars, tidypolars and arrow packages.

I would greatly appreciate any comments or feedback on my approach. Are there any drawbacks I might be overlooking?

Dockerfile

FROM rocker/r-ver:4.4.2
LABEL maintainer="Anatoly Tsyplenkov <[email protected]>"

# Install system requirements
RUN apt update && apt install -y sudo \
    passwd \ 
    openssh-server \ 
    curl \
    libcurl4-openssl-dev \
    libssl-dev

# Install RUST and cargo
RUN curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh -s -- -y

# Install air, R formatter
RUN curl --proto '=https' --tlsv1.2 -LsSf https://github.com/posit-dev/air/releases/download/0.2.0/air-installer.sh | sh

# Create the required /run/sshd directory and set permissions
RUN mkdir -p /run/sshd && chmod 0755 /run/sshd

# Configure the SSH server using the environment variable
RUN echo "PermitRootLogin yes" >> /etc/ssh/sshd_config && \
    echo "PasswordAuthentication yes" >> /etc/ssh/sshd_config && \
    echo "Port 80" >> /etc/ssh/sshd_config

# Set password from argument
RUN echo "root:password" | chpasswd

# Create directories for project and renv cache
RUN mkdir -p /PROJECT_DIR

# Set the working directory
WORKDIR /PROJECT_DIR

# Configure R and renv
COPY .Renviron .Renviron
ENV R_ENVIRON .Renviron
RUN R -e "install.packages('renv', repos = c(CRAN = 'https://cloud.r-project.org'))"

# IMPORTANT ----
## Comment lines 43-47 if you are building the image the first time 
## instead, build image as usual and configure `renv` manually via
## renv::init()

## Restore packages using renv
COPY .Rprofile .Rprofile
COPY renv.lock renv.lock
COPY renv/activate.R renv/activate.R
COPY renv/settings.json renv/settings.json
RUN R -s -e "renv::restore()"

# Start the SSH service
CMD ["/usr/sbin/sshd", "-D"]

README.md

The current project uses renv environment manager and Podman containerization technology. Build on top of the rocker image, the Dockerfile is configured to install all the system dependencies, required packages and restore the renv environment.

1. Install Podman and create a podman machine
   
2. Navigate to the root folder of the project

cd path/to/PROJECT_DIR

3. Build the container image from Dockerfile.

podman build -t PROJECT_IMAGE -f Dockerfile

4. Create and run a container with the mounted local directory and on port 8080:

podman run -d --name PROJECT_CONTAINER --mount "type=bind,src=$(pwd),target=/PROJECT_DIR" -p 8080:80 PROJECT_IMAGE 

5. Log in into your container:

podman exec -it PROJECT_CONTAINER /bin/bash

OR you can SSH into the container with the default password (password), where 172.27.59.242 is the ip address of your WSL installation:

# Get your WSL ip address
wsl hostname -I
#> 172.27.59.242 10.88.0.1

# Log in into it
ssh root@172.27.59.242 -p 8080

or if you are working under Linux:

# Get your container's ip and port
podman container inspect -f '{{.NetworkSettings.IPAddress}} {{.NetworkSettings.Ports}}' PROJECT_CONTAINER
#> 10.88.0.8 map[80/tcp:[{0.0.0.0 8080}]]

# SSH into it
ssh [email protected] -p 80

First launch w/o renv.lock

If you are running the podman container the first time, it's important to comment step requiring to configure renv. It's better to do it manually in R using renv::init(). This is because renv should create renv.lock and other files, which we prefer to keep on the local machine, not container. Only renv library will be stored on container in folder /renvlib.

[atsyplenkov]

And I prefer to store RENV_LIBRARY not in the project folder. Here is the .Renviron:

RENV_CONFIG_AUTOLOADER_ENABLED = "TRUE"
RENV_PATHS_LOCKFILE = "renv.lock"
RENV_CONFIG_PAK_ENABLED = "TRUE"
RENV_PATHS_LIBRARY = "/renvlib"

[atsyplenkov]

Below are my notes on how to ssh into WSL in Positron, using the open-remote-ssh. Everything should be the same and for Podman container, apart from the User (root) and Port (8080) vars

Configure Positron to ssh into WSL

Now, let's go to the Positron IDE and in the command palette (Ctrl+Shift+P) find Remote-SSH: Open SSH Configuration File.... If you have never used it before, it should be empty. We need to add here WSL's name, ip address, port and username as follows:

Host <WSL NAME>
    HostName <WSL IP ADDRESS>
    Port <LISTEN PORT>
    User <WSL USERNAME>

#> My config is
#> Host Debian
#>    HostName 172.27.59.242
#>    Port 2222
#>    User atsyp

That's it. Save the config file, then navigate to the Activity Bar, find the Remote Explorer extension, select SSH Targets in the drop-down menu, refresh list, find Debian, right-click on it and select Connect to Host in New Window. You will be asked to enter your <WSL PASSWORD> and the first connection will take some time, as Positron needs to install some additional things.

[b-rodrigues]

very nice, thank you! this is quite helpful. I will take inspiration from this for #404