DEV Community

Ramananda Panda
Ramananda Panda

Posted on

🚀 I Built QNVS — A Node.js Version Manager That Doesn't Need Admin Rights (Yes, Even on Windows)

#cli #node #showdev #tooling

No sudo. No IT ticket. No drama. Just qnvs and vibes.

Hero image — developer at a clean workstation
Suggested hero image: Unsplash — Christopher Gower (Developer workstation)

The Problem That Made Me Build This

Picture this: Monday morning. You're a developer at a company where IT guards the admin password like it's nuclear launch codes. You need Node.js 22 for a new project, but your machine has Node 18. The options?

  1. Submit an IT ticket. Estimated response: 3-7 business days. Maybe. If Mercury is in retrograde.
  2. Use nvm. Great on macOS/Linux! On Windows? [laughs in Group Policy]
  3. Use nvm-windows. Requires admin privileges to create symlinks. Back to step 1.
  4. Download Node.js manually. Sure, if you enjoy living like it's 2009.

None of these worked for me. So instead of rage-quitting, I rage-coded.

Meet QNVS — Quick Node Version Switcher. A single binary, zero-dependency, cross-platform, no-admin-required Node.js version manager with a gorgeous interactive TUI. Built in Go. Ships in ~10MB. Works everywhere.

Terminal with beautiful UI
Suggested image: Unsplash — Florian Olivo (Terminal/Code)

Wait, What Does "No Admin Required" Actually Mean?

Let me be crystal clear because this is the entire reason QNVS exists:

  • ❌ No sudo
  • ❌ No Administrator PowerShell
  • ❌ No Developer Mode toggle
  • ❌ No Group Policy exceptions
  • ❌ No IT tickets
  • ❌ No "please sir, may I have write access to Program Files"

QNVS lives entirely in user space. On macOS/Linux, it chills in ~/.qnvs. On Windows, it sits in %LOCALAPPDATA%\qnvs. That's it. Your home directory. The one place on the computer that's actually yours.

You download the binary. You run qnvs setup. You install Node.js versions. You switch between them. You feel powerful. All without elevating a single privilege.

The TUI That Made My Terminal Beautiful ✨

Look, I could've just built a boring CLI. But I had access to the Charm ecosystem — bubbletea, bubbles, lipgloss — and honestly, if you're going to build a terminal tool in 2025, you owe it to yourself to make it pretty.

Run qnvs with no arguments and you get this:

 ██████╗ ███╗   ██╗██╗   ██╗███████╗
██╔═══██╗████╗  ██║██║   ██║██╔════╝
██║   ██║██╔██╗ ██║██║   ██║███████╗
██║▄▄ ██║██║╚██╗██║╚██╗ ██╔╝╚════██║
╚██████╔╝██║ ╚████║ ╚████╔╝ ███████║
 ╚══▀▀═╝ ╚═╝  ╚═══╝  ╚═══╝  ╚══════╝
  Quick Node Version Switcher • No admin required

╭──────────────────────────────────────────────╮
│                                              │
│  ▸ 📦  Install Node.js                       │
│        Download and install a new version    │
│                                              │
│    📋  List/Switch                            │
│    🗑️   Uninstall                             │
│    🔧  Setup                                  │
│    🔓  Toggle TLS Skip                        │
│    ❓  Help                                   │
│    👋  Exit                                   │
│                                              │
│   2 installed   Active: v22.22.0             │
╰──────────────────────────────────────────────╯

  ↑↓ navigate │ ⏎ select │ q quit
Enter fullscreen mode Exit fullscreen mode

Arrow keys to navigate. Enter to select. q to quit. That's the entire learning curve.

No flags to memorize. No --help to desperately consult. Just a menu. With emojis. Like civilized people.

Colorful keyboard / aesthetic dev setup
Suggested image: Unsplash — Clay Banks (Colorful keyboard)

The Windows Problem (And How I Solved It)

Here's the dirty secret of Node.js version managers on Windows: they almost all rely on symlinks or junctions.

  • Symlinks need Developer Mode or admin rights
  • Directory junctions (mklink /J) usually work without admin... until your company's Group Policy says "nah"
  • Cue developer tears

QNVS takes a hybrid approach that I'm unreasonably proud of:

Step 1: Try to create a directory junction. This works on most Windows machines without admin rights and gives you fast, transparent version switching.

