Loglog Games

Rust is slow to compile, and not that productive when writing gameplay code (see https://loglog.games/blog/leaving-rust-gamedev/) Odin... technically not a scripting language, and haven't used it that much. But if compile times are good enough and hot reloading works, might worth a try. Though I think manual memory management can be antithetical when churning out gameplay code quickly (or when you're working with game designers with minimal background in programming)

> I wonder if Rust can reap some of the benefits of arena-based allocation by leveraging its lifetime tracking. I'm reminded of one positive remark made here: https://loglog.games/blog/leaving-rust-gamedev/#ecs-solves-the-wrong-k… > The key point being, this allows a language like Rust to completely side-step the borrow checker and allow us to do "manual memory management with arenas" without actually touching any hairy pointers, and while remaining 100% safe. If there was one thing to point at that I like about Rust, it'd be this. Especially with a library like thunderdome it really feels that this is a great match, and that this data structure very well fits the language as it was intended.

You are really being a jerk in this entire thread. Here is an 18,000+ word article on one domain where Rust is not a great fit. https://loglog.games/blog/leaving-rust-gamedev/

> First, let me assure you - yes, we (as in, the Rust Project) absolutely do care about the performance of our beloved compiler, and we put in a lot of effort to improve it. I'm probably being ungrateful here, but here goes anyway. Yes, Rust cares about performance of the compiler, but it would likely be more accurate to say that compiler performance is, like, 15th on the list of things they care about, and they'll happily trade off slower compile times for one of the other things. I find posts about Rust like this one, where they say "ah, of course we care about perf, look, we got the compile times on a somewhat nontrivial project to go from 1m15s to 1m09s" somewhat underwhelming - I think they miss the point. For me, I basically only care if compile times are virtually instantaneous. e.g. Vite scales to a million lines and can hot-swap my code changes in instantaneously. This is where the productivity benefits come in. Don't just trust me on it. Remember this post[1]? > "I feels like some people realize how much more polish could their games have if their compile times were 0.5s instead of 30s. Things like GUI are inherently tweak-y, and anyone but users of godot-rust are going to be at the mercy of restarting their game multiple times in order to make things look good. " [1]: https://loglog.games/blog/leaving-rust-gamedev/#compile-times-have-imp…

And less language adoption in regions whose devs aren't able to afford beefy computers to use Rust ergonomically. Which is why then they go back other languages, https://loglog.games/blog/leaving-rust-gamedev

This post has some good examples of this sort of problem: https://loglog.games/blog/leaving-rust-gamedev/

Web browsers, yes. With GUIs and games, it's a less clear. Of course you can write GUIs and games in any Turing complete language but there's still a lot of work to be done in finding the right ergonomics in Rust [1, 2]. [1] https://www.warp.dev/blog/why-is-building-a-ui-in-rust-so-hard [2] https://loglog.games/blog/leaving-rust-gamedev/

> First is to assume that almost everything is an assumption. Second is to insert enough flexibility into the work so that only minimal parts of it are lost if your assumptions are wrong. That's why rigid language like Rust is suitable for mature domains (like rewriting an existing app in Rust) where most things are known, instead of new and quickly iterating things (many unknown unknown). https://loglog.games/blog/leaving-rust-gamedev/

The borrow checker rejects loads of sound programs - just read https://rust-unofficial.github.io/too-many-lists/ Aliasing rules can also be problematic in some circumstances (but also beneficial for compiler optimisations). And the orphan rule is also quite restrictive for adapting imported types, if you're coming from an interpreted language. https://loglog.games/blog/leaving-rust-gamedev/ sums up the main issues nicely tbh.

https://loglog.games/blog/leaving-rust-gamedev/#hot-reloading-is-more-… Hot reloading! Iteration! A friend of mine wrote an article 25+ years ago about using C++ based scripting (compiles to C++). My friend is super smart engineer, but I don't think he was thinking of those poor scripters that would have to wait on iteration times. Granted 25 years ago the teams were small, but nowadays the amount of scripters you would have on AAA game is probably dozen if not two or three dozen and even more! Imagine all of them waiting on compile... Or trying to deal with correctness, etc.

The title is inflammatory and yet there are few nuanced takes in the article. It's weird to see it shoot to the top of HN. I think the loglog article is a much better, nuanced, full critique of Rust. https://loglog.games/blog/leaving-rust-gamedev/ The internet is just so full of negativity these days. People upvote titles but don't read articles. Reading about people's views on subjects is useful, but I don't think this one is.

C++ will easily let you write non-thread-safe code anywhere, won't complain about multiple mutable pointers to the same object, will let you leave pointers dangling and resources leaked. Such code is of course crappy, but the OP wants to test if things are fun before committing to implementing them properly. Rust wants things done properly on the first try (which usually is a good thing, except throw-away prototypes). https://loglog.games/blog/leaving-rust-gamedev/

Author switched to C++ and OpenGL. > Comfy is now archived until further notice... After abandoning Rust for gamedev [1] ... I just don't have the energy to constantly play catchup to the Rust ecosystem [1] (April 2024) https://loglog.games/blog/leaving-rust-gamedev/

This. I assume it's a similar argument as the one presented in https://loglog.games/blog/leaving-rust-gamedev/ Edit: I just noticed that this article is also writen in the archival reason. I'll leave it here anyway for those that miss it.

There are at least a couple of main reasons: 1. Rust attracts technically minded people, which is only a part (arguably not so important) of the skills/mindset required to produce a game; the result is that Rust as a community produces (way) more engines/plugins than games. 2. Rust is not convenient for fast iterations, typically required for games; when considering the game development landscape as a whole (ie. including indie production), performance is not as critical as thought, therefore the language loses the appeal compared to, say, C#. Over the last year, there have been a few articles by devs who actually produced a game in Rust, then left; this is one of the most recent: https://loglog.games/blog/leaving-rust-gamedev.

This is one of the top posts on /r/rust over on reddit, which details the pain points of using rust for gamedev. It's a long one, but give it a read if you have the time. Many of the posters in that subreddit along with even developers of rust saw the critique of the language as fair and well thought out. https://loglog.games/blog/leaving-rust-gamedev/

That's very politely said. Leaving Rust gamedev after 3 years https://loglog.games/blog/leaving-rust-gamedev/ The Rust programming language absolutely positively sucks https://old.reddit.com/r/rust/comments/12b7p2p/the_rust_programming_la…

For those who missed the earlier article this is refering to, I think it's this one: https://loglog.games/blog/leaving-rust-gamedev/

You might find this to be an interesting read:- https://loglog.games/blog/leaving-rust-gamedev/ In this, they make a good point about refactoring more with Rust than other languages. In some cases, "fighting the compiler" is not always want you want to do, especially when mocking some code/game state.

There was an article related to that recently: https://loglog.games/blog/leaving-rust-gamedev/#gui-situation-in-rust-…

The first part of your statement feels true, although that's... unverified and lacks actual backing up. The second part of your statement is very debatable based on what safe means in this case, and whether it's an enormous benefit for a given situation. There's plenty of stories [0][1] about Rust getting in the way and being very innappropriate for certain tasks and goals, and those "enormous benefits" can become "enormous roadblocks" in different perspectives and use cases. In my personal and very subjective opinion I think Rust can be very good when applied to security applications, realtime with critical safety requirements (in some embedded scenarios for example), that sort of stuff. I think it really gets in the way too much in other scenarios with demanding rules and pattern that prevent from experimenting easily and exploring solutions quickly. [0]https://barretts.club/posts/rust-for-the-engine/ [1]https://loglog.games/blog/leaving-rust-gamedev/

Rust? Since when is Rust the pinnacle of static type safety? After I've worked for some time with a language that can express even stronger invariants in types than Rust (Scala) I don't see that property anymore as clear win regardless circumstances. I don't think any more "stronger types == better, no matter what". You have a price to pay for "not being allowed to do mistakes": Explorative work becomes quite difficult if the type system is really rigid. Fast iteration may become impossible. (Small changes may require to re-architecture half your program, just to make the type system happy again![1]) It's a trade-off. Like with everything else. For a robust end product it's a good thing. For fast experimentation it's a hindrance. [1] Someone described that issue quite well in the context of Rust and game development here: https://loglog.games/blog/leaving-rust-gamedev/ But it's not exclusive to Rust, nor game dev.

This huge blog post goes over some of the challenges of using Rust. https://loglog.games/blog/leaving-rust-gamedev/ For the community I'll pluck out this paragraph > That being said, there is an overwhelming force in the Rust community that when anyone mentions they're having problems with Rust the language on a fundamental level, the answer is "you just don't get it yet, I promise once you get good enough things will make sense". This is not just with Rust, if you try using ECS you're told the same thing. If you try to use Bevy you'll be told the same thing. If you try to make GUIs with whichever framework you choose (be it one of the reactive solutions or immediate mode), you'll be told the same thing. The problem you're having is only a problem because you haven't tried hard enough. I've experienced this same feedback when I was struggling with Rust. One time when I posted in the Rust subreddit about it seeking help and talking about my struggles, I got the unhelpful response of "I believe in people" as a dismissive response to my struggles. Admittedly this was years ago and I've since moved on from Rust, but the blog post is dated from 2024-04-26, so it appears the issues with the language still remain

> It refutes the idea that the "developer joy is pretty low" either way. https://deadmoney.gg/news/articles/migrating-away-from-rust https://loglog.games/blog/leaving-rust-gamedev https://www.boringcactus.com/2025/04/13/2025-survey-of-rust-gui-librar… https://gist.github.com/rtfeldman/77fb430ee57b42f5f2ca973a3992532f https://medium.com/@rusty-vibes/part-4-abandoning-rust-for-c-83a1c2fd3… A pile of evidence refutes your statement. There is more if you need. > I'm happy to revise what I said from "Rust keeps winning" to "Rust continually won" "Rust has peaked"