Consider renaming `bevy_core_widgets` to `bevy_headless_widgets`

[alice-i-cecile]

I'm working on release notes, and I find myself constantly having to explain that the "core widgets are headless", rather than "these are the essential widgets". Instead of this, we should just name the crate / concept something that game devs will immediately grasp.

Previously discussed with @tychedelia, who was in favor. cc @viridia.

[viridia]

Would this also entail renaming all of the widget components as well? Currently they all use the Core prefix: CoreButton, CoreSlider and so on. Or are we only talking about renaming the crate?

I'm not super fond of the word "headless", although I know that term has gained some currency in the web world. I think the word "unstyled" is a bit less fanciful. When I think of "headless" UI, I tend to think of running X11 in headless mode, that is, without an attached display adaptor.

Something like AbstractButton also works, and in some ways is better since the core widgets aren't entirely unstyled - they contain only those styles necessary for the widget to function at all.

What I was aiming at with the name "core" was to say that this is the "kernel" of a widget.

[alice-i-cecile]

Abstract is better than Core. Crate name is most important to me, but I would ideally like if the component names matched.

[BD103]

I'm not super fond of the word "headless", although I know that term has gained some currency in the web world. I think the word "unstyled" is a bit less fanciful. When I think of "headless" UI, I tend to think of running X11 in headless mode, that is, without an attached display adaptor.

If you don't like bevy_headless_widgets, you could always go for bevy_decapitated_widgets >:D

But in all seriousness, I prefer "headless" over "abstract". It's more clear that the logic is detached from the renderer, I think "abstract" is too generic. (As much as it plagued Java, I'd like to avoid that.)

[viridia]

If I had to use the name "headless" I would probably go with something like bevy_ui_headless so that it sorts next to bevy_ui. But I'm hoping for something better: I prefer to name things based on what they are, rather than on what they aren't.

(One of my least favorite product names is "aftershave" which tells you absolutely nothing about what it is or does.)

[atlv24]

Is this essentially some kind of Model/View split? bevy_model_widget? naming it bevy_abstract_widget would be a bit weird but probably fine too. bevy_everything_but_the_widget, bevy_i_cant_believe_its_not_widgets, bevy_proto_widgets, bevy_widget_state?

[viridia]

In order to avoid over-constraining the problem, I think that the issues of the crate name and the component naming convention should be separated. I realize that there's a desire for consistency between them, but this is not an absolute requirement, and in terms of meaning and grammar the two are somewhat distinct. Trying to come up with a single word that fits in both places makes the problem harder.

I think my original choice of the word "core" was subconsciously a double meaning: that the individual components represented the "kernel" or "core" of a widget, but also that the crate as a whole was a collection of "essential" widgets. (This suggests yet another crate name: bevy_widget_essentials.)

By this logic, the component probably should have been called ButtonCore rather than CoreButton, but I didn't care for that option. ButtonKernel might be slightly better.

I don't care for ButtonState because buttons are stateless, although most other widgets aren't. Worse, there may in the future be widgets whose state is stored in a second component.

I don't like using the word "abstract" in the crate name, but for the individual components I think it's fine. I realize that people coming from Java likely have strong feelings about that word, as it's use is somewhat ubiquitous there to represent abstract base classes; and to a lesser extent in Python; but in Rust there's simply no equivalent, the closest we come is traits. So if we want to claim that word, I think it would be ok.

Generally I care less about the aesthetics of the crate name (which, in my code anyway, only appears once per source file in the import statement) than I do about the component names which occur lots of times. I could live with the name "headless" in the crate name, but I don't like it in the names of the components.

Another choice I have been avoiding is to elide the prefix altogether - so CoreButton would be named simply Button. Unfortunately, there's already a Button in bevy_ui, and there's a button() function in feathers (which may eventually turn into a struct if BSN decides to support structs-as-templates, giving us yet another Button). This would mean that explicit qualification of the name would be pretty much mandatory to avoid confusion.

[mgi388]

How about just bevy_widget?

Notes:

• I dislike naming things core (be it crate or component), it means nothing to me and IMHO is as bad as common, base, util and utils.
• I said bevy_widget not bevy_ui_widget because it seems obvious that widgets are UI things but both of these are fine. Possibly I might actually lean to bevy_ui_widget because lately I’ve felt that you can read that crate name to know it will depend on bevy_ui (which I think this does). It’s not normative but I noticed the Zed codebase doing this and I started to do it.
• Singular not plural. IMHO it doesn’t matter if it contains multiple things just name the crate/package/module singular. Same reason I prefer bevy_camera_controller (just saying).

As for the Core in component name, maybe put widget in it, e.g., ButtonWidget. It reads nice: “this is a button widget component”

FWIW I dislike CoreButton and ButtonCore (please don’t put Core at the end!)

Thanks for the invitation to the bike shed.

[ickshonpe]

We already chose to put the qualifier at the end for other subcrates, like bevy_input_focus, bevy_sprite_render, and bevy_ui_render. So I think any one from bevy_widgets_core, bevy_ui_widgets_core, bevy_ui_widgets, or just bevy_widgets would be an improvement.

I've never really liked the bevy_core_widgets and Core<widget-name> naming scheme, but I don't haven't have any obviously better suggestions. I don't like headless either or abstract.

[radiorobin]

I noticed that Cart referred to it as Bevy Standard Widgets in the Fifth Birthday post which isn't terrible and gets the point across clearly. But I also agree bevy_widget(s) or bevy_ui_widget(s) would work perfectly fine, the simplest solution is usually best.

Regardless of which name is chosen it really should either imply that these are supposed to be generic or that this is simply the bevy implementation and thus you are free to build upon it. (something headless doesn't immediately communicate imo)

[janhohenheim]

I like headless, and I like prefix/suffixless. Whatever you do, just remove Core :p