Deno 2.7: Temporal API, Windows ARM, and npm overrides

We are happy to announce the release of version 2.7 of the Deno runtime, which brings a number of improvements and additions.

To upgrade to Deno 2.7, run the following in your terminal:

deno upgrade

If Deno is not yet installed, run one of the following commands to install or learn how to install it here.

# Using Shell (macOS and Linux):
curl -fsSL https://deno.land/install.sh | sh

# Using PowerShell (Windows):
iwr https://deno.land/install.ps1 -useb | iex

What’s new in Deno 2.7

Temporal API stabilized

The Temporal API is now stable in Deno. The

--unstable-temporal

flag is no longer required. Chrome 144 shipped

Temporal

in January 2026, and Deno now follows suit as part of the V8 14.5 upgrade.

const today = Temporal.Now.plainDateISO();
const nextMonth = today.add({ months: 1 }); // immutable - today unchanged

const meeting = Temporal.ZonedDateTime.from(
  "2026-03-15T14:30[America/New_York]",
);
const inTokyo = meeting.withTimeZone("Asia/Tokyo"); // same instant

For a deeper dive, see Mat’s fantastic post.

Windows on ARM support

Deno now provides official builds for Windows on ARM (

aarch64-pc-windows-msvc

). This means native performance on ARM-based Windows devices like Surface Pro X, Lenovo ThinkPad X13s, and other Snapdragon-powered laptops, with no x86 emulation overhead.

# Install Deno on Windows ARM
iwr https://deno.land/install.ps1 -useb | iex

This has been a long-requested feature and closes the gap for developers working on ARM hardware across all major platforms.

package.json overrides support

Deno has first-class package.json support. Our goal is that Node projects run in Deno with little to no changes. This release adds support for the overrides field, giving you control over the versions of packages deep in your dependency tree.

This is useful when you need to pin a transitive dependency to fix a security vulnerability, force compatibility with a specific version, or replace a package entirely.

{
  "dependencies": {
    "express": "^4.18.0"
  },
  "overrides": {
    "cookie": "0.7.0",
    "express": {
      "qs": "6.13.0"
    }
  }
}

In this example,

cookie

is pinned to

0.7.0

everywhere in the dependency graph, while

qs

is only overridden when required by

express

.

New APIs for subprocesses

Deno 2.7 introduces a simpler way to run subprocesses. The new

Deno.spawn()

,

Deno.spawnAndWait()

, and

Deno.spawnAndWaitSync()

functions are convenient shorthands for the existing

Deno.Command

API:

// Before: two steps
const child = new Deno.Command("echo", { args: ["hello"] }).spawn();

// After: one step
const child = Deno.spawn("echo", ["hello"]);

All three functions support a 3-argument overload where args are passed separately from options:

// Spawn a child process (returns ChildProcess)
const child = Deno.spawn("deno", ["fmt", "--check"], {
  stdout: "inherit",
});

// Wait for completion (returns CommandOutput)
const output = await Deno.spawnAndWait("git", ["status"]);
console.log(output.stdout);

// Synchronous variant
const result = Deno.spawnAndWaitSync("echo", ["done"]);

These new APIs are currently marked as unstable, meaning that they may evolve over time until formally stabilised in the runtime.

Node.js compatibility

Dozens of fixes across

node:worker_threads

,

node:child_process

,

node:zlib

,

node:sqlite

, and more.

node:worker_threads