Step 2: If junctions fail (thanks, Group Policy), QNVS automatically falls back to shim mode — it creates tiny .cmd wrapper scripts in ~/.qnvs/bin/ that redirect to the active Node.js version:

@echo off
"C:\Users\you\AppData\Local\qnvs\versions\v22.22.0\node.exe" %*
Enter fullscreen mode Exit fullscreen mode

That's it. A .cmd file. Group Policy can't block .cmd files because that would break literally everything else on Windows. It's not a hack — it's a feature.

The fallback is completely automatic and transparent. You don't configure anything. You don't even know it happened. QNVS just... works.

The CLI: For When You Know What You Want

The interactive TUI is great for exploring, but sometimes you just want to get in, switch versions, and get out. The CLI has your back:

# Install Node 22 (latest 22.x.x)
qnvs install 22

# Install the latest LTS
qnvs install lts

# Install a specific version
qnvs install 20.10.0

# Switch versions
qnvs use 22

# See what you've got
qnvs list

# What's active?
qnvs current
Enter fullscreen mode Exit fullscreen mode

Version resolution is smart. Type 22 and QNVS fetches the latest 22.x.x from nodejs.org. Type lts and it finds the latest Long Term Support release. Type latest and... you get the latest. Revolutionary stuff.

Command What It Does
qnvs Launch the interactive TUI
qnvs install <version> Download and install a version
qnvs use <version> Switch to an installed version
qnvs list List installed versions
qnvs current Show the active version
qnvs uninstall <version> Remove a version
qnvs setup Initialize QNVS + configure PATH

Corporate VPN? No Problem.

Raise your hand if you've ever seen this error:

x509: certificate signed by unknown authority
Enter fullscreen mode Exit fullscreen mode

If you're behind a corporate VPN like Cato, Zscaler, or Palo Alto, your company is probably doing TLS inspection — which means your HTTPS requests are getting re-signed by a corporate certificate that your tools don't trust.

Most tools: "Figure it out yourself. Here's a 47-step Stack Overflow thread."

QNVS: "Toggle a switch."

CLI:

qnvs install 22 --insecure
Enter fullscreen mode Exit fullscreen mode

Interactive mode: Just select "🔓 Toggle TLS Skip" from the menu before installing.

Is it ideal? No. TLS verification exists for good reasons. But when you're on a locked-down corporate machine and the VPN is doing inspection, this beats "can't install Node.js at all" every single time.

Why Go? (Again)

I keep building things in Go and people keep asking why. So here's the elevator pitch:

  1. Single binary. No runtime. No node_modules. No Python virtual environment. No Java classpath. Just one file. Copy it. Run it. Done.

  2. Cross-compilation is stupid easy. One command gives me binaries for Windows/macOS/Linux across amd64 and arm64. Six platforms, zero hassle:

GOOS=windows GOARCH=amd64 go build -o qnvs-windows-amd64.exe .
GOOS=darwin  GOARCH=arm64  go build -o qnvs-macos-arm64 .
GOOS=linux   GOARCH=amd64  go build -o qnvs-linux-amd64 .
Enter fullscreen mode Exit fullscreen mode

  1. The Charm ecosystem. Bubbletea + Bubbles + Lipgloss = gorgeous terminal UIs with minimal effort. It's like React but for terminals and without the existential crisis of choosing a state management library.

  2. ~10MB binary. The entire tool — TUI, version resolution, download with progress bars, archive extraction, platform detection — fits in the space of about 3 JPEG photos from your phone.

Gopher / Go mascot
Suggested image: Gopherize.me for a custom gopher, or Unsplash — Go-related imagery

How It Actually Works Under The Hood

For the curious (and the people who read source code for fun — I see you), here's the architecture:

The whole project is two files:

  • main.go — The core: version resolution, downloading, extraction, symlink/junction/shim management, CLI handling
  • interactive.go — The entire TUI, built on Bubbletea's Elm architecture

Version resolution hits https://nodejs.org/dist/index.json, parses the JSON, and fuzzy-matches your input. 22 → latest v22.x.x. lts → latest release where the lts field is a string (Node.js marks LTS versions with a codename like "Jod").

