Write a viral engineering blog post for Hacker News that summarizes the notes below the --- which are about the Turborepo team migrating the Turborepo codebase from Go to Rust and why. Discuss why the team is making the migration incrementally and why this is relevant to other high-performance engineering teams doing filesystem work debating Rust or Go. Use a witty, but chill voice.
---

Nathan:

- Organizational
 - Our team wants to write Rust. We think it’s neat and it makes us happy. This alone is \*reason enough\* to do it as long as it aligns with other goals in our organization.
 - Hiring for Rust-interested web-focused engineers is easier than hiring for Go-interested web-focused engineers.
 - We want to work with the Turbopack people and primitives. Creating our own internal “library” of code gives us the ability to row the boat together. We have similar needs and problems that aren’t addressed \*anywhere else\* and it’s important to go together as a team. (Go fast? Go alone. Go far? Go together.)
- Community
 - There is a \*strong\* interest in Rust from the JavaScript community. This makes it more-accessible for people coming from JS-tooling-in-JS land, and enables community contributions.
 - We have had little engagement from the Go community in our projects, and few occasions to interact with them in external code. Not unexpected, but we’d like to build a community and we believe that we can be successful with that in Rust.
- Ecosystem
 - The Node.js ecosystem is absolutely massive. Almost anything you need has been written in JS, or is forkable. We come from this world, and this is the expectation we have for depth, breadth, and maintenance.
 - The Rust ecosystem has a few extremely-high-quality core pieces that are in \*everything\*. `serde` is a work of art. `rayon` is fantastic. Those serve as foundational tools that have \*solved\* entire problem spaces in a consistent way for the entire community.
 - Algorithm research happens in Rust, not Go. New toys show up, implement a trait, and poof, they’re in your codebase.
 - The Go ecosystem is not easily discoverable and feels very dead. People regularly write one-off solutions to general problems. Most of the best things are Google-authored and fit with Google’s worldview, but not necessarily everybody else’s.
 - The Go ecosystem has frequently-used yet poorly-maintained libraries that are a core part of the experience (e.g. afero). spf13 “Holowaychuk'd” the Go ecosystem and then disappeared (and recently stepped away from Google and Go entirely).
 - The “correctness” quotient of libraries in Go is somewhere between JS and Rust. Not good enough to be 100% reliable, not as flexible as JS when you need to duckpunch something.
- C Interop
 - As you get deeper and deeper into Go you start to discover that the best way to do certain tasks is to bind to a C library. zstd, libgit2, regular expressions, and more. This means that, \*even without Rust adoption\*, we were going to lose some of the development experience wins of Go.
 - This works “just fine” but the real point here is, once you’ve got a compiler toolchain setup for each of your targets for CGO, there’s little to prevent you from also making the small hop over to Rust. (Once we can compile with CGO, we can \*also\* compile to `c-archive` and have Rust call our Go code.)
- Go Language Design and Priorities
 - Go is designed for network computing run in data centers. It \*excels\* at that. The ecosystem of libraries available in that space are of super-high quality. `context` is a work of art.
 - In comparison, Go shipped a read-only filesystem abstraction a couple years ago. It’s still read-only. Why? You don’t write to filesystems in a (Google) data center environment.
 - Our use case doesn’t align with the Go maintainers’ needs and use cases. That leads to needing to roll our own (lots of things) because they’re not a priority to address at language level.
 - No MSVC support.
- Rust Language Design and Priorities
 - Rust has prioritized correctness over convenience. Paths? Not as easy to use, because the underlying primitive is not easy to use. It returns the complexity to the programmer to explicitly handle correctly. But we care about precisely that in a world where basically 90% of what we do is path handling.
 - In general we believe it is better-suited to ship Rust to a hostile environment like a user’s box than Go. Go’s stdlib “aligns” a lot of behaviors that can’t \*actually\* be aligned between platforms—most specifically around filesystem APIs … again a place that we care about.
 - Is able to build on the MSVC toolchain.
- Vision
 - We want to, with localized heating, boil the JS ocean. (Starting at the places where people are, and slowly moving to boil the whole ocean.) We want to bring full incremental computation all the way from dev time into production. We’re working backward from production with Turbopack, and forward from the build tool with Turborepo. The next iteration of this is “infinitely granular DAG which includes the whole ecosystem.” Nobody else appears to be attempting that granularity.
 - Success here is a \*massive\* moat, possibly insurmountable. For context I would have said the same thing about C compilers, but Clang and LLVM have done it over the last 20 years. But 20 years is one hell of a moat and we can respond a lot faster than 20 years to maintain that separation.
 - Being the stewards for the community primitives (in this case `turbo` … which is what happens after repo/pack merger) gives us the ability to push the \*entire\* ecosystem forward, slowly increasing what is possible to even attempt.
