Node.js 26 Becomes Active LTS on October 28, 2026

Node.js 26 becomes an Active LTS release on October 28, 2026, according to the official Node.js release schedule — the moment the runtime that shipped as the “Current” release on May 5, 2026 is considered stable enough for production use with a guaranteed support window. The switch lands within days of Node.js 24 leaving Active LTS status on October 20, 2026, which means two major versions are changing support tiers almost simultaneously this month.

If your team has been waiting for an official green light to move off Node.js 24 or skip straight to the newest runtime, this is effectively it. Here is what the Active LTS label actually changes, what shipped in Node.js 26, and how to think about the upgrade.

What “Active LTS” Means, and Why It Matters

Every Node.js major version moves through the same lifecycle, laid out on the official Node.js release schedule: a six-month “Current” phase for library authors to add support, followed by “Active LTS,” then “Maintenance LTS,” then end-of-life. The project’s own release documentation is blunt about what that means in practice: “Production applications should only use Active LTS or Maintenance LTS releases.”

During the Current phase, a version is still absorbing breaking changes and isn’t positioned as a production default — it exists so the ecosystem (frameworks, native addons, cloud runtimes) can catch up before the long-term support clock starts. Active LTS is the opposite: it’s a promise of roughly 30 months of total LTS support, covering critical bug fixes, security patches, and npm compatibility, without this disruptive semver-major churn appearing mid-stream. For any team deciding which runtime to standardize on in a Dockerfile, a CI matrix, or a managed platform like AWS Lambda, Active LTS is the status that typically triggers the “safe to adopt broadly” decision.

That’s why the October 28, 2026 date is more than a changelog footnote. It’s the date Node.js 26 formally becomes the version the project itself recommends for new production deployments, alongside the still-supported Node.js 24.

The Node.js 26 LTS Transition: October 28, 2026

Node.js 26.0.0 shipped as the Current release on May 5, 2026, kicking off its six-month evaluation window. Per the schedule maintained in the nodejs/Release repository on GitHub, that window closes on October 28, 2026, when v26 moves to Active LTS. From that date, Node.js 26 is expected to receive Active LTS support until October 20, 2027, when it transitions to Maintenance LTS, continuing with reduced-scope fixes until its end-of-life on April 30, 2029.

The release schedule page itself carries a standard caveat worth repeating here rather than glossing over: “Dates are subject to change.” Treat October 28, 2026 as the officially scheduled transition date, not an immovable guarantee — but also not a rumor. It’s the date published on Node.js’s own infrastructure, not a third-party estimate.

Node.js 24’s Active LTS Era Is Ending Too

The timing isn’t a coincidence so much as a structural overlap. Node.js 24 entered Active LTS on October 28, 2025, and according to the same release schedule, its Active LTS phase ends on October 20, 2026 — just eight days before Node.js 26 takes over the “newest Active LTS” slot. Node.js 24 doesn’t disappear: it moves into Maintenance LTS, where it keeps receiving critical fixes until its scheduled end-of-life on April 30, 2028. But it stops being the version the project is actively steering the ecosystem toward.

Practically, this means that for a short window in late October 2026, Node.js has two LTS lines in active or near-active status at once — v24 sliding into maintenance mode and v26 taking over as the lead Active LTS release — with Node.js 22 further back in its own Maintenance LTS phase. Teams running v24 in production aren’t forced to move immediately; Maintenance LTS is still a supported, patched tier. But it’s the signal that new projects and major version bumps should now default to targeting v26.

What’s New in Node.js 26

The official Node.js 26.0.0 release notes on nodejs.org detail the changes that shipped back in May and that Active LTS now locks in as the supported baseline. The most notable additions and removals:

• Temporal API enabled by default. The release notes describe Temporal as “a modern date/time API for JavaScript that provides a more robust and feature-rich alternative to the legacy Date object,” and it now ships on by default rather than behind a flag. For any codebase doing serious date/timezone handling, this is the headline change in v26.
• V8 engine update. Node.js 26 bundles V8 14.6.202.33, aligned with Chromium 146, bringing newer JavaScript language features such as Map.prototype.getOrInsert() / getOrInsertComputed() (and their WeakMap equivalents) for upsert-style operations, plus Iterator.concat() for sequencing iterators.
• Undici 8.0.2. Node’s bundled HTTP client implementation gets a major version bump, which is worth checking against any code relying on Undici internals or fetch behavior.
• Breaking changes (semver-major). http.Server.prototype.writeHeader() is fully removed in favor of writeHead(); the legacy internal stream modules (_stream_wrap, _stream_readable, _stream_writable, _stream_duplex, _stream_transform, _stream_passthrough) are fully removed; the --experimental-transform-types flag was removed; and module.register() is now runtime-deprecated.
• Build and platform requirements. Building Node.js 26 from source now requires GCC 13.2 or later, Python 3.9 support has been dropped, and platform support for Power8 (p8) and z13 hardware was removed.
• Native addon ABI. NODE_MODULE_VERSION moved to 147, meaning native addons compiled for earlier Node majors will need rebuilding.
• Dependency bumps. libuv updated to 1.52.1 and ICU to 78.3, plus a new KeyObject raw key format option in the crypto module and an enabled Percentile extension in the built-in SQLite module.

