v1.0.0

publish 1.0.0 to registry

v0.9.0-next.2

What's Changed

• Fixed postinstall script

v0.9.0-next.1

What's Changed

• Add workaround for windows x yarn users by @jaredpalmer in #93

v0.9.0-next.0

What's Changed

• Getting Started Docs update by @becca in #70
• Move CLI to Vercel by @jaredpalmer in #52
• Add devcontainer for development / codespaces by @jaredpalmer in #84
• Repo Updates for OSS by @jaredpalmer in #85
• Remote caching and auth with Vercel by @jaredpalmer in #88
• Stop publishing binaries to private github registry by @jaredpalmer in #92

New Contributors

• @becca made their first contribution in #70

Full Changelog: v0.8.5...v0.9.0-next.0

v0.8.5

What's Changed

• 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.

---

Historical Changelog

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:

  {
    "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 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 ro...

v0.8.5-next.1

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.

This is available on the next branch so install with yarn add turbo@next or equivalent