iris-aiandClaude Opus 5
d21a21524f
Bryan's call, 2026-09-16: a length and an alignment are properties of one widget, so a widget cannot both be 100 wide and take two shares of a row -- that needs two widgets, and the second one should do as little as possible. `WidgetPtr` already was that widget: it draws its child in the whole of its box and reports what the child said. It only lacked a name that says so and a way to make one around an existing widget. `Wrapper` rather than `Wrap` so it cannot be read as the text setting, and `.wrapper()` rather than `.wrapped()` for the same reason. Its child stays optional, since being a swappable slot is what it was written for and what the tab bar still uses it as. `set_ptr` is deleted rather than renamed. It had no caller, and putting a widget into an existing wrapper is what `Wrapper::set` already does. `tabs` draws its centred square again: `.sized((100, 100)).center() .wrapper().width(leftover(2))` is two widgets where the chain without `.wrapper()` was one, and `.width` was overwriting what `.sized` set. That was the last of the three ways `tabs` had drifted from canonical `main` unnoticed; what is left between them is the truncated multiply's antialiased edges and the widget count itself. `widget_trait!` takes no attributes, so `.wrapper()` carries an ordinary comment and the explanation lives on `Wrapper`. Checked: fmt, clippy, 83 suite tests, 17 core unit tests, the release oracle at 100 seeds, and `tabs` rendered at 1920x1200 against `main`'s own. Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
iris
My experimental attempt at a rust ui library (also my first ui library).
It's currently designed around using retained data structures (widgets), rather than diffing generated trees from data like xilem or iced. This is an experiment and I'm not sure if it's a good idea or not.
Examples are in examples, eg. cargo run --example tabs.
Goals, in general order:
- does what I want it to (text, images, video, animations)
- very easy to use ignoring ergonomic ref counting
- reasonably fast / efficient (a lot faster than electron, save battery life, try to beat iced and xilem)
dev details
not targeting web rn cause wanna use actual nice gpu features & entire point of this is to make desktop apps / not need a web browser
general ideas trynna use rn / experiment with:
- retained mode
- specifically designed around wgpu so there's no translation
- postfix functions for most things to prevent unreadable indentation (going very well)
- events can be done directly where you draw the widgets
- almost no macros in user code & actual LSP typechecking (variadic generics if you can hear me please save us)
- relative anchor + absolute offset coord system (+ "rest" / leftover during widget layout)
- single threaded ui & pass context around to make non async usage straightforward (pretty unsure about this)
- widgets store outside of the actual rendering so they can be moved around and swapped easily (unsure about this but seems to work good for now)
under heavy initial development so not gonna try to explain status, maybe check TODO for that; sizable chance it gets a rewrite once I know everything I need and what seems to work best
it's called iris because it's the structure around what you actually want to display and colorful