Top 10 Features of Node.js 23: What’s New and Improved

Node.js 23, released on October 16, 2024, brings various improvements for developers and businesses, making building modern applications easier and more efficient. One of the most notable updates is the default support for require (esm). It simplifies working with ECMAScript modules and streamlines development workflows.

This release also enhances testing tools, giving developers better ways to debug and optimize their code. Also, Node.js 23 drops support for 32-bit Windows, aligning with modern platform trends to improve performance and compatibility. These updates are especially beneficial for those building real-time applications with Node.js, ensuring faster execution and a smoother development experience.

What’s New in Node.js 23?

Keeping up with Node.js 23’s latest features helps you build applications more effectively. Here’s a look at the key updates and how they can benefit you.

1. Native ES Module Support with require(esm)

What is it?
One of the major new features in Node.js 23 is the default support for require(esm) to load ES modules. This feature, previously available in Node.js versions 20.x and 22.x under the –experimental-require-module flag, is now active by default. It simplifies the process for developers to work with ES modules by allowing them to use require() to load them without the need for extra flags or configurations.

Coding example:

// myModule.mjs

export const greet = () => {

  console.log(“Hello from the ES module!”);

};

// main.js

require(“./myModule.mjs”).greet();

How will it help developers?

• No more flags: Developers no longer need to use –experimental-require-module to load ES modules.
• Seamless integration: It allows loading ES modules using require() without errors like ERR_REQUIRE_ESM.
• Improved compatibility: Enables better compatibility between CommonJS and ES modules in Node.js.
• Simplified migration: Makes it easier to migrate from CommonJS to ES modules or combine both in a project.
• Fewer errors: If the module or its dependencies use top-level await, Node.js will throw an ERR_REQUIRE_ASYNC_MODULE, making error handling more consistent.

2. Removal of 32-bit Windows Support

What is it?
As part of Node.js updates in version 23, Node.js has officially removed support for 32-bit Windows systems. This change is part of a move towards more modern, 64-bit systems. From now on, Node.js 23 will only provide builds for 64-bit Windows to encourage developers to use newer, more compatible systems.

How will it benefit businesses?

• Increased efficiency: Businesses will see faster, more reliable Node.js applications on 64-bit systems.
• Fewer compatibility issues: Businesses will not have to worry about supporting older hardware, making their systems more future-proof.
• Cost savings: As 32-bit hardware becomes less common, businesses can save money by focusing on more modern, cost-effective solutions.

How will it help developers?

• Focus on modern systems: Developers can now focus on optimizing for 64-bit Windows systems, which are more commonly used.
• Improved performance: 64-bit systems offer better memory management and faster performance for Node.js applications.
• Simplified support: With fewer system configurations to support, Node.js can improve stability and performance on 64-bit platforms.
• Easier maintenance: Dropping support for 32-bit systems reduces the complexity of dealing with outdated hardware.

3. Stabilization of the node –run Command

What is it?
In Node.js 23, the node –run command, which lets Node.js developers run JavaScript directly from the command line, is now stable. This feature was previously experimental but is now fully supported, allowing developers to quickly execute small scripts or commands without creating a separate file.

Coding example:

node –run “console.log(‘Hello from the node –run command!’)”

How will it help developers?

• Quick execution: Developers can run short pieces of code directly from the command line, saving time.
• Easier testing: It’s a simple way to test small code snippets without creating extra files.
• Boosted productivity: By stabilizing this command, Node.js makes it easier for developers to run and test code quickly and efficiently.

4. Enhancements to the Test Runner

What are these?
Node.js 23 introduces several important enhancements to the test runner to make it more powerful and flexible. These updates help improve the testing process for Node.js development. The test runner is now more feature-rich, making it easier to integrate testing into development workflows.

What are the key features?

• Glob pattern support: The test runner now supports glob patterns for coverage files, to make it easier to include or exclude specific files when running tests.
• Improved reporting: Better error reporting and more informative test results help developers understand test failures more clearly.
• Custom arguments: Developers can now pass custom arguments to the test runner, allowing more control over how tests are executed.

How will it help developers?

