This is not a serious project; I just wanted to experiment with Bevy. 😄 It's the first game I've ever created, so I'm interested in learning about the aspects I could improve.
https://github.com/NiiightmareXD/golab
Bevy Game Engine Explained Visually
A visual tour of how Bevy helps you compose complex, emergent games from small independent systems and a data-driven architecture.
Hey all, long time Unity dev finally trying something new. I have been experimenting with Rust/Bevy for a bit now and really enjoying it! What started as a quick procedural world generation/mine/build experiment has quickly evolved to include builder bots, blueprints and farming.
Hi, I am a C developer, and I am working on a game, it's a city builder. I want to make a "game engine" specifically made for this project, partly because I think that available game engines like Godot and Unity are complex and hard to learn, and also because I want to create something myself. I love the aspect of coding and I find that these engines abstract a lot. It's mainly a 3D map editor with some extra features. I heard about Bevy and the fact that I can use its components separately to create my own game engine, and I wanted to get the opinion of people who are familiar with Bevy and the Rust language. In the beginning I wanted to make it using raylib and C but apparently raylib is quite limited when it comes to animations and graphics features (like particles...). The main purpose of this engine is that I don't want to have to build a 3D renderer.
My question is: do you think this is feasible? Is it a good design?
Thanks in advance for your help.
We've just shipped v0.12.0 of `bonsai-bt`, and the big addition this release is live visualizations in the browser — you can now watch the state of your behavior tree update in real time as it ticks, including which nodes are running, succeeding, or failing.
For anyone unfamiliar: behavior trees are a great way to build deterministic AI — they're widely used for things like robotics control loops, game NPCs, and any agent that needs predictable, debuggable decision-making. The new visualizer makes it a lot easier to actually see what your tree is doing and catch issues without sprinkling print statements everywhere.
The visualizer is gated behind a feature flag. Add it to your `Cargo.toml` like this:
```toml
[dependencies]
bonsai-bt = { version = "0.12.0", features = ["visualize"] }
```
For more, see repo: https://github.com/Sollimann/bonsai
After a year and a half of fighting with async Rust I'm finally ready to announce Bevy-s2n-quic. An Aeronet compatible Bevy networking plugin utillizing the incredibly powerful s2n-quic library by Amazon.
Currently working at the moment is:
WIP/needs polish:
Project Links:
https://github.com/CorneliusCornbread/bevy-s2n-quic
https://crates.io/crates/bevy-s2n-quic
Related Links:
https://docs.rs/aeronet/0.20.0/aeronet/
https://crates.io/crates/s2n-quic
I want to participate as a collaborator in a Bevy project under the GPL, Apache, or MIT license. Can someone recommend a project to me, please? Thanks
Hey everyone,
I was thinking it would be awesome if Bevy hosted an official game jam.
The main goal would simply be to encourage more game developers to try out Bevy and see what the engine can do. It doesn't even need to have a prize pool (though a small prize would obviously be cool), just something to bring the community together and get people coding.
If this has already happened before, that's completely fine, let's do another one! If it would be the first official one, even better.
I really want to see this happen, so I’d be more than happy to volunteer and help organize/arrange the event if the community or maintainers are interested.
What do you all think? Would you participate?
The recordings of our last virtual meetup are now live on YouTube. Give it a watch and a like to appreciate our community speakers!
Hi guys, just posting another devlog for jackdaw, to show the progress we’ve made since the last one! We’ve had lots of new contributors and features added to get us even closer to being a proper editor.
Repo: https://github.com/jbuehler23/jackdaw
Discord: https://discord.gg/GqXb4uwMg
Link: https://github.com/voxell-tech/velyst
Hey Reddit folks, I’ve been experimenting with real-time Typst rendering inside Bevy using Vello. The idea is to treat Typst as something more like a reactive, interactive 2d vector scene.
One interesting aspect is that Typst functions can be evaluated and rendered dynamically, which opens up possibilities for dashboards, data visualization, motion graphics (sth I’m heavily targeting, similar to manim), UIs
I’m working hard towards making the scene queryable/modifiable (esp for animations). Curious what the Typst community thinks. What use cases would you want from “live Typst”?
Any feedback is welcomed! Especially around architecture or use cases I might be missing.
You can try it now for free here: https://store.steampowered.com/app/3578080/Wee_Boats/
Appreciate anyone who checks it out and any feedback is very welcome!
Built a mobile idle game with Bevy 0.15 + egui. No sprites anywhere —
all visuals are procedural geometry drawn with egui's painter API.
Runs on Android and WASM.
You mine asteroids, automate a drone fleet, and receive transmissions
from something watching near the black hole.
One technical thing the Bevy community might find useful:
egui::Window click events are unreliable in bevy_egui 0.33. All
interactive UI uses painter + ui.interact() instead. Took a while
to land on that pattern but it's solid now.
Play in browser: https://rdug627.itch.io/voidrift
Source (MIT): https://github.com/rfd62794/VoidDrift
Prototype — more orbital rings and drone types in progress.
Mobile feedback especially welcome.
Link to project: walk-and-talk
Hello everyone! I am a software engineer of about 3-4 years and I discovered this game engine while learning about Rust. After completing the Impatient Programmer's Rust tutorial and reading the documentation for the Avian Engine, I decided to try out Bevy. This is my first non-tutorial experience into Bevy and decided to document it in the form of a github repository. It may stand as a "what are the first speed-bumps a slightly experienced programmer would hit and immediately write code for" kind of thing. I believe I have created a half-decent input system as well as menu and level design pattern. I would be interested into what others think!
I'm open to contributions, comments, criticisms, and I apologize for the manifesto of a readme. More updates soon!
The reason the github only has 3 commits is because it was initially on a personal github and I wanted to move it to something that wasn't attached to my name. I promise moving forward I will contribute to this version and not the personal one.
Bevy is so simple I don't even know if I want an editor to be honest or at least I hope Bevy continue having an option to continue editor-less and keep things lightweight, simple, and clean. What I do is I just draw debug widgets as simple boolean flags and development has been really smooth especially with how fast things reload and compile and I push for as much hot reloading as possible... I have always hated fighting against UI or nested UI and Godot was pretty bad in that regard.
It really is refreshingly simple. I am so excited to see where Bevy goes. I hope to see Avian become as good as Jolt and shout out to Bevy HUI, using html/css like was great and got some good looking UI up and running with ease.
I haven't tried too much of Lightyear networking but having these out of the box is insane.
Advanced replication
Client-side prediction: with just a one-line change, you can enable client-prediction with rollback on the client, so that your inputs can feel responsive
Snapshot interpolation: with just a one-line change, you can enable Snapshot interpolation so that entities are smoothly interpolated even if replicated infrequently.
Client-authoritative replication: you can also replicate entities from the client to the server. The authority over the entity is transferable between the client and the server.
Pre-spawning predicted entities: you can spawn Predicted entities on the client first, and then transfer the authority to the server. This ensures that the entity is spawned immediately, but will still be controlled by the server.
Entity mapping: lightyear also supports replicating components/messages that contain references to other entities. The entities will be mapped from the local World to the remote World.
Interest management: lightyear supports replicating only a subset of the World to clients. Interest management is made flexible by the use of Rooms
Input Delay: you can add a custom amount of input-delay as a trade-off between having a more responsive game or more miss-predictions
Bandwidth Management: you can set a cap to the bandwidth for the connection. Then messages will be sent in decreasing order of priority (that you can set yourself), with a priority-accumulation scheme
Lag Compensation is available so that predicted entities can interact with interpolated entities (used most often for fps games)
If you guys have any frameworks you enjoy, let me know.
Why there isn't a visual editor for bevy engine? i think it will be easier and more beginner friendly as a beginner...
Here with a new showcase for the new firefly version! This one introduces support for multiple cameras, render layers for lights and occluders, as well as a new handy `CombineLightmapTo` relationship to combine multiple lightmaps into a main one in various ways.
One example of this is the new FOV example, which spawns two cameras, one rendering the two large 'visibility' lights, and the other one rendering the red and blue lights. The lightmap from the visibility camera is multiplied over the other lightmap, creating a field-of-view effect.
You can also notice that the central line occluder blocks lights on both layers, while the smaller squares to the sides only block the red and blue lights.
Also, each camera / lightmap can have its own indepedent settings, such as hdr or soft shadows, which I find pretty fun to play around with. And they can also be set to e.g. add over each other instead of multiply.
Another notable addition are the custom lightmap sizes which can be used to achieve a stylized pixelated effect or to significantly improve performance at a pretty low quality cost.
You can see all changes in the release notes.
Follow the bevy discord thread for more updates and questions!
And here is the repo.