What you don't like about Rust?

This page summarizes the projects mentioned and recommended in the original post on reddit.com/r/rust

Our great sponsors
  • Mergify - Automate your Pull Request with Mergify
  • SonarLint - Clean code begins in your IDE with SonarLint
  • Scout APM - Less time debugging, more time building
  • rust

    Empowering everyone to build reliable and efficient software.

    Mostly absence of ecosystem critical features like GATs or TAIT (even as https://github.com/rust-lang/rust/pull/82898). Why are they ecosystem critical? Well, you could return `impl Trait` in your own traits, but that doesn't mean that every crate you use won't `Box` right away, meaning that you'll receive (small) allocations each time you want to use async in traits for example. And AFAIK, GATs are essential to streaming iterators (not as a separate crate, but rather as a drop-in feature to current iterator), and this feature would be awesome to have in Rust today. Nonetheless, it's awesome that we'll be able to use TAIT really soon (https://github.com/rust-lang/rust/issues/63063#issuecomment-796869380) and GATs have only one issue left until removal of `incomplete_features`!

  • rfcs

    RFCs for changes to Rust

    Looks like this (maybe?) but it just got postponed: https://github.com/rust-lang/rfcs/pull/2593

  • Mergify

    Automate your Pull Request with Mergify. Mergify is the most powerful merge queue tool that offers speculative checks, batch merges, and multiple queueing options. Coordinated with any CI and fully integrated to GitHub. Get started or request a demo!

  • bacon

    background rust code check (by Canop)

    For the common compilation, you should not have to wait. You should just have a background compiler telling you in a side window/terminal about the errors or failing tests. I use bacon for that purpose.

  • mold

    mold: A Modern Linker

    Have you tried using mold to speed up the linking phase?

  • tonic

    A native gRPC client & server implementation with async/await support.

    Only thing I don't like so far is having tons of boilerplate to have my struct fields correctly typed between my actix rest facade and the underlying tonic grpc microservices (having copycat structs with same fields but some casted to ::uuid::Uuid instead of ::std::string::String, or some to::chrono::DateTime<::chrono::Utc> instead of ::std::option::Option<::prost_types::Timestamp>, and so on). That's not really Rust's fault at all, but I wish there was a better way (if ever there is that I'm unaware of, please point me out in the right direction).

  • actix-web

    Actix Web is a powerful, pragmatic, and extremely fast web framework for Rust.

    Only thing I don't like so far is having tons of boilerplate to have my struct fields correctly typed between my actix rest facade and the underlying tonic grpc microservices (having copycat structs with same fields but some casted to ::uuid::Uuid instead of ::std::string::String, or some to::chrono::DateTime<::chrono::Utc> instead of ::std::option::Option<::prost_types::Timestamp>, and so on). That's not really Rust's fault at all, but I wish there was a better way (if ever there is that I'm unaware of, please point me out in the right direction).

  • ocaml

    The core OCaml system: compilers, runtime system, base libraries

  • SonarLint

    Clean code begins in your IDE with SonarLint. Up your coding game and discover issues early. SonarLint is a free plugin that helps you find & fix bugs and security issues from the moment you start writing code. Install from your favorite IDE marketplace today.

  • VisualFSharp

    The F# compiler, F# core library, F# language service, and F# tooling integration for Visual Studio

  • config

    configuration.nix is better than dot files (by matklad)

    And, while a spam links, here’s a link with more links: https://github.com/matklad/config/blob/master/links.adoc

  • rune

    An embeddable dynamic programming language for Rust.

    I know this may be unnecessary, but you can try rune. From its book:

  • cargo-geiger

    Detects usage of unsafe Rust in a Rust crate and its dependencies.

    Because even std and big-name crates like smallvec have had memory bugs in the past. That's why people wave cargo-geiger and Miri over your code and distrust it unless you come prepared with thorough benchmarks to justify non-FFI unsafe use.

  • miri

    An interpreter for Rust's mid-level intermediate representation

    Because even std and big-name crates like smallvec have had memory bugs in the past. That's why people wave cargo-geiger and Miri over your code and distrust it unless you come prepared with thorough benchmarks to justify non-FFI unsafe use.

  • bstr

    A string type for Rust that is not required to be valid UTF-8.

    Fun little nit-pick that does not detract from your overall point: you can actually count graphemes with a regex and that's exactly what bstr does. :-)

  • nomicon

    The Dark Arts of Advanced and Unsafe Rust Programming

    Finally, soundness and UB muddying. There's no official documentation for whats actually unsound in Rust. ATM it's just whatever top-dog community members or "UB researchers" say is UB. The primary way I've personally learned about soundness in Rust was talking with the community, particularly on Discord for easier back & forth. Coming from this setting, things like the Nomicon aren't fleshed out, unnecessarily condescending, and don't actually explain why certain things are UB. Whereas academic papers like Stacked Borrows or related blogs which focus too much on its math end up with complex rulesets that are difficult to map to practical settings like concurrent algorithms or subtle scenarios not directly covered by the literature. Excluding online videos, it feels like the only two extremes are those that are available and have witnessed it to be detrimental for newer unsafe programmers trying to understand the rules.

  • tokio

    A runtime for writing reliable asynchronous applications with Rust. Provides I/O, networking, scheduling, timers, ...

    (Coincidentally, Tokio is actually in an ironic situation given your statement - TL;DR Tokio avoiding heap allocations in its sync primitives by using intrusive linked lists makes it unsound & even with many looking at it and not being prioritized).

  • zig

    General-purpose programming language and toolchain for maintaining robust, optimal, and reusable software.

    If you've found your optimum combination, deterring from it doesn't sound helpful. I've personally dipped from Rust after finding that its ecosystem/community often goes against the "Make costs explicit" mindset and noted in some points from the root comment. FWIW my new near-optimal combination is Zig

  • miniserve

    🌟 For when you really just want to serve some files over HTTP right now!

    (Which is why, so far, I've stuck to writing async Rust stuff that I can then lock down tightly in a sandbox. For example, one project I've been meaning to finish v0.1 of is a cross between a learning project and a playground for potential contributions to miniserve (thus, actix-web based) which presents the specified folder as an image gallery, and it currently includes a launcher wrapper which goes above and beyond to configure Firejail to lock it down. No write permissions to anywhere but ~/.cache/thumbnails, a dynamically built Firejail profile that blacklists any unnecessary folder outside /home and, thus, not covered by --whitelist, uses --readonly on anything not hidden by whitelist/blacklist directives, future plans to customize the default system call whitelist, etc.)

NOTE: The number of mentions on this list indicates mentions on common posts plus user suggested alternatives. Hence, a higher number means a more popular project.

Suggest a related project

Related posts