Positron R Integration Issue on NixOS: "Binary is not a shell script wrapping the executable"

[sinh-x]

I'm having trouble setting up R for Positron on NixOS. My R version is 4.4.2, and I can access it with the R command from my CLI without issues. However, Positron is unable to recognize it, giving the following error in the Positron R Extension output:

2025-02-09 14:00:39.717 [info] Log level: Debug
2025-02-09 14:00:39.717 [info] Refreshing testthat status
2025-02-09 14:00:39.748 [info] Not working in an R package
2025-02-09 14:00:39.748 [info] Context key 'testthatIsConfigured' is 'false'
2025-02-09 14:00:39.748 [info] Context key 'testthatHasTests' is 'false'
2025-02-09 14:00:39.829 [info] Skipping registry check on non-Windows platform
2025-02-09 14:00:39.975 [info] Possibly found R on PATH: /run/current-system/sw/bin/R.
2025-02-09 14:00:39.975 [info] Resolved R binary at /nix/store/pn5156f5qm6vrm23df6r1vz2hfqdbcji-R-4.4.2-wrapper/bin/R
2025-02-09 14:00:40.054 [info] Possibly found R on PATH: /run/current-system/sw/bin/R.
2025-02-09 14:00:40.054 [info] Resolved R binary at /nix/store/pn5156f5qm6vrm23df6r1vz2hfqdbcji-R-4.4.2-wrapper/bin/R
2025-02-09 14:00:40.062 [info] Candidate R binary at /nix/store/pn5156f5qm6vrm23df6r1vz2hfqdbcji-R-4.4.2-wrapper/bin/R
2025-02-09 14:00:40.062 [info] Binary is not a shell script wrapping the executable: /nix/store/pn5156f5qm6vrm23df6r1vz2hfqdbcji-R-4.4.2-wrapper/bin/R
2025-02-09 14:00:40.062 [info] Filtering out /nix/store/pn5156f5qm6vrm23df6r1vz2hfqdbcji-R-4.4.2-wrapper/bin/R: invalid R installation.

It seems Positron is finding the R binary, but it's not recognizing it as a valid R installation because it's not a shell script wrapper as Positron expects. Below is the last few lines of the /nix/store/pn5156f5qm6vrm23df6r1vz2hfqdbcji-R-4.4.2-wrapper/bin/R

1789   │ export R_LIBS_SITE
1790   │ R_LIBS_SITE=${R_LIBS_SITE:+':'$R_LIBS_SITE':'}
1791   │ R_LIBS_SITE=${R_LIBS_SITE/':''/nix/store/3h6bf22zcnxzs4jsbqn52f70plgjq2hd-r-boot-1.3-31/library'':'/':'}
1792   │ R_LIBS_SITE='/nix/store/3h6bf22zcnxzs4jsbqn52f70plgjq2hd-r-boot-1.3-31/library'$R_LIBS_SITE
1793   │ R_LIBS_SITE=${R_LIBS_SITE#':'}
1794   │ R_LIBS_SITE=${R_LIBS_SITE%':'}
1795   │ export R_LIBS_SITE
1796   │ exec "/nix/store/yhbsa7kjw2zdj30x4gpfzammglggbj9h-R-4.4.2/bin/R"  "$@"

And here is the content of /nix/store/yhbsa7kjw2zdj30x4gpfzammglggbj9h-R-4.4.2/bin/R

#!/nix/store/4fvc5fm8bszmkydng1ivrvr5cbvr1g60-bash-5.2p37/bin/bash
# Shell wrapper for R executable.

R_HOME_DIR=/nix/store/yhbsa7kjw2zdj30x4gpfzammglggbj9h-R-4.4.2/lib/R
if test "${R_HOME_DIR}" = "/nix/store/yhbsa7kjw2zdj30x4gpfzammglggbj9h-R-4.4.2/lib/R"; then
   case "linux-gnu" in
   linux*)
     run_arch=`uname -m`
     case "$run_arch" in
        x86_64|mips64|ppc64|powerpc64|sparc64|s390x)
          libnn=lib64
          libnn_fallback=lib
        ;;
        *)
          libnn=lib
          libnn_fallback=lib64
        ;;
     esac
     if [ -x "/nix/store/yhbsa7kjw2zdj30x4gpfzammglggbj9h-R-4.4.2/${libnn}/R/bin/exec/R" ]; then
        R_HOME_DIR="/nix/store/yhbsa7kjw2zdj30x4gpfzammglggbj9h-R-4.4.2/${libnn}/R"
     elif [ -x "/nix/store/yhbsa7kjw2zdj30x4gpfzammglggbj9h-R-4.4.2/${libnn_fallback}/R/bin/exec/R" ]; then
        R_HOME_DIR="/nix/store/yhbsa7kjw2zdj30x4gpfzammglggbj9h-R-4.4.2/${libnn_fallback}/R"
     ## else -- leave alone (might be a sub-arch)
     fi
     ;;
  esac