- Future
 - We believe that Rust is where the puck is heading. We want to help it get there, and be ready when that future arrives.

Nicholas:

- Reasons for Rust
 - Performance
 - Not \*really\* valid because performance issues are less language constricted and more inherent architecture issues.
 - But maybe true? Too early to tell.
 - Ecosystem
 - IMO stuff like serde, swc, clap, etc. are good reasons to use Rust.
 - Go has separate interfaces for every text format (toml, json, yaml, etc)
 - Being able to use cargo to share code with the Turbopack people
 - Standardization with turbopack
 - Opens up a future for a whole suite of tooling in Rust
 - Our version of Rome (obviously don’t say that directly) (do we want to talk about future plans?)
 - Eventually use Turbopack’s graph infrastructure (maybe)
 - Go problems
 - Go and Windows.
- Reasons against Rust
 - Slows down shipping velocity
 - We’ve done a really good job of limiting this. We’ve slowed down our shipping a little but still done a great job incrementally moving and keeping our existing users.
 - Ecosystem limitations
 - Globbing libraries are still a mess. Won’t match JS globbing behavior
 - Hard to determine standard practices
 - You will have less than ideal code.
 - The orphan rule will bite you.
 - Hiring isn’t hard, but the most senior rust developer you can find will have like 5 years of Rust experience, max.
 - Very easy to bike shed with macros, traits, funky types, refactoring, etc.
 - Just because Rust lets you refactor easily doesn’t mean you should.

Greg

Consolidating some points shamelessly stolen from above

- Rust Positives
 - JS ↔ Rust interop is a good story, technically and community-wise
 - Rust ↔ C is a good story, and we use some tools written in C
 - Rust is growing at Vercel and with NextJS, specifically
- Go Negatives
 - The Go ecosystem is all-or-nothing. Once you need to make use of functionality not written in Go, you lose a lot of the benefits of having been in Go. What we lose:
 - Easy cross-platform static binary generation
 - Compilation speed (still better than rust tho)
 - Writing portable code is hard \*and\* not a focus of the ecosystem.
 - Conditional compilation support is basic
 - Platform-related APIs are either least-common-denominator or fudged to look cross-platform
 - Mismatch with community priorities
 - The Go community seems focused on being the best tool for writing an RPC server.
 - `Context` and goroutines are great primitives for request-scoped work within a long-running process.
 - Getting an HTTP server up and running is easy, and GRPC and protobuf is not much harder.
 - Such software is often intended to run on a single platform, or does not interact significantly with the host platform, so a workflow such as developing on `macos` and deploying on `linux` is the straightforward happy path.
 - Interop with other ecosystems is not a priority.
 - `turbo` is a cross-platform CLI tool that interacts heavily with the local filesystem and process tree.
 - Some of the best tools for filesystem interactions are written in C, so interop is important
 - Differences exist between different platforms, we as developers need those differences surfaced to us so we can handle them appropriately.
 - 

Anthony’s notes from talking to Greg:

- not necessarily about language features, let’s break some new ground
- moreso about what we are buliding doesn’t align with the problem we’re trying to solve
- Go is good for RPCing and webservers and that’s what the ecosystem cares about
 - Go will lie to you about platform specific differences (an ecosystem and community mindset)
- we want good interop with JS, interop with OS’es, platform specific stuff
- The JavaScript community is spending time learning Rust right now
- Globbing and performance stuff is pretty meh, those are language specific features
-
user
Sure, I can help you with a witty but chill response for a blog post about the Turborepo team's migration from Go to Rust. Here it goes:

Hey, there! Thanks for your interest in our migration from Go to Rust. At Turborepo, we're not just after language features. We're just as much about the community, the ecosystem, and the right tools for the job. Here's why we're making the leap to Rust, step by step.

Firstly, let's talk community. The JavaScript community is all over Rust right now, and that's a huge draw for us. We believe we can build a vibrant community around our tools, and Rust is a great way to do that. Plus, the ecosystem is second to none. From serde to SWC, Cargo is a superb way to share code across turbo and Turbopack.

