Sources

The other biggest worries were that Rust may become too complex (41.6% in 2025 versus 45.2% in 2024) and that the developers and maintainers of Rust are not properly supported (38.4% in 2025 versus 35.4% in 2024). The survey also asked developers which aspects of Rust present non-trivial problems to their programming productivity. Here slow compilation led the way, with 27.9% of developers saying slow compilation was a big problem and 54.68% saying that compilation could be improved but did not limit them. High disk space usage and a subpar debugging experience were also top complaints, with 22.24% and 19.90% of developers citing them as big problems. … - 91.7% of respondents reported using Rust in 2025, down from 92.5% in 2024. ... - Generic const expressions was the leading unimplemented or nightly-only feature that respondents in 2025 were looking to see stabilized, with 18.35% saying the feature would unblock their use case and 41.53% saying it would improve their code.

- Rust’s learning curve remains a barrier. Among the 358 respondents who don’t use Rust, 22 % called Rust “too difficult to learn,” with word-clouds full of “syntax,” “confusing,” and even “toxic.” - Compile times and disk usage remain major complaints: 17% say slow compilation is a serious problem, and 34% say it could be significantly better.

#### 1. Lack of Library Support: While Rust’s standard library is comprehensive, it may not have the same level of library support as more established languages like Python or JavaScript. This can make it more difficult to find pre-built libraries or tools for tasks that are commonly handled in other languages. #### 2. Limited Dynamism: Rust is a statically typed language, which means that it can be less flexible than dynamically typed languages like Python or JavaScript. This can make it more difficult to handle certain types of programming tasks or edge cases. #### 3. Limited Support for Object-Oriented Programming: While Rust has some support for object-oriented programming (OOP), it is not as robust as the support found in languages like Python or Java. This can make it more challenging to write large, complex OOP applications. #### 4. Limited Support for Functional Programming: While Rust has some support for functional programming, it is not as comprehensive as the support found in languages like Haskell or Lisp. This can make it more difficult to write pure functional programs or to use functional programming patterns extensively. #### 5. Limited Support for Multithreading: While Rust has some support for multithreading, it may not be as robust as the support found in languages like C++ or Java. This can make it more challenging to write complex multithreaded applications. #### 6. Limited Support for Generic Programming: While Rust has some support for generic programming, it may not be as comprehensive as the support found in languages like Haskell or TypeScript. This can make it more difficult to write generic programs that can handle a wide range of data types and patterns. #### 7. Limited Tooling Support: While Rust has a growing ecosystem of tools and libraries, its tooling support may not be as extensive as the support found in more established languages like Python or JavaScript. This can make it more challenging to use Rust for certain tasks or projects that require extensive tooling support. #### 8. Compile Time: Rust’s compile-time evaluation can sometimes result in slower compilation times compared to interpreted languages like Python or JavaScript. While this can be mitigated with optimizations, it may still be a consideration for developers who need quick turnaround times.

### 2.2 Growing Maintenance Cost: Maintaining big C++ codebases is famously challenging. Technical debt increases in magnitude as projects grow, particularly in codebases spanning decades and through several iterations and ownership changes. Maintaining C++ at scale runs a risk and a resource drain without consistent formatting, modern language features, and safe concurrency primitives. Particularly for new teams inheriting legacy systems, Rust’s expressive syntax, rigorous compile-time checks, and community standards help to lower long-term maintenance costs and increase team productivity. ### 2.3 Challenges New Developer Onboarding: Modern developers—especially those from languages like Python, JavaScript, or Go—often find C++ antiquated, difficult, and hostile to newbies. The syntax is difficult, the error messages are vague, and even writing basic, safe programs can call for thorough understanding of memory management. Rust, while stringent, offers a substantially more supportive developer environment. It actively guides new programmers toward writing safe, idiomatic code. … ### Where Rust Falls Short: - **GUI Development:** While efforts like egui, iced, and druid exist, Rust lacks a mature, cross-platform GUI framework equivalent to Qt or Electron. - **Mobile Apps:** Rust doesn’t yet offer first-class support for iOS/Android app development out of the box. - **Rapid Prototyping:** The compiler’s strictness might slow down fast iteration, especially for scripting-style workflows.

The 2025 State of Rust Survey, based on 7,156 responses collected in late 2025, reveals that while 57.6% of Rust developers are satisfied with the language's pace of evolution, three major concerns dominate: insufficient industry adoption (42.1%), growing language complexity (41.6%), and inadequate support for maintainers - #rust •3m read time• From infoworld.com

