Bevy 0.15 released (opens in new tab)

We'd like to land initial BSN features within the next two cycles (obviously sooner is better than later).

We do have plans to upstream a physics plugin, but we aren't yet in a rush to do so, given how great the 3rd party options are. Once visual Bevy Editor workflows start being viable, the pressure to bless a physics plugin will go up I think.

Thanks for the kind words!

Practically at the moment you do need to learn Rust to use the engine. Our public APIs are all Rust APIs. I'll note that Bevy's ECS makes a lot of Rust more approachable, as it is written to "feel" high level, and it solves a lot of the ownership problems for you that normally trip up newbies. I am of the opinion that Rust is a productive gamedev language, especially in the context of Bevy.

That being said, we've built Bevy ECS and our Bevy Reflect (our Rust reflection library) in a way that enable bindings to other languages to be built. People have built partial Lua and Javascript scripting support on top already. For ecosystem health reasons, I believe that Bevy should have one official language (Rust), but we still want to give people the tools they need to build the integrations they want.

We do get a healthy amount of donations, both from corporations and individuals (see https://bevyengine.org/donate). If you navigate from there to our foundation page, you can see how we spend it. We are a 501c3 non-profit, so each year we MUST file a public annual report as well outlining our activities.

The strong criticism Rust got in this area is being poorly suited for rapid throwaway prototyping. I think that's fair — slow compile times and language's focus on writing things properly on the first try are the opposite of what you want when trying out random ideas and seeing what sticks. I think that may be fixable. Partly it's a skill issue (with enough experience, you can cut corners when you known which ones to cut). Partly it could be improved by tooling for hot reloading, and perhaps a scripting language integrated with Rust.

In Bevy in particular almost everything happens through ECS, and the ECS has a Reflection API, so you can hook it up to whatever you want, and manipulate it from any language.

I also wonder what about the rest of the game development lifecycle. Games are taking many years to develop, and not all of that is quick exploration. The more of the game starts taking shape, the more you actually need stuff to work. You need ability to refactor, polish, and extend the implementation without breaking things. You need to be fixing gameplay bugs, not wasting time on hard-to-reproduce crashes.

I personally love working with Rust. I think it delivers on the various buzzwords that made it popular. In general when people critique Rust in this context, it comes down to:

1. Rust's ownership / mutability features

Bevy ECS specifically alleviates a lot of the ownership problems that newbies often encounter in Rust. It doesn't solve _all_ of those problems ... there are definitely still UX rough edges. This _will_ be a sticking point for some people. The cost / benefit here is also hard for newbies to evaluate, as it is a _very complicated problem that requires years of experience in the space_.

From my perspective, the cost is worth it. Strict mutability and ownership rules allow us to parallelize everything safely and automatically. Strict mutability allows us to (via the DerefMut trait) _perfectly and automatically_ detect all changes to components and allow developers to react to them. This is something that is unique to Rust, at least in the mainstream. You will not find this type of feature in ECS-es written in other languages, as they literally don't have the semantics to globally distinguish between a read vs write pointer deref.

Opt-in garbage collected ECS is something that people are experimenting with in Rust right now), which would allow people to define "do whatever you want" code.

And _right now_ you can always just use Bevy ECS's unsafe api variants to do whatever you want when the "safety" isn't worth it to you.

2. Rust is "too low-level"

Rust can feel "high level" when it needs to, and Bevy is built in a way that takes advantage of that. If you look at our example code, it _looks_ high level: https://github.com/bevyengine/bevy/blob/main/examples/3d/3d_...

I value what I like to call "progressive disclosure of complexity". I want people to be able to quickly and easily use the tools I build without much experience. And as they gain experience, I want them to be able to seamlessly dive further down the stack. I believe Rust handles the encoding the "low level" stuff better than every other language, both by more accurately modeling system constraints and by protecting people from doing the "wrong thing". It also allows you to use those low level pieces to "climb up" the stack until you have something like the Bevy API.

Unlike most engines, in Bevy you can start "at the top" in your program, hit F12 in your IDE to "go to definition", and keep going until you hit the core language APIs. And _then_ you can hit F12 one more time and go into Rust's source code. This experience is extremely empowering, coming from engines like Godot, which have a "high level" API with a "hard cut" before you go into the engine with a completely different language and paradigm (and no good way for your IDE to bridge the gap).

Bevy (and Rust) are for the developers that care about understanding (and controlling) their tools from top to bottom, and are willing to undergo a bit of initial pain (relative to scripting languages) to make that happen. Rust is not a perfect language and it isn't the best "constraint solve" for everyone. But I am most interested in building a holistic experience that empowers people that value that kind of thing.

3. Compile times

Rust compile times can be long if you aren't intentional about it. That being said, Bevy is built in a way to make compile times reasonable. With our "fast compiles" setup (see the getting started guide on our website), I can compile a change to our examples in ~0.5 seconds. Thats close enough to "instant" for me. The trick in general is (1) make sure you aren't writing code in a such a way that requires recompiling EVERYTHING (2) use dynamic linking for large deps (we do this for you in Bevy via the dynamic_linking cargo feature) (3) use a fast linker (covered in our guide).

Ensuring you follow principle (1) in large projects is a skill that needs to be honed. But on the Bevy side, via our opinionated Plugin structure (and dynamically linking those plugins), I think we can provide bounds that discourage people from shooting themselves in the foot.

I will close by saying that it is worth thinking critically about what tools you use and not following hype trains blindly. Picking Rust _and/or_ Bevy for your project _is_ currently something that many people should not do. However I think that Rust and Bevy are both VERY good tools that will be right for some people. And due to their "carefully and seamlessly climb up the stack" approach instead of "riskily climbing down when necessary", they have extremely solid foundations, and their user experience improves constantly. They are both increasingly suitable tools for more and more categories of people, and I expect that trend to continue.

> As one of the Bevy contributors, I'd love to hear what you didn't like in the past, and what you liked from this release.

One issue that I always had with Bevy's development direction was how it felt a bit incongruent in a way. Like we get all these advanced rendering features but the boring basics are only slowly getting added. But of course it makes sense, its much more fun to work on a super advanced state of the art virtual geometry renderer (that is very impressive stuff) than it is to work on the boring parts.

I hope one day the foundation gets proper funding and can fund development with a clear focus and direction like the Blender foundation.

Why this release feels somehow different is because there are many mundane, boring but very foundational features added, like sorry but I do not give a fuck about chromatic aberration, but I do care about required components, animation masks, additive blending and events, box shadows, cosmic text, ui scrolling, interpolation functions and event propagation / bubbling.

Take the only now added animation masks, what use is an engine that supports visualized geometry (added in previous release) rendering but I can't render the hand movements of a character separate from the body? That's what I mean by incongruent, its not meant as a criticism, that's just how open source works of course but its still frustrating sometimes.

For the things still missing, for example: declarative scenes (in the works with BSN), asset streaming and pipeline events, (proper) rich text rendering, pointer and text selection events to name a few.

So seeing these "boring" things slowly getting added with each release also makes me very optimistic for the future of Bevy!

(notice how I didn't even mention the editor ;)

Totally subjective and superficial outsider view, but it has been my perception both that Bevy does not make great use of Rust features (i.e. I’ve heard it relies a lot on dynamic dispatch / there are things that can be done wrong which aren’t caught by the typesystem?) and that it lacks feature parity on certain important points (which I couldn’t be asked to enumerate) — which could be forgivable if its use of Rust’s typesystem was more advantageous given the first point but could be an issue if it wasn’t well differentiated by it.