Entornos reproducibles para análisis de datos con {renv}

Mejora la reproducibilidad de tus proyectos fijando las versiones de los paquetes usados

18/11/2026

consejos avanzado reproducibilidad

La reproducibilidad es el conjunto de prácticas que permiten que tus procesos puedan ser repetidos, ya sea por ti o por otras personas, garantizando que los resultados pueden volver a regenerarse de manera exacta. Es un concepto clave en proyectos de ciencia de datos, y para las ciencias en general.

Si bien la reproducibilidad es clave para las ciencias, también lo es para garantizar que tus procesos estén preparados para el futuro, puedan actualizarse, y puedan ser usados por otras personas.

Dentro de todas las cosas que pueden hacer que un proyecto no sea reproducible están todos los problemas que pueden impedir que tu proyecto se ejecute en el futuro, o que haga que sus resultados sean imposibles de repetir. Por ejemplo: datos faltantes o inexistentes, rutas a archivos fuera del proyecto e imposibles de localizar, y las versiones de los paquetes usados.

{renv} te ayuda a congelar las versiones de los paquetes que uses, para que puedas reinstalarlos en el futuro o en otros computadores y tu proyecto siga funcionando sin sorpresas.

Cómo funciona {renv}

Normalmente, todos los paquetes que instalas en R quedan en una librería global de tu computador (una carpeta misteriosa en las profundidades de tu sistema operativo), y todos tus proyectos usan esos mismos paquetes. El problema es que, si actualizas un paquete para un proyecto nuevo, la actualización también afecta a tus proyectos antiguos, que podrían dejar de funcionar o entregar resultados distintos.

Con {renv}, cada proyecto tiene su propia librería de paquetes, aislada del resto del sistema.

sin {renv}
sistema
paquetes
proyecto A
proyecto B
con {renv}
sistema
caché de {renv}
↓ ↓
proyecto A
paquetes
proyecto B
paquetes
Sin {renv}, todos los proyectos comparten los paquetes del sistema. Con {renv}, cada proyecto tiene sus propios paquetes, enlazados desde el caché.

{renv} mantiene un registro de paquetes usados en el proyecto con sus versiones exactas en renv.lock (el lockfile). Este archivo es lo que permite que después los paquetes se puedan volver a instalar de manera reproducible en otro momento o en otro computador.

Los paquetes instalados por {renv} se guardan en un caché que se enlaza desde ahí a cada proyecto, en la versión que corresponda. Así, si dos proyectos usan la misma versión de un paquete, no necesita reinstalarse!

Por qué usarlo

Algunas situaciones donde {renv} hace la diferencia:

  • Compartir un proyecto con un/a colega, para que pueda ejecutarlo con los mismos paquetes que usaste tú, sin tener que adivinar qué instalar.
  • Migrar proyectos a otro computador, instalando todos los paquetes necesarios con un solo comando.
  • Archivar proyectos terminados, para asegurarte que en el futuro puedas volver a ejecutarlos y obtener los mismos resultados.
  • Desplegar proyectos a producción, como aplicaciones Shiny o procesos en servidores, para que las versiones de los paquetes queden fijas y ninguna actualización eche a perder nada.

Empezar a usar {renv}

A grandes rasgos, lo que hará {renv} en tu proyecto es registrar los paquetes usados en tu código, registrar sus versiones actuales, bajarlos en un caché, e instalarlos.

Luego, el paquete nos servirá para poder reinstalar los paquetes, y será también la forma en que podremos actualizar los paquetes usados (ya sea agregando nuevos o sacando automáticamente los que ya no se usen!)

Esquema del funcionamiento de {renv} en tu sistema. Basado en este diagrama.

Primero instalamos {renv} como cualquier otro paquete:

install.packages("renv")

Luego, con el proyecto abierto, iniciamos {renv}:

renv::init()

Esto revisará todos los scripts del proyecto para detectar qué paquetes se usan, los instala en la librería del proyecto, registra sus versiones en el lockfile, y reinicia la sesión de R.

Desde ese momento, cada vez que abras el proyecto o inicies R en esa carpeta, {renv} se activará automáticamente.

Al iniciar {renv} se crean los siguientes archivos en el proyecto:

renv.lock
Registro de los paquetes usados en el proyecto y sus versiones exactas.
renv/library/
Librería del proyecto, donde quedan los paquetes instalados.
renv/activate.R
Script que activa {renv} e instala la versión correcta del paquete si no está.
.Rprofile
Ejecuta renv/activate.R automáticamente al abrir el proyecto.

Revisar el estado

Algo que haremos con cierta frecuencia será revisar si los paquetes en uso del proyecto, los que están instalados y los que están registrados en el lockfile coinciden:

renv::status()

Si todo está en orden, veremos este mensaje:

No issues found -- the project is in a consistent state.

Esto significa que los paquetes que se usan están registrados en el lockfile!

De lo contrario, renv::status() nos va a indicar inconsistencias en el registro de paquetes y versiones, y qué función ejecutar para solucionarlo.

Lockfile

En el Lockfile (archivo renv.lock) se registran las versiones de los paquetes que usas, con toda la información necesaria para poder reinstalarlos en el futuro.

Al principio el archivo registra la versión de R que usas y los repositorios desde los que instalas paquetes (yo uso Posit Package Manager y el mirror de CRAN de la Universidad de Chile):

