Packages

turbo

2.11.13 · 18 Nov 2026MIT48.2M / weekRepositoryHomepagenpmAtom feed

Your version

2.11.9

16 Oct 2026Where it was published

2.11.13 is the newest release of 2.x.

In short

1 removed118 new58 faster35 fixed23 internal

  • Removed

    refactor: Remove setup lifecycle script controls

Release note

What's Changed

Changelog

  • Prefetch Cargo metadata during lazy graph construction

  • Compute Berry lockfile closures once across workspaces

  • Check cache hit outputs in place instead of on the blocking pool

  • Speed up Berry lockfile loading

  • Parse bun.lock without building a JSON syntax tree

  • Skip the dry run cache batch window when there is no remote cache

  • Emit lockfile closures pre-sorted and cheapen closure interning

  • Reuse configuration derived from turbo.json between the shim and the CLI

  • Report locked tools-only setup plans

  • Compute Bun lockfile closures once across workspaces

  • Reuse open parent directories when restoring cache archives

  • Skip dropping the run right before turbo run exits

  • Match literal input exclusions without compiling globs

  • Copy pruned package files in parallel

  • Report proposed first-lock and refresh setup plans

  • Compress large cache archives with multithreaded zstd

  • Read tracked file stats from directory listings on Windows

  • Diff changed lockfile resolutions with a merge instead of ordered sets

  • Write dry run text output through one buffered stdout handle

  • Parse pnpm-workspace.yaml once per command

  • Write each file trace error to stderr in a single call

  • Reuse glob validation results when re-validating turbo.json in the language server

  • Keep git subprocesses off the critical path of dry runs

  • Classify watch file changes when they arrive instead of on a 100ms poll

  • Buffer TUI raw-output spool writes

  • Add the turbo query version key without re-parsing the response

  • Replay cached task logs in whole-line chunks

  • Write each boundaries diagnostic to stderr in a single call

  • Walk leading-globstar input trees in parallel without wax

  • Reuse open parent directories when writing cache archives

  • Index Bun lockfile subgraph lookups instead of rescanning all packages

  • Render the pruned lockfile while package files are copied

  • Resolve exact native npm lock cohorts

  • Batch prefixed task output into one write per chunk

  • Share one allocation per external package identity

  • Remove quadratic package-name scan from microfrontends discovery

  • Render file trace errors on several threads

  • Check boundaries packages in parallel again

  • Read PTY child output in 8 KiB chunks

  • Load each package's tsconfig once when checking boundaries

  • Skip the file watcher round trip when checking outputs for new task hashes

  • Refresh only memory stats in turbo info

  • Walk and record prune copy plans in parallel

  • Reconcile sealed clone-local setup selections

  • Accept Homebrew's bundled npm prefix in setup source preflight

  • Report ignored version manager declarations during setup

  • Provision clone-local setup without lock writes

  • Integrate native npm provisioning into setup

  • Parse Go toolchain declarations for setup

  • Parse root uv version requests for setup

  • Add root-only turbo setup policy to turbo.json

  • Bootstrap a verified repository-scoped rustup

  • Follow approved release CDN redirects in verified downloads

  • Explain missing Git and non-repository setup roots

  • Keep non-UTF-8 arguments from crashing the turbo shim

  • Install managed tool generations on native Windows

  • Add the shell hook by default from the POSIX installer

  • Accept Corepack SHA-224 package manager pins

  • Accept official Bun ZIP metadata in verified archives

  • Write turbo.lock as indented JSON

  • Accept project .npmrc files with only install-layout settings

  • Define native lifecycle-script policy for dependency setup

  • Resolve uv requests to official locked releases

  • Install locked uv with repo-scoped launchers

  • Record official Go release artifacts in turbo.lock

  • Create, refresh, and freeze uv selections in turbo setup

  • Resolve root Python requests through managed uv

  • Lock managed Python for every supported architecture

  • Select Linux setup artifacts by detecting the host libc at runtime

  • Provision verified Go toolchain archives

  • Provision locked rustup from turbo setup

  • Keep managed setup working under Ubuntu's default 0002 umask

  • Provision pnpm 11 releases with their module entry points

  • Accept npm and pnpm wrapper environments in setup source policy

  • Extract official python-build-standalone archives

  • Declare additional repository tools in root setup policy

  • Parse JSX in JavaScript files

  • Complete CI frozen setup behavior

  • Provision tools with plain turbo setup and report skipped dependencies

  • Record trusted setup installations outside the repository

  • Provision pnpm 12 native binaries from verified platform packages

  • Parse root rust-toolchain files into portable requests

  • Provision locked Python interpreters through managed uv

  • Sync uv workspaces from the committed uv.lock

  • Resolve Rust toolchain requests to exact locked channels

  • Authorize prepared tools from private setup evidence

  • Install locked Rust toolchains through private rustup

  • Create and update Rust selections in turbo.lock

  • Prefetch locked Cargo dependencies with managed cargo

  • Activate trusted Node and pnpm for task execution

  • Enforce managed run compatibility before CLI handoff

  • Close managed execution authorization gaps

  • Preserve informational exits in managed repositories

  • Reuse trusted installations for offline setup

  • Add experimental managed Node and pnpm peer capabilities

  • Lock additional tool artifacts and detect declaration drift

  • Install additional tools through a generic verified artifact backend

  • Activate locked uv and Python and check their readiness

  • Precompile managed Python bytecode while staging

  • Prune setup records for deleted, moved, or re-cloned roots

  • Activate locked Rust toolchains and check their readiness

  • Provision locked additional tools from turbo setup

  • Create and refresh Go entries in turbo.lock during local setup

  • Prefetch Go modules without changing go.mod or go.sum

  • Advertise the managed Node/pnpm peer contract on GNU Linux x64

  • Provision locked Yarn classic binaries

  • Add repository and CLI controls for skipping lifecycle scripts

  • Explain whether turbo setup repairs tools or updates the lock

  • Reuse verified tool downloads across repositories

  • Cache installed tool tree hashes per generation

  • Apply root setup policy and CLI overrides in turbo setup

  • Pin and verify the xz Rust tarballs rustup downloads

  • Hash locked additional-tool artifact identity portably

  • Provision locked modern Yarn bundles

  • Provision locked Bun binaries without global Bun

  • Provision offline setup from verified cached artifacts

  • Measure and remove inactive managed tool storage

  • Create and update turbo.lock for Yarn and Bun during local setup

  • Validate installed Yarn and Bun activation plans and checks

  • Set up Bun-only repositories without a Node declaration

  • Add a shell hook that activates managed tools in bash and zsh

  • Add an uninstall mode to the POSIX installer

  • Route setup downloads through credential-free mirror overrides

  • Clean up replaced managed tools automatically during setup

  • Add the turbo exec command surface

  • Run turbo exec commands with the managed environment

  • Activate locked Go and check its readiness in turbo setup --check

  • Name the missing Node declaration when --no-lock setup cannot start

  • Add shell hook support for fish and PowerShell

  • Run turbo setup in pruned output without a Git repository

  • Accept umask 0002 ancestors of trusted setup records

  • Guard managed turbo exec local CLI handoff

  • Lock and verify system Node.js and pnpm under verify-system policy

  • Record and authorize trusted setup roots on native Windows

  • Provision managed Node and pnpm on native Windows

  • Preserve turbo exec behavior for Windows .cmd launchers and Ctrl+C

  • Stop native Windows turbo setup on Ctrl+C from either entrypoint

  • Refuse managed setup on Windows arm64 hosts, including x64 turbo under emulation

  • Propose setup plans with every ecosystem's lock resolver

  • Detect the host libc for managed turbo run

  • Add a frozen npm install adapter for setup dependencies

  • Activate additional tool binaries in managed run and exec

  • Install locked npm dependencies during turbo setup

  • Follow HTTPS redirects for additional-tool artifacts

  • Configure setup mirrors in the root setup policy

  • Record trusted setup roots for --no-lock installs

  • Activate and hash --no-lock selections in plain turbo run

  • Install additional-tool archives without a top-level folder

  • Mirror Bun, uv, and Python release downloads

  • Mirror Go and Rust release downloads

  • Provision declared npm without lock writes

  • Activate every managed ecosystem in turbo run, including its own probes

  • Download additional tools through the shared cache, offline mode, and a mirror

  • Resolve native task commands through managed binaries

  • Qualify additional tools on native Windows x64

  • Use verified system tools in managed turbo run

  • Let turbo run and turbo exec use verify-system tools on musl hosts

  • Provision managed uv on native Windows x64

  • Provision locked Rust toolchains on native Windows x64

  • Kill the command when turbo exec is killed

  • Provision managed Go from the official Windows x64 zip

  • Provision managed Python on native Windows x64

  • Activate managed tools from the PowerShell hook on native Windows x64

  • Activate managed Go with a plain GOROOT on native Windows

  • Provision locked Bun on native Windows x64

  • Keep PowerShell hook output ASCII so console code pages cannot corrupt PATH

  • Provision pnpm 12 native binaries on native Windows x64

  • Kill the local turbo when the global turbo that handed off is killed

  • Activate managed Rust on native Windows x64

  • Activate managed Go from the shell hook on native Windows x64

  • Block cache restoration writes to Git metadata

  • Report locked dependency actions in turbo setup plans and checks

  • Advertise the managed-run peer contract on every claimed platform

  • Activate managed tools in turbo watch

  • Stamp installed tool trees on native Windows

  • Install pnpm dependencies in frozen mode during setup

  • Measure setup outcomes through standard telemetry

  • Install Yarn dependencies immutably during setup

  • Activate managed tools in commands that discover the repository

  • Install Bun dependencies from a frozen lock during setup

  • Sync locked uv workspaces during turbo setup

  • Reject Windows prefixed paths during cache restore

  • Prefetch locked Cargo dependencies during turbo setup

  • Prefetch Go modules during turbo setup

  • Prefetch Cargo dependencies and report the MSVC linker on Windows

  • Install locked dependencies offline from native caches

  • Prefetch Go modules with managed Go on native Windows

  • Install locked JavaScript dependencies on native Windows x64

  • Probe repository-local turbo on Windows and cover pins on every platform

  • Export managed runtime variables from the shell hook on every platform

  • Load each tsconfig once per file trace

  • Overlap reading and compression when writing large cache archives

  • Speed up pnpm lockfile pruning and encoding in turbo prune

  • Prefetch remote cache artifacts as soon as task hashes are known

  • Remove the remaining quadratic passes from the Bun prune subgraph

  • Memoize Cargo.lock closures and share resolution identities

  • Match node_modules-style exclusions by path segment instead of compiling globs

  • Avoid waking the rayon pool for small workspaces

  • Overlap affected change detection with package graph construction

  • Find line breaks in task output a block at a time

  • Buffer task log file writes in 64 KiB blocks

  • Hand lockfile closures to JavaScript resolution as indices

  • Share each file's text across its trace errors

  • Preserve task output after non-zero exits

  • Overlap reading and compression when building cache archives for upload

  • Install cache archives locally while they upload

  • Skip newline normalization copies for already-normalized TUI output

  • Attribute Cargo.lock changes to the crates whose dependencies changed

  • Stop installing the Unix shell hook automatically

  • Allow native package manager configuration during setup

  • cache: Parallelize dry-run HEAD fallback

A whole project to check? Paste its package.json in the dependency check: every deprecated, outdated or vulnerable dependency, with what to upgrade to. Free, no account.