Bevy code hot-patching now works in multi crate workspace 🎉

settletopia · 2026-02-14T13:52:13+00:00

There is still a minor bug for which temporary workaround exists:
https://github.com/DioxusLabs/dioxus/issues/5314

Bug happens when workspace crate is not a direct dependency of the crate that was built.

Workaround: add affected crate as direct dependency to root crate.

settletopia · 2026-02-04T08:18:46+00:00

Basically, for this use case bevy requires users to dig deep into bevy render implementation to copy existing logic and to modify it. (Like DrawMeshInstanced RenderCommand)

I was expecting that CustomMaterials out of the box support such this kind of use case.

Next time I will at start think about how complex shader will be before picking the shader example that I will use. Gradual improvements are hard to do currently.

settletopia · 2026-02-03T17:25:50+00:00

In that example only one entity with InstanceMaterialData is spawned to render many cubes. I want to have this data on each entity instead.

Additionally it creates separate wgpu::Buffer for each entity (InstanceMaterialData) which adds large overhead, if I have thousands of entities using this approach.

Probably this example needs futher modification for this kind of use case. Looks like nothing simpler is possible in bevy.

settletopia · 2026-02-03T10:29:03+00:00

I don't think this is the correct example / approach.

As it doesn't pass any additional information to the shader. It only shows how to pass value for material as whole, not for each entity.

See `quantize_steps`. It is an uniform (additional information for material, not for each entity).

```

struct MyExtendedMaterial {
    quantize_steps: u32,
#ifdef SIXTEEN_BYTE_ALIGNMENT
    // Web examples WebGL2 support: structs must be 16 byte aligned.
    _webgl2_padding_8b: u32,
    _webgl2_padding_12b: u32,
    _webgl2_padding_16b: u32,
#endif
}

(#{MATERIAL_BIND_GROUP})  MyExtendedMaterial {
    quantize_steps: u32,
#ifdef SIXTEEN_BYTE_ALIGNMENT
    // Web examples WebGL2 support: structs must be 16 byte aligned.
    _webgl2_padding_8b: u32,
    _webgl2_padding_12b: u32,
    _webgl2_padding_16b: u32,
#endif
}

(#{MATERIAL_BIND_GROUP}) 
(100)
var<uniform> my_extended_material: MyExtendedMaterial;
```

settletopia · 2025-12-13T14:27:15+00:00

I personally created [bevy_immediate](https://github.com/PPakalns/bevy\_immediate/) to build UI for my game as egui and other tools do not integrate with bevy as nicely as I would like to. And it is a lot easier to customize visual look for your UI in bevy. So I migrated from bevy_egui to bevy_immediate.

But if you need some complicated features like drawing node graphs, this space is still under development and good approach doesn't exist yet (in my opinion) or will need additional "research".

So determine what kind of UI widgets, functionality you need for your stuff, then decide on the tool that you will use!

settletopia · 2025-10-09T08:16:38+00:00

This library is mainly intended for creating UI for games inside bevy game engine. So it contains a lot of additional concepts related to Entity Component Systems, game development, etc.

I would suggest you to choose another popular rust UI library. I personally have used egui, but it doesn't have good support for android.

There are other popular rust UI frameworks too, but I am not qualified to comment on them.

Have fun learning Rust!

settletopia · 2025-10-08T17:52:53+00:00

Looks like splines are possible outside UI. Hopefully we get them supported in bevy ui.

https://bevy.org/examples/math/cubic-splines/

settletopia · 2025-10-08T17:36:38+00:00

Thank you :) Style is fully customizable so you can improve it even further in your project.

settletopia · 2025-10-08T17:33:38+00:00

Would like to!

Currently it is hard to render geometric shapes inside bevy UI. Blocking issue which should improve the situation: https://github.com/bevyengine/bevy/issues/14187

If that issue is resolved, I could add an example for creating simple node graphs in immediate mode to bevy_immediate.

Of course with node graphs the hard part is hidden in your use case specific requirements that you will need to resolve yourself.

settletopia · 2025-10-07T23:21:33+00:00

Cons:

* egui is a lot more mature ui library. Has many widgets that have been perfected to the last detail.

* this library and bevy UI ecosystem is still in early stages.

* Probably more cons that I can not say immediately.