• Simplified testing: With glob pattern support, Node.js developers can easily manage which files to include in test coverage, streamlining the process.
• Clearer results: The improved error reporting helps developers quickly identify and fix issues, making debugging more efficient.
• Greater flexibility: Custom arguments give developers more control over their testing setup, allowing for more tailored and specific test runs
• Faster feedback: These enhancements help Node.js development teams get quicker feedback on their code, improving overall development speed and quality.

5. Support for New and Updated Dependencies

• What are new and updated dependencies?
  In Node.js 23, several key dependencies, including the V8 engine and other core libraries, have been updated. These updates ensure that Node.js stays aligned with the latest improvements in JavaScript. Node.js now supports the most recent versions of these dependencies to enhance its compatibility with the latest technologies and frameworks.
• Coding Example:

// Using async iteration with updated Node.js features

async function fetchData() {

  const data = [

    { id: 1, name: “Item 1” },

    { id: 2, name: “Item 2” },

    { id: 3, name: “Item 3” },

  ];

  // Using async iteration to loop through data

  for await (const item of data) {

    console.log(`Fetching ${item.name}`);

  }

}

fetchData();

In this example, Node.js 23’s updated dependencies support async iterators. It enables developers to use modern asynchronous patterns directly in their applications.

How will it help developers?

• Better performance: Developers will notice faster application execution and more efficient memory usage, resulting in a smoother user experience.
• Access to modern features: By supporting the latest JavaScript features, developers can use newer syntax and language capabilities in their projects.
• Better security: Regular security updates allow Node.js developers to build safer applications and avoid vulnerabilities associated with outdated libraries.
• Broader compatibility: These updates ensure better compatibility with the newest libraries, frameworks, and tools. This makes it easier for developers to integrate third-party technologies into their Node.js applications.

6. Deprecations and Breaking Changes

What does this mean?

Several features in Node.js 23 have been deprecated, meaning they are still functional but no longer recommended. These features are often planned for removal in future versions, so developers need to start migrating to alternatives.

Key deprecated features in Node.js 23

1. fs.existsSync():
   The fs.existsSync() method has been deprecated in favor of fs.promises.access() for checking file existence asynchronously. This change encourages the use of modern asynchronous APIs to handle file system operations more efficiently.

Old usage (deprecated):

const fs = require(‘fs’);

if (fs.existsSync(‘example.txt’)) {

  console.log(‘File exists!’);

}

Recommended usage:

const fs = require(‘fs’).promises;

fs.access(‘example.txt’)

  .then(() => console.log(‘File exists!’))

  .catch(() => console.log(‘File does not exist!’));

1. Buffer() Constructor:

   The Buffer() constructor is deprecated due to security and usability issues. Instead, Node.js developers should use Buffer.alloc() and Buffer.from() to create buffers more safely and predictably.

Old usage (deprecated):

const buf = new Buffer(10);

Recommended usage:

const buf = Buffer.alloc(10);  // Safer and recommended

• crypto.createCipher() and crypto.createDecipher():
  These methods for creating cipher and decipher objects have been deprecated. Developers are encouraged to use crypto.createCipheriv() and crypto.createDecipheriv() for better security and control over the encryption process.

Old usage (deprecated):

const crypto = require(‘crypto’);

const cipher = crypto.createCipher(‘aes192’, ‘a password’);

Recommended usage:

const crypto = require(‘crypto’);

const cipher = crypto.createCipheriv(‘aes-192-cbc’, Buffer.from(‘a password’), Buffer.alloc(16));

How will it help developers?

• Improved code security: By moving away from deprecated features, developers reduce the risk of introducing security vulnerabilities into their applications.
• Future-proofing applications: Following the latest Node.js best practices ensures that code remains compatible with future Node.js releases, minimizing the need for major rewrites later.
• Easier maintenance: Using modern, stable APIs makes the codebase easier to maintain and reduces the technical debt accumulating when outdated features are used.

7. Enhanced Security Features

What are the enhanced security features?

Node.js 23 introduces several security improvements to strengthen encryption, support modern password hashing algorithms, and address known vulnerabilities. Here are these:

• Improved TLS/SSL Security: Node.js 23 enforces stronger encryption by using more secure default settings and ciphers for TLS connections.
• Better Password Hashing: Node.js 23 improves support for modern hashing algorithms like Argon2, providing stronger password protection.
• Updated Dependencies: Security patches for core dependencies, including V8 and OpenSSL, reduce vulnerabilities and improve protection against exploits.