fi

if test -n "${R_HOME}" && \
   test "${R_HOME}" != "${R_HOME_DIR}"; then
  echo "WARNING: ignoring environment value of R_HOME"
fi
R_HOME="${R_HOME_DIR}"
export R_HOME
R_SHARE_DIR=/nix/store/yhbsa7kjw2zdj30x4gpfzammglggbj9h-R-4.4.2/lib/R/share
export R_SHARE_DIR
R_INCLUDE_DIR=/nix/store/yhbsa7kjw2zdj30x4gpfzammglggbj9h-R-4.4.2/lib/R/include
export R_INCLUDE_DIR
R_DOC_DIR=/nix/store/yhbsa7kjw2zdj30x4gpfzammglggbj9h-R-4.4.2/lib/R/doc
export R_DOC_DIR

# Since this script can be called recursively, we allow R_ARCH to
# be overridden from the environment.
# This script is shared by parallel installs, so nothing in it should
# depend on the sub-architecture except the default here.
: ${R_ARCH=}

usage="
Usage: R [options] [< infile] [> outfile]
   or: R CMD command [arguments]

Start R, a system for statistical computation and graphics, with the
specified options, or invoke an R tool via the 'R CMD' interface.

Options:
  -h, --help            Print short help message and exit
  --version             Print version info and exit
  --encoding=ENC        Specify encoding to be used for stdin
  --encoding ENC
  RHOME			Print path to R home directory and exit
  --save                Do save workspace at the end of the session
  --no-save             Don't save it
  --no-environ          Don't read the site and user environment files
  --no-site-file        Don't read the site-wide Rprofile
  --no-init-file        Don't read the user R profile
  --restore             Do restore previously saved objects at startup
  --no-restore-data     Don't restore previously saved objects
  --no-restore-history  Don't restore the R history file
  --no-restore          Don't restore anything
  --vanilla		Combine --no-save, --no-restore, --no-site-file,
			--no-init-file and --no-environ
  --no-readline         Don't use readline for command-line editing
  --max-connections=N   Set max number of connections to N
  --max-ppsize=N        Set max size of protect stack to N
  --min-nsize=N         Set min number of fixed size obj's (\"cons cells\") to N
  --min-vsize=N         Set vector heap minimum to N bytes; '4M' = 4 MegaB
  -q, --quiet           Don't print startup message
  --silent              Same as --quiet
  -s, --no-echo         Make R run as quietly as possible
  --interactive         Force an interactive session
  --verbose             Print more information about progress
  -d, --debugger=NAME   Run R through debugger NAME
  --debugger-args=ARGS  Pass ARGS as arguments to the debugger
  -g TYPE, --gui=TYPE	Use TYPE as GUI; possible values are 'X11' (default)
			and 'Tk'.
  --arch=NAME		Specify a sub-architecture
  --args                Skip the rest of the command line
  -f FILE, --file=FILE  Take input from 'FILE'
  -e EXPR               Execute 'EXPR' and exit

FILE may contain spaces but not shell metacharacters.

Commands:
  BATCH			Run R in batch mode
  COMPILE		Compile files for use with R
  SHLIB			Build shared library for dynamic loading
  INSTALL		Install add-on packages
  REMOVE		Remove add-on packages
  build			Build add-on packages
  check			Check add-on packages
  LINK			Front-end for creating executable programs
  Rprof			Post-process R profiling files
  Rdconv		Convert Rd format to various other formats
  Rd2pdf		Convert Rd format to PDF
  Rd2txt		Convert Rd format to pretty text
  Stangle		Extract S/R code from Sweave documentation
  Sweave		Process Sweave documentation
  Rdiff			Diff R output ignoring headers etc
  config		Obtain configuration information about R
  javareconf		Update the Java configuration variables
  rtags                 Create Emacs-style tag files from C, R, and Rd files

