---
title: Changelog
---

# Changelog

## v0.8.5

- Completely rewritten and revamped internal graph. Fixes long standing bug with construction. You no longer need to specify all possible tasks, turbo will figure out the transitive tasks necessary automatically.
- Anything passed after a `--` to `turbo run` will be passed through to all build tasks. This is a temporary workaround for parameterized builds. The use case is for something like `turbo` or Next.js which has OS-specific builds and cache artifacts which would otherwise have an identical hash.
- `turbo` CLI output is now color aware, which should make reading build logs on platforms like Vercel and Netlify (and any other non-interactive terminal) easier.

## v0.8.4

- `turbo` is now much more friendly to OSS. In prior versions, a CI run triggered by a pull request by an outside contributor on a turborepo with remote caching would fail because `turbo` would bail in response to the unauthorized HTTP status code from our API (because the outside contributor doesn't have access to the original repo's secrets and thus TURBO_TOKEN). From now on though, `turbo` will show this warning message and fallback to local caching in this situation. This is a win for everyone as it allows core contributors with write access to get fastest builds, while still have fairly fast external contributions. In the future, we may explore public remote caches for OSS as well as read-only tokens.

## v0.8.3

- Remove support doublestar globs in workspaces (introduced in `v0.8.1`) until a faster implementation can be found

## v0.8.2

- The globs you use to specify your `package.json` `workspaces` or `pnpm-workspaces.yaml` now properly handles doublestar globs directives (e.g. `packages/**`)—`turbo` will automatically ignore `node_modules` and `bower_components` directories for you. This matches up with NPM, PNPM, and Yarn implementations.

## v0.8.1

- Botched release due to GitHub packages bug, do not use. This has been removed from the registry.

## v0.8.0

- `turbo` can now be run from a workspaces which are in subdirectories (not the git root).
- Internal changes need for the forthcoming UI, which is flagged off warranted a minor version bump

## v0.7.5

- Fixed issue where including an pipeline package-specific overrides with topological `dependsOn` created circular task graph dependency

## v0.7.4

