turborepo

> is this the beginning of a larger trend where JS/TS tooling migrates to native implementations No, it is not. It is a continuation of an existing trend You may be interested in esbuild (https://github.com/evanw/esbuild), turborepo (https://github.com/vercel/turborepo), biome-js (https://github.com/biomejs/biome) are all native reimplementations of existing projects in JS/TS. esbuild is written in Go, the others in Rust. > reveals something deeper: Microsoft prioritized shipping a working solution over language politics Its not that "deep". I don't see the politics either way, there are clearly successful projects using both Go and Rust. The only people who see "politics" are those who see people disagreeing, are unable to understand the substance of the disagreement and decide "ah, it's just politics".

One detail I enjoy from this post is that sometimes you can just call a CLI[0]. It's easy to spend a lot of time figuring out how to expose some Rust/C code as a library for your language, but I like the simplicity of just compiling, shipping the binary and then calling it as a subprocess. Yes, there's overhead in starting a new process to "just call a function", but I think this approach is still underutilized. [0]: https://github.com/vercel/turbo/blob/c0ee0dea7388d1081512c93...

I've been using https://www.prysk.net/ for the past few months, and I really like the simplicity of running a programming and using standard tools to validate the output and any system changes. Here's a bunch of tests in the turborepo codebase if anyone is interested https://github.com/vercel/turbo/tree/main/turborepo-tests/in...

This was meant to link to a specific comment, but looks like HN strips hashes from the URL https://github.com/vercel/turbo/issues/986#issuecomment-1477...

Kind of. Poster asked if you can prune only deps and exclude dev deps. That's currently unsupported: https://github.com/vercel/turbo/issues/1100

Here's the bulk of the code used to generate the code they're building: https://github.com/vercel/turbo/blob/main/crates/turbopack-c... They're building basically the same thing over and over again. This surprised me, given their intro post: https://vercel.com/blog/turbopack Relevant quote: > Turbopack is built on Turbo: an open-source, incremental memoization framework for Rust. Turbo can cache the result of any function in the program. When the program is run again, functions won't re-run unless their inputs have changed. This granular architecture enables your program to skip large amounts of work, at the level of the function. I'd be curious to see if a real-world app (or even one generated with more variety in components) showed comparable performance numbers

The engine here are the creates called "turbo-tasks" and "turbo-tasks-*" extend it with more features. See a bit in https://github.com/vercel/turbo/blob/main/architecture.md#tu...

Documentation here is one of the areas we need to work on. There's a bit in https://github.com/vercel/turbo/blob/main/architecture.md#tu... A small example of code that uses this is https://github.com/vercel/turbo/blob/main/crates/turbo-tasks..., which defines how we can load a `.env` file using FS read caching, cached `read` and `read_all` functions, etc.

Right, they link to this docs page when referring to the memoization library: https://turbo.build/pack/docs/core-concepts And the github link at the top of the page links here: https://github.com/vercel/turbo but, despite being called "turbo", that seems to actually be the repo for Turbopack (the webpack alternative) not "Turbo" the library. Even digging a bit into the crates, I'm not sure where this supposed library lives: https://github.com/vercel/turbo/tree/main/crates

Turborepo author here... > * tasks on the root package (e.g. tsc -b that typechecks all packages) We are working on this as we speak! The first step is to add the ability to restrict hashing `inputs`[1] to the Turborepo `pipeline`. After that we are going to be adding root task running in the next minor release. However, as your monorepo grows, you will likely want to move away from running tasks like tsc from the root and instead run them on a per-package basis. The reason is that tools like Bazel, Buck, Turborepo, etc. can become more incremental (and thus faster) as your dependency/task graph becomes more granular (as long as you maintain or reduce the average affected blast radius of a given change). The other argument against root tasks is that they break hermeticity and encapsulation of the package abstraction. That being said, root

While we're initially focused on JavaScript and TypeScript codebases, you can already use Turborepo with any language as long as you define tasks through `package.json` scripts and use npm/pnpm/yarn workspaces. Turborepo is written in Go and uses `turbo` to build `turbo` in its own monorepo[1]. We're discussing more native support for other languages. It would likely be a commitment to a small subset of popular languages (e.g. Rust, Go, C++, Python) while still maintaining our goal of nearly zero configuration. [1]: https://github.com/vercel/turborepo/blob/main/turbo.json