Air-Gapped Package Manager

Advanced

Package Manager communicates with the Posit Package Service to access CRAN, Bioconductor, PyPI, and Open VSX packages and metadata. In offline (air-gapped) environments, it is possible to directly download the necessary data from the online Posit Package Service and then copy it to an offline Package Manager server.

flowchart LR
    subgraph "Internet-Connected Environment"
        A["Posit Package Service<br>(CRAN, PyPI, Open VSX, etc.)"]
        B{"rspm-offline-downloader"}
        A --> B
    end
    
    C@{ shape: cyl, label: "Removable Media<br>e.g., USB drive, etc." }
    D["Offline Posit Package Manager Server"]
    
    B -->|Download Packages/Metadata| C
    C -->|Transfer Data| D

This guide walks through the steps of setting up the offline environment, performing regular updates, and upgrading Package Manager in offline environments.

Storage Requirements

The amount of disk storage required to run Package Manager in an offline environment depends on the types of packages you have configured. A typical installation will require at least 250 GB of additional disk storage, but this can vary based on other factors specific to CRAN, Bioconductor, PyPI, and Open VSX.

CRAN

CRAN requires at least 170 GB of storage space.

If CRAN binary package serving is enabled, the required storage will increase depending on the number of platforms in use.

Each R version, distribution, and architecture combination requires an additional 200 GB of storage on average. The size varies between 100 to 300+ GB, with newer R versions and distributions tending to be smaller.

Note

For example, at least 800 GB of storage space is required to support R package binaries for R 4.4 and 4.5 on RHEL 8 and RHEL 9, for the x86_64 architecture.

Bioconductor

Bioconductor requires up to 220 GB of storage per Bioconductor version. The total size of Bioconductor will be over 2.6 TB, so Package Manager allows a subset of Bioconductor versions to be used in offline environments.

If Bioconductor binary package serving is enabled, the required storage increases for each Bioconductor version you mirror binaries for. Each Bioconductor version pins a single R version. The number of binary platforms is therefore the number of Bioconductor versions multiplied by the distributions and architectures you select, rather than a free combination of R versions and distributions.

ImportantCRAN and Bioconductor binaries share one location

Package Manager serves CRAN and Bioconductor binaries from a single location. Mirror both into the same destination directory. If you download them into separate directories, the server finds no binary index for the packages in the other directory and quietly serves those packages from source, with nothing in the server log to indicate why.

PyPI

PyPI requires more than 20 TB of storage for the entirety of PyPI. This is too large to download in most cases, so Package Manager allows a subset of PyPI packages to be used in offline environments.

The total size of the offline PyPI data will depend on your use of packages. Deep learning packages, such as Tensorflow and PyTorch, are notoriously large, with hundreds of gigabytes needed for each project’s collection of files. If you do not anticipate using deep learning packages, a starting storage size of 50 GB is likely adequate. If you do intend to use deep learning packages, you should plan for 500 GB or more.

Open VSX

Open VSX storage requirements depend on the number of extensions you choose to mirror and the platforms you target.

For reference, the full Open VSX registry (all extensions, all platforms) is approximately 2 TB. Most deployments need only a curated list of extensions for a few platforms, which is significantly smaller. A typical set of 50-100 popular extensions for a few platforms requires 2-5 GB of storage. Extensions with many platform-specific builds (such as language servers with native components) will require more space.

Using the --target-platforms flag to limit downloads to only the platforms in use can significantly reduce storage requirements.

Initial Setup

First, install the offline downloader on a system with outbound internet access to the Posit Package Service, https://rspm-sync.rstudio.com. The version of the offline downloader must match the version of your Package Manager server.

Review the commands to download offline package data for CRAN, Bioconductor, PyPI, or Open VSX:

Downloading the Data

When ready, run the download commands with the appropriate flags to perform the full download. Each command supports a --dryrun flag to describe what will be downloaded without saving any files.

If running more than one command, use the same --destination path for each command.

The commands will download metadata and package files, and may take some time to complete. The --concurrency flag (which defaults to 500) may be adjusted to speed up the downloads, depending on network conditions. Faster connections may benefit from a higher download concurrency, while slower connections may benefit from a lower concurrency.

If a proxy is required to access the Posit Package Service, use the --outbound-proxy flag to specify an outbound proxy server for downloading.

NoteChanging download parameters

