Sources

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.)

Rust developers are worried the programming language may become too complex and that its popularity in the tech industry doesn’t quite meet expectations, according to new research. The Rust Project surveyed 9,710 developers worldwide, with the US, Germany, China and the UK accounting for almost half of respondents. ... ## Rust is a difficult programming language to learn However, the survey did identify less positive feedback. Of the survey respondents who did not use Rust, 31% said it was because it was ‘too difficult’ to learn or that it would take too long. Of the former Rust users who participated in the 2023 survey, 24% cited difficulty as the primary reason for giving up - although this does mark a drop from 30% last year. When asked ‘what are your biggest worries for the future of Rust?’ the majority (43%) were worried about Rust becoming too complex at 43% — up from 37% in 2022. Meanwhile 42% of respondents were concerned about a low level of Rust usage in the tech industry and 32% of respondents in 2023 were worried about Rust developers and maintainers not being properly supported. ##### RELATED WHITEPAPER ... When asked what features that Rust users want to be implemented or improved, 20% of respondents said that they wanted Rust to slow down the development of new features, which the report said “likely goes hand in hand with the previously mentioned worry that Rust becomes too complex”.

### 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

#### 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.

The release of Wild Linker 0.6.0, a fast linker for Linux written in Rust, garnered attention (333 upvotes) for its bug fixes and new features like RISCV64 support. Users are excited about its potential to become a default in Rust’s toolchain. Additionally, the serde_core crate’s restructuring to improve compile times (536 upvotes) reflects ongoing efforts to address one of Rust’s pain points—slow builds. Community members emphasized the global energy savings from such optimizations, even if runtime performance isn’t affected. … ## Controversies and Pitfalls ### Supply Chain Security Concerns A major controversy erupted around supply chain security following the discovery of malicious crates on crates.io (378 upvotes). Users expressed alarm over disposable accounts and attack vectors, with one commenter urging for better defenses before state actors exploit these vulnerabilities. The consensus is that while Rust’s model relies on trust, blind dependency upgrades and sprawling dependency trees (e.g., with tokio) pose significant risks. In downvoted discussions (-42 score), some argued for abandoning centralized repositories like crates.io in favor of vetted libraries akin to C++ practices, though this was met with skepticism due to Rust’s distinct ecosystem dynamics. **Takeaway:** Audit your dependencies regularly using tools like cargo-audit. Minimize reliance on lesser-known crates and consider contributing to community efforts for crate auditing to bolster ecosystem security. ### Learning Curve and Syntax Frustrations Rust’s steep learning curve continues to frustrate newcomers, as seen in posts like “How to think in Rust?” (80 upvotes) and downvoted threads expressing intent to abandon Rust over partial borrowing limitations (0 score). Users struggle with intuitive construct selection and syntax complexity, especially around self-referential structures and async ecosystems. Downvoted opinions often suggest Rust isn’t suited for OOP patterns, with critics feeling punished by the borrow checker compared to languages like C# or Java. **Takeaway:** Focus on Rust’s type system to model problems effectively—adopt the mantra “make invalid states unrepresentable.” For OOP challenges, use tools like std::mem::take to manage partial borrows, and seek community resources like No Boilerplate on YouTube for mindset shifts. ### Tooling and Ecosystem Fragmentation Tooling pain points, particularly with doctests (102 upvotes), reveal gaps in IDE support and integration with cargo check or clippy, making documentation testing cumbersome. Async ecosystem fragmentation—debated in posts wishing for a unified runtime (0 score)—also frustrates developers who juggle tokio, async-std, and runtime-specific quirks. **Takeaway:** Work around doctest limitations by drafting code in dummy functions before copying to documentation. For async projects, standardize on a single runtime (e.g., tokio) early in development to avoid compatibility headaches, and follow Rust’s async working group updates for future unification efforts.

