News for hackers. Stuff that matters.
Re:Comfy, the 2D rust game engine, is now archived by ndiddy on Monday September 09, 2024 @07:29AM (#41487486)
> It might not be obvious how much effort it takes to manage bugfixes in dependencies where every few weeks there's a new breaking API change in egui/winit/wgpu, and while these probably seem extremely minor to those who spend all their time building an engine on top of said libraries, sinking a day or two in figuring things out and fixing stuff on every release is a gigantic waste of time in my view.

That's insane. For comparison SDL does breaking API changes every ~10 years (and they implement the previous version's API as a wrapper around the current version's API to support legacy software). Maybe the egui/winit/wgpu devs just expect that every end-user will just pin their package versions for the duration of a project, but it seems like a real burden for devs of libraries like Comfy that depend on them.

Re:Comfy, the 2D rust game engine, is now archived by lewispollard on Monday September 09, 2024 @07:35AM (#41487527)
The entire Rust ecosystem for gamedev is kind of like that - it was only recently that people really started writing games entirely in Rust, and even now there are very few actual released commercial games out there. I think there's a bit of a loop happening where it's like, until Rust is considered "stable" for serious gamedev work, libraries will be developed in this kind of "unstable" way where breaking changes should be expected at any time, but at the same time, that instability is making it less of a serious contender for gamedev work.
Re:Comfy, the 2D rust game engine, is now archived by thrdbndndn on Monday September 09, 2024 @07:46AM (#41487594)
Forget about gamedev. An anecdote: a friend wrote a personal Rust project which purely works with website's APIs and some minor file operations (basically a scraper).

And I, as his only user, have to constantly update my local Rust installation to newest dev to be able to compile his newest code base.

I understand it's more about him being on edge than the language itself alone -- but it still feels insane for me. In most of other languages, you can't make your code so backwards incompatible even if you actively try.

Re:Comfy, the 2D rust game engine, is now archived by orphea on Monday September 09, 2024 @07:54AM (#41487659)
It's not more, it's 100% on your friend, I'm afraid. One is not supposed to jump to the newest version every time simply because one can. Updating the minimum supported Rust version is a breaking change that should not be done lightly.
Re:Comfy, the 2D rust game engine, is now archived by steveklabnik on Monday September 09, 2024 @09:28AM (#41488337)
> Updating the minimum supported Rust version is a breaking change

This is not the majority sentiment, for better or for worse. The project stopped releasing "what version of Rust do you use most" in the survey results in 2020 (which is a shame, imho) the vast, vast majority of folks use the latest stable, and very few use a previous version of stable. I have no real reason to believe this overall trend has changed since then.

This is especially true for an application, which this project seems to be. Libraries may have more of a reason to explicitly lag behind the latest, but there's not really a good reason to bother if nobody else is going to depend on your code.

Re:Comfy, the 2D rust game engine, is now archived by prophesi on Monday September 09, 2024 @10:37AM (#41488950)
That makes sense to me. I usually use asdf to version Rust in personal projects, so I'm not always on the latest. But when I work on a new release I'll almost always update rust and any of my other dependencies, as I'd otherwise never keep them up-to-date. Or if a new language feature I want to try just came out.

And God forbid you fall behind on React Native major releases in a project. I think the Expo project's solution to this is for all of the native configuration be done via plugins and cross-platform config[0]. Otherwise you'll be dealing with large diffs of native Android/iOS code that would have even native mobile devs tread carefully.

[0] https://docs.expo.dev/workflow/prebuild/#sensible-upgrades

Re:Comfy, the 2D rust game engine, is now archived by vilunov on Monday September 09, 2024 @09:33AM (#41488380)
> Updating the minimum supported Rust version is a breaking change that should not be done lightly.

Why? As I see, requiring a higher minor version of your dependency including the compiler is not a breaking change (and does not warrant a major version bump wrt semver), as there should be no problem in bumping the minor version of any dependency, even if it's used for different packages.

Re:Comfy, the 2D rust game engine, is now archived by noirscape on Monday September 09, 2024 @09:46AM (#41488532)
> Updating the minimum supported Rust version is a breaking change that should not be done lightly.

Someone should tell that to Rust library devs, because from what I understand, their packaging ecosystem pretty much always assumes that all libraries are running on the latest version of Rust.

There's no "commonly used versions" or LTS builds for Rust, so it seems that every packaging maintainer just supports the latest and everyone is up shitcreek if a new version changes and hard breaks code for older Rust. With how micropackage oriented Rust is, you practically can only jump to the newest version if you want your builds to keep working since I doubt you'll be using stdlib-only Rust.

Compare and contrast every (anecdotal) Rust users favorite bugbear, Python, where if you're building a library, it's pretty commonly assumed that you can follow one of the two major deprecation points for Python versions (end of bugfixes or end of security updates), which means most major libraries usually follow one of the two for the internal features (and therefore lowest version) they use.

Re:Comfy, the 2D rust game engine, is now archived by ffsm8 on Monday September 09, 2024 @11:48AM (#41489730)
I've only done a few hello world style projects in rust, and my python experience is also almost 8 yrs ago now, so I might be wrong... But doesn't rust pull it's dependencies as bytecode vs python (which is a script language at its core) that pulls the source code?

The bytecode would only ever work with the VM that it's been compiled against I think, which sounds to me like the real issue here...?

I don't think you'd have this issue if you'd fetch your rust dependencies via git and then build them locally.

And pre building for every version is expensive, which is likely why the rust ecosystem doesn't really do it right now.

And I doubt it's gonna change unless a MAMA (Microsoft, Apple, Meta, Alphabet) company "embraces" it... The EEE style

Re:Comfy, the 2D rust game engine, is now archived by steveklabnik on Monday September 09, 2024 @11:56AM (#41489816)
Crates.io stores packages as source code.

Rust does not have a VM, and doesn't use bytecode.

That being said, it could in theory serve them as binary code, which yes, would then mean that it would need to be stored per version and per architecture both, which would be quite a lot more than the source that's stored now.

Re:Comfy, the 2D rust game engine, is now archived by afdbcreid on Monday September 09, 2024 @11:58AM (#41489845)
Re:Comfy, the 2D rust game engine, is now archived by satvikpendem on Monday September 09, 2024 @08:02AM (#41487732)
I don't understand, it's recommended practice to update your Rust install to the latest whenever there's a new version, because Rust itself is wholly backwards compatible, so 1.0 code should continue to compile with whatever the latest version is. Are you saying the libraries he's using are deprecating functionality instead of the core language? If so, then yeah I've had that issue too with certain libraries like clap.
Re:Comfy, the 2D rust game engine, is now archived by nrabulinski on Monday September 09, 2024 @08:30AM (#41487895)
No, he’s saying his friend sees a new, shiny, just stabilized function in the standard library and first thing they do is jump to using it
Re:Comfy, the 2D rust game engine, is now archived by satvikpendem on Monday September 09, 2024 @09:07AM (#41488155)
I mean, so what? I think in actuality what they're implying is that one shouldn't update Rust to latest, even though that's the recommendation. So it shouldn't matter what the friend does, as long as they're always on latest Rust. In fact, the friend is in the right, in this scenario.
Re:Comfy, the 2D rust game engine, is now archived by hu3 on Monday September 09, 2024 @10:19AM (#41488808)
> I mean, so what?

That mindset leads to the start of this thread:

> It might not be obvious how much effort it takes to manage bugfixes in dependencies where every few weeks there's a new breaking API change in egui/winit/wgpu, and while these probably seem extremely minor to those who spend all their time building an engine on top of said libraries, sinking a day or two in figuring things out and fixing stuff on every release is a gigantic waste of time in my view.

Re:Comfy, the 2D rust game engine, is now archived by satvikpendem on Monday September 09, 2024 @10:22AM (#41488828)
But not really, because the person we are talking about is, if I understand correctly, a user of the software their friend wrote, not someone who is implementing any features themselves and thus needs to rely on a stable API. All they need to do is to update their Rust version, which is really the same as any other software that must update over time.

This same sentiment is also echoed by Steve Klabnik here [0], it seems.

[0] https://news.ycombinator.com/item?id=41488337

Re:Comfy, the 2D rust game engine, is now archived by hu3 on Monday September 09, 2024 @10:34AM (#41488923)
Can't agree because updating code to utilize new shiny features frequently impacts those who use the code because of leaky abstractions. Or even deliberate breaking API changes to accommodate said new language features.

As I said, the mindset.

Re:Comfy, the 2D rust game engine, is now archived by satvikpendem on Monday September 09, 2024 @10:38AM (#41488960)
How does it impact the user? Again, this is an application, not a library, so I really don't see how, just as using some desktop application that the developer updates should not affect the end user themselves. If this indeed were a library, then sure, I'd agree, but by my inference, it does not seem so.
Re:Comfy, the 2D rust game engine, is now archived by ratmice on Monday September 09, 2024 @07:59AM (#41487710)
It is also about how easy rust makes it to use libraries, and depend upon external libraries as a part of your public API. C in particular makes this pretty inconvenient, so a lot of projects include data structures and things that otherwise might be pulled in via library themselves. That lends itself towards less reliance on external deps but also more internal stability.

At the very least I can say, that experiences I've had that are common in rust, where I have dependency X needing to be upgraded in lockstep (the same version) across multiple external dependencies with different maintainers. Are things that I've basically never experienced with C based languages.

At least I don't think it is just that things need time to stabilize, but also just the packaging system causes network effects which you don't get the joy of experiencing if you don't have one.

Re:Comfy, the 2D rust game engine, is now archived by cmrdporcupine on Monday September 09, 2024 @08:29AM (#41487890)
This is the right answer. Crates.io comes with a whole mixed bag of experiences. Increases initial project development velocity at the expense of long-term velocity (and sanity). After 2.5 years of doing Rust full-time it's the one thing I'd look back and say I'd rather see done entirely different.
Re:Comfy, the 2D rust game engine, is now archived by throwaway17_17 on Monday September 09, 2024 @08:56AM (#41488074)
What do you think some of the alternatives for library distribution and management are that would be more successful. I am an unabashed proponent of the C style manage t dependencies yourself in a manner consistent for your own work, but many people are 100% adverse to that position. Do you think a middle ground would be possible?
Re:Comfy, the 2D rust game engine, is now archived by Ygg2 on Monday September 09, 2024 @09:09AM (#41488182)
Then vendor your dependencies in Rust. If you don't want libraries to change and the depenency maintainer won't commit to stable API, you have to vendor it.
Re:Comfy, the 2D rust game engine, is now archived by marvin-hansen on Monday September 09, 2024 @10:36AM (#41488943)
I am currently working on a Rust project of about 70 crates that builds with Bazel. I ended up with vendoring everything because of very subtle bugs in rules_rust for Bazel that caught me off guard and seem to happen on non vendored deps. Fun fact, all Rust code in rules_rust is vendored by default so it's clearly the way to go.

Also, previously I had weird quirks occuring randomly, but after having switched to vendored deps, everything works stable, reliable, and as expected.

I don't agree with the fast pace of how often certain crates produce breaking changes, but I found that with Bazel at least stuff works all the time regardless. Also, builds are noticably faster because downloading and building sub dependencies can take considerably time in large projects.

Re:Comfy, the 2D rust game engine, is now archived by cmrdporcupine on Monday September 09, 2024 @09:43AM (#41488493)
I prefer "vendored" self managed dependencies as well. However the Rust ecosystem will fight fight fight you in this regard.

I am leaning towards starting future Rust personal projects on buck or bazel or gn, instead of Cargo. And checked-in vendored dependencies.

It's not a popular position, but I have seen the crates explosion in larger projects go so wrong... And 10 years at Google taught me that vendored third party deps is an entirely reasonable approach for that.

Re:Comfy, the 2D rust game engine, is now archived by steveklabnik on Monday September 09, 2024 @09:54AM (#41488600)
Cargo includes a vendor command. You can do the checked-in vendored dependencies if you'd like.

That said I am intrigued by using buck more as well, though I haven't been actually doing it yet.

Re:Comfy, the 2D rust game engine, is now archived by cmrdporcupine on Monday September 09, 2024 @10:07AM (#41488727)
The vendoring support in Cargo isn't really what I'm looking for. It's more "download all my deps from crates.io and make local copies" and it has various limitations I kept running into which I don't have time this morning to go back and document. It really felt like an afterthought and not at all like the third_party workflow that people who have worked with the Google monorepo would be used to.
Re:Comfy, the 2D rust game engine, is now archived by steveklabnik on Monday September 09, 2024 @10:10AM (#41488750)
I am interested in what vendoring means other than “put all of my dependencies’ code in my repo” but if you don’t have time, that’s chill. I’ve only seen open source projects using buck/bazel and haven’t ever seen google3, so I’m sure I’m missing something.
Re:Comfy, the 2D rust game engine, is now archived by CraigJPerry on Monday September 09, 2024 @11:35AM (#41489569)
Not OP but a difference is in who manages the updating of a vendored dep. You don’t want to update every time there’s a release, but you don’t want to never update either.

If upstream (which you’ve vendored) releases a security fix, how does your system capture and act on that event?

If vendoring just means we periodically pull a copy of upstream into our repo then you can have unbounded time when you don’t know there’s a vuln and therefore haven’t considered whether you need to act.

This is obv different from the situation where we all just cargo install (without —locked) and different from c style dep mgmt where we get sec fixes for many libs via our OS patching.

Re:Comfy, the 2D rust game engine, is now archived by steveklabnik on Monday September 09, 2024 @11:57AM (#41489834)
> If upstream (which you’ve vendored) releases a security fix, how does your system capture and act on that event?

You still retain the Cargo.toml and Cargo.lock, so the exact same way as if you didn't vendor: `cargo-audit` would inform you, you'd update the version, and re-vendor.

Re:Comfy, the 2D rust game engine, is now archived by CraigJPerry on Monday September 09, 2024 @12:42PM (#41490348)
It’s not how do you do that, it’s What (systemically) triggers you to do that?

Are some developer(s) on the team responsible for subscribing to the relevant vuln lists and scanning them each day? Do you buy in some tooling?

Re:Comfy, the 2D rust game engine, is now archived by steveklabnik on Monday September 09, 2024 @01:01PM (#41490635)
The cargo-audit I referred to in my previous post is that tooling, it's commonly run in CI regularly.

But, also, this is pretty far afield from my original question: I understand why keeping copies of your dependencies can introduce various things you should handle, but my original question was "what is vendoring your dependencies if not 'keeping a copy of the source code of your dependencies in the repository'"? That's my understanding of the definition of "vendoring," so I was curious what my original parents' definition was.

Re:Comfy, the 2D rust game engine, is now archived by atoav on Monday September 09, 2024 @10:09AM (#41488740)
Well. Rust has lock files, so breaks will only happen when you decide they are allowed to happen, by running cargo update.

In C they also only happen when you update the dependencies you have.

Granted, Rust makes it easier to pull on dependecies, but it also makes it easier to keep them up to date.

Re:Comfy, the 2D rust game engine, is now archived by Starlevel004 on Monday September 09, 2024 @11:01AM (#41489154)
> Rust has lock files, so breaks will only happen when you decide they are allowed to happen, by running cargo update.

great in theory but ``cargo install`` will straight up ignore lockfiles by default[0], meaning trying to install a binary package is a roulette of "did this tiny package update before everyone in the dependency tree noticed"

[0]: https://github.com/rust-lang/cargo/issues/7169

Re:Comfy, the 2D rust game engine, is now archived by jeroenhd on Monday September 09, 2024 @09:35AM (#41488399)
There's nothing preventing you from using the defined-by-spec-but-not-actually implemented C++23 methods, either. You can write perfectly spec-compliant C++ code that will only work on the latest version of MS C++ because other compilers don't support the feature yet. Shortly after new C++ specs are released, it's even possible to write spec-compliant code that no production compiler can even compile!

It's just that developers in the slow languages don't do that often.

With the guarantee to be able to build older projects (version specified in the Cargo.toml file) and only one real mainstream compiler (the "can compile code but lacks any of the language checks" GCC version doesn't really count), there are few downsides to always having the latest compiler, something other languages sometimes struggle with.

Coming from Rust, I made the foolish mistake of installing the latest Clang and GCC, only to find out that tons of software suddenly stopped compiling because apparently the code requires old compiler bugs/features to work (that are not emulated in newer versions). I've had similar issues with Java, where JRE 17 or 21 could not compile Java 8 projects without modifications to the project because of the new modules feature.

In an environment where updating your compiler toolkit is basically worry-free, it's a lot easier to use recent or even unstable functions. This invites developers to make use of recently added APIs, whereas developers from other ecosystems will wait months or years before even considering new APIs that have been stabilised.

Re:Comfy, the 2D rust game engine, is now archived by desdenova on Monday September 09, 2024 @07:33AM (#41487508)
The rust ecosystem is young, most of those libraries haven't even reached 1.0.

Basing any serious project on 0.x libraries is always subject to this issue.

Re:Comfy, the 2D rust game engine, is now archived by aeurielesn on Monday September 09, 2024 @08:04AM (#41487743)
I believe a post from one or two weeks ago showed it seems more of a systematic Rust ecosystem problem.
Re:Comfy, the 2D rust game engine, is now archived by CaptainOfCoit on Monday September 09, 2024 @09:16AM (#41488232)
What, exactly, is the problem? That libraries/projects remain below 1.0 for too long? Because lots of breaking changes before a 1.0.0 release is to be expected for anything following semver (which as far as I know, most if not all of the Rust ecosystem uses).
Re:Comfy, the 2D rust game engine, is now archived by littlestymaar on Monday September 09, 2024 @07:49AM (#41487615)
I'm always puzzled with people saying that things move too quickly and that they fail to keep up, in any language. Why do you guys even try to keep up in the first place? Unless there's a bug in a dependency you're using, if version 0.4 works, you don't have to use 0.5 or 0.6. Or maybe there's a new feature that you need in the newer version, then you can afford to spend time doing the migration but in this case you should also be happy the the pace of development is fast because that's how the feature ended up landing in the first place.

For most use-cases, it's fine to stay on out of date libraries for years, and that's what the Linux distros do all the time (mostly patching crippling bugs and security vulnerabilities).

Re:Comfy, the 2D rust game engine, is now archived by mysterydip on Monday September 09, 2024 @07:54AM (#41487660)
90% agree. The scenario that I've seen that messes with this is when you include lib x which has dependency on version 0.5 of y, but your code depends on version 0.4 of y.
Re:Comfy, the 2D rust game engine, is now archived by tstenner on Monday September 09, 2024 @09:31AM (#41488360)
cargo handles this just fine, unless you get lib y objects through the lib x api
Re:Comfy, the 2D rust game engine, is now archived by q3k on Monday September 09, 2024 @08:24AM (#41487852)
> Basing any serious project on 0.x libraries is always subject to this issue.

So I guess I'll hold off on having random numbers in Rust then [1].

[1] - https://docs.rs/rand/latest/rand/

Re:Comfy, the 2D rust game engine, is now archived by swfsql on Monday September 09, 2024 @10:54AM (#41489094)
It's already at 0.8, just another 20% and..!
Re:Comfy, the 2D rust game engine, is now archived by mcpar-land on Monday September 09, 2024 @09:21AM (#41488267)
On the flip side of this, when libraries in rust do reach 1.0, they often are just done. The serialization/deserialization library serde which has become the de-facto standard has been on 1.0.xxx for the past seven years. https://crates.io/crates/serde/versions

I think this speaks to rust's strengths in that if you know your spec, you can write a rock-solid version of it - and its weakness, where if you don't know your spec you'll be making breaking changes a lot.

Re:Comfy, the 2D rust game engine, is now archived by viraptor on Monday September 09, 2024 @08:08AM (#41487771)
wgpu only got the first non-0 release this July and started 4-ish years ago. They didn't even have a chance of taking 10 years. I'm sure SDL wasn't very API stable in 1998.
Re:Comfy, the 2D rust game engine, is now archived by seba_dos1 on Monday September 09, 2024 @11:14AM (#41489298)
4 years after starting SDL was already deep into 1.2, which is the API that's still supported today via sdl12-compat (and the original codebase as well, which is still maintained even though it's deprecated).
Re:Comfy, the 2D rust game engine, is now archived by rapsey on Monday September 09, 2024 @07:34AM (#41487519)
Things move quickly because there is so much development being put into these base libraries. Which is of course a blessing and a curse.
Re:Comfy, the 2D rust game engine, is now archived by rollcat on Monday September 09, 2024 @08:39AM (#41487948)
I cannot find the article right now, but it was a wonderful piece on why a language like Rust is by design incompatible with the whole idea/process of making games. (I hope it rings a bell for someone who can find it.)

It went something like this: you start with a nice little tidy spec for basic arithmetic; how "a + b" must be the same as "b + a", etc. Then the designer comes back to you and asks for the ability to make numbers blue. You're like wtf but ok, when you add a blue "a" to a non-blue "b", the result becomes blue; you must remove half of your tests (because they no longer even apply) and rewrite the other half to match the spec, and a week of work later the result somehow still makes some mathematical sense. Then the designer comes back to you with the request to make even numbers shoot sparks on death, and to remove all fives...

And it's just how it goes. Games need to be iterated on quickly and efficiently, with a tight feedback loop on what ends up being fun during playtesting, and what doesn't. Rust might be great for writing low-level code / engines, but it will constantly get in your way where you need to respond quickly.

Re:Comfy, the 2D rust game engine, is now archived by capitainenemo on Monday September 09, 2024 @10:11AM (#41488752)
Interesting because there was a rust keynote by kyren arguing the exact same thing for why games were a poor fit for OOP/C++. Arguing for data oriented which rust does well. ... or C I suppose.

It might be that rust ecosystem this dev was dealing with was itself draining with continually shifting APIs, but that's not the same as the language itself.

https://kyren.github.io/2018/09/14/rustconf-talk.html

Re:Comfy, the 2D rust game engine, is now archived by consteval on Wednesday September 11, 2024 @04:30PM (#41515110)
Most C++ games aren't really OOP C++. They're more loosey-goosey maybe you use some OOP stuff sometimes C++.

The problem is C is far too low level. And everything you can do in C, you can do in C++. You just also get things like namespaces and RAII.

From a game making perspective, there's no rules anywhere saying you have to write good, readable, C++. You can, and often people do, make amalgamations and monstrosities. You can do this very quickly, and if there's little bugs here and there it's no biggie, because you're just making a game. A segmentation fault is really not the end of the world.

Re:Comfy, the 2D rust game engine, is now archived by capitainenemo on Saturday September 14, 2024 @04:21PM (#41542548)
Well... yes. Rust is kinda like nicer C. You can augment the data structures with behaviours. Which kyren notes in her keynote. I just feel the problem of the author of Comfy is not so much with rust-the-language but with the existing SDKs he was trying to build on which were moving targets. Not unsurprising for new stuff.
Re:Comfy, the 2D rust game engine, is now archived by consteval on Tuesday September 17, 2024 @09:33AM (#41567449)
I wouldn't describe Rust as a nicer C. Rust is a more correct C++, and C++ is a nicer C.

Rust isn't actually nicer to program in than C++. It takes longer to produce the same amount of code. The tradeoff is correctness. So now the value of using Rust depends on the value of correctness. In most domains, correctness is very valuable. Game development is one in a million, where correctness really doesn't matter that much. What matters more is velocity and tooling.

Even if Rust catches up with C++ in tooling and is stable, I don't believe it will replace C++ in gaming specifically. Because C++ naturally orients itself more towards that super fast development, throw-shit-at-the-wall approach to software. For gaming, that works best.

Re:Comfy, the 2D rust game engine, is now archived by capitainenemo on Sunday September 22, 2024 @12:39PM (#41618175)
I was thinking back to the C-based dev I've done which was heavy on tying together data structures with functions that operated on them. Adding behaviours to data structures is way nicer in Rust, so that's the part that I feel would make it attractive to a C developer, in particular a game developer.

... and without the messiness of OOP inheritance in C++ messing with your convoluted game rules... (that was the main thing kyren was focusing on in that keynote) - obviously you don't have to use OOP, but your C++ frameworks probably do, and it's the natural way to do C++ and to augment your data structures with useful behaviours... if you're not doing that, you're kinda back to C-like, and at that point I feel Rust does win again...

Re:Comfy, the 2D rust game engine, is now archived by consteval on Tuesday September 24, 2024 @02:41PM (#41639625)
I mean, I just don't think this is true. All the most mature entity-component frameworks are built in C++.

C++ is one of the most flexible languages, ever. OOP is a very tiny part of C++. You can 100% do data-oriented designs. And most and engines, do!

> if you're not doing that, you're kinda back to C-like

I don't understand how you can believe this. Maybe you don't have the C++ experience.

You have higher order functions, you have templates, you have compile-time programming. Hell, C++ has higher-kinded types - even Rust's type system can't do that!

C++ is very convenient to program in and very powerful. That's why it's used for games and will continue to be used for games. Rust is not more powerful, in any ways, in that regard. It can do the same shit, but with more headache. Usually that's worth it, but not for video games.

Re:Comfy, the 2D rust game engine, is now archived by pjmlp on Monday September 09, 2024 @08:42AM (#41487966)
It is from the same author, they link it on the readme.
Re:Comfy, the 2D rust game engine, is now archived by rollcat on Monday September 09, 2024 @09:08AM (#41488169)
Silly me, thanks!
Re:Comfy, the 2D rust game engine, is now archived by jvanderbot on Monday September 09, 2024 @09:22AM (#41488281)
Exactly, this is poor SWE. If you need a new feature from a latest rustc or an upstream, and can stomach losing users, then perhaps you mark things #[deprecated] for a release or two (which should be months, not days).

AND don't bundle bugfixes with API breaks if it can be avoided.

Otherwise, just don't bother!

This is hype-driven development at its worst.

Re:Comfy, the 2D rust game engine, is now archived by wormlord on Monday September 09, 2024 @10:12AM (#41488766)
I sat down one weekend to try and make a demo in Bevy. The ECS system was cool, it's almost like querying a database. However every tutorial I found, even the most recent ones, were already outdated. They had just moved from 0.14 to 0.15 which broke a ton of things. I opted to mess around in Godot instead.
Re:Comfy, the 2D rust game engine, is now archived by ogoffart on Monday September 09, 2024 @10:17AM (#41488794)
Some crates are better than other.

For Slint (Another GUI toolkit in Rust), we try to keep our API as stable as possible for as long as possible. We use other crates behind the scene such as winit and co., but we don't expose them in our public API, and we take care of the burden to update them.