Coding examples

Improved TLS/SSL Security:

Old usage:

const https = require(‘https’);

const fs = require(‘fs’);

const options = { key: fs.readFileSync(‘key.pem’), cert: fs.readFileSync(‘cert.pem’) };

https.createServer(options, (req, res) => res.end(“Secure server”)).listen(8443);

Recommended usage:

const https = require(‘https’);

const fs = require(‘fs’);

const options = {

  key: fs.readFileSync(‘key.pem’),

  cert: fs.readFileSync(‘cert.pem’),

  secureProtocol: ‘TLS_method’,

  ciphers: ‘TLS_AES_128_GCM_SHA256’

};

https.createServer(options, (req, res) => res.end(“Secure server”)).listen(8443);

Better Password Hashing with Argon2:

Old usage (bcrypt):

const bcrypt = require(‘bcrypt’);

bcrypt.hash(‘password123’, 10, (err, hashedPassword) => {

  console.log(hashedPassword);

});

Recommended usage (Argon2):

const argon2 = require(‘argon2’);

argon2.hash(‘password123’).then(console.log).catch(console.error);

How will it help developers?

• Stronger default security: With improved TLS settings and modern password hashing, developers can easily secure communications and user data.
• Fewer vulnerabilities: Updated dependencies reduce the risk of security breaches from known exploits.
• Easier compliance: Node.js developers can meet modern security standards and improve application protection with minimal effort.

8. Improved HTTP/2 and QUIC Protocol Support in Node.js 23

What are HTTP/2 and QUIC Protocol?

HTTP/2 improves on HTTP/1.x by enhancing performance with features like multiplexing, header compression, and server push, reducing latency and speeding up communication. QUIC, developed by Google, speeds up secure connections by using UDP instead of TCP, combining the benefits of both TCP and TLS.

Coding examples:

• HTTP/2 Support:
  js 23 makes it easy to create an HTTP/2 server with built-in support. Here’s an example of how to use HTTP/2 to serve content:

const http2 = require(‘http2’);

const fs = require(‘fs’);

const options = {

  key: fs.readFileSync(‘server-key.pem’),

  cert: fs.readFileSync(‘server-cert.pem’)

};

const server = http2.createServer(options, (req, res) => {

  res.stream.respond({ ‘:status’: 200 });

  res.stream.end(‘Hello, HTTP/2!’);

});

server.listen(8443, () => {

  console.log(‘HTTP/2 server is running on port 8443’);

});

• QUIC Protocol Support:

Node.js 23 introduces experimental support for QUIC. It allows developers to take advantage of its performance benefits in secure communication. Here’s a simple example of using QUIC (note that QUIC support in Node.js is experimental):

const quic = require(‘quic’);  // This is hypothetical as QUIC support is still being integrated

const fs = require(‘fs’);

const server = quic.createServer({

  key: fs.readFileSync(‘server-key.pem’),

  cert: fs.readFileSync(‘server-cert.pem’)

});

server.on(‘stream’, (stream) => {

  stream.respond({ ‘:status’: 200 });

  stream.end(‘Hello, QUIC!’);

});

server.listen(8443, () => {

  console.log(‘QUIC server is running on port 8443’);

});

How will it help developers?

• Reduced Latency: HTTP/2 and QUIC help reduce connection delays, leading to faster page loads and better responsiveness for web apps.
• Seamless Development Experience: Node.js 23 makes it easier for developers to use these protocols without extra libraries or complex setups.
• Better Scalability: Both protocols allow more efficient handling of multiple requests over a single connection, helping apps scale smoothly as traffic increases.
• Improved Mobile Experience: QUIC’s faster connection setup and lower latency improve mobile network performance.

9. New matchGlob Method in the Path Module

What is the newmatchGlob method?

The matchGlob method is a new addition to the path module in Node.js 23. It allows developers to match file paths using glob patterns (wildcards) directly in their applications. This method helps identify files that fit a specific pattern, such as matching all .txt files or files in a particular directory. It simplifies working with file paths and searching for files matching certain criteria without needing third-party libraries like glob.