There were multiple failures before that `unwrap()` and the argument can easily be made that this is no different than an unchecked exception or a release assertion. > Sync/Send, Mutex and reference counting (Arc)? Unfortuantely, those lock or simply mess with CPU caches badly, so they are inefficient for multithreaded communication, at least an intensive one. They are safe, but inefficient. Which kinda destroys the first uncompromising thing in Rust — performance. … There’s a handful of pain points that the Rust model does impart which are not fundamental. For example, unsafe code is required to get a mutable borrow to two different fields of a struct at the same time. But really that’s the only example I can think of offhandedly, and I expect there are not many in total. Nearly all of the pain is merely the trouble of thinking through these issue upfront instead of kicking the can down the road. … ... 1. Previous claims that Rust code often just works after compiling. 2. Previous claims that low-level error-handling idioms like matching, using Result, etc improve code reliability. 3. Previous claims that using unwrap in example code is ok for brevity. Also, Rust developers would know not to use it in production code. 4. The fact that significant portions of the internet were taken down because a production unwrap from a big, mature player and one of the Rust early adopters. … However, this article is overall not at the level expected of Rust anti-fans in 2025. I commend the author for trying, but they need to improve in several areas like providing iron-clad real-world examples, proving the required level of experience, focusing more on pain points like dependencies and the potential for supply-chain attacks, addressing reskilling issues and internal corporate politics, etc. There was a blog by a veteran Rust game developer a while back which single-handedly destroyed the enthusiasm for Rust in gaming. That is the gold standard of Rust criticism for me. … - Mutable shared state: make bad designs hard to write. Mutable shared state is another one of these eternal bug sources. Use channels and pass messages. Honestly, it reads like a lot of critiques of Rust: people haven't spent enough time with it, and are not over the learning curve yet. Of course everything is cumbersome before you're used to it. … > Honestly, it reads like a lot of critiques of Rust: people haven't spent enough time with it, and are not over the learning curve yet. Exactly. I’ve spent years with rust and my complaints are very different. Well, I still wish it compiled faster but all the other stuff is noobie problems. As someone with more experience, my frustration points are things like how async blocks do compiler magic you can’t write yourself. I hate unnameable types. I think Pin is confusing and weird. And the syntax for interacting with raw pointers is unnecessarily inconvenient and ugly.

3. The fact that for reasonable compile time you need to split projects into lots of small crates. Again, I understand the reasons, but the result sucks and we can definitely do better. As I understand it this is because crates are compiled as one compilation unit, and they have to be because circular dependencies are allowed. While that is true, I expect most code doesn't actually have circular dependencies so why not make those opt-in? Or even automatically split items/files within a crate into separate compilation units based on the dependency graph? … We see it time and again across anything that has two implementations. The pace of development is pretty good, to the point where one of the main criticisms of Rust is that it moves too quickly. The stability is pretty good, I can only remember one time when code was broken. Compile times are mediocre but three ambitious projects hope to tackle that - parallel frontend, cranelift backend, changing the default linker to a better one(landing next month). … themafia 3 months ago ... The TOML configuration format is weak and it's easy for things like namespaces and features and optional dependencies to get severely complex rather quickly to the point that it's easy to introduce subtle bugs or create a fragile configuration. The requirement to use semver, which may work for a lot of projects, but is not necessarily the best when dealing with software that deals with regulatory compliance issues. The version number is sometimes a product of multiple considerations. Unless you want to publish a page that helps users understand how versions map onto regulatory calendars. … reallydifficult though, and requires you to commit to certain implementation details without ever changing them, so I can understand why it’s not a priority. To my knowledge the only success stories are Swift (which faced the problem head-on) and COM (which has a language-independent IDL and other pain points.) ObjC has such extreme late binding that it almost feels like cheating. If rust had a full-featured ABI it would be nearly the perfect language. (It would improve compile times as well, because we’d move to a world where dependencies could just be binaries, which would cut compile times massively.)