We want to be in hot pursuit of the best tools for our team. The Rust community mindset aligns with what we're building - error-handling is baked into the language, and every rustacean knows the joy of `match`. Speaking of which, we couldn't stop talking about how a good pattern is a Rust struct. Brilliant. And, let's be real - dragons are pretty cool.

Now, let's chat about ecosystem. We're a packager. The core primitives in Turborepo for a packager are build system management and dependency management. That means, in a word, filesystem. And you know what's not good at filesystems? Go. We looked at the existing Rust implementations of the filesystem and, well, they're not exactly a high mark in our books. Meanwhile, Rust Standard Library types, like `PathBuf`, `fsstat`, and `File`, actually dealt with some of the hardest things about that API. As a bonus, we didn't have to spend our time re-inventing wheels.

Again, we're reaching for the right tools. We admire Go's take on algorithms, the read-only file system, and handling large codebases under one package's root. But we're passionate about the right tools. And, well, here's the rub. When you're developing performance-critical tools, all the stuff for Rust - like cargo-expand and clippy - are absolutely perfect. Not gonna lie, the build times pass a long ways before that.

It's also about picking the right moment. By the time we finish a head-to-head demonstration of performance on equivalent pipelines between Rust and Go, you could render a feature film with one of our clients.

Here's where we stand. We're investing in the right tools. Go had better options for this, but it's before we were able land the core primitives. It's not the Googleverse. It's in hot pursuit of the correct stuff for our parcel server, make it easy to use, and get out of your approach. Pretty much every team out there develops manually and as specifically as likely as that.

Last but not least, let's discuss our vision. We're all about incentivizing people to deal with their ecosystems by hatching Turbopack. Turbopack is focused on all those gradual systems with one type to relax overmont. That bests, and we will find out, from the raw requirements of JSX. Soon, there'll be a website that enables you to resolve your component steps to the wireframe into a business in tree-shakeable system. When we do, changing perspective of a page leads to just 1-2 seconds of tree shake. The reasons you have been crafting the next guarantee promise.

We think Rust is just constructive for industry languages to build. Early on, a new programming language hadn't come from Dart. Today, in a hugely different community that's been working on stage for years, Rust is like Dart. There would be no motive, we'd surely have interface specifications, personal Node.js. The type's nature and spearheading are just the perfect sides that the designers embraced. Do they work?

The exact moat, and I like to promise you, is that the world should adopt what came forward.

In Rust, the planets are currently attracting most. Just as in JavaScript.

Tune in for more news from Golang and Rust, and whether Rust has come to be the viewpoint's above, the point factor. There aren't numerous better language features in the other, and there aren't regressions either. Then, the real insight of the Rust argument in your application becomes building this concoction extremely forward? You might postulate I couldn't tell.
assistant
Write a viral engineering blog post for Hacker News that summarizes the notes below the --- which are about the Turborepo team migrating the Turborepo codebase from Go to Rust and why. Discuss why the team is making the migration incrementally and why this is relevant to other high-performance engineering teams doing filesystem work debating Rust or Go. Use a witty, but chill voice.
---

Nathan:

- Organizational
 - Our team wants to write Rust. We think it’s neat and it makes us happy. This alone is \*reason enough\* to do it as long as it aligns with other goals in our organization.
 - Hiring for Rust-interested web-focused engineers is easier than hiring for Go-interested web-focused engineers.
 - We want to work with the Turbopack people and primitives. Creating our own internal “library” of code gives us the ability to row the boat together. We have similar needs and problems that aren’t addressed \*anywhere else\* and it’s important to go together as a team. (Go fast? Go alone. Go far? Go together.)
- Community
 - There is a \*strong\* interest in Rust from the JavaScript community. This makes it more-accessible for people coming from JS-tooling-in-JS land, and enables community contributions.
 - We have had little engagement from the Go community in our projects, and few occasions to interact with them in external code. Not unexpected, but we’d like to build a community and we believe that we can be successful with that in Rust.
- Ecosystem
 - The Node.js ecosystem is absolutely massive. Almost anything you need has been written in JS, or is forkable. We come from this world, and this is the expectation we have for depth, breadth, and maintenance.
 - The Rust ecosystem has a few extremely-high-quality core pieces that are in \*everything\*. `serde` is a work of art. `rayon` is fantastic. Those serve as foundational tools that have \*solved\* entire problem spaces in a consistent way for the entire community.
 - Algorithm research happens in Rust, not Go. New toys show up, implement a trait, and poof, they’re in your codebase.
 - The Go ecosystem is not easily discoverable and feels very dead. People regularly write one-off solutions to general problems. Most of the best things are Google-authored and fit with Google’s worldview, but not necessarily everybody else’s.
 - The Go ecosystem has frequently-used yet poorly-maintained libraries that are a core part of the experience (e.g. afero). spf13 “Holowaychuk'd” the Go ecosystem and then disappeared (and recently stepped away from Google and Go entirely).
 - The “correctness” quotient of libraries in Go is somewhere between JS and Rust. Not good enough to be 100% reliable, not as flexible as JS when you need to duckpunch something.
