Por qué necesitas un gestor de versiones de Node.js
Si trabajas con JavaScript en el servidor durante el tiempo suficiente, tarde o temprano te encontrarás en esta situación: un proyecto heredado solo funciona con Node.js 20, el proyecto nuevo de tu equipo exige Node.js 26 y una librería que quieres probar todavía no es compatible con la versión más reciente. Si instalaste Node.js con el instalador oficial o con el gestor de paquetes de tu sistema, solo tienes una versión disponible, y cambiarla implica desinstalar, reinstalar y cruzar los dedos para que nada se rompa.
Un gestor de versiones resuelve este problema de raíz. NVM, siglas de Node Version Manager, te permite tener instaladas varias versiones de Node.js al mismo tiempo y pasar de una a otra con un solo comando. Cada versión vive en su propia carpeta, con su propio npm y sus propios paquetes globales, de modo que trabajar en un proyecto no contamina los demás.
En esta guía aprenderás a instalar NVM en Linux, macOS y Windows, a instalar y cambiar versiones de Node.js, a fijar la versión de cada proyecto con un archivo .nvmrc y a resolver los problemas más habituales. Todos los comandos están actualizados a las versiones vigentes: nvm 0.40.8 para sistemas tipo Unix, NVM for Windows 2.0.1 y Node.js 26, que acaba de convertirse en la versión LTS activa.
Cómo funciona NVM por dentro
Antes de instalar nada conviene entender qué hace NVM, porque así sabrás interpretar cualquier problema que aparezca.
Cuando instalas Node.js de forma tradicional, el ejecutable node se coloca en una ruta del sistema, como /usr/local/bin en Linux y macOS o C:\Program Files\nodejs en Windows. Tu terminal busca los programas en las carpetas de la variable PATH, encuentra ese ejecutable y lo usa.
NVM cambia ese mecanismo. Descarga cada versión de Node.js en una carpeta propia dentro de su directorio de trabajo, por ejemplo ~/.nvm/versions/node/v26.0.0. Cuando ejecutas nvm use 26, NVM modifica el PATH de tu sesión para que la carpeta de esa versión aparezca primero. A partir de ese momento, node, npm y npx apuntan a la versión elegida.
Esta es la estructura que crea NVM en Linux y macOS después de instalar algunas versiones:
~/.nvm/
├── nvm.sh
├── bash_completion
├── alias/
│ └── default
└── versions/
└── node/
├── v22.21.0/
│ ├── bin/
│ └── lib/node_modules/
├── v24.11.0/
│ ├── bin/
│ └── lib/node_modules/
└── v26.0.0/
├── bin/
└── lib/node_modules/
De este diseño se derivan tres consecuencias prácticas. La primera es que NVM no necesita permisos de administrador en Linux y macOS, porque todo vive dentro de tu carpeta personal. La segunda es que los paquetes globales son independientes por versión: si instalas typescript de forma global con Node.js 24, no estará disponible cuando cambies a Node.js 26. La tercera es que el cambio de versión afecta solo a la terminal actual, salvo que definas una versión por defecto.
Un detalle importante: el proyecto original, nvm, es un script de shell pensado para sistemas tipo Unix y no funciona en Windows. En Windows se usa un proyecto independiente llamado NVM for Windows, con comandos muy parecidos pero un funcionamiento interno distinto. Lo verás en su propia sección.
Qué versión de Node.js elegir en 2026
NVM te da libertad para instalar cualquier versión, pero conviene saber cuáles están vigentes. Node.js publica versiones mayores y las clasifica en dos tipos: las versiones Current, que reciben las novedades más recientes, y las versiones LTS (Long Term Support), que reciben soporte prolongado y son las recomendadas para producción.
La situación a finales de octubre de 2026 es la siguiente:
- Node.js 26 entró en fase LTS activa el 28 de octubre de 2026. Es la opción recomendada para proyectos nuevos.
- Node.js 24 está en fase de mantenimiento LTS y recibirá correcciones de seguridad hasta abril de 2028. Es una opción sólida para proyectos existentes.
- Node.js 22 llega al final de su vida útil el 30 de abril de 2027. Si tienes proyectos en esta versión, es buen momento para planificar la migración.
Además, el proyecto anunció un cambio de calendario: a partir de Node.js 27 se publicará una sola versión mayor al año, en abril, que pasará a LTS en octubre. Con este modelo todas las versiones serán LTS, a diferencia del esquema anterior en el que solo lo eran las versiones pares. Con NVM, adaptarte a este calendario será tan sencillo como ejecutar un nvm install cada año.
Preparar el sistema antes de instalar NVM
El error más frecuente al empezar con NVM es instalarlo encima de una instalación de Node.js ya existente. Las dos instalaciones compiten por el PATH y el resultado es confuso: ejecutas nvm use 26, pero node --version sigue mostrando la versión anterior.
Por eso el primer paso es averiguar si ya tienes Node.js instalado y de dónde viene. En Linux y macOS ejecuta:
which node
node --version
/usr/local/bin/node
v20.18.0
Si la ruta es /usr/local/bin/node o /usr/bin/node, se trata de una instalación del sistema. Desinstálala con el mismo método que usaste para instalarla. Por ejemplo, si la instalaste con Homebrew en macOS:
brew uninstall node
Si la instalaste con el gestor de paquetes de una distribución basada en Debian o Ubuntu:
sudo apt remove nodejs
sudo apt autoremove
En Windows, abre la sección de aplicaciones instaladas en la configuración del sistema, desinstala Node.js y comprueba después que la carpeta C:\Program Files\nodejs ya no existe. Si sigue ahí, elimínala manualmente. Revisa también la carpeta %AppData%\npm, donde npm guarda los paquetes globales, y bórrala si no la necesitas.
Antes de desinstalar, apunta los paquetes globales que usas para reinstalarlos después:
npm list -g --depth=0
/usr/local/lib
├── [email protected]
├── [email protected]
└── [email protected]
Verifica que el sistema queda limpio ejecutando de nuevo node --version. El resultado esperado es un error que indica que el comando no existe.
Instalar NVM en Linux y macOS
La instalación en sistemas tipo Unix se hace con un script oficial que clona el repositorio de nvm en ~/.nvm y añade unas líneas de configuración a tu archivo de perfil de la shell. Para instalar nvm en Linux necesitas la versión estable más reciente, que es la 0.40.8.
Necesitas curl o wget. La mayoría de distribuciones y macOS ya incluyen alguno de los dos. Ejecuta uno de estos comandos:
curl -o- https://raw.githubusercontent.com/nvm-sh/nvm/v0.40.8/install.sh | bash
wget -qO- https://raw.githubusercontent.com/nvm-sh/nvm/v0.40.8/install.sh | bash
Observa que la URL incluye el número de versión. Fijar la versión en el comando es una buena práctica: sabes exactamente qué código estás ejecutando y el resultado será idéntico en todas las máquinas de tu equipo. Si quieres revisar el script antes de ejecutarlo, algo recomendable siempre que se canaliza una descarga hacia bash, descárgalo primero y ábrelo:
curl -o install-nvm.sh https://raw.githubusercontent.com/nvm-sh/nvm/v0.40.8/install.sh
less install-nvm.sh
bash install-nvm.sh
Al terminar, el instalador muestra un mensaje parecido a este:
=> Appending nvm source string to /home/ana/.bashrc
=> Appending bash_completion source string to /home/ana/.bashrc
=> Close and reopen your terminal to start using nvm or run the following to use it now:
export NVM_DIR="$HOME/.nvm"
[ -s "$NVM_DIR/nvm.sh" ] && \. "$NVM_DIR/nvm.sh"
[ -s "$NVM_DIR/bash_completion" ] && \. "$NVM_DIR/bash_completion"
El script detecta tu shell y escribe esas líneas en el archivo correspondiente: ~/.bashrc para Bash en Linux, ~/.zshrc para Zsh, que es la shell por defecto en macOS, o ~/.bash_profile en algunos casos. Las líneas hacen tres cosas: definen la variable NVM_DIR con la ruta de instalación, cargan el script principal nvm.sh si existe y activan el autocompletado de comandos.
Para empezar a usar NVM sin cerrar la terminal, recarga tu perfil:
source ~/.bashrc
Si usas Zsh, el comando equivalente es source ~/.zshrc. Después comprueba la instalación:
nvm --version
0.40.8
Un matiz importante: nvm no es un programa independiente, sino una función de shell. Por eso which nvm no devuelve nada aunque NVM funcione perfectamente. Para comprobar que está cargado, usa command -v nvm, que debe devolver la palabra nvm.
Qué hacer si la terminal no reconoce el comando nvm
Si después de instalar ves el mensaje nvm: command not found, casi siempre se debe a que el archivo de perfil no contiene las líneas de carga o a que tu shell lee un archivo distinto del que modificó el instalador.
Primero averigua qué shell estás usando:
echo $SHELL
/bin/zsh
Luego abre el archivo de configuración que corresponde a esa shell y comprueba que contiene el bloque de NVM. Si no está, añádelo al final del archivo:
export NVM_DIR="$HOME/.nvm"
[ -s "$NVM_DIR/nvm.sh" ] && \. "$NVM_DIR/nvm.sh"
[ -s "$NVM_DIR/bash_completion" ] && \. "$NVM_DIR/bash_completion"
En macOS hay un caso particular: si el archivo ~/.zshrc no existía antes de la instalación, el script puede no haberlo creado. Créalo y vuelve a lanzar el instalador:
touch ~/.zshrc
curl -o- https://raw.githubusercontent.com/nvm-sh/nvm/v0.40.8/install.sh | bash
source ~/.zshrc
En macOS también conviene tener instaladas las herramientas de línea de comandos de Xcode, porque NVM puede necesitar compilar Node.js desde el código fuente si no encuentra un binario precompilado para tu combinación de versión y arquitectura:
xcode-select --install
Instalar NVM for Windows
En Windows se utiliza NVM for Windows, un proyecto independiente mantenido por Corey Butler. Su versión estable más reciente es la 2.0.1, publicada en octubre de 2026. La rama 2.x es una reescritura completa respecto a la 1.x e incorpora cambios notables: ya no exige obligatoriamente privilegios de administrador, permite cambiar de versión según la carpeta en la que te encuentres, instala automáticamente versiones que falten y descarga varias versiones en paralelo. Sus instaladores, además, están firmados digitalmente.
Si en otros tutoriales ves que hay que abrir la terminal como administrador para ejecutar nvm use, ten en cuenta que esa restricción era propia de la rama 1.x, que creaba enlaces simbólicos en carpetas del sistema.
Estos son los pasos para instalar NVM en Windows de forma limpia:
- Desinstala cualquier versión previa de Node.js, como se explicó en la sección de preparación.
- Abre la página de lanzamientos del repositorio
coreybutler/nvm-windowsen GitHub. - Localiza la versión marcada como estable, no las marcadas como beta o pre-release.
- Descarga el instalador que corresponda a tu arquitectura. Los archivos siguen el formato
nvm-<versión>-x64-setup.exepara procesadores Intel o AMD de 64 bits ynvm-<versión>-arm64-setup.exepara equipos ARM. - Ejecuta el instalador y acepta las rutas propuestas, salvo que tengas un motivo para cambiarlas.
Cuando termine, abre una nueva ventana de PowerShell o del símbolo del sistema. Es importante que sea una ventana nueva, porque las que ya estaban abiertas no conocen los cambios en el PATH. Comprueba la instalación:
nvm version
2.0.1
Si el comando no se reconoce, cierra todas las terminales y vuelve a abrirlas. Si el problema persiste, revisa en la configuración de variables de entorno de Windows que la ruta de instalación de NVM figura en el PATH de tu usuario.
Instalar versiones de Node.js con NVM
Con NVM listo, ya puedes instalar Node.js. Los comandos de esta sección corresponden a nvm en Linux y macOS. En Windows la sintaxis es muy parecida y verás las diferencias más adelante.
Para instalar la versión LTS más reciente, que es la recomendada en la mayoría de los casos:
nvm install --lts
Installing latest LTS version.
Downloading and installing node v26.0.0...
Downloading https://nodejs.org/dist/v26.0.0/node-v26.0.0-linux-x64.tar.xz...
######################################################################## 100,0%
Computing checksum with sha256sum
Checksums matched!
Now using node v26.0.0 (npm v11.6.2)
Creating default alias: default -> lts/* (-> v26.0.0)
La salida muestra varias cosas interesantes. NVM descarga un binario oficial, verifica su suma de comprobación para asegurarse de que no está corrupto ni manipulado, activa la versión y, como es la primera que instalas, la marca como versión por defecto.
Para instalar la versión más reciente, incluida la rama Current, usa el alias node:
nvm install node
Un error habitual es escribir nvm install latest. En nvm para Linux y macOS ese alias no existe; el correcto es node. En NVM for Windows, en cambio, sí se acepta latest.
Para instalar una versión concreta, indica el número completo o solo la versión mayor. Si indicas solo la mayor, NVM instala la versión más reciente de esa rama:
nvm install 24
nvm install 22.21.0
También puedes instalar una rama LTS por su nombre en clave, con el formato lts/nombre. Esto resulta útil en documentación de proyectos, porque expresa la intención de usar una rama de soporte prolongado sin atarse a un parche concreto.
Para ver las versiones disponibles para descarga, ejecuta:
nvm ls-remote --lts
v22.21.0 (Latest LTS: Jod)
v24.11.0 (Latest LTS: Krypton)
-> v26.0.0 (Latest LTS)
Los números de parche que ves en los ejemplos de esta guía son ilustrativos; los que obtengas tú dependerán del día en que ejecutes los comandos. La salida real también es mucho más larga, porque incluye todas las versiones LTS publicadas. Sin la opción --lts verás el listado completo, que incluye cientos de versiones.
Cambiar entre versiones y definir la versión por defecto
Una vez que tienes varias versiones instaladas, puedes listarlas con:
nvm ls
v22.21.0
v24.11.0
-> v26.0.0
default -> lts/* (-> v26.0.0)
node -> stable (-> v26.0.0) (default)
La flecha indica la versión activa en la terminal actual. Debajo aparecen los alias, que son nombres que apuntan a una versión. Para cambiar de versión:
nvm use 24
node --version
Now using node v24.11.0 (npm v11.6.0)
v24.11.0
Recuerda que este cambio solo afecta a la terminal en la que lo ejecutas. Si abres otra ventana, verás la versión por defecto. Para cambiar esa versión por defecto, usa un alias:
nvm alias default 26
A partir de ese momento, todas las terminales nuevas empezarán con Node.js 26. Si prefieres que la versión por defecto sea siempre la LTS más reciente, sin tener que actualizar el alias cada vez que aparezca una nueva, usa:
nvm alias default lts/*
Otros comandos útiles para el día a día son estos:
nvm current # Muestra la versión activa
nvm which 24 # Muestra la ruta del ejecutable de esa versión
nvm uninstall 22 # Elimina una versión instalada
nvm deactivate # Quita NVM del PATH de la sesión actual
También puedes ejecutar un comando con una versión concreta sin cambiar la versión activa. Es muy práctico para comprobar si tu código funciona en varias versiones:
nvm exec 22 node --version
nvm run 24 app.js
El primer comando ejecuta cualquier programa con el entorno de Node.js 22. El segundo ejecuta directamente un archivo JavaScript con Node.js 24.
Fijar la versión de cada proyecto con nvmrc
Cambiar de versión a mano cada vez que entras en un proyecto es incómodo y propenso a errores. La solución es un archivo .nvmrc en la raíz del proyecto que indique qué versión necesita. Gracias al archivo nvmrc por proyecto, cualquier persona que clone el repositorio sabrá exactamente con qué versión trabajar.
Crea el archivo con la versión deseada:
cd ~/proyectos/api-facturacion
echo "24" > .nvmrc
El contenido puede ser una versión mayor, una versión completa como 24.11.0 o un alias como lts/*. Con el archivo en su sitio, basta con ejecutar los comandos sin indicar versión:
nvm install
nvm use
Found '/home/ana/proyectos/api-facturacion/.nvmrc' with version <24>
Now using node v24.11.0 (npm v11.6.0)
NVM busca el archivo .nvmrc en la carpeta actual y, si no lo encuentra, en las carpetas superiores. Esto permite tener un archivo en la raíz de un monorepo que se aplica a todos los paquetes.
Conviene añadir este archivo al control de versiones. Es una forma de documentación que además se puede ejecutar. Muchas herramientas de integración continua también lo reconocen; por ejemplo, la acción oficial para configurar Node.js en GitHub Actions permite leer la versión desde ese archivo:
- uses: actions/setup-node@v6
with:
node-version-file: ".nvmrc"
Si quieres llevarlo un paso más allá, puedes hacer que tu shell cambie de versión automáticamente al entrar en una carpeta con .nvmrc. En Zsh, añade esta función al final de ~/.zshrc:
autoload -U add-zsh-hook
cargar_nvmrc() {
local archivo_nvmrc="$(nvm_find_nvmrc)"
if [ -n "$archivo_nvmrc" ]; then
local version_deseada="$(nvm version "$(cat "$archivo_nvmrc")")"
if [ "$version_deseada" = "N/A" ]; then
nvm install
elif [ "$version_deseada" != "$(nvm version)" ]; then
nvm use --silent
fi
elif [ -n "$(PWD=$OLDPWD nvm_find_nvmrc)" ] && [ "$(nvm version)" != "$(nvm version default)" ]; then
nvm use default --silent
fi
}
add-zsh-hook chpwd cargar_nvmrc
cargar_nvmrc
La función se ejecuta cada vez que cambias de directorio. Si encuentra un .nvmrc, comprueba si la versión está instalada; si no lo está, la instala, y si lo está pero no es la activa, la activa. Cuando sales de un proyecto con .nvmrc, vuelve a la versión por defecto. El hook chpwd es propio de Zsh; en Bash habría que adaptar la idea redefiniendo el comando cd.
En NVM for Windows 2.x el cambio de versión por carpeta forma parte de las funciones integradas, por lo que no necesitas escribir scripts propios. Consulta la documentación oficial del proyecto para activarlo.
Gestionar npm y los paquetes globales
Cada versión de Node.js trae su propia versión de npm, y cada una tiene su carpeta de paquetes globales. Esto evita conflictos, pero tiene una consecuencia que sorprende a muchos desarrolladores: al instalar una versión nueva, tus herramientas globales desaparecen.
NVM ofrece una solución elegante. Al instalar una versión nueva, puedes pedirle que copie los paquetes globales de otra:
nvm install 26 --reinstall-packages-from=24
Este comando instala Node.js 26 y, a continuación, reinstala en ella todos los paquetes globales que tenías en Node.js 24. Es la forma más cómoda de actualizar de versión sin perder herramientas como typescript, pnpm o la CLI de tu framework favorito.
Si además quieres que ciertos paquetes se instalen automáticamente en cada versión nueva, puedes listarlos en el archivo $NVM_DIR/default-packages, uno por línea:
cat > "$NVM_DIR/default-packages" << 'EOF'
typescript
pnpm
npm-check-updates
EOF
Para actualizar npm a su última versión compatible con la versión de Node.js activa, NVM incluye un comando específico:
nvm install-latest-npm
Este comando es preferible a ejecutar npm install -g npm@latest directamente, porque comprueba la compatibilidad entre npm y la versión de Node.js antes de actualizar.
Por último, una recomendación sobre los gestores de paquetes alternativos. Si tu equipo usa pnpm o Yarn, en lugar de instalarlos de forma global en cada versión puedes declararlos en el campo packageManager de tu package.json. Así cada proyecto define también la versión de su gestor de paquetes.
Diferencias de comandos entre nvm y NVM for Windows
Aunque los dos proyectos comparten nombre e idea, son herramientas distintas y algunos comandos cambian. Esta tabla resume las equivalencias más habituales:
Acción nvm (Linux/macOS) NVM for Windows
------------------------------ ------------------------- -----------------------
Ver versión de la herramienta nvm --version nvm version
Instalar la última LTS nvm install --lts nvm install lts
Instalar la más reciente nvm install node nvm install latest
Instalar una versión nvm install 24 nvm install 24
Usar una versión nvm use 24 nvm use 24
Listar instaladas nvm ls nvm list
Listar disponibles nvm ls-remote nvm list available
Versión activa nvm current nvm current
Desinstalar nvm uninstall 22 nvm uninstall 22
La regla práctica es sencilla: los comandos básicos de instalar, usar y desinstalar son iguales, mientras que los de consulta y los alias especiales varían. Si escribes documentación para un equipo con sistemas mixtos, indica siempre ambas variantes o, mejor todavía, apóyate en el archivo .nvmrc, que funciona como punto de referencia común.
Errores comunes y cómo resolverlos
Aun con una instalación correcta, hay problemas que aparecen con frecuencia. Estos son los más habituales y su solución.
El comando nvm use no cambia la versión. Ejecutas nvm use 26, el mensaje confirma el cambio, pero node --version muestra otra versión. La causa es casi siempre una instalación de Node.js anterior que sigue en el PATH por delante de NVM. Ejecuta which node en Linux y macOS o where node en Windows. Si la ruta no está dentro de la carpeta de NVM, desinstala esa instalación previa.
La versión vuelve a cambiar al abrir otra terminal. No es un error: nvm use solo afecta a la sesión actual. Define la versión por defecto con nvm alias default o usa un archivo .nvmrc con el cambio automático.
Un paquete global deja de funcionar tras cambiar de versión. Como cada versión tiene sus propios paquetes globales, la herramienta no está instalada en la versión activa. Reinstálala o usa la opción --reinstall-packages-from cuando instales versiones nuevas.
Las herramientas gráficas no encuentran Node.js. Algunos editores o aplicaciones de escritorio no cargan tu archivo de perfil de la shell y, por tanto, no ven la configuración de NVM. Arranca el editor desde una terminal con NVM cargado o configura en el editor la ruta absoluta del ejecutable, que puedes obtener con nvm which current.
La terminal tarda en abrirse. Cargar NVM añade unos milisegundos al inicio de cada sesión, que pueden notarse en equipos lentos o con muchas versiones instaladas. Revisa que no estés cargando NVM dos veces en tu perfil, algo frecuente si ejecutaste el instalador varias veces, y elimina las versiones que ya no uses con nvm uninstall.
Aparece un error de permisos al instalar paquetes globales. Con NVM nunca deberías necesitar sudo para npm install -g, porque los paquetes se instalan en tu carpeta personal. Si el error aparece, es señal de que estás usando el npm de una instalación del sistema y no el de NVM. Vuelve a revisar el primer punto de esta lista.
NVM intenta compilar Node.js desde el código fuente. Ocurre cuando no existe un binario oficial para tu combinación de sistema y arquitectura, algo que puede pasar con versiones muy antiguas en procesadores ARM. La compilación tarda mucho y requiere herramientas de desarrollo. Siempre que puedas, usa una versión con binarios oficiales.
Mantener NVM actualizado
NVM también recibe actualizaciones con correcciones y mejoras. La versión 0.40.7, por ejemplo, hizo que las instalaciones concurrentes de una misma versión se ejecuten en serie y que la sustitución de una carpeta de versión durante la extracción sea atómica, lo que evita instalaciones corruptas si el proceso se interrumpe.
Para actualizar nvm en Linux y macOS basta con ejecutar de nuevo el script de instalación con el número de la versión nueva:
curl -o- https://raw.githubusercontent.com/nvm-sh/nvm/v0.40.8/install.sh | bash
source ~/.bashrc
nvm --version
El script detecta la instalación existente y la actualiza sin tocar las versiones de Node.js que ya tienes. Tampoco duplica las líneas del archivo de perfil si ya están presentes.
En Windows, descarga el instalador de la nueva versión estable desde la página de lanzamientos y ejecútalo. Si vienes de la rama 1.x, revisa las notas de la versión antes de actualizar, ya que la 2.x cambió el mecanismo con el que activa las versiones.
En cuanto a Node.js, el flujo recomendado para actualizar un proyecto a la nueva LTS es:
nvm install 26 --reinstall-packages-from=24
nvm use 26
npm test
echo "26" > .nvmrc
Instalas la versión nueva conservando tus herramientas, la activas, ejecutas las pruebas del proyecto y, si todo pasa, actualizas el .nvmrc para que el resto del equipo haga el cambio.
Alternativas a NVM y cuándo considerarlas
NVM es la opción más extendida, pero no la única. Conocer las alternativas te ayudará a decidir si es la herramienta adecuada para tu caso.
fnm (Fast Node Manager) está escrito en Rust y funciona en Linux, macOS y Windows con los mismos comandos. Su principal ventaja es la velocidad: la terminal arranca prácticamente sin retraso y el cambio de versión es instantáneo. Además, lee los archivos .nvmrc, así que migrar desde NVM es sencillo. Es una buena elección si trabajas en varios sistemas operativos y quieres una sintaxis única.
Volta adopta un enfoque distinto. En lugar de cambiar la versión activa, fija las versiones de Node.js y del gestor de paquetes dentro del package.json de cada proyecto y selecciona automáticamente la correcta al ejecutar cualquier comando. Es muy cómodo para equipos que quieren reproducibilidad estricta sin pensar en ello.
mise, sucesor espiritual de asdf, gestiona versiones de muchos lenguajes a la vez: Node.js, Python, Go, Java y más. Si trabajas con varios lenguajes y quieres una única herramienta para todos, merece la pena valorarlo.
Por último, los contenedores Docker ofrecen el aislamiento más completo, porque cada proyecto lleva su propio sistema operativo, versión de Node.js y dependencias. No sustituyen a un gestor de versiones en el día a día, pero son la opción natural para entornos de producción y de integración continua.
Para la mayoría de desarrolladores que trabajan en Linux o macOS, NVM sigue siendo una elección excelente por su madurez, su documentación y su amplia adopción. Si la velocidad de arranque de la terminal te preocupa o trabajas mucho en Windows, fnm es la alternativa más cercana.
Conclusiones
Contar con un gestor de versiones de Node.js es una de esas decisiones que, una vez tomadas, se vuelven imprescindibles. NVM te permite tener varias versiones conviviendo en el mismo equipo, cambiar entre ellas con un comando y aislar los paquetes globales de cada una, lo que elimina por completo los conflictos entre proyectos.
En esta guía has visto cómo preparar el sistema eliminando instalaciones previas, cómo instalar nvm 0.40.8 en Linux y macOS y NVM for Windows 2.0.1 en Windows, y cómo instalar, activar y definir por defecto versiones de Node.js. También has aprendido a fijar la versión de cada proyecto con .nvmrc, a conservar tus herramientas globales al cambiar de versión y a resolver los errores más frecuentes.
El momento es especialmente oportuno: Node.js 26 acaba de convertirse en la versión LTS activa, Node.js 22 se acerca al final de su soporte y el calendario de lanzamientos cambiará a partir de Node.js 27. Con NVM y un archivo .nvmrc en cada repositorio, adaptarte a cada nueva versión será cuestión de minutos, y todo tu equipo trabajará siempre con la misma versión.