While it is great to see some developers being happy with the state we have today, it is clear that many people are not so lucky, and Rust's build performance limits their productivity. Around 45% respondents who answered that they are no longer using Rust said that at least one of the reasons why they stopped were long compile times. … ## Important workflows ... Waiting too long for an incremental rebuild after making a small source code change was by far the most common complaint in the open answers that we received, and it was also the most common problem that respondents said they struggle with. Based on our respondents' answers, this comes down to three main bottlenecks: … **The linking phase is too slow.** This was a very common complaint, and it is indeed a real issue, because unlike the rest of the compilation process, linking is always performed "from scratch". The Rust compiler usually delegates linking to an external/system linker, so its performance is not completely within our hands. However, we are attempting to switch to faster linkers by default. … - **Incremental rebuild of a single crate is too slow.** The performance of this workflow depends on the cleverness of the incremental engine of the Rust compiler. While it is already very sophisticated, there are some parts of the compilation process that are not incremental yet or that are not cached in an optimal way. For example, expansion of derive proc macros is not currently cached, although work is underway to change that. ... To gauge how long is the typical rebuild latency, we asked our respondents to pick a single Rust project that they work on and which causes them to struggle with build times the most, and tell us how long they have to wait for it to be rebuilt after making a code change. [PNG] [SVG] Even though many developers do not actually experience this latency after each code change, as they consume results of type checking or inline annotations in their code editor, the fact that 55% of respondents have to wait more than ten seconds for a rebuild is far from ideal. … ### Clean and CI builds Around 20% of participants responded that clean builds are a significant blocker for them. In order to improve their performance, you can try a recently introduced experimental Cargo and compiler option called `hint-mostly-unused`, which can in certain situations help improve the performance of clean builds, particularly if your dependencies contain a lot of code that might not actually be used by your crate(s). One area where clean builds might happen often is Continuous Integration (CI). 1495 respondents said that they use CI to build Rust code, and around 25% of them consider its performance to be a big blocker for them. However, almost 36% of respondents who consider CI build performance to be a big issue said that they do not use any caching in CI, which we found surprising. … ## Understanding why builds are slow When Rust developers experience slow builds, it can be challenging to identify where exactly is the compilation process spending time, and what could be the bottleneck. It seems that only very few Rust developers leverage tools for profiling their builds:

Overall, developers using Rust are satisfied with Rust compilation performance, but slow builds and rebuilds in several common workflows limit the productivity for a significant fraction of Rust users, according to the Rust Compiler Performance Survey, which was conducted the past two months by the Rust compiler performance working group. … “While it is great to see some developers being happy with the state we have today, it is clear that many people are not so lucky, and Rust’s build performance limits their productivity,” said Jakub Beranek on behalf of the working group. “Around 45% of respondents who answered that they are no longer using Rust said that at least one of the reasons why they stopped were long compile times.” The survey found that the Rust build experience “differs wildly across users and workflows” and is not as clear-cut as “Rust builds are slow,” Beranek said. “We actually received many positive comments about users being happy with Rust build performance, and appreciation for it being improved vastly over the past several years to the point where it stopped being a problem.” But some survey respondents said the build performance of Rust was inferior to languages such as Go or Zig. ... Other findings of the Rust Compiler Performance Survey: - Waiting too long for an incremental rebuild after making a small source code change was by far the most common complaint in open answers received. - The incremental build of a single Rust compilation crate was too slow. - Several users mentioned that they would like to see Rust perform hot patching. - When Rust developers experience slow builds, it can be challenging to identify where exactly the compilation process is spending time, and what the bottleneck could be.