• Worker stdout is now forwarded to the parent process (#32160)
• Worker stdin support (#32165)
• worker.terminate() now returns the correct exit code (#32168)
• process.exit() in a worker immediately halts execution (#32169)
• Exit code propagation fixed (#32124)
• ref()/unref() is now idempotent like Node.js (#32161)
• execArgv validation instead of rejecting all flags (#32145)
• Error events emitted for terminal errors (#32052)
• threadName property added (#32072)
• worker.cpuUsage() implemented (#32050)
• BroadcastChannel ref/unref support (#32036)

node:child_process

• stdio streams are now proper Socket instances (#31975)
• stdio streams unrefed by default to match Node.js behavior (#32071)
• Shell redirections handled in exec (#32087)
• fork() now accepts URL as modulePath (#32268)
• timeout and killSignal support for spawn() (#32283)
• NODE_OPTIONS respected for --require and --inspect-publish-uid (#31949)

node:zlib

• Zstd compression support added (#32025)
• Multiple compatibility fixes (#32039)
• Write callback is now async to match Node.js behavior (#32130)

node:sqlite

• DatabaseSync.setAuthorizer() implemented (#32009)
• Defensive option enabled on DatabaseSync (#32004)
• SQLTagStore implemented (#31945)
• StatementSync compatibility improvements (#31941)
• Garbage collection no longer invalidates associated resources (#31737)

Other changes

• PerformanceObserver implemented (#31875)
• process.constrainedMemory() added (#32209)
• process.features properly implemented (#31864)
• hasColors() added to process.stdout and process.stderr (#31985)
• util.parseEnv and process.loadEnvFile compatibility (#32183)
• tls.setDefaultCACertificates support (#31522)
• inspector.open(), inspector.close(), and inspector.url() support (#31898, #31705)
• fs.writeFile and FileHandle.writeFile compatibility (#32077)
• fs.rmdir compatibility (#32144)
• fs.rm no longer dereferences symlinks (#31886)
• openAsBlob export added to node:fs (#32261)
• IPv6 host support in node:http (#32258)
• AsyncLocalStorage context preserved in unhandledRejection handlers (#32264)
• Error formatting compatibility (#31970)
• assert.ok compatibility (#32173)
• performance.clearResourceTimings() and setResourceTimingBufferSize() implemented (#31603)
• FileHandle.readableWebStream() implemented (#31745)
• FileHandle.readv() method added (#31943)
• HTTP keepAlive connection reuse is now enabled for node:http Agent, reducing latency for repeated requests to the same host (#31709)
• node:test mock API implemented (#31954)
• Named pipe listen, connect, and open support (#31624)

API changes

navigator.platform

The

navigator.platform

property is now available in Deno, returning the operating system platform the runtime is running on. This improves compatibility with web code and libraries that check

navigator.platform

for platform-specific behavior:

console.log(navigator.platform);
// "MacIntel", "Win32", "Linux x86_64", etc.

Brotli support in CompressionStream and DecompressionStream

The web standard

CompressionStream

and

DecompressionStream

APIs now support the

"brotli"

format alongside the existing

"gzip"

and

"deflate"

:

const stream = new CompressionStream("brotli");
const response = new Response(body.pipeThrough(stream));

Brotli typically achieves better compression ratios than gzip for text content.

FsFile.tryLock()

A new non-blocking file lock method. Unlike

lock()

which blocks until the lock is acquired,

tryLock()

returns immediately with a boolean indicating whether the lock was obtained:

const file = await Deno.open("data.db", { read: true, write: true });

if (await file.tryLock(true)) {
  // Exclusive lock acquired, safe to write
  await file.write(data);
  await file.unlock();
} else {
  console.log("File is locked by another process");
}

SHA3 support in crypto.subtle

The Web Crypto API now supports SHA3 hash algorithms (

SHA3-256

,

SHA3-384

,

SHA3-512

) for

generateKey

,

encrypt

, and

decrypt

operations with RSA-OAEP:

const keyPair = await crypto.subtle.generateKey(
  {
    name: "RSA-OAEP",
    modulusLength: 2048,
    publicExponent: new Uint8Array([1, 0, 1]),
    hash: "SHA3-256",
  },
  true,
  ["encrypt", "decrypt"],
);

const data = new TextEncoder().encode("Hello, Deno!");
const encrypted = await crypto.subtle.encrypt(
  { name: "RSA-OAEP" },
  keyPair.publicKey,
  data,
);
const decrypted = await crypto.subtle.decrypt(
  { name: "RSA-OAEP" },
  keyPair.privateKey,
  encrypted,
);

GIF and WebP support for createImageBitmap

createImageBitmap

now supports GIF and WebP image formats in addition to the previously supported PNG, JPEG, and BMP:

const res = await fetch("https://example.com/animation.webp");
const blob = await res.blob();
const bitmap = await createImageBitmap(blob);
console.log(`${bitmap.width}x${bitmap.height}`);

Package manager improvements

deno create

Deno supported scaffolding projects from templates using

deno init

subcommand. This release adds a familiar

deno create

alias users might be familiar from other package managers.

# From npm (resolves to create-vite)
$ deno create npm:vite -- my-project

It works with JSR packages as well - as long as the JSR package exports a

./create

entry point, you can use it as a template source:

# From JSR (uses the ./create export)
$ deno create jsr:@std/http

deno install --compile

You can now compile npm packages into standalone executables during global installation. Compiled executables are faster to start and don’t depend on a Deno installation:

$ deno install --global --compile -A npm:@anthropic-ai/claude-code

This produces a native binary that can be distributed and run without Deno .

--save-exact for deno add

By default,

deno add

saves dependencies with a caret range (

^

), allowing compatible updates. The new

--save-exact

(or

--exact

) flag pins to the exact version instead. Useful when you need to pin a specific version or are working in environments where even minor version bumps need to be deliberate:

$ deno add --save-exact npm:express
# Adds "express": "4.21.0" instead of "express": "^4.21.0"

This also works with

deno install

.

jsr: scheme support in package.json

You can now use

jsr:

specifiers directly in your

package.json

dependencies. This means projects using

package.json

can depend on JSR packages without needing a

deno.json

:

{
  "dependencies": {
    "@std/path": "jsr:^1.0.9"
  }
}

This works with

deno install

and brings JSR packages to any project that uses

package.json

for dependency management.

deno audit --ignore

You can now filter out known advisories by CVE ID when running

deno audit

. This is useful for suppressing false positives or accepted risks in CI:

$ deno audit --ignore=CVE-2024-12345,CVE-2024-67890

Quality of life improvements

deno compile --self-extracting

deno compile

gains a

--self-extracting

flag. Instead of serving files from an in-memory virtual file system, the compiled binary extracts all embedded files to disk on first run and uses real file system operations at runtime.

This unlocks full Node API support for compiled binaries, including native addons that need real files on disk. The extraction directory is chosen automatically: next to the binary if writable, otherwise in the platform’s data directory (

~/.local/share/

on Linux,

~/Library/Application Support/

on macOS,

%LOCALAPPDATA%

on Windows):

$ deno compile --self-extracting -A main.ts -o my-app
$ ./my-app  # Extracts embedded files on first run, then executes

deno task improvements

Deno’s built-in task runner shell becomes more configurable in this release. You can now turn on

pipefail

:

{
  "tasks": {
    "lint": "set -o pipefail && deno lint **/*.ts | tee lint-output.txt"
  }
}

You can also control glob behavior with

shopt

:

nullglob

,

failglob

, and

globstar

are all configurable.

Additionally, we turned off

failglob

by default in order to match bash’s defaults.

failglob

caused too many issues. For example, urls with query parameters would cause an error due to

?

not matching a file on the file system.

deno check --check-js

If you have a JavaScript-only project and want to type-check it with Deno, you previously had to either add

// @ts-check

to every file or set

compilerOptions.checkJs

in your

deno.json

. The new

--check-js

flag lets you do it in a single command with no config changes:

$ deno check --check-js main.js

Fail fast for deno fmt

Stop on the first unformatted file instead of reporting all of them. Useful in large codebases in CI where you just need to know if something is off.

$ deno fmt --check --fail-fast

Chrome DevTools and VSCode debugging improvements

Deno 2.7 brings significant improvements to the debugging experience. You can now debug Web Workers through both Chrome DevTools and VSCode. Previously only the main thread was debuggable. The implementation supports Chrome’s

Target.*

domain and VSCode’s

NodeWorker.*

domain, so workers appear automatically in whichever debugger you use.

The

--inspect

flag now accepts bare hosts and bare ports, matching Node.js behavior:

$ deno run --inspect=9229 main.ts         # 127.0.0.1:9229
$ deno run --inspect=192.168.0.1 main.ts  # 192.168.0.1:9229
$ deno run --inspect=:0 main.ts           # OS-assigned port

A new

--inspect-publish-uid

flag has also been added to support VSCode’s debugging infrastructure, allowing VSCode to use the same debugging setup for both Node.js and Deno projects.

deno upgrade cache

Downloaded Deno binaries are now cached under

$DENO_DIR/dl/

during

deno upgrade

. If you upgrade to the same version again (e.g. on a different machine profile or after a rollback), the cached archive is reused instead of re-downloading. For canary builds, old cache entries are automatically pruned, keeping only the 10 most recent.

If the cache grows too large,

deno clean

will remove it along with other cached data.

OpenTelemetry for Deno Cron

Deno.cron

jobs are now automatically instrumented with OpenTelemetry. Each cron invocation emits spans with the job name and execution status, so you get observability out of the box when using an OTEL-compatible backend.

deno upgrade checksum verification

You can now verify a

deno upgrade

download against a known checksum using the new

--checksum

flag. This is useful for CI pipelines and security-conscious environments where you want to ensure the binary hasn’t been tampered with:

$ deno upgrade --checksum=<sha256-hash> 2.7.0

SHA-256 checksums for each platform are published as

.sha256sum

files alongside the release archives on the GitHub releases page. You can fetch the checksum for your platform like this:

# Fetch the SHA-256 checksum for Linux x86_64
$ curl -sL https://github.com/denoland/deno/releases/download/v2.7.0/deno-x86_64-unknown-linux-gnu.zip.sha256sum

SSLKEYLOGFILE support

Set the

SSLKEYLOGFILE

environment variable to log TLS session keys to a file, enabling traffic inspection with tools like Wireshark for debugging encrypted connections:

$ SSLKEYLOGFILE=./keys.log deno run --allow-net main.ts
# Now open keys.log in Wireshark to decrypt captured TLS traffic

V8 14.5

Deno 2.7 upgrades the V8 engine to version 14.5, bringing the latest performance improvements, bug fixes, and new JavaScript features from the V8 team.

Acknowledgments

We couldn’t build Deno without the help of our community! Whether by answering questions in our community Discord server or reporting bugs, we are incredibly grateful for your support. In particular, we’d like to thank the following people for their contributions to Deno 2.7: Amol Yadav, Andy Bodnar, AprilNEA, Asher Gomez, Ayu, Bedis Nbiba, Chase Knowlden, Christian Svensson, cui, ddmoney420, Florian Schwalm, Gitoffthelawn, Hajime-san, Haruto, intelliking, iownbey, it-education-md, James Bronder, Jeff Wilson, John Downey, Jose Fernandez, kantrolv, Kenta Moriuchi, kookyleo, Kyle Tse, Lee Dogeon, lif, Mahesh Thakur, Mert Can Altin, MkDev11, Padraic Slattery, Pietro Marchini, Ramnivas Laddad, Ryan Lahman, scarf, Takuro Kitahara, TarikSogukpinar, Tu Shaokun, ud2, and Varun Chawla.

Would you like to join the ranks of Deno contributors? Check out our contribution docs here, and we’ll see you on the list next time.

Believe it or not, the changes listed above still don’t tell you everything that got better in 2.7. You can view the full list of pull requests merged in Deno 2.7 on GitHub.

Thank you for catching up with our 2.7 release, and we hope you love building with Deno!