Products · Product
Rust
Raised as a usability problem by 640 people on Hacker News over 16 years (2011–2026), in 614 threads.
- 1
- 2Compiler takes too long on every runUnreviewed
- 1
- 2
- 3Compiler takes too long on every runUnreviewed
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 1
- 2
- 3Compiler takes too long on every runUnreviewed
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
- 22
- 23
- 24
- 25
- 26
- 27
- 28
- 29
- 30
- 31
- 32
- 33
Every issue, all time, most people first
Heavy sigil syntax makes code hard to readUnreviewed
20112026- Rust's lib.rs and mod system feels unintuitive and overly complex to use2026-05-25
- Hard to get started; non-trivial code often fails to compile unless written the Rust way2026-05-08
- Rust rejects code the author knows is correct, blocking progress while making games2026-03-08
Borrow checker forces contorted code, hurting readabilityUnreviewed
20112026- Verbose syntax and a borrow checker that feels dumb to the writer2026-10-20
- Lifetimes inside function bodies are opaque, so borrow checker errors appear suddenly and are hard to understand2026-03-08
- Forces constant rewrites and workarounds to satisfy the borrow checker2025-10-31
Compiler takes too long on every runUnreviewed
20112026- Compiling takes over a minute, making the feature edit-and-see loop very slow2026-05-26
- Slow compile times make the development experience sluggish and frustrating2026-05-07
- Compiling large Rust projects runs out of memory; tooling is hard to set up2025-12-12
Syntax fixes lead to whole-program rejections; errors hard to readUnreviewed
20112026- Remaining 10% of compiler errors are hard to understand for newcomers2026-03-21
- Error messages from compile-time code are nigh unreadable2024-03-24
- Compiler constantly nags about warnings and rules even when the user already knows the risk2023-05-18
Async requirement spreads through the whole codebaseUnreviewed
20112026- Async is so difficult to use that experienced programmers avoid it2026-04-26
- Async feels much harder to use than JavaScript's, with long rebuild waits2026-04-25
- Async abstraction hides what happens, making performance regressions hard to debug2025-03-30
Error handling is tedious; boilerplate and macros keep tripping people upUnreviewed
20112026- Error handling is tedious and confusing; boilerplate, macros and choices keep tripping the user up2026-05-24
- The one-character ? makes it too easy to skip adding error context2025-12-05
- Hard to use when the result is not passed directly to a function2025-02-03
Macros are hard to debug and error messages don't helpUnreviewed
20112026- Hard to understand code because of layers of macros and traits2026-03-09
- Debugging requires wading through many layers of traits, macros, and constructors to find where things are set2025-10-20
- Macro code is painful to read and write, and proc macros need a whole new crate2024-01-31
Type error messages point at the wrong typeUnreviewed
20112026- Type errors are inscrutable, involving Send/Sync and complicated trait hackery the author can't work out2025-03-19
- Error messages are unhelpful, hard to act on, and don't say what went wrong2025-03-13
- Error paths lack type information, forcing guesses from documentation about what functions do2024-09-14
Trait syntax and unclear errors make traits hard to understandUnreviewed
20112026- Type-level code with nested trait bounds is hard to read and understand2024-05-16
- Can't implement a foreign trait on a foreign type, forcing tedious newtype wrappers and fixing hundreds of errors2023-09-01
- Traits are hard to reason about, so writing code means guessing compiler incantations2023-02-14
Rust doc pages are confusing and cluttered for first-time readersUnreviewed
20112026- Lack of documentation causes friction for developers using graphics crates2024-06-25
- Makes unknown unknowns hard to discover, especially for newcomers to Rust2022-07-19
- Documentation often has no answers, or wrong ones, on how syntax and semantics work2021-07-26
Lifetime specifiers required without understanding, guessed by trialUnreviewed
20112026- Keeps getting lifetimes wrong; can't grasp them even after thinking they're understood2026-01-01
- Compiler rejects code and ownership and lifetime rules are hard to learn by trial and error2025-11-14
- Can't get the compiler to accept lifetimes for code the author considers safe2025-05-06
Lifetime annotations look confusing and seem pointlessUnreviewed
20112026- Lifetime annotations and symbols look confusing to untrained developers2025-03-02
- Code combining multiple generic types with lifetime markers is hard to follow2024-08-30
- Lifetime annotations are painful, magical, and very annoying to work with2023-11-09
Writing custom async streams is extremely difficultUnreviewed
20112026- Must understand Pin, Send, lifetimes and dynamic dispatch just to use async2025-12-03
- Async code gets wordy and exposes implementation details like Pin<Box<...>> too early2025-12-03
- Async has many footguns and ergonomic issues that make mistakes easy2025-11-07
Module system is confusing and hard to learnUnreviewed
20112026- Module system is confusing for beginners because it works backwards from #include2026-03-31
- Hard to understand how importing and defining modules works2022-09-13
- Module system feels very confusing at first2022-05-12
str and String are confusing to tell apartUnreviewed
20112026- Three string types make basic string manipulation hard for beginners, needing much reading and many compile failures2022-12-04
- Confusing difference between String and &str with poor explanations available2022-06-24
- Keeps confusing the two String types despite understanding them somewhat2022-05-19
Ownership constraints are hard to learn and behave unintuitivelyUnreviewed
20112026- Hard to reason about ownership once data doesn't fit the simple mental model2025-05-04
- Having to write ownership annotations is tedious and wastes time2024-02-15
- Ownership constraints are hard to learn and have unintuitive consequences2022-11-27
Can't predict when values get copied under borrow rulesUnreviewed
20112026- Move semantics aren't intuitive for programmers coming from C2026-01-01
- Can't tell whether borrowing patterns will work until compiler feedback arrives hours later2024-11-17
- Move versus copy behaviour depends on type, so it is hard to predict and confusing2023-01-03
Cryptic trait errors when sharing mutable state with asyncUnreviewed
20112026- Async code is harder to write due to recursion and trait limitations2024-07-16
- Restructuring closure-based code into loops and weird lifetime issues from async_trait macro2023-11-07
- Cryptic trait error messages when sharing mutable state with async code2023-10-26
Raw pointer code in unsafe blocks is hard to read and writeUnreviewed
20112026- Working with raw pointers in unsafe blocks feels like the language fights you, and the syntax is hard to read2025-11-14
- Converting strings to and from C strings is painful and forces unsafe blocks everywhere2024-09-06
- Unsafe code is much harder to write correctly than in C or C++2022-05-24
Pin's guarantees need unsafe code outside async fnUnreviewed
20112026- Hard to express borrow lifetimes in async code, forcing Box::pin or unsafe2024-05-02
- Pin is unintuitive to use and still requires unsafe code2020-07-12
- Pin's guarantee of never moving is counterintuitive compared to pinned-only-while-pinned2019-11-29
Lifetimes reject code that should work, unlike HaskellUnreviewed
20112026- Lifetime needing to bubble up far is non-intuitive to the programmer2023-08-28
- Lifetimes are more annoying to deal with than Haskell, and things that should work often don't2022-06-08
- Lifetime syntax is hard to learn and discouraged the commenter2020-06-06
Optimizing inefficient code requires advanced language featuresUnreviewed
20112026- Convoluted syntax makes programs hard to read and audit2024-10-18
- Optimizing inefficient code requires advanced language features, frustrating newcomers2020-01-21
- Syntax differs from C-like languages, adding learning overhead for newcomers2019-07-14
Handling Result errors neatly when calling sync code inside async is hardUnreviewed
20112026- One async error floods the console with many Send/Sync errors, burying the real syntax error2023-10-26
- Sync code that does I/O can't be used inside async code, so everything needs two versions2022-06-03
- Hard to handle Result errors neatly when calling sync code inside async2020-09-19
Constantly changing libraries make the right way hard to knowUnreviewed
20112026- Basic standard library methods stay unstable for years, forcing developers to rely on workarounds2026-08-11
- Recommended library docs are utterly incomprehensible, taking days to learn to use2023-01-04
- Too many changing libraries and practices make it hard to know the right way2020-04-11
Borrow checker blocks sharing mutable references across threadsUnreviewed
20112026- Borrow checker fights shared mutable references across threads, making multithreaded code hard to write2026-02-28
- Compiler errors on mutable borrowing across threads force long trial-and-error debugging2023-11-07
- Hard to get shared-memory code working; borrow checker can't be told the intended state after unsafe2022-11-23
Poor contrast and small fonts make links and labels hard to readUnreviewed
20112026- Page looks fancy but nothing makes sense; text is a waste of time2026-10-21
- Red text on black background is hard to read2023-09-18
- Poor contrast and small fonts make text hard to read; links and labels confusing2018-11-30
Obscure syntax and complex concepts block getting startedUnreviewed
20112026- Simple things are overly complicated and the syntax is not obvious2022-01-30
- Hard to learn: obscure syntax and complex concepts block getting started2021-03-19
- Tutorial pads basic syntax with long walkthroughs, so the key facts are buried2015-07-14
Generic arithmetic needs cumbersome trait bounds and casting workaroundsUnreviewed
20112026- Must hand-write many forwarding methods to delegate a trait to a composed type2025-05-08
- Casting between traits needs awkward super-traits and manual conversion methods2020-06-16
- Writing generic arithmetic over two types needs cumbersome trait bounds and casting workarounds2016-11-04
Controls don't match native look, theme or OS conventionsUnreviewed
20112026- Rust GUI libraries have non-native, buggy UIs and weak accessibility compared to Qt2026-09-11
- Pure Rust GUI libraries' controls don't match native look, theme or OS conventions2023-03-18
- Rust binary requires a newer glibc than the board has, and the user can't work out how to fix it2023-02-24
Easy to get dangling pointers and wrong trait impls without unsafe codeUnreviewed
20112026- Raw pointer handling is unintuitive and clutters the algorithm with extra concepts2026-07-25
- Easy to get dangling pointers and wrong trait implementations, with complex consequences, despite no unsafe code2026-04-22
- Dangling pointers from as_ptr are easy to create and their errors are subtle2021-04-09
Inconsistent semicolons make code harder to read and unsure if it compilesUnreviewed
20112026- Missing or present semicolons cause hard-to-understand errors in multiline functions2016-11-17
- Inconsistent semicolon use makes the code harder to read and unsure whether it compiles2016-02-07
- Subtle semicolon behavior will cause programmer bugs that are hard to track down2013-08-09
Switching struct fields to borrowed forces lifetime annotations everywhereUnreviewed
20112026- Lifetime syntax is non-obvious and hard to debug in borrowing structs2022-11-27
- Refactoring owned struct fields to borrowed ones forces lifetime annotations everywhere the struct appears2018-11-23
- Can't borrow one struct field while referencing another, forcing awkward restructuring of code2018-08-02
Unreviewed issues were grouped by machine: Claude Haiku labelled each comment as a usability complaint, named what it's about and summed up the problem in a line, and a small model grouped similar problems. Nobody has checked them by hand. Expect mistakes.
The newest 50 complaints
- Page looks fancy but nothing makes sense; text is a waste of time2026-10-21
- Verbose syntax and a borrow checker that feels dumb to the writer2026-10-20
- Combinator chains are hard to read and understand compared with simple loops2026-09-19
- Rust GUI libraries have non-native, buggy UIs and weak accessibility compared to Qt2026-09-11
- Safety rules force clone() and reference-counting spam, which hurts developer productivity2026-09-10
- Users must choose sandboxing levels they cannot understand without reading source code2026-08-21
- Basic standard library methods stay unstable for years, forcing developers to rely on workarounds2026-08-11
- Unstable features force projects into nightly-only builds and show unusable autocomplete suggestions2026-08-11
- Pin is so confusing that commenters got its semantics wrong2026-08-03
- Raw pointer handling is unintuitive and clutters the algorithm with extra concepts2026-07-25
- Writing basic structures like linked lists is painful; much more to learn than other languages2026-07-21
- Editor is so slow after saving that switching files feels like a different computer2026-07-16
- Crate boundaries force extra bridge and trait crates, adding ergonomic friction2026-07-09
- Waits on rust-analyzer re-checking code because it discards results instead of caching them2026-07-09
- Awkward to safely project a Cell down to the exact fields needed to mutate2026-07-01
- Generics limit monomorphization, forcing separate proc_macro crates for metaprogramming2026-05-26
- Compiling takes over a minute, making the feature edit-and-see loop very slow2026-05-26
- Rust's lib.rs and mod system feels unintuitive and overly complex to use2026-05-25
- Error handling is tedious and confusing; boilerplate, macros and choices keep tripping the user up2026-05-24
- Rust's async has more friction and annoying details than JS or C#2026-05-15
- Code snippets can't be swiped sideways and footer links don't respond on mobile2026-05-10
- Hard to get started; non-trivial code often fails to compile unless written the Rust way2026-05-08
- Slow compile times make the development experience sluggish and frustrating2026-05-07
- Async in Rust is hard to use: unnameable futures, Pin complexity, borrow checker limits, no standard executor2026-04-27
- Async is so difficult to use that experienced programmers avoid it2026-04-26
- Async feels much harder to use than JavaScript's, with long rebuild waits2026-04-25
- Easy to get dangling pointers and wrong trait implementations, with complex consequences, despite no unsafe code2026-04-22
- Module system is confusing for beginners because it works backwards from #include2026-03-31
- Curly braces have several meanings depending on context, hard to tell which applies2026-03-24
- Remaining 10% of compiler errors are hard to understand for newcomers2026-03-21
- Hard to understand code because of layers of macros and traits2026-03-09
- Hard to tell what needs to be declared mut, a lot to learn up front2026-03-09
- Lifetimes inside function bodies are opaque, so borrow checker errors appear suddenly and are hard to understand2026-03-08
- Rust rejects code the author knows is correct, blocking progress while making games2026-03-08
- Borrow checker fights shared mutable references across threads, making multithreaded code hard to write2026-02-28
- Keywords like mut and fn are annoying to read2026-02-23
- Pin is unnecessarily confusing to understand and use2026-02-23
- Simplest button needs messy lifetimes and state management boilerplate, forcing a runtime2026-02-19
- Strict Rust rules forced the commenter to deal with mutable shared value issues they didn't care about2026-01-30
- Globals need convoluted workarounds, sometimes macro crate chains, making game development painful2026-01-27
- Too many things to track, so simple tasks carry heavy cognitive overhead2026-01-26
- Hard to define meaningful error types; thiserror makes forwarding errors too easy2026-01-04
- Keeps getting lifetimes wrong; can't grasp them even after thinking they're understood2026-01-01
- Rust code is hard to read and guess what it does2026-01-01
- Hard to guess what Rust code does; less intuitive to read and reason about2026-01-01
- Async programming in Rust is overly complex and makes the language unusable2026-01-01
- Move semantics aren't intuitive for programmers coming from C2026-01-01
- Dealing with OsString is harder than necessary; stdlib encourages panicking on non-UTF-8 paths2025-12-27
- Simple struct-like declarations need many derive macros, making code harder to write2025-12-22
- Arc and Any require writing extra boilerplate that makes simple code harder than in Python2025-12-15