Our interviews with 70+ developers across all experience levels tell a different story. While beginners struggle with ownership concepts, experts face domain-specific challenges—async complexity for network developers, certification gaps for safety-critical teams, ecosystem maturity issues for embedded developers. Even more concerning, we discovered evidence of "silent attrition"—developers who quietly abandon Rust not because they can't learn it, but because the accumulated friction makes them less productive than they'd like to be. … ### Compilation performance: the universal productivity tax **Every single cohort** we analyzed—from novices to experts, from embedded developers to web developers—cited compilation times as a significant barrier to productivity: > "Java takes about 100 milliseconds, Rust anywhere from 5 seconds to a minute depending on what you changed" -- Distinguished engineer working on backend systems at a large company > "8 to 10s iteration cycle... when you want to tweak the padding on a box" -- GUI development team The impact varies by domain, but the pattern is consistent. CLI tool and GUI developers, who need rapid iteration cycles, are hit hardest. Safety-critical developers with 25-30 minute build times face workflow disruption. Size-constrained embedded developers are forced into optimized builds that take longer to compile and complicate debugging. What's particularly important to note, is that this isn't just about absolute build times; it's about the **development velocity tax** that compounds over time. Long compile times can have strong negative impact on code iteration time. Anything that can reduce this code iteration time - hot reloading, fast debug builds, faster linking - will have an outsized impact on development velocity. Moreover, the compilation performance tax compounds at scale. Individual developers might tolerate 5-10 second builds, but teams with CI/CD pipelines, large codebases, and frequent iterations face exponentially worse impacts. One participant noted 25-30 minute builds that create "wait for 30 minutes before the tool finds out I made a mistake" cycles. ### The borrow checker: first it's sour, then it's sweet The borrow checker is often touted as a "beginner problem", and we found that this is largely true: Novices are most strongly impacted by the borrow checker, but this often extends even into the stage where a developer is *comfortable* writing Rust where they *still* get tripped by the borrow checker sometimes. However, highly-experienced Rust developers basically never cite the borrow checker itself as a frustration for them. > Ownership: The first time I went through the chapter, I was really like, what is this? - Developer learning Rust as a first language > I actually did not understand the borrow checker until I spent a lot of time writing Rust - Executive at a developer tools company ### Async complexity: the "Three Horsemen" problem Multiple participants identified `async` as a pain point. Many people, not just beginners, often choose to completely avoid it, instead focusing on solely on sync Rust. This is because, for many, `async` Rust feels completely different. > My biggest complaint with Rust is async. If we want to use [a tool], we're forced into that model...not just a different language, but a different programming model... … ## How challenges amplify differently across domains While the core challenges are universal, different domains have unique challenges that ultimately must be either adoption blockers or acceptable trade-offs. ### Embedded systems: where every constraint matters Embedded developers face the most constrained environment for resources, which can amplify other challenges like learning. > "if you pull in a crate, you pull in a lot of things and you have no control" -- Embedded systems researcher > "can't use standard collections like hashmaps" -- Embedded software engineer Debug builds become too large for small controllers, forcing developers into optimized builds that complicate debugging. … ### Safety-critical systems: stability vs. innovation tension Safety-critical developers need Rust's memory safety guarantees, but face unique challenges around certification and tooling: > "we don't have the same tools we have to measure its safety criticality as we do in C++ and I think it's a worry point" -- Safety systems engineer > "not a lot of people know Rust not a lot of managers actually trust that this is a technology that's here to stay" -- Safety-critical developer on organizational barriers The tension between Rust's rapid evolution and safety-critical requirements for stability creates adoption barriers even when the technical benefits are clear. … ### GUI development: compile times inhibit iteration speed GUI developers need rapid visual feedback, making compilation times particularly painful: > We've got a UI framework that's just Rust code so when you want to tweak the padding on a box ... it's a pain that we just kind of accept a 10 seconds or more iteration cycle. -- Developer … ## Conclusion (not done yet) Rust's challenges are more nuanced than the conventional "steep learning curve" narrative suggests. They're persistent, evolving, and domain-specific. Most importantly, they compound in ways that can create silent attrition even among developers who successfully learn the language. Understanding these patterns is crucial for Rust's continued growth.

We landed long-awaited features in 2025 (`let chains` and `async closures`) and the survey results show that they are indeed very popular and often used. That's something to celebrate! Now `generic const expressions` and `improved trait methods` are bubbling up in the charts as the most-wanted features. Most of the other desired features didn't change significantly. [PNG] [SVG] [Wordcloud of open answers] When asked about which non-trivial problems people encounter, little changes overall compared to 2024: resource usage (slow compile times and storage usage) is still up there. The debugging story slipped from 2nd to 4th place (~2pp). We just started a survey to learn more about it!

However, Rust is not all sunshine and rainbows. There are real pain points that need to be addressed if Rust wants to compete with other popular programming languages. Many of these pain points are well known (slow compile times, steep learning curve relative to other languages, etc) and I do not have much to add. But I do want to explore a topic that is less talked about but is very important in my mind. … ## Onboarding Friction Rust has a reputation for being difficult to learn/use compared to “higher” level languages like Javascript and GoLang. I feel this is a bit overblown, especially for modern Rust. Personally I find that I am nearly as fast if not faster in coding in Rust as I am in other languages. However, I did find the learning experience quite difficult compared to other languages. … Every time we add a new keyword it adds more things for the user to be familiar with to understand what a program does. The Rust type system gives the user many ways to express their problem, which is great but comes with the drawback of increasing burden to understand code that you did not write. I sometimes feel this in code reviews when the author uses a syntax that I do not commonly use. … I find that I often desire improvements to existing Rust features rather than new features entirely. A great example of this is the “Async Rust”. Async Rust is not a new feature, but it still does not feel “complete”. Async traits are still not dyn comptaible without using async_trait, Async closures (this was stabilized in Rust 1.85), Async Drop is still unstable. In 2025, I am the most excited about the project goal to refine async rust. ## Tooling Features Until now, I have been primarily talking about language features and not the greater Rust ecosystem. I have a very difficult perspective on adding new features to tools in the Rust ecosystem. Above I argue that introducing language features make the language more complex and introduces development friction when working in a team. For tooling features, this usually does not apply. For example, `cargo build` hides a lot of the complexity of interacting with `rustc` and makes Rust development vastly more approachable. Most tooling features reduce the complexity of Rust users need to deal with on a daily basis.