Please use 'R CMD command --help' to obtain further information about
the usage of 'command'.

Options --arch, --no-environ, --no-init-file, --no-site-file and --vanilla
can be placed between R and CMD, to apply to R processes run by 'command'

Report bugs at <https://bugs.R-project.org>."

## some systems have a more portable sed, e.g. /usr/xpg4/bin/sed on Solaris,
## so make sure that is used.
SED=/nix/store/v93bdqf52x2r2lqijv0f7x3yhylwy957-gnused-4.9/bin/sed
export SED

error () {
  echo "ERROR: $*" >&2
  exit 1
}

### Argument loop
args=
debugger=
debugger_args=
gui=
while test -n "${1}"; do
  case ${1} in
    RHOME|--print-home)
      echo "${R_HOME}"; exit 0 ;;
    CMD)
      shift;
      export R_ARCH
      . "${R_HOME}/etc${R_ARCH}/ldpaths"
      exec sh "${R_HOME}/bin/Rcmd" "${@}" ;;
    -g|--gui)
      if test -n "`echo ${2} | ${SED} 's/^-.*//'`"; then
	gui="${2}"
        args="${args} ${1} ${2}"
	shift
      else
	error "option '${1}' requires an argument"
      fi
      ;;
    --gui=*)
      gui=`echo "${1}" | ${SED} -e 's/[^=]*=//'`
      args="${args} ${1}"
      ;;
    -d|--debugger)
      if test -n "`echo ${2} | ${SED} 's/^-.*//'`"; then
	debugger="${2}"; shift
      else
	error "option '${1}' requires an argument"
      fi
      ;;
    --debugger=*)
      debugger=`echo "${1}" | ${SED} -e 's/[^=]*=//'` ;;
    --debugger-args=*)
      debugger_args=`echo "${1}" | ${SED} -e 's/[^=]*=//'` ;;
    -h|--help)
      echo "${usage}"; exit 0 ;;
    --args)
      break ;;
    --arch)
      if test -n "`echo ${2} | ${SED} 's/^-.*//'`"; then
	R_ARCH="/${2}"
        shift
      else
        error "option '${1}' requires an argument"
      fi
      ## check sub-architecture here for a better error message
      if ! test -d ${R_HOME}/etc${R_ARCH}; then
        error "sub-architecture '${1}' is not installed"
      fi
      ;;
    --arch=*)
      r_arch=`echo "${1}" | ${SED} -e 's/[^=]*=//'`
      R_ARCH="/${r_arch}"
      ## check sub-architecture here for a better error message
      if ! test -d ${R_HOME}/etc${R_ARCH}; then
        error "sub-architecture '${r_arch}' is not installed"
      fi
      ;;
    -e)
      TAB=`printf "\t"`
      if test -n "`echo ${2} | ${SED} 's/^-.*//'`"; then
	a=`(echo "${2}" && echo) | ${SED} -e 's/ /~+~/g' | \
          ${SED} -e :a -e N -e '$!ba' -e 's/\n/~n~/g' -e 's/~n~$//g' -e "s/$TAB/~t~/g"`
        shift
      else
	error "option '${1}' requires a non-empty argument"
      fi
      args="${args} -e $a"
      ;;
    -f)
      if test -n "`echo ${2} | ${SED} 's/^-.*//'`"; then
	a=`echo "${2}" | ${SED} -e 's/ /~+~/g'`; shift
      else
	error "option '${1}' requires a filename argument"
      fi
      args="${args} -f $a"
      ;;
    --file=*)
      a=`echo "${1}" | ${SED} -e 's/[^=]*=//' | ${SED} -e 's/ /~+~/g'`
      args="${args} --file=$a"
      ;;
    --no-environ)
      R_ENVIRON=''
      export R_ENVIRON
      R_ENVIRON_USER=''
      export R_ENVIRON_USER
      args="${args} ${1}"
      ;;
    --no-site-file)
      R_PROFILE=''
      export R_PROFILE
      args="${args} ${1}"
      ;;
    --no-init-file)
      R_PROFILE_USER=''
      export R_PROFILE_USER
      args="${args} ${1}"
      ;;
    --vanilla)
      R_ENVIRON=''
      export R_ENVIRON
      R_ENVIRON_USER=''
      export R_ENVIRON_USER
      R_PROFILE=''
      export R_PROFILE
      R_PROFILE_USER=''
      export R_PROFILE_USER
      args="${args} ${1}"
      ;;
    *)
      args="${args} ${1}" ;;
  esac
  shift