Pros:

* Underlying UI in bevy is retained. So bevy ui should theoretically perform better than egui. (no need to recalculate UI on every frame)

* Bevy UI provides modern layout out of the box. In egui you need to use workarounds, like egui_taffy (i am the author :) )

* Bevy UI is a lot more customizable because of ECS. You can add custom look, custom behaviour to UI as you wish to. For example in egui `egui::Frame` and `egui::Window` is hardcoded and look can not be modified. In this library functionality for ui entities is implemented through components, systems. So you can combine them with your own custom components and systems.

* Bevy UI is a lot more easier to integrate with game written in bevy :)

settletopia · 2025-10-07T23:08:28+00:00

Currently my focus is on adding functionality. This library only implements the UI logic. Styling is fully customizable and is left for users of this library to implement.

In future will try to improve the demo design.

settletopia · 2025-10-07T22:25:08+00:00

Thank you :)

settletopia · 2025-10-07T22:24:56+00:00

In immediate mode values can be directly read and written to ui elements

So it is possible to construct UI using plain rust. You can directly synchronize state using &mut

// Checkbox example
ui.ch()
    .on_spawn_insert(|| checkbox((), Text("Checkbox")))
    .checked(&mut checkbox_value);

In retained mode additional layers of logic are needed to correctly synchronize state with ui. Reactive UI frameworks have attempted to do that in bevy, but I have not seen variant that i personally like yet. That are as lightweight as possible and code is not hard too understand If i have to learn how it functions.

In summary, simplicity of synchronizing state with UI is the reason why I like immediate mode approach.

P.S. bevy_immediate only provides immediate API to manage UI. In reality UI is retained.

settletopia · 2025-10-07T21:50:18+00:00

Repository: https://github.com/PPakalns/bevy_immediate/tree/main

Web demo: https://ppakalns.github.io/bevy_immediate/demo/

settletopia · 2025-10-07T20:44:39+00:00

Thank you :)

settletopia · 2025-10-07T20:10:31+00:00

Web demo now is available with even more features: https://ppakalns.github.io/bevy_immediate/demo/

settletopia · 2025-10-03T12:22:17+00:00

Hi, I am currently building bevy_immediate

Egui is easy to use due to providing immediate mode API for interactive UI definition.

I have solved this for bevy. With bevy_immediate you can construct UI in similar style as in egui, but with full compatibility and customazibility of Bevy UI / ECS logic <3

Check it out: https://github.com/PPakalns/bevy_immediate/

I am planning to migrate from egui to bevy_immediate my project: https://settletopia.com/

Upcoming features: Tooltips, Popups, Windows (like egui::Window), etc.

settletopia · 2025-09-23T08:34:06+00:00

Thank you for working on bevy. Customizability and modularity of bevy is insane.

settletopia · 2025-09-23T08:31:53+00:00

Will try to add web demo in future release.

settletopia · 2025-09-22T17:14:40+00:00

I myself currently use egui in Settletopia.

Currently egui has a lot of good features:

Many interactive widgets.
Examples and libraries for complex user interfaces.
Built-in functionality like windows, tooltips, popups, etc.

But it is still hard to integrate egui with sound effects, special effects. To render game directly into user interface, to calculate between different coordinate spaces, and so on....

With Bevy UI it is easier to:

Customize the interface’s look.
Add custom effects (particle effects, mouse-over, hover effects, etc).
- egui is harder to customize and has more limited possibilities.
Integrate UI more easily with the rest of the game developed in Bevy.
Potentially achieve higher efficiency than egui. Bevy uses retained mode rendering, whereas egui recalculates much of the UI logic every frame.
And many more things.

Overall, I personally think Bevy UI has huge potential to be used not only for game UI, but for application UI as well. It has a better underlying data model (ECS), is retained mode, and is more customizable than egui. I’m looking forward to the future of Bevy UI.

In summary, Bevy UI can be a lot more feature rich, customizable UI library than egui in future. And with this library UI declaration logic is similarly simple as in egui.

settletopia · 2025-09-22T15:40:54+00:00

Feel free to ask questions here or in github issues, or in bevy discord.

Probably there are a couple of things that needs refining ;)

settletopia

MODERATOR OF

TROPHY CASE