- C Interop
 - As you get deeper and deeper into Go you start to discover that the best way to do certain tasks is to bind to a C library. zstd, libgit2, regular expressions, and more. This means that, \*even without Rust adoption\*, we were going to lose some of the development experience wins of Go.
 - This works “just fine” but the real point here is, once you’ve got a compiler toolchain setup for each of your targets for CGO, there’s little to prevent you from also making the small hop over to Rust. (Once we can compile with CGO, we can \*also\* compile to `c-archive` and have Rust call our Go code.)
- Go Language Design and Priorities
 - Go is designed for network computing run in data centers. It \*excels\* at that. The ecosystem of libraries available in that space are of super-high quality. `context` is a work of art.
 - In comparison, Go shipped a read-only filesystem abstraction a couple years ago. It’s still read-only. Why? You don’t write to filesystems in a (Google) data center environment.
 - Our use case doesn’t align with the Go maintainers’ needs and use cases. That leads to needing to roll our own (lots of things) because they’re not a priority to address at language level.
 - No MSVC support.
- Rust Language Design and Priorities
 - Rust has prioritized correctness over convenience. Paths? Not as easy to use, because the underlying primitive is not easy to use. It returns the complexity to the programmer to explicitly handle correctly. But we care about precisely that in a world where basically 90% of what we do is path handling.
 - In general we believe it is better-suited to ship Rust to a hostile environment like a user’s box than Go. Go’s stdlib “aligns” a lot of behaviors that can’t \*actually\* be aligned between platforms—most specifically around filesystem APIs … again a place that we care about.
 - Is able to build on the MSVC toolchain.
- Vision
 - We want to, with localized heating, boil the JS ocean. (Starting at the places where people are, and slowly moving to boil the whole ocean.) We want to bring full incremental computation all the way from dev time into production. We’re working backward from production with Turbopack, and forward from the build tool with Turborepo. The next iteration of this is “infinitely granular DAG which includes the whole ecosystem.” Nobody else appears to be attempting that granularity.
 - Success here is a \*massive\* moat, possibly insurmountable. For context I would have said the same thing about C compilers, but Clang and LLVM have done it over the last 20 years. But 20 years is one hell of a moat and we can respond a lot faster than 20 years to maintain that separation.
 - Being the stewards for the community primitives (in this case `turbo` … which is what happens after repo/pack merger) gives us the ability to push the \*entire\* ecosystem forward, slowly increasing what is possible to even attempt.
- Future
 - We believe that Rust is where the puck is heading. We want to help it get there, and be ready when that future arrives.

Nicholas:

- Reasons for Rust
 - Performance
 - Not \*really\* valid because performance issues are less language constricted and more inherent architecture issues.
 - But maybe true? Too early to tell.
 - Ecosystem
 - IMO stuff like serde, swc, clap, etc. are good reasons to use Rust.
 - Go has separate interfaces for every text format (toml, json, yaml, etc)
 - Being able to use cargo to share code with the Turbopack people
 - Standardization with turbopack
 - Opens up a future for a whole suite of tooling in Rust
 - Our version of Rome (obviously don’t say that directly) (do we want to talk about future plans?)
 - Eventually use Turbopack’s graph infrastructure (maybe)
 - Go problems
 - Go and Windows.
- Reasons against Rust
 - Slows down shipping velocity
 - We’ve done a really good job of limiting this. We’ve slowed down our shipping a little but still done a great job incrementally moving and keeping our existing users.
 - Ecosystem limitations
 - Globbing libraries are still a mess. Won’t match JS globbing behavior
 - Hard to determine standard practices
 - You will have less than ideal code.
 - The orphan rule will bite you.
 - Hiring isn’t hard, but the most senior rust developer you can find will have like 5 years of Rust experience, max.
 - Very easy to bike shed with macros, traits, funky types, refactoring, etc.
 - Just because Rust lets you refactor easily doesn’t mean you should.

Greg

Consolidating some points shamelessly stolen from above