**John:** Exactly—build times are a big issue. The InfoWorld article, published just 12 hours ago as of today (September 16, 2025), points out that while satisfaction is high overall, significant users report delays in common tasks like incremental builds or when using dependencies. This echoes the 2024 State of Rust Survey from the official Rust Blog, where developers noted compilation speed as a top concern, even as productivity has increased. ### Key Findings from the Latest Surveys **Lila:** What did the surveys actually find? ... **John:** Let’s break it down. The 2024 State of Rust Survey, released in February 2025 via the Rust Blog, showed that most developers worry about the language’s future due to complexity and slow compilation. For instance, 68% of respondents highlighted compilation times as a barrier, up from previous years. The newer InfoWorld piece builds on this, noting that in workflows involving large codebases or frequent changes, rebuilds can drag on, frustrating teams. From trending discussions on X (formerly Twitter), verified accounts like @rustlang have been sharing insights from RustConf 2025 in Seattle, where speakers from Microsoft and Amazon praised Rust’s security but admitted the learning curve and compiler speeds are hurdles. One post from @rust_discussions linked to the survey results, sparking threads about how enterprises are adopting Rust despite these issues—adoption surged 68.75% in enterprises this year, per Rust Trends newsletter. **Slow Builds:**Common in monorepos or when adding features, leading to wait times of minutes instead of seconds. **Rebuild Overhead:**Even small changes trigger full recompiles, which the survey calls a ‘big problem’ for 30-40% of users. **Dependency Management:**Cargo, Rust’s package manager, is great, but resolving and compiling crates (Rust’s libraries) adds up. **Error Messages:**While helpful, they can be verbose, making debugging feel overwhelming for newcomers. … ### Current Developments and Community Buzz **John:** Totally relatable, Lila. ... But challenges like complexity worry devs, as seen in the 2023 survey echoes from InfoWorld in 2024. … ### FAQs on Rust Compiler Pain Points **John:** Sure, let’s tackle a few common ones based on recent discussions. **Lila:** First, how can I speed up my Rust builds as a beginner? **John:** Start with Cargo’s –release flag for optimized builds, or use mold linker for faster linking. Community tips on Mastodon from February 2025 emphasize clean dependencies. **Lila:** What’s the biggest worry for Rust’s future? **John:** Per the surveys, it’s balancing features without bloating complexity. Devs want fixes, not frills, as noted in Medium’s March 2024 piece on Rust 1.77. **Lila:** Is Rust getting better at this?

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. … - 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.

The 2025 State of Rust Survey, published March 2, 2026, reveals a striking paradox: Rust developers rank compile times as their #1 complaint for the third year running, yet job postings doubled in two years and companies pay a 15.5% salary premium ($130,292 average) to hire Rust talent. Based on 7,156 developer responses, the survey confirms what enterprises already know—when reliability, memory safety, and performance are business requirements, developer convenience takes a backseat. ... Compile time remains developers’ #1 pain point. The Compiler Performance Survey 2025 found that “waiting too long for incremental rebuild after making a small source code change was by far the most common complaint.” Debugging satisfaction declined from 2nd to 4th place—a ~2 percentage point drop that prompted the Rust Foundation to launch a dedicated Debugging Survey in February 2026. … ## Ecosystem Maturity: Stable Releases and Rust-Native Tooling ... ## Pain Points Persist: Compile Times and Onboarding Costs The survey’s honesty about friction validates community transparency. Compile time bottlenecks remain specific and technical: workspace rebuilds trigger full dependent crate recompilation (not incremental across boundaries), the linking phase always runs “from scratch” without caching, and the incremental engine isn’t optimally cached across all compilation stages. The Rust team responds actively. ... Onboarding costs hit enterprises hard. “When enterprises hire 50 backend engineers in a quarter, the cost of onboarding them into Rust is massive, with most teams expecting months before someone can contribute meaningfully.” ... - **Pain points remain honest and specific**—compile times won’t disappear (inherent to safety), debugging satisfaction declined (dedicated survey launched), and onboarding takes months (not weeks)

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.

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!

## Although many users are satisfied with Rust build performance, a significant fraction of users report that slow builds and rebuilds in several common workflows are a ‘big problem’ for them. 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. ... Challenges developers face with Rust build performance were not always as simple as slow compiler performance, said Beranek. ... 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.