I really want to like bevy but compile times are slow and the output binaries are huge.
I built a few games in WASM and was shocked to see many of the bevy variants larger than the Unity versions.
There’s definitely a market for rust game engines but it seems that no one’s hit the sweet spot yet.
I hear Rust being slow to compile is their biggest gripe, but really - look at what you’re gaining for the slowdown!
Bevy gives you a very nice ECS to model your app but compilation can be slower than hand crafted code, while not using it gives you tonnes more code and the complexities that come with it, just to compile faster?
I don’t know what you mean by, “just to compile faster.” Compiling fast is critical to game development. There’s no formula for fun so you have to iterate extensively.
I also don’t think that other solutions are “tonnes more code.” Any code will explode in size if poorly written. The same is true for bevy.
I swear I have only heard about ECS and people trying to show off how good the ECS is when it comes to Bevy, never about an actual game.
"There are more rust game engines than rust games" - Confucius
"The claim which is made without proof can be dismissed without proof" - Big Brain
What are some notable rust games?
Here is ten games in bevy engine
Rust has like 2-3 game engines and a bunch of bindings.
Bevy gives you a very nice ECS
That's a single data structure. People say binaries start at 50 MB for a hello world program and 700 MB for the debug binaries.
https://old.reddit.com/r/bevy/comments/16wcixk/cant_figure_o...
It's a single data structure that contains your entire game though? The whole point of the ECS is that literally everything uses the same data; it's like if you modeled every object in the world with one struct that has an optional field for every piece of data that could exist. I'm not saying that necessarily makes the tradeoff worthwhile, but calling it a "single data structure" is a bit reductive.
It's a single data structure that contains your entire game though?
Are you asking?
but calling it a "single data structure" is a bit reductive.
No it isn't. It's like a tiny database. Depending on how someone implements it, it could use arrays, hash maps and b-trees. There is no universe where this means a binary that does nothing should be 50 megabytes.
> It's like a tiny database.
No it isn't. It also handles system management and concurrency, basically the main loop of your application.
I also would be cautious of assigning the blame of the binary size onto the data structure on its own.
I would say yes it’s like a tiny database but as well as all the other things your added. And I think that’s a good thing, because it does this at the type level!
I’m actually seeing if I can build a parser using bevy_ecs just because the way their state machine works, it looks like it would be fun
system management
What does that mean?
concurrency
Some data structures and databases deal with concurrency.
In this case systems are the S of ECS and contain all your game logic, acting upon the entities and components (E and C).
By system management I assume they mean the APIs bevy offers for scheduling and sequencing systems and events so your game logic remains modularized while still running in the correct order.
It seems like you're calling an entire game engine "ECS". I'm not sure what the point is here, the whole question was what justifies having a 50 MB hello world binary. It doesn't matter what you put into a data structure, the data structure itself shouldn't make 50 MB binaries.
No, they aren't calling the entire game engine "ECS". Entity-Component-System is an architecture that Bevy is structured around.
As I have previously stated, I wouldn't blame the data structures used behind Bevy just yet, given Rust's tendency for making bloated binaries. What is taking the most space in this 50MB binary? How does it scale with the complexity of the application?
Even if you can put a function pointer into a data structure, that's still just a data structure.
I don't know where you are trying to go with this logic. You still haven't assured that the 50MB is actually related to data structures used behind by bevy, lest you are insunating that the data structures used by bevy are solely responsible for that size, which is not what the post claims.
How small is a hello world in C on Linux? The last time I checked a few years ago, it was either 9Mb or 13Mb (memory is fuzzy on this one but one of them was right).
Edit: wow I’m way off… it must have been the 90s when I checked this lol
C statically linked hello world binaries have never been 9MB or 13MB, they definitely weren't in the 90s. Also these are rust binaries.
Yeah, testing here with GCC 13.3.0 led to 16K. Perhaps, when you made your test, the compiler was statically linking some libs, which would explain the massive increase in size.
You should probably read the whole thread. You jumped in half way through and got all mixed up.
I know the thread. Your point is about whether Bevy's "data structure" is worth 50MB. I pressing on the fact that you haven't shown what this 50MB actually are.
But, out of curiosity, do you also consider the Linux Kernel also a data structure?
I pressing on the fact that you haven't shown what this 50MB actually are.
To be clear you think an ECS implementation is 50 MB?
But, out of curiosity, do you also consider the Linux Kernel also a data structure?
Do you think a spreadsheet the holds function pointers is a kernel?
> To be clear you think an ECS implementation is 50MB?
No.
> Do you think a spreadsheet the[sic] holds a function pointer is a kernel?
Do you think an entire engine, including its system scheduler, is a spreadsheet? If so, shouldn't be hard to apply the same argument to any kernel. Of course, it all relies on your definitions and sense of reductionism.
I think you're conflating other big features of a game engine with a way to store data. If you look at other ecs implementations they are data structures, they don't do "system scheduling" (is that different from regular scheduling?)
First of, Bevy isn't just an ECS implementation. It's a game engine designed around ECS. While the ECS part is its core, Bevy also provides rendering, resource management, physics, etc. One of its other tasks, a rather important one too, is system scheduling: once you register systems, Bevy is responsible for dispatching them each frame, at the appropriate time, while also avoid data races over global resources and components.
Other ECS implementations might not, but Bevy does come with a system scheduler. You register systems (functions that operate over the components) and, through their parameters, Bevy's scheduler decides how to parallelize the registered systems while avoid data races.
Exactly this.
Compile times are my biggest struggle, too. I'm vibecoding Bevy with parallel agents, and the bottleneck is often compiling the changes on my 7950X, not getting Codex to write them.
As far as file sizes go, I'd be really interested in how a Rust compiler that didn't monomorphize so much would perform. Right now you have to modify the source code to write polymorphic generic functions, but it doesn't strictly have to be that way (at least as far as I can see).
I wouldn't use Bevy for a web only game either, especially while it's still single threaded on WASM.
Bevy website has some tips for improving compile times, have you tried them out?
Yes, absolutely. I did that before vibecoding too, as rapidly editing and testing is so crucial.
The way Bevy's internal state is so easily saved and loaded is convenient for this.