mrkeyoor.comAsk

vercel/turborepotested 08 Oct 2026commit 7b470b6

turborepo review

Our Turborepo run installed 1,804 dependencies in 68 seconds and used 1,675 MB, but build and tests were skipped.

  • 1,804 packages
68 sto install
    Dev Toolsevaluationupdated 27 Oct 2026
    +29stars / 7d

    Turborepo runs workspace tasks and reuses cached results when their known inputs match. It helps JavaScript and TypeScript workspace teams avoid repeating work across a repository, with an optional remote cache for sharing task artifacts between machines.

    Verdict

    Our Turborepo run installed 1,804 dependencies in 68 seconds and used 1,675 MB, but build and tests were skipped. It proves dependency setup only. Evaluate Turborepo when repeated workspace tasks justify maintaining their cache configuration. Before sharing results across machines, check that cache hits restore required files and that task logs contain no secrets.

    We ran it

    Lab card: what happened when we ran turborepo
    Lab card from our sandbox run
    Screenshot of turborepo (turborepo.dev)
    turborepo.dev
    Install✓ · 68s1804 packages · 1675 MB
    Buildn/ano build script
    Testsn/ano test script
    Repo5835 files~418,603 lines of source · 93 MB · 12 CI workflows

    Answers from our run

    Does turborepo build from source?

    Dependencies installed in 68 seconds (1804 packages), and the project has no separate build step. We cloned commit 7b470b6 into a clean Debian container with 3 CPUs and no project-specific setup.

    Does turborepo have tests you can run?

    Not through a standard command: the project exposes no test script or target that our harness could run.

    Who should not use turborepo?

    Teams whose tasks produce different outputs for the same known inputs, unless they exclude those tasks from caching.

    What are the alternatives to turborepo?

    Nx, Lage. Our Turborepo run installed 1,804 dependencies in 68 seconds and used 1,675 MB, but build and tests were skipped.

    Setup3/5Our source checkout installed in 68 s, a heavy install of 1,804 dependencies, and we did not run a README task.Editor’s note: The contributor dependency step completed, but build, tests and an end-user cached task were not exercised.
    Docs3/5The README has an install section (“Getting Started”) and usage in the same section, but the usage section is thin: no code and under 400 characters.Editor’s note: The supplied caching and remote-cache extracts support the guidance here; the full documentation and configuration reference were not assessed.
    Community5/5Last push on 2026-10-27 and 31,346 stars.Editor’s note: Current issue discussion and maintainer responsiveness were not assessed.
    Maturity4/5Latest release v2.11.10 on 2026-10-20 and repository created 2021-10-05.Editor’s note: The lab skipped build and tests and measured no artifact restoration, so operational correctness was not assessed.

    How we score

    Discussed on

    1. hnHow Turborepo is porting from Go to Rust116 points
    2. hnVercel acquires Turborepo, a high-performance build system47 points
    3. hnWhy Turborepo is migrating from Go to Rust17 points
    4. hnTurborepo 1.8: OSS Build System for JavaScript Codebases by Vercel12 points
    5. hnHow We Continued Porting Turborepo to Rust (With Zig)11 points

    Who it’s for

    JavaScript workspace teams with repeated deterministic tasks on developer machines or in CI.
    Developers prepared to define generated outputs and inspect cache inputs.
    Platform teams evaluating local, managed remote or self-hosted cache storage.

    Who it’s NOT for

    Teams whose tasks produce different outputs for the same known inputs, unless they exclude those tasks from caching.
    Projects whose tasks finish faster than cache transfers, or whose artifacts cost more to transfer than regenerate.
    Organizations unable to keep secrets out of task logs before sharing cached artifacts.
    Worktree workflows with generated files that embed absolute paths, unless the team addresses cache isolation.

    Setup reality

    Our October 8, 2026 sandbox run at 7b470b6 completed pnpm dependency installation in 68 seconds, recording 1,804 dependencies and 1,675 MB on disk. Build and tests were skipped because the lab detected no corresponding script or target. This establishes dependency setup only. It does not establish a compiled executable, passing checks or a functioning cache.

    Local caching needs no remote service. Shared caching adds provider authentication and repository linking, or configuration for a service implementing the Remote Cache API. Generated outputs and behavior-changing inputs need deliberate configuration before cached results are trustworthy. The suggested cache-restoration check below comes from the documentation and our synthesis; it was not executed in this sandbox.

    The recorded configuration was 3 CPUs, 8 GB RAM and image label lab-node:22. That label does not verify actual runtime versions. The checkout contained 5,835 files, approximately 418,603 source lines and 93 MB before dependency installation. This contributor-checkout footprint is not a minimum requirement for adding Turborepo to an existing workspace.

    The caching guide says linked worktrees share local cache by default and restored artifacts retain embedded absolute paths. An explicit cacheDir can isolate local worktree caches. That setting does not isolate a remote cache shared across machines.

    Turborepo caching needs declared outputs

    A cache hit can replay a successful build log without restoring the files your next step needs. Turborepo caches generated files only when the task declares them as outputs. It captures terminal logs regardless. That distinction is the first thing to check when evaluating task caching.

    Turborepo fingerprints task inputs and reuses a previous result when the fingerprint matches. This suits workspaces that repeatedly run deterministic tasks on developer machines and in CI. Our run measured dependency installation, so it provides no cache-hit speedup or estimate of CI savings.

    What happened when we ran it

    Our sandbox completed the pnpm dependency-install step in 68 seconds at commit 7b470b6 on October 8, 2026. It recorded 1,804 dependencies and 1,675 MB on disk. The lab found no build script or target and skipped building; it likewise found no tests script or target and skipped tests.

    Those skipped steps describe what the general repository harness detected. They do not establish that Turborepo lacks a build system or tests. Successful dependency installation does not show that the executable compiled, workspace checks passed or cached files were restored correctly.

    The recorded environment had 3 CPUs, 8 GB RAM and image label lab-node:22. Actual runtime versions require the toolchain logs. The checkout contained 5,835 files, approximately 418,603 source lines and 93 MB. The scan identified monorepo workspaces and twelve CI workflow files, without detecting a Dockerfile or top-level tests directory. It did not establish whether those CI workflows passed.

    These measurements describe the upstream contributor checkout. They are not minimum requirements for adding the published package to an existing workspace. The run measured neither uncached task execution nor remote artifact transfer.

    Check files as well as cache messages

    The caching guide assumes deterministic tasks: the same known inputs should produce the same outputs. A build that depends on an undeclared environment value or an external service needs attention before its results can be reused safely. Some tasks may need caching disabled.

    Generated files require a separate outputs declaration. A successful log replay therefore does not establish that a deployable directory exists.

    For an initial evaluation, choose one deterministic build and identify the files its downstream step consumes. Declare those outputs, run the build, remove the generated files and run it again with unchanged inputs. Check that a cache hit restores those files. This is a proposed acceptance check based on the documentation, not an experiment completed in our lab.

    Use the documented dry-run option to inspect task selection without executing tasks. Run summaries can help inspect inputs and restored outputs. Compare summaries when an expected cache hit becomes a miss.

    Caching also has a transfer cost. The guide describes tasks that execute faster than a remote-cache round trip and artifacts that take longer to upload or download than to regenerate. Measure those tradeoffs in your workspace before enabling caching everywhere.

    Shared caches include task logs

    Local cache results live in .turbo/cache. Remote caching is optional, so local reuse provides a starting point for checking output restoration before configuring a shared service.

    Vercel provides a managed remote cache. Turborepo also documents an HTTP API for other implementations, including self-hosted services. Its manual login route accepts an API URL, team and token.

    The remote-cache guide warns that Turborepo treats logs as artifacts. Credentials or sensitive data printed during a task can therefore enter the shared cache. Review task output before enabling sharing.

    Turborepo documents optional HMAC-SHA256 artifact signing. Downloads that fail verification are ignored and treated as cache misses. Signing checks integrity and authenticity; it does not remove sensitive information from valid artifacts.

    Linked Git worktrees automatically share local cache, according to the caching guide. Cached contents are restored without rewriting absolute paths, so a generated file can still point at another checkout. An explicit cacheDir isolates local worktree caches. Remote caching remains a separate sharing path and needs the same artifact checks.

    Compare configuration needs with Nx and Lage

    Nx's README describes optional plugins that discover tasks, configure cache inputs and outputs, and scaffold code. Evaluate Nx when that plugin support is part of your requirement. We have no comparative measurements showing that it is faster or easier in your repository.

    Lage's documentation describes workspace task execution and offers local caching or your own cloud storage. Include it when comparing task-runner configuration and storage choices. Neither alternative was run in this sandbox, so comparative setup time and performance remain unknown.

    Release evidence and remaining limits

    The supplied release record identifies Turborepo v2.11.10, released on October 20, 2026. Its changelog includes fixes to hashing and cached symlink restoration. The sandbox run predates that release and does not verify those fixes. Repository metadata records a push on October 27, 2026.

    Current issue discussion and maintainer responsiveness were not assessed. Before adoption, use one representative task to establish whether a cache hit restores the files your downstream job consumes, then measure whether reuse saves time in your own workflow.

    Alternatives

    ProjectWhat it isPick it when
    Nx gh↗A monorepo toolkit with optional task-discovery and code-scaffolding plugins.Evaluate Nx when you want plugins to discover tasks, configure cache inputs and outputs, and scaffold code.
    LageA workspace task runner with local caching and cloud storage choices.Evaluate Lage when comparing workspace task execution and cache-storage configuration is your main decision.

    Sources

    1. Turborepo caching guide
    2. Turborepo remote caching
    3. Nx README
    4. Lage documentation
    5. Turborepo v2.11.10
    6. Turborepo repository facts

    More dev tools reviews