Downloading uses a custom progress bar (Charm's progress component) that shows real-time MB progress. It does a HEAD request first to get the content length, then streams the download with a 32KB buffer.

Extraction handles both .tar.gz (macOS/Linux) and .zip (Windows) natively — no tar or unzip binary needed. Pure Go. It even handles symlinks in tar archives (npm/npx are symlinks in the Node.js distribution).

Switching is where it gets spicy:

  • Unix: Swap a symlink. ~/.qnvs/current → ~/.qnvs/versions/v22.22.0. Done.
  • Windows (happy path): Create a directory junction. Same concept, Windows flavor.
  • Windows (corporate dystopia): Generate .cmd shims. Same result, different mechanism.

Installation: Pick Your Poison

macOS / Linux:

curl -L https://github.com/qnvs/qnvs/releases/latest/download/qnvs-linux-amd64 -o qnvs
chmod +x qnvs
./qnvs setup
Enter fullscreen mode Exit fullscreen mode

Windows (PowerShell):

Invoke-WebRequest -Uri "https://github.com/qnvs/qnvs/releases/latest/download/qnvs-windows-amd64.exe" -OutFile "qnvs.exe"
.\qnvs.exe setup
Enter fullscreen mode Exit fullscreen mode

Build from source:

git clone https://github.com/qnvs/qnvs.git
cd qnvs
go build -o qnvs .
./qnvs setup
Enter fullscreen mode Exit fullscreen mode

setup creates the directory structure, copies the binary to ~/.qnvs/bin/, and even tries to auto-append the PATH export to your .bashrc or .zshrc. On Windows, it tells you exactly what to add to your PATH. No guessing.

Light bulb / idea / inspiration
Suggested image: Unsplash — Riccardo Annandale (Light bulb)

QNVS vs. The Competition

Let's be honest — there are other version managers out there. Here's where QNVS stands:

Feature QNVS nvm nvm-windows fnm Volta
No admin required ✅ ✅ ❌ ⚠️ ⚠️
Windows support ✅ ❌ ✅ ✅ ✅
Works behind corporate VPN ✅ (built-in) ❌ ❌ ❌ ❌
Interactive TUI ✅ ❌ ❌ ❌ ❌
Single binary ✅ ❌ ✅ ✅ ✅
Corporate Windows (no junctions) ✅ (auto shim) N/A ❌ ❌ ❌
Zero dependencies ✅ ❌ (bash) ✅ ✅ ✅

The corporate Windows row is the killer feature. If you've ever been stuck on a locked-down Windows machine where mklink is blocked and Developer Mode is disabled, you know the pain. QNVS is the first version manager I know of that handles this gracefully with its automatic shim fallback.

Who Is This For?

  • 🏢 Corporate developers trapped behind Group Policy and VPN inspection
  • 💻 Windows users who are tired of "requires admin" being the answer to everything
  • 🎨 TUI enthusiasts who believe CLI tools should be beautiful
  • 🏃 Developers who hate bloat — one binary, no runtime, no install scripts
  • 🔄 Anyone juggling multiple Node.js projects with different version requirements
  • 🆕 Beginners who find nvm confusing — just run qnvs and use the arrow keys

If you've ever Googled "how to install Node.js without admin rights" at 11 PM on a work laptop... I built this for you.

Celebration / confetti
Suggested image: Unsplash — Jason Leung (Confetti)

What's Next?

QNVS is at v1.1.3 and I'm actively working on it. Things rattling around in my brain:

  • 📌 Auto-detect .nvmrc / .node-version — walk into a project directory and QNVS switches automatically
  • 🔄 Self-update — qnvs update to grab the latest QNVS binary
  • 📦 Package manager support — install and manage pnpm/yarn alongside Node
  • 🪟 Windows code signing — so you stop getting the "Unknown Publisher" warning
  • 🌐 Mirror support — for environments that can't reach nodejs.org directly
  • 📊 Disk usage display — see how much space each version is eating

Give It a Spin ⭐

QNVS is open-source (MIT licensed) and lives at github.com/qnvs/qnvs.

Three steps to happiness:

  1. Download the binary for your platform from Releases
  2. Run qnvs setup
  3. Run qnvs and bask in the TUI glow

Star the repo if it saved you from filing an IT ticket. Open an issue if something's broken. Submit a PR if you want to make it better. Or just enjoy switching Node versions without asking anyone's permission for once in your corporate life.

Built with 🐹 Go, the ✨ Charm ecosystem, and a deep resentment for "Please contact your system administrator."

Top comments (0)