{
  "R": {
    "Version": "4.6.1",
    "Repositories": [
      {
        "Name": "CRAN",
        "URL": "https://packagemanager.posit.co/cran/latest"
      },
      {
        "Name": "Chile",
        "URL": "https://cran.dcc.uchile.cl"
      }
    ]
  },
  ...

…y luego viene la lista de paquetes usados e instalados en tu proyecto:

  "Packages": {
  "territorial": {
      "Package": "territorial",
      "Version": "0.9.13",
      "Source": "Repository",
      "Imports": [
        "cli",
        "dplyr",
        "forcats",
        "glue",
        "purrr",
        "stringr"
      ],
      # ...
      "Repository": "https://bastianolea.r-universe.dev",
      "RemoteType": "repository",
      "NeedsCompilation": "no",
      "RemoteUrl": "https://github.com/bastianolea/territorial",
      # ...
    },

Si te fijas, contiene información descriptiva, las dependencias de los paquetes, y los lugares desde donde tiene que instalarlos.

No necesitamos editar este archivo a mano, porque renv lo mantendrá actualizado!

Flujo de trabajo

Los conceptos principales son el estado (status, con renv::status()) y la foto (snapshot, con renv::snapshot()) que tomamos a las versiones de los paquetes para fijarlas.

Una vez iniciado {renv}, el trabajo diario en el proyecto sigue este ciclo:

Usar un paquete nuevo en el código
↓

Instalar un paquete nuevo

renv::install() o install.packages()
↓

Revisar el estado de la librería

renv::status()
↓

Registrar los paquetes y sus versiones

renv::snapshot()
↓
Seguir trabajando

La idea es que cada vez que el proyecto quede funcionando con un paquete nuevo o actualizado, tomemos una snapshot para que el lockfile refleje el estado actual del proyecto.

Casos de uso

Registrar nuevos paquetes

Si empezamos a usar un paquete nuevo en el proyecto, lo instalamos y luego registramos su versión en el lockfile:

install.packages("ggplot2")
library(ggplot2) # usar el paquete...
# renv::status()
renv::snapshot()

Desinstalar un paquete

Para dejar de usar un paquete, es tan simple como borrar sus referencias en los scripts del proyecto. Luego renv::status() se va a dar cuenta que ya no lo usas, y te sugerirá hacer un renv::snapshot() que eliminará el paquete sobrante del lockfile.

Actualizar paquetes

Para actualizar todos los paquetes del proyecto a sus versiones más recientes, o solamente uno:

# actualizar todos los paquetes
renv::update()

# actualizar un paquete
renv::update("dplyr")

Después de actualizar, ejecuta tu código para revisar que todo siga funcionando, y si es así, registra las nuevas versiones con renv::snapshot() para que queden en el lockfile. Si algo se echó a perder, renv::restore() vuelve a instalar las versiones que estaban registradas en el lockfile, deshaciendo la actualización. Seguridad!

Restaurar un proyecto

Cuando abrimos el proyecto en otro computador, descargamos un proyecto de otra persona que usa {renv}, o un cambio rompió algo, abrimos el proyecto de RStudio y restauramos los paquetes desde el lockfile:

renv::restore()
renv.lock
→
renv::restore()
→
librería del proyecto

La función renv::restore() lee el lockfile e instala cada paquete en la versión exacta que estaba registrada, dejando el proyecto tal como estaba cuando se tomó la última snapshot.

Compartir un proyecto

Para que otra persona pueda restaurar tu proyecto, siempre es una buena práctica compartir la carpeta entera del proyecto. Así incluyes todos los scripts, datos, readme.md y otros archivos asociados. Esto incluye los archivos renv.lock, .Rprofile y renv/activate.R, que le permitirán a otras personas hacer renv::restore().

Actualizar R

Un clásico: cuando actualizas R, tienes que volver a instalar todos tus paquetes. Pero si usas {renv}, luego de actualizar R sólo ejecutas renv::restore() y se instala todito de una.

Desactivar {renv}

Si queremos que el proyecto vuelva a usar la librería global del sistema, desactivamos {renv}:

renv::deactivate()

Esto conserva el lockfile y la carpeta renv, así que podemos volver a activarlo en cualquier momento con renv::activate(). Si queremos eliminar todo rastro de {renv} del proyecto, usamos renv::deactivate(clean = TRUE) o bien borramos todos los archivos y carpetas asociados a renv.

Limitaciones

{renv} fija las versiones de los paquetes, pero no controla la versión de R ni las dependencias del sistema operativo que algunos paquetes necesitan (por ejemplo, librerías geoespaciales para {sf}).

  • Si necesitas ejecutar varias versiones de R en un mismo computador y cambiar entre ellas, usa rig.
  • Si necesitas garantizar la reproducibilidad a nivel de versiones de R, existe rix: entornos reproducibles con Nix, y si lo requieres a nivel de sistema operativo, existe Docker.

La restauración de un proyecto puede fallar si un paquete tiene que compilarse desde el código fuente. Esto pasa porque, si bien CRAN ofrece versiones compiladas de los paquetes, no las ofrece para versiones antiguas, por lo que se dificultan las restauraciones. Para evitarlo, conviene instalar paquetes desde Posit Package Manager, que entrega paquetes binarios precompilados incluso de versiones antiguas, que se instalan más fácil y rápido.

Recursos

Fecha de publicación:
18/11/2026
Extensión:
9 minute read, 1840 words
Categorías:
Tutoriales
Tags:
consejos avanzado reproducibilidad
Ver también:
Instalar paquetes de R desde Posit Package Manager
Guía para programar en R con inteligencia artificial
Cargar archivos CSV más rápido en R con `{arrow}`