# Node.js Moves to One Release a Year, With LTS for Every Major

Page: https://hirantha.me/blog/nodejs-moves-to-one-release-a-year-with-lts-for-every-major
Published: 2026-09-30
Written by: hirantha.me Newsroom (AI-generated). An AI model wrote this from the sources listed below; how it is made: https://hirantha.me/about/newsroom
Topics: node.js, lts, release schedule, temporal api, javascript

> From Node.js 27, one major ships each April, every version gets 30 months of LTS, and a new Alpha channel starts in October 2026.

Node.js is changing how it ships. From version 27, there will be one major release a year, every release will get long-term support, and a new Alpha channel arrives for early testing. Version 26 is the last release under the old model.

## What changes with Node.js 27

The project's announcement lays out a yearly cycle in three phases:

| Phase | Length | Purpose |
|---|---|---|
| Alpha | 6 months (October to March) | Early testing, breaking changes allowed |
| Current | 6 months (April to October) | Stabilisation |
| LTS (long-term support) | 30 months | Security and critical bug fixes |

That adds up to 36 months of support from the first Current release. Node.js 27's timeline runs from Alpha in October 2026, release in April 2027, LTS in October 2027 and end of life in April 2030.

Two rules disappear. There is no longer a spring and autumn pair of majors, and the old convention that odd-numbered versions never reach LTS ends. Every major version is now a candidate for production use once it reaches LTS.

The Alpha channel ships as semver prereleases such as `27.0.0-alpha.1`. They are signed, tagged and run through CITGM (Canary in the Goldmine), the project's test suite that builds popular npm packages against new Node builds. The audience is library authors and continuous integration pipelines, not production. The announcement says the 30-month LTS duration, the security process and the V8 adoption cycle stay as they are.

## Where Node.js 26 fits

Node.js 26.0.0 was released on 5 May 2026 and is the current release line. It moves to LTS in October 2026, and per the announcement its end of life is April 2029.

The headline feature is the Temporal API, now enabled without a flag. Temporal replaces the awkward `Date` object with distinct types such as `Temporal.PlainDate` and `Temporal.ZonedDateTime`, which avoids mixed-up time zones and month-end arithmetic surprises. A short example:

```js
const start = Temporal.PlainDate.from('2026-01-31');
console.log(start.add({ months: 1 }).toString());
// 2026-02-28
```

The release also bundles V8 14.6 and Undici 8, the HTTP client behind Node's built-in `fetch`, per a write-up by Lilting. It removes some legacy pieces, including `http.Server.prototype.writeHeader()` and the internal `_stream_*` modules. Old dependencies that still touch them will break.

One caution from the same write-up: Temporal works in Node, but browser coverage is only around 69 percent and Safari is missing, so front-end code shared with a server still needs a polyfill.

## Why the project is doing this

The old rhythm produced two majors a year, only one of which received long-term support. Ecosystem maintainers had to test against releases that most users would never run in production. Moving breaking changes into an Alpha window and promoting a single release to LTS concentrates that effort. The announced structure points that way, though the project's post as summarised here does not spell the reasoning out.

## The upgrade calendar in short

For the next year the sequence is simple. Node.js 26 reaches LTS in October 2026. Node.js 27 Alpha builds start appearing the same month, and the stable 27.0.0 follows in April 2027. Because 27 then waits until October 2027 for LTS, teams that only run LTS releases get 26 first and 27 eighteen months after the Alpha begins. Nothing forces an upgrade in between, but library maintainers who want to catch breakage early have a defined place to do it.

## Support status of older lines

The project's release page says production applications should run only Active LTS or Maintenance LTS releases. It lists Node.js 20 as end of life since 24 March 2026, so anyone still on it has no security fixes. Node.js 22 and 24 are both in LTS status on that page, although the end-of-life dates it prints for them look inconsistent, so check the schedule directly before planning around them.

## What this means in practice

- **Production apps:** stay on an LTS line. Node.js 24 is the sensible choice until 26 reaches LTS in October, and then decide.
- **Libraries:** add Node.js 26 to your test matrix now, and plan to add 27 Alpha builds once they appear in October.
- **Teams that pin versions:** update automation that assumes even means LTS. Under the new model that assumption fails for Node.js 27 onward.
- **Date handling:** try Temporal on server-side code where you control the runtime, and keep a fallback for anything that also ships to browsers.

The practical effect is a slower, more predictable upgrade calendar: one decision a year instead of two, with a clear early warning for breaking changes.

## Questions

**When does Node.js 26 become LTS?**
October 2026, per the Node.js project. Its end of life is listed as April 2029.

**Will odd-numbered Node.js versions get LTS?**
Yes. From Node.js 27 every major version moves to LTS, ending the odd-versions-never rule.

**What is the Node.js Alpha channel?**
A prerelease stream such as 27.0.0-alpha.1, aimed at library authors and CI pipelines, where breaking changes are allowed. It is not for production.

**Which Node.js version should production apps use now?**
An LTS line. Lilting suggests staying on 24 LTS and testing 26 in CI until its October LTS promotion.

## Sources

- [Evolving the Node.js release schedule](https://nodejs.org/en/blog/announcements/evolving-the-nodejs-release-schedule), Node.js
- [Node.js previous releases](https://nodejs.org/en/about/previous-releases), Node.js
- [Node.js 26 ships unflagged Temporal and Undici 8, LTS migration starts October 2026](https://lilting.ch/en/articles/nodejs-26-current-temporal-undici), Lilting