The offline downloader is additive-only. It does not remove files from previous runs. If you change your download parameters (e.g., the extension list, --target-platforms, --distributions, or requirements.txt), stale files from previous downloads will remain in the destination directory. Use a clean destination directory when changing download parameters to avoid serving outdated or unwanted data.

Because CRAN and Bioconductor binaries share one location, starting from a clean destination directory removes both. Plan to re-run get cran and get bioconductor together when you do this, so the destination ends up with the binaries for both sources.

CRAN

To download the minimum required offline CRAN data:

Terminal
./rspm-offline-downloader get cran --rspm-version=2026.08.0 --destination=[/path/to/destination/]

If CRAN binary package serving is enabled, download the binary packages for just the R versions, distributions, and architectures you need using the --include-binaries, --r-versions, --distributions, and --architectures flags.

For example, to download the binary packages for R 4.4 and 4.5, for RHEL 9, Ubuntu 24 (Noble), and Windows:

Terminal
./rspm-offline-downloader get cran --rspm-version=2026.08.0 --destination=[/path/to/destination/] \
    --include-binaries --r-versions=4.4,4.5 --distributions=rhel9,noble,windows

If the --architectures flag is not specified, all architectures will be downloaded for the applicable distributions. If you only need specific architectures, you can specify them using the --architectures flag. For example, to download macOS binary packages for arm64 only or x86_64 only:

Terminal
# Download macOS binary packages for arm64 only
./rspm-offline-downloader get cran --rspm-version=2026.08.0 --destination=[/path/to/destination/] \
    --include-binaries --r-versions=4.4,4.5 --distributions=macos --architectures=arm64

# Download macOS binary packages for x86_64 only
./rspm-offline-downloader get cran --rspm-version=2026.08.0 --destination=[/path/to/destination/] \
    --include-binaries --r-versions=4.4,4.5 --distributions=macos --architectures=x86_64

After running the download command, you can validate that the files were downloaded correctly using the rspm-offline-downloader validate cran command:

Terminal
./rspm-offline-downloader validate cran --rspm-version=2026.08.0 --destination=[/path/to/destination] --packages

Adding binary packages to an existing offline environment

To add binary packages to an offline environment that already has the source packages, use the --skip-source flag. The download then contains only the binary packages and the manifest, so it is much smaller to transfer to the offline server. Copy the result into the existing destination directory, alongside the source packages already there.

The flag requires --include-binaries.

Terminal
./rspm-offline-downloader get cran --rspm-version=2026.08.0 --destination=[/path/to/destination/] \
    --include-binaries --r-versions=4.4 --distributions=jammy --skip-source

Package Manager serves source packages for any platform a binary package is not available for, so do not serve a dataset downloaded with --skip-source on its own.

Downloading a subset of CRAN packages

Instead of the full CRAN mirror, you can download only a specific set of packages and their dependencies by passing a requirements.txt file with the --file-in flag. The offline downloader resolves all dependencies of the listed packages, so you do not need to list them yourself. It also downloads each package’s complete version history, so older and archived versions remain installable.

