Call snapshot() to create a lockfile capturing the state of a project's R package dependencies. The lockfile can be used to later restore these project's dependencies as required.

  project = NULL,
  library = NULL,
  lockfile = file.path(project, "renv.lock"),
  type = settings$snapshot.type(project = project),
  prompt = interactive(),
  force = FALSE



The project directory. If NULL, then the active project will be used. If no project is currently active, then the current working directory is used instead.


Unused arguments, reserved for future expansion. If any arguments are matched to ..., renv will signal an error.


The R libraries to snapshot. When NULL, the active R libraries (as reported by .libPaths()) are used.


The location where the generated lockfile should be written. By default, the lockfile is written to a file called renv.lock in the project directory. When NULL, the lockfile (as an R object) is returned directly instead.


The type of snapshot to perform. See Snapshot Type for more details. When NULL (the default), an "implicit"-style snapshot is performed.


Boolean; prompt the user before taking any action? For backwards compatibility, confirm is accepted as an alias for prompt.


Boolean; force generation of a lockfile even when pre-flight validation checks have failed?


The generated lockfile, as an R object (invisibly). Note that this function is normally called for its side effects.


See the lockfile documentation for more details on the structure of a lockfile.

Snapshot Type

Depending on how you prefer to manage dependencies, you might prefer selecting a different snapshot mode. The modes available are as follows:


Capture all packages within the active R libraries in the lockfile. This is the quickest and simplest method, but may lead to undesired packages (e.g. development dependencies) entering the lockfile.


Only capture packages which appear to be used in your project in the lockfile. The intersection of packages installed in your R libraries, alongside those used in your R code as inferred by renv::dependencies(), will enter the lockfile. This helps ensure that only the packages your project requires will enter the lockfile, but may be slower if your project contains a large number of files. If this becomes an issue, you might consider using .renvignore files to limit which files renv uses for dependency discovery, or explicitly declaring your required dependencies in a DESCRIPTION file. You can also force a dependency on a particular package by writing e.g. library(<package>) into a file called dependencies.R.


Only capture packages which are explicitly listed in the project DESCRIPTION file. This workflow is recommended for users who wish to more explicitly manage a project's R package dependencies.


Like "implicit", but use a custom user-defined filter instead. The filter should be specified by the R option renv.snapshot.filter, and should either be a character vector naming a function (e.g. "package::method"), or be a function itself. The function should only accept one argument (the project directory), and should return a vector of package names to include in the lockfile.

By default, "implicit"-style snapshots are used. The snapshot type can be configured on a project-specific basis using the renv project settings mechanism.

See also

Other reproducibility: lockfiles, restore()


if (FALSE) { # disable automatic snapshots auto.snapshot <- getOption("") options( = FALSE) # initialize a new project (with an empty R library) renv::init(bare = TRUE) # install digest 0.6.19 renv::install("digest@0.6.19") # save library state to lockfile renv::snapshot() # remove digest from library renv::remove("digest") # check library status renv::status() # restore lockfile, thereby reinstalling digest 0.6.19 renv::restore() # restore automatic snapshots options( = auto.snapshot) }