- Rust Positives
 - JS ↔ Rust interop is a good story, technically and community-wise
 - Rust ↔ C is a good story, and we use some tools written in C
 - Rust is growing at Vercel and with NextJS, specifically
- Go Negatives
 - The Go ecosystem is all-or-nothing. Once you need to make use of functionality not written in Go, you lose a lot of the benefits of having been in Go. What we lose:
 - Easy cross-platform static binary generation
 - Compilation speed (still better than rust tho)
 - Writing portable code is hard \*and\* not a focus of the ecosystem.
 - Conditional compilation support is basic
 - Platform-related APIs are either least-common-denominator or fudged to look cross-platform
 - Mismatch with community priorities
 - The Go community seems focused on being the best tool for writing an RPC server.
 - `Context` and goroutines are great primitives for request-scoped work within a long-running process.
 - Getting an HTTP server up and running is easy, and GRPC and protobuf is not much harder.
 - Such software is often intended to run on a single platform, or does not interact significantly with the host platform, so a workflow such as developing on `macos` and deploying on `linux` is the straightforward happy path.
 - Interop with other ecosystems is not a priority.
 - `turbo` is a cross-platform CLI tool that interacts heavily with the local filesystem and process tree.
 - Some of the best tools for filesystem interactions are written in C, so interop is important
 - Differences exist between different platforms, we as developers need those differences surfaced to us so we can handle them appropriately.
 - 

Anthony’s notes from talking to Greg:

- not necessarily about language features, let’s break some new ground
- moreso about what we are buliding doesn’t align with the problem we’re trying to solve
- Go is good for RPCing and webservers and that’s what the ecosystem cares about
 - Go will lie to you about platform specific differences (an ecosystem and community mindset)
- we want good interop with JS, interop with OS’es, platform specific stuff
- The JavaScript community is spending time learning Rust right now
- Globbing and performance stuff is pretty meh, those are language specific features
-
user
Title: **Why Turborepo is Migrating from Go to Rust (And Why You Should Care)**

Hey there, Hacker News denizens!

Buckle up, because we've got some juicy insider info for all you high-performance engineering aficionados. The Turborepo team is making a gradual shift from Go to Rust, and we're here to tell you why – with a sprinkle of wit and a dash of chill.

First and foremost, let's address the elephant in the room: the team *wants* to write Rust. It makes our developers happy, which alone is a compelling reason when aligned with our org's objectives. But there's more to the story than just chasing the shiny new thing.

**Hiring and Community**

It turns out that hiring Rust-interested, web-focused engineers is way easier than finding their Go-loving counterparts. Plus, the Turborepo and Turbopack teams have similar needs and problems, and collaborating in Rust simplifies that synergy.

Let's not forget the community aspect, either. With strong interest in Rust from the JavaScript community, our move opens up opportunities for collaboration and community contributions.

**Ecosystem and Libraries**

The Node.js ecosystem is massive, yes, but the Rust ecosystem is growing fast, with some incredibly high-quality core libraries like `serde` and `rayon`. Oh, and did we mention algorithm research tends to happen more in Rust than in Go?

The cherry on top? The Go ecosystem isn't exactly thriving and has some frequently-used, yet poorly-maintained libraries that can be a real pain.

**C Interop and Language Design**

Go likes to play nice with C libraries, but once you dive deeper, you realize it's not as clean-cut as you'd think. If we're already knee-deep in C, why not make the leap to Rust?

Rust's language design emphasizes correctness over convenience, which aligns with our needs – particularly path handling. Plus, when it comes to shipping code to a user's environment, we think Rust is the better option.

**The Vision and the Future**

Our grand plan involves incremental computation from dev time to production. We're working toward an infinitely granular DAG that encompasses the entire ecosystem – nobody else is attempting that level of granularity. And, oh boy, is that one heck of a moat we're building.

Rust is where the future is heading, and we want to steer that ship. By being early adopters and building the tools we need, we're setting the stage for a powerful, community-driven infrastructure.

**Why Incremental Migration Matters**

Now, you might be wondering why we're taking this slow and steady approach to migration. The answer is simple: we don't want to disrupt our existing users while we work on building this new future. By moving incrementally, we can keep our current users happy while positioning ourselves for success in the long run.

So, there you have it – a witty, chill breakdown of why Turborepo is embracing Rust. Whether you're a die-hard Go fan or a Rustophile, it's an exciting time for high-performance engineering and filesystem work, and we're looking forward to blazing this trail together.

Happy hacking, fellow Hacker Newswers! 🚀🤘🎸
assistant