The requirements.txt format is one package name per line (lines starting with # are comments and blank lines are ignored):

requirements.txt
dplyr
jsonlite

Then pass it with --file-in. Add --include-binaries and the platform flags described above to also download binaries for those packages:

Terminal
./rspm-offline-downloader get cran --rspm-version=2026.08.0 --destination=[/path/to/destination/] \
    --file-in=requirements.txt --include-binaries --r-versions=4.5 --distributions=jammy
ImportantAlways list every package you want served, including ones you already have

The requirements file is the complete list of what the repository serves, not a list of packages to add. Every download rebuilds the package index to match the file exactly, so a package missing from the file is missing from the index.

This matters when you add a package later. To add jsonlite to a repository that already serves dplyr, add jsonlite to your existing requirements file and keep dplyr in it:

requirements.txt
dplyr
jsonlite

Do not download with a file that lists only jsonlite. That download contains a valid index for jsonlite alone, and copying it into the destination directory replaces the index that listed dplyr. The result is a repository that serves one package instead of two.

dplyr’s files are not deleted when this happens. They remain in the destination directory and the repository simply stops listing them, so recovery is to restore the full requirements file and download again. Nothing needs to be re-transferred except the index. Because the files are still on disk, the destination directory’s size is not a reliable signal that anything went wrong: check the package count the repository serves.

The same applies to a package you remove from the requirements file. Removing it stops the repository serving it, which is the intended way to retire a package, but it is worth knowing that it takes effect on the next download.

This is true of every repository type that accepts a requirements file, not just CRAN: Bioconductor, Python, and Open VSX downloads all rebuild their index from the file in the same way.

Limiting how much version history to download

By default the download includes each package’s complete version history, which for a full mirror is most of its size. Use the --since flag to keep only the versions that were current on or after a date you choose:

Terminal
./rspm-offline-downloader get cran --rspm-version=2026.08.0 --destination=[/path/to/destination/] \
    --since=2025-01-01

The date is your mirror’s retention start. Choose it once, when you first build the mirror, and record it with your other download settings: pass the same date on every run. Doing so means each run keeps everything the previous run kept, plus whatever is new.

The window keeps the versions that were current on or after that date. Versions that had already been archived before it are not downloaded, which is where most of the size reduction comes from.

No package is dropped entirely. If a package had no release on or after the date, the download keeps its most recent earlier version, so a package that has not changed in years remains installable.

--since works on a full mirror as shown above, and it also works with --file-in to limit version history for a chosen set of packages. It behaves the same way with get bioconductor. You can also set it in the requirements file, which keeps the setting with the package list; a --since flag on the command line overrides the file:

requirements.txt
--since 2025-01-01
dplyr
jsonlite
Note

--since chooses how much version history the mirror keeps. It is different from --starting-snapshot and --ending-snapshot, which limit what a single run downloads when the previous download is not available on the machine you are running from.

The two work together. To ship updates on external media without copying the whole dataset each time, use the same --since date on every run and add --starting-snapshot to download only the files added since your last transfer.

WarningAn incremental download is not a working repository on its own

A download made with --starting-snapshot contains only the files added since the date you gave. It is meant to be copied into a destination directory that already holds everything older, and it only works there.

Do not serve or test one by itself. Its package index still lists every package in the repository, not just the ones it contains, so the repository looks complete while most installs fail: in a typical incremental download the index lists tens of thousands of packages and the files for a couple of thousand are present. Verify an incremental download only after you have copied it into the destination directory, and use validate cran, validate bioconductor, validate pypi, or validate openvsx there.

Important--starting-snapshot cannot be combined with --file-in for CRAN or Bioconductor

--starting-snapshot downloads only the files dated on or after the date you give, on the assumption that the machine you copy the data to already holds everything older. That assumption holds for a full mirror you update repeatedly. It does not hold when you select packages by name with --file-in, because the set of packages you want can grow:

  • You add a package to the requirements file, and all of its versions predate the date you gave.
  • An updated package gains a new dependency, and that dependency’s versions predate the date you gave. This happens without any change to your requirements file.

In both cases the package index lists the package but the download does not contain it, so installing it fails. Run --file-in downloads without --starting-snapshot. A --file-in download is much smaller than a full mirror, so a complete run is inexpensive.

Bioconductor

By default, the get bioconductor command downloads offline Bioconductor data for all versions of Bioconductor:

Terminal
./rspm-offline-downloader get bioconductor --rspm-version=2026.08.0 --destination=[/path/to/destination/]

Since this is very large, we recommend downloading just the subset of Bioconductor versions in use with the --versions flag. For example, to download offline data for just the current release and devel versions:

Terminal
./rspm-offline-downloader get bioconductor --rspm-version=2026.08.0 --destination=[/path/to/destination/] \
    --versions=release,devel

Or to download offline data for just Bioconductor 3.17 and 3.18:

Terminal
./rspm-offline-downloader get bioconductor --rspm-version=2026.08.0 --destination=[/path/to/destination/] \
    --versions=3.17,3.18

Bioconductor binary packages

To also mirror Bioconductor binary packages, add --include-binaries and the distributions to download them for:

Terminal
./rspm-offline-downloader get bioconductor --rspm-version=2026.08.0 --destination=[/path/to/destination/] \
    --versions=release,devel --include-binaries --distributions=jammy,rhel9

Each Bioconductor version pins a single R version, so Package Manager selects the R versions for you. Use --r-versions to narrow the download to particular R versions. The downloader reports and skips any Bioconductor version that pins a different R version. For example, if you only serve R 4.4:

Terminal
./rspm-offline-downloader get bioconductor --rspm-version=2026.08.0 --destination=[/path/to/destination/] \
    --versions=release,devel --include-binaries --distributions=jammy --r-versions=4.4

Binaries are available for the main Bioconductor software repository. The data, workflow, and book repositories contain no compiled code, so they are always served from source.

Use --architectures to limit the download to specific architectures. By default, all architectures available for the selected distributions are downloaded.

Mirror Bioconductor binaries into the same destination directory as your CRAN data. See Bioconductor storage requirements for why.

After running the download command, you can validate that the files were downloaded correctly using the rspm-offline-downloader validate bioconductor command:

Terminal
./rspm-offline-downloader validate bioconductor --rspm-version=2026.08.0 --destination=[/path/to/destination] --packages

You can also download only a specific set of Bioconductor packages and their dependencies with a requirements.txt file and the --file-in flag. As with CRAN, the offline downloader resolves all dependencies of the listed packages (Bioconductor --file-in downloads sources only):

Terminal
./rspm-offline-downloader get bioconductor --rspm-version=2026.08.0 --destination=[/path/to/destination/] \
    --versions=release --file-in=requirements.txt

As with CRAN, you cannot combine --file-in with --starting-snapshot, and --since works here too. See Limiting how much version history to download. The requirements file must also list every package you want served, not just newly added ones; see Downloading a subset of CRAN packages.

NoteUpdating Bioconductor data

When updating downloaded Bioconductor data, you may choose to download only versions for which you need new data. When copying the new data to the air-gapped server, be sure to keep the data for previous versions. If you remove any data for versions that are in use, errors will occur when attempting to access packages or metadata from those versions.

PyPI

Since the entirety of PyPI is too large to download in most cases, Package Manager mirrors a subset of PyPI when running in offline environments. You must specify a subset of PyPI packages to download using a requirements.txt file.

This is similar to Curated PyPI Sources, and requirements.txt files from curated PyPI sources may be reused for the offline downloader.

Otherwise, create a requirements.txt file containing each PyPI package necessary for your installation, including all dependencies. The format of requirements.txt is a text file with one package name per line:

Requirements Format
[package name]

For example, a requirements.txt file for a mirror of the Django and numpy packages could look like:

requirements.txt
asgiref
Django>=5.1
numpy==2.1.0
pip
setuptools
sqlparse
typing_extensions

See Generating requirements.txt for more details on how to generate a requirements.txt file.

Note

Currently, the requirements.txt file format for the offline downloader only supports package names with optional version constraints. Recursive file references and other definitions (e.g., extras, option flags, environment markers) will be ignored.

Once you have the requirements.txt file, specify the path to it using the --file-in flag:

Terminal
./rspm-offline-downloader get pypi --rspm-version=2026.08.0 --destination=[/path/to/destination] \
    --file-in=requirements.txt

The requirements file must list every package you want served, not just newly added ones. Each download rebuilds the package index to match the file, so adding a package means adding it to your existing file rather than downloading with a file that lists only the new package. See Downloading a subset of CRAN packages for what happens otherwise.

After running the download command, you can validate that the files were downloaded correctly using the rspm-offline-downloader validate pypi command.

Terminal
./rspm-offline-downloader validate pypi --rspm-version=2026.08.0 --destination=[/path/to/destination] --packages
NoteLimitations and recommendations

The mirrored PyPI subset will only include snapshots where the specified packages have changed. The PyPI snapshot calendar will only display these snapshots, so there may not be as many available dates as a full PyPI repository.

Changing the included subset of packages will alter the historical snapshots in the PyPI source, potentially affecting users installing packages from frozen snapshot URLs. Curated PyPI sources will not change, however, and will continue to include their originally added packages.

We recommend only adding packages to the offline subset in most cases, and only removing packages when it is certain that no users or curated sources are using that removed package. If removing a package causes package installation failures or prevents a curated PyPI source from being updated, this may be resolved by restoring the removed package in the offline data, or removing the package from the curated PyPI source.

Open VSX

The get openvsx command supports two modes: downloading all extensions, or downloading a curated subset.

NotePreview downloads with –dryrun

Use the --dryrun flag to preview what will be downloaded without saving any files. For Open VSX, the dry run reports the total estimated download size and file counts, which is useful for planning storage requirements before committing to a full download. Note that --dryrun still downloads a small amount of metadata (manifest and checkpoint index) to a temporary directory in order to compute the estimates.

Terminal
./rspm-offline-downloader get openvsx --rspm-version=2026.08.0 --destination=[/path/to/destination] --dryrun

Downloading all extensions

To download all Open VSX extensions:

Terminal
./rspm-offline-downloader get openvsx --rspm-version=2026.08.0 --destination=[/path/to/destination]
WarningStorage requirements

Downloading all extensions without platform filtering requires approximately 2 TB of storage. Use --target-platforms to significantly reduce the download size if your users only need specific platforms.

To download all extensions for specific platforms only:

Terminal
./rspm-offline-downloader get openvsx --rspm-version=2026.08.0 --destination=[/path/to/destination] \
    --target-platforms=linux-x64,linux-arm64

Downloading a subset of extensions

To download only specific extensions, create an extensions.txt file containing each extension to mirror, one per line, in namespace.name format:

extensions.txt Format
# Lines starting with # are comments
# Blank lines are ignored

ms-python.python
golang.go
redhat.vscode-yaml
ms-toolsai.jupyter
NoteAutomatic dependency resolution

You do not need to list extension dependencies manually. The offline downloader automatically resolves and downloads all transitive dependencies and bundled extensions for each extension in the file.

Once you have the extensions.txt file, download the extensions:

Terminal
./rspm-offline-downloader get openvsx --rspm-version=2026.08.0 --destination=[/path/to/destination] \
    --file-in=extensions.txt

You can also combine --file-in with --target-platforms to further reduce download size:

Terminal
./rspm-offline-downloader get openvsx --rspm-version=2026.08.0 --destination=[/path/to/destination] \
    --file-in=extensions.txt --target-platforms=linux-x64,linux-arm64

Platform filtering

The --target-platforms flag works with both download modes. The download always includes the universal platform, which serves as the fallback for extensions without platform-specific builds.

Available platforms include: linux-x64, linux-arm64, darwin-x64, darwin-arm64, win32-x64, win32-ia32, alpine-x64, alpine-arm64, and web.

Validation

After running the download command, validate the files using the rspm-offline-downloader validate openvsx command:

Terminal
./rspm-offline-downloader validate openvsx --rspm-version=2026.08.0 --destination=[/path/to/destination] --packages

Copying the Data

After the offline data has been downloaded, copy it over to the offline Package Manager server.

First, create a directory to store the data in the offline Package Manager server, such as /var/lib/rspm-offline-data. If you have a cluster of nodes, use shared storage for this directory.

Terminal
sudo mkdir -p /var/lib/rspm-offline-data

Copy the data downloaded earlier from the online system to this directory on the offline Package Manager server. For completely isolated servers, you may need to copy the data to a physical drive in order to move it to the offline environment.

For example, if the downloaded data was located at /path/to/data:

Terminal
sudo cp -r /path/to/data/. /var/lib/rspm-offline-data

Confirm that the offline data directory has all the files from the original data directory.

Finally, modify the permissions on the directory in the offline Package Manager server, changing ownership to the Unix account running Package Manager, rstudio-pm by default:

Terminal
sudo chown -R rstudio-pm:rstudio-pm /var/lib/rspm-offline-data

Configuring Package Manager

Next, configure the offline Package Manager server to use the downloaded data. Set the Manifest.URL configuration setting to the file path of the offline data directory.

/etc/rstudio-pm/rstudio-pm.gcfg
[Manifest]
URL = A URL in the form, `file:///<the directory you created in the previous section>`

For example, if your offline data directory is at /var/lib/rspm-offline-data, the file /etc/rstudio-pm/rstudio-pm.gcfg should contain:

/etc/rstudio-pm/rstudio-pm.gcfg
[Manifest]
URL = file:///var/lib/rspm-offline-data

Once the file is updated, restart the Package Manager server:

Terminal
sudo systemctl restart rstudio-pm

If the configuration was successful, you should see messages like this in the server log at /var/log/rstudio/rstudio-pm/rstudio-pm.log:

/var/log/rstudio/rstudio-pm/rstudio-pm.log
Configured to serve CRAN data from a directory. Checking path '/var/lib/rspm-offline-data'.
Configured to serve Bioconductor data from a directory. Checking path '/var/lib/rspm-offline-data'.
Configured to serve PyPI data from a directory. Checking path '/var/lib/rspm-offline-data'.
Configured to serve OpenVSX data from a directory. Checking path '/var/lib/rspm-offline-data'.

Follow the Quick Start guide to make CRAN, Bioconductor, PyPI, or Open VSX packages available in the offline Package Manager server. Package Manager will now update package data from the offline data directory (e.g., /var/lib/rspm-offline-data) rather than the online Posit Package Service.

To set up an Open VSX mirror in the offline environment, see Open VSX Mirror.

Regular Updates

It is important to regularly update data available on the offline server. The Posit Package Service is typically updated with new packages every day.

We recommend using the follow steps to keep your offline server up to date:

  1. If you have maintained the originally downloaded files, you can perform a relatively fast update by rerunning the rspm-offline-downloader commands. Subsequent command executions will simply add or update files as necessary without redownloading the entire set.

  2. Copy the directory from the online machine to the directory created in the offline Package Manager during the initial setup, e.g., /var/lib/rspm-offline-data. Ensure that the directory is still owned by the Unix account running Package Manager, rstudio-pm by default.

  3. Once the offline data directory has been updated, the Package Manager server will automatically synchronize the new data during the scheduled syncs. You may also manually synchronize the data by running the rspm sync command.

Note

If you manually update the offline data using an external drive, you can use the --starting-snapshot flag to only download new files since your last synchronization. Use the validate cran, validate bioconductor, validate pypi, or validate openvsx command in the rspm-offline-downloader tool to ensure that the destination directory is valid.

For CRAN and Bioconductor, --starting-snapshot is only for full-mirror downloads. If you select packages by name with --file-in, run the update without --starting-snapshot. See Limiting how much version history to download for the reason.

Updating Vulnerability Data

Package vulnerability data changes often, typically daily, so you may want to update the vulnerability data without updating any package data. This can be done using the rspm-offline-downloader get vulns command.

Terminal
./rspm-offline-downloader get vulns --destination=[/path/to/destination]

After staging the new vulnerability data into the offline-data directory, Package Manager will pick up the change on its next scheduled vulnerability sync. To load the new data into the running server immediately, run:

Terminal
rspm sync --type=vulns

This triggers a sync for every ecosystem that has at least one repository exposing it. The command does not return until the running server reloads the data, so a successful response guarantees that subsequent requests to the vulnerability endpoints see it. You do not need to restart the server.

Note

In a clustered deployment, other nodes fetch vulnerability data asynchronously. If the load balancer routes a request to a different node, that node can still briefly serve old data.

Upgrading Package Manager

A new version of Package Manager may require data from a new version of the Posit Package Service. To ensure a smooth upgrade with limited downtime, we recommend the following steps:

  1. You will need a staging environment that mirrors your offline production server. After creating this environment, begin by upgrading the offline staging server to the latest Package Manager release.

  2. Follow the instructions for the Initial Setup of an Air-Gapped server in the Initial Setup section, using the offline staging server. Always install the matching version of the offline downloader utility for your Package Manager server.

  3. After you have validated that everything works as expected, copy the offline data, e.g., /var/lib/rspm-offline-data, from the offline staging server to the offline production server.

  4. Upgrade the offline production server to the new version of Package Manager.

  5. (Optional) After an upgrade, clean up any unused files from the previous version of Package Manager. Navigate to the directory storing offline data, e.g., /var/lib/rspm-offline-data. This directory will contain versioned directories, e.g.,

    /v3
/v4

    The output from rspm-offline-downloader get [ cran | bioconductor | pypi | openvsx ] will have indicated the version of the Posit Package Service required by the current version of Package Manager, e.g., Performing full download of schema version v4.

  6. In this example, only the following directories are necessary:

    • /var/lib/rspm-offline-data/v4 (CRAN)
    • /var/lib/rspm-offline-data/manifest/v4 (CRAN)
    • /var/lib/rspm-offline-data/bioc/manifest/v5 (Bioconductor)
    • /var/lib/rspm-offline-data/pypi (PyPI)
    • /var/lib/rspm-offline-data/sysreqs (System Requirements)
    • /var/lib/rspm-offline-data/distros (Supported platforms)
    • /var/lib/rspm-offline-data/bindex (CRAN Package Binary Index)
    • /var/lib/rspm-offline-data/bin (CRAN Package Binaries)
    • /var/lib/rspm-offline-data/openvsx (Open VSX extensions)
    • /var/lib/rspm-offline-data/vulns (Vulnerabilities)

  7. The following directories can be removed if present:

    • /var/lib/rspm-offline-data/v3 (old CRAN data)
    • /var/lib/rspm-offline-data/v2 (old CRAN data)
    • /var/lib/rspm-offline-data/bioc/v3 (old Bioconductor data)
    • /var/lib/rspm-offline-data/bioc/v4 (old Bioconductor data)
Back to top