done

. "${R_HOME}/etc${R_ARCH}/ldpaths"

R_binary="${R_HOME}/bin/exec${R_ARCH}/R"
export R_ARCH

case "${gui}" in
Tk|tk|X11|x11)
  ;;
"")
  ;;
*)
  error "unknown GUI ${gui}"
esac

## R_HOME may have moved, so check
if test -x "${R_HOME}"; then
  :
else
  error "R_HOME ('${R_HOME}') not found"
fi

## Startup
if test -z "${debugger}"; then
  exec "${R_binary}"  ${args} "${@}"
else
  ## Ideally, we would like the debugger to start R with additional
  ## ('inferior') arguments, but not all debuggers can do this.  We know
  ## about valgrind and some versions of GDB , and deal with these.
  ## Otherwise, to be on the safe side, we disregard non-debugger
  ## command line args.
  args_ok=no
  case "`${debugger} --version 2>/dev/null`" in
    "GNU gdb"*)
      if ${debugger} --help 2>/dev/null | \
          grep ' *--args' >/dev/null; then
	args_ok=yes
	debugger_args="${debugger_args} --args"
      fi
      ;;
    valgrind*)
      args_ok=yes
      ;;
  esac
  if test -n "${args}${*}" && test "${args_ok}" = no; then
    args=`expr "${args} ${*}" : " *\(.*\)"`
    echo "*** Further command line arguments ('${args}') disregarded"
    echo "*** (maybe use 'run ${args}' from *inside* ${debugger})"
    echo ""
    exec ${debugger} ${debugger_args} "${R_binary}"
  else
    exec ${debugger} ${debugger_args} "${R_binary}" ${args} "${@}"
  fi
fi

### Local Variables: ***
### mode: sh ***
### sh-indentation: 2 ***
### End: ***

[jennybc]

It looks like Nix's methods for launching R with its intended modifications to R_LIBS_SITE break Positron's vetting of R installations. Nix is inserting an extra layer of indirection and this new wrapper script doesn't fulfill Positron's checks for what it expects for a discovered R "binary" (which is actually a shell script for non-Windows OSes).

As a hack or experiment, you could tell Positron about the actual "binary", which seems to be at /nix/store/yhbsa7kjw2zdj30x4gpfzammglggbj9h-R-4.4.2/bin/R via a setting:

https://positron.posit.co/r-installations.html#customizing-r-discovery

That will bypass the efforts to configure R_LIBS_SITE, so it presumably is not a true, long-term solution. My assessment is that, as it stands, Nix's methods for setting R_LIBS_SITE make it look like an invalid R installation.

[sinh-x]

Thanks, I manage to remove the layer of Nix wrapper and have positron discover R correctly.

Still, I couldn't find the config positron.r.customBinaries in the document links you shared. How can I config that?

Here is my positron version info

Positron Version: 2024.11.0 build 116
Code - OSS Version: 1.93.0
Commit: 8b1688ababfa228db515a739050c466f3bb3089f
Date: 2024-10-28T02:41:12.364Z
Electron: 30.4.0
Chromium: 124.0.6367.243
Node.js: 20.15.1
V8: 12.4.254.20-electron.0
OS: Linux x64 6.12.12

[jennybc]

Hmmmm, I see it when I do a similar settings search as you:

Your Positron version suggests it's from November 2024, so your first move should be to update that. It's quite likely that this feature landed in a public pre-release since you last updated.

[sinh-x]

Thank you, I managed to get the latest version of form github release and get it work perfectly now!

[Aman9das]

