All of a sudden, the Rust programming language fell into a series of deprecations.

As a systems programming language, Rust focuses on security, especially concurrency security. It supports multi-paradigm languages with functional and imperative programming paradigms and generics, and is syntactically similar to C and C++.

Photo source: https://x.com/ThePrimeagen/status/1875592777440084416

At the end of December, Daniel Stenberg, the founder of curl, a well-known open source project, announced that he would drop support for the Hyper HTTP backend written in Rust and remove the associated code completely. The move has attracted a lot of attention from the developer community.

The journey is coming to an end. The experiment is over. We tried, but we failed.

In 2020, Stenberg began adding support for another HTTP backend to curl, using a library written on Rust called hyper. His idea was to introduce an alternative internal HTTP implementation that curl/libcurl could use instead of the native implementation. The goal is to provide curl users with a more secure HTTP backend implementation with Rust's memory security.

The initial work was generously sponsored by ISRG, the organization behind excellent work such as "Let's Encrypt." Stenberg worked closely with hyper lead developer Sean McArthur and made great progress. So far, Stenberg has offered hyper support in curl under the EXPERIMENTAL tag, hoping to capture users' interest and spark their spirit of experimentation.

Stenberg says they're 95 percent done, and almost the entire test suite runs the same way, regardless of which backend is used when building curl. However, it was those last few percent that turned out to be the biggest resistance, leading to project failure, abandonment, and total withdrawal.

Why is that? To sum up, there are mainly two reasons.

On the one hand, almost no one wants it, curl users have no interest in hyper. Existing hyper users also don't care if it's compatible with curl.

On the other hand, the libcurl library is written in C and hyper is written in rust, and you need a C glue layer between the two. This requires developers who are proficient in both C and Rust to delve into the relevant architectures and protocols to move the project forward. The reality is that there is a dearth of such developers.

Therefore, since hpyer work is not expected to be completed in the short to medium term, and the cost of retaining code is too high, this code can only be reduced to provide flexibility and reduce complexity.

While hyper's experiment itself failed, Stenberg thinks they learned some lessons from it and improved curl along the way. When the hyper project started in 2020, the Rust language itself wasn't ready. Over time, Rust has now improved to become a better language and can serve projects like Hyper-better.

In addition, after dropping hyper, curl still has two experimental Rust-written backend support, rustls (for TLS) and uiche (for QUIC and HTTP/3). Both backends use better internal apis in crul and hook into libcurl in a cleaner way, making them easier to support and less of a burden than hyper.

hyper's super backend code has been removed from git, and no trace of it will be left when curl 8.12.0 is released in February 2025.

But while hpyer has been removed, Stenberg is open to introducing a secure back end written in Rust or another language in the future. It's going to be a little bit different, because they have a much better internal architecture now than they did when they started hyper in 2020.

Coincidentally, in early December, Prisma, another open source database toolchain project, said it would migrate from Rust to TypeScript in pursuit of a better plugin and extension ecosystem.

Prisma's architecture has historically limited community contributions, and its core functions (such as query parsing, validation, and execution) are managed by the Rust engine, which is opaque to the TypeScript focused community. So the decision was made to migrate Prisma's core logic from Rust to TypeScript, and to redesign ORM to make customization and extension easier.

Rust has been on the rise in recent years, climbing the ranks of some programming language rankings, such as the 2024 IEEE Top programming languages list, Rust ranks very high. There is also a strong call to replace C and C++ with Rust.

While Rust is powerful and unique in terms of security, it is also relatively expensive to learn. In a survey on "What's stopping you from learning Rust in 2025", someone threw out a powerful point: his most used C/C++ library is the best in its class, with decades of development experience behind it. With Rust, he would either go to great lengths to keep using it, or use some random, unknown package with no pedigree. Others think that Rust syntax looks ugly.

Photo source: https://x.com/kai_fall/status/1875549570513658212

It took me 18 months, and I'm full of regrets

In fact, in early 2024, a Medium article recounted how the author spent 18 months rebuilding his algorithmic trading platform in Rust. It took a lot of thought, but I ended up regretting it. Take a look at what happened to Austin Starks in the process.

At the beginning of the article, Austin said that he was very optimistic about Rust, and even a fan of Rust. Rust seems to be one of the fastest and most secure programming languages out there. Of course, he found that he was not alone. If you read an article about the Rust programming language online, you're likely to encounter overwhelmingly positive reviews. Every guide on Medium, every Reddit post, every Stack Overflow answer - everything celebrates it.

This was the beginning of the story, or "nightmare," when Austin decided to abandon TypeScript and rewrite his entire open source algorithmic trading system into Rust.

In fact, this bad experience has a long history. Earlier, Austin wrote about his experience with Rust. He said at the time that while he liked Rust's speed and some of the language design, he didn't really like the language at all. But as soon as the article was published, it was roundly criticized. One highly praised comment even accused Austin of writing his article in ChatGPT. This is clearly the biggest criticism of text creation in the AI era.

Austin reflected, perhaps because he hadn't given Rust enough opportunities. He decided to stay with Rust for a while longer. After using it, he was finally able to confidently conclude:

This language just sucks!!

What's wrong with Rust?

Austin summed up his dislike of Rust in a few words: bad, verbose, incomprehensible syntax and semantics.

A complex Rust function example

Austin quipped that anyone who says Rust's semantics aren't bad is lying. Without a large, very powerful language model, there are many things that cannot be done when writing functions. He didn't want to spend 90 minutes figuring out the where clause in the run_transaction function. Eventually, he gave up on the idea of using helper functions altogether because it was impossible to get the code to compile. What people say is Rust's biggest strength (a strict compiler to eliminate errors) is Rust's biggest weakness.

As an example, Austin said that if you were to write the exact same function in Go, the code would look something like this. While the core structure of the function remains relatively unchanged, the code works as intended without too many complex tweaks, tricks, or trial and error.

Functions implemented by Go

Rust seems to have some advantages when it comes to error handling. As long as you avoid using unsafe unwrap to reduce runtime errors (such as null pointer exceptions), you can be sure that your code will run and continue to run. Is that really the case? Austin: No!

He points out that when data goes wrong or something unexpected happens, it can be difficult for developers to diagnose the problem quickly, because error messages are often not intuitive enough and it can be difficult for developers to understand the root cause of the error. He quipped that he might not have found the right way to enable stack tracing, making debugging more difficult.

Austin: Where is my stack trace??

In contrast, Python can provide stack traces that tell you exactly what happened, down to the line number. Austin said that even in Go, there are errors.Wrap (...) Allows you to view the entire error stack. Clearly, this is a design flaw in Rust.

In addition to Rust's design flaws, the community atmosphere is difficult to comment on. Austin says the community can't accept the idea that Rust is flawed. Opinions expressed will be attacked, and questions asked will only yield negative results.

The "helpful" responses Austin received from the Rust community