* From playing in the space I know it's possible to make games using Rust. However in the ecosystem my biggest negatives is the [lack of] case studies and demonstrations of it working.

* Rust is still a risky choice, compared to C++.

* Still feels like a new community. There is always risk associated with that - does the language take a big swing in direction - does support drop off. I'm encouraged by the support for low level (embedded / OS ) development, which hopefully means the core feature set remains robust.

* Many unfinished, unmaintained crates. Lots of churn.

* A lot of common needs are not yet available 'out of the box'.

* Compile time, no runtime reflection, updating deep dependency in the tree is hard.

* Iteration time is I think too big, due to compilation time, [lack of] hot-reloading tooling, etc.

* Iteration time (especially while prototyping). This includes both compile time but also sorting out lifetimes when I know I'll be rewriting something very soon anyway, this "frontloading" the effort of having the borrow checker run at compile time is useful for most tasks but when I want to try something quickly it can be a draining experience, in this regard GC'd languages have an advantage imo.

* Prototyping seems not as easy in Rust due to "fighting the compiler"

* Not enough documentation to get past beginner stage

* Lacking examples for gamedev libs.

* Documentation is usually either high level or examples but rarely both. Very few real world examples to draw from.

* Lack of a data-and-script based engine like Unreal Engine or Unity means even small projects end up feeling very bring-your-own-engine.

* Missing graphical editors, frictionless prototyping of games

* The language has a higher upfront cognitive load than any other mainstream language I know of, mostly due to the borrow checker. It's very hard to hack through stuff and get away with it, which makes it a particularly hard sell for game prototypes.

* I know that it is a less common language to use so as a company I will have to have my staff learn Rust before they can start.

* Rust could be tricky to hire for, and hiring someone who doesn't know Rust to work in Rust will come with a ramp-up period.

* Definitely lack of proper IDE (like out of the box Cargo integration and working debugger - yeah, I tested Visual Studio Code and it's very slow, suggestions are not great, fastest way to run, check and build is to use terminal - not IDE) - I would say that something like QT Creator or Visual Studio would be great

* Regarding debugging, the industry standard is (or that I'm aware of) Visual Studio, for its very good IDE and tools, also, a lot of users are very used to that kind of tools and looks like Rust is missing some of them.

* rust-analyzer is still very incomplete, but it's the only thing that works for me

* Poor IDE and debugging support in IDE. Mainly visual studio.

* Can't debug it properly, hashmap (for example) is absolutely not debuggable. Not sure how it works inside (instead of C++).

- debug mode way too slow, often need to set opt-level=1 or 2 for dev profile

* As a tools developer, a major negative point is the current absence of a reliable GUI framework (we use WPF + C# with Visual Studio).

* No first party support for console development makes Rust a tough sell for a lot of professional work.

* Rust is not officially supported on console by Sony or Microsoft.

* Rust can't be seriously considered yet, because it does not have support from the PS4 SDK. Although there are other considerations (studio culture, integration with existing systems, etc.), official support from Sony is a requirement before Rust could be used in a PS4 game.

Our code, and any middleware/engine that we might license, is in C++. Using Rust and C++ together is painful, and rewriting the existing tech to be purely Rust would be very expensive.

* Also, no professional game engine (UE4, Unity) integrates with Rust yet.

* Unknown compatibility

- Lack of a straightforward path to make rust work easily with C++ in both directions. The only trustable way I see now is through manual C wrappers, which is error-prone and time consuming.

* Strong type system allows for easily enforcing some performance and safety best practices

* Multithreading safety

* Elimination of data races greatly improves reliability for multithreaded code.

* Safe concurrency

* Great performance and compile time verifications

* Performance and reliability

* Parallelism

* the ecosystem is full of passionate and smart people who take quality software very seriously

* a really welcoming community with great goals and courage to pursue them

* Collective community effort to "build the right thing" and "build the thing right"

* being able to pull down libraries piecemeal and have them build with your stuff immediately is great

* A mature Rust ecosystem will (hopefully!) have a lower bar for entry than a mature C++ ecosystem, without giving up performance.