- Fix regression with `--since` flag (it wasn't working)
- Unknown/misspelled CLI flags will now properly error instead of failing silently

## v0.7.3

- Fixed issue with `prune` where `.gitignore` didn't exist. It now safely handles this situation.
- Fixed issue with `prune` where turbo's internal representation of the lockfile was being outputted to the root directory instead of to the cache.
- Fixed infinite loop during `turbo link`

## v0.7.2

- Improved error messages around auth flow

## v0.7.1

- Invalid flag/config errors now return proper exit code (1)
- Added ability to specify token, team, and project via `TURBO_TOKEN`, `TURBO_TEAM`, and `TURBO_PROJECT` environment variables. The flags will take precendence over the environement variables when both are present.

## v0.7.0

- Remote caching is finally here! Along with a super super early preview of `https://beta.turborepo.com`. Remote caching allows everyone on your team and even your CI/CD to recycle previously cached task artifacts. Think of it like Dropbox, but for your builds!

**Getting started with v0.7.0**

- Remove all the `.npmrc` stuff! You no longer need a token to download `turbo`.
- Upgrade turbo: `yarn add turbo -W`
- Create an account and team on `https://beta.turborepo.com/signup`
- Activate your CLI: `yarn turbo login`
- Link your monorepo to a new project: `yarn turbo link`
- Use `turbo`! In addition to locally caching artifacts, turbo will now also two-way sync artifacts to your remote cache.
- Invite your team members so they can use your artifacts too. In your dashboard, go to Users and then blast out some invites. Once they have accepted the invitation, they'll be added to your team and have access to all of your projects. They can then link their local git repos to your shared turborepo.
- Connect your CI (programmatic non-interactive access): To give your CI/CD access to your turborepo.com team, project, and cache, go to the dashboard and create a personal access token for your account (API Tokens > Create). Copy this token to a safe place (you'll only see it once). Add it to as a secret environment variable in your CI provider. You can then pass it to turbo CLI like so: `yarn turbo run build --token=<my_token> --team=<my-team-url> --project=<my-project>`

During this limited preview period, storage and bandwidth is free for everyone in the Discord, but please don't abuse it.

**Stuff missing/what we're working on**

- Inspect/explore remote cache artifacts in the dashboard
- Usage UI
- Cleaner error messages

_WARNING/DISCLAIMER: This is rough, and they'll be bugs, but #shippingisperfection._

## v0.6.10

- Added (back) partial support for NPM and PNPM workspaces. When using either of these package managers, `turbo` will include the entire contents of the relevant lockfile in its hashing algorithm for each package task. This differs from `yarn` behavior where `turbo` will include the resolved the versions of dependencies for a given package. The `prune` command does not yet work with `pnpm` or `npm`. These features will be added at a later date.

## v0.6.9

- Remote cache hits now store to other caches (file system).

## v0.6.8

- Improved chrome profiling output (`--profile`) flag
- Fixed hashing regression with lockfiles

## v0.6.7

- Removed misleading/useless warning message about reading missing log file during replay.

## v0.6.6

- `turbo` can now construct hashes without being in a git repository. This is extremely useful for docker deployment and running builds inside of pruned `out` directories for a PaaS like Vercel or Netlify.

## v0.6.5

- Fix cache regression where the first run was not properly storing artifact output
- Fix regression with lockfile hash
- Fix regression with cache worker pool on Linux

## v0.6.4

- Improved error messages

## v0.6.3

- Add hybrid (remote + local) caching
- Ensure that execution output summary waits until all replay logs have been flushed already.

## v0.6.2

- Internal refactoring related to remote caching

## v0.6.1

- In the presence of an error without `--continue`, `turbo` will properly flush/shutdown async cache workers instead of leaving them hanging (resulting in partial artifact outputs).

## v0.6.0

- `turbo` is now 50-80% faster thanks to refactoring/improving cache behavior. While fetching artifacts from the cache is still synchronous, storing task artifacts is now async (and queued) among a worker pool so that it is non-blocking. The cache internals have been tweaked so that multiple cache implementations (i.e. local and remote) can be multiplexed together in the future.
- Improved file copying algorithm. `turbo` will first attempt to use hardlinks to copy files and fallback to a real copy if the hardlink fails. If you experience any regressions, please let us know. If necessary, we can add `--no-hardlinks` flag and/or `"copyBehavior"` config key to tune this (either globally or on a per-task basis).
- Fixed glob bug in `pipeline.<taskId>.outputs` not respecting `!` properly

## v0.5.12

- `turbo` is around 20% faster thanks to some concurrency/performance improvements to hashing

## v0.5.11

- `turbo` will now print a warning when `.git` is not present. It will continue with forced local execution and avoid caching any artifacts (the equivalent of `--force` and `--no-cache` flags)

## v0.5.10

- Fixed regression with `--includeDependencies` and `--since` flags in `turbo run`

## v0.5.9

- Pruned lockfile now includes correct file header and line breaks between entries

## v0.5.8

- You can now express package-specific tasks and implicit dependencies between tasks in `pipeline` like this:

  ```json
  {
    "turbo": {
      "pipeline": {
        "build": {
          "dependsOn": ["^build"]
        },
        "test": {
          "dependsOn": ["build"]
        },
        "deploy": {
          "dependsOn": ["test"]
        },
        "frontend#deploy": {
          "dependsOn": ["ui#test", "backend#deploy", "backend#health-check"]
        }
      }
    }
  }
  ```

  In this example, we illustrate a `deploy` script of `frontend` application depends on both the `deploy` and `health-check` NPM scripts of `backend` as well as the `test` script of a `ui` package. The syntax is `<package>#<task>`.

  This seems like it goes against the `"test": { "dependsOn": ["build"] }` and `"deploy": { "dependsOn": ["test"] }`, but it does not. Since `test` and `deploy` scripts do not have topological dependencies (e.g. `^<task>`), they theoretically can get triggered anytime once their own package's `build` and `test` scripts have finished!
  Although this feature is extremely powerful, unless they are being used for applications/services for CI/CD orchestration, the general guidance is to get rid of these specific package-task to package-task dependencies in the `pipeline` (so the `turbo` can be schedule more optimally).

  **Note: Package-tasks do not inherit cache configuration. You must redeclare [`outputs`](./reference/configuration#outputs) at the moment.**

## v0.5.7

- Fix regression with `--scope` flag on multi-cluster dependency graphs

## v0.5.6

- Improved lockfile parse performance. `turbo` now will hash/cache the converted SYML in the cache folder for faster subsequent reads. This hash is not included in task hashes, it's just used for determining if `turbo` should re-parse the SYML lockfile or not.
- `turbo prune` now properly includes lockfile entries from root deps, devDeps, optionalDeps, and peerDeps. You should now safely be able to run `yarn --frozen-lockfile` inside of the `out` directory.
- Performance improvements

## v0.5.5

- Deprecated `turbo graph` with an error message. This functionality has been moved into `turbo run` behind the `--graph` flag.
  If [Graphviz](https://graphviz.org) is installed, this flag will generate an file visualizing the current task graph.
  The output file format can be controlled with the filename's extension if it is specified. If a filename is not specified, `graph-<timestamp>.jpg` is outputted. If Graphviz is not installed, this command prints the dot graph to `stdout`.

  ```sh
  turbo run build --graph
  turbo run build test lint --graph=my-graph.svg
  turbo run build test lint --graph=my-json-graph.json
  turbo run build test lint --graph=my-graph.pdf
  turbo run build test lint --graph=my-graph.png
  ```

## v0.5.4

- Fixed regression with `--docker` flag `json` directory

## v0.5.3

- Added back `--concurrency` flag from v0.3.x to limit task execution concurrency. The default is `10`.
- Deprecated `--serial` flag with a warning message. This will still work for now, but is simply equivalent to `--concurrency=1`.

## v0.5.2

- Adds back `turbo prune` behavior from v0.4.x (i.e. `out/full`, `out/json`, one sublockfile) via `--docker` flag. This output
  style is in fact optimal for Docker layer caching. However, the v0.5.x default is _also_ useful when deploying to PaaS providers (e.g. Vercel). So now it can do both!

## v0.5.1

- Fixed regression when copying files and folders recursively

## v0.5.0

### Breaking changes

- `turbo prune` now generates only one folder with all the source code in it (instead of 2). This makes the command more useful to people not using Docker.
- `turbo` now includes `pipeline.<task>.outputs` in its hashing algorithm. Changing it should bust the cache. This is both more correct and also makes it easier to migrate to `turbo` (i.e. changing outputs yields different hashes meaning the cache is less likely to include unwanted stuff)
- Added internal `optionalDependencies` to hash algorithm
- Fixed regression where `turbo`'s hashing algorithm was not including the OS platform (e.g. darwin/linux/windows) in global hash calculation

### Improvements

- Replaying cached logs no longer blocks graph / task execution resulting in a massive perf improvement
- Fixed incorrect CLI usage text for `turbo prune`
- Improved `turbo prune` error messages and error message CLI output

## v0.4.11

- Tweak to `turbo` CLI installation and authentication

## v0.4.10

- Alter install wrapper

## v0.4.9

- Improved error messages

## v0.4.9

- Tweak to `turbo` installation and authentication

## v0.4.7

- Fix cache outputs in pipelines to respect folders that start with dots

## v0.4.6

- Tweaked `turbo` installation script

## v0.4.5

- Fixed CLI panic caused by concurrent writes to log colorizer

## v0.4.4

- `turbo` now properly handles long and shorthand `workspaces` declarations in `package.json`

## v0.4.3

- Fixed lockfile parsing when dependencies use string version names (e.g. `latest`)

## v0.4.2

- Improved error handling and error messages

## v0.4.1

- `turbo run` will now throw an error if you attempt to run a target that doesn't exist in the `pipeline`.
- Added back ">>> FULL TURBO" indicator when 100% of results are cached.

## v0.4.0

### Breaking changes

- Logs are now output to `.turbo` directory instead of `turbo` directory. This moves the directory out of the middle of your package's source code. Update your `.gitignore` accordingly.
- Removed support for NPM and PNPM (although we can add these back later)
- The `--concurrency` has been removed. 9/10 times this was used to force serial execution with `--concurrency=1`.
  Now you can just pass `--serial` to get this behavior.
- Turbo no longer includes the hash of the contents of the root lockfile in its hash algorithm.
  Instead, `turbo` now hashes the set of the resolved versions of a package's `dependencies` and `devDependencies`
  based on the root lockfile. The old behavior would explode the cache whenever the root lockfile changed. With this new behavior,
  changing the lockfile will only bust the cache for those package's impacted by the added/changed/removed dependencies. To get this to work, though, **you must now specify all
  `dependencies` and `devDependencies` in each `package.json`**.
- `environmentGlobs` have been renamed to `globalDependencies`

### What's New?

- Completely rewritten from the ground up in Go!! `turbo` is now more than 10x faster.
- Added `prune` command to allow outputting a pruned subset of your monorepo for a given project! Perfect
  for Docker layer caching.
- Added a `graph` command that will print a .dot graph to the console and/or output to a file
  which you can view in Graphviz or online
- We now validate your graph with more useful errors for cycles and multiple roots
- Added `pipeline` key to `turbo` in `package.json`. This allows users to control the task graph topology
  and per-task options such as `outputs`. Right now, `pipeline` exists at the project level,
  but in later releases these will be overridable on per-package basis.

  ```json
  // <root>/package.json
  {
    "turbo": {
      "pipeline": {

        "build": {
          // This `^` tells turbo that this pipeline target relies on a topological target being completed.
          // In english, this reads as: "this package's `build` command depends on its dependencies' or
          // devDependencies' `build` command being completed"
          "dependsOn": ["^build"]
          // You can now also specify outputs on a per-task basis. Logs will also be automatically
          // added to this, so you can omit them.
          "outputs": ["dist/**"]
        },
        "test": {
          // Without a `^`, `dependsOn` can be used to express the relationships between tasks at the package level.
          // In English, this reads as: "this package's `test` command depends on its `build` command first being completed"
          "dependsOn": ["build"]
        },
        "dev": {},
      }
    }
  }
  ```

### Migration Guide

- Move your config from `turbo.json` into `package.json` under the `turbo` key.
- Add an object called `pipeline` that specifies the relationship of your project's tasks. `turbo` can now _only_ run those tasks listed in `pipeline` object.
- Replace usage of `--concurrency=1` flags to just `--serial`
- Since `turbo` now only hashes the resolved version of deps (and not the contents of the root lockfile), you need specify all `devDependencies` used by a package in the package itself.

## v0.3.18

- Fixed `turbo run` output showing false error with 0 exit code

## v0.3.17

- Added `--continue` flag to `turbo run` (defaults to `false`). This flag tells `turbo` whether or not to continue with execution in the presence of an error (i.e. non-zero exit code from a task).
  By default, specifying the `--parallel` flag will automatically set `--continue` to `true` unless explicitly set to `false`.
  When `--continue` is `true`, `turbo` will exit with the highest exit code value encountered during exection.

## v0.3.16

- Speed improvements

## v0.3.15

- `cacheStorageOptions` now default to `local` so they can be omitted in `turbo` configuration
- Changed docs to suggest using `package.json` key `turbo` for configuration going forward. This will ease future migration to Go implementation.

## v0.3.14

- Fixed caching issue with Lerna due to `turbo` not properly reading `packages` list from `lerna.json` resulting in `null` hashes.
- Top-level `lint` command now has specialized log treatment along with `test` where `turbo` will now only cache `turbo/run-lint.log`.
- Added documentation around caching ESLint by setting `TIMING=1 eslint ...`
