Rust

Malicious crates have been discovered on crates.io, with concerns about disposable accounts and attack vectors. Developers worry that blind dependency upgrades and sprawling dependency trees (especially with tokio) pose significant security risks that could be exploited by state actors.

Developers report that incremental rebuilds after making minor source code changes take significantly longer than expected. Workspace rebuilds trigger full dependent crate recompilation (not incremental across boundaries), and the linking phase always runs from scratch without caching, creating major productivity bottlenecks.

Python's accessibility flooded the market with junior developers, creating intense competition for entry-level roles. Companies migrate to Go or Kotlin for performance/type safety, and AI startups prefer Julia/Rust, leaving Python devs maintaining legacy models.

Mojo offers Python interoperability with C-level speed; Julia dominates scientific computing; Rust leads systems programming; Zig and WebAssembly-centric languages dominate edge/IoT. Python loses use-case ownership across domains.

When enterprises hire large teams of backend engineers, the cost and time to onboard them into Rust is substantial, with most teams expecting months before new hires can contribute meaningfully. This creates significant friction for rapid team scaling.

The linking phase is performed from scratch every time and is a major bottleneck in the build process. Since Rust delegates linking to external system linkers, performance improvements are limited, though the Rust team is attempting to switch to faster linkers by default.

The Rust compiler's incremental engine has gaps where certain compilation parts are not incremental or not cached optimally. For example, expansion of derive proc macros is not currently cached, causing unnecessary recompilation.

Rust lacks production-ready, cross-platform GUI frameworks equivalent to Qt or Electron. Existing efforts (egui, iced, druid) are immature, forcing GUI developers to choose between long iteration cycles or alternative languages.

Embedded developers cannot control what gets pulled in with dependencies, leading to bloat. Debug builds become too large for small controllers, forcing developers into optimized builds that complicate debugging and violate typical embedded workflows.

Async functionality feels like a completely different programming model from synchronous Rust, causing many developers to avoid it entirely. The complexity is cited even by non-beginners as a major pain point affecting framework choices and code architecture.

Rust lacks a full-featured, stable ABI, making it difficult to distribute dependencies as pre-compiled binaries. This forces recompilation of all transitive dependencies, significantly increasing compile times and preventing the binary-based dependency model used by many ecosystems.

Rust compilation is notably slower compared to other programming languages, creating friction in the development workflow and reducing developer productivity.

Developers successfully learn Rust but quietly abandon it due to accumulated friction and productivity concerns that compound over time, a pattern not captured by traditional learning curve narratives.

Developers struggle with async ecosystem fragmentation, needing to juggle multiple runtimes (tokio, async-std, etc.) with runtime-specific quirks and incompatibilities. There is no unified async runtime, creating compatibility headaches across projects.

Rust's debugging story represents a significant non-trivial problem for developers, with 19.90% reporting it as a big problem. This issue slipped from 2nd to 4th place in priority ranking from 2024 to 2025.

High disk space consumption is a significant non-trivial problem affecting Rust developers' productivity. 22.24% of developers report it as a big problem limiting their work.

Rust's steep learning curve frustrates newcomers, with common complaints about complex syntax, difficulty with intuitive construct selection, self-referential structures, and the borrow checker. Among non-Rust users surveyed, 22% cited Rust as 'too difficult to learn'.

Rust doesn't offer out-of-the-box, first-class support for iOS and Android app development, limiting adoption for mobile-focused teams and forcing reliance on workarounds or alternative languages.

Sync/Send semantics, Mutex, and Arc provide memory safety for concurrent code but have poor CPU cache behavior and performance characteristics, undermining Rust's performance-first positioning for intensive multithreaded applications.

Developers must split projects into many small crates to achieve reasonable compile times, since crates are compiled as single units and circular dependencies are allowed. This artificial fragmentation complicates project structure despite most code lacking true circular dependencies.

Generic const expressions is the leading unimplemented/nightly-only feature blocking Rust development. 18.35% of developers say it would unblock their use case and 41.53% say it would improve their code.

Rust's TOML configuration format, combined with complex namespace and feature flag systems, makes it easy to introduce subtle bugs and create fragile configurations, particularly problematic for projects with many optional dependencies.

Rust's support for object-oriented programming patterns is not as robust as languages like Python or Java, making it more challenging to write large, complex OOP applications. Developers struggle with OOP paradigms and feel constrained by the borrow checker.

When developers experience slow Rust builds, it is challenging to identify where the compilation process is spending time and what the bottleneck is. Very few Rust developers leverage build profiling tools to diagnose issues.

While Rust's standard library is comprehensive, it lacks the breadth of library support found in more established languages like Python or JavaScript. This makes it difficult to find pre-built libraries or tools for tasks commonly handled in other languages.

Documentation testing with doctests is cumbersome due to gaps in IDE support and poor integration with cargo check and clippy. This creates friction in the development workflow for maintaining code examples in documentation.

The requirement to use semantic versioning doesn't align well with software under regulatory compliance, where version numbers often reflect multiple regulatory and product considerations rather than pure API compatibility.

Rust's strict static typing makes it less flexible than dynamically typed languages like Python or JavaScript, creating challenges for certain types of programming tasks and edge cases that are easier in dynamic languages.

41.6% of Rust developers worry that Rust may become too complex, indicating concern about the language's trajectory and maintainability as it evolves.

38.4% of Rust developers worry that Rust developers and maintainers are not properly supported, indicating concern about the sustainability and resource allocation of the language ecosystem.

Getting mutable borrows to different fields of the same struct simultaneously requires unsafe code despite the compiler being able to verify memory safety, creating friction for common programming patterns.

42.1% of Rust developers are concerned that Rust does not get enough usage in the tech industry, despite the language's benefits. This remains the top worry among developers.

Rust's support for functional programming is not as comprehensive as languages like Haskell or Lisp, making it more difficult to write pure functional programs or use functional programming patterns extensively.