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
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.
Índice
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.
{renv}{renv}{renv}{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!)

{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:
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:
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()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.lockrenv::restore()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.
Publicaciones relacionadas
Recursos
- Introducción a
renv - Taller proyectos reproducibles con renv, impartido por Pao Corrales
- rix: entornos reproducibles para R con Nix, que llevan la reproducibilidad más allá que
{renv} - Capítulo sobre flujos de trabajo en R del libro R para Ciencia de Datos, que trata en profundidad el concepto de proyectos en RStudio.
- Ease
renv::restore()by updating your repository to Posit Public Package Manager - Instalar paquetes de R desde Posit Package Manager
Publicaciones sobre reproducibilidad
Publicaciones sobre consejos