bevy VS macroquad

Most of Nanite (at least, everything but the LOD system, I haven't tried that part, and the compute rasterizer due to lack of storage image atomics because Metal lacks them...) is implementable in WebGPU actually.

I have a PR that does a lot of the same things (meshlets, visbuffer, material depth, two pass occlusion culling) open for Bevy https://github.com/bevyengine/bevy/pull/10164 that I've been working on, which uses WebGPU.

WebGPU is actually a pretty good API imo. It's missing some advanced features like raytracing, mesh shaders, and subgroup operations (coming soon!), but it can still do a lot.

The much bigger missing feature is "bindless" support (non-uniform arrays of bound resources). BindGroup overhead (and ergonomics) is a significant downside.

ECS architectures are used in a number of young open source game engines, such as Bevy[1]. I haven't done game development for a long time, but hearing about an architecture that does away with the heavy and complex OOP you often see in games makes me want to dip my toes in again and check it out.

[1]: https://bevyengine.org/

https://github.com/bevyengine/bevy/blob/main/examples/shader...

Yup! The Bevy Editor is our current highest priority. The first step is building out a new Scene / UI system that will serve as the foundation for the editor (as the Bevy Editor will be built as a Bevy App).

I have a post about this (with working prototypes) here: https://github.com/bevyengine/bevy/discussions/9538

This is something that can certainly happen. In fact, this is exactly what happened with the Bevy engine, in which a total of 246 contributors agreed to relicense the engine, as explained in this blog post. However, in this case it was done for the good of the engine and its users.

If you are using Rust, you should check out https://bevyengine.org which is a rust based game engine with a focus on ECS

I was crowing to my game dev buddy about how he (a Unity C-sharp developer) ought to check out Bevy and Rust because the Rust type system is friggin’ awesome!

Code examples: https://bevyengine.org/learn/book/getting-started/ecs/

License is Apache 2.0 OR MIT:

https://github.com/bevyengine/bevy/blob/main/LICENSE-APACHE

https://github.com/bevyengine/bevy/blob/main/LICENSE-MIT

For those who are more code centric and like rust, https://bevyengine.org/ is a good alternative to godot as far as open source goes.

There were even discussions about deprecating static mut. Even if you think you got it right, there are too many things that might go wrong, like aliasing. For example, macroquad needs a complete rewrite because of their static mut.

It's based on macroquad and you can play the wasm version here: https://unvirtual.github.io/yinsh-rs/

The reality is that I have used unsafe that is also unsound out of convenience because fixing it is a papercut too many. And this tends to be common! I know enough to spot unsoundness in other projects (sometimes even early). But not enough to be confident in my own abilities to write sound unsafe code. Why? Because it's really flipping hard, that's why!

Given that you are making a game, you might want to consider using a game framework such as https://github.com/not-fl3/macroquad/.Macroquad has full support for WASM, and will allow you to render your game both locally and in the browser via WASM depending on how you compile it.

Compare the basic examples to draw a simple shape like a triangle in wgpu (https://github.com/gfx-rs/wgpu/blob/master/wgpu/examples/hello-triangle/main.rs), and in macroquad (https://github.com/not-fl3/macroquad/blob/master/examples/basic_shapes.rs).

Comparing raylib to bevy is like comparing a scooter to a sports car. They're not particularly comparable in functionality or design. If you want a fairer comparison, see macroquad.

Macroquad. https://github.com/not-fl3/macroquad

Macroquad is also an option.