None of this is radical compared to a typical Node.js major release, but the deprecation removals (particularly the legacy stream internals and writeHeader()) are the kind of change that can break older middleware or framework code that hasn’t been updated in a few years — which is exactly why the Current-to-Active-LTS runway exists.

The LTS Schedule at a Glance

Dates for Node.js 24 and 26 come directly from the schedule published in the nodejs/Release repository and nodejs.org’s own previous-releases page; the Node.js 27 row reflects the cadence change described in the next section rather than a fixed, dated schedule entry, since the project has not yet published exact v27 phase dates.

Why the Release Cadence Is Changing Starting With Node.js 27

Alongside the v26 transition, Node.js’s own documentation flags a bigger structural shift coming after it. The nodejs.org release-schedule page states it directly: “Starting with Node.js 27, the release cycle will be annual and every major version will move to LTS status after its six-month Current phase (and six additional months of Alpha phase).” That’s a change from the current pattern, where a new major version ships roughly every six months and only the even-numbered ones graduate to Active LTS while odd-numbered releases are retired after their Current phase.

In other words: Node.js 27 (and every major after it) is expected to get a longer runway before hitting Active LTS — a six-month Current phase plus six months of Alpha — rather than the current twice-a-year major-version churn. Node.js’s own release notes don’t spell out the full rationale, but the practical effect for downstream teams is fewer, more deliberate major version boundaries to track once the new cadence takes hold.

Should You Upgrade to Node.js 26 Now?

For most production workloads, the Active LTS label on October 28, 2026 is the point where the calculus shifts from “wait and see” to “plan the migration.” A few scenarios to weigh:

• Already on Node.js 24: No urgency. Node.js 24 moves into Maintenance LTS, not end-of-life, and will keep getting critical and security fixes through April 2028. Active LTS v26 is the better long-term target, but v24 Maintenance is still a legitimate place to run production code while you test v26 compatibility.
• Starting a new project today: Target Node.js 26. It’s about to carry the project’s full Active LTS backing, and a new codebase has no legacy baggage to clash with the removed APIs.
• Running Node.js 22 or older: Node.js 22’s own LTS clock is further along; check its status on the official schedule before deciding whether to leapfrog straight to v26 or land on v24 Maintenance first.
• Heavy on native addons or older middleware: Budget real testing time. The NODE_MODULE_VERSION bump to 147 means native modules need rebuilding, and anything still calling the now-fully-removed legacy stream internals or http.Server.prototype.writeHeader() will break outright, not just warn.

None of this requires exotic tooling — the same package-manager workflows teams already use for dependency upgrades apply here, whether that’s npm itself or an alternative like pnpm’s faster installs. The bigger lift is usually auditing CI images, base Docker images, and any serverless runtime pins for the version string.

How to Upgrade Safely

A reasonable rollout sequence for most teams:

1. Pull the current LTS/Current builds from the official Node.js downloads page and run your test suite against Node.js 26 in a branch or staging environment before Active LTS day.
2. Grep the codebase for the specific removed APIs called out in the release notes — writeHeader(), the internal _stream_* modules, and --experimental-transform-types usage — since those fail hard rather than degrade gracefully.
3. Rebuild and re-test any native addons against the new NODE_MODULE_VERSION (147).
4. Update CI matrices and container base images (node:26 tags) once internal testing passes, and update engines fields in package.json to reflect the new minimum.
5. Keep Node.js 24 in the rotation as a rollback target for a release cycle or two — it remains patched under Maintenance LTS.

Teams that have already modernized their JavaScript toolchain around newer runtime targets — similarly to how projects evaluate systems-level alternatives like Rust or ship performance-sensitive code through WebAssembly — will generally find the v26 jump straightforward, since most of the breaking changes target long-deprecated internals rather than mainstream application code.

The Governance Context

Node.js’s release process is coordinated by the project under the OpenJS Foundation, which also stewards related JavaScript runtime and tooling projects. The LTS schedule itself is a community-maintained commitment rather than a single vendor’s roadmap, which is part of why the dates are published openly on GitHub and nodejs.org rather than announced piecemeal. For background on how Node.js’s event-driven, V8-based architecture fits into the broader JavaScript ecosystem, Wikipedia’s Node.js entry has a useful technical overview, and npm’s own documentation covers how package resolution and the engines field interact with specific Node versions in the official npm docs.

What’s Next

The immediate milestone is October 28, 2026, when Node.js 26 becomes the project’s lead Active LTS release and Node.js 24 formally settles into Maintenance LTS. Beyond that, the bigger story is the cadence change slated for Node.js 27: a move to one major release a year, with a longer six-month Current plus six-month Alpha runway before LTS status, replacing the twice-yearly major version rhythm Node.js developers have worked around for years. Expect nodejs.org to publish firmer v27 phase dates as that release approaches — Pandromeda will update this piece, and publish a follow-up, once the project locks those dates in.

Written byFelix Moreau

Felix Moreau writes Pandromeda's software coverage and how-to guides. He covers Windows, macOS and Linux updates, the apps people rely on, emulators and developer tools, and turns official documentation into clear, numbered steps that work on the current version.

More from Felix MoreauAll Software & Guides coverage