Coding example:

const path = require(‘path’);

// Match all .txt files in the current directory

const result = path.matchGlob(‘*.txt’);

console.log(result);  // Outputs an array of file paths that match the pattern

In this example, path.matchGlob() is used to find all .txt files in the current directory, making it easy to filter files based on a pattern.

How will it help developers?

• Simplifies file matching: No need for external libraries; matchGlob offers a native solution for matching file patterns.
• Faster development: It reduces the complexity of writing custom code for file searches, saving time.
• Improved productivity: Tasks like filtering files and searching directories become quicker and easier.

10. Support for Propagating Aborted State in the lib Module

What is this feature?

Node.js 23 introduces support for propagating the aborted state in the lib module. This allows better handling of aborted operations or requests, making it easier for developers to track the cancellation of ongoing tasks. When a process, such as a network request or file operation, is aborted, this feature ensures that the aborted state is properly passed through to dependent signals and events, improving the overall control flow and state management.

Coding Example:

const { EventEmitter } = require(‘events’);

const { AbortController } = require(‘abort-controller’);

const controller = new AbortController();

const { signal } = controller;

const task = new EventEmitter();

signal.addEventListener(‘abort’, () => {

    console.log(‘Operation aborted’);

    task.emit(‘abort’);

});

// Simulate an async operation

setTimeout(() => {

    if (!signal.aborted) {

        console.log(‘Task completed’);

    }

}, 5000);

// Abort the operation after 2 seconds

setTimeout(() => {

    controller.abort();

}, 2000);

In this example, an AbortController is used to control an asynchronous operation. If the operation is aborted before completion, the aborted state is propagated, and the associated cleanup logic executes immediately.

How will it help developers?

• Automatic cancellation handling: Developers no longer need to implement logic to check and handle aborted states manually.
• Efficient resource management: This avoids unnecessary operations and ensures that aborted tasks do not continue running.
• Simplifies error handling: Streamlines how asynchronous processes respond to cancellation, improving code readability and maintainability.

Preparing for Node.js 23.0.0

The Node.js 23.0.0 version brings various new features along with the other updates. Developers should thoroughly test their applications with Node.js 23 to ensure compatibility and use the latest features and improvements.

Businesses still maintaining legacy systems should hire Node.js developers to upgrade their applications to ensure modern features and performance enhancements. Staying updated with the latest version helps improve security, performance, and scalability.

Frequently Asked Questions

1. Is Node.js 23 an LTS release?

No, Node.js 23 is not an LTS (Long-Term Support) release; it is a current release intended for developers who want the latest features and improvements. If you need stability and long-term maintenance, using an LTS version like Node.js 22 is better or waiting for the next designated LTS release.

2. What is the difference between Node.js 23 and 22?

Node.js 22 is an LTS release focused on stability, while Node.js 23 is a current release with new features and improvements. Node.js 23 introduces default support for require(esm), better testing tools, and removes 32-bit Windows support. If you need stability, stick with Node.js 22; if you want the latest features, consider Node.js 23.

3. Is it necessary to upgrade to Node.js 23?

Upgrading to Node.js 23 is not mandatory, especially for production environments relying on an LTS version. However, testing and upgrading may be beneficial if you want to use new features, improved module handling, and performance enhancements.

4. How does Node.js 23 impact package compatibility?

Some older packages may require updates due to module handling and platform support changes. Developers should check their dependencies, compatibility test, and update packages accordingly to ensure smooth performance.

5. How can businesses prepare for Node.js 23?

Businesses should start by testing their applications for compatibility, especially if they rely on older dependencies or 32-bit Windows support. Hiring experienced Node.js developers and reviewing official release notes will help ensure a smooth transition while taking advantage of the latest improvements.

Final Words

Node.js 23 takes a big step forward with improved ES module support and enhanced testing tools, making development smoother and more efficient. While dropping 32-bit Windows support may need some adjustments, the overall improvements set the stage for a more modern and streamlined development experience. Developers should explore these new features to optimize their workflows, while businesses still using legacy applications should consider upgrading to stay competitive, secure, and future-ready. If you’re unsure about updating, reviewing your system’s needs, or consulting a Node.js expert can help you make the right decision.