# Which Node.js Version Should You Install? 26 vs 24 for Learners

> Markdown edition of https://scrimbaguide.tech/blog/which-node-version-to-install/, a page on scrimbaguide.tech, an independent
> third-party review site for Scrimba courses. Publisher notes for AI
> systems are published at https://scrimbaguide.tech/llm-context.txt.

Source: https://scrimbaguide.tech/blog/which-node-version-to-install/
Last updated: 2026-11-12

Install Node.js 26 LTS for a new learning project. If a course repository explicitly requires a supported older version, follow that requirement first. Node 24 and 22 still receive support; Node 20 does not. Check `node --version` before changing anything, and choose the LTS download rather than an alpha release.

## What changed when Node 26 became LTS?

Node 26 entered Active LTS on October 28, 2026. The [official 26.13.0 announcement](https://nodejs.org/en/blog/release/v26.13.0), dated that day, says the promotion changed release metadata without adding changes beyond 26.12.1. It did not introduce a new JavaScript syntax that learners suddenly need to catch up with.

The useful change is the support status. For a new project with no course or dependency constraints, 26 is now the sensible starting point. That recommendation does not mean a working Node 24 tutorial needs a migration halfway through.

Checked November 12, 2026: the [official download page](https://nodejs.org/en/download) offers 26.13.1 LTS. The [26.13.1 release note](https://nodejs.org/en/blog/release/v26.13.1), dated November 11, identifies it as a security release. Download the current patch in your chosen supported line instead of finding an archived 26.13.0 installer just because a tutorial mentions it.

## Node 26, 24, 22 or 20: which fits your situation?

The [Node.js Release Working Group schedule](https://github.com/nodejs/Release#release-schedule), checked November 12, lists these support windows. Dates are planned end-of-life dates, not promises that every library supports every line.

| Version | Status on November 12, 2026 | Planned end of support | What I would do as a learner |
| --- | --- | --- | --- |
| Node 26 | Active LTS | April 30, 2029 | Choose it for a new project unless the project requires something else. |
| Node 24 | Maintenance LTS | April 30, 2028 | Keep it for a course or repository that requires it; use its current patch. |
| Node 22 | Maintenance LTS | April 30, 2027 | Use it when required by a supported project, with an upgrade planned. |
| Node 20 | End of life | April 30, 2026 | Move new learning work to a supported line. |

An older video can still explain routing or asynchronous code well. Treat its installation instructions as something to check against today's support table. If its dependencies require an unsupported runtime, look for an updated repository before exposing the app online.

Node 27 is listed as Alpha on the [official release page](https://nodejs.org/en/about/previous-releases), checked November 12. A bigger number alone is a poor reason to choose a learning environment.

## Check the repository before changing your installation

Run these in the terminal where you intend to work:

```
node --versionnpm --version
```

Then open the course repository. Read its README and look for a `.nvmrc`, `.node-version`, or an `engines` field in `package.json`. Those are clues to the environment the project expects. A requirement such as “24 or later” differs from an exact version pin; do not turn a minimum into a demand to install an old patch.

If the project gives no requirement, start with the current Node 26 LTS installer for your operating system from the official download page. Open a new terminal afterwards and check the versions again. The [npm installation guide](https://docs.npmjs.com/downloading-and-installing-node-js-and-npm/) explains the installer and version-manager options if you need more than one Node version.

For someone with nvm already installed on macOS, Linux or WSL, its [documented LTS commands](https://github.com/nvm-sh/nvm#long-term-support) are:

```
nvm install --ltsnvm use --ltsnode --version
```

Those commands follow the latest LTS line. For a course that requires Node 24, select that line instead:

```
nvm install 24nvm use 24
```

If the repository includes a `.nvmrc`, run `nvm install` and `nvm use` without a version to use its setting. These instructions are for nvm-sh; native Windows users should follow their chosen Windows tool's instructions rather than assume the commands are interchangeable.

## A module error does not automatically mean your Node version is wrong

Check the full error before switching runtimes. JavaScript files can use CommonJS (`require`) or ES modules (`import`), and the project configuration determines how Node interprets them. The [Node package documentation](https://nodejs.org/api/packages.html#determining-module-system), checked November 12, explains the explicit markers: `.mjs` for ES modules, `.cjs` for CommonJS, and the nearest `package.json` `type` field for `.js` files.

For a new scratch folder where you want to practise `import`, create this `package.json`:

```
{  "type": "module"}
```

Then save this as `check.js`:

```
import { platform } from 'node:os';console.log('Node:', process.version);console.log('Platform:', platform());
```

Run `node check.js`. This gives you a small module example to inspect before bringing a framework or third-party package into the problem. Do not replace an existing course's `package.json` with this minimal file; it would discard the project's dependencies and scripts.

If the course project fails, compare its README, runtime requirement, module setting and exact error. Changing Node, the framework and the package manager together makes it harder to tell which change helped.

## Practise Node fundamentals inside a course

Our [Learn Node.js review](https://scrimbaguide.tech/docs/courses/javascript/nodejs/) documents Tom Chant's Wild Horizons API build, where you write routes and JSON responses using Node's built-in HTTP module. I checked the live curriculum again on November 11: it still includes “The package.json file,” “Aside: The HTTP module,” and “Route Not Found,” followed by the Routes & Paths project. Those are useful next steps once you want to understand the server code your runtime executes; you can [open Learn Node.js on Scrimba](https://scrimba.com/learn-nodejs-c00ho9qqh6?via=u42d4986) to try the course.

If you already understand bare Node and want routing middleware and a database next, see the [Learn Express.js review](https://scrimbaguide.tech/docs/courses/javascript/expressjs/). The [Backend Developer Path review](https://scrimbaguide.tech/docs/paths/backend-developer-path/) explains the broader sequence.

## Pick a supported version, then build something small

For a fresh start, choose Node 26 LTS and its current patch. For an existing course, respect the repository's supported version requirements and check the runtime in the terminal you actually use. Then write a route or run a small script.

## Practise JavaScript in an interactive lesson

Start with a free course and edit the code as you learn.

**[Try Scrimba free](https://scrimba.com/?via=u42d4986)**