It occurs as Positron Checks for the String "Shell wrapper for R executable" and "R_HOME_DIR" in the Shell Script, which NixOS' rWrapper does not contain.

  r-set = (rWrapper.override { packages = rpkgs; }).overrideAttrs (
    finalAttrs: previousAttrs: {
      buildCommand =
        previousAttrs.buildCommand
        + ''
          # Modify the R script to add the desired comment
          sed -i '2i# Shell wrapper for R executable' $out/bin/R
          sed -i '3iR_HOME_DIR=${pkgs.R}/lib/R' $out/bin/R
        '';
    }
  );

Fixed it for me.
@detroyejr

[detroyejr]

Currently, the easiest way to use positron with nix is with something like the following:

let
  pkgs = import <nixpkgs> { };
in
pkgs.mkShell {
  packages = [
    # Positron
    pkgs.positron-bin

    # R & packages.
    pkgs.R
    pkgs.rPackages.httr
    pkgs.rPackages.ggplot2

    # Python, ipykernel & packages.
    # pkgs.python313
    # pkgs.python313Packages.ipykernel # NOTE: Required for python.
    # pkgs.python313Packages.pandas
    # pkgs.python313Packages.requests
  ];
}

You can drop this snippet into a "default.nix" file, adjust to your needs, and use nix-shell to get a working environment. This mkShell should be equivalent to what you would get with rWrapper and positron is able to use it just fine. I've not run into any major issues using this method but If this doesn't fit your use-case, please let me know.

The rWrapper override suggested by @Aman9das works but we still have an additional issue to figure out before it would really be useful since positron doesn't know about the R packages included in the wrapper. RStudio also behaves like this in nix which is why there are a couple different "wrappers" with similar API's and not just one single rWrapper.

If you have other questions or issues, feel free to open an issue in nixos/nixpkgs and/or ping me. I co-maintain the nixpkgs version of positron (not officially supported by Posit) along with @b-rodrigues and either of us are happy to help with these kinds of questions!

[joelnitta]

If I understand correctly @detroyejr , the solution you outline above involves using nix-shell to enter the environment, then running positron to launch positron from nix, correct?

I have a slightly different use-case: I am trying to use R within a nix environment on a remote server that I connect to via SSH. I can't use the method above because, although I am able to get a GUI that shows up with Positron running, it has an unacceptably slow lag that makes it impossible to use as an IDE.

I think it would be great if nix environments showed up in the list of interpreters just like it does for conda envs.

[detroyejr]

@joelnitta This is a tricky one and I don't have a great solution. But, I've got a workaround to get an R installation working with remote ssh which is better than nothing.

Here's the same shell as above with a shellHook.

let
  pkgs = import <nixpkgs> { };
in
pkgs.mkShell {
  packages = [
    # Positron
    pkgs.positron-bin

    # R & packages.
    pkgs.R
    pkgs.rPackages.httr
    pkgs.rPackages.ggplot2
  ];

  shellHook = ''
    # Customize R_LIBS_SITE
    echo "Modifying .Renviron"
    echo "R_LIBS_SITE=$(Rscript -e 'paste(.libPaths(), collapse = ":")' | cut -d' ' -f2)" > .Renviron
    echo "Add ${pkgs.R}/bin/R to positron.r.customBinaries for discovery."
  '';
}

On your SSH machine, run nix-shell to download dependencies and execute the shellHook. It writes R_LIBS_SITE to an .Renviron file providing it with information about all the packages that are available in nix. When positron launches to use this workspace, it should pick up the .Renviron file like R normally does.

Next follow the instructions on the last line and add the printed /nix/store path to the positron.r.customBinaries. My settings on the remote side look like this:

{
    "positron.r.customBinaries": [
        "/nix/store/6kr6ps54j136aiw52xbbq97qx5jrla6r-R-4.4.3/bin/R"
    ]
}

When I restart, re-connect to ssh, and open the project folder everything worked as I would expect. If you update the R packages set, you'll need to re-run nix-shell in order for R_LIBS_SITE to update.

Hopefully we can improve this a bit over time, but the remote ssh extension doesn't give us a lot of customization options. Positron also has specific things it looks for when discovering R installations so we're limited by that too.

For python, it's a little easier since positron is more flexible with what it discovers.

let
  pkgs = import <nixpkgs> { };
in
pkgs.python3.withPackages (
  ps: with ps; [
    requests
  ]
)

You can nix-build this file and get a symlinked "result" which positron will discover and choose as the default when you open the project folder. This might work with remote ssh as well if you nix-build there too. Hope that helps!