Vendor iris, the in-house UI library, at iris/

Iris's decision: it lives in this repository for now, included by path,
with its history left in the iris/iris repository on the gitea remote
(this is its main at 7b54aaf, byte-identical to the public GitHub copy).
It gets its own repository back once it has proved itself here.

RUST.md's I0 records the decision and what the first build said: the
tree does not compile on the current nightly because const_trait_impl
now requires traits to be declared 'const trait', which is the first
item of I0b.

Co-Authored-By: Claude Fable 5.1 <noreply@anthropic.com>

.gitignore

@@ -21,3 +21,6 @@ certs/
 config.ron
 config.json
 sessions/
+
+# iris, the in-house UI library, is vendored at iris/ and built by cargo.
+iris/target/

AGENTS.md

@@ -46,6 +46,10 @@ Module-by-module intent is in PLAN.md's "Backend layout".
   before touching `TranscriptCache.kt`, `TranscriptSource.kt`, or the opening
   and stream effects in `SessionScreen.kt`.
 - `TODO.md` — the working list.
+- `RUST.md` — the plan for moving the app to Rust (on the `rustify`
+  branch of the `ai-app-2` clone): what has to be reproduced, the
+  framework decision, and the ordered experiments with their pass
+  conditions. Read it before touching anything under that branch.
 - `.dev-updater.ron` — what Dev Updater builds here: the server (run as
   `service: Managed(…)`, supervised by Dev Updater's own implementation
   rather than a script kept here) and the APK, in parallel. It points at

RUST.md

@@ -0,0 +1,611 @@
+# Moving the app to Rust
+
+Working document for the question Iris asked on 2026-09-04: what are the
+options for switching the phone app to Rust, ideally pure Rust with one UI
+framework shared with a future winit-based desktop application, at full
+feature parity and without giving up anything native, performance
+especially. Constraints she set: no Dioxus and nothing that draws through a
+WebView; **no UI DSL** (which rules out Makepad and Slint); the result
+should stay lightweight; platform-specific pieces are fine to maintain;
+reimplementing a framework piece from scratch where it does not fit is
+fine; effort and elapsed time do not matter, long-term robustness does;
+this clone is where things get tried before anything is committed to
+`ai-app`. Her own library, [iris](https://github.com/cat16/iris), is the
+**in-house framework to be built up** for this, with Masonry as the
+yardstick it is measured against.
+
+Decisions get a date and a reason here, the way `PLAN.md` does. Nothing in
+this file has been tried yet unless a section says it has.
+
+## What has to be reproduced
+
+The app is ~19,000 lines of Kotlin. It splits three ways, and the split is
+what decides how much of a port is mechanical.
+
+**Pure logic with no Compose or Android in it, ~4,500 lines.** `Api.kt`
+(1,142), `Events.kt`, `EventStream.kt`, `Sse.kt`, `TranscriptCache.kt`
+(589, touches `java.io.File` only), `TranscriptSource.kt`,
+`MarkdownSyntax.kt`, `Languages.kt`, `Highlighter.kt`, `Ansi.kt`,
+`ResetCountdown.kt`, `Durations.kt`, `Sizes.kt`, `ModelName.kt`,
+`LoadState.kt`, `ImportableStream.kt`. `TranscriptUnits.kt` and
+`TranscriptItems.kt` (the event fold into rows, ~940 lines) are logic with
+a handful of Compose annotations. This is also exactly the code that has
+JVM unit tests today. All of it ports directly, and most of it already has a
+Rust twin in `server/`: `Events.kt` is a hand-kept mirror of
+`session/driver.rs`'s enum, the highlighter and the syntax scanner exist on
+the server for the explorer, and the cache compares the server's own JSON
+lines. **Sharing these types between server and app is the single largest
+"keep things in sync" win available, and it does not depend on which UI
+framework wins.**
+
+**Compose UI, ~13,000 lines.** Screens, dialogs, the transcript list, the
+markdown renderer's customisations, tool cards, the file explorer viewer and
+editor. This is the part a UI framework choice is about.
+
+**Android platform code, ~1,500 lines**, spread over 20 files. Every one of
+these is a Java-side object that no Rust framework can replace, because
+Android only offers them as Java classes:
+
+- `NotificationService` — a **foreground service** holding the
+  `/notifications` SSE stream while the app is closed, with its ongoing
+  notification, `specialUse` type and the `POST_NOTIFICATIONS` request.
+- `MainActivity` — edge-to-edge, the `ACCESS_LOCAL_NETWORK` runtime
+  permission (Android 17), `singleTop` intent routing for `aiapp://enroll`,
+  notification taps, and the **share sheet** (`ACTION_SEND`, any MIME type).
+- `ServerConfig` — the bearer token sealed under an **Android Keystore**
+  AES-GCM key, shared with Dev Updater through `wg-app-link`'s `:link`.
+- `EnrollmentScanActivity` — the in-app **QR scanner** (zxing, camera).
+- `Attachments` — `ContentResolver` reads of shared URIs, `BitmapFactory`
+  decode and downscale, **EXIF** orientation.
+- `SessionImage` — bitmap decode for produced images.
+- `ScrollAnchor`, `Drafts` — `SharedPreferences`; `CrashLog` — `filesDir`.
+- `TranscriptCache` — `cacheDir`.
+- `DebugStats`/`FrameStats` — `Choreographer` frame timing and the render
+  report; `runtime-tracing` names composables in a system trace.
+
+So **"pure Rust" on Android means Rust owns every line of logic and
+drawing, behind a thin shell of Java stubs**, and a packaging step that
+produces a signed APK. How thin, and whether Gradle is inevitable, are
+answered below.
+
+### How much Java is unavoidable, and why
+
+Rust can *call* any Android API through JNI (`jni` crate, with
+`ndk-context` handing over the `JavaVM` and the Activity): posting a
+notification, `startForegroundService`, the Keystore, `ContentResolver`
+reads, permission requests, `WindowInsets`, the clipboard. None of that
+needs a line of Kotlin. What JNI cannot do is *define* a class that the
+system instantiates **by name from the manifest** — an `Activity`, a
+`Service`, an `Application`, a `BroadcastReceiver`. Those must exist as dex
+bytecode inside the APK before any Rust runs, because the framework
+constructs them and only then calls into native code. `NativeActivity` is
+the platform's own stub for the Activity case; there is no
+`NativeService`, and android-view ships its own `View` subclass for the
+same reason.
+
+So the floor is roughly **two Java classes of ten lines each**: an
+`Activity` and a `Service` whose lifecycle methods are declared `native`
+and registered from `JNI_OnLoad`, plus whatever android-view already
+provides. Everything they would have done in Kotlin — insets, intent
+routing, the SSE follow loop, the notification builder — is Rust reached
+through those stubs. Writing the stubs in Java rather than Kotlin drops
+`kotlinc` from the toolchain; `javac` comes with the JDK Gradle already
+needs. Generating the dex from Rust is not worth it: there is no mature
+Rust dex writer, and the stubs never change.
+
+### Can the APK be built without Gradle?
+
+Yes. An APK is a zip containing a binary-XML `AndroidManifest.xml`,
+`resources.arsc`, `classes.dex`, `lib/<abi>/*.so` and assets, aligned and
+signed with the v2 scheme. The tools are `aapt2` (manifest and resources),
+`d8` (Java bytecode to dex), `zipalign` and `apksigner`, all in the SDK's
+`build-tools`, none of them Gradle. Three ways to drive them:
+
+- **A `cargo xtask`** (or `build.rs`-adjacent script) that runs `cargo ndk`
+  for each ABI, `javac` + `d8` for the stubs, `aapt2 link`, `zipalign`,
+  `apksigner`. About 150 lines, every step visible, no AGP, no Gradle
+  daemon holding 2.8 GB between builds. The pinned-CA constant becomes a
+  `build.rs` reading the same `certs/ca.pem` path.
+- **[cargo-apk2](https://github.com/mzdk100/cargo-apk2)**: the maintained
+  successor to cargo-apk, and unlike it compiles `java_sources` /
+  `kotlin_sources` into the dex and declares multiple activities **and
+  services** with intent filters from `[package.metadata.android]`, with
+  per-profile keystores and optional `aapt2`. Exactly the shape needed;
+  the question is whether a third-party tool with one maintainer beats
+  150 lines we own.
+- **cargo-apk / xbuild**: unmaintained and `NativeActivity`-only. No.
+
+What Gradle would take with it: Android Lint (which found two real bugs
+here, but in Kotlin that would no longer exist — with forty lines of Java
+stubs there is little left for it to find), manifest merging, R8, and the
+generated-source plumbing. What it gives back: one toolchain, `cargo`
+end to end, and Dev Updater keeps calling `build-apk.sh` exactly as now.
+**Recommendation: the xtask**, with cargo-apk2 read for the details it
+already got right (v2 signing, `uses-feature`, ABI splits).
+
+### The behaviours that are hard to get back
+
+Reading the Compose code for what a replacement must be able to express,
+rather than what it happens to look like:
+
+1. **The transcript is one selectable body of text.** One
+   `SelectionContainer` around the whole lazy list, so a selection runs from
+   a reply into the tool output beneath it. The framework needs selectable
+   read-only rich text across many rows, with the platform's selection
+   handles and clipboard on the phone.
+2. **Rich inline text**: markdown with links (one tap detector per text,
+   not a node per link), inline code chips drawn behind the text, tables
+   with wrapping cells and a sideways scroll, syntax-highlighted fences,
+   ANSI colour in tool output, Nerd Font icon glyphs. Needs a text layout
+   engine with spans, not just styled labels.
+3. **A bottom-anchored virtualised list of variable-height rows**, paged in
+   both directions (800-event pages, `HISTORY_SCREENS` measured in
+   viewports), with a saved scroll anchor per session, "hold the edge
+   nearest the tap" when a row expands (`holdTopEdge`, done in the layout
+   pass so the wrong frame is never drawn), and rows keyed so that a run of
+   tool calls stays one row while it grows.
+4. **The soft keyboard**: the composer resizes with the IME, the guard
+   against a stuck inset animation, drafts per session, autocorrect and
+   suggestions from the phone's own keyboard. This is where most Rust
+   frameworks fail on Android today; see below.
+5. **Platform integration through the app model**: foreground service,
+   notifications, share sheet, deep link, Keystore, camera, back gesture,
+   edge-to-edge insets, local-network permission.
+6. **Accessibility names on icon buttons**, which the bench scripts depend
+   on (`ui-trace` taps by label). A framework with no accessibility tree
+   also breaks the measuring rig.
+7. **Measurable frames**: the debug render report, and a way to attribute
+   a frame's cost to a widget on the real phone.
+
+## The two constraints that decide it
+
+**1. Android text input.** Every framework built on `winit` inherits
+winit's Android backend, and that backend cannot drive the soft keyboard
+properly: the IME tracking issues
+([#1823](https://github.com/rust-windowing/winit/issues/1823),
+[#2766](https://github.com/rust-windowing/winit/issues/2766)) are open,
+`ReceivedCharacter` is unimplemented on Android
+([#2305](https://github.com/rust-windowing/winit/issues/2305)), and the
+`android-activity` groundwork for editor actions only merged in February
+2026 ([PR #214](https://github.com/rust-mobile/android-activity/pull/214))
+with the winit half still to come. Composition, autocorrect and suggestions
+need an `InputConnection` implemented on the Java side, which winit's
+`NativeActivity`/`GameActivity` model does not offer. The frameworks that
+type on Android today each wrote their own Java glue (Slint, Makepad), and
+the one designed to do it the way Android intends is
+[`android-view`](https://github.com/rust-mobile/android-view): a Rust
+implementation of an Android `View`, with text input through
+`InputConnection`, accessibility, touch, callbacks on the UI thread, usable
+either as a whole app or embedded beside ordinary Android components. It is
+marked WIP. Both Linebender (its Masonry demo lives in that repo) and
+Robius/Makepad ([Robrix's release notes](https://github.com/project-robius/robrix/releases)
+say Android lacks a "full" keyboard and they are integrating android-view
+for it) are converging on it. **That makes android-view the phone-side
+foundation whichever widget set sits on top**, and the first thing to
+build and measure here.
+
+**2. Rich, selectable text and a virtualised list.** Frameworks group by
+their text stack:
+
+- **Parley + Fontique + Vello** (Linebender): rich spans, selection and
+  editing utilities, IME support driven through `ui-events`, AccessKit text
+  properties ([Linebender 2026 Q1](https://linebender.org/blog/tmil-25/),
+  [parley](https://github.com/linebender/parley)). Used by Masonry/Xilem,
+  and by Blitz. Vello proper needs compute shaders; `vello_hybrid` (CPU
+  path processing, GPU compositing) is "roughly beta" and runs on GLES too,
+  and Vello CPU exists as a no-GPU fallback.
+- **cosmic-text** (iced, egui optionally): good layout, but the widgets on
+  top decide selection. iced's `markdown` widget is not selectable
+  ([discourse](https://discourse.iced.rs/t/markdown-widgets-text-should-be-selectable/1107)).
+- **Slint's own**: `TextInput` with `read-only` is the selectable-text
+  trick; there is **no inline rich text at all** (issue
+  [#1325](https://github.com/slint-ui/slint/issues/1325), markdown request
+  [#6684](https://github.com/slint-ui/slint/issues/6684) both open). A
+  markdown transcript with links and code chips cannot be drawn.
+- **Makepad's own**: GPU/SDF text, a `Markdown` widget and a virtualised
+  `PortalList` in `makepad-widgets`.
+
+## Options
+
+### A. Keep Compose, move the logic into a Rust core (uniffi)
+
+A `client-core` crate (events shared with the server, API client, SSE,
+transcript fold, cache, markdown model, highlighter, ANSI) exposed to
+Kotlin through [uniffi](https://github.com/mozilla/uniffi-rs). Compose keeps
+drawing. Desktop would be a second UI (iced or Compose Desktop) over the
+same core.
+
+- **For**: the logic and the wire types stop drifting from the server
+  today, with tests in one language. Incremental and always shippable.
+- **Against**: it is not what was asked for. The 13,000 lines of UI stay
+  Kotlin, the desktop app shares no UI code, and the `:link` Kotlin module
+  stays. uniffi's Kotlin Multiplatform bindings are a
+  [community fork](https://github.com/UbiqueInnovation/uniffi-kotlin-multiplatform-bindings);
+  the Android-only bindings are Mozilla's and solid.
+- **Verdict**: not the destination, but **step one of every other option**
+  is building this crate, so it costs nothing to keep it as the fallback.
+
+### B. Slint
+
+Rust on Android is officially supported (minSdk 26, `android-activity`
+backend, own Java IME glue, safe areas and keyboard insets since 1.15,
+Skia renderer needs `clang`). Royalty-free licence requires disclosing
+Slint use; GPLv3 otherwise. UI is a separate `.slint` DSL, not Rust.
+
+- **Against**: no rich inline text (see above), so the transcript cannot be
+  drawn as it is today; the UI language is not Rust, which forfeits the
+  "compiler catches it" motivation for the half of the code that is UI.
+- **Verdict**: rejected on rich text alone.
+
+### C. iced
+
+Elm-style, Rust-only widgets, desktop-first, `winit` + `wgpu`. Has a
+`markdown` widget and `rich_text` with links. The maintainer states mobile
+is a non-goal ([iced](https://github.com/iced-rs/iced)); a community
+Android example exists and its author could not get the soft keyboard
+working, patched widgets for touch, and notes no accessibility
+([HN thread](https://news.ycombinator.com/item?id=46350641)). Markdown is
+not selectable; `scrollable` is not virtualised.
+
+- **Verdict**: a fine desktop toolkit and the one Iris named, but every
+  phone-side gap (IME, touch, accessibility, selection, virtualisation)
+  would be ours to build and maintain against a project that does not want
+  them. Not the shared framework.
+
+### D. egui
+
+Immediate mode, `winit`-based on Android, AccessKit integration,
+selectable labels across a `Ui`. Repaints only on input by default, so
+battery is not the immediate-mode worry. Android IME is blocked on winit
+([discussion](https://github.com/emilk/egui/discussions/2053)); the
+workaround is an in-app virtual keyboard, which is exactly the
+non-native keyboard to avoid. Variable-height virtualised lists are manual
+(`show_rows` assumes uniform heights). Looks like egui, not Material.
+
+- **Verdict**: workable on desktop, wrong on the phone for the same reason
+  as iced, plus a look that would need a full custom style.
+
+### E. Makepad
+
+GPU-rendered, hybrid retained/immediate, `live_design!` DSL with hot
+reload, MIT, 1.0 in 2025 ([makepad](https://github.com/makepad/makepad)).
+Ships Android apps today with its own Java glue; Robrix (a Matrix chat
+client, the closest analogue to this app) is its reference application on
+Android, iOS and desktop. Has `Markdown`, `PortalList` (virtualised),
+`TextInput`. Robrix reports the Android keyboard is not "full" and is moving
+to android-view for it; the README says non-standard targets "may require
+minor fixes".
+
+- **For**: the only option that already ships a chat-shaped app on Android
+  and desktop from one codebase, with the widgets this app needs.
+- **Against**: the DSL is its own language with its own shader-based
+  styling, so a large part of the UI would not be checked by rustc; the
+  rendering model (SDF everything) is a different world from Compose's,
+  and selection across a `Markdown` widget is unverified.
+- **Verdict**: **rejected 2026-09-04** — Iris does not want a DSL. Kept
+  here so its Android keyboard status stays a data point about
+  android-view, not as an option.
+
+### F. Masonry / Xilem on android-view (Linebender)
+
+Retained widget tree (Masonry) with a reactive view layer (Xilem) that
+reads like Compose; Rust all the way down; Vello, Parley, Fontique,
+AccessKit, `ui-events`. Widgets include `Prose` (selectable read-only rich
+text), `TextArea`, `VirtualScroll`, and this year `Svg`, `Split`,
+`CollapsePanel`, a new layout system, and IME through `ui-events`
+independent of winit. `masonry_android_view` exists in the android-view
+repo and is "not yet generally usable"; Xilem calls itself experimental.
+Desktop runs on winit. Vello needs a compute-capable GPU or falls back to
+`vello_hybrid`/CPU.
+
+- **For**: the only stack where every hard behaviour above maps onto a
+  component designed for it: selection and rich text (Parley/Prose),
+  virtualised variable heights (`VirtualScroll`), native IME
+  (android-view's `InputConnection`), accessibility (AccessKit, now with an
+  Android crate), one Rust widget language on both platforms. The team is
+  the one writing the Android integration everyone else is adopting.
+- **Against**: pre-1.0 with API churn each release; a small team; no
+  Material widget set, so every control's look is ours; some of the pieces
+  (`masonry_android_view`, `vello_hybrid`) are explicitly unfinished. Being
+  early means fixing things upstream ourselves, which Iris said is
+  acceptable.
+- **Verdict**: **the option to try first**, because it is the only one
+  whose gaps are "not finished yet" rather than "not designed for this".
+
+### G. iris — the in-house library, and what "from scratch" means here
+
+[cat16/iris](https://github.com/cat16/iris), read 2026-09-04 from the one
+public commit (2026-01-31, "portfolio copy"; ~8,700 lines in `core`,
+`macro` and the crate itself). Retained-mode widgets stored outside the
+render tree, `wgpu` 28 directly, `winit` 0.30, `cosmic-text` 0.16, a
+relative-anchor-plus-offset layout with `rest()` and `rel()` lengths, a
+postfix builder API (`rect(..).radius(30).on(CursorSense::click(), ..)
+.sized(..).align(..)`), events handled where the widget is declared, and
+a single-threaded context passed explicitly — all of which reads like this
+codebase's own rules. There is text editing (`widget/text/edit.rs`),
+images, masks, spans and stacks; the TODO names text resizing as
+per-frame slow and scaling as unsolved. It requires **nightly** (fourteen
+`#![feature]` gates, among them `const_trait_impl`, `unboxed_closures`,
+`portable_simd`, `associated_type_defaults`). Desktop only; no Android
+surface, no IME, no accessibility tree, no virtualised list, no rich-text
+selection.
+
+**iris is not a candidate to be tested as it stands. It is the in-house
+library** (Iris, 2026-09-04): "essentially a good start to a rewrite from
+scratch", to be maintained and extended by the sessions working here.
+So the list above of what it lacks is a **work list, not a score**. When
+the app needs something iris does not have, the answer is to build it
+into iris. The layer iris has is the widget and layout layer; the layers
+it needs are the same ones Masonry gets from android-view, Parley and
+AccessKit, and there is no reason iris cannot sit on those same
+foundations rather than reinvent them — the surface, the keyboard bridge
+and the accessibility tree are platform plumbing, not a framework's
+identity. Whether the text stack stays cosmic-text or moves to Parley is
+the first real design decision in that work (see I1 below).
+
+Two things to carry into that work honestly. Nightly is the opposite of
+"holds up long term": a build that breaks on a toolchain update, on the
+machine Dev Updater builds on, unattended. Pin a dated nightly in
+`rust-toolchain.toml` immediately, and keep a list of which `#![feature]`
+gates are load-bearing so they can be retired as they stabilise or are
+designed around. And a one-person framework carries every gap itself,
+which is what Iris said she is willing to do.
+
+"From scratch" therefore means iris, not a fourth thing. Masonry stays in
+the plan as the **yardstick and the fallback**: building its demo and its
+version of the transcript screen first says what a finished stack costs
+on this hardware, proves android-view before iris depends on it, and
+gives a comparison that is measured rather than remembered.
+
+Not considered further: **GPUI** (Zed) mobile is a community fork that
+depends on unpublished crates; **Dioxus/Blitz** is excluded by Iris (its
+native renderer is Parley/Vello under HTML semantics, and the earlier
+`tdep-survey/app-dioxus` spike parked it on a `vello_hybrid` stroke bug and
+shipped the WebView); **Compose Multiplatform Desktop** would give a desktop
+app for nothing but in Kotlin, which is the opposite direction.
+
+### Weight and debug builds
+
+Iris remembers the Linebender stack being slow in debug. What is behind
+that is the dependency graph — Vello, wgpu, Parley, Fontique, Skrifa —
+running unoptimised on the CPU side (path encoding, shaping), not the
+widget layer. Xilem's own advice is only `split-debuginfo = "unpacked"` to
+keep `target/` small; the fix everyone with this shape of dependency tree
+uses is to optimise dependencies while leaving the app crate at `opt-level
+= 0`:
+
+    [profile.dev.package."*"]
+    opt-level = 2
+
+E1 measures this rather than remembering it: cold and incremental build
+time, APK size, resident memory at rest and while streaming, and the
+frame cost of one 800-event page — for the Masonry demo as shipped, then
+with the profile above. Vello proper needs compute shaders and carries a
+large shader set; `vello_hybrid` is lighter and Masonry can now render
+through either (or Vello CPU) via its `imaging` abstraction, so "keep it
+light" has a knob inside the same stack.
+
+## Recommendation
+
+1. **Build `client-core` now, whatever the framework.** A Rust crate holding
+   the event model (shared with `server/` as one crate, ending the
+   `Events.kt` mirror), the API and SSE clients, the transcript fold, the
+   cache, the markdown block model, the highlighter and the ANSI parser,
+   with the existing JVM tests ported. It is the part of the app that is
+   already tested, already logic, and already duplicated on the server.
+2. **One foundation, two widget layers.** The platform plumbing is shared
+   whichever way the decision goes: android-view for the Android surface,
+   keyboard and accessibility bridge; `wgpu` for the GPU; AccessKit for
+   names; winit on the desktop. On top of it, **Masonry as the yardstick**
+   (E1, E2) and **iris as the thing being built** (I0–I5), both aimed at
+   the same transcript screen with the same pass conditions.
+3. **Decide when the transcript screen exists in both**, from the
+   measurements, and record the decision here with the numbers. If iris
+   carries the screen within the Compose baseline, it is the app's
+   framework and Masonry was the calibration. If it does not, the
+   measurement says which parts of Masonry to adopt underneath it.
+4. Then the shell (E3), the desktop window (E4) and the packaging (E5),
+   which do not depend on the choice.
+
+## Experiments, in order
+
+Each has a pass condition that is a measurement in this clone. The rig
+matters: this emulator runs `-gpu host` with **host Vulkan switched off**
+(`GPU_HOST_FEATURES` in `emulator-tools`, a gfxstream/Venus gap), so inside
+the guest a `wgpu` app gets GLES, not Vulkan; the earlier Dioxus spike also
+needed `WGPU_GLES_MINOR_VERSION=1` for compute shaders and found `wgpu`'s
+Android backend wants API 26 (a libc symbol). The real phone has Vulkan.
+Per the standing rule, a rig limit is something to fix before it is
+accepted.
+
+- [ ] **E0 — toolchain.** No NDK is installed (`~/Android/Sdk/ndk` is
+      empty; the Android Rust targets are). Install the NDK under the
+      user-owned SDK, `cargo-ndk`, and record the versions here.
+- [ ] **E1 — android-view's Masonry demo on this emulator.** Pass: it
+      builds with `cargo-ndk` + Gradle, renders on the GPU, and the phone's
+      own keyboard types into its editor with autocorrect and suggestions.
+      Note which `wgpu` backend it took and any environment flags needed.
+- [ ] **E2 — a transcript in Masonry.** One screen: open a sandbox session,
+      page 800 events into `VirtualScroll` bottom-anchored, draw markdown
+      from `pulldown-cmark` into Parley rich text with links and code
+      chips, select across two rows with the platform handles, expand a
+      tool row holding its top edge. Pass: the render numbers land within
+      the Compose baseline in `transcript-bench.sh` on the GPU emulator
+      (same gestures, same session), and every one of the seven behaviours
+      above is either shown or has a written reason it cannot be.
+- [ ] **E3 — the shell.** Kotlin `MainActivity` + `NotificationService`
+      + Keystore + share intent calling into Rust over JNI, with the SSE
+      follow loop in Rust. Pass: a notification arrives with the app
+      closed, and a share lands in a session.
+- [ ] **E4 — the same screen on the desktop** in a winit window, from the
+      same crate, with only the layout differing.
+- [ ] **E5 — the packaging xtask**: `cargo ndk` → `javac`/`d8` → `aapt2`
+      → `zipalign` → `apksigner`, signed with the existing release key,
+      installed through Dev Updater. Pass: the APK installs over the
+      Gradle-built one and the notification service starts.
+
+### The iris track
+
+These build iris up to carry the app. Each is a feature added to iris
+with a pass condition, in dependency order. Work in `iris/` in this
+repository on the `rustify` branch, and record in this file what each
+step measured.
+
+- [x] **I0a — where iris lives (decided 2026-09-04).** For now it is
+      **vendored at `iris/` in this repository**, history not carried,
+      and consumed by path. Iris's decision: keep it close while it is
+      being reshaped for this app, and give it back its own repository —
+      `iris/iris` on the gitea remote, which already holds the full
+      244-commit history, on a branch of its own — once it has proved
+      itself. The vendored tree is that repository's `main` at
+      `7b54aaf` ("readme", 2026-01-29), byte-identical to the public
+      GitHub copy, so a later reconciliation has a known base. A crate
+      that uses it says `iris = { path = "../iris" }`.
+- [ ] **I0b — make it build here.** Pin a dated nightly in
+      `iris/rust-toolchain.toml` (the machine has
+      `nightly-x86_64-unknown-linux-gnu`, rustc 1.100.0-nightly
+      2026-08-25); list every `#![feature]` gate with what it is for, so
+      each can be retired when it stabilises. Get `cargo build`, `clippy`
+      and `fmt` clean at the defaults and the `tabs` example running in a
+      window (this VM has no display: a headless compositor is what
+      `emu` uses for the emulator, and the same trick serves here).
+      Pass: a fresh clone builds unattended from the pinned toolchain.
+      **Measured 2026-09-04**: `cargo +nightly check` on that nightly
+      fails in `iris-core` with 36 errors, all one cause — the
+      `const_trait_impl` feature changed shape between January and
+      August: `impl const Trait for T` is now rejected with "expected a
+      trait, found type" unless the trait itself is declared
+      `const trait`, at seven sites (`num.rs`, `align.rs`, `axis.rs`,
+      `pos.rs`, `color.rs`, `math.rs`, `vec2.rs`), and the unresolved
+      `UiVec2`/`Vec2`/`impl_op` imports cascade from those. That is the
+      nightly-drift risk in one build; the fix is mechanical (declare
+      the traits `const trait`), and it is the first item of I0b rather
+      than pinning back to a January nightly, which would only defer it.
+- [ ] **I1 — the text stack decision.** iris uses cosmic-text; the
+      transcript needs rich inline spans (links, code chips, colour),
+      selection across many widgets with the platform's handles on the
+      phone, and an editor the IME can drive (composition regions, not
+      just committed characters). Compare cosmic-text and Parley against
+      exactly those three, in iris, on a real transcript's text. Parley
+      is the expectation because android-view's IME bridge and AccessKit's
+      text properties are written against it; measure rather than assume.
+      Pass: a written decision here with what each was tried on, and the
+      TODO's "text resizing per frame is really slow" measured and either
+      fixed or explained.
+- [ ] **I2 — iris on android-view.** An `android-view` surface as a second
+      backend beside winit: `wgpu` on the view's surface (GLES here, see
+      the Vulkan section; Vulkan on the phone), touch as pointer events,
+      window insets and the keyboard inset as layout inputs, the back
+      gesture as an event, the IME bridge feeding the editor from I1.
+      Pass: the `tabs` example and a text field run on the emulator, and
+      the phone's own keyboard types into the field with autocorrect and
+      suggestions — the same bar as E1.
+- [ ] **I3 — a virtualised, bottom-anchored list.** Variable-height rows,
+      keyed, composed only while visible, paged in both directions with a
+      "more" sentinel at each end, a scroll anchor that survives rows
+      being inserted above, and "hold the edge nearest the tap" done in
+      the layout pass. Pass: 800 rows of real transcript text from the
+      sandbox scroll without a frame over the Compose baseline in
+      `transcript-bench.sh`, measured on the GPU emulator.
+- [ ] **I4 — accessibility names via AccessKit.** Every control carries a
+      name; `ui-trace` can find and tap it by label. Pass: `bench-lib.sh`'s
+      tap-by-name works against the iris screen unchanged.
+- [ ] **I5 — the transcript screen in iris.** E2's pass conditions, all
+      seven behaviours, against the sandbox with `--delay`. This is the
+      point the decision in the recommendation is made at.
+
+## For the next agent
+
+What to do when you pick this up, in order, so nothing here has to be
+re-derived:
+
+1. Read this file, then `AGENTS.md` and `PLAN.md`. The rules there
+   (measure, do not read; fix the rig before accepting its limits; the
+   emulator is this checkout's own) all apply.
+2. Work on the **`rustify`** branch of this clone (`ai-app-2`), not on
+   `main` and not in `ai-app`. Nothing on this branch is production until
+   Iris says so. Commit and push as you go.
+3. Take the next unchecked box above, in order: E0 first, then E1, then
+   the iris track from I0. E-steps and I-steps can proceed in parallel in
+   separate sessions once E1 has proved android-view on this emulator.
+4. Every step ends with its measurement written into this file beside the
+   box, and the box ticked or the reason it could not be written in its
+   place. A step that is blocked says by what, not "later".
+5. Run the existing rigs rather than inventing new ones: `ui-sandbox.sh`
+   for a server with fixtures, `transcript-bench.sh` for the scroll
+   baseline, `ui-trace` for anything positional, `emu up` for the
+   emulator. The Vulkan section below says how to get a Vulkan path in the
+   emulator when a `wgpu` backend needs one.
+6. Decisions belong here with a date and what was rejected, the way
+   `PLAN.md` does it. Do not put design into commit messages alone.
+
+### Vulkan in the emulator (measured 2026-09-04)
+
+A `wgpu` app in this emulator was going to get GLES only, because host
+Vulkan is switched off in `emulator-tools`. Retried today on Mesa
+26.1.7: **Venus still fails the same way** — gfxstream picks
+`externalMemoryMode: OpaqueFd`, probes `VK_FORMAT_R8G8B8A8_UNORM` for an
+exportable colour buffer, and Venus says the format is unsupported
+(`Failed to find memory type for ColorBuffers`, fatal before adb sees the
+device). Venus does advertise `VK_KHR_external_memory_fd` and
+`VK_EXT_external_memory_dma_buf`, so the gap is specifically opaque-fd
+image export. gfxstream has a string-valued `VulkanExternalMemoryMode`
+setting ("overrides what would otherwise be determined automatically"),
+but `-feature Name=Value` is rejected as a bad feature name, and the only
+mode words compiled into this emulator's `libgfxstream_backend.so`
+(37.1.11) are `OpaqueFd`, `Metal` and `none` — there is no dma-buf mode
+in this build to switch to. So Venus is blocked by the emulator, not by
+Mesa; retry when the emulator package updates, since upstream gfxstream
+does have dma-buf external memory.
+
+What **does** work: pointing the emulator's Vulkan loader at the software
+ICDs the emulator ships itself, with the feature enabled:
+
+    VK_DRIVER_FILES=$HOME/Android/Sdk/emulator/lib64/vulkan/vk_swiftshader_icd.json \
+    GPU_HOST_FEATURES="-feature Vulkan" emu up
+
+The guest then reports Vulkan 1.3 (`cmd gpu vkjson`, SwiftShader
+Subzero) while GLES still runs on the real GPU through virgl — so a
+Vello/wgpu app can take its real Vulkan path here, with compute shaders,
+CPU-rasterised. That is enough to test *correctness* of the Vulkan path
+in the emulator; GPU *performance* of it is a phone measurement either
+way, exactly as `MACHINE.md` already says about frame times. **lavapipe**
+(`lvp_icd.json`, the other ICD the emulator ships) selected llvmpipe and
+booted, then the emulator died right after loading the `default_boot`
+snapshot with nothing in the log; a snapshot saved under a different
+Vulkan device is the suspect, and `-no-snapshot-load` is the untested
+next step. SwiftShader is the one that works today.
+Making this an `emu` option belongs in `emulator-tools` and is a shared
+tooling change, so it goes through the other sessions first.
+
+## Things a Rust app changes elsewhere
+
+- **`wg-app-link`'s `:link`** (pinned TLS, enrollment store, QR activity)
+  is Kotlin shared with Dev Updater. The certificate code already exists on
+  the Rust side of the submodule; the pinned-CA build step
+  (`generatePinnedCert`) becomes a `build.rs` reading the same path. The QR
+  scanner stays a Kotlin activity, since the camera is a platform feature.
+- **Tooling** becomes `cargo` for everything but packaging: `cargo test`,
+  `clippy`, `fmt` cover the whole client, which is the motivation. Gradle
+  remains for the APK, signing (`~/.config/ai-app/release.jks`) and Dev
+  Updater's build modes; `build-apk.sh` would call `cargo ndk` first.
+- **The bench scripts** (`ui-trace` by accessibility label) keep working
+  only if the framework exposes names through AccessKit on Android; that is
+  part of E2's pass condition, not a nicety.
+- **Icons** stay Nerd Font glyphs from the committed subset; Parley/Fontique
+  loads a font file directly, so `build-icon-font.sh` is unchanged.
+
+## Sources
+
+- iced: [repo](https://github.com/iced-rs/iced), [0.14 release](https://github.com/iced-rs/iced/releases/tag/0.14.0), [Android thread](https://news.ycombinator.com/item?id=46350641), [markdown selection request](https://discourse.iced.rs/t/markdown-widgets-text-should-be-selectable/1107)
+- Linebender: [2026 Q1 report](https://linebender.org/blog/tmil-25/), [xilem](https://github.com/linebender/xilem), [parley](https://github.com/linebender/parley), [vello](https://github.com/linebender/vello), [vello_hybrid](https://docs.rs/vello_hybrid/latest/vello_hybrid/)
+- android-view: [repo](https://github.com/rust-mobile/android-view); android-activity [PR #214](https://github.com/rust-mobile/android-activity/pull/214)
+- winit Android IME: [#1823](https://github.com/rust-windowing/winit/issues/1823), [#2766](https://github.com/rust-windowing/winit/issues/2766), [#2305](https://github.com/rust-windowing/winit/issues/2305)
+- egui on Android: [discussion #2053](https://github.com/emilk/egui/discussions/2053)
+- Slint: [Android guide](https://docs.slint.dev/latest/docs/slint/guide/platforms/mobile/android/), [1.15 release](https://slint.dev/blog/slint-1.15-released), [licensing](https://slint.dev/faqs), rich text [#1325](https://github.com/slint-ui/slint/issues/1325), markdown [#6684](https://github.com/slint-ui/slint/issues/6684)
+- Makepad: [repo](https://github.com/makepad/makepad), [makepad-widgets](https://docs.rs/makepad-widgets), [Robrix](https://github.com/project-robius/robrix), [Robrix releases](https://github.com/project-robius/robrix/releases)
+- AccessKit: [releases](https://github.com/AccessKit/accesskit/releases)
+- Build tools: [cargo-ndk](https://github.com/bbqsrc/cargo-ndk), [cargo-apk](https://github.com/rust-mobile/cargo-apk), [rust-mobile](https://github.com/rust-mobile)
+- uniffi: [repo](https://github.com/mozilla/uniffi-rs), [KMP bindings fork](https://github.com/UbiqueInnovation/uniffi-kotlin-multiplatform-bindings)
+- GPUI mobile: [gpui-mobile](https://github.com/itsbalamurali/gpui-mobile)
+- The earlier Dioxus spike's findings on `wgpu`/Vulkan in this emulator: `~/repos/tdep-survey/app-dioxus/README.md`

iris/.gitignore

@@ -0,0 +1,2 @@
+/target
+perf.data*

iris/Cargo.toml

@@ -0,0 +1,42 @@
+[package]
+name = "iris"
+version.workspace = true
+edition.workspace = true
+
+# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
+
+[dependencies]
+iris-core = { workspace = true }
+iris-macro = { workspace = true }
+cosmic-text = { workspace = true }
+unicode-segmentation = { workspace = true }
+winit = { workspace = true }
+arboard = { workspace = true, features = ["wayland-data-control"] }
+pollster = { workspace = true }
+wgpu = { workspace = true }
+image = { workspace = true }
+tokio = { workspace = true, features = ["sync", "rt", "rt-multi-thread"] }
+
+[dev-dependencies]
+tokio = { workspace = true, features = ["sync", "rt", "rt-multi-thread", "time"] }
+
+[workspace]
+members = ["core", "macro"]
+
+[workspace.package]
+version = "0.1.0"
+edition = "2024"
+
+[workspace.dependencies]
+pollster = "0.4.0"
+winit = "0.30.12"
+wgpu = "28.0.0"
+bytemuck = "1.23.1"
+image = "0.25.6"
+cosmic-text = "0.16.0"
+unicode-segmentation = "1.12.0"
+fxhash = "0.2.1"
+arboard = "3.6.1"
+iris-core = { path = "core" }
+iris-macro = { path = "macro" }
+tokio = "1.49.0"

iris/TODO

@@ -0,0 +1,40 @@
+images
+    settings (sampler)
+
+text
+    figure out ways to speed up / what costs the most
+    resizing (per frame) is really slow (assuming painter isn't griefing)
+    j is weird / fix x offset
+
+masks r just made to bare minimum work
+
+scaling
+    could be just a simple scaling factor that multiplies abs
+    and need to ensure text uses raw abs and not scaled abs
+    naming? (pt, px)
+    want to keep (drawn) regions using px? or should I add another field to UiScalar/Vec
+    field could be best solution so redrawing stuff isn't needed & you can specify both as user
+
+WidgetRef<W> or smth instead of Id
+    enum that's either an Id or an actual concrete instance of W
+    painter takes them in instead of (or in addition to) id
+    then type wrapper widgets to contain them
+    allows for compile time optimization if a widget wrapper's inner is known at compile time
+        and the id of inner is not needed anywhere
+    maybe introduce InnerWidget trait to allow for editors to expose & modify inner type
+    maybe could also store a parent widget and keep using InnerWidget trait? unsure if possible
+
+really weird limitation:
+    I don't think you can currently remove an element from a parent and put it in a child of the same parent
+    because it removes the unused children after the entire parent redraw
+    but the child gets drawn during that, so it will think the child is still active !!!
+    or something like that idk, maybe I need a special enum for parent that includes a undecided state where it may or may not get redrawn by the parent
+    or just do ref counting and ensure all drawn things == 1 afterwards (seems like best way)
+    ok so I'm removing the limit for now
+
+don't forget I'm streaming
+
+tags
+vecs for each widget type?
+
+POTENTIAL BUG: closures that store IDs will not decrement the id!!! need to not increment id if moved into closure somehow??? wait no, need to decrement ID every time an event fn is added...... only if the id is used in it..??

iris/core/Cargo.toml

@@ -0,0 +1,12 @@
+[package]
+name = "iris-core"
+version.workspace = true
+edition.workspace = true
+
+[dependencies]
+winit = { workspace = true }
+wgpu = { workspace = true }
+bytemuck ={ workspace = true }
+image = { workspace = true }
+cosmic-text = { workspace = true }
+fxhash = { workspace = true }

iris/core/src/attr.rs

@@ -0,0 +1,23 @@
+use crate::{UiRsc, WidgetIdFn, WidgetLike, WeakWidget};
+
+pub trait WidgetAttr<Rsc, W: ?Sized> {
+    type Input;
+    fn run(rsc: &mut Rsc, id: WeakWidget<W>, input: Self::Input);
+}
+
+pub trait Attrable<Rsc, W: ?Sized, Tag> {
+    fn attr<A: WidgetAttr<Rsc, W>>(self, input: A::Input) -> impl WidgetIdFn<Rsc, W>;
+}
+
+impl<Rsc: UiRsc, WL: WidgetLike<Rsc, Tag>, Tag> Attrable<Rsc, WL::Widget, Tag> for WL {
+    fn attr<A: WidgetAttr<Rsc, WL::Widget>>(
+        self,
+        input: A::Input,
+    ) -> impl WidgetIdFn<Rsc, WL::Widget> {
+        |rsc| {
+            let id = self.add(rsc);
+            A::run(rsc, id, input);
+            id
+        }
+    }
+}

iris/core/src/event/ctx.rs

@@ -0,0 +1,18 @@
+use crate::{HasEvents, WeakWidget, Widget};
+
+pub struct EventCtx<'a, Rsc: HasEvents, Data> {
+    pub state: &'a mut Rsc::State,
+    pub data: Data,
+}
+
+pub struct EventIdCtx<'a, Rsc: HasEvents, Data, W: ?Sized> {
+    pub widget: WeakWidget<W>,
+    pub state: &'a mut Rsc::State,
+    pub data: Data,
+}
+
+impl<Rsc: HasEvents, Data, W: Widget> EventIdCtx<'_, Rsc, Data, W> {
+    pub fn widget<'a>(&self, rsc: &'a mut Rsc) -> &'a mut W {
+        &mut rsc.ui_mut().widgets[self.widget]
+    }
+}

iris/core/src/event/manager.rs

@@ -0,0 +1,157 @@
+use crate::{
+    ActiveData, Event, EventCtx, EventFn, EventIdCtx, EventLike, HasEvents, IdLike, LayerId,
+    WeakWidget, WidgetEventFn, WidgetId,
+    util::{HashMap, HashSet, TypeMap},
+};
+use std::{any::TypeId, rc::Rc};
+
+pub struct EventManager<Rsc> {
+    widget_to_types: HashMap<WidgetId, HashSet<TypeId>>,
+    types: TypeMap<dyn EventManagerLike<Rsc>>,
+}
+
+impl<Rsc> Default for EventManager<Rsc> {
+    fn default() -> Self {
+        Self {
+            widget_to_types: Default::default(),
+            types: Default::default(),
+        }
+    }
+}
+
+impl<Rsc: HasEvents + 'static> EventManager<Rsc> {
+    pub fn get_type<E: EventLike>(&mut self) -> &mut TypeEventManager<Rsc, E::Event> {
+        self.types.type_or_default()
+    }
+
+    pub fn register<I: IdLike + 'static, E: EventLike>(
+        &mut self,
+        id: I,
+        event: E,
+        f: impl for<'a> WidgetEventFn<Rsc, <E::Event as Event>::Data<'a>, I::Widget>,
+    ) {
+        let i = id.id();
+        self.get_type::<E>().register(id, event, f);
+        self.widget_to_types
+            .entry(i)
+            .or_default()
+            .insert(Self::type_key::<E>());
+    }
+
+    pub fn type_key<E: EventLike>() -> TypeId {
+        TypeId::of::<TypeEventManager<Rsc, E::Event>>()
+    }
+}
+
+pub trait EventsLike {
+    fn remove(&mut self, id: WidgetId);
+    fn draw(&mut self, active: &ActiveData);
+    fn undraw(&mut self, active: &ActiveData);
+}
+
+impl<Rsc: HasEvents + 'static> EventsLike for EventManager<Rsc> {
+    fn remove(&mut self, id: WidgetId) {
+        for t in self.widget_to_types.get(&id).into_flat_iter() {
+            self.types.get_mut(t).unwrap().remove(id);
+        }
+    }
+
+    fn draw(&mut self, active: &ActiveData) {
+        for t in self.widget_to_types.get(&active.id).into_flat_iter() {
+            self.types.get_mut(t).unwrap().draw(active);
+        }
+    }
+
+    fn undraw(&mut self, active: &ActiveData) {
+        for t in self.widget_to_types.get(&active.id).into_flat_iter() {
+            self.types.get_mut(t).unwrap().undraw(active);
+        }
+    }
+}
+
+pub trait EventManagerLike<State> {
+    fn remove(&mut self, id: WidgetId);
+    fn draw(&mut self, data: &ActiveData);
+    fn undraw(&mut self, data: &ActiveData);
+}
+
+type EventData<Rsc, E> = (E, Rc<dyn for<'a> EventFn<Rsc, <E as Event>::Data<'a>>>);
+pub struct TypeEventManager<Rsc: HasEvents, E: Event> {
+    // TODO: reduce visiblity!!
+    pub active: HashMap<LayerId, HashMap<WidgetId, E::State>>,
+    map: HashMap<WidgetId, Vec<EventData<Rsc, E>>>,
+}
+
+impl<Rsc: HasEvents, E: Event> EventManagerLike<Rsc> for TypeEventManager<Rsc, E> {
+    fn remove(&mut self, id: WidgetId) {
+        self.map.remove(&id);
+        for layer in self.active.values_mut() {
+            layer.remove(&id);
+        }
+    }
+    fn draw(&mut self, data: &ActiveData) {
+        self.active
+            .entry(data.layer)
+            .or_default()
+            .entry(data.id)
+            .or_default();
+    }
+    fn undraw(&mut self, data: &ActiveData) {
+        if let Some(layer) = self.active.get_mut(&data.layer) {
+            layer.remove(&data.id);
+        }
+    }
+}
+
+impl<Rsc: HasEvents, E: Event> Default for TypeEventManager<Rsc, E> {
+    fn default() -> Self {
+        Self {
+            active: Default::default(),
+            map: Default::default(),
+        }
+    }
+}
+
+impl<Rsc: HasEvents + 'static, E: Event> TypeEventManager<Rsc, E> {
+    fn register<I: IdLike + 'static>(
+        &mut self,
+        widget: I,
+        event: impl EventLike<Event = E>,
+        f: impl for<'a> WidgetEventFn<Rsc, E::Data<'a>, I::Widget>,
+    ) {
+        let event = event.into_event();
+        self.map.entry(widget.id()).or_default().push((
+            event,
+            Rc::new(move |ctx, rsc| {
+                f(
+                    EventIdCtx {
+                        widget: WeakWidget::new(widget.id()),
+                        state: ctx.state,
+                        data: ctx.data,
+                    },
+                    rsc,
+                );
+            }),
+        ));
+    }
+
+    pub fn run_fn<'a>(
+        &mut self,
+        id: impl IdLike,
+    ) -> impl for<'b> FnOnce(EventCtx<'_, Rsc, E::Data<'b>>, &mut Rsc) + 'a {
+        let fs = self.map.get(&id.id()).cloned().unwrap_or_default();
+        move |ctx, rsc| {
+            for (e, f) in fs {
+                if let Some(data) = e.should_run(&ctx.data) {
+                    f(
+                        EventCtx {
+                            state: ctx.state,
+                            data,
+                        },
+                        rsc,
+                    )
+                }
+            }
+        }
+    }
+}

iris/core/src/event/mod.rs

@@ -0,0 +1,44 @@
+mod ctx;
+mod manager;
+mod rsc;
+
+pub use ctx::*;
+pub use manager::*;
+pub use rsc::*;
+
+pub trait Event: Sized + 'static + Clone {
+    type Data<'a>: Clone = ();
+    type State: Default = ();
+    #[allow(unused_variables)]
+    fn should_run<'a>(&self, data: &Self::Data<'a>) -> Option<Self::Data<'a>> {
+        Some(data.clone())
+    }
+}
+
+pub trait EventLike {
+    type Event: Event;
+    fn into_event(self) -> Self::Event;
+}
+
+impl<E: Event> EventLike for E {
+    type Event = Self;
+
+    fn into_event(self) -> Self::Event {
+        self
+    }
+}
+
+pub trait EventFn<Rsc: HasEvents, Data>: Fn(EventCtx<Rsc, Data>, &mut Rsc) + 'static {}
+impl<Rsc: HasEvents, F: Fn(EventCtx<Rsc, Data>, &mut Rsc) + 'static, Data> EventFn<Rsc, Data>
+    for F
+{
+}
+
+pub trait WidgetEventFn<Rsc: HasEvents, Data, W: ?Sized>:
+    Fn(EventIdCtx<Rsc, Data, W>, &mut Rsc) + 'static
+{
+}
+impl<Rsc: HasEvents, F: Fn(EventIdCtx<Rsc, Data, W>, &mut Rsc) + 'static, Data, W: ?Sized>
+    WidgetEventFn<Rsc, Data, W> for F
+{
+}

iris/core/src/event/rsc.rs

@@ -0,0 +1,34 @@
+use crate::{
+    Event, EventCtx, EventLike, EventManager, IdLike, UiRsc, WeakWidget, Widget, WidgetEventFn,
+};
+
+pub trait HasState: 'static {
+    type State;
+}
+
+pub trait HasEvents: Sized + UiRsc + HasState {
+    fn events(&self) -> &EventManager<Self>;
+    fn events_mut(&mut self) -> &mut EventManager<Self>;
+
+    fn register_event<W: Widget + ?Sized, E: EventLike>(
+        &mut self,
+        id: WeakWidget<W>,
+        event: E,
+        f: impl for<'a> WidgetEventFn<Self, <E::Event as Event>::Data<'a>, W>,
+    ) {
+        self.events_mut().register(id, event, f);
+    }
+}
+
+pub trait RunEvents: HasEvents {
+    fn run_event<E: EventLike>(
+        &mut self,
+        id: impl IdLike,
+        data: <E::Event as Event>::Data<'_>,
+        state: &mut Self::State,
+    ) {
+        let f = self.events_mut().get_type::<E>().run_fn(id);
+        f(EventCtx { state, data }, self)
+    }
+}
+impl<T: HasEvents> RunEvents for T {}

iris/core/src/lib.rs

@@ -0,0 +1,36 @@
+#![feature(macro_metavar_expr_concat)]
+#![feature(const_ops)]
+#![feature(const_trait_impl)]
+#![feature(const_convert)]
+#![feature(map_try_insert)]
+#![feature(unboxed_closures)]
+#![feature(fn_traits)]
+#![feature(const_cmp)]
+#![feature(const_destruct)]
+#![feature(portable_simd)]
+#![feature(associated_type_defaults)]
+#![feature(unsize)]
+#![feature(coerce_unsized)]
+#![feature(option_into_flat_iter)]
+
+mod attr;
+mod event;
+mod num;
+mod orientation;
+mod primitive;
+mod render;
+mod ui;
+mod widget;
+
+pub mod util;
+
+pub use attr::*;
+pub use event::*;
+pub use num::*;
+pub use orientation::*;
+pub use primitive::*;
+pub use render::*;
+pub use ui::*;
+pub use widget::*;
+
+pub type UiColor = primitive::Color<u8>;

iris/core/src/num.rs

@@ -0,0 +1,49 @@
+use crate::util::Vec2;
+use std::marker::Destruct;
+
+pub const trait UiNum {
+    fn to_f32(self) -> f32;
+}
+
+impl const UiNum for f32 {
+    fn to_f32(self) -> f32 {
+        self
+    }
+}
+
+impl const UiNum for u32 {
+    fn to_f32(self) -> f32 {
+        self as f32
+    }
+}
+
+impl const UiNum for i32 {
+    fn to_f32(self) -> f32 {
+        self as f32
+    }
+}
+
+pub const fn vec2(x: impl const UiNum, y: impl const UiNum) -> Vec2 {
+    Vec2::new(x.to_f32(), y.to_f32())
+}
+
+impl<T: const UiNum + Copy> const From<T> for Vec2 {
+    fn from(v: T) -> Self {
+        Self {
+            x: v.to_f32(),
+            y: v.to_f32(),
+        }
+    }
+}
+
+impl<T: const UiNum, U: const UiNum> const From<(T, U)> for Vec2
+where
+    (T, U): const Destruct,
+{
+    fn from((x, y): (T, U)) -> Self {
+        Self {
+            x: x.to_f32(),
+            y: y.to_f32(),
+        }
+    }
+}

iris/core/src/orientation/align.rs

@@ -0,0 +1,200 @@
+use crate::vec2;
+
+use super::*;
+
+#[derive(Clone, Copy, PartialEq, Eq)]
+pub struct Align {
+    pub x: Option<AxisAlign>,
+    pub y: Option<AxisAlign>,
+}
+
+impl Align {
+    pub const TOP_LEFT: RegionAlign = RegionAlign::TOP_LEFT;
+    pub const TOP_CENTER: RegionAlign = RegionAlign::TOP_CENTER;
+    pub const TOP_RIGHT: RegionAlign = RegionAlign::TOP_RIGHT;
+    pub const CENTER_LEFT: RegionAlign = RegionAlign::CENTER_LEFT;
+    pub const CENTER: RegionAlign = RegionAlign::CENTER;
+    pub const CENTER_RIGHT: RegionAlign = RegionAlign::CENTER_RIGHT;
+    pub const BOT_LEFT: RegionAlign = RegionAlign::BOT_LEFT;
+    pub const BOT_CENTER: RegionAlign = RegionAlign::BOT_CENTER;
+    pub const BOT_RIGHT: RegionAlign = RegionAlign::BOT_RIGHT;
+    pub const LEFT: CardinalAlign = CardinalAlign::LEFT;
+    pub const H_CENTER: CardinalAlign = CardinalAlign::H_CENTER;
+    pub const RIGHT: CardinalAlign = CardinalAlign::RIGHT;
+    pub const TOP: CardinalAlign = CardinalAlign::TOP;
+    pub const V_CENTER: CardinalAlign = CardinalAlign::V_CENTER;
+    pub const BOT: CardinalAlign = CardinalAlign::BOT;
+
+    pub fn tuple(&self) -> (Option<AxisAlign>, Option<AxisAlign>) {
+        (self.x, self.y)
+    }
+}
+
+#[derive(Clone, Copy, PartialEq, Eq)]
+pub enum AxisAlign {
+    Neg,
+    Center,
+    Pos,
+}
+
+impl AxisAlign {
+    pub const fn rel(&self) -> f32 {
+        match self {
+            Self::Neg => 0.0,
+            Self::Center => 0.5,
+            Self::Pos => 1.0,
+        }
+    }
+}
+
+pub struct CardinalAlign {
+    axis: Axis,
+    align: AxisAlign,
+}
+
+impl CardinalAlign {
+    pub const LEFT: Self = Self::new(Axis::X, AxisAlign::Neg);
+    pub const H_CENTER: Self = Self::new(Axis::X, AxisAlign::Center);
+    pub const RIGHT: Self = Self::new(Axis::X, AxisAlign::Pos);
+    pub const TOP: Self = Self::new(Axis::Y, AxisAlign::Neg);
+    pub const V_CENTER: Self = Self::new(Axis::Y, AxisAlign::Center);
+    pub const BOT: Self = Self::new(Axis::Y, AxisAlign::Pos);
+
+    pub const fn new(axis: Axis, align: AxisAlign) -> Self {
+        Self { axis, align }
+    }
+}
+
+#[derive(Clone, Copy, PartialEq, Eq)]
+pub struct RegionAlign {
+    pub x: AxisAlign,
+    pub y: AxisAlign,
+}
+
+impl RegionAlign {
+    pub const TOP_LEFT: Self = Self::new(AxisAlign::Neg, AxisAlign::Neg);
+    pub const TOP_CENTER: Self = Self::new(AxisAlign::Center, AxisAlign::Neg);
+    pub const TOP_RIGHT: Self = Self::new(AxisAlign::Pos, AxisAlign::Neg);
+    pub const CENTER_LEFT: Self = Self::new(AxisAlign::Neg, AxisAlign::Center);
+    pub const CENTER: Self = Self::new(AxisAlign::Center, AxisAlign::Center);
+    pub const CENTER_RIGHT: Self = Self::new(AxisAlign::Pos, AxisAlign::Center);
+    pub const BOT_LEFT: Self = Self::new(AxisAlign::Neg, AxisAlign::Pos);
+    pub const BOT_CENTER: Self = Self::new(AxisAlign::Center, AxisAlign::Pos);
+    pub const BOT_RIGHT: Self = Self::new(AxisAlign::Pos, AxisAlign::Pos);
+
+    pub const fn new(x: AxisAlign, y: AxisAlign) -> Self {
+        Self { x, y }
+    }
+    pub const fn rel(&self) -> Vec2 {
+        vec2(self.x.rel(), self.y.rel())
+    }
+}
+
+impl UiVec2 {
+    pub fn partial_align(&self, align: Align) -> UiRegion {
+        UiRegion {
+            x: if let Some(align) = align.x {
+                self.x.align(align)
+            } else {
+                UiSpan::FULL
+            },
+            y: if let Some(align) = align.y {
+                self.y.align(align)
+            } else {
+                UiSpan::FULL
+            },
+        }
+    }
+
+    pub fn align(&self, align: RegionAlign) -> UiRegion {
+        UiRegion {
+            x: self.x.align(align.x),
+            y: self.y.align(align.y),
+        }
+    }
+}
+
+impl Vec2 {
+    pub fn partial_align(&self, align: Align) -> UiRegion {
+        let s = UiVec2::from(*self);
+        UiRegion {
+            x: if let Some(align) = align.x {
+                s.x.align(align)
+            } else {
+                UiSpan::FULL
+            },
+            y: if let Some(align) = align.y {
+                s.y.align(align)
+            } else {
+                UiSpan::FULL
+            },
+        }
+    }
+
+    pub fn align(&self, align: RegionAlign) -> UiRegion {
+        let s = UiVec2::from(*self);
+        UiRegion {
+            x: s.x.align(align.x),
+            y: s.y.align(align.y),
+        }
+    }
+}
+
+impl UiScalar {
+    pub const fn align(&self, align: AxisAlign) -> UiSpan {
+        let rel = align.rel();
+        let mut start = UiScalar::rel(rel);
+        start.abs -= self.abs * rel;
+        start.rel -= self.rel * rel;
+        let mut end = UiScalar::rel(rel);
+        end.abs += self.abs * (1.0 - rel);
+        end.rel += self.rel * (1.0 - rel);
+        UiSpan { start, end }
+    }
+}
+
+impl From<RegionAlign> for Align {
+    fn from(region: RegionAlign) -> Self {
+        Self {
+            x: Some(region.x),
+            y: Some(region.y),
+        }
+    }
+}
+
+impl From<Align> for RegionAlign {
+    fn from(align: Align) -> Self {
+        Self {
+            x: align.x.unwrap_or(AxisAlign::Center),
+            y: align.y.unwrap_or(AxisAlign::Center),
+        }
+    }
+}
+
+impl From<CardinalAlign> for RegionAlign {
+    fn from(align: CardinalAlign) -> Self {
+        Align::from(align).into()
+    }
+}
+
+impl From<CardinalAlign> for Align {
+    fn from(cardinal: CardinalAlign) -> Self {
+        let align = Some(cardinal.align);
+        match cardinal.axis {
+            Axis::X => Self { x: align, y: None },
+            Axis::Y => Self { x: None, y: align },
+        }
+    }
+}
+
+impl const From<RegionAlign> for UiVec2 {
+    fn from(align: RegionAlign) -> Self {
+        Self::rel(align.rel())
+    }
+}
+
+impl RegionAlign {
+    pub const fn pos(self) -> UiVec2 {
+        UiVec2::from(self)
+    }
+}

iris/core/src/orientation/axis.rs

@@ -0,0 +1,115 @@
+use super::*;
+
+#[derive(Copy, Clone, Eq, PartialEq)]
+pub enum Axis {
+    X,
+    Y,
+}
+
+impl std::ops::Not for Axis {
+    type Output = Self;
+
+    fn not(self) -> Self::Output {
+        match self {
+            Self::X => Self::Y,
+            Self::Y => Self::X,
+        }
+    }
+}
+
+#[derive(Clone, Copy, Eq, PartialEq)]
+pub struct Dir {
+    pub axis: Axis,
+    pub sign: Sign,
+}
+
+impl Dir {
+    pub const fn new(axis: Axis, dir: Sign) -> Self {
+        Self { axis, sign: dir }
+    }
+
+    pub const LEFT: Self = Self::new(Axis::X, Sign::Neg);
+    pub const RIGHT: Self = Self::new(Axis::X, Sign::Pos);
+    pub const UP: Self = Self::new(Axis::Y, Sign::Neg);
+    pub const DOWN: Self = Self::new(Axis::Y, Sign::Pos);
+}
+
+#[derive(Clone, Copy, Eq, PartialEq)]
+pub enum Sign {
+    Neg,
+    Pos,
+}
+
+impl Vec2 {
+    pub fn axis(&self, axis: Axis) -> f32 {
+        match axis {
+            Axis::X => self.x,
+            Axis::Y => self.y,
+        }
+    }
+
+    pub fn axis_mut(&mut self, axis: Axis) -> &mut f32 {
+        match axis {
+            Axis::X => &mut self.x,
+            Axis::Y => &mut self.y,
+        }
+    }
+
+    pub const fn from_axis(axis: Axis, aligned: f32, ortho: f32) -> Self {
+        Self {
+            x: match axis {
+                Axis::X => aligned,
+                Axis::Y => ortho,
+            },
+            y: match axis {
+                Axis::Y => aligned,
+                Axis::X => ortho,
+            },
+        }
+    }
+}
+
+pub const trait AxisT {
+    fn get() -> Axis;
+}
+
+pub struct XAxis;
+impl const AxisT for XAxis {
+    fn get() -> Axis {
+        Axis::X
+    }
+}
+
+pub struct YAxis;
+impl const AxisT for YAxis {
+    fn get() -> Axis {
+        Axis::Y
+    }
+}
+
+#[derive(Clone, Copy, Debug, Default)]
+pub struct BothAxis<T> {
+    pub x: T,
+    pub y: T,
+}
+
+impl<T> BothAxis<T> {
+    pub const fn axis<A: const AxisT>(&mut self) -> &mut T {
+        match A::get() {
+            Axis::X => &mut self.x,
+            Axis::Y => &mut self.y,
+        }
+    }
+    pub fn take_axis<A: const AxisT>(self) -> T {
+        match A::get() {
+            Axis::X => self.x,
+            Axis::Y => self.y,
+        }
+    }
+    pub fn axis_dyn(&mut self, axis: Axis) -> &mut T {
+        match axis {
+            Axis::X => &mut self.x,
+            Axis::Y => &mut self.y,
+        }
+    }
+}

iris/core/src/orientation/len.rs

@@ -0,0 +1,198 @@
+use super::*;
+use crate::{UiNum, util::impl_op};
+
+#[derive(Debug, Default, Clone, Copy, PartialEq)]
+pub struct Size {
+    pub x: Len,
+    pub y: Len,
+}
+
+#[derive(Debug, Clone, Copy, PartialEq)]
+pub struct Len {
+    pub abs: f32,
+    pub rel: f32,
+    pub rest: f32,
+}
+
+impl<N: UiNum> From<N> for Len {
+    fn from(value: N) -> Self {
+        Len::abs(value.to_f32())
+    }
+}
+
+impl<Nx: UiNum, Ny: UiNum> From<(Nx, Ny)> for Size {
+    fn from((x, y): (Nx, Ny)) -> Self {
+        Self {
+            x: x.into(),
+            y: y.into(),
+        }
+    }
+}
+
+impl From<Len> for Size {
+    fn from(value: Len) -> Self {
+        Self { x: value, y: value }
+    }
+}
+
+impl Size {
+    pub const ZERO: Self = Self {
+        x: Len::ZERO,
+        y: Len::ZERO,
+    };
+
+    pub const REST: Self = Self {
+        x: Len::REST,
+        y: Len::REST,
+    };
+
+    pub fn abs(v: Vec2) -> Self {
+        Self {
+            x: Len::abs(v.x),
+            y: Len::abs(v.y),
+        }
+    }
+
+    pub fn rel(v: Vec2) -> Self {
+        Self {
+            x: Len::rel(v.x),
+            y: Len::rel(v.y),
+        }
+    }
+
+    pub fn rest(v: Vec2) -> Self {
+        Self {
+            x: Len::rest(v.x),
+            y: Len::rest(v.y),
+        }
+    }
+
+    pub fn to_uivec2(self) -> UiVec2 {
+        UiVec2 {
+            x: self.x.apply_rest(),
+            y: self.y.apply_rest(),
+        }
+    }
+
+    pub fn from_axis(axis: Axis, aligned: Len, ortho: Len) -> Self {
+        match axis {
+            Axis::X => Self {
+                x: aligned,
+                y: ortho,
+            },
+            Axis::Y => Self {
+                x: ortho,
+                y: aligned,
+            },
+        }
+    }
+
+    pub fn axis(&self, axis: Axis) -> Len {
+        match axis {
+            Axis::X => self.x,
+            Axis::Y => self.y,
+        }
+    }
+}
+
+impl Len {
+    pub const ZERO: Self = Self {
+        abs: 0.0,
+        rel: 0.0,
+        rest: 0.0,
+    };
+
+    pub const REST: Self = Self {
+        abs: 0.0,
+        rel: 0.0,
+        rest: 1.0,
+    };
+
+    pub fn apply_rest(&self) -> UiScalar {
+        UiScalar {
+            rel: self.rel + if self.rest > 0.0 { 1.0 } else { 0.0 },
+            abs: self.abs,
+        }
+    }
+
+    pub fn abs(abs: impl UiNum) -> Self {
+        Self {
+            abs: abs.to_f32(),
+            rel: 0.0,
+            rest: 0.0,
+        }
+    }
+    pub fn rel(rel: impl UiNum) -> Self {
+        Self {
+            abs: 0.0,
+            rel: rel.to_f32(),
+            rest: 0.0,
+        }
+    }
+    pub fn rest(ratio: impl UiNum) -> Self {
+        Self {
+            abs: 0.0,
+            rel: 0.0,
+            rest: ratio.to_f32(),
+        }
+    }
+}
+
+pub mod len_fns {
+    use super::*;
+
+    pub fn abs(abs: impl UiNum) -> Len {
+        Len {
+            abs: abs.to_f32(),
+            rel: 0.0,
+            rest: 0.0,
+        }
+    }
+    pub fn rel(rel: impl UiNum) -> Len {
+        Len {
+            abs: 0.0,
+            rel: rel.to_f32(),
+            rest: 0.0,
+        }
+    }
+    pub fn rest(ratio: impl UiNum) -> Len {
+        Len {
+            abs: 0.0,
+            rel: 0.0,
+            rest: ratio.to_f32(),
+        }
+    }
+}
+
+impl_op!(Len Add add; abs rel rest);
+impl_op!(Len Sub sub; abs rel rest);
+
+impl_op!(Size Add add; x y);
+impl_op!(Size Sub sub; x y);
+
+impl Default for Len {
+    fn default() -> Self {
+        Self::rest(1.0)
+    }
+}
+
+impl std::fmt::Display for Size {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        write!(f, "({}, {})", self.x, self.y)
+    }
+}
+
+impl std::fmt::Display for Len {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        if self.abs != 0.0 {
+            write!(f, "{} abs;", self.abs)?;
+        }
+        if self.rel != 0.0 {
+            write!(f, "{} rel;", self.rel)?;
+        }
+        if self.rest != 0.0 {
+            write!(f, "{} rest;", self.rest)?;
+        }
+        Ok(())
+    }
+}

iris/core/src/orientation/mod.rs

@@ -0,0 +1,11 @@
+mod align;
+mod axis;
+mod len;
+mod pos;
+
+use crate::util::Vec2;
+
+pub use align::*;
+pub use axis::*;
+pub use len::*;
+pub use pos::*;

iris/core/src/orientation/pos.rs

@@ -0,0 +1,464 @@
+use std::{fmt::Display, hash::Hash, marker::Destruct};
+
+use super::*;
+use crate::{
+    UiNum,
+    util::{LerpUtil, impl_op},
+};
+
+#[repr(C)]
+#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash, bytemuck::Pod, bytemuck::Zeroable, Default)]
+pub struct UiVec2 {
+    pub x: UiScalar,
+    pub y: UiScalar,
+}
+
+impl UiVec2 {
+    pub const ZERO: Self = Self {
+        x: UiScalar::ZERO,
+        y: UiScalar::ZERO,
+    };
+
+    pub const fn new(x: UiScalar, y: UiScalar) -> Self {
+        Self { x, y }
+    }
+
+    pub const fn abs(abs: impl const Into<Vec2>) -> Self {
+        let abs = abs.into();
+        Self {
+            x: UiScalar::abs(abs.x),
+            y: UiScalar::abs(abs.y),
+        }
+    }
+
+    pub const fn rel(rel: impl const Into<Vec2>) -> Self {
+        let rel = rel.into();
+        Self {
+            x: UiScalar::rel(rel.x),
+            y: UiScalar::rel(rel.y),
+        }
+    }
+
+    pub const fn shift(&mut self, offset: impl const Into<UiVec2>) {
+        let offset = offset.into();
+        *self += offset;
+    }
+
+    pub const fn offset(mut self, offset: impl const Into<UiVec2>) -> Self {
+        self.shift(offset);
+        self
+    }
+
+    pub const fn within(&self, region: &UiRegion) -> UiVec2 {
+        UiVec2 {
+            x: self.x.within(&region.x),
+            y: self.y.within(&region.y),
+        }
+    }
+
+    pub const fn outside(&self, region: &UiRegion) -> UiVec2 {
+        UiVec2 {
+            x: self.x.outside(&region.x),
+            y: self.y.outside(&region.y),
+        }
+    }
+
+    pub fn axis_mut(&mut self, axis: Axis) -> &mut UiScalar {
+        match axis {
+            Axis::X => &mut self.x,
+            Axis::Y => &mut self.y,
+        }
+    }
+
+    pub fn axis(&self, axis: Axis) -> UiScalar {
+        match axis {
+            Axis::X => self.x,
+            Axis::Y => self.y,
+        }
+    }
+
+    pub fn to_abs(&self, rel: Vec2) -> Vec2 {
+        Vec2 {
+            x: self.x.to_abs(rel.x),
+            y: self.y.to_abs(rel.y),
+        }
+    }
+
+    pub const FULL_SIZE: Self = Self::rel(Vec2::ONE);
+
+    pub const fn from_axis(axis: Axis, aligned: UiScalar, ortho: UiScalar) -> Self {
+        match axis {
+            Axis::X => Self {
+                x: aligned,
+                y: ortho,
+            },
+            Axis::Y => Self {
+                x: ortho,
+                y: aligned,
+            },
+        }
+    }
+
+    pub fn get_abs(&self) -> Vec2 {
+        (self.x.abs, self.y.abs).into()
+    }
+
+    pub fn get_rel(&self) -> Vec2 {
+        (self.x.rel, self.y.rel).into()
+    }
+
+    pub fn abs_mut(&mut self) -> Vec2View<'_> {
+        Vec2View {
+            x: &mut self.x.abs,
+            y: &mut self.y.abs,
+        }
+    }
+}
+
+impl Display for UiVec2 {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        write!(f, "rel{};abs{}", self.get_rel(), self.get_abs())
+    }
+}
+
+impl_op!(UiVec2 Add add; x y);
+impl_op!(UiVec2 Sub sub; x y);
+
+impl const From<Vec2> for UiVec2 {
+    fn from(abs: Vec2) -> Self {
+        Self::abs(abs)
+    }
+}
+
+impl<T: const UiNum, U: const UiNum> const From<(T, U)> for UiVec2
+where
+    (T, U): const Destruct,
+{
+    fn from(abs: (T, U)) -> Self {
+        Self::abs(abs)
+    }
+}
+
+#[repr(C)]
+#[derive(Debug, Copy, Clone, PartialEq, bytemuck::Pod, Default, bytemuck::Zeroable)]
+pub struct UiScalar {
+    pub rel: f32,
+    pub abs: f32,
+}
+
+impl Eq for UiScalar {}
+impl Hash for UiScalar {
+    fn hash<H: std::hash::Hasher>(&self, state: &mut H) {
+        state.write_u32(self.rel.to_bits());
+        state.write_u32(self.abs.to_bits());
+    }
+}
+
+impl_op!(UiScalar Add add; rel abs);
+impl_op!(UiScalar Sub sub; rel abs);
+
+impl UiScalar {
+    pub const ZERO: Self = Self { rel: 0.0, abs: 0.0 };
+    pub const FULL: Self = Self { rel: 1.0, abs: 0.0 };
+
+    pub const fn new(rel: f32, abs: f32) -> Self {
+        Self { rel, abs }
+    }
+
+    pub const fn rel(rel: f32) -> Self {
+        Self { rel, abs: 0.0 }
+    }
+
+    pub const fn abs(abs: f32) -> Self {
+        Self { rel: 0.0, abs }
+    }
+
+    pub const fn rel_min() -> Self {
+        Self::new(0.0, 0.0)
+    }
+
+    pub const fn rel_max() -> Self {
+        Self::new(1.0, 0.0)
+    }
+
+    pub const fn max(&self, other: Self) -> Self {
+        Self {
+            rel: self.rel.max(other.rel),
+            abs: self.abs.max(other.abs),
+        }
+    }
+
+    pub const fn min(&self, other: Self) -> Self {
+        Self {
+            rel: self.rel.min(other.rel),
+            abs: self.abs.min(other.abs),
+        }
+    }
+
+    pub const fn offset(mut self, amt: f32) -> Self {
+        self.abs += amt;
+        self
+    }
+
+    pub const fn within(&self, span: &UiSpan) -> Self {
+        let anchor = self.rel.lerp(span.start.rel, span.end.rel);
+        let offset = self.abs + self.rel.lerp(span.start.abs, span.end.abs);
+        Self {
+            rel: anchor,
+            abs: offset,
+        }
+    }
+
+    pub const fn outside(&self, span: &UiSpan) -> Self {
+        let rel = self.rel.lerp_inv(span.start.rel, span.end.rel);
+        let abs = self.abs - rel.lerp(span.start.abs, span.end.abs);
+        Self { rel, abs }
+    }
+
+    pub fn within_len(&self, len: UiScalar) -> Self {
+        self.within(&UiSpan {
+            start: UiScalar::ZERO,
+            end: len,
+        })
+    }
+
+    pub fn select_len(&self, len: UiScalar) -> Self {
+        len.within_len(*self)
+    }
+
+    pub const fn flip(&mut self) {
+        self.rel = 1.0 - self.rel;
+        self.abs = -self.abs;
+    }
+
+    pub const fn to(&self, end: Self) -> UiSpan {
+        UiSpan { start: *self, end }
+    }
+
+    pub const fn to_abs(&self, rel: f32) -> f32 {
+        self.rel * rel + self.abs
+    }
+}
+
+#[repr(C)]
+#[derive(Debug, Copy, Clone, PartialEq, bytemuck::Pod, bytemuck::Zeroable)]
+pub struct UiSpan {
+    pub start: UiScalar,
+    pub end: UiScalar,
+}
+
+impl UiSpan {
+    pub const FULL: Self = Self {
+        start: UiScalar::ZERO,
+        end: UiScalar::FULL,
+    };
+
+    pub const fn rel(rel: f32) -> Self {
+        Self {
+            start: UiScalar::rel(rel),
+            end: UiScalar::rel(rel),
+        }
+    }
+
+    pub const fn new(start: UiScalar, end: UiScalar) -> Self {
+        Self { start, end }
+    }
+
+    pub const fn flip(&mut self) {
+        self.start.flip();
+        self.end.flip();
+        std::mem::swap(&mut self.start.rel, &mut self.end.rel);
+        std::mem::swap(&mut self.start.abs, &mut self.end.abs);
+    }
+
+    pub const fn shift(&mut self, offset: UiScalar) {
+        self.start += offset;
+        self.end += offset;
+    }
+
+    pub const fn within(&self, parent: &Self) -> Self {
+        Self {
+            start: self.start.within(parent),
+            end: self.end.within(parent),
+        }
+    }
+
+    pub const fn outside(&self, parent: &Self) -> Self {
+        Self {
+            start: self.start.outside(parent),
+            end: self.end.outside(parent),
+        }
+    }
+
+    pub const fn len(&self) -> UiScalar {
+        self.end - self.start
+    }
+}
+
+#[repr(C)]
+#[derive(Debug, Copy, Clone, PartialEq, bytemuck::Pod, bytemuck::Zeroable)]
+pub struct UiRegion {
+    pub x: UiSpan,
+    pub y: UiSpan,
+}
+
+impl UiRegion {
+    pub const FULL: Self = Self {
+        x: UiSpan::FULL,
+        y: UiSpan::FULL,
+    };
+
+    pub const fn new(x: UiSpan, y: UiSpan) -> Self {
+        Self { x, y }
+    }
+
+    pub const fn rel(rel: Vec2) -> Self {
+        Self {
+            x: UiSpan::rel(rel.x),
+            y: UiSpan::rel(rel.y),
+        }
+    }
+    pub const fn within(&self, parent: &Self) -> Self {
+        Self {
+            x: self.x.within(&parent.x),
+            y: self.y.within(&parent.y),
+        }
+    }
+    pub const fn outside(&self, parent: &Self) -> Self {
+        Self {
+            x: self.x.outside(&parent.x),
+            y: self.y.outside(&parent.y),
+        }
+    }
+
+    pub const fn axis(&mut self, axis: Axis) -> &UiSpan {
+        match axis {
+            Axis::X => &self.x,
+            Axis::Y => &self.y,
+        }
+    }
+
+    pub const fn axis_mut(&mut self, axis: Axis) -> &mut UiSpan {
+        match axis {
+            Axis::X => &mut self.x,
+            Axis::Y => &mut self.y,
+        }
+    }
+
+    pub const fn flip(&mut self, axis: Axis) {
+        match axis {
+            Axis::X => self.x.flip(),
+            Axis::Y => self.y.flip(),
+        }
+    }
+
+    pub fn shift(&mut self, offset: impl Into<UiVec2>) {
+        let offset = offset.into();
+        self.x.shift(offset.x);
+        self.y.shift(offset.y);
+    }
+
+    pub fn offset(mut self, offset: impl Into<UiVec2>) -> Self {
+        self.shift(offset);
+        self
+    }
+
+    pub fn to_px(&self, size: Vec2) -> PixelRegion {
+        PixelRegion {
+            top_left: self.top_left().get_rel() * size + self.top_left().get_abs(),
+            bot_right: self.bot_right().get_rel() * size + self.bot_right().get_abs(),
+        }
+    }
+
+    pub const fn center(&self) -> UiVec2 {
+        Align::CENTER.pos().within(self)
+    }
+
+    pub const fn size(&self) -> UiVec2 {
+        UiVec2 {
+            x: self.x.len(),
+            y: self.y.len(),
+        }
+    }
+
+    pub const fn top_left(&self) -> UiVec2 {
+        UiVec2 {
+            x: self.x.start,
+            y: self.y.start,
+        }
+    }
+
+    pub const fn bot_right(&self) -> UiVec2 {
+        UiVec2 {
+            x: self.x.end,
+            y: self.y.end,
+        }
+    }
+
+    pub const fn from_axis(axis: Axis, aligned: UiSpan, ortho: UiSpan) -> Self {
+        Self {
+            x: match axis {
+                Axis::X => aligned,
+                Axis::Y => ortho,
+            },
+            y: match axis {
+                Axis::X => ortho,
+                Axis::Y => aligned,
+            },
+        }
+    }
+}
+
+impl Display for UiRegion {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        write!(
+            f,
+            "{} -> {} (size: {})",
+            self.top_left(),
+            self.bot_right(),
+            self.size()
+        )
+    }
+}
+
+#[derive(Debug)]
+pub struct PixelRegion {
+    pub top_left: Vec2,
+    pub bot_right: Vec2,
+}
+
+impl PixelRegion {
+    pub fn contains(&self, pos: Vec2) -> bool {
+        pos.x >= self.top_left.x
+            && pos.x <= self.bot_right.x
+            && pos.y >= self.top_left.y
+            && pos.y <= self.bot_right.y
+    }
+
+    pub fn size(&self) -> Vec2 {
+        self.bot_right - self.top_left
+    }
+}
+
+impl Display for PixelRegion {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        write!(f, "{} -> {}", self.top_left, self.bot_right)
+    }
+}
+
+pub struct Vec2View<'a> {
+    pub x: &'a mut f32,
+    pub y: &'a mut f32,
+}
+
+impl Vec2View<'_> {
+    pub fn set(&mut self, other: Vec2) {
+        *self.x = other.x;
+        *self.y = other.y;
+    }
+
+    pub fn add(&mut self, other: Vec2) {
+        *self.x += other.x;
+        *self.y += other.y;
+    }
+}

iris/core/src/primitive/color.rs

@@ -0,0 +1,163 @@
+use std::marker::Destruct;
+
+/// stored in linear for sane manipulation
+#[repr(C)]
+#[derive(Clone, Copy, Hash, PartialEq, Eq, bytemuck::Zeroable, Debug)]
+pub struct Color<T> {
+    pub r: T,
+    pub g: T,
+    pub b: T,
+    pub a: T,
+}
+
+impl<T: ColorNum> Color<T> {
+    pub const BLACK: Self = Self::rgb(T::MIN, T::MIN, T::MIN);
+    pub const WHITE: Self = Self::rgb(T::MAX, T::MAX, T::MAX);
+    pub const GRAY: Self = Self::rgb(T::MID, T::MID, T::MID);
+
+    pub const RED: Self = Self::rgb(T::MAX, T::MIN, T::MIN);
+    pub const ORANGE: Self = Self::rgb(T::MAX, T::MID, T::MIN);
+    pub const YELLOW: Self = Self::rgb(T::MAX, T::MAX, T::MIN);
+    pub const LIME: Self = Self::rgb(T::MID, T::MAX, T::MIN);
+    pub const GREEN: Self = Self::rgb(T::MIN, T::MAX, T::MIN);
+    pub const TURQUOISE: Self = Self::rgb(T::MIN, T::MAX, T::MID);
+    pub const CYAN: Self = Self::rgb(T::MIN, T::MAX, T::MAX);
+    pub const SKY: Self = Self::rgb(T::MIN, T::MID, T::MAX);
+    pub const BLUE: Self = Self::rgb(T::MIN, T::MIN, T::MAX);
+    pub const PURPLE: Self = Self::rgb(T::MID, T::MIN, T::MAX);
+    pub const MAGENTA: Self = Self::rgb(T::MAX, T::MIN, T::MAX);
+
+    pub const NONE: Self = Self::new(T::MIN, T::MIN, T::MIN, T::MIN);
+
+    pub const fn new(r: T, g: T, b: T, a: T) -> Self {
+        Self { r, g, b, a }
+    }
+    pub const fn rgb(r: T, g: T, b: T) -> Self {
+        Self { r, g, b, a: T::MAX }
+    }
+    pub fn alpha(mut self, a: T) -> Self {
+        self.a = a;
+        self
+    }
+
+    pub fn as_arr(self) -> [T; 4] {
+        [self.r, self.g, self.b, self.a]
+    }
+}
+
+pub const trait F32Conversion {
+    fn to(self) -> f32;
+    fn from(x: f32) -> Self;
+}
+
+pub trait ColorNum {
+    const MIN: Self;
+    const MID: Self;
+    const MAX: Self;
+}
+
+macro_rules! map_rgb {
+    ($x:ident,$self:ident, $e:tt) => {
+        #[allow(unused_braces)]
+        Self {
+            r: {
+                let $x = $self.r;
+                $e
+            },
+            g: {
+                let $x = $self.g;
+                $e
+            },
+            b: {
+                let $x = $self.b;
+                $e
+            },
+            a: $self.a,
+        }
+    };
+}
+
+impl<T: ColorNum + const F32Conversion> Color<T>
+where
+    Self: const Destruct,
+{
+    pub const fn mul_rgb(self, amt: impl const F32Conversion) -> Self {
+        let amt = amt.to();
+        map_rgb!(x, self, { T::from(x.to() * amt) })
+    }
+
+    pub const fn add_rgb(self, amt: impl const F32Conversion) -> Self {
+        let amt = amt.to();
+        map_rgb!(x, self, { T::from(x.to() + amt) })
+    }
+
+    pub const fn darker(self, amt: f32) -> Self {
+        self.mul_rgb(1.0 - amt)
+    }
+
+    pub const fn brighter(self, amt: f32) -> Self {
+        map_rgb!(x, self, {
+            let x = x.to();
+            T::from(x + (1.0 - x) * amt)
+        })
+    }
+
+    pub fn map_rgb(self, f: impl Fn(T) -> T) -> Self {
+        Self {
+            r: f(self.r),
+            g: f(self.g),
+            b: f(self.b),
+            a: self.a,
+        }
+    }
+
+    pub fn srgb(r: T, g: T, b: T) -> Self {
+        Self {
+            r: s_to_l(r),
+            g: s_to_l(g),
+            b: s_to_l(b),
+            a: T::MAX,
+        }
+    }
+}
+
+fn s_to_l<T: F32Conversion>(x: T) -> T {
+    let x = x.to();
+    T::from(if x <= 0.0405 {
+        x / 12.92
+    } else {
+        ((x + 0.055) / 1.055).powf(2.4)
+    })
+}
+
+impl ColorNum for u8 {
+    const MIN: Self = u8::MIN;
+    const MID: Self = u8::MAX / 2;
+    const MAX: Self = u8::MAX;
+}
+
+impl ColorNum for f32 {
+    const MIN: Self = 0.0;
+    const MID: Self = 0.5;
+    const MAX: Self = 1.0;
+}
+
+unsafe impl bytemuck::Pod for Color<u8> {}
+
+impl const F32Conversion for f32 {
+    fn to(self) -> f32 {
+        self
+    }
+    fn from(x: f32) -> Self {
+        x
+    }
+}
+
+impl const F32Conversion for u8 {
+    fn to(self) -> f32 {
+        self as f32 / 255.0
+    }
+    fn from(x: f32) -> Self {
+        (x * 255.0).clamp(0.0, 255.0) as Self
+    }
+}

iris/core/src/primitive/layer.rs

@@ -0,0 +1,275 @@
+use std::ops::{Index, IndexMut};
+
+use crate::{
+    render::{MaskIdx, Primitive, PrimitiveHandle, PrimitiveInst, Primitives},
+    util::to_mut,
+};
+
+pub type LayerId = usize;
+
+struct LayerNode<T> {
+    next: Ptr,
+    prev: Ptr,
+    child: Option<Child>,
+    depth: usize,
+    data: T,
+}
+
+#[derive(Clone, Copy, Debug)]
+enum Ptr {
+    /// continue on same level
+    Next(usize),
+    /// go back to parent
+    Parent(usize),
+    /// end
+    None,
+}
+
+/// TODO: currently this does not ever free layers
+/// is that realistically desired?
+pub struct Layers<T> {
+    vec: Vec<LayerNode<T>>,
+    /// index of last layer at top level (start at first = 0)
+    last: usize,
+}
+
+#[derive(Clone, Copy)]
+struct Child {
+    head: usize,
+    tail: usize,
+}
+
+pub type PrimitiveLayers = Layers<Primitives>;
+
+impl<T: Default> Layers<T> {
+    pub fn new() -> Layers<T> {
+        Self {
+            vec: vec![LayerNode::head()],
+            last: 0,
+        }
+    }
+
+    pub fn clear(&mut self) {
+        self.vec.clear();
+        self.vec.push(LayerNode::head());
+    }
+
+    fn push(&mut self, node: LayerNode<T>) -> LayerId {
+        let i = self.vec.len();
+        self.vec.push(node);
+        i
+    }
+
+    pub fn next(&mut self, i: LayerId) -> LayerId {
+        if let Ptr::Next(i) = self.vec[i].next {
+            return i;
+        }
+        let i_new = self.push(LayerNode::new(
+            T::default(),
+            self.vec[i].next,
+            Ptr::Next(i),
+            self.vec[i].depth,
+        ));
+        self.vec[i].next = Ptr::Next(i_new);
+        self.vec[i_new].prev = Ptr::Next(i);
+        match self.vec[i_new].next {
+            Ptr::Next(i) => self.vec[i].prev = Ptr::Next(i_new),
+            Ptr::Parent(i) => self.vec[i].child.as_mut().unwrap().tail = i_new,
+            Ptr::None => self.last = i_new,
+        }
+        i_new
+    }
+
+    pub fn child(&mut self, i: LayerId) -> LayerId {
+        if let Some(c) = self.vec[i].child {
+            return c.head;
+        }
+        let i_child = self.push(LayerNode::new(
+            T::default(),
+            Ptr::Parent(i),
+            Ptr::Parent(i),
+            self.vec[i].depth + 1,
+        ));
+        self.vec[i].child = Some(Child {
+            head: i_child,
+            tail: i_child,
+        });
+        i_child
+    }
+
+    pub fn iter_mut(&mut self) -> LayerIteratorMut<'_, T> {
+        LayerIteratorMut::new(&mut self.vec, self.last)
+    }
+
+    pub fn iter_orderless_mut(&mut self) -> impl Iterator<Item = (usize, &mut T)> {
+        self.vec.iter_mut().map(|n| &mut n.data).enumerate()
+    }
+
+    pub fn iter(&self) -> impl Iterator<Item = (LayerId, &T)> {
+        self.indices().map(|i| (i, &self.vec[i].data))
+    }
+
+    pub fn iter_depth(&self) -> impl Iterator<Item = ((LayerId, usize), &T)> {
+        self.indices()
+            .map(|i| ((i, self.vec[i].depth), &self.vec[i].data))
+    }
+
+    pub fn indices(&self) -> LayerIndexIterator<'_, T> {
+        LayerIndexIterator::new(&self.vec, self.last)
+    }
+}
+
+impl PrimitiveLayers {
+    pub fn write<P: Primitive>(
+        &mut self,
+        layer: LayerId,
+        info: PrimitiveInst<P>,
+    ) -> PrimitiveHandle {
+        self[layer].write(layer, info)
+    }
+
+    pub fn free(&mut self, h: &PrimitiveHandle) -> MaskIdx {
+        self[h.layer].free(h)
+    }
+}
+
+impl<T: Default> Default for Layers<T> {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
+impl<T> Index<LayerId> for Layers<T> {
+    type Output = T;
+
+    fn index(&self, index: LayerId) -> &Self::Output {
+        &self.vec[index].data
+    }
+}
+
+impl<T> IndexMut<LayerId> for Layers<T> {
+    fn index_mut(&mut self, index: LayerId) -> &mut Self::Output {
+        &mut self.vec[index].data
+    }
+}
+
+impl<T: Default> LayerNode<T> {
+    pub fn new(data: T, next: Ptr, prev: Ptr, depth: usize) -> Self {
+        Self {
+            next,
+            prev,
+            child: None,
+            data,
+            depth,
+        }
+    }
+
+    pub fn head() -> Self {
+        Self::new(T::default(), Ptr::None, Ptr::None, 0)
+    }
+}
+
+pub struct LayerIteratorMut<'a, T> {
+    inner: LayerIndexIterator<'a, T>,
+}
+
+impl<'a, T> Iterator for LayerIteratorMut<'a, T> {
+    type Item = (usize, &'a mut T);
+
+    fn next(&mut self) -> Option<Self::Item> {
+        let i = self.inner.next()?;
+        // SAFETY: requires index iterator to work properly
+        let layer = unsafe { to_mut(&self.inner.vec[i].data) };
+        Some((i, layer))
+    }
+}
+
+impl<'a, T> DoubleEndedIterator for LayerIteratorMut<'a, T> {
+    fn next_back(&mut self) -> Option<Self::Item> {
+        let i = self.inner.next_back()?;
+        // SAFETY: requires index iterator to work properly
+        let layer = unsafe { to_mut(&self.inner.vec[i].data) };
+        Some((i, layer))
+    }
+}
+
+impl<'a, T> LayerIteratorMut<'a, T> {
+    fn new(vec: &'a mut Vec<LayerNode<T>>, last: usize) -> Self {
+        Self {
+            inner: LayerIndexIterator::new(vec, last),
+        }
+    }
+}
+
+pub struct LayerIndexIterator<'a, T> {
+    next: Option<usize>,
+    next_back: Option<usize>,
+    vec: &'a Vec<LayerNode<T>>,
+}
+
+impl<'a, T> Iterator for LayerIndexIterator<'a, T> {
+    type Item = usize;
+
+    fn next(&mut self) -> Option<Self::Item> {
+        let ret_i = self.next?;
+        let node = &self.vec[ret_i];
+        self.next = if let Some(c) = node.child {
+            Some(c.head)
+        } else if let Ptr::Next(i) = node.next {
+            Some(i)
+        } else if let Ptr::Parent(i) = node.next {
+            let mut node = &self.vec[i];
+            while let Ptr::Parent(i) = node.next {
+                node = &self.vec[i];
+            }
+            if let Ptr::Next(i) = node.next {
+                Some(i)
+            } else {
+                None
+            }
+        } else {
+            None
+        };
+        if self.next_back.unwrap() == ret_i {
+            self.next = None;
+            self.next_back = None;
+        }
+        Some(ret_i)
+    }
+}
+
+impl<'a, T> DoubleEndedIterator for LayerIndexIterator<'a, T> {
+    fn next_back(&mut self) -> Option<Self::Item> {
+        let ret_i = self.next_back?;
+        let node = &self.vec[ret_i];
+        self.next_back = if let Ptr::Next(mut i) = node.prev {
+            while let Some(c) = self.vec[i].child {
+                i = c.tail
+            }
+            Some(i)
+        } else if let Ptr::Parent(i) = node.prev {
+            Some(i)
+        } else {
+            None
+        };
+        if self.next.unwrap() == ret_i {
+            self.next = None;
+            self.next_back = None;
+        }
+        Some(ret_i)
+    }
+}
+
+impl<'a, T> LayerIndexIterator<'a, T> {
+    fn new(vec: &'a Vec<LayerNode<T>>, last: usize) -> Self {
+        let mut last = last;
+        while let Some(c) = vec[last].child {
+            last = c.tail;
+        }
+        Self {
+            next: Some(0),
+            next_back: Some(last),
+            vec,
+        }
+    }
+}

iris/core/src/primitive/mod.rs

@@ -0,0 +1,9 @@
+mod color;
+mod layer;
+mod text;
+mod texture;
+
+pub use color::*;
+pub use layer::*;
+pub use text::*;
+pub use texture::*;

iris/core/src/primitive/text.rs

@@ -0,0 +1,191 @@
+use crate::{Align, RegionAlign, TextureHandle, Textures, UiColor, util::Vec2};
+use cosmic_text::{
+    Attrs, AttrsList, Buffer, CacheKey, Color, Family, FontSystem, Metrics, Placement, SwashCache,
+    SwashContent,
+};
+use image::{DynamicImage, GenericImageView, RgbaImage};
+use std::simd::{Simd, num::SimdUint};
+
+/// TODO: properly wrap this
+pub mod text_lib {
+    pub use cosmic_text::*;
+}
+
+pub struct TextData {
+    pub font_system: FontSystem,
+    pub swash_cache: SwashCache,
+    glyph_cache: Vec<(Placement, CacheKey, Color)>,
+}
+
+impl Default for TextData {
+    fn default() -> Self {
+        Self {
+            font_system: FontSystem::new(),
+            swash_cache: SwashCache::new(),
+            glyph_cache: Default::default(),
+        }
+    }
+}
+
+#[derive(Clone, Copy)]
+pub struct TextAttrs {
+    pub color: UiColor,
+    pub font_size: f32,
+    pub line_height: f32,
+    pub family: Family<'static>,
+    pub wrap: bool,
+    /// inner alignment of text region (within where it's drawn)
+    pub align: RegionAlign,
+}
+
+impl TextAttrs {
+    pub fn apply(&self, font_system: &mut FontSystem, buf: &mut Buffer, width: Option<f32>) {
+        buf.set_metrics_and_size(
+            font_system,
+            Metrics::new(self.font_size, self.line_height),
+            width,
+            None,
+        );
+        let attrs = Attrs::new().family(self.family);
+        let list = AttrsList::new(&attrs);
+        for line in &mut buf.lines {
+            line.set_attrs_list(list.clone());
+        }
+    }
+}
+
+pub type TextBuffer = Buffer;
+
+impl Default for TextAttrs {
+    fn default() -> Self {
+        let size = 16.0;
+        Self {
+            color: UiColor::WHITE,
+            font_size: size,
+            line_height: size * LINE_HEIGHT_MULT,
+            family: Family::SansSerif,
+            wrap: false,
+            align: Align::CENTER_LEFT,
+        }
+    }
+}
+
+pub const LINE_HEIGHT_MULT: f32 = 1.1;
+
+impl TextData {
+    pub fn draw(
+        &mut self,
+        buffer: &mut TextBuffer,
+        attrs: &TextAttrs,
+        textures: &mut Textures,
+    ) -> RenderedText {
+        // TODO: either this or the layout stuff (or both) is super slow,
+        // should probably do texture packing and things if possible.
+        // very visible if you add just a couple of wrapping texts and resize window
+        // should also be timed to figure out exactly what points need to be sped up
+        // let mut pixels = HashMap::<_, [u8; 4]>::default();
+        let mut min_x = 0;
+        let mut min_y = 0;
+        let mut max_x = 0;
+        let mut max_y = 0;
+        let text_color = {
+            let c = attrs.color;
+            cosmic_text::Color::rgba(c.r, c.g, c.b, c.a)
+        };
+        let mut max_width = 0.0f32;
+        let mut height = 0.0;
+
+        for run in buffer.layout_runs() {
+            for glyph in run.glyphs.iter() {
+                let physical_glyph = glyph.physical((0., 0.), 1.0);
+
+                let glyph_color = match glyph.color_opt {
+                    Some(some) => some,
+                    None => text_color,
+                };
+
+                if let Some(img) = self
+                    .swash_cache
+                    .get_image(&mut self.font_system, physical_glyph.cache_key)
+                {
+                    let mut pos = img.placement;
+                    pos.left += physical_glyph.x;
+                    pos.top = physical_glyph.y + run.line_y as i32 - pos.top;
+                    min_x = min_x.min(pos.left);
+                    min_y = min_y.min(pos.top);
+                    max_x = max_x.max(pos.left + pos.width as i32);
+                    max_y = max_y.max(pos.top + pos.height as i32);
+                    self.glyph_cache
+                        .push((pos, physical_glyph.cache_key, glyph_color));
+                }
+            }
+            max_width = max_width.max(run.line_w);
+            height += run.line_height;
+        }
+        let img_width = (max_x - min_x + 1) as u32;
+        let img_height = (max_y - min_y + 1) as u32;
+        let mut image = RgbaImage::new(img_width, img_height);
+
+        for (pos, key, color) in self.glyph_cache.drain(..) {
+            let img = self
+                .swash_cache
+                .get_image(&mut self.font_system, key)
+                .as_ref()
+                .unwrap();
+            let mut merge = |i, color: [u8; 4]| {
+                let i = i as i32;
+                let x = (i % pos.width as i32 + pos.left - min_x) as u32;
+                let y = (i / pos.width as i32 + pos.top - min_y) as u32;
+                let pixel = &mut image[(x, y)].0;
+                // TODO: no clue if proper alpha blending should be done
+                *pixel = Simd::from(color).saturating_add(Simd::from(*pixel)).into();
+            };
+
+            match img.content {
+                SwashContent::Mask => {
+                    for (i, a) in img.data.iter().enumerate() {
+                        let mut color = color.as_rgba();
+                        color[3] = ((color[3] as u32 * *a as u32) / u8::MAX as u32) as u8;
+                        merge(i, color);
+                    }
+                }
+                SwashContent::SubpixelMask => todo!("subpixel mask text rendering"),
+                SwashContent::Color => {
+                    let (colors, _) = img.data.as_chunks::<4>();
+                    for (i, color) in colors.iter().enumerate() {
+                        merge(i, *color);
+                    }
+                }
+            }
+        }
+
+        let max_dim = 8192;
+        if image.width() > max_dim || image.height() > max_dim {
+            let width = image.width().min(max_dim);
+            let height = image.height().min(max_dim);
+            eprintln!(
+                "WARNING: image of size {:?} cropped to {:?} (texture too big)",
+                image.dimensions(),
+                (width, height)
+            );
+            image = image.view(0, 0, width, height).to_image();
+        }
+
+        RenderedText {
+            handle: textures.add(image),
+            top_left_offset: Vec2::new(min_x as f32, min_y as f32),
+            size: Vec2::new(max_width, height),
+        }
+    }
+}
+
+#[derive(Clone)]
+pub struct RenderedText {
+    pub handle: TextureHandle,
+    pub top_left_offset: Vec2,
+    pub size: Vec2,
+}
+
+pub trait HasTextures {
+    fn add_texture(&mut self, image: DynamicImage) -> TextureHandle;
+}

iris/core/src/primitive/texture.rs

@@ -0,0 +1,136 @@
+use crate::{
+    render::TexturePrimitive,
+    util::{RefCounter, Vec2},
+};
+use image::{DynamicImage, GenericImageView};
+use std::{
+    ops::Index,
+    sync::mpsc::{Receiver, Sender, channel},
+};
+
+#[derive(Debug, Clone)]
+pub struct TextureHandle {
+    inner: TexturePrimitive,
+    size: Vec2,
+    counter: RefCounter,
+    send: Sender<u32>,
+}
+
+/// a texture manager for a ui
+/// note that this is heavily oriented towards wgpu's renderer so the primitives don't need mapped
+pub struct Textures {
+    free: Vec<u32>,
+    images: Vec<Option<DynamicImage>>,
+    updates: Vec<Update>,
+    send: Sender<u32>,
+    recv: Receiver<u32>,
+}
+
+pub enum TextureUpdate<'a> {
+    Push(&'a DynamicImage),
+    Set(u32, &'a DynamicImage),
+    Free(u32),
+    PushFree,
+    SetFree,
+}
+
+enum Update {
+    Push(u32),
+    Set(u32),
+    Free(u32),
+}
+
+impl Textures {
+    pub fn new() -> Self {
+        let (send, recv) = channel();
+        Self {
+            free: Vec::new(),
+            images: Vec::new(),
+            updates: Vec::new(),
+            send,
+            recv,
+        }
+    }
+    pub fn add(&mut self, image: impl Into<DynamicImage>) -> TextureHandle {
+        let image = image.into();
+        let size = image.dimensions().into();
+        let view_idx = self.push(image);
+        // 0 == default in renderer; TODO: actually create samplers here
+        let sampler_idx = 0;
+        TextureHandle {
+            inner: TexturePrimitive {
+                view_idx,
+                sampler_idx,
+            },
+            size,
+            counter: RefCounter::new(),
+            send: self.send.clone(),
+        }
+    }
+
+    fn push(&mut self, image: DynamicImage) -> u32 {
+        if let Some(i) = self.free.pop() {
+            self.images[i as usize] = Some(image);
+            self.updates.push(Update::Set(i));
+            i
+        } else {
+            let i = self.images.len() as u32;
+            self.images.push(Some(image));
+            self.updates.push(Update::Push(i));
+            i
+        }
+    }
+
+    pub fn free(&mut self) {
+        for idx in self.recv.try_iter() {
+            self.images[idx as usize] = None;
+            self.updates.push(Update::Free(idx));
+            self.free.push(idx);
+        }
+    }
+
+    pub fn updates(&mut self) -> impl Iterator<Item = TextureUpdate<'_>> {
+        self.updates.drain(..).map(|u| match u {
+            Update::Push(i) => self.images[i as usize]
+                .as_ref()
+                .map(TextureUpdate::Push)
+                .unwrap_or(TextureUpdate::PushFree),
+            Update::Set(i) => self.images[i as usize]
+                .as_ref()
+                .map(|img| TextureUpdate::Set(i, img))
+                .unwrap_or(TextureUpdate::SetFree),
+            Update::Free(i) => TextureUpdate::Free(i),
+        })
+    }
+}
+
+impl TextureHandle {
+    pub fn primitive(&self) -> TexturePrimitive {
+        self.inner
+    }
+    pub fn size(&self) -> Vec2 {
+        self.size
+    }
+}
+
+impl Drop for TextureHandle {
+    fn drop(&mut self) {
+        if self.counter.drop() {
+            let _ = self.send.send(self.inner.view_idx);
+        }
+    }
+}
+
+impl Index<&TextureHandle> for Textures {
+    type Output = DynamicImage;
+
+    fn index(&self, index: &TextureHandle) -> &Self::Output {
+        self.images[index.inner.view_idx as usize].as_ref().unwrap()
+    }
+}
+
+impl Default for Textures {
+    fn default() -> Self {
+        Self::new()
+    }
+}

iris/core/src/render/data.rs

@@ -0,0 +1,50 @@
+use crate::{UiRegion, util::Id};
+use wgpu::*;
+
+#[repr(C)]
+#[derive(Copy, Clone, bytemuck::Pod, bytemuck::Zeroable, Default)]
+pub struct WindowUniform {
+    pub width: f32,
+    pub height: f32,
+}
+
+#[repr(C)]
+#[derive(Copy, Clone, bytemuck::Pod, bytemuck::Zeroable)]
+pub struct PrimitiveInstance {
+    pub region: UiRegion,
+    pub binding: u32,
+    pub idx: u32,
+    pub mask_idx: MaskIdx,
+}
+
+impl PrimitiveInstance {
+    const ATTRIBS: [VertexAttribute; 7] = vertex_attr_array![
+        0 => Float32x2,
+        1 => Float32x2,
+        2 => Float32x2,
+        3 => Float32x2,
+        4 => Uint32,
+        5 => Uint32,
+        6 => Uint32,
+    ];
+
+    pub fn desc() -> VertexBufferLayout<'static> {
+        VertexBufferLayout {
+            array_stride: std::mem::size_of::<Self>() as BufferAddress,
+            step_mode: VertexStepMode::Instance,
+            attributes: &Self::ATTRIBS,
+        }
+    }
+}
+
+pub type MaskIdx = Id<u32>;
+
+impl MaskIdx {
+    pub const NONE: Self = Self::preset(u32::MAX);
+}
+
+#[repr(C)]
+#[derive(Debug, Copy, Clone, bytemuck::Pod, bytemuck::Zeroable)]
+pub struct Mask {
+    pub region: UiRegion,
+}

iris/core/src/render/mod.rs

@@ -0,0 +1,362 @@
+use std::num::NonZero;
+
+use crate::{
+    UiData, UiRenderState,
+    render::{data::PrimitiveInstance, texture::GpuTextures, util::ArrBuf},
+    util::HashMap,
+};
+use data::WindowUniform;
+use wgpu::{
+    util::{BufferInitDescriptor, DeviceExt},
+    *,
+};
+use winit::dpi::PhysicalSize;
+
+mod data;
+mod primitive;
+mod texture;
+mod util;
+
+pub use data::{Mask, MaskIdx};
+pub use primitive::*;
+
+const SHAPE_SHADER: &str = include_str!("./shader.wgsl");
+
+pub struct UiRenderNode {
+    uniform_group: BindGroup,
+    primitive_layout: BindGroupLayout,
+    rsc_layout: BindGroupLayout,
+    rsc_group: BindGroup,
+
+    pipeline: RenderPipeline,
+
+    layers: HashMap<usize, RenderLayer>,
+    active: Vec<usize>,
+    window_buffer: Buffer,
+    textures: GpuTextures,
+    masks: ArrBuf<Mask>,
+}
+
+struct RenderLayer {
+    instance: ArrBuf<PrimitiveInstance>,
+    primitives: PrimitiveBuffers,
+    primitive_group: BindGroup,
+}
+
+impl UiRenderNode {
+    pub fn draw<'a>(&'a self, pass: &mut RenderPass<'a>) {
+        pass.set_pipeline(&self.pipeline);
+        pass.set_bind_group(0, &self.uniform_group, &[]);
+        pass.set_bind_group(2, &self.rsc_group, &[]);
+        for i in &self.active {
+            let layer = &self.layers[i];
+            if layer.instance.len() == 0 {
+                continue;
+            }
+            pass.set_bind_group(1, &layer.primitive_group, &[]);
+            pass.set_vertex_buffer(0, layer.instance.buffer.slice(..));
+            pass.draw(0..4, 0..layer.instance.len() as u32);
+        }
+    }
+
+    pub fn update(
+        &mut self,
+        device: &Device,
+        queue: &Queue,
+        ui: &mut UiData,
+        ui_render: &mut UiRenderState,
+    ) {
+        self.active.clear();
+        for (i, primitives) in ui_render.layers.iter_mut() {
+            self.active.push(i);
+            for change in primitives.apply_free() {
+                if let Some(inst) = ui_render.active.get_mut(&change.id) {
+                    for h in &mut inst.primitives {
+                        if h.layer == i && h.inst_idx == change.old {
+                            h.inst_idx = change.new;
+                            break;
+                        }
+                    }
+                }
+            }
+            let rlayer = self.layers.entry(i).or_insert_with(|| {
+                let primitives = PrimitiveBuffers::new(device);
+                let primitive_group =
+                    Self::primitive_group(device, &self.primitive_layout, primitives.buffers());
+                RenderLayer {
+                    instance: ArrBuf::new(
+                        device,
+                        BufferUsages::VERTEX | BufferUsages::COPY_DST,
+                        "instance",
+                    ),
+                    primitives,
+                    primitive_group,
+                }
+            });
+            if primitives.updated {
+                rlayer
+                    .instance
+                    .update(device, queue, primitives.instances());
+                rlayer.primitives.update(device, queue, primitives.data());
+                rlayer.primitive_group = Self::primitive_group(
+                    device,
+                    &self.primitive_layout,
+                    rlayer.primitives.buffers(),
+                );
+                primitives.updated = false;
+            }
+        }
+        let mut changed = false;
+        changed |= self.textures.update(&mut ui.textures);
+        if ui.masks.changed {
+            ui.masks.changed = false;
+            self.masks.update(device, queue, &ui.masks[..]);
+            changed = true;
+        }
+        if changed {
+            self.rsc_group = Self::rsc_group(device, &self.rsc_layout, &self.textures, &self.masks);
+        }
+    }
+
+    pub fn resize(&mut self, size: &PhysicalSize<u32>, queue: &Queue) {
+        let slice = &[WindowUniform {
+            width: size.width as f32,
+            height: size.height as f32,
+        }];
+        queue.write_buffer(&self.window_buffer, 0, bytemuck::cast_slice(slice));
+    }
+
+    pub fn new(
+        device: &Device,
+        queue: &Queue,
+        config: &SurfaceConfiguration,
+        limits: UiLimits,
+    ) -> Self {
+        let shader = device.create_shader_module(ShaderModuleDescriptor {
+            label: Some("UI Shape Shader"),
+            source: ShaderSource::Wgsl(SHAPE_SHADER.into()),
+        });
+
+        let window_uniform = WindowUniform::default();
+        let window_buffer = device.create_buffer_init(&BufferInitDescriptor {
+            label: Some("window"),
+            contents: bytemuck::cast_slice(&[window_uniform]),
+            usage: BufferUsages::UNIFORM | BufferUsages::COPY_DST,
+        });
+
+        let uniform_layout = device.create_bind_group_layout(&BindGroupLayoutDescriptor {
+            entries: &[BindGroupLayoutEntry {
+                binding: 0,
+                visibility: ShaderStages::VERTEX | ShaderStages::FRAGMENT,
+                ty: BindingType::Buffer {
+                    ty: BufferBindingType::Uniform,
+                    has_dynamic_offset: false,
+                    min_binding_size: None,
+                },
+                count: None,
+            }],
+            label: Some("window"),
+        });
+
+        let uniform_group = Self::bind_group_0(device, &uniform_layout, &window_buffer);
+
+        let primitive_layout = device.create_bind_group_layout(&BindGroupLayoutDescriptor {
+            entries: &core::array::from_fn::<_, { PrimitiveBuffers::LEN }, _>(|i| {
+                BindGroupLayoutEntry {
+                    binding: i as u32,
+                    visibility: ShaderStages::FRAGMENT,
+                    ty: BindingType::Buffer {
+                        ty: BufferBindingType::Storage { read_only: true },
+                        has_dynamic_offset: false,
+                        min_binding_size: None,
+                    },
+                    count: None,
+                }
+            }),
+            label: Some("primitive"),
+        });
+
+        let tex_manager = GpuTextures::new(device, queue);
+        let masks = ArrBuf::new(
+            device,
+            BufferUsages::STORAGE | BufferUsages::COPY_DST,
+            "ui masks",
+        );
+
+        let rsc_layout = Self::rsc_layout(device, &limits);
+        let rsc_group = Self::rsc_group(device, &rsc_layout, &tex_manager, &masks);
+
+        let pipeline_layout = device.create_pipeline_layout(&PipelineLayoutDescriptor {
+            label: Some("UI Shape Pipeline Layout"),
+            bind_group_layouts: &[&uniform_layout, &primitive_layout, &rsc_layout],
+            immediate_size: 0,
+        });
+        let pipeline = device.create_render_pipeline(&RenderPipelineDescriptor {
+            label: Some("UI Shape Pipeline"),
+            layout: Some(&pipeline_layout),
+            vertex: VertexState {
+                module: &shader,
+                entry_point: Some("vs_main"),
+                buffers: &[PrimitiveInstance::desc()],
+                compilation_options: Default::default(),
+            },
+            fragment: Some(FragmentState {
+                module: &shader,
+                entry_point: Some("fs_main"),
+                targets: &[Some(ColorTargetState {
+                    format: config.format,
+                    blend: Some(BlendState::ALPHA_BLENDING),
+                    write_mask: ColorWrites::ALL,
+                })],
+                compilation_options: Default::default(),
+            }),
+            primitive: PrimitiveState {
+                topology: PrimitiveTopology::TriangleStrip,
+                strip_index_format: None,
+                front_face: FrontFace::Cw,
+                cull_mode: Some(Face::Back),
+                polygon_mode: PolygonMode::Fill,
+                unclipped_depth: false,
+                conservative: false,
+            },
+            depth_stencil: None,
+            multisample: MultisampleState {
+                count: 1,
+                mask: !0,
+                alpha_to_coverage_enabled: false,
+            },
+            multiview_mask: None,
+            cache: None,
+        });
+
+        Self {
+            uniform_group,
+            primitive_layout,
+            rsc_layout,
+            rsc_group,
+            pipeline,
+            window_buffer,
+            layers: HashMap::default(),
+            active: Vec::new(),
+            textures: tex_manager,
+            masks,
+        }
+    }
+
+    fn bind_group_0(
+        device: &Device,
+        layout: &BindGroupLayout,
+        window_buffer: &Buffer,
+    ) -> BindGroup {
+        device.create_bind_group(&BindGroupDescriptor {
+            layout,
+            entries: &[BindGroupEntry {
+                binding: 0,
+                resource: window_buffer.as_entire_binding(),
+            }],
+            label: Some("ui window"),
+        })
+    }
+
+    fn primitive_group(
+        device: &Device,
+        layout: &BindGroupLayout,
+        buffers: [(u32, &Buffer); PrimitiveBuffers::LEN],
+    ) -> BindGroup {
+        device.create_bind_group(&BindGroupDescriptor {
+            layout,
+            entries: &buffers.map(|(binding, buf)| BindGroupEntry {
+                binding,
+                resource: buf.as_entire_binding(),
+            }),
+            label: Some("ui primitives"),
+        })
+    }
+
+    fn rsc_layout(device: &Device, limits: &UiLimits) -> BindGroupLayout {
+        device.create_bind_group_layout(&BindGroupLayoutDescriptor {
+            entries: &[
+                BindGroupLayoutEntry {
+                    binding: 0,
+                    visibility: ShaderStages::FRAGMENT,
+                    ty: BindingType::Texture {
+                        sample_type: TextureSampleType::Float { filterable: false },
+                        view_dimension: TextureViewDimension::D2,
+                        multisampled: false,
+                    },
+                    count: Some(NonZero::new(limits.max_textures).unwrap()),
+                },
+                BindGroupLayoutEntry {
+                    binding: 1,
+                    visibility: ShaderStages::FRAGMENT,
+                    ty: BindingType::Sampler(SamplerBindingType::NonFiltering),
+                    count: Some(NonZero::new(limits.max_samplers).unwrap()),
+                },
+                BindGroupLayoutEntry {
+                    binding: 2,
+                    visibility: ShaderStages::FRAGMENT,
+                    ty: BindingType::Buffer {
+                        ty: BufferBindingType::Storage { read_only: true },
+                        has_dynamic_offset: false,
+                        min_binding_size: None,
+                    },
+                    count: None,
+                },
+            ],
+            label: Some("ui rsc"),
+        })
+    }
+
+    fn rsc_group(
+        device: &Device,
+        layout: &BindGroupLayout,
+        tex_manager: &GpuTextures,
+        masks: &ArrBuf<Mask>,
+    ) -> BindGroup {
+        device.create_bind_group(&BindGroupDescriptor {
+            layout,
+            entries: &[
+                BindGroupEntry {
+                    binding: 0,
+                    resource: BindingResource::TextureViewArray(&tex_manager.views()),
+                },
+                BindGroupEntry {
+                    binding: 1,
+                    resource: BindingResource::SamplerArray(&tex_manager.samplers()),
+                },
+                BindGroupEntry {
+                    binding: 2,
+                    resource: masks.buffer.as_entire_binding(),
+                },
+            ],
+            label: Some("ui rsc"),
+        })
+    }
+
+    pub fn view_count(&self) -> usize {
+        self.textures.view_count()
+    }
+}
+
+pub struct UiLimits {
+    max_textures: u32,
+    max_samplers: u32,
+}
+
+impl Default for UiLimits {
+    fn default() -> Self {
+        Self {
+            max_textures: 100000,
+            max_samplers: 1000,
+        }
+    }
+}
+
+impl UiLimits {
+    pub fn max_binding_array_elements_per_shader_stage(&self) -> u32 {
+        self.max_textures + self.max_samplers
+    }
+    pub fn max_binding_array_sampler_elements_per_shader_stage(&self) -> u32 {
+        self.max_samplers
+    }
+}

iris/core/src/render/primitive.rs

@@ -0,0 +1,282 @@
+use std::ops::{Deref, DerefMut};
+
+use crate::{
+    Color, UiRegion, WidgetId,
+    render::{
+        ArrBuf,
+        data::{MaskIdx, PrimitiveInstance},
+    },
+};
+use bytemuck::Pod;
+use wgpu::*;
+
+pub struct Primitives {
+    instances: Vec<PrimitiveInstance>,
+    assoc: Vec<WidgetId>,
+    data: PrimitiveData,
+    free: Vec<usize>,
+    pub updated: bool,
+}
+
+impl Default for Primitives {
+    fn default() -> Self {
+        Self {
+            instances: Default::default(),
+            assoc: Default::default(),
+            data: Default::default(),
+            free: Vec::new(),
+            updated: true,
+        }
+    }
+}
+
+pub trait Primitive: Pod {
+    const BINDING: u32;
+    fn vec(data: &mut PrimitiveData) -> &mut PrimitiveVec<Self>;
+}
+
+macro_rules! primitives {
+    ($($name:ident: $ty:ty => $binding:expr,)*) => {
+        #[derive(Default)]
+        pub struct PrimitiveData {
+            $(pub(crate) $name: PrimitiveVec<$ty>,)*
+        }
+
+        pub struct PrimitiveBuffers {
+            $($name: ArrBuf<$ty>,)*
+        }
+
+        impl PrimitiveBuffers {
+            pub fn update(&mut self, device: &Device, queue: &Queue, data: &PrimitiveData) {
+                $(self.$name.update(device, queue, &data.$name);)*
+            }
+        }
+
+        impl PrimitiveBuffers {
+            pub const LEN: usize = primitives!(@count $($name)*);
+            pub fn buffers(&self) -> [(u32, &Buffer); Self::LEN] {
+                [
+                    $((<$ty>::BINDING, &self.$name.buffer),)*
+                ]
+            }
+            pub fn new(device: &Device) -> Self {
+                Self {
+                    $($name: ArrBuf::new(
+                        device,
+                        BufferUsages::STORAGE | BufferUsages::COPY_DST,
+                        stringify!($name),
+                    ),)*
+                }
+            }
+        }
+
+        impl PrimitiveData {
+            pub fn clear(&mut self) {
+                $(self.$name.clear();)*
+            }
+            pub fn free(&mut self, binding: u32, idx: usize) {
+                match binding {
+                    $(<$ty>::BINDING => self.$name.free(idx),)*
+                    _ => unreachable!()
+                }
+            }
+        }
+
+        $(
+            unsafe impl bytemuck::Pod for $ty {}
+            unsafe impl bytemuck::Zeroable for $ty {}
+            impl Primitive for $ty {
+                const BINDING: u32 = $binding;
+                fn vec(data: &mut PrimitiveData) -> &mut PrimitiveVec<Self> {
+                    &mut data.$name
+                }
+            }
+        )*
+    };
+    (@count $t1:tt $($t:tt)+) => { 1 + primitives!(@count $($t),+) };
+    (@count $t:tt) => { 1 };
+}
+
+pub struct PrimitiveInst<P> {
+    pub id: WidgetId,
+    pub primitive: P,
+    pub region: UiRegion,
+    pub mask_idx: MaskIdx,
+}
+
+impl Primitives {
+    pub fn write<P: Primitive>(
+        &mut self,
+        layer: usize,
+        PrimitiveInst {
+            id,
+            primitive,
+            region,
+            mask_idx,
+        }: PrimitiveInst<P>,
+    ) -> PrimitiveHandle {
+        self.updated = true;
+        let vec = P::vec(&mut self.data);
+        let i = vec.add(primitive);
+        let inst = PrimitiveInstance {
+            region,
+            idx: i as u32,
+            mask_idx,
+            binding: P::BINDING,
+        };
+        let inst_i = if let Some(i) = self.free.pop() {
+            self.instances[i] = inst;
+            self.assoc[i] = id;
+            i
+        } else {
+            let i = self.instances.len();
+            self.instances.push(inst);
+            self.assoc.push(id);
+            i
+        };
+        PrimitiveHandle::new::<P>(layer, inst_i, i)
+    }
+
+    /// returns (old index, new index)
+    pub fn apply_free(&mut self) -> impl Iterator<Item = PrimitiveChange> {
+        self.free.sort_by(|a, b| b.cmp(a));
+        self.free.drain(..).filter_map(|i| {
+            self.instances.swap_remove(i);
+            self.assoc.swap_remove(i);
+            if i == self.instances.len() {
+                return None;
+            }
+            let id = self.assoc[i];
+            let old = self.instances.len();
+            Some(PrimitiveChange { id, old, new: i })
+        })
+    }
+
+    pub fn free(&mut self, h: &PrimitiveHandle) -> MaskIdx {
+        self.updated = true;
+        self.data.free(h.binding, h.data_idx);
+        self.free.push(h.inst_idx);
+        self.instances[h.inst_idx].mask_idx
+    }
+
+    pub fn data(&self) -> &PrimitiveData {
+        &self.data
+    }
+
+    pub fn instances(&self) -> &Vec<PrimitiveInstance> {
+        &self.instances
+    }
+
+    pub fn region_mut(&mut self, h: &PrimitiveHandle) -> &mut UiRegion {
+        self.updated = true;
+        &mut self.instances[h.inst_idx].region
+    }
+}
+
+pub struct PrimitiveChange {
+    pub id: WidgetId,
+    pub old: usize,
+    pub new: usize,
+}
+
+#[derive(Debug)]
+pub struct PrimitiveHandle {
+    pub layer: usize,
+    pub inst_idx: usize,
+    pub data_idx: usize,
+    pub binding: u32,
+}
+
+impl PrimitiveHandle {
+    fn new<P: Primitive>(layer: usize, inst_idx: usize, data_idx: usize) -> Self {
+        Self {
+            layer,
+            inst_idx,
+            data_idx,
+            binding: P::BINDING,
+        }
+    }
+}
+
+primitives!(
+    rects: RectPrimitive => 0,
+    textures: TexturePrimitive => 1,
+);
+
+#[repr(C)]
+#[derive(Copy, Clone)]
+pub struct RectPrimitive {
+    pub color: Color<u8>,
+    pub radius: f32,
+    pub thickness: f32,
+    pub inner_radius: f32,
+}
+
+impl RectPrimitive {
+    pub fn color(color: Color<u8>) -> Self {
+        Self {
+            color,
+            radius: 0.0,
+            thickness: 0.0,
+            inner_radius: 0.0,
+        }
+    }
+}
+
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct TexturePrimitive {
+    pub view_idx: u32,
+    pub sampler_idx: u32,
+}
+
+pub struct PrimitiveVec<T> {
+    vec: Vec<T>,
+    free: Vec<usize>,
+}
+
+impl<T> PrimitiveVec<T> {
+    pub fn new() -> Self {
+        Self {
+            vec: Vec::new(),
+            free: Vec::new(),
+        }
+    }
+    pub fn add(&mut self, t: T) -> usize {
+        if let Some(i) = self.free.pop() {
+            self.vec[i] = t;
+            i
+        } else {
+            let i = self.vec.len();
+            self.vec.push(t);
+            i
+        }
+    }
+    pub fn free(&mut self, i: usize) {
+        self.free.push(i);
+    }
+    pub fn clear(&mut self) {
+        self.free.clear();
+        self.vec.clear();
+    }
+}
+
+impl<T> Default for PrimitiveVec<T> {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
+impl<T> Deref for PrimitiveVec<T> {
+    type Target = Vec<T>;
+
+    fn deref(&self) -> &Self::Target {
+        &self.vec
+    }
+}
+
+impl<T> DerefMut for PrimitiveVec<T> {
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        &mut self.vec
+    }
+}

iris/core/src/render/shader.wgsl

@@ -0,0 +1,178 @@
+const RECT: u32 = 0u;
+const TEXTURE: u32 = 1u;
+
+@group(0) @binding(0)
+var<uniform> window: WindowUniform;
+@group(1) @binding(RECT)
+var<storage> rects: array<Rect>;
+@group(1) @binding(TEXTURE)
+var<storage> textures: array<TextureInfo>;
+
+struct Rect {
+    color: u32,
+    radius: f32,
+    thickness: f32,
+    inner_radius: f32,
+}
+
+struct TextureInfo {
+    view_idx: u32,
+    sampler_idx: u32,
+}
+
+struct Mask {
+    x: UiSpan,
+    y: UiSpan,
+}
+
+struct UiSpan {
+    start: UiScalar,
+    end: UiScalar,
+}
+
+struct UiScalar {
+    rel: f32,
+    abs: f32,
+}
+
+struct UiVec2 {
+    rel: vec2<f32>,
+    abs: vec2<f32>,
+}
+
+@group(2) @binding(0)
+var views: binding_array<texture_2d<f32>>;
+@group(2) @binding(1)
+var samplers: binding_array<sampler>;
+@group(2) @binding(2)
+var<storage> masks: array<Mask>;
+
+struct WindowUniform {
+    dim: vec2<f32>,
+};
+
+struct InstanceInput {
+    @location(0) x_start: vec2<f32>,
+    @location(1) x_end: vec2<f32>,
+    @location(2) y_start: vec2<f32>,
+    @location(3) y_end: vec2<f32>,
+    @location(4) binding: u32,
+    @location(5) idx: u32,
+    @location(6) mask_idx: u32,
+}
+
+struct VertexOutput {
+    @location(0) top_left: vec2<f32>,
+    @location(1) bot_right: vec2<f32>,
+    @location(2) uv: vec2<f32>,
+    @location(3) binding: u32,
+    @location(4) idx: u32,
+    @location(5) mask_idx: u32,
+    @builtin(position) clip_position: vec4<f32>,
+};
+
+struct Region {
+    pos: vec2<f32>,
+    uv: vec2<f32>,
+    top_left: vec2<f32>,
+    bot_right: vec2<f32>,
+}
+
+@vertex
+fn vs_main(
+    @builtin(vertex_index) vi: u32,
+    in: InstanceInput,
+) -> VertexOutput {
+    var out: VertexOutput;
+
+    let top_left_rel = vec2(in.x_start.x, in.y_start.x);
+    let top_left_abs = vec2(in.x_start.y, in.y_start.y);
+    let bot_right_rel = vec2(in.x_end.x, in.y_end.x);
+    let bot_right_abs = vec2(in.x_end.y, in.y_end.y);
+
+    let top_left = floor(top_left_rel * window.dim) + floor(top_left_abs);
+    let bot_right = floor(bot_right_rel * window.dim) + floor(bot_right_abs);
+    let size = bot_right - top_left;
+
+    let uv = vec2<f32>(
+        f32(vi % 2u),
+        f32(vi / 2u)
+    );
+    let pos = (top_left + uv * size) / window.dim * 2.0 - 1.0;
+    out.clip_position = vec4<f32>(pos.x, -pos.y, 0.0, 1.0);
+    out.uv = uv;
+    out.binding = in.binding;
+    out.idx = in.idx;
+    out.top_left = top_left;
+    out.bot_right = bot_right;
+    out.mask_idx = in.mask_idx;
+
+    return out;
+}
+
+@fragment
+fn fs_main(
+    in: VertexOutput
+) -> @location(0) vec4<f32> {
+    let pos = in.clip_position.xy;
+    let region = Region(pos, in.uv, in.top_left, in.bot_right);
+    let i = in.idx;
+    var color: vec4<f32>;
+    switch in.binding {
+        case RECT: {
+            color = draw_rounded_rect(region, rects[i]);
+        }
+        case TEXTURE: {
+            color = draw_texture(region, textures[i]);
+        }
+        default: {
+            color = vec4(1.0, 0.0, 1.0, 1.0);
+        }
+    }
+    if in.mask_idx != 4294967295u {
+        let mask = masks[in.mask_idx];
+        let tl = UiVec2(vec2(mask.x.start.rel, mask.y.start.rel), vec2(mask.x.start.abs, mask.y.start.abs));
+        let br = UiVec2(vec2(mask.x.end.rel, mask.y.end.rel), vec2(mask.x.end.abs, mask.y.end.abs));
+
+        let top_left = floor(tl.rel * window.dim) + floor(tl.abs);
+        let bot_right = floor(br.rel * window.dim) + floor(br.abs);
+        if pos.x < top_left.x || pos.x > bot_right.x || pos.y < top_left.y || pos.y > bot_right.y {
+            color *= 0.0;
+        }
+    }
+    return color;
+}
+
+// TODO: this seems really inefficient (per frag indexing)?
+fn draw_texture(region: Region, info: TextureInfo) -> vec4<f32> {
+    return textureSample(views[info.view_idx], samplers[info.sampler_idx], region.uv);
+}
+
+fn draw_rounded_rect(region: Region, rect: Rect) -> vec4<f32> {
+    var color = unpack4x8unorm(rect.color);
+
+    let edge = 0.5;
+
+    let size = region.bot_right - region.top_left;
+    let corner = size / 2.0;
+    let center = region.top_left + corner;
+
+    let dist = distance_from_rect(region.pos, center, corner, rect.radius);
+    color.a *= 1.0 - smoothstep(-min(edge, rect.radius), edge, dist);
+
+    if rect.thickness > 0.0 {
+        let dist2 = distance_from_rect(region.pos, center, corner - rect.thickness, rect.inner_radius);
+        color.a *= smoothstep(-min(edge, rect.inner_radius), edge, dist2);
+    }
+
+    return color;
+}
+
+fn distance_from_rect(pixel_pos: vec2<f32>, rect_center: vec2<f32>, rect_corner: vec2<f32>, radius: f32) -> f32 {
+    // vec from center to pixel
+    let p = pixel_pos - rect_center;
+    // vec from inner rect corner to pixel
+    let q = abs(p) - (rect_corner - radius);
+    return length(max(q, vec2(0.0))) - radius;
+}
+

iris/core/src/render/texture.rs

@@ -0,0 +1,129 @@
+use image::{DynamicImage, EncodableLayout};
+use wgpu::{util::DeviceExt, *};
+
+use crate::{TextureUpdate, Textures};
+
+pub struct GpuTextures {
+    device: Device,
+    queue: Queue,
+    views: Vec<TextureView>,
+    view_count: usize,
+    samplers: Vec<Sampler>,
+    null_view: TextureView,
+    no_views: Vec<TextureView>,
+}
+
+impl GpuTextures {
+    pub fn update(&mut self, textures: &mut Textures) -> bool {
+        let mut changed = false;
+        for update in textures.updates() {
+            changed = true;
+            match update {
+                TextureUpdate::Push(image) => self.push(image),
+                TextureUpdate::Set(i, image) => self.set(i, image),
+                TextureUpdate::SetFree => self.view_count += 1,
+                TextureUpdate::Free(i) => self.free(i),
+                TextureUpdate::PushFree => self.push_free(),
+            }
+        }
+        changed
+    }
+    fn set(&mut self, i: u32, image: &DynamicImage) {
+        self.view_count += 1;
+        let view = self.create_view(image);
+        self.views[i as usize] = view;
+    }
+    fn free(&mut self, i: u32) {
+        self.view_count -= 1;
+        self.views[i as usize] = self.null_view.clone();
+    }
+    fn push(&mut self, image: &DynamicImage) {
+        self.view_count += 1;
+        let view = self.create_view(image);
+        self.views.push(view);
+    }
+    fn push_free(&mut self) {
+        self.view_count += 1;
+        self.views.push(self.null_view.clone());
+    }
+
+    fn create_view(&self, image: &DynamicImage) -> TextureView {
+        let image = image.to_rgba8();
+        let (width, height) = image.dimensions();
+        let texture = self.device.create_texture_with_data(
+            &self.queue,
+            &TextureDescriptor {
+                label: None,
+                size: Extent3d {
+                    width,
+                    height,
+                    depth_or_array_layers: 1,
+                },
+                mip_level_count: 1,
+                sample_count: 1,
+                dimension: TextureDimension::D2,
+                format: TextureFormat::Rgba8Unorm,
+                usage: TextureUsages::TEXTURE_BINDING,
+                view_formats: &[],
+            },
+            wgt::TextureDataOrder::MipMajor,
+            image.as_bytes(),
+        );
+        texture.create_view(&TextureViewDescriptor::default())
+    }
+
+    pub fn new(device: &Device, queue: &Queue) -> Self {
+        let null_view = null_texture_view(device);
+        Self {
+            device: device.clone(),
+            queue: queue.clone(),
+            views: Vec::new(),
+            samplers: vec![default_sampler(device)],
+            no_views: vec![null_view.clone()],
+            null_view,
+            view_count: 0,
+        }
+    }
+
+    pub fn views(&self) -> Vec<&TextureView> {
+        if self.views.is_empty() {
+            &self.no_views
+        } else {
+            &self.views
+        }
+        .iter()
+        .by_ref()
+        .collect()
+    }
+
+    pub fn samplers(&self) -> Vec<&Sampler> {
+        self.samplers.iter().by_ref().collect()
+    }
+
+    pub fn view_count(&self) -> usize {
+        self.view_count
+    }
+}
+
+pub fn null_texture_view(device: &Device) -> TextureView {
+    device
+        .create_texture(&TextureDescriptor {
+            label: Some("null"),
+            size: Extent3d {
+                width: 1,
+                height: 1,
+                depth_or_array_layers: 1,
+            },
+            mip_level_count: 1,
+            sample_count: 1,
+            dimension: TextureDimension::D2,
+            format: TextureFormat::Rgba8Unorm,
+            usage: TextureUsages::TEXTURE_BINDING,
+            view_formats: &[],
+        })
+        .create_view(&TextureViewDescriptor::default())
+}
+
+pub fn default_sampler(device: &Device) -> Sampler {
+    device.create_sampler(&SamplerDescriptor::default())
+}

iris/core/src/render/util/mod.rs

@@ -0,0 +1,48 @@
+use std::marker::PhantomData;
+
+use bytemuck::Pod;
+use wgpu::*;
+
+pub struct ArrBuf<T: Pod> {
+    label: &'static str,
+    usage: BufferUsages,
+    pub buffer: Buffer,
+    len: usize,
+    _pd: PhantomData<T>,
+}
+
+impl<T: Pod> ArrBuf<T> {
+    pub fn new(device: &Device, usage: BufferUsages, label: &'static str) -> Self {
+        Self {
+            label,
+            usage,
+            buffer: Self::init_buf(device, 0, usage, label),
+            len: 0,
+            _pd: PhantomData,
+        }
+    }
+    pub fn update(&mut self, device: &Device, queue: &Queue, data: &[T]) {
+        if self.len != data.len() {
+            self.len = data.len();
+            self.buffer =
+                Self::init_buf(device, std::mem::size_of_val(data), self.usage, self.label);
+        }
+        queue.write_buffer(&self.buffer, 0, bytemuck::cast_slice(data));
+    }
+    fn init_buf(device: &Device, size: usize, usage: BufferUsages, label: &'static str) -> Buffer {
+        let mut size = size as u64;
+        if usage.contains(BufferUsages::STORAGE) {
+            size = size.max(std::mem::size_of::<T>() as u64);
+        }
+        device.create_buffer(&BufferDescriptor {
+            label: Some(label),
+            size,
+            mapped_at_creation: false,
+            usage,
+        })
+    }
+    #[allow(clippy::len_without_is_empty)]
+    pub fn len(&self) -> usize {
+        self.len
+    }
+}

iris/core/src/ui/active.rs

@@ -0,0 +1,14 @@
+use crate::{LayerId, MaskIdx, PrimitiveHandle, TextureHandle, UiRegion, WidgetId};
+
+/// important non rendering data for retained drawing
+#[derive(Debug)]
+pub struct ActiveData {
+    pub id: WidgetId,
+    pub region: UiRegion,
+    pub parent: Option<WidgetId>,
+    pub textures: Vec<TextureHandle>,
+    pub primitives: Vec<PrimitiveHandle>,
+    pub children: Vec<WidgetId>,
+    pub mask: MaskIdx,
+    pub layer: LayerId,
+}

iris/core/src/ui/cache.rs

@@ -0,0 +1,18 @@
+use crate::{BothAxis, Len, UiVec2, WidgetId, util::HashMap};
+
+#[derive(Default)]
+pub struct Cache {
+    pub size: BothAxis<HashMap<WidgetId, (UiVec2, Len)>>,
+}
+
+impl Cache {
+    pub fn remove(&mut self, id: WidgetId) {
+        self.size.x.remove(&id);
+        self.size.y.remove(&id);
+    }
+
+    pub fn clear(&mut self) {
+        self.size.x.clear();
+        self.size.y.clear();
+    }
+}

iris/core/src/ui/mod.rs

@@ -0,0 +1,47 @@
+use crate::{Mask, TextData, Textures, WeakWidget, WidgetId, Widgets, util::TrackedArena};
+
+mod active;
+mod cache;
+mod painter;
+mod render_state;
+mod size;
+
+pub use active::*;
+pub use painter::Painter;
+pub use render_state::*;
+pub use size::*;
+
+#[derive(Default)]
+pub struct UiData {
+    pub widgets: Widgets,
+    pub textures: Textures,
+    pub text: TextData,
+    pub masks: TrackedArena<Mask, u32>,
+}
+
+pub trait UiRsc {
+    fn ui(&self) -> &UiData;
+    fn ui_mut(&mut self) -> &mut UiData;
+
+    #[allow(unused_variables)]
+    fn on_add(&mut self, id: WeakWidget) {}
+    #[allow(unused_variables)]
+    fn on_remove(&mut self, id: WidgetId) {}
+    #[allow(unused_variables)]
+    fn on_draw(&mut self, active: &ActiveData) {}
+    #[allow(unused_variables)]
+    fn on_undraw(&mut self, active: &ActiveData) {}
+
+    fn widgets(&self) -> &Widgets {
+        &self.ui().widgets
+    }
+    fn widgets_mut(&mut self) -> &mut Widgets {
+        &mut self.ui_mut().widgets
+    }
+    fn free(&mut self) {
+        while let Some(id) = self.widgets_mut().free_next() {
+            self.on_remove(id);
+        }
+        self.ui_mut().textures.free();
+    }
+}

iris/core/src/ui/painter.rs

@@ -0,0 +1,145 @@
+use crate::{
+    Axis, Len, RenderedText, Size, SizeCtx, StrongWidget, TextAttrs, TextBuffer, TextData,
+    TextureHandle, UiRegion, UiRenderState, UiRsc, Widget, WidgetId,
+    render::{Mask, MaskIdx, Primitive, PrimitiveHandle, PrimitiveInst},
+    util::Vec2,
+};
+
+/// makes your surfaces look pretty
+pub struct Painter<'a> {
+    pub(super) state: &'a mut UiRenderState,
+    pub(super) rsc: &'a mut dyn UiRsc,
+
+    pub(super) region: UiRegion,
+    pub(super) mask: MaskIdx,
+    pub(super) textures: Vec<TextureHandle>,
+    pub(super) primitives: Vec<PrimitiveHandle>,
+    pub(super) children: Vec<WidgetId>,
+    pub layer: usize,
+    pub(super) id: WidgetId,
+}
+
+impl<'a> Painter<'a> {
+    fn primitive_at<P: Primitive>(&mut self, primitive: P, region: UiRegion) {
+        let h = self.state.layers.write(
+            self.layer,
+            PrimitiveInst {
+                id: self.id,
+                primitive,
+                region,
+                mask_idx: self.mask,
+            },
+        );
+        if self.mask != MaskIdx::NONE {
+            // TODO: I have no clue if this works at all :joy:
+            self.rsc.ui_mut().masks.push_ref(self.mask);
+        }
+        self.primitives.push(h);
+    }
+
+    /// Writes a primitive to be rendered
+    pub fn primitive<P: Primitive>(&mut self, primitive: P) {
+        self.primitive_at(primitive, self.region)
+    }
+
+    pub fn primitive_within<P: Primitive>(&mut self, primitive: P, region: UiRegion) {
+        self.primitive_at(primitive, region.within(&self.region));
+    }
+
+    pub fn set_mask(&mut self, region: UiRegion) {
+        assert!(self.mask == MaskIdx::NONE);
+        self.mask = self.rsc.ui_mut().masks.push(Mask { region });
+    }
+
+    /// Draws a widget within this widget's region.
+    pub fn widget<W: ?Sized>(&mut self, id: &StrongWidget<W>) {
+        self.widget_at(id, self.region);
+    }
+
+    /// Draws a widget somewhere within this one.
+    /// Useful for drawing child widgets in select areas.
+    pub fn widget_within<W: ?Sized>(&mut self, id: &StrongWidget<W>, region: UiRegion) {
+        self.widget_at(id, region.within(&self.region));
+    }
+
+    fn widget_at<W: ?Sized>(&mut self, id: &StrongWidget<W>, region: UiRegion) {
+        self.children.push(id.id());
+        self.state.draw_inner(
+            self.layer,
+            id.id(),
+            region,
+            Some(self.id),
+            self.mask,
+            None,
+            self.rsc,
+        );
+    }
+
+    pub fn texture_within(&mut self, handle: &TextureHandle, region: UiRegion) {
+        self.textures.push(handle.clone());
+        self.primitive_at(handle.primitive(), region.within(&self.region));
+    }
+
+    pub fn texture(&mut self, handle: &TextureHandle) {
+        self.textures.push(handle.clone());
+        self.primitive(handle.primitive());
+    }
+
+    pub fn texture_at(&mut self, handle: &TextureHandle, region: UiRegion) {
+        self.textures.push(handle.clone());
+        self.primitive_at(handle.primitive(), region);
+    }
+
+    /// returns (handle, offset from top left)
+    pub fn render_text(&mut self, buffer: &mut TextBuffer, attrs: &TextAttrs) -> RenderedText {
+        let ui = self.rsc.ui_mut();
+        ui.text.draw(buffer, attrs, &mut ui.textures)
+    }
+
+    pub fn region(&self) -> UiRegion {
+        self.region
+    }
+
+    pub fn size<W: ?Sized + Widget>(&mut self, id: &StrongWidget<W>) -> Size {
+        self.size_ctx().size(id)
+    }
+
+    pub fn len_axis<W: ?Sized + Widget>(&mut self, id: &StrongWidget<W>, axis: Axis) -> Len {
+        match axis {
+            Axis::X => self.size_ctx().width(id),
+            Axis::Y => self.size_ctx().height(id),
+        }
+    }
+
+    pub fn output_size(&self) -> Vec2 {
+        self.state.output_size
+    }
+
+    pub fn px_size(&mut self) -> Vec2 {
+        self.region.size().to_abs(self.state.output_size)
+    }
+
+    pub fn text_data(&mut self) -> &mut TextData {
+        &mut self.rsc.ui_mut().text
+    }
+
+    pub fn child_layer(&mut self) {
+        self.layer = self.state.layers.child(self.layer);
+    }
+
+    pub fn next_layer(&mut self) {
+        self.layer = self.state.layers.next(self.layer);
+    }
+
+    pub fn label(&self) -> &str {
+        &self.rsc.widgets().data(self.id).unwrap().label
+    }
+
+    pub fn id(&self) -> &WidgetId {
+        &self.id
+    }
+
+    pub fn size_ctx(&mut self) -> SizeCtx<'_> {
+        self.state.size_ctx(self.id, self.region.size(), self.rsc)
+    }
+}

iris/core/src/ui/render_state.rs

@@ -0,0 +1,319 @@
+use crate::{
+    ActiveData, Axis, IdLike, MaskIdx, Painter, PixelRegion, PrimitiveLayers, SizeCtx,
+    StrongWidget, UiRegion, UiRsc, UiVec2, WidgetId, Widgets,
+    ui::cache::Cache,
+    util::{HashMap, HashSet, Vec2, forget_ref},
+};
+
+pub struct UiRenderState {
+    pub active: HashMap<WidgetId, ActiveData>,
+    pub layers: PrimitiveLayers,
+    pub(super) output_size: Vec2,
+    pub cache: Cache,
+
+    old_root: Option<WidgetId>,
+    resized: bool,
+    draw_started: HashSet<WidgetId>,
+}
+
+impl UiRenderState {
+    pub fn new() -> Self {
+        Self {
+            active: Default::default(),
+            layers: Default::default(),
+            cache: Default::default(),
+            output_size: Vec2::ZERO,
+            old_root: None,
+            resized: false,
+            draw_started: Default::default(),
+        }
+    }
+
+    pub fn resize(&mut self, size: impl Into<Vec2>) {
+        self.output_size = size.into();
+        self.resized = true;
+    }
+
+    pub fn update<'a>(&mut self, root: impl Into<Option<&'a StrongWidget>>, rsc: &mut dyn UiRsc) {
+        // safety mechanism for memory leaks; might wanna return a result instead so user can
+        // decide whether to panic or not
+        if !rsc.widgets().waiting.is_empty() {
+            let widgets = rsc.widgets();
+            let len = widgets.waiting.len();
+            let all: Vec<_> = widgets
+                .waiting
+                .iter()
+                .map(|&w| format!("'{}' ({w:?})", widgets.label(w)))
+                .collect();
+            panic!(
+                "{len} widget(s) were never upgraded\n\
+                this is likely a memory leak; consider upgrading to strong if you plan on using it later\n\
+                weak widgets: {all:#?}"
+            );
+        }
+        let root = root.into();
+        if self.root_changed(root) || self.resized {
+            self.redraw_all(root, rsc);
+            self.old_root = root.map(|r| r.id());
+            self.resized = false;
+        } else if rsc.widgets().has_updates() {
+            self.redraw_updates(rsc);
+        }
+    }
+
+    fn redraw_all(&mut self, root: Option<&StrongWidget>, rsc: &mut dyn UiRsc) {
+        self.clear(rsc);
+        // free all resources & cache
+        if let Some(id) = root {
+            self.draw_inner(0, id.id(), UiRegion::FULL, None, MaskIdx::NONE, None, rsc);
+        }
+    }
+
+    // TODO: should prolly make a DrawInfo struct or smth for everything other than rsc
+    #[allow(clippy::too_many_arguments)]
+    pub(super) fn draw_inner(
+        &mut self,
+        layer: usize,
+        id: WidgetId,
+        region: UiRegion,
+        parent: Option<WidgetId>,
+        mask: MaskIdx,
+        old_children: Option<Vec<WidgetId>>,
+        rsc: &mut dyn UiRsc,
+    ) {
+        let mut old_children = old_children.unwrap_or_default();
+        if let Some(active) = self.active.get_mut(&id)
+            && !rsc.widgets().needs_redraw.contains(&id)
+        {
+            // check to see if we can skip drawing first
+            if active.region == region {
+                return;
+            } else if active.region.size() == region.size() {
+                // TODO: epsilon?
+                let from = active.region;
+                self.mov(id, from, region);
+                return;
+            }
+            // if not, then maintain resize and track old children to remove unneeded
+            let active = self.remove(id, false, rsc).unwrap();
+            old_children = active.children;
+        }
+
+        // draw widget
+        self.draw_started.insert(id);
+
+        let mut painter = Painter {
+            state: self,
+            region,
+            mask,
+            layer,
+            id,
+            textures: Vec::new(),
+            primitives: Vec::new(),
+            children: Vec::new(),
+            rsc,
+        };
+
+        let mut widget = painter.rsc.widgets().get_dyn_dynamic(id);
+        widget.draw(&mut painter);
+        drop(widget);
+
+        let Painter {
+            state: _,
+            rsc: _,
+            region,
+            mask,
+            textures,
+            primitives,
+            children,
+            layer,
+            id,
+        } = painter;
+
+        // add to active
+        let active = ActiveData {
+            id,
+            region,
+            parent,
+            textures,
+            primitives,
+            children,
+            mask,
+            layer,
+        };
+
+        // remove old children that weren't kept
+        for c in &old_children {
+            if !active.children.contains(c) {
+                self.remove_rec(*c, rsc);
+            }
+        }
+
+        rsc.on_draw(&active);
+        self.active.insert(id, active);
+    }
+
+    fn mov(&mut self, id: WidgetId, from: UiRegion, to: UiRegion) {
+        let active = self.active.get_mut(&id).unwrap();
+        for h in &active.primitives {
+            let region = self.layers[h.layer].region_mut(h);
+            *region = region.outside(&from).within(&to);
+        }
+        active.region = active.region.outside(&from).within(&to);
+        // SAFETY: children cannot be recursive
+        let children = unsafe { forget_ref(&active.children) };
+        for child in children {
+            self.mov(*child, from, to);
+        }
+    }
+
+    /// NOTE: instance textures are cleared and self.textures freed
+    fn remove(&mut self, id: WidgetId, undraw: bool, rsc: &mut dyn UiRsc) -> Option<ActiveData> {
+        let mut active = self.active.remove(&id);
+        if let Some(active) = &mut active {
+            for h in &active.primitives {
+                let mask = self.layers.free(h);
+                if mask != MaskIdx::NONE {
+                    rsc.ui_mut().masks.remove(mask);
+                }
+            }
+            active.textures.clear();
+            rsc.ui_mut().textures.free();
+            if undraw {
+                rsc.on_undraw(active);
+            }
+        }
+        active
+    }
+
+    fn remove_rec(&mut self, id: WidgetId, rsc: &mut dyn UiRsc) -> Option<ActiveData> {
+        self.cache.remove(id);
+        let inst = self.remove(id, true, rsc);
+        if let Some(inst) = &inst {
+            for c in &inst.children {
+                self.remove_rec(*c, rsc);
+            }
+        }
+        inst
+    }
+
+    fn clear(&mut self, rsc: &mut dyn UiRsc) {
+        for (_, active) in self.active.drain() {
+            rsc.on_undraw(&active);
+        }
+        self.cache.clear();
+        self.layers.clear();
+        rsc.widgets_mut().needs_redraw.clear();
+        rsc.free();
+    }
+
+    pub fn redraw_updates(&mut self, rsc: &mut dyn UiRsc) {
+        while let Some(&id) = rsc.widgets().needs_redraw.iter().next() {
+            self.redraw(id, rsc);
+        }
+        rsc.free();
+    }
+
+    pub fn root_changed<'a>(&self, root: impl Into<Option<&'a StrongWidget>>) -> bool {
+        root.into().map(|r| r.id()) != self.old_root
+    }
+
+    pub fn needs_redraw<'a>(
+        &self,
+        root: impl Into<Option<&'a StrongWidget>>,
+        widgets: &Widgets,
+    ) -> bool {
+        self.root_changed(root) || widgets.has_updates()
+    }
+
+    pub fn active_widgets(&self) -> usize {
+        self.active.len()
+    }
+
+    pub fn debug(&self, widgets: &Widgets, label: &str) -> impl Iterator<Item = &ActiveData> {
+        self.active.iter().filter_map(move |(&id, inst)| {
+            let l = widgets.label(id);
+            if l == label { Some(inst) } else { None }
+        })
+    }
+
+    pub fn debug_layers(&self) {
+        for ((idx, depth), primitives) in self.layers.iter_depth() {
+            let indent = " ".repeat(depth * 2);
+            let len = primitives.instances().len();
+            print!("{indent}{idx}: {len} primitives");
+            if len >= 1 {
+                print!(" ({})", primitives.instances()[0].binding);
+            }
+            println!();
+        }
+    }
+
+    pub fn window_region(&self, id: &impl IdLike) -> Option<PixelRegion> {
+        let region = self.active.get(&id.id())?.region;
+        Some(region.to_px(self.output_size))
+    }
+
+    /// redraws a widget that's currently active (drawn)
+    pub fn redraw(&mut self, id: WidgetId, rsc: &mut dyn UiRsc) {
+        rsc.widgets_mut().needs_redraw.remove(&id);
+        self.draw_started.remove(&id);
+        // check if parent depends on the desired size of this, if so then redraw it first
+        for axis in [Axis::X, Axis::Y] {
+            if let Some(&(outer, old)) = self.cache.size.axis_dyn(axis).get(&id)
+                && let Some(current) = self.active.get(&id)
+                && let Some(pid) = current.parent
+            {
+                self.cache.size.axis_dyn(axis).remove(&id);
+                let new = self.size_ctx(id, outer, rsc).len_axis(id, axis);
+                self.cache.size.axis_dyn(axis).insert(id, (outer, new));
+                if new != old {
+                    self.redraw(pid, rsc);
+                }
+            }
+        }
+
+        if self.draw_started.contains(&id) {
+            return;
+        }
+
+        let Some(active) = self.remove(id, false, rsc) else {
+            return;
+        };
+
+        self.draw_inner(
+            active.layer,
+            id,
+            active.region,
+            active.parent,
+            active.mask,
+            Some(active.children),
+            rsc,
+        );
+    }
+
+    pub(super) fn size_ctx<'b>(
+        &'b mut self,
+        source: WidgetId,
+        outer: UiVec2,
+        rsc: &'b mut dyn UiRsc,
+    ) -> SizeCtx<'b> {
+        let ui = rsc.ui_mut();
+        SizeCtx {
+            source,
+            cache: &mut self.cache,
+            text: &mut ui.text,
+            textures: &mut ui.textures,
+            widgets: &ui.widgets,
+            outer,
+            output_size: self.output_size,
+            id: source,
+        }
+    }
+}
+
+impl Default for UiRenderState {
+    fn default() -> Self {
+        Self::new()
+    }
+}

iris/core/src/ui/size.rs

@@ -0,0 +1,86 @@
+use crate::{
+    Axis, AxisT, IdLike, Len, RenderedText, Size, TextAttrs, TextBuffer, TextData, Textures,
+    UiVec2, WidgetAxisFns, WidgetId, Widgets, XAxis, YAxis, ui::cache::Cache, util::Vec2,
+};
+
+pub struct SizeCtx<'a> {
+    pub text: &'a mut TextData,
+    pub textures: &'a mut Textures,
+    pub(super) source: WidgetId,
+    pub(super) widgets: &'a Widgets,
+    pub(super) cache: &'a mut Cache,
+    /// TODO: should this be pub? rn used for sized
+    pub outer: UiVec2,
+    pub(super) output_size: Vec2,
+    pub(super) id: WidgetId,
+}
+
+impl SizeCtx<'_> {
+    pub fn id(&self) -> &WidgetId {
+        &self.id
+    }
+
+    pub fn source(&self) -> &WidgetId {
+        &self.source
+    }
+
+    pub(super) fn len_inner<A: const AxisT>(&mut self, id: WidgetId) -> Len {
+        if let Some((_, len)) = self.cache.size.axis::<A>().get(&id) {
+            return *len;
+        }
+        let len = self
+            .widgets
+            .get_dyn_dynamic(id)
+            .desired_len::<A>(&mut SizeCtx {
+                text: self.text,
+                textures: self.textures,
+                source: self.source,
+                widgets: self.widgets,
+                cache: self.cache,
+                outer: self.outer,
+                output_size: self.output_size,
+                id,
+            });
+        self.cache.size.axis::<A>().insert(id, (self.outer, len));
+        len
+    }
+
+    pub fn width(&mut self, id: impl IdLike) -> Len {
+        self.len_inner::<XAxis>(id.id())
+    }
+
+    pub fn height(&mut self, id: impl IdLike) -> Len {
+        self.len_inner::<YAxis>(id.id())
+    }
+
+    pub fn len_axis(&mut self, id: impl IdLike, axis: Axis) -> Len {
+        match axis {
+            Axis::X => self.width(id),
+            Axis::Y => self.height(id),
+        }
+    }
+
+    pub fn size(&mut self, id: impl IdLike) -> Size {
+        let id = id.id();
+        Size {
+            x: self.width(id),
+            y: self.height(id),
+        }
+    }
+
+    pub fn px_size(&mut self) -> Vec2 {
+        self.outer.to_abs(self.output_size)
+    }
+
+    pub fn output_size(&mut self) -> Vec2 {
+        self.output_size
+    }
+
+    pub fn draw_text(&mut self, buffer: &mut TextBuffer, attrs: &TextAttrs) -> RenderedText {
+        self.text.draw(buffer, attrs, self.textures)
+    }
+
+    pub fn label(&self, id: WidgetId) -> &String {
+        self.widgets.label(id)
+    }
+}

iris/core/src/util/arena.rs

@@ -0,0 +1,109 @@
+use std::ops::Deref;
+
+use crate::util::{Id, IdNum, IdTracker};
+
+pub struct Arena<T, I> {
+    data: Vec<T>,
+    tracker: IdTracker<I>,
+}
+
+impl<T, I: IdNum> Arena<T, I> {
+    pub fn new() -> Self {
+        Self {
+            data: Vec::new(),
+            tracker: IdTracker::default(),
+        }
+    }
+
+    pub fn push(&mut self, value: T) -> Id<I> {
+        let id = self.tracker.next();
+        let i = id.idx();
+        if i == self.data.len() {
+            self.data.push(value);
+        } else {
+            self.data[i] = value;
+        }
+        id
+    }
+
+    pub fn remove(&mut self, id: Id<I>) -> T
+    where
+        T: Copy,
+    {
+        let i = id.idx();
+        self.tracker.free(id);
+        self.data[i]
+    }
+}
+
+impl<T, I: IdNum> Default for Arena<T, I> {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
+pub struct TrackedArena<T, I> {
+    inner: Arena<T, I>,
+    refs: Vec<u32>,
+    pub changed: bool,
+}
+
+impl<T, I: IdNum> TrackedArena<T, I> {
+    pub fn new() -> Self {
+        Self {
+            inner: Arena::default(),
+            refs: Vec::new(),
+            changed: true,
+        }
+    }
+
+    pub fn push(&mut self, value: T) -> Id<I> {
+        self.changed = true;
+        let id = self.inner.push(value);
+        let i = id.idx();
+        if i == self.refs.len() {
+            self.refs.push(0);
+        }
+        id
+    }
+
+    pub fn push_ref(&mut self, i: Id<I>) {
+        self.refs[i.idx()] += 1;
+    }
+
+    pub fn remove(&mut self, id: Id<I>) -> T
+    where
+        T: Copy,
+    {
+        let i = id.idx();
+        self.refs[i] -= 1;
+        if self.refs[i] == 0 {
+            self.changed = true;
+            self.inner.remove(id)
+        } else {
+            self[i]
+        }
+    }
+}
+
+impl<T, I: IdNum> Default for TrackedArena<T, I> {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
+impl<T, I> Deref for TrackedArena<T, I> {
+    type Target = Vec<T>;
+
+    fn deref(&self) -> &Self::Target {
+        &self.inner.data
+    }
+}
+
+impl<T, I> Deref for Arena<T, I> {
+    type Target = Vec<T>;
+
+    fn deref(&self) -> &Self::Target {
+        &self.data
+    }
+}

iris/core/src/util/borrow.rs

@@ -0,0 +1,35 @@
+use std::ops::{Deref, DerefMut};
+
+pub struct DynBorrower<'a, T: ?Sized> {
+    data: &'a mut T,
+    borrowed: &'a mut bool,
+}
+
+impl<'a, T: ?Sized> DynBorrower<'a, T> {
+    pub fn new(data: &'a mut T, borrowed: &'a mut bool) -> Self {
+        if *borrowed {
+            panic!("tried to mutably borrow the same thing twice");
+        }
+        Self { data, borrowed }
+    }
+}
+
+impl<T: ?Sized> Drop for DynBorrower<'_, T> {
+    fn drop(&mut self) {
+        *self.borrowed = false;
+    }
+}
+
+impl<T: ?Sized> Deref for DynBorrower<'_, T> {
+    type Target = T;
+
+    fn deref(&self) -> &Self::Target {
+        self.data
+    }
+}
+
+impl<T: ?Sized> DerefMut for DynBorrower<'_, T> {
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        self.data
+    }
+}

iris/core/src/util/change.rs

@@ -0,0 +1,30 @@
+use std::ops::{Deref, DerefMut};
+
+pub struct MutDetect<T> {
+    inner: T,
+    pub changed: bool,
+}
+
+impl<T> Deref for MutDetect<T> {
+    type Target = T;
+
+    fn deref(&self) -> &Self::Target {
+        &self.inner
+    }
+}
+
+impl<T> DerefMut for MutDetect<T> {
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        self.changed = true;
+        &mut self.inner
+    }
+}
+
+impl<T> From<T> for MutDetect<T> {
+    fn from(inner: T) -> Self {
+        MutDetect {
+            inner,
+            changed: true,
+        }
+    }
+}

iris/core/src/util/id.rs

@@ -0,0 +1,87 @@
+#[repr(C)]
+#[derive(Eq, Hash, PartialEq, Debug, Clone, Copy, bytemuck::Zeroable)]
+pub struct Id<I = u64>(I);
+
+unsafe impl<I: Copy + bytemuck::Zeroable + 'static> bytemuck::Pod for Id<I> {}
+
+pub struct IdTracker<I = u64> {
+    free: Vec<Id<I>>,
+    cur: Id<I>,
+}
+
+impl<I: IdNum> IdTracker<I> {
+    #[allow(clippy::should_implement_trait)]
+    pub fn next(&mut self) -> Id<I> {
+        if let Some(id) = self.free.pop() {
+            return id;
+        }
+        let next = self.cur.next();
+        std::mem::replace(&mut self.cur, next)
+    }
+
+    #[allow(dead_code)]
+    pub fn free(&mut self, id: Id<I>) {
+        self.free.push(id);
+    }
+}
+
+impl<I: IdNum> Id<I> {
+    #[allow(dead_code)]
+    /// for debug purposes; should this be exposed?
+    /// generally you want to use labels with widgets
+    pub(crate) fn raw(id: I) -> Self {
+        Self(id)
+    }
+    pub fn idx(&self) -> usize {
+        self.0.idx()
+    }
+    pub fn next(&self) -> Id<I> {
+        Self(self.0.next())
+    }
+    pub const fn preset(value: I) -> Self {
+        Self(value)
+    }
+}
+
+impl<I: IdNum> Default for IdTracker<I> {
+    fn default() -> Self {
+        Self {
+            free: Vec::new(),
+            cur: Id(I::first()),
+        }
+    }
+}
+
+pub trait IdNum {
+    fn first() -> Self;
+    fn next(&self) -> Self;
+    fn idx(&self) -> usize;
+}
+
+impl IdNum for u64 {
+    fn first() -> Self {
+        0
+    }
+
+    fn next(&self) -> Self {
+        self + 1
+    }
+
+    fn idx(&self) -> usize {
+        *self as usize
+    }
+}
+
+impl IdNum for u32 {
+    fn first() -> Self {
+        0
+    }
+
+    fn next(&self) -> Self {
+        self + 1
+    }
+
+    fn idx(&self) -> usize {
+        *self as usize
+    }
+}

iris/core/src/util/math.rs

@@ -0,0 +1,87 @@
+use std::ops::*;
+
+pub const trait LerpUtil {
+    fn lerp(self, from: Self, to: Self) -> Self;
+    fn lerp_inv(self, from: Self, to: Self) -> Self;
+}
+
+pub const trait DivOr {
+    fn div_or(self, rhs: Self, other: Self) -> Self;
+}
+
+impl const DivOr for f32 {
+    fn div_or(self, rhs: Self, other: Self) -> Self {
+        let res = self / rhs;
+        if res.is_nan() { other } else { res }
+    }
+}
+
+impl<T: const Add<Output = T> + const Sub<Output = T> + const Mul<Output = T> + const DivOr + Copy> const
+    LerpUtil for T
+{
+    /// linear interpolation
+    /// from * (1.0 - self) + to * self
+    fn lerp(self, from: Self, to: Self) -> Self {
+        from + (to - from) * self
+    }
+    /// inverse of lerp
+    fn lerp_inv(self, from: Self, to: Self) -> Self {
+        (self - from).div_or(to - from, from)
+    }
+}
+
+macro_rules! impl_op {
+    ($T:ident $op:ident $fn:ident $opa:ident $fna:ident; $($field:ident)*) => {
+        #[allow(non_snake_case)]
+        mod ${concat($T, _op_, $fn, _impl)} {
+            use super::*;
+            #[allow(unused_imports)]
+            use std::ops::*;
+            impl const $op for $T {
+                type Output = Self;
+
+                fn $fn(self, rhs: Self) -> Self::Output {
+                    Self {
+                        $($field: self.$field.$fn(rhs.$field),)*
+                    }
+                }
+            }
+            impl const $opa for $T {
+                fn $fna(&mut self, rhs: Self) {
+                    *self = self.$fn(rhs);
+                }
+            }
+            impl const $op<f32> for $T {
+                type Output = Self;
+
+                fn $fn(self, rhs: f32) -> Self::Output {
+                    Self {
+                        $($field: self.$field.$fn(rhs),)*
+                    }
+                }
+            }
+            impl const $op<$T> for f32 {
+                type Output = $T;
+
+                fn $fn(self, rhs: $T) -> Self::Output {
+                    $T {
+                        $($field: self.$fn(rhs.$field),)*
+                    }
+                }
+            }
+            impl const $opa<f32> for $T {
+                fn $fna(&mut self, rhs: f32) {
+                    *self = self.$fn(rhs);
+                }
+            }
+        }
+    };
+    ($T:ident $op:ident $fn:ident; $($field:ident)*) => {
+        impl_op!($T $op $fn ${concat($op,Assign)} ${concat($fn,_assign)}; $($field)*);
+    };
+    (impl $op:ident for $T:ident: $fn:ident $($field:ident)*) => {
+        impl_op!($T $op $fn ${concat($op,Assign)} ${concat($fn,_assign)}; $($field)*);
+    };
+}
+
+pub(crate) use impl_op;

iris/core/src/util/mod.rs

@@ -0,0 +1,24 @@
+mod arena;
+mod borrow;
+mod change;
+mod id;
+mod math;
+mod refcount;
+mod slot;
+mod trust;
+mod typemap;
+mod vec2;
+
+pub use arena::*;
+pub use borrow::*;
+pub use change::*;
+pub use id::*;
+pub use math::*;
+pub use refcount::*;
+pub use slot::*;
+pub use trust::*;
+pub use typemap::*;
+pub use vec2::*;
+
+pub type HashMap<K, V> = fxhash::FxHashMap<K, V>;
+pub type HashSet<K> = fxhash::FxHashSet<K>;

iris/core/src/util/refcount.rs

@@ -0,0 +1,36 @@
+use std::sync::{
+    Arc,
+    atomic::{AtomicU32, Ordering},
+};
+
+#[derive(Debug)]
+pub struct RefCounter(Arc<AtomicU32>);
+
+impl RefCounter {
+    pub fn new() -> Self {
+        Self(Arc::new(0.into()))
+    }
+    pub fn refs(&self) -> u32 {
+        self.0.load(Ordering::Acquire)
+    }
+    pub fn drop(&mut self) -> bool {
+        let refs = self.0.fetch_sub(1, Ordering::Release);
+        refs == 0
+    }
+    pub fn quiet_clone(&self) -> Self {
+        Self(self.0.clone())
+    }
+}
+
+impl Default for RefCounter {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
+impl Clone for RefCounter {
+    fn clone(&self) -> Self {
+        self.0.fetch_add(1, Ordering::Release);
+        Self(self.0.clone())
+    }
+}

iris/core/src/util/slot.rs

@@ -0,0 +1,69 @@
+#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
+pub struct SlotId {
+    idx: u32,
+    genr: u32,
+}
+
+pub struct SlotVec<T> {
+    data: Vec<(u32, Option<T>)>,
+    free: Vec<u32>,
+}
+
+impl<T> SlotVec<T> {
+    pub fn new() -> Self {
+        Self {
+            data: Default::default(),
+            free: Default::default(),
+        }
+    }
+
+    pub fn add(&mut self, x: T) -> SlotId {
+        if let Some(idx) = self.free.pop() {
+            let (genr, data) = &mut self.data[idx as usize];
+            *data = Some(x);
+            SlotId { idx, genr: *genr }
+        } else {
+            let idx = self.data.len() as u32;
+            let genr = 0;
+            self.data.push((genr, Some(x)));
+            SlotId { idx, genr }
+        }
+    }
+
+    pub fn free(&mut self, id: SlotId) {
+        let (genr, data) = &mut self.data[id.idx as usize];
+        *genr += 1;
+        *data = None;
+        self.free.push(id.idx);
+    }
+
+    pub fn get(&self, id: SlotId) -> Option<&T> {
+        let slot = &self.data[id.idx as usize];
+        if slot.0 != id.genr {
+            return None;
+        }
+        slot.1.as_ref()
+    }
+
+    pub fn get_mut(&mut self, id: SlotId) -> Option<&mut T> {
+        let slot = &mut self.data[id.idx as usize];
+        if slot.0 != id.genr {
+            return None;
+        }
+        slot.1.as_mut()
+    }
+
+    pub fn len(&self) -> usize {
+        self.data.len() - self.free.len()
+    }
+
+    pub fn is_empty(&self) -> bool {
+        self.len() == 0
+    }
+}
+
+impl<T> Default for SlotVec<T> {
+    fn default() -> Self {
+        Self::new()
+    }
+}

iris/core/src/util/trust.rs

@@ -0,0 +1,17 @@
+#[allow(clippy::missing_safety_doc)]
+pub unsafe fn forget_ref<'a, T>(x: &T) -> &'a T {
+    unsafe { std::mem::transmute::<&T, &T>(x) }
+}
+
+#[allow(clippy::missing_safety_doc)]
+pub unsafe fn forget_mut<'a, T>(x: &mut T) -> &'a mut T {
+    unsafe { std::mem::transmute::<&mut T, &mut T>(x) }
+}
+
+#[allow(clippy::mut_from_ref, clippy::missing_safety_doc)]
+pub unsafe fn to_mut<T>(x: &T) -> &mut T {
+    #[allow(mutable_transmutes)]
+    unsafe {
+        std::mem::transmute::<&T, &mut T>(x)
+    }
+}

iris/core/src/util/typemap.rs

@@ -0,0 +1,56 @@
+use crate::util::HashMap;
+use std::{
+    any::TypeId,
+    marker::Unsize,
+    ops::{Deref, DerefMut},
+};
+
+pub struct TypeMap<Trait: ?Sized> {
+    map: HashMap<TypeId, Box<Trait>>,
+}
+
+impl<Trait: ?Sized> TypeMap<Trait> {
+    pub fn set_type<T: Unsize<Trait> + 'static>(&mut self, val: T) {
+        self.map
+            .insert(TypeId::of::<T>(), Box::new(val) as Box<Trait>);
+    }
+
+    pub fn type_mut<T: Unsize<Trait> + 'static>(&mut self) -> Option<&mut T> {
+        Some(Self::convert_mut(self.map.get_mut(&TypeId::of::<T>())?))
+    }
+
+    pub fn type_or_default<T: Default + Unsize<Trait> + 'static>(&mut self) -> &mut T {
+        Self::convert_mut(
+            self.map
+                .entry(TypeId::of::<T>())
+                .or_insert(Box::new(T::default()) as Box<Trait>),
+        )
+    }
+
+    fn convert_mut<T: Unsize<Trait>>(entry: &mut Box<Trait>) -> &mut T {
+        // allegedly this is just what Any does...
+        unsafe { &mut *(entry.as_mut() as *mut Trait as *mut T) }
+    }
+}
+
+impl<T: ?Sized> Deref for TypeMap<T> {
+    type Target = HashMap<TypeId, Box<T>>;
+
+    fn deref(&self) -> &Self::Target {
+        &self.map
+    }
+}
+
+impl<T: ?Sized> DerefMut for TypeMap<T> {
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        &mut self.map
+    }
+}
+
+impl<T: ?Sized> Default for TypeMap<T> {
+    fn default() -> Self {
+        Self {
+            map: Default::default(),
+        }
+    }
+}

iris/core/src/util/vec2.rs

@@ -0,0 +1,99 @@
+use crate::util::{DivOr, impl_op};
+use std::{hash::Hash, ops::*};
+
+#[repr(C)]
+#[derive(Clone, Copy, PartialEq, Default, bytemuck::Pod, bytemuck::Zeroable)]
+pub struct Vec2 {
+    pub x: f32,
+    pub y: f32,
+}
+
+impl Eq for Vec2 {}
+
+impl Hash for Vec2 {
+    fn hash<H: std::hash::Hasher>(&self, state: &mut H) {
+        state.write_u32(self.x.to_bits());
+        state.write_u32(self.y.to_bits());
+    }
+}
+
+impl Vec2 {
+    pub const ZERO: Self = Self::new(0.0, 0.0);
+    pub const ONE: Self = Self::new(1.0, 1.0);
+
+    pub const fn new(x: f32, y: f32) -> Self {
+        Self { x, y }
+    }
+
+    pub const fn round(self) -> Self {
+        Self {
+            x: self.x.round(),
+            y: self.y.round(),
+        }
+    }
+
+    pub const fn floor(self) -> Self {
+        Self {
+            x: self.x.floor(),
+            y: self.y.floor(),
+        }
+    }
+
+    pub const fn ceil(self) -> Self {
+        Self {
+            x: self.x.ceil(),
+            y: self.y.ceil(),
+        }
+    }
+
+    pub const fn tuple(&self) -> (f32, f32) {
+        (self.x, self.y)
+    }
+
+    pub const fn with_x(mut self, x: f32) -> Self {
+        self.x = x;
+        self
+    }
+
+    pub const fn with_y(mut self, y: f32) -> Self {
+        self.y = y;
+        self
+    }
+}
+
+// this version looks kinda cool... is it more readable? more annoying to copy and change though
+impl_op!(impl Add for Vec2: add x y);
+impl_op!(Vec2 Sub sub; x y);
+impl_op!(Vec2 Mul mul; x y);
+impl_op!(Vec2 Div div; x y);
+
+impl const DivOr for Vec2 {
+    fn div_or(self, rhs: Self, other: Self) -> Self {
+        Self {
+            x: self.x.div_or(rhs.x, other.x),
+            y: self.y.div_or(rhs.y, other.y),
+        }
+    }
+}
+
+impl Neg for Vec2 {
+    type Output = Self;
+
+    fn neg(mut self) -> Self::Output {
+        self.x = -self.x;
+        self.y = -self.y;
+        self
+    }
+}
+
+impl std::fmt::Debug for Vec2 {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        write!(f, "({}, {})", self.x, self.y)
+    }
+}
+
+impl std::fmt::Display for Vec2 {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        write!(f, "({}, {})", self.x, self.y)
+    }
+}

iris/core/src/widget/data.rs

@@ -0,0 +1,22 @@
+use crate::Widget;
+
+pub struct WidgetData {
+    pub widget: Box<dyn Widget>,
+    pub label: String,
+    /// dynamic borrow checking
+    pub borrowed: bool,
+}
+
+impl WidgetData {
+    pub fn new<W: Widget>(widget: W) -> Self {
+        let mut label = std::any::type_name::<W>().to_string();
+        if let (Some(first), Some(last)) = (label.find(":"), label.rfind(":")) {
+            label = label.split_at(first).0.to_string() + "::" + label.split_at(last + 1).1;
+        }
+        Self {
+            widget: Box::new(widget),
+            label,
+            borrowed: false,
+        }
+    }
+}

iris/core/src/widget/handle.rs

@@ -0,0 +1,164 @@
+use std::{marker::Unsize, ops::CoerceUnsized, sync::mpsc::Sender};
+
+use crate::{
+    UiRsc, Widget,
+    util::{RefCounter, SlotId},
+};
+
+pub type WidgetId = SlotId;
+
+/// An identifier for a widget that can index a UI or event ctx to get it.
+/// This is a strong handle that does not impl Clone, and when it is dropped,
+/// a signal is sent to the owning UI to clean up the resources.
+///
+/// TODO: ergonomic clones when they get put in rust-analyzer & don't cause ICEs?
+pub struct StrongWidget<W: ?Sized = dyn Widget> {
+    pub(super) id: WidgetId,
+    counter: RefCounter,
+    send: Sender<WidgetId>,
+    ty: *const W,
+}
+
+/// A weak handle to a widget.
+/// Will not keep it alive, but can still be used for indexing like WidgetHandle.
+pub struct WeakWidget<W: ?Sized = dyn Widget> {
+    pub(super) id: WidgetId,
+    #[allow(unused)]
+    ty: *const W,
+}
+
+impl<W: Widget + ?Sized + Unsize<dyn Widget>> StrongWidget<W> {
+    pub fn any(self) -> StrongWidget<dyn Widget> {
+        self
+    }
+}
+
+impl<W: ?Sized> StrongWidget<W> {
+    pub(crate) fn new(id: WidgetId, send: Sender<WidgetId>) -> Self {
+        Self {
+            id,
+            counter: RefCounter::new(),
+            send,
+            ty: null_ptr(),
+        }
+    }
+
+    pub fn id(&self) -> WidgetId {
+        self.id
+    }
+
+    pub fn refs(&self) -> u32 {
+        self.counter.refs()
+    }
+
+    pub fn weak(&self) -> WeakWidget<W> {
+        let Self { ty, id, .. } = *self;
+        WeakWidget { ty, id }
+    }
+}
+
+impl<W: ?Sized> WeakWidget<W> {
+    pub(crate) fn new(id: WidgetId) -> Self {
+        Self { id, ty: null_ptr() }
+    }
+
+    pub fn id(&self) -> WidgetId {
+        self.id
+    }
+
+    #[track_caller]
+    pub fn upgrade(self, ui: &mut impl UiRsc) -> StrongWidget<W> {
+        ui.widgets_mut().upgrade(self)
+    }
+}
+
+impl<W: ?Sized> Drop for StrongWidget<W> {
+    fn drop(&mut self) {
+        if self.counter.drop() {
+            let _ = self.send.send(self.id);
+        }
+    }
+}
+
+pub trait WidgetIdFn<Rsc, W: ?Sized = dyn Widget>: FnOnce(&mut Rsc) -> WeakWidget<W> {}
+impl<Rsc, W: ?Sized, F: FnOnce(&mut Rsc) -> WeakWidget<W>> WidgetIdFn<Rsc, W> for F {}
+
+pub trait IdLike {
+    type Widget: ?Sized;
+    fn id(&self) -> WidgetId;
+}
+
+impl<W: ?Sized> IdLike for &StrongWidget<W> {
+    type Widget = W;
+    fn id(&self) -> WidgetId {
+        self.id
+    }
+}
+
+impl<W: ?Sized> IdLike for StrongWidget<W> {
+    type Widget = W;
+    fn id(&self) -> WidgetId {
+        self.id
+    }
+}
+
+impl<W: ?Sized> IdLike for WeakWidget<W> {
+    type Widget = W;
+    fn id(&self) -> WidgetId {
+        self.id
+    }
+}
+
+impl IdLike for WidgetId {
+    type Widget = dyn Widget;
+    fn id(&self) -> WidgetId {
+        *self
+    }
+}
+
+impl<T: ?Sized + Unsize<U>, U: ?Sized> CoerceUnsized<StrongWidget<U>> for StrongWidget<T> {}
+impl<T: ?Sized + Unsize<U>, U: ?Sized> CoerceUnsized<WeakWidget<U>> for WeakWidget<T> {}
+
+impl<W: ?Sized> Clone for WeakWidget<W> {
+    fn clone(&self) -> Self {
+        *self
+    }
+}
+impl<W: ?Sized> Copy for WeakWidget<W> {}
+impl<W: ?Sized> PartialEq for WeakWidget<W> {
+    fn eq(&self, other: &Self) -> bool {
+        self.id == other.id
+    }
+}
+
+impl<W> PartialEq for StrongWidget<W> {
+    fn eq(&self, other: &Self) -> bool {
+        self.id == other.id
+    }
+}
+
+impl<W> std::fmt::Debug for StrongWidget<W> {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        self.id.fmt(f)
+    }
+}
+
+impl<'a, W: Widget + 'a, State: UiRsc> FnOnce<(&'a mut State,)> for WeakWidget<W> {
+    type Output = &'a mut W;
+
+    extern "rust-call" fn call_once(self, args: (&'a mut State,)) -> Self::Output {
+        &mut args.0.widgets_mut()[self]
+    }
+}
+
+fn null_ptr<W: ?Sized>() -> *const W {
+    if size_of::<&W>() == size_of::<*const dyn Widget>() {
+        let w: *const dyn Widget = &();
+        unsafe { std::mem::transmute_copy(&w) }
+    } else {
+        unsafe { std::mem::transmute_copy(&[0usize; 1]) }
+    }
+}
+
+unsafe impl<W: ?Sized> Send for WeakWidget<W> {}
+unsafe impl<W: ?Sized> Sync for WeakWidget<W> {}

iris/core/src/widget/like.rs

@@ -0,0 +1,75 @@
+use crate::UiRsc;
+
+use super::*;
+use std::marker::Unsize;
+
+pub trait WidgetLike<Rsc: UiRsc, Tag>: Sized {
+    type Widget: Widget + ?Sized + Unsize<dyn Widget>;
+
+    fn add(self, rsc: &mut Rsc) -> WeakWidget<Self::Widget>;
+
+    fn add_strong(self, rsc: &mut Rsc) -> StrongWidget<Self::Widget> {
+        self.add(rsc).upgrade(rsc)
+    }
+
+    fn with_id<W2>(
+        self,
+        f: impl FnOnce(&mut Rsc, WeakWidget<Self::Widget>) -> WeakWidget<W2>,
+    ) -> impl WidgetIdFn<Rsc, W2> {
+        move |state| {
+            let id = self.add(state);
+            f(state, id)
+        }
+    }
+
+    fn set_root(self, rsc: &mut Rsc, root: &mut impl HasRoot) {
+        let id = self.add_strong(rsc);
+        root.set_root(id);
+    }
+}
+
+pub trait HasRoot {
+    fn set_root(&mut self, root: StrongWidget);
+}
+
+pub trait WidgetArrLike<Rsc, const LEN: usize, Tag> {
+    #[track_caller]
+    fn add(self, state: &mut Rsc) -> WidgetArr<LEN>;
+}
+
+impl<Rsc, const LEN: usize> WidgetArrLike<Rsc, LEN, ArrTag> for WidgetArr<LEN> {
+    fn add(self, _: &mut Rsc) -> WidgetArr<LEN> {
+        self
+    }
+}
+
+// variadic generics please save us
+macro_rules! impl_widget_arr {
+    ($n:expr;$($W:ident)*) => {
+        impl_widget_arr!($n;$($W)*;$(${concat($W,Tag)})*);
+    };
+    ($n:expr;$($W:ident)*;$($Tag:ident)*) => {
+        impl<Rsc: UiRsc, $($W: WidgetLike<Rsc, $Tag>,$Tag,)*> WidgetArrLike<Rsc, $n, ($($Tag,)*)> for ($($W,)*) {
+            fn add(self, rsc: &mut Rsc) -> WidgetArr<$n> {
+                #[allow(non_snake_case)]
+                let ($($W,)*) = self;
+                WidgetArr::new(
+                    [$($W.add(rsc).upgrade(rsc),)*],
+                )
+            }
+        }
+    };
+}
+
+impl_widget_arr!(1;A);
+impl_widget_arr!(2;A B);
+impl_widget_arr!(3;A B C);
+impl_widget_arr!(4;A B C D);
+impl_widget_arr!(5;A B C D E);
+impl_widget_arr!(6;A B C D E F);
+impl_widget_arr!(7;A B C D E F G);
+impl_widget_arr!(8;A B C D E F G H);
+impl_widget_arr!(9;A B C D E F G H I);
+impl_widget_arr!(10;A B C D E F G H I J);
+impl_widget_arr!(11;A B C D E F G H I J K);
+impl_widget_arr!(12;A B C D E F G H I J K L);

iris/core/src/widget/mod.rs

@@ -0,0 +1,87 @@
+use crate::{Axis, AxisT, Len, Painter, SizeCtx};
+use std::any::Any;
+
+mod data;
+mod handle;
+mod like;
+mod tag;
+mod view;
+mod widgets;
+
+pub use data::*;
+pub use handle::*;
+pub use like::*;
+pub use tag::*;
+pub use view::*;
+pub use widgets::*;
+
+pub trait Widget: Any {
+    fn draw(&mut self, painter: &mut Painter);
+    fn desired_width(&mut self, ctx: &mut SizeCtx) -> Len;
+    fn desired_height(&mut self, ctx: &mut SizeCtx) -> Len;
+}
+
+pub trait WidgetAxisFns {
+    fn desired_len<A: AxisT>(&mut self, ctx: &mut SizeCtx) -> Len;
+}
+
+impl<W: Widget + ?Sized> WidgetAxisFns for W {
+    fn desired_len<A: AxisT>(&mut self, ctx: &mut SizeCtx) -> Len {
+        match A::get() {
+            Axis::X => self.desired_width(ctx),
+            Axis::Y => self.desired_height(ctx),
+        }
+    }
+}
+
+impl Widget for () {
+    fn draw(&mut self, _: &mut Painter) {}
+    fn desired_width(&mut self, _: &mut SizeCtx) -> Len {
+        Len::ZERO
+    }
+    fn desired_height(&mut self, _: &mut SizeCtx) -> Len {
+        Len::ZERO
+    }
+}
+
+impl dyn Widget {
+    pub fn as_any(&self) -> &dyn Any {
+        self
+    }
+
+    pub fn as_any_mut(&mut self) -> &mut dyn Any {
+        self
+    }
+}
+
+/// A function that returns a widget given a UI.
+/// Useful for defining trait functions on widgets that create a parent widget so that the children
+/// don't need to be IDs yet
+pub trait WidgetFn<State, W: Widget + ?Sized>: FnOnce(&mut State) -> W {}
+impl<State, W: Widget + ?Sized, F: FnOnce(&mut State) -> W> WidgetFn<State, W> for F {}
+
+pub struct WidgetArr<const LEN: usize> {
+    pub arr: [StrongWidget; LEN],
+}
+
+impl<const LEN: usize> WidgetArr<LEN> {
+    pub fn new(arr: [StrongWidget; LEN]) -> Self {
+        Self { arr }
+    }
+}
+
+pub trait WidgetOption<State> {
+    fn get(self, state: &mut State) -> Option<StrongWidget>;
+}
+
+impl<State> WidgetOption<State> for () {
+    fn get(self, _: &mut State) -> Option<StrongWidget> {
+        None
+    }
+}
+
+impl<State, F: FnOnce(&mut State) -> Option<StrongWidget>> WidgetOption<State> for F {
+    fn get(self, state: &mut State) -> Option<StrongWidget> {
+        self(state)
+    }
+}

iris/core/src/widget/tag.rs

@@ -0,0 +1,64 @@
+use super::*;
+use crate::UiRsc;
+use std::marker::Unsize;
+
+pub struct WidgetTag;
+impl<Rsc: UiRsc, W: Widget> WidgetLike<Rsc, WidgetTag> for W {
+    type Widget = W;
+    fn add(self, rsc: &mut Rsc) -> WeakWidget<W> {
+        let w = rsc.ui_mut().widgets.add_weak(self);
+        rsc.on_add(w);
+        w
+    }
+}
+
+pub struct FnTag;
+impl<Rsc: UiRsc, W: Widget, F: FnOnce(&mut Rsc) -> W> WidgetLike<Rsc, FnTag> for F {
+    type Widget = W;
+    fn add(self, rsc: &mut Rsc) -> WeakWidget<W> {
+        self(rsc).add(rsc)
+    }
+}
+
+pub trait WidgetFnTrait<Rsc> {
+    type Widget: Widget;
+    fn run(self, rsc: &mut Rsc) -> Self::Widget;
+}
+pub struct FnTraitTag;
+impl<Rsc: UiRsc, T: WidgetFnTrait<Rsc>> WidgetLike<Rsc, FnTraitTag> for T {
+    type Widget = T::Widget;
+    #[track_caller]
+    fn add(self, rsc: &mut Rsc) -> WeakWidget<T::Widget> {
+        self.run(rsc).add(rsc)
+    }
+}
+
+pub struct RefTag;
+impl<Rsc: UiRsc, W: ?Sized + Widget + Unsize<dyn Widget>> WidgetLike<Rsc, RefTag>
+    for WeakWidget<W>
+{
+    type Widget = W;
+    fn add(self, _: &mut Rsc) -> WeakWidget<W> {
+        self
+    }
+}
+
+pub struct RefFnTag;
+impl<Rsc: UiRsc, W: ?Sized + Widget + Unsize<dyn Widget>, F: FnOnce(&mut Rsc) -> WeakWidget<W>>
+    WidgetLike<Rsc, RefFnTag> for F
+{
+    type Widget = W;
+    fn add(self, rsc: &mut Rsc) -> WeakWidget<W> {
+        self(rsc)
+    }
+}
+
+pub struct ViewTag;
+impl<Rsc: UiRsc, V: WidgetView> WidgetLike<Rsc, ViewTag> for V {
+    type Widget = V::Widget;
+    fn add(self, _: &mut Rsc) -> WeakWidget<Self::Widget> {
+        self.root()
+    }
+}
+
+pub struct ArrTag;

iris/core/src/widget/view.rs

@@ -0,0 +1,24 @@
+use std::marker::Unsize;
+
+use crate::{IdLike, WeakWidget, Widget};
+
+pub trait WidgetView {
+    type Widget: Widget + ?Sized + Unsize<dyn Widget>;
+    fn root(&self) -> WeakWidget<Self::Widget>;
+}
+
+pub trait HasWidget {
+    type Widget: Widget + ?Sized + Unsize<dyn Widget>;
+}
+
+impl<W: Widget + Unsize<dyn Widget> + ?Sized> HasWidget for WeakWidget<W> {
+    type Widget = W;
+}
+
+impl<WV: WidgetView> IdLike for WV {
+    type Widget = WV::Widget;
+
+    fn id(&self) -> super::WidgetId {
+        self.root().id
+    }
+}

iris/core/src/widget/widgets.rs

@@ -0,0 +1,145 @@
+use std::sync::mpsc::{Receiver, Sender, channel};
+
+use crate::{
+    IdLike, StrongWidget, WeakWidget, Widget, WidgetData, WidgetId,
+    util::{DynBorrower, HashSet, SlotVec, forget_mut, to_mut},
+};
+
+pub struct Widgets {
+    pub needs_redraw: HashSet<WidgetId>,
+    vec: SlotVec<WidgetData>,
+    send: Sender<WidgetId>,
+    recv: Receiver<WidgetId>,
+    pub(crate) waiting: HashSet<WidgetId>,
+}
+
+impl Widgets {
+    pub fn new() -> Self {
+        let (send, recv) = channel();
+        Self {
+            needs_redraw: Default::default(),
+            vec: Default::default(),
+            waiting: Default::default(),
+            send,
+            recv,
+        }
+    }
+
+    pub fn has_updates(&self) -> bool {
+        !self.needs_redraw.is_empty()
+    }
+
+    pub fn get_dyn(&self, id: WidgetId) -> Option<&dyn Widget> {
+        Some(self.vec.get(id)?.widget.as_ref())
+    }
+
+    pub fn get_dyn_mut(&mut self, id: WidgetId) -> Option<&mut dyn Widget> {
+        self.needs_redraw.insert(id);
+        Some(self.vec.get_mut(id)?.widget.as_mut())
+    }
+
+    /// get_dyn but dynamic borrow checking of widgets
+    /// lets you do recursive (tree) operations, like the painter does
+    pub(crate) fn get_dyn_dynamic<'a>(&self, id: WidgetId) -> WidgetWrapper<'a> {
+        // SAFETY: must guarantee no other mutable references to this widget exist
+        // done through the borrow variable
+        let data = unsafe { forget_mut(to_mut(self.vec.get(id).unwrap())) };
+        if data.borrowed {
+            panic!("tried to mutably borrow the same widget twice");
+        }
+        WidgetWrapper::new(data.widget.as_mut(), &mut data.borrowed)
+    }
+
+    pub fn get<I: IdLike>(&self, id: &I) -> Option<&I::Widget>
+    where
+        I::Widget: Sized + Widget,
+    {
+        self.get_dyn(id.id())?.as_any().downcast_ref()
+    }
+
+    pub fn get_mut<I: IdLike>(&mut self, id: &I) -> Option<&mut I::Widget>
+    where
+        I::Widget: Sized + Widget,
+    {
+        self.get_dyn_mut(id.id())?.as_any_mut().downcast_mut()
+    }
+
+    pub fn add_strong<W: Widget>(&mut self, widget: W) -> StrongWidget<W> {
+        let id = self.vec.add(WidgetData::new(widget));
+        StrongWidget::new(id, self.send.clone())
+    }
+
+    pub fn add_weak<W: Widget>(&mut self, widget: W) -> WeakWidget<W> {
+        let id = self.vec.add(WidgetData::new(widget));
+        self.waiting.insert(id);
+        WeakWidget::new(id)
+    }
+
+    #[track_caller]
+    pub fn upgrade<W: ?Sized>(&mut self, rf: WeakWidget<W>) -> StrongWidget<W> {
+        if !self.waiting.remove(&rf.id()) {
+            let label = self.label(rf);
+            let id = rf.id();
+            panic!(
+                "widget '{label}' ({id:?}) was already added\ncannot add a widget twice; consider creating two"
+            )
+        }
+        StrongWidget::new(rf.id(), self.send.clone())
+    }
+
+    pub fn data(&self, id: impl IdLike) -> Option<&WidgetData> {
+        self.vec.get(id.id())
+    }
+
+    pub fn label(&self, id: impl IdLike) -> &String {
+        &self.data(id.id()).unwrap().label
+    }
+
+    /// useful for debugging
+    pub fn set_label(&mut self, id: impl IdLike, label: String) {
+        self.data_mut(id.id()).unwrap().label = label;
+    }
+
+    pub fn data_mut(&mut self, id: impl IdLike) -> Option<&mut WidgetData> {
+        self.vec.get_mut(id.id())
+    }
+
+    pub fn free_next(&mut self) -> Option<WidgetId> {
+        let next = self.recv.try_recv().ok()?;
+        self.vec.free(next);
+        Some(next)
+    }
+
+    #[allow(clippy::len_without_is_empty)]
+    pub fn len(&self) -> usize {
+        self.vec.len()
+    }
+}
+
+impl Default for Widgets {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
+pub type WidgetWrapper<'a> = DynBorrower<'a, dyn Widget>;
+
+impl<I: IdLike> std::ops::Index<I> for Widgets
+where
+    I::Widget: Sized + Widget,
+{
+    type Output = I::Widget;
+
+    fn index(&self, id: I) -> &Self::Output {
+        self.get(&id).unwrap()
+    }
+}
+
+impl<I: IdLike> std::ops::IndexMut<I> for Widgets
+where
+    I::Widget: Sized + Widget,
+{
+    fn index_mut(&mut self, id: I) -> &mut Self::Output {
+        self.get_mut(&id).unwrap()
+    }
+}

iris/examples/minimal.rs

@@ -0,0 +1,21 @@
+use iris::prelude::*;
+
+fn main() {
+    DefaultApp::<State>::run();
+}
+
+#[derive(DefaultUiState)]
+struct State {
+    ui_state: DefaultUiState,
+}
+
+impl DefaultAppState for State {
+    fn new(
+        mut ui_state: DefaultUiState,
+        rsc: &mut DefaultRsc<Self>,
+        _: Proxy<Self::Event>,
+    ) -> Self {
+        rect(Color::RED).set_root(rsc, &mut ui_state);
+        Self { ui_state }
+    }
+}

iris/examples/tabs/main.rs

@@ -0,0 +1,225 @@
+use cosmic_text::Family;
+use std::{cell::RefCell, rc::Rc};
+use winit::event::WindowEvent;
+
+use iris::prelude::*;
+type ClientRsc = DefaultRsc<Client>;
+
+fn main() {
+    DefaultApp::<Client>::run();
+}
+
+#[derive(DefaultUiState)]
+pub struct Client {
+    ui_state: DefaultUiState,
+    info: WeakWidget<Text>,
+}
+
+impl DefaultAppState for Client {
+    fn new(
+        mut ui_state: DefaultUiState,
+        rsc: &mut DefaultRsc<Self>,
+        _: Proxy<Self::Event>,
+    ) -> Self {
+        let rrect = rect(Color::WHITE).radius(20);
+        let pad_test = (
+            rrect.color(Color::BLUE),
+            (
+                rrect
+                    .color(Color::RED)
+                    .sized((100, 100))
+                    .center()
+                    .width(rest(2)),
+                (
+                    rrect.color(Color::ORANGE),
+                    rrect.color(Color::LIME).pad(10.0),
+                )
+                    .span(Dir::RIGHT)
+                    .width(rest(2)),
+                rrect.color(Color::YELLOW),
+            )
+                .span(Dir::RIGHT)
+                .pad(10)
+                .width(rest(3)),
+        )
+            .span(Dir::RIGHT)
+            .add(rsc);
+
+        let span_test = (
+            rrect.color(Color::GREEN).width(100),
+            rrect.color(Color::ORANGE),
+            rrect.color(Color::CYAN),
+            rrect.color(Color::BLUE).width(rel(0.5)),
+            rrect.color(Color::MAGENTA).width(100),
+            rrect.color(Color::RED).width(100),
+        )
+            .span(Dir::LEFT)
+            .add(rsc);
+
+        let span_add = Span::empty(Dir::RIGHT).add(rsc);
+
+        let add_button = rect(Color::LIME)
+            .radius(30)
+            .on(CursorSense::click(), move |_, rsc| {
+                let child = image(include_bytes!("assets/sungals.png"))
+                    .center()
+                    .add_strong(rsc);
+                span_add(rsc).push(child);
+            })
+            .sized((150, 150))
+            .align(Align::BOT_RIGHT);
+
+        let del_button = rect(Color::RED)
+            .radius(30)
+            .on(CursorSense::click(), move |_, rsc| {
+                span_add(rsc).pop();
+            })
+            .sized((150, 150))
+            .align(Align::BOT_LEFT);
+
+        let span_add_test = (span_add, add_button, del_button).stack().add(rsc);
+
+        let btext = |content| wtext(content).size(30);
+
+        let text_test = (
+            btext("this is a").align(Align::LEFT),
+            btext("teeeeeeeest").align(Align::RIGHT),
+            btext("okkk\nokkkkkk!").align(Align::LEFT),
+            btext("hmm"),
+            btext("a"),
+            (
+                btext("'").family(Family::Monospace).align(Align::TOP),
+                btext("'").family(Family::Monospace),
+                btext(":gamer mode").family(Family::Monospace),
+                rect(Color::CYAN).sized((10, 10)).center(),
+                rect(Color::RED).sized((100, 100)).center(),
+                rect(Color::PURPLE).sized((50, 50)).align(Align::TOP),
+            )
+                .span(Dir::RIGHT)
+                .center(),
+            wtext("pretty cool right?").size(50),
+        )
+            .span(Dir::DOWN)
+            .add(rsc);
+
+        let texts = Span::empty(Dir::DOWN).gap(10).add(rsc);
+        let msg_area = texts.scrollable().masked().background(rect(Color::SKY));
+        let add_text = wtext("add")
+            .editable(EditMode::MultiLine)
+            .text_align(Align::LEFT)
+            .size(30)
+            .attr::<Selectable>(())
+            .on(Submit, move |ctx, rsc| {
+                let w = ctx.widget;
+                let content = w.edit(rsc).take();
+                let text = wtext(content)
+                    .editable(EditMode::MultiLine)
+                    .size(30)
+                    .text_align(Align::LEFT)
+                    .wrap(true)
+                    .attr::<Selectable>(());
+                let msg_box = text
+                    .background(rect(Color::WHITE.darker(0.5)))
+                    .add_strong(rsc);
+                texts(rsc).push(msg_box);
+            })
+            .add(rsc);
+
+        let text_edit_scroll = (
+            msg_area.height(rest(1)),
+            (
+                Rect::new(Color::WHITE.darker(0.9)),
+                (
+                    add_text.width(rest(1)),
+                    Rect::new(Color::GREEN)
+                        .on(CursorSense::click(), move |ctx, rsc: &mut ClientRsc| {
+                            rsc.run_event::<Submit>(add_text, (), ctx.state);
+                        })
+                        .sized((40, 40)),
+                )
+                    .span(Dir::RIGHT)
+                    .pad(10),
+            )
+                .stack()
+                .size(StackSize::Child(1))
+                .layer_offset(1)
+                .align(Align::BOT),
+        )
+            .span(Dir::DOWN)
+            .add(rsc);
+
+        let main = WidgetPtr::new().add(rsc);
+
+        let vals = Rc::new(RefCell::new((0, Vec::new())));
+        let mut switch_button = |color, to: WeakWidget, label| {
+            let to = to.upgrade(rsc);
+            let vec = &mut vals.borrow_mut().1;
+            let i = vec.len();
+            if vec.is_empty() {
+                vec.push(None);
+                main(rsc).set(to);
+            } else {
+                vec.push(Some(to));
+            }
+            let vals = vals.clone();
+            let rect = rect(color)
+                .on(CursorSense::click(), move |ctx, rsc| {
+                    let (prev, vec) = &mut *vals.borrow_mut();
+                    if let Some(h) = vec[i].take() {
+                        vec[*prev] = main(rsc).replace(h);
+                        *prev = i;
+                    }
+                    ctx.widget(rsc).color = color.darker(0.3);
+                })
+                .on(
+                    CursorSense::HoverStart | CursorSense::unclick(),
+                    move |ctx, rsc| {
+                        ctx.widget(rsc).color = color.brighter(0.2);
+                    },
+                )
+                .on(CursorSense::HoverEnd, move |ctx, rsc| {
+                    ctx.widget(rsc).color = color;
+                });
+            (rect, wtext(label).size(30).text_align(Align::CENTER)).stack()
+        };
+
+        let tabs = (
+            switch_button(Color::RED, pad_test, "pad"),
+            switch_button(Color::GREEN, span_test, "span"),
+            switch_button(Color::BLUE, span_add_test, "image span"),
+            switch_button(Color::MAGENTA, text_test, "text layout"),
+            switch_button(
+                Color::YELLOW.mul_rgb(0.5),
+                text_edit_scroll,
+                "text edit scroll",
+            ),
+        )
+            .span(Dir::RIGHT);
+
+        let info = wtext("").add(rsc);
+        let info_sect = info.pad(10).align(Align::RIGHT);
+
+        ((tabs.height(40), main.pad(10)).span(Dir::DOWN), info_sect)
+            .stack()
+            .set_root(rsc, &mut ui_state);
+
+        Self { ui_state, info }
+    }
+
+    fn window_event(
+        &mut self,
+        _: WindowEvent,
+        rsc: &mut DefaultRsc<Self>,
+        render: &mut UiRenderState,
+    ) {
+        let new = format!(
+            "widgets: {}\nactive: {}\nviews: {}",
+            rsc.widgets().len(),
+            render.active_widgets(),
+            self.ui_state.renderer.ui.view_count(),
+        );
+        if new != *rsc.widgets()[self.info].content {
+            *rsc.widgets_mut()[self.info].content = new;
+        }
+    }
+}

iris/examples/task.rs

@@ -0,0 +1,34 @@
+use iris::prelude::*;
+use std::time::Duration;
+
+fn main() {
+    DefaultApp::<State>::run();
+}
+
+#[derive(DefaultUiState)]
+struct State {
+    ui_state: DefaultUiState,
+}
+
+impl DefaultAppState for State {
+    fn new(
+        mut ui_state: DefaultUiState,
+        rsc: &mut DefaultRsc<Self>,
+        _: Proxy<Self::Event>,
+    ) -> Self {
+        let rect = rect(Color::RED).add(rsc);
+        rect.task_on(CursorSense::click(), async move |mut ctx| {
+            tokio::time::sleep(Duration::from_secs(1)).await;
+            ctx.update(move |_, rsc| {
+                let rect = rect(rsc);
+                if rect.color == Color::RED {
+                    rect.color = Color::BLUE;
+                } else {
+                    rect.color = Color::RED;
+                }
+            });
+        })
+        .set_root(rsc, &mut ui_state);
+        Self { ui_state }
+    }
+}

iris/examples/view.rs

@@ -0,0 +1,53 @@
+use iris::prelude::*;
+
+fn main() {
+    DefaultApp::<State>::run();
+}
+
+#[derive(DefaultUiState)]
+struct State {
+    ui_state: DefaultUiState,
+}
+
+type Rsc = DefaultRsc<State>;
+
+#[derive(Clone, Copy, WidgetView)]
+struct Test {
+    #[root]
+    root: WeakWidget<Rect>,
+    cur: WeakState<bool>,
+}
+
+impl Test {
+    pub fn new(rsc: &mut Rsc) -> Self {
+        let root = rect(Color::RED).add(rsc);
+        let cur = rsc.create_state(root, false);
+        Self { root, cur }
+    }
+    pub fn toggle(&self, rsc: &mut Rsc) {
+        let cur = &mut rsc[self.cur];
+        *cur = !*cur;
+        if *cur {
+            rsc[self.root].color = Color::BLUE;
+        } else {
+            rsc[self.root].color = Color::RED;
+        }
+    }
+}
+
+impl DefaultAppState for State {
+    fn new(
+        mut ui_state: DefaultUiState,
+        rsc: &mut DefaultRsc<Self>,
+        _: Proxy<Self::Event>,
+    ) -> Self {
+        let test = Test::new(rsc);
+
+        test.on(CursorSense::click(), move |_, rsc| {
+            test.toggle(rsc);
+        })
+        .set_root(rsc, &mut ui_state);
+
+        Self { ui_state }
+    }
+}

iris/macro/Cargo.toml

@@ -0,0 +1,12 @@
+[package]
+name = "iris-macro"
+version.workspace = true
+edition.workspace = true
+
+[dependencies]
+proc-macro2 = "1.0.103"
+quote = "1.0.42"
+syn = { version = "2.0.111", features = ["full"] }
+
+[lib]
+proc-macro = true

iris/macro/src/lib.rs

@@ -0,0 +1,196 @@
+extern crate proc_macro;
+use proc_macro::TokenStream;
+use quote::quote;
+use syn::{
+    Attribute, Block, Error, GenericParam, Generics, Ident, ItemStruct, ItemTrait, Signature,
+    Token, Type, Visibility,
+    parse::{Parse, ParseStream, Result},
+    parse_macro_input, parse_quote,
+    spanned::Spanned,
+};
+
+struct Input {
+    attrs: Vec<Attribute>,
+    vis: Visibility,
+    name: Ident,
+    generics: Generics,
+    fns: Vec<InputFn>,
+}
+
+struct InputFn {
+    sig: Signature,
+    body: Block,
+}
+
+impl Parse for Input {
+    fn parse(input: ParseStream) -> Result<Self> {
+        let attrs = input.call(Attribute::parse_outer)?;
+        let vis = input.parse()?;
+        input.parse::<Token![trait]>()?;
+        let name = input.parse()?;
+        let generics = input.parse::<Generics>()?;
+        input.parse::<Token![;]>()?;
+        let mut fns = Vec::new();
+        while !input.is_empty() {
+            let sig = input.parse()?;
+            let body = input.parse()?;
+            fns.push(InputFn { sig, body })
+        }
+        if !input.is_empty() {
+            input.error("function expected");
+        }
+        Ok(Input {
+            attrs,
+            vis,
+            name,
+            generics,
+            fns,
+        })
+    }
+}
+
+#[proc_macro]
+pub fn widget_trait(input: TokenStream) -> TokenStream {
+    let Input {
+        attrs,
+        vis,
+        name,
+        mut generics,
+        fns,
+    } = parse_macro_input!(input as Input);
+
+    let sigs: Vec<_> = fns.iter().map(|f| f.sig.clone()).collect();
+    let impls: Vec<_> = fns
+        .iter()
+        .map(|InputFn { sig, body }| quote! { #sig #body })
+        .collect();
+
+    let Some(GenericParam::Type(state)) = generics.params.first() else {
+        return Error::new(name.span(), "expected state generic parameter")
+            .into_compile_error()
+            .into();
+    };
+
+    let state = &state.ident;
+
+    generics
+        .params
+        .push(parse_quote!(WL: WidgetLike<#state, Tag>));
+    generics.params.push(parse_quote!(Tag));
+
+    let mut trai: ItemTrait = parse_quote!(
+        #vis trait #name #generics {
+            #(#sigs;)*
+        }
+    );
+
+    trai.attrs = attrs;
+
+    quote! {
+        #trai
+
+        impl #generics #name<Rsc, WL, Tag> for WL {
+            #(#impls)*
+        }
+    }
+    .into()
+}
+
+#[proc_macro_derive(DefaultUiState, attributes(default_ui_state))]
+pub fn derive_default_ui_state(input: TokenStream) -> TokenStream {
+    let mut output = proc_macro2::TokenStream::new();
+
+    let state: ItemStruct = parse_macro_input!(input);
+
+    let mut found_attr = false;
+    let mut state_field = None;
+    for field in &state.fields {
+        if !found_attr
+            && let Type::Path(path) = &field.ty
+            && path.path.is_ident("DefaultUiState")
+        {
+            state_field = Some(field);
+        }
+        let Some(attr) = field
+            .attrs
+            .iter()
+            .find(|a| a.path().is_ident("default_ui_state"))
+        else {
+            continue;
+        };
+        if found_attr {
+            output.extend(
+                Error::new(
+                    attr.span(),
+                    "cannot have more than one default_ui_state attribute",
+                )
+                .into_compile_error(),
+            );
+            continue;
+        }
+        found_attr = true;
+        state_field = Some(field);
+    }
+    let Some(field) = state_field else {
+        output.extend(
+            Error::new(state.ident.span(), "no DefaultUiState field found").into_compile_error(),
+        );
+        return output.into();
+    };
+    let sname = &state.ident;
+    let fname = field.ident.as_ref().unwrap();
+    output.extend(quote! {
+        impl iris::default::HasDefaultUiState for #sname {
+            fn default_state(&self) -> &iris::default::DefaultUiState {
+                &self.#fname
+            }
+            fn default_state_mut(&mut self) -> &mut iris::default::DefaultUiState {
+                &mut self.#fname
+            }
+        }
+    });
+    output.into()
+}
+
+#[proc_macro_derive(WidgetView, attributes(root))]
+pub fn derive_widget_view(input: TokenStream) -> TokenStream {
+    let mut output = proc_macro2::TokenStream::new();
+
+    let state: ItemStruct = parse_macro_input!(input);
+
+    let mut found_attr = false;
+    let mut state_field = None;
+    for field in &state.fields {
+        let Some(attr) = field.attrs.iter().find(|a| a.path().is_ident("root")) else {
+            continue;
+        };
+        if found_attr {
+            output.extend(
+                Error::new(attr.span(), "cannot have more than one root widget")
+                    .into_compile_error(),
+            );
+            continue;
+        }
+        found_attr = true;
+        state_field = Some(field);
+    }
+    let Some(field) = state_field else {
+        output.extend(
+            Error::new(state.ident.span(), "no root widget field found (#[root])")
+                .into_compile_error(),
+        );
+        return output.into();
+    };
+    let sname = &state.ident;
+    let fname = field.ident.as_ref().unwrap();
+    let fty = &field.ty;
+    output.extend(quote! {
+        impl iris::core::WidgetView for #sname {
+            type Widget = <#fty as iris::core::HasWidget>::Widget;
+            fn root(&self) -> #fty {
+                self.#fname
+            }
+        }
+    });
+    output.into()
+}

iris/readme.md

@@ -0,0 +1,31 @@
+# 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:
+1. does what I want it to (text, images, video, animations)
+2. very easy to use ignoring ergonomic ref counting
+3. 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

iris/src/default/app.rs

@@ -0,0 +1,60 @@
+use winit::{
+    application::ApplicationHandler,
+    event::WindowEvent,
+    event_loop::{ActiveEventLoop, EventLoop, EventLoopProxy},
+    window::WindowId,
+};
+
+pub trait AppState {
+    type Event: 'static;
+    fn new(event_loop: &ActiveEventLoop, proxy: EventLoopProxy<Self::Event>) -> Self;
+    fn window_event(&mut self, event: WindowEvent, event_loop: &ActiveEventLoop);
+    fn event(&mut self, event: Self::Event, event_loop: &ActiveEventLoop);
+    fn exit(&mut self);
+
+    fn run()
+    where
+        Self: Sized,
+    {
+        App::<Self>::run();
+    }
+}
+
+pub struct App<State: AppState> {
+    state: Option<State>,
+    proxy: EventLoopProxy<State::Event>,
+}
+
+impl<State: AppState> App<State> {
+    pub fn run() {
+        let event_loop = EventLoop::with_user_event().build().unwrap();
+        let proxy = event_loop.create_proxy();
+        event_loop
+            .run_app(&mut App::<State> { state: None, proxy })
+            .unwrap();
+    }
+}
+
+impl<State: AppState> ApplicationHandler<State::Event> for App<State> {
+    fn resumed(&mut self, event_loop: &ActiveEventLoop) {
+        if self.state.is_none() {
+            let state = State::new(event_loop, self.proxy.clone());
+            self.state = Some(state);
+        }
+    }
+
+    fn window_event(&mut self, event_loop: &ActiveEventLoop, _id: WindowId, event: WindowEvent) {
+        let state = self.state.as_mut().unwrap();
+        state.window_event(event, event_loop);
+    }
+
+    fn user_event(&mut self, event_loop: &ActiveEventLoop, event: State::Event) {
+        let state = self.state.as_mut().unwrap();
+        state.event(event, event_loop);
+    }
+
+    fn exiting(&mut self, _: &ActiveEventLoop) {
+        let state = self.state.as_mut().unwrap();
+        state.exit();
+    }
+}

iris/src/default/attr.rs

@@ -0,0 +1,78 @@
+use crate::prelude::*;
+use std::time::{Duration, Instant};
+use winit::dpi::{LogicalPosition, LogicalSize};
+
+pub struct Selector;
+
+impl<Rsc: HasEvents, W: Widget + 'static> WidgetAttr<Rsc, W> for Selector
+where
+    Rsc::State: HasDefaultUiState,
+{
+    type Input = WeakWidget<TextEdit>;
+
+    fn run(rsc: &mut Rsc, container: WeakWidget<W>, id: Self::Input) {
+        rsc.register_event(container, CursorSense::click_or_drag(), move |ctx, rsc| {
+            let region = ctx.data.render.window_region(&id).unwrap();
+            let id_pos = region.top_left;
+            let container_pos = ctx.data.render.window_region(&container).unwrap().top_left;
+            let pos = ctx.data.pos + container_pos - id_pos;
+            let size = region.size();
+            select(
+                rsc,
+                ctx.data.render,
+                ctx.state,
+                id,
+                pos,
+                size,
+                ctx.data.sense.is_dragging(),
+            );
+        });
+    }
+}
+
+pub struct Selectable;
+
+impl<Rsc: HasEvents> WidgetAttr<Rsc, TextEdit> for Selectable
+where
+    Rsc::State: HasDefaultUiState,
+{
+    type Input = ();
+
+    fn run(rsc: &mut Rsc, id: WeakWidget<TextEdit>, _: Self::Input) {
+        rsc.register_event(id, CursorSense::click_or_drag(), move |ctx, rsc| {
+            select(
+                rsc,
+                ctx.data.render,
+                ctx.state,
+                id,
+                ctx.data.pos,
+                ctx.data.size,
+                ctx.data.sense.is_dragging(),
+            );
+        });
+    }
+}
+
+fn select(
+    rsc: &mut impl UiRsc,
+    render: &UiRenderState,
+    state: &mut impl HasDefaultUiState,
+    id: WeakWidget<TextEdit>,
+    pos: Vec2,
+    size: Vec2,
+    dragging: bool,
+) {
+    let state = state.default_state_mut();
+    let now = Instant::now();
+    let recent = (now - state.last_click) < Duration::from_millis(300);
+    state.last_click = now;
+    id.edit(rsc).select(pos, size, dragging, recent);
+    if let Some(region) = render.window_region(&id) {
+        state.window.set_ime_allowed(true);
+        state.window.set_ime_cursor_area(
+            LogicalPosition::<f32>::from(region.top_left.tuple()),
+            LogicalSize::<f32>::from(region.size().tuple()),
+        );
+    }
+    state.focus = Some(id);
+}

iris/src/default/event.rs

@@ -0,0 +1,9 @@
+use iris_core::Event;
+
+#[derive(Eq, PartialEq, Hash, Clone)]
+pub struct Submit;
+impl Event for Submit {}
+
+#[derive(Eq, PartialEq, Hash, Clone)]
+pub struct Edited;
+impl Event for Edited {}

iris/src/default/input.rs

@@ -0,0 +1,78 @@
+use crate::prelude::*;
+use winit::{
+    event::{MouseButton, MouseScrollDelta, WindowEvent},
+    keyboard::{Key, NamedKey},
+};
+
+#[derive(Default)]
+pub struct Input {
+    cursor: CursorState,
+    pub modifiers: Modifiers,
+}
+
+impl Input {
+    pub fn event(&mut self, event: &WindowEvent) -> bool {
+        match event {
+            WindowEvent::CursorMoved { position, .. } => {
+                self.cursor.pos = Vec2::new(position.x as f32, position.y as f32);
+                self.cursor.exists = true;
+            }
+            WindowEvent::MouseInput { state, button, .. } => {
+                let buttons = &mut self.cursor.buttons;
+                let pressed = state.is_pressed();
+                match button {
+                    MouseButton::Left => buttons.left.update(pressed),
+                    MouseButton::Right => buttons.right.update(pressed),
+                    MouseButton::Middle => buttons.middle.update(pressed),
+                    _ => (),
+                }
+            }
+            WindowEvent::MouseWheel { delta, .. } => {
+                let mut delta = match *delta {
+                    MouseScrollDelta::LineDelta(x, y) => Vec2::new(x, y),
+                    MouseScrollDelta::PixelDelta(pos) => Vec2::new(pos.x as f32, pos.y as f32),
+                };
+                if delta.x == 0.0 && self.modifiers.shift {
+                    delta.x = delta.y;
+                    delta.y = 0.0;
+                }
+                self.cursor.scroll_delta = delta;
+            }
+            WindowEvent::CursorLeft { .. } => {
+                self.cursor.exists = false;
+                self.modifiers.clear();
+            }
+            WindowEvent::KeyboardInput { event, .. } => {
+                if let Key::Named(named) = event.logical_key {
+                    let pressed = event.state.is_pressed();
+                    match named {
+                        NamedKey::Control => {
+                            self.modifiers.control = pressed;
+                        }
+                        NamedKey::Shift => {
+                            self.modifiers.shift = pressed;
+                        }
+                        _ => (),
+                    }
+                }
+            }
+            _ => return false,
+        }
+        true
+    }
+
+    pub fn end_frame(&mut self) {
+        self.cursor.end_frame();
+    }
+}
+
+impl DefaultUiState {
+    pub fn window_size(&self) -> Vec2 {
+        let size = self.renderer.window().inner_size();
+        (size.width, size.height).into()
+    }
+
+    pub fn cursor_state(&self) -> &CursorState {
+        &self.input.cursor
+    }
+}

iris/src/default/mod.rs

@@ -0,0 +1,354 @@
+use crate::prelude::*;
+use arboard::Clipboard;
+use std::{
+    marker::{PhantomData, Sized},
+    sync::Arc,
+    time::Instant,
+};
+use winit::{
+    event::{Ime, WindowEvent},
+    event_loop::{ActiveEventLoop, EventLoopProxy},
+    window::{Window, WindowAttributes},
+};
+
+mod app;
+mod attr;
+mod event;
+mod input;
+mod render;
+mod sense;
+mod state;
+mod task;
+
+pub use app::*;
+pub use attr::*;
+pub use event::*;
+pub use input::*;
+pub use render::*;
+pub use sense::*;
+pub use state::*;
+pub use task::*;
+
+pub type Proxy<Event> = EventLoopProxy<Event>;
+
+pub struct DefaultUiState {
+    pub root: Option<StrongWidget>,
+    pub renderer: UiRenderer,
+    pub input: Input,
+    pub focus: Option<WeakWidget<TextEdit>>,
+    pub clipboard: Clipboard,
+    pub window: Arc<Window>,
+    pub ime: usize,
+    pub last_click: Instant,
+}
+
+impl HasRoot for DefaultUiState {
+    fn set_root(&mut self, root: StrongWidget) {
+        self.root = Some(root);
+    }
+}
+
+impl DefaultUiState {
+    pub fn new(window: impl Into<Arc<Window>>) -> Self {
+        let window = window.into();
+        Self {
+            root: None,
+            renderer: UiRenderer::new(window.clone()),
+            window,
+            input: Input::default(),
+            clipboard: Clipboard::new().unwrap(),
+            ime: 0,
+            last_click: Instant::now(),
+            focus: None,
+        }
+    }
+}
+
+pub trait HasDefaultUiState: Sized + 'static {
+    fn default_state(&self) -> &DefaultUiState;
+    fn default_state_mut(&mut self) -> &mut DefaultUiState;
+}
+
+pub trait DefaultAppState: HasDefaultUiState {
+    type Event = ();
+    fn new(ui_state: DefaultUiState, rsc: &mut DefaultRsc<Self>, proxy: Proxy<Self::Event>)
+    -> Self;
+    #[allow(unused_variables)]
+    fn event(
+        &mut self,
+        event: Self::Event,
+        rsc: &mut DefaultRsc<Self>,
+        render: &mut UiRenderState,
+    ) {
+    }
+    #[allow(unused_variables)]
+    fn exit(&mut self, rsc: &mut DefaultRsc<Self>, render: &mut UiRenderState) {}
+    #[allow(unused_variables)]
+    fn window_event(
+        &mut self,
+        event: WindowEvent,
+        rsc: &mut DefaultRsc<Self>,
+        render: &mut UiRenderState,
+    ) {
+    }
+    fn window_attributes() -> WindowAttributes {
+        Default::default()
+    }
+}
+
+pub struct DefaultRsc<State: 'static> {
+    pub ui: UiData,
+    pub events: EventManager<Self>,
+    pub tasks: Tasks<Self>,
+    pub state: WidgetState,
+    _state: PhantomData<State>,
+}
+
+impl<State> DefaultRsc<State> {
+    fn init(window: Arc<Window>) -> (Self, TaskMsgReceiver<Self>) {
+        let (tasks, recv) = Tasks::init(window);
+        (
+            Self {
+                ui: Default::default(),
+                events: Default::default(),
+                tasks,
+                state: Default::default(),
+                _state: Default::default(),
+            },
+            recv,
+        )
+    }
+
+    pub fn create_state<T: 'static>(&mut self, id: impl IdLike, data: T) -> WeakState<T> {
+        self.state.add(id.id(), data)
+    }
+}
+
+impl<State> UiRsc for DefaultRsc<State> {
+    fn ui(&self) -> &UiData {
+        &self.ui
+    }
+
+    fn ui_mut(&mut self) -> &mut UiData {
+        &mut self.ui
+    }
+
+    fn on_draw(&mut self, active: &ActiveData) {
+        self.events.draw(active);
+    }
+
+    fn on_undraw(&mut self, active: &ActiveData) {
+        self.events.undraw(active);
+    }
+
+    fn on_remove(&mut self, id: WidgetId) {
+        self.events.remove(id);
+        self.state.remove(id);
+    }
+}
+
+impl<State: 'static> HasState for DefaultRsc<State> {
+    type State = State;
+}
+
+impl<State: 'static> HasEvents for DefaultRsc<State> {
+    fn events(&self) -> &EventManager<Self> {
+        &self.events
+    }
+
+    fn events_mut(&mut self) -> &mut EventManager<Self> {
+        &mut self.events
+    }
+}
+
+impl<State: 'static> HasTasks for DefaultRsc<State> {
+    fn tasks_mut(&mut self) -> &mut Tasks<Self> {
+        &mut self.tasks
+    }
+}
+
+impl<State: 'static> HasWidgetState for DefaultRsc<State> {
+    fn widget_state(&self) -> &WidgetState {
+        &self.state
+    }
+
+    fn widget_state_mut(&mut self) -> &mut WidgetState {
+        &mut self.state
+    }
+}
+
+pub struct DefaultApp<State: DefaultAppState> {
+    rsc: DefaultRsc<State>,
+    render: UiRenderState,
+    state: State,
+    task_recv: TaskMsgReceiver<DefaultRsc<State>>,
+}
+
+impl<State: DefaultAppState> AppState for DefaultApp<State> {
+    type Event = State::Event;
+
+    fn new(event_loop: &ActiveEventLoop, proxy: EventLoopProxy<Self::Event>) -> Self {
+        let window = event_loop
+            .create_window(State::window_attributes())
+            .unwrap();
+        let default_state = DefaultUiState::new(window);
+        let (mut rsc, task_recv) = DefaultRsc::init(default_state.window.clone());
+        let state = State::new(default_state, &mut rsc, proxy);
+        let render = UiRenderState::new();
+        Self {
+            rsc,
+            state,
+            render,
+            task_recv,
+        }
+    }
+
+    fn event(&mut self, event: Self::Event, _: &ActiveEventLoop) {
+        self.state.event(event, &mut self.rsc, &mut self.render);
+    }
+
+    fn window_event(&mut self, event: WindowEvent, event_loop: &ActiveEventLoop) {
+        let Self {
+            rsc,
+            render,
+            state,
+            task_recv,
+        } = self;
+
+        for update in task_recv.try_iter() {
+            update(state, rsc);
+        }
+
+        let ui_state = state.default_state_mut();
+        let input_changed = ui_state.input.event(&event);
+        let cursor_state = ui_state.cursor_state().clone();
+        let old = ui_state.focus;
+        if cursor_state.buttons.left.is_start() {
+            ui_state.focus = None;
+        }
+        if input_changed {
+            let window_size = ui_state.window_size();
+            render.run_sensors(rsc, state, cursor_state, window_size);
+        }
+        let ui_state = state.default_state_mut();
+        if old != ui_state.focus
+            && let Some(old) = old
+        {
+            old.edit(rsc).deselect();
+        }
+        match &event {
+            WindowEvent::CloseRequested => event_loop.exit(),
+            WindowEvent::RedrawRequested => {
+                render.update(&ui_state.root, rsc);
+                ui_state.renderer.update(&mut rsc.ui, render);
+                ui_state.renderer.draw();
+            }
+            WindowEvent::Resized(size) => {
+                render.resize((size.width, size.height));
+                ui_state.renderer.resize(size)
+            }
+            WindowEvent::KeyboardInput { event, .. } => {
+                if let Some(sel) = ui_state.focus
+                    && event.state.is_pressed()
+                {
+                    let mut text = sel.edit(rsc);
+                    match text.apply_event(event, &ui_state.input.modifiers) {
+                        TextInputResult::Unfocus => {
+                            ui_state.focus = None;
+                            ui_state.window.set_ime_allowed(false);
+                        }
+                        TextInputResult::Submit => {
+                            rsc.run_event::<Submit>(sel, (), state);
+                        }
+                        TextInputResult::Paste => {
+                            if let Ok(t) = ui_state.clipboard.get_text() {
+                                text.insert(&t);
+                            }
+                            rsc.run_event::<Edited>(sel, (), state);
+                        }
+                        TextInputResult::Copy(text) => {
+                            if let Err(err) = ui_state.clipboard.set_text(text) {
+                                eprintln!("failed to copy text to clipboard: {err}")
+                            }
+                        }
+                        TextInputResult::Used => {
+                            rsc.run_event::<Edited>(sel, (), state);
+                        }
+                        TextInputResult::Unused => {}
+                    }
+                }
+            }
+            WindowEvent::Ime(ime) => {
+                if let Some(sel) = ui_state.focus {
+                    let mut text = sel.edit(rsc);
+                    match ime {
+                        Ime::Enabled | Ime::Disabled => (),
+                        Ime::Preedit(content, _pos) => {
+                            // TODO: highlight once that's real
+                            text.replace(ui_state.ime, content);
+                            ui_state.ime = content.chars().count();
+                        }
+                        Ime::Commit(content) => {
+                            text.insert(content);
+                        }
+                    }
+                }
+            }
+            _ => (),
+        }
+        state.window_event(event, rsc, render);
+        let ui_state = self.state.default_state_mut();
+        if render.needs_redraw(&ui_state.root, rsc.widgets()) {
+            ui_state.renderer.window().request_redraw();
+        }
+        ui_state.input.end_frame();
+    }
+
+    fn exit(&mut self) {
+        self.state.exit(&mut self.rsc, &mut self.render);
+    }
+}
+
+pub trait RscIdx<Rsc> {
+    type Output;
+    fn get(self, rsc: &Rsc) -> &Self::Output;
+    fn get_mut(self, rsc: &mut Rsc) -> &mut Self::Output;
+}
+
+impl<State: 'static, I: RscIdx<DefaultRsc<State>>> std::ops::Index<I> for DefaultRsc<State> {
+    type Output = I::Output;
+
+    fn index(&self, index: I) -> &Self::Output {
+        index.get(self)
+    }
+}
+
+impl<State: 'static, I: RscIdx<DefaultRsc<State>>> std::ops::IndexMut<I> for DefaultRsc<State> {
+    fn index_mut(&mut self, index: I) -> &mut Self::Output {
+        index.get_mut(self)
+    }
+}
+
+impl<W: Widget, Rsc: UiRsc> RscIdx<Rsc> for WeakWidget<W> {
+    type Output = W;
+
+    fn get(self, rsc: &Rsc) -> &Self::Output {
+        &rsc.ui().widgets[self]
+    }
+
+    fn get_mut(self, rsc: &mut Rsc) -> &mut Self::Output {
+        &mut rsc.ui_mut().widgets[self]
+    }
+}
+
+impl<T: 'static, Rsc: HasWidgetState> RscIdx<Rsc> for WeakState<T> {
+    type Output = T;
+
+    fn get(self, rsc: &Rsc) -> &Self::Output {
+        rsc.widget_state().get(self)
+    }
+
+    fn get_mut(self, rsc: &mut Rsc) -> &mut Self::Output {
+        rsc.widget_state_mut().get_mut(self)
+    }
+}

iris/src/default/render.rs

@@ -0,0 +1,144 @@
+use iris_core::{UiData, UiLimits, UiRenderNode, UiRenderState};
+use pollster::FutureExt;
+use std::sync::Arc;
+use wgpu::*;
+use winit::{dpi::PhysicalSize, window::Window};
+
+pub const CLEAR_COLOR: Color = Color::BLACK;
+
+pub struct UiRenderer {
+    window: Arc<Window>,
+    surface: Surface<'static>,
+    device: Device,
+    queue: Queue,
+    config: SurfaceConfiguration,
+    encoder: CommandEncoder,
+    pub ui: UiRenderNode,
+}
+
+impl UiRenderer {
+    pub fn update(&mut self, ui: &mut UiData, render: &mut UiRenderState) {
+        self.ui.update(&self.device, &self.queue, ui, render);
+    }
+
+    pub fn draw(&mut self) {
+        let output = self.surface.get_current_texture().unwrap();
+        let view = output
+            .texture
+            .create_view(&TextureViewDescriptor::default());
+
+        let mut encoder = std::mem::replace(&mut self.encoder, Self::create_encoder(&self.device));
+        {
+            let render_pass = &mut encoder.begin_render_pass(&RenderPassDescriptor {
+                color_attachments: &[Some(RenderPassColorAttachment {
+                    view: &view,
+                    resolve_target: None,
+                    ops: Operations {
+                        load: LoadOp::Clear(CLEAR_COLOR),
+                        store: StoreOp::Store,
+                    },
+                    depth_slice: None,
+                })],
+                ..Default::default()
+            });
+            self.ui.draw(render_pass);
+        }
+
+        self.queue.submit(std::iter::once(encoder.finish()));
+        output.present();
+    }
+
+    pub fn resize(&mut self, size: &PhysicalSize<u32>) {
+        self.config.width = size.width;
+        self.config.height = size.height;
+        self.surface.configure(&self.device, &self.config);
+        self.ui.resize(size, &self.queue);
+    }
+
+    fn create_encoder(device: &Device) -> CommandEncoder {
+        device.create_command_encoder(&CommandEncoderDescriptor {
+            label: Some("Render Encoder"),
+        })
+    }
+
+    pub fn new(window: Arc<Window>) -> Self {
+        let size = window.inner_size();
+
+        let instance = Instance::new(&InstanceDescriptor {
+            backends: Backends::PRIMARY,
+            ..Default::default()
+        });
+
+        let surface = instance
+            .create_surface(window.clone())
+            .expect("Could not create window surface!");
+
+        let adapter = instance
+            .request_adapter(&RequestAdapterOptions {
+                power_preference: PowerPreference::default(),
+                compatible_surface: Some(&surface),
+                force_fallback_adapter: false,
+            })
+            .block_on()
+            .expect("Could not get adapter!");
+
+        let ui_limits = UiLimits::default();
+
+        let (device, queue) = adapter
+            .request_device(&DeviceDescriptor {
+                required_features: Features::TEXTURE_BINDING_ARRAY
+                    | Features::PARTIALLY_BOUND_BINDING_ARRAY
+                    | Features::SAMPLED_TEXTURE_AND_STORAGE_BUFFER_ARRAY_NON_UNIFORM_INDEXING,
+                required_limits: Limits {
+                    max_binding_array_elements_per_shader_stage: ui_limits
+                        .max_binding_array_elements_per_shader_stage(),
+                    max_binding_array_sampler_elements_per_shader_stage: ui_limits
+                        .max_binding_array_sampler_elements_per_shader_stage(),
+                    max_buffer_size: 1 << 30,
+                    ..Default::default()
+                },
+                ..Default::default()
+            })
+            .block_on()
+            .expect("Could not get device!");
+
+        let surface_caps = surface.get_capabilities(&adapter);
+        let surface_format = surface_caps
+            .formats
+            .iter()
+            .copied()
+            .find(|f| f.is_srgb())
+            .unwrap_or(surface_caps.formats[0]);
+
+        let config = SurfaceConfiguration {
+            usage: TextureUsages::RENDER_ATTACHMENT,
+            format: surface_format,
+            width: size.width,
+            height: size.height,
+            present_mode: PresentMode::AutoNoVsync,
+            alpha_mode: surface_caps.alpha_modes[0],
+            desired_maximum_frame_latency: 2,
+            view_formats: vec![],
+        };
+
+        surface.configure(&device, &config);
+
+        let encoder = Self::create_encoder(&device);
+
+        let ui = UiRenderNode::new(&device, &queue, &config, ui_limits);
+
+        Self {
+            surface,
+            device,
+            queue,
+            config,
+            encoder,
+            ui,
+            window,
+        }
+    }
+
+    pub fn window(&self) -> &Window {
+        self.window.as_ref()
+    }
+}

iris/src/default/sense.rs

@@ -0,0 +1,308 @@
+use crate::prelude::*;
+use std::{
+    ops::{BitOr, Deref, DerefMut},
+    rc::Rc,
+};
+
+#[derive(Clone, Copy, PartialEq)]
+pub enum CursorButton {
+    Left,
+    Right,
+    Middle,
+}
+
+#[derive(Clone, Copy, PartialEq)]
+pub enum CursorSense {
+    PressStart(CursorButton),
+    Pressing(CursorButton),
+    PressEnd(CursorButton),
+    HoverStart,
+    Hovering,
+    HoverEnd,
+    Scroll,
+}
+
+#[derive(Clone)]
+pub struct CursorSenses(Vec<CursorSense>);
+
+impl Event for CursorSenses {
+    type Data<'a> = CursorData<'a>;
+    type State = SensorState;
+    fn should_run<'a>(&self, data: &Self::Data<'a>) -> Option<Self::Data<'a>> {
+        if let Some(sense) = should_run(self, &data.cursor, data.hover) {
+            let mut data = data.clone();
+            data.sense = sense;
+            Some(data)
+        } else {
+            None
+        }
+    }
+}
+
+impl CursorSense {
+    pub fn click() -> Self {
+        Self::PressStart(CursorButton::Left)
+    }
+    pub fn click_or_drag() -> CursorSenses {
+        Self::click() | Self::Pressing(CursorButton::Left)
+    }
+    pub fn unclick() -> Self {
+        Self::PressEnd(CursorButton::Left)
+    }
+    pub fn is_dragging(&self) -> bool {
+        matches!(self, CursorSense::Pressing(CursorButton::Left))
+    }
+}
+
+#[derive(Default, Clone)]
+pub struct CursorState {
+    pub pos: Vec2,
+    pub exists: bool,
+    pub buttons: CursorButtons,
+    pub scroll_delta: Vec2,
+}
+
+#[derive(Default, Clone)]
+pub struct CursorButtons {
+    pub left: ActivationState,
+    pub middle: ActivationState,
+    pub right: ActivationState,
+}
+
+impl CursorButtons {
+    pub fn select(&self, button: &CursorButton) -> &ActivationState {
+        match button {
+            CursorButton::Left => &self.left,
+            CursorButton::Right => &self.right,
+            CursorButton::Middle => &self.middle,
+        }
+    }
+
+    pub fn end_frame(&mut self) {
+        self.left.end_frame();
+        self.middle.end_frame();
+        self.right.end_frame();
+    }
+
+    pub fn iter(&self) -> impl Iterator<Item = (CursorButton, &ActivationState)> {
+        [
+            CursorButton::Left,
+            CursorButton::Middle,
+            CursorButton::Right,
+        ]
+        .into_iter()
+        .map(|b| (b, self.select(&b)))
+    }
+}
+
+impl CursorState {
+    pub fn end_frame(&mut self) {
+        self.buttons.end_frame();
+        self.scroll_delta = Vec2::ZERO;
+    }
+}
+
+#[derive(Debug, Clone, Copy, Default, PartialEq)]
+pub enum ActivationState {
+    Start,
+    On,
+    End,
+    #[default]
+    Off,
+}
+
+/// this and other similar stuff has a generic
+/// because I kind of want to make CursorModule generic
+/// or basically have some way to have custom senses
+/// that depend on active widget positions
+/// but I'm not sure how or if worth it
+pub struct Sensor<Ctx: HasEvents, Data> {
+    pub senses: CursorSenses,
+    pub f: Rc<dyn EventFn<Ctx, Data>>,
+}
+
+pub type SenseShape = UiRegion;
+
+#[derive(Default, Debug)]
+pub struct SensorState {
+    pub hover: ActivationState,
+}
+
+#[derive(Clone)]
+pub struct CursorData<'a> {
+    /// where this widget was hit
+    pub pos: Vec2,
+    pub size: Vec2,
+    pub scroll_delta: Vec2,
+    pub hover: ActivationState,
+    pub cursor: CursorState,
+    /// the first sense that triggered this
+    pub sense: CursorSense,
+    pub render: &'a UiRenderState,
+}
+
+pub trait SensorUi {
+    fn run_sensors<Rsc: HasEvents>(
+        &self,
+        rsc: &mut Rsc,
+        state: &mut Rsc::State,
+        cursor: CursorState,
+        window_size: Vec2,
+    );
+}
+
+impl SensorUi for UiRenderState {
+    fn run_sensors<Rsc: HasEvents>(
+        &self,
+        rsc: &mut Rsc,
+        state: &mut Rsc::State,
+        cursor: CursorState,
+        window_size: Vec2,
+    ) {
+        // in order to remove this take, need to store active list in UiRenderState somehow
+        // this would probably be done through a generic parameter that adds yet another rsc /
+        // state like thing, but local to render state, and is passed to UiRsc events so you can
+        // update it there?
+        let mut active = std::mem::take(&mut rsc.events_mut().get_type::<CursorSense>().active);
+        for layer in self.layers.indices().rev() {
+            let mut sensed = false;
+            for (id, sensor) in active.get_mut(&layer).into_flat_iter() {
+                let shape = self.active.get(id).unwrap().region;
+                let region = shape.to_px(window_size);
+                let in_shape = cursor.exists && region.contains(cursor.pos);
+                sensor.hover.update(in_shape);
+                if sensor.hover == ActivationState::Off {
+                    continue;
+                }
+                sensed = true;
+
+                let cursor = cursor.clone();
+
+                let data = CursorData {
+                    pos: cursor.pos - region.top_left,
+                    size: region.bot_right - region.top_left,
+                    scroll_delta: cursor.scroll_delta,
+                    hover: sensor.hover,
+                    cursor,
+                    // this does not have any meaning;
+                    // might wanna set up Event to have a prepare stage
+                    sense: CursorSense::Hovering,
+                    render: self,
+                };
+                rsc.run_event::<CursorSense>(*id, data, state);
+            }
+            if sensed {
+                break;
+            }
+        }
+        rsc.events_mut().get_type::<CursorSense>().active = active;
+    }
+}
+
+pub fn should_run(
+    senses: &CursorSenses,
+    cursor: &CursorState,
+    hover: ActivationState,
+) -> Option<CursorSense> {
+    for sense in senses.iter() {
+        if match sense {
+            CursorSense::PressStart(button) => cursor.buttons.select(button).is_start(),
+            CursorSense::Pressing(button) => cursor.buttons.select(button).is_on(),
+            CursorSense::PressEnd(button) => cursor.buttons.select(button).is_end(),
+            CursorSense::HoverStart => hover.is_start(),
+            CursorSense::Hovering => hover.is_on(),
+            CursorSense::HoverEnd => hover.is_end(),
+            CursorSense::Scroll => cursor.scroll_delta != Vec2::ZERO,
+        } {
+            return Some(*sense);
+        }
+    }
+    None
+}
+
+impl ActivationState {
+    pub fn is_start(&self) -> bool {
+        *self == Self::Start
+    }
+    pub fn is_on(&self) -> bool {
+        *self == Self::Start || *self == Self::On
+    }
+    pub fn is_end(&self) -> bool {
+        *self == Self::End
+    }
+    pub fn is_off(&self) -> bool {
+        *self == Self::End || *self == Self::Off
+    }
+    pub fn update(&mut self, on: bool) {
+        *self = match *self {
+            Self::Start => match on {
+                true => Self::On,
+                false => Self::End,
+            },
+            Self::On => match on {
+                true => Self::On,
+                false => Self::End,
+            },
+            Self::End => match on {
+                true => Self::Start,
+                false => Self::Off,
+            },
+            Self::Off => match on {
+                true => Self::Start,
+                false => Self::Off,
+            },
+        }
+    }
+
+    pub fn end_frame(&mut self) {
+        match self {
+            Self::Start => *self = Self::On,
+            Self::End => *self = Self::Off,
+            _ => (),
+        }
+    }
+}
+
+impl EventLike for CursorSense {
+    type Event = CursorSenses;
+    fn into_event(self) -> Self::Event {
+        self.into()
+    }
+}
+
+impl Deref for CursorSenses {
+    type Target = Vec<CursorSense>;
+
+    fn deref(&self) -> &Self::Target {
+        &self.0
+    }
+}
+
+impl DerefMut for CursorSenses {
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        &mut self.0
+    }
+}
+
+impl From<CursorSense> for CursorSenses {
+    fn from(val: CursorSense) -> Self {
+        CursorSenses(vec![val])
+    }
+}
+
+impl BitOr for CursorSense {
+    type Output = CursorSenses;
+
+    fn bitor(self, rhs: Self) -> Self::Output {
+        CursorSenses(vec![self, rhs])
+    }
+}
+
+impl BitOr<CursorSense> for CursorSenses {
+    type Output = Self;
+
+    fn bitor(mut self, rhs: CursorSense) -> Self::Output {
+        self.0.push(rhs);
+        self
+    }
+}

iris/src/default/state.rs

@@ -0,0 +1,75 @@
+use iris_core::{
+    WidgetId,
+    util::{HashMap, HashSet},
+};
+use std::{
+    any::{Any, TypeId},
+    marker::PhantomData,
+};
+
+#[derive(Clone, Copy, PartialEq, Eq, Hash)]
+struct Key {
+    id: WidgetId,
+    ty: TypeId,
+    i: usize,
+}
+
+#[derive(Default)]
+pub struct WidgetState {
+    widgets: HashMap<WidgetId, HashSet<(TypeId, usize)>>,
+    counts: HashMap<(WidgetId, TypeId), usize>,
+    map: HashMap<Key, Box<dyn Any>>,
+}
+
+impl WidgetState {
+    pub fn new() -> Self {
+        Self::default()
+    }
+    pub fn add<T: 'static>(&mut self, id: WidgetId, data: T) -> WeakState<T> {
+        let ty = TypeId::of::<T>();
+        let count = self.counts.entry((id, ty)).or_default();
+        let i = *count;
+        let key = Key { ty, i, id };
+        self.map.insert(key, Box::new(data));
+        self.widgets.entry(id).or_default().insert((ty, i));
+        *count += 1;
+        WeakState {
+            key,
+            _pd: PhantomData,
+        }
+    }
+    pub fn remove(&mut self, id: WidgetId) {
+        for &(ty, i) in self.widgets.get(&id).into_iter().flatten() {
+            self.map.remove(&Key { id, ty, i });
+        }
+    }
+    pub fn get<T: 'static>(&self, state: WeakState<T>) -> &T {
+        self.map.get(&state.key).unwrap().downcast_ref().unwrap()
+    }
+    pub fn get_mut<T: 'static>(&mut self, state: WeakState<T>) -> &mut T {
+        self.map
+            .get_mut(&state.key)
+            .unwrap()
+            .downcast_mut()
+            .unwrap()
+    }
+}
+
+#[derive(Clone, Copy)]
+pub struct WeakState<T> {
+    key: Key,
+    _pd: PhantomData<T>,
+}
+
+pub trait HasWidgetState {
+    fn widget_state(&self) -> &WidgetState;
+    fn widget_state_mut(&mut self) -> &mut WidgetState;
+}
+
+impl<'a, T: 'static> FnOnce<(&'a mut WidgetState,)> for WeakState<T> {
+    type Output = &'a mut T;
+
+    extern "rust-call" fn call_once(self, (state,): (&'a mut WidgetState,)) -> Self::Output {
+        state.get_mut(self)
+    }
+}

iris/src/default/task.rs

@@ -0,0 +1,82 @@
+use iris_core::HasState;
+use std::{
+    pin::Pin,
+    sync::{
+        Arc,
+        mpsc::{Receiver as SyncReceiver, Sender as SyncSender, channel as sync_channel},
+    },
+};
+use tokio::{
+    runtime::Runtime,
+    sync::mpsc::{
+        UnboundedReceiver as AsyncReceiver, UnboundedSender as AsyncSender,
+        unbounded_channel as async_channel,
+    },
+};
+use winit::window::Window;
+
+pub type TaskMsgSender<Rsc> = SyncSender<Box<dyn TaskUpdate<Rsc>>>;
+pub type TaskMsgReceiver<Rsc> = SyncReceiver<Box<dyn TaskUpdate<Rsc>>>;
+
+pub trait TaskUpdate<Rsc: HasState>: FnOnce(&mut Rsc::State, &mut Rsc) + Send {}
+impl<F: FnOnce(&mut Rsc::State, &mut Rsc) + Send, Rsc: HasState> TaskUpdate<Rsc> for F {}
+
+pub struct Tasks<Rsc: HasState> {
+    start: AsyncSender<BoxTask>,
+    window: Arc<Window>,
+    msg_send: SyncSender<Box<dyn TaskUpdate<Rsc>>>,
+}
+
+pub struct TaskCtx<Rsc: HasState> {
+    send: TaskMsgSender<Rsc>,
+}
+
+impl<Rsc: HasState> TaskCtx<Rsc> {
+    pub fn update(&mut self, f: impl TaskUpdate<Rsc> + 'static) {
+        let _ = self.send.send(Box::new(f));
+    }
+}
+impl<Rsc: HasState + 'static> TaskCtx<Rsc> {
+    fn new(send: TaskMsgSender<Rsc>) -> Self {
+        Self { send }
+    }
+}
+
+type BoxTask = Pin<Box<dyn Future<Output = ()> + Send>>;
+
+impl<Rsc: HasState> Tasks<Rsc> {
+    pub fn init(window: Arc<Window>) -> (Self, TaskMsgReceiver<Rsc>) {
+        let (start, start_recv) = async_channel();
+        let (msgs, msgs_recv) = sync_channel();
+        std::thread::spawn(|| {
+            let rt = Runtime::new().unwrap();
+            rt.block_on(listen(start_recv))
+        });
+        (
+            Self {
+                start,
+                msg_send: msgs,
+                window,
+            },
+            msgs_recv,
+        )
+    }
+
+    pub fn spawn<F: AsyncFnOnce(TaskCtx<Rsc>) + 'static + std::marker::Send>(&mut self, task: F)
+    where
+        F::CallOnceFuture: Send,
+    {
+        let send = self.msg_send.clone();
+        let window = self.window.clone();
+        let _ = self.start.send(Box::pin(async move {
+            task(TaskCtx::new(send)).await;
+            window.request_redraw();
+        }));
+    }
+}
+
+async fn listen(mut recv: AsyncReceiver<BoxTask>) {
+    while let Some(task) = recv.recv().await {
+        tokio::spawn(task);
+    }
+}

iris/src/event.rs

@@ -0,0 +1,87 @@
+use iris_core::*;
+use iris_macro::*;
+use std::sync::Arc;
+
+use crate::default::{TaskCtx, TaskUpdate, Tasks};
+
+pub trait Eventable<Rsc: HasEvents, Tag>: WidgetLike<Rsc, Tag> {
+    fn on<E: EventLike>(
+        self,
+        event: E,
+        f: impl for<'a> WidgetEventFn<Rsc, <E::Event as Event>::Data<'a>, Self::Widget>,
+    ) -> impl WidgetIdFn<Rsc, Self::Widget> {
+        move |rsc| {
+            let id = self.add(rsc);
+            rsc.register_event(id, event.into_event(), move |ctx, rsc| {
+                f(
+                    EventIdCtx {
+                        widget: id,
+                        state: ctx.state,
+                        data: ctx.data,
+                    },
+                    rsc,
+                );
+            });
+            id
+        }
+    }
+}
+impl<WL: WidgetLike<Rsc, Tag>, Rsc: HasEvents, Tag> Eventable<Rsc, Tag> for WL {}
+
+widget_trait! {
+    pub trait TaskEventable<Rsc: HasEvents + HasTasks>;
+    fn task_on<'a, E: EventLike, F: AsyncWidgetEventFn<Rsc, WL::Widget>>(
+        self,
+        event: E,
+        f: F,
+    ) -> impl WidgetIdFn<Rsc, WL::Widget>
+        where <E::Event as Event>::Data<'a>: Send,
+        for<'b> F::CallRefFuture<'b>: Send,
+    {
+        let f = Arc::new(f);
+        move |rsc| {
+            let id = self.add(rsc);
+            rsc.register_event(id, event.into_event(), move |_, rsc| {
+                let f = f.clone();
+                rsc.tasks_mut().spawn(async move |task| {
+                    f(AsyncEventIdCtx {
+                        widget: id,
+                        task,
+                    }).await;
+                });
+            });
+            id
+        }
+    }
+}
+
+pub trait HasTasks: Sized + HasState + HasEvents {
+    fn tasks_mut(&mut self) -> &mut Tasks<Self>;
+
+    fn spawn_task<F: AsyncFnOnce(TaskCtx<Self>) + 'static + std::marker::Send>(&mut self, task: F)
+    where
+        F::CallOnceFuture: Send,
+    {
+        self.tasks_mut().spawn(task);
+    }
+}
+
+pub trait AsyncWidgetEventFn<Rsc: HasEvents, W: ?Sized>:
+    AsyncFn(AsyncEventIdCtx<Rsc, W>) + Send + Sync + 'static
+{
+}
+impl<Rsc: HasEvents, F: AsyncFn(AsyncEventIdCtx<Rsc, W>) + Send + Sync + 'static, W: ?Sized>
+    AsyncWidgetEventFn<Rsc, W> for F
+{
+}
+
+pub struct AsyncEventIdCtx<Rsc: HasEvents, W: ?Sized> {
+    pub widget: WeakWidget<W>,
+    task: TaskCtx<Rsc>,
+}
+
+impl<Rsc: HasEvents, W: ?Sized> AsyncEventIdCtx<Rsc, W> {
+    pub fn update(&mut self, f: impl TaskUpdate<Rsc> + 'static) {
+        self.task.update(f);
+    }
+}

iris/src/lib.rs

@@ -0,0 +1,26 @@
+#![feature(unboxed_closures)]
+#![feature(fn_traits)]
+#![feature(gen_blocks)]
+#![feature(associated_type_defaults)]
+#![feature(unsize)]
+#![feature(option_into_flat_iter)]
+#![feature(async_fn_traits)]
+
+pub mod default;
+pub mod event;
+pub mod widget;
+
+pub use iris_core as core;
+pub use iris_macro as macros;
+
+pub mod prelude {
+    use super::*;
+    pub use default::*;
+    pub use event::*;
+    pub use iris_core::*;
+    pub use iris_macro::*;
+    pub use widget::*;
+
+    pub use iris_core::util::Vec2;
+    pub use len_fns::*;
+}

iris/src/widget/image.rs

@@ -0,0 +1,55 @@
+use crate::prelude::*;
+use image::DynamicImage;
+
+pub struct Image {
+    handle: TextureHandle,
+}
+
+impl Widget for Image {
+    fn draw(&mut self, painter: &mut Painter) {
+        painter.texture(&self.handle);
+    }
+
+    fn desired_width(&mut self, _: &mut SizeCtx) -> Len {
+        Len::abs(self.handle.size().x)
+    }
+
+    fn desired_height(&mut self, _: &mut SizeCtx) -> Len {
+        Len::abs(self.handle.size().y)
+    }
+}
+
+pub fn image<State: UiRsc>(image: impl LoadableImage) -> impl WidgetFn<State, Image> {
+    let image = image.get_image().expect("Failed to load image");
+    move |state| Image {
+        handle: state.ui_mut().textures.add(image),
+    }
+}
+
+pub trait LoadableImage {
+    fn get_image(self) -> Result<DynamicImage, String>;
+}
+
+impl LoadableImage for &str {
+    fn get_image(self) -> Result<DynamicImage, String> {
+        image::open(self).map_err(|e| format!("{e:?}"))
+    }
+}
+
+impl LoadableImage for String {
+    fn get_image(self) -> Result<DynamicImage, String> {
+        image::open(self).map_err(|e| format!("{e:?}"))
+    }
+}
+
+impl<const LEN: usize> LoadableImage for &[u8; LEN] {
+    fn get_image(self) -> Result<DynamicImage, String> {
+        image::load_from_memory(self).map_err(|e| format!("{e:?}"))
+    }
+}
+
+impl LoadableImage for DynamicImage {
+    fn get_image(self) -> Result<DynamicImage, String> {
+        Ok(self)
+    }
+}

iris/src/widget/mask.rs

@@ -0,0 +1,20 @@
+use crate::prelude::*;
+
+pub struct Masked {
+    pub inner: StrongWidget,
+}
+
+impl Widget for Masked {
+    fn draw(&mut self, painter: &mut Painter) {
+        painter.set_mask(painter.region());
+        painter.widget(&self.inner);
+    }
+
+    fn desired_width(&mut self, ctx: &mut SizeCtx) -> Len {
+        ctx.width(&self.inner)
+    }
+
+    fn desired_height(&mut self, ctx: &mut SizeCtx) -> Len {
+        ctx.height(&self.inner)
+    }
+}

iris/src/widget/mod.rs

@@ -0,0 +1,15 @@
+mod image;
+mod mask;
+mod position;
+mod ptr;
+mod rect;
+mod text;
+mod trait_fns;
+
+pub use image::*;
+pub use mask::*;
+pub use position::*;
+pub use ptr::*;
+pub use rect::*;
+pub use text::*;
+pub use trait_fns::*;

iris/src/widget/position/align.rs

@@ -0,0 +1,35 @@
+use crate::prelude::*;
+
+pub struct Aligned {
+    pub inner: StrongWidget,
+    pub align: Align,
+}
+
+impl Widget for Aligned {
+    fn draw(&mut self, painter: &mut Painter) {
+        let region = match self.align.tuple() {
+            (Some(x), Some(y)) => painter
+                .size(&self.inner)
+                .to_uivec2()
+                .align(RegionAlign { x, y }),
+            (Some(x), None) => {
+                let x = painter.size_ctx().width(&self.inner).apply_rest().align(x);
+                UiRegion::new(x, UiSpan::FULL)
+            }
+            (None, Some(y)) => {
+                let y = painter.size_ctx().height(&self.inner).apply_rest().align(y);
+                UiRegion::new(UiSpan::FULL, y)
+            }
+            (None, None) => UiRegion::FULL,
+        };
+        painter.widget_within(&self.inner, region);
+    }
+
+    fn desired_width(&mut self, ctx: &mut SizeCtx) -> Len {
+        ctx.width(&self.inner)
+    }
+
+    fn desired_height(&mut self, ctx: &mut SizeCtx) -> Len {
+        ctx.height(&self.inner)
+    }
+}

iris/src/widget/position/layer.rs

@@ -0,0 +1,23 @@
+use crate::prelude::*;
+
+pub struct LayerOffset {
+    pub inner: StrongWidget,
+    pub offset: usize,
+}
+
+impl Widget for LayerOffset {
+    fn draw(&mut self, painter: &mut Painter) {
+        for _ in 0..self.offset {
+            painter.next_layer();
+        }
+        painter.widget(&self.inner);
+    }
+
+    fn desired_width(&mut self, ctx: &mut SizeCtx) -> Len {
+        ctx.width(&self.inner)
+    }
+
+    fn desired_height(&mut self, ctx: &mut SizeCtx) -> Len {
+        ctx.height(&self.inner)
+    }
+}

iris/src/widget/position/max_size.rs

@@ -0,0 +1,48 @@
+use crate::prelude::*;
+
+pub struct MaxSize {
+    pub inner: StrongWidget,
+    pub x: Option<Len>,
+    pub y: Option<Len>,
+}
+
+impl MaxSize {
+    fn apply_to_outer(&self, ctx: &mut SizeCtx) {
+        if let Some(x) = self.x {
+            ctx.outer.x.select_len(x.apply_rest());
+        }
+        if let Some(y) = self.y {
+            ctx.outer.y.select_len(y.apply_rest());
+        }
+    }
+}
+
+impl Widget for MaxSize {
+    fn draw(&mut self, painter: &mut Painter) {
+        painter.widget(&self.inner);
+    }
+
+    fn desired_width(&mut self, ctx: &mut SizeCtx) -> Len {
+        self.apply_to_outer(ctx);
+        let width = ctx.width(&self.inner);
+        if let Some(x) = self.x {
+            let width_px = width.apply_rest().to_abs(ctx.output_size().x);
+            let x_px = x.apply_rest().to_abs(ctx.output_size().x);
+            if width_px > x_px { x } else { width }
+        } else {
+            width
+        }
+    }
+
+    fn desired_height(&mut self, ctx: &mut SizeCtx) -> Len {
+        self.apply_to_outer(ctx);
+        let height = ctx.height(&self.inner);
+        if let Some(y) = self.y {
+            let height_px = height.apply_rest().to_abs(ctx.output_size().y);
+            let y_px = y.apply_rest().to_abs(ctx.output_size().y);
+            if height_px > y_px { y } else { height }
+        } else {
+            height
+        }
+    }
+}

iris/src/widget/position/mod.rs

@@ -0,0 +1,19 @@
+mod align;
+mod layer;
+mod max_size;
+mod offset;
+mod pad;
+mod scroll;
+mod sized;
+mod span;
+mod stack;
+
+pub use align::*;
+pub use layer::*;
+pub use max_size::*;
+pub use offset::*;
+pub use pad::*;
+pub use scroll::*;
+pub use sized::*;
+pub use span::*;
+pub use stack::*;

iris/src/widget/position/offset.rs

@@ -0,0 +1,21 @@
+use crate::prelude::*;
+
+pub struct Offset {
+    pub inner: StrongWidget,
+    pub amt: UiVec2,
+}
+
+impl Widget for Offset {
+    fn draw(&mut self, painter: &mut Painter) {
+        let region = UiRegion::FULL.offset(self.amt);
+        painter.widget_within(&self.inner, region);
+    }
+
+    fn desired_width(&mut self, ctx: &mut SizeCtx) -> Len {
+        ctx.width(&self.inner)
+    }
+
+    fn desired_height(&mut self, ctx: &mut SizeCtx) -> Len {
+        ctx.height(&self.inner)
+    }
+}

iris/src/widget/position/pad.rs

@@ -0,0 +1,134 @@
+use crate::prelude::*;
+
+pub struct Pad {
+    pub padding: Padding,
+    pub inner: StrongWidget,
+}
+
+impl Widget for Pad {
+    fn draw(&mut self, painter: &mut Painter) {
+        painter.widget_within(&self.inner, self.padding.region());
+    }
+
+    fn desired_width(&mut self, ctx: &mut SizeCtx) -> Len {
+        let width = self.padding.left + self.padding.right;
+        let height = self.padding.top + self.padding.bottom;
+        ctx.outer.x.abs -= width;
+        ctx.outer.y.abs -= height;
+        let mut size = ctx.width(&self.inner);
+        size.abs += width;
+        size
+    }
+
+    fn desired_height(&mut self, ctx: &mut SizeCtx) -> Len {
+        let width = self.padding.left + self.padding.right;
+        let height = self.padding.top + self.padding.bottom;
+        ctx.outer.x.abs -= width;
+        ctx.outer.y.abs -= height;
+        let mut size = ctx.height(&self.inner);
+        size.abs += height;
+        size
+    }
+}
+
+pub struct Padding {
+    pub left: f32,
+    pub right: f32,
+    pub top: f32,
+    pub bottom: f32,
+}
+
+impl Padding {
+    pub const ZERO: Self = Self {
+        left: 0.0,
+        right: 0.0,
+        top: 0.0,
+        bottom: 0.0,
+    };
+
+    pub fn uniform(amt: impl UiNum) -> Self {
+        let amt = amt.to_f32();
+        Self {
+            left: amt,
+            right: amt,
+            top: amt,
+            bottom: amt,
+        }
+    }
+    pub fn region(&self) -> UiRegion {
+        let mut region = UiRegion::FULL;
+        region.x.start.abs += self.left;
+        region.y.start.abs += self.top;
+        region.x.end.abs -= self.right;
+        region.y.end.abs -= self.bottom;
+        region
+    }
+    pub fn x(amt: impl UiNum) -> Self {
+        let amt = amt.to_f32();
+        Self {
+            left: amt,
+            right: amt,
+            top: 0.0,
+            bottom: 0.0,
+        }
+    }
+    pub fn y(amt: impl UiNum) -> Self {
+        let amt = amt.to_f32();
+        Self {
+            left: 0.0,
+            right: 0.0,
+            top: amt,
+            bottom: amt,
+        }
+    }
+
+    pub fn top(amt: impl UiNum) -> Self {
+        let mut s = Self::ZERO;
+        s.top = amt.to_f32();
+        s
+    }
+
+    pub fn bottom(amt: impl UiNum) -> Self {
+        let mut s = Self::ZERO;
+        s.bottom = amt.to_f32();
+        s
+    }
+
+    pub fn left(amt: impl UiNum) -> Self {
+        let mut s = Self::ZERO;
+        s.left = amt.to_f32();
+        s
+    }
+
+    pub fn right(amt: impl UiNum) -> Self {
+        let mut s = Self::ZERO;
+        s.right = amt.to_f32();
+        s
+    }
+
+    pub fn with_top(mut self, amt: impl UiNum) -> Self {
+        self.top = amt.to_f32();
+        self
+    }
+
+    pub fn with_bottom(mut self, amt: impl UiNum) -> Self {
+        self.bottom = amt.to_f32();
+        self
+    }
+
+    pub fn with_left(mut self, amt: impl UiNum) -> Self {
+        self.left = amt.to_f32();
+        self
+    }
+
+    pub fn with_right(mut self, amt: impl UiNum) -> Self {
+        self.right = amt.to_f32();
+        self
+    }
+}
+
+impl<T: UiNum> From<T> for Padding {
+    fn from(amt: T) -> Self {
+        Self::uniform(amt.to_f32())
+    }
+}

iris/src/widget/position/scroll.rs

@@ -0,0 +1,66 @@
+use crate::prelude::*;
+
+pub struct Scroll {
+    inner: StrongWidget,
+    axis: Axis,
+    amt: f32,
+    snap_end: bool,
+    container_len: f32,
+    content_len: f32,
+}
+
+impl Widget for Scroll {
+    fn draw(&mut self, painter: &mut Painter) {
+        let output_len = painter.output_size().axis(self.axis);
+        let container_len = painter.region().axis(self.axis).len();
+        let content_len = painter
+            .len_axis(&self.inner, self.axis)
+            .apply_rest()
+            .within_len(container_len)
+            .to_abs(output_len);
+        self.container_len = container_len.to_abs(output_len);
+        self.content_len = content_len;
+
+        if self.snap_end {
+            self.amt = self.content_len - self.container_len;
+        }
+        self.update_amt();
+
+        let mut region = UiRegion::FULL.offset(Vec2::from_axis(self.axis, -self.amt, 0.0));
+        region.axis_mut(self.axis).end = region.axis(self.axis).start.offset(self.content_len);
+        painter.widget_within(&self.inner, region);
+    }
+
+    fn desired_width(&mut self, ctx: &mut SizeCtx) -> Len {
+        ctx.width(&self.inner)
+    }
+
+    fn desired_height(&mut self, ctx: &mut SizeCtx) -> Len {
+        ctx.height(&self.inner)
+    }
+}
+
+impl Scroll {
+    pub fn new(inner: StrongWidget, axis: Axis) -> Self {
+        Self {
+            inner,
+            axis,
+            amt: 0.0,
+            snap_end: true,
+            container_len: 0.0,
+            content_len: 0.0,
+        }
+    }
+
+    pub fn update_amt(&mut self) {
+        self.amt = self.amt.max(0.0);
+        let len = (self.content_len - self.container_len).max(0.0);
+        self.amt = self.amt.min(len);
+        self.snap_end = self.amt == len;
+    }
+
+    pub fn scroll(&mut self, amt: f32) {
+        self.amt -= amt;
+        self.update_amt();
+    }
+}

iris/src/widget/position/sized.rs

@@ -0,0 +1,34 @@
+use crate::prelude::*;
+
+pub struct Sized {
+    pub inner: StrongWidget,
+    pub x: Option<Len>,
+    pub y: Option<Len>,
+}
+
+impl Sized {
+    fn apply_to_outer(&self, ctx: &mut SizeCtx) {
+        if let Some(x) = self.x {
+            ctx.outer.x.select_len(x.apply_rest());
+        }
+        if let Some(y) = self.y {
+            ctx.outer.y.select_len(y.apply_rest());
+        }
+    }
+}
+
+impl Widget for Sized {
+    fn draw(&mut self, painter: &mut Painter) {
+        painter.widget(&self.inner);
+    }
+
+    fn desired_width(&mut self, ctx: &mut SizeCtx) -> Len {
+        self.apply_to_outer(ctx);
+        self.x.unwrap_or_else(|| ctx.width(&self.inner))
+    }
+
+    fn desired_height(&mut self, ctx: &mut SizeCtx) -> Len {
+        self.apply_to_outer(ctx);
+        self.y.unwrap_or_else(|| ctx.height(&self.inner))
+    }
+}

iris/src/widget/position/span.rs

@@ -0,0 +1,207 @@
+use crate::prelude::*;
+use std::marker::PhantomData;
+
+pub struct Span {
+    pub children: Vec<StrongWidget>,
+    pub dir: Dir,
+    pub gap: f32,
+}
+
+impl Widget for Span {
+    fn draw(&mut self, painter: &mut Painter) {
+        let total = self.len_sum(&mut painter.size_ctx());
+        let mut start = UiScalar::rel_min();
+        for child in &self.children {
+            let mut span = UiSpan::FULL;
+            span.start = start;
+            let len = painter.len_axis(child, self.dir.axis);
+            if len.rest > 0.0 {
+                let offset = UiScalar::new(total.rel, total.abs);
+                let rel_end = UiScalar::rel(len.rest / total.rest);
+                let end = (UiScalar::rel_max() + start) - offset;
+                start = rel_end.within(&start.to(end));
+            }
+            start.abs += len.abs;
+            start.rel += len.rel;
+            span.end = start;
+            let mut child_region = UiRegion::from_axis(self.dir.axis, span, UiSpan::FULL);
+            if self.dir.sign == Sign::Neg {
+                child_region.flip(self.dir.axis);
+            }
+            painter.widget_within(child, child_region);
+            start.abs += self.gap;
+        }
+    }
+
+    fn desired_width(&mut self, ctx: &mut SizeCtx) -> Len {
+        match self.dir.axis {
+            Axis::X => self.desired_len(ctx),
+            Axis::Y => self.desired_ortho(ctx),
+        }
+    }
+
+    fn desired_height(&mut self, ctx: &mut SizeCtx) -> Len {
+        match self.dir.axis {
+            Axis::X => self.desired_ortho(ctx),
+            Axis::Y => self.desired_len(ctx),
+        }
+    }
+}
+
+impl Span {
+    pub fn empty(dir: Dir) -> Self {
+        Self {
+            children: Vec::new(),
+            dir,
+            gap: 0.0,
+        }
+    }
+
+    pub fn gap(mut self, gap: impl UiNum) -> Self {
+        self.gap = gap.to_f32();
+        self
+    }
+
+    pub fn push(&mut self, w: StrongWidget) {
+        self.children.push(w);
+    }
+
+    pub fn pop(&mut self) -> Option<StrongWidget> {
+        self.children.pop()
+    }
+
+    fn len_sum(&mut self, ctx: &mut SizeCtx) -> Len {
+        let gap = self.gap * self.children.len().saturating_sub(1) as f32;
+        self.children.iter().fold(Len::abs(gap), |mut s, id| {
+            // it's tempting to subtract the abs & rel from the ctx outer,
+            // but that would create inconsistent sizing if you put
+            // a rest first vs last & only speed up in one direction.
+            // I think this is only solvable by restricting how you can
+            // compute size, bc currently you need child to define parent's
+            // sectioning and you need parent's sectioning to define child.
+            // Fortunately, that doesn't matter in most cases
+            let len = ctx.len_axis(id, self.dir.axis);
+            s += len;
+            s
+        })
+    }
+
+    fn desired_len(&mut self, ctx: &mut SizeCtx) -> Len {
+        let len = self.len_sum(ctx);
+        if len.rest == 0.0 && len.rel == 0.0 {
+            len
+        } else {
+            Len::default()
+        }
+    }
+
+    fn desired_ortho(&mut self, ctx: &mut SizeCtx) -> Len {
+        // this is a weird hack to get text wrapping to work properly when in a downward span
+        // the correct solution here is to add a function to widget that lets them
+        // request that ctx.outer has an axis "resolved" before checking the other,
+        // and panicking or warning if two request opposite axis (unsolvable in that case)
+        let outer = ctx.outer.axis(self.dir.axis);
+        if self.dir.axis == Axis::X {
+            // so....... this literally copies draw so that the lengths are correctly set in the
+            // context, which makes this slow and not cool
+            let total = self.len_sum(ctx);
+            let mut start = UiScalar::rel_min();
+            let mut ortho_len = Len::ZERO;
+            for child in &self.children {
+                let mut span = UiSpan::FULL;
+                span.start = start;
+                let len = ctx.len_axis(child, self.dir.axis);
+                if len.rest > 0.0 {
+                    let offset = UiScalar::new(total.rel, total.abs);
+                    let rel_end = UiScalar::rel(len.rest / total.rest);
+                    let end = (UiScalar::rel_max() + start) - offset;
+                    start = rel_end.within(&start.to(end));
+                }
+                start.abs += len.abs;
+                start.rel += len.rel;
+                span.end = start;
+
+                let scalar = span.len();
+                *ctx.outer.axis_mut(self.dir.axis) = outer.select_len(scalar);
+                let ortho = ctx.len_axis(child, !self.dir.axis);
+                // TODO: rel shouldn't do this, but no easy way before actually calculating pixels
+                if ortho.rel > 0.0 || ortho.rest > 0.0 {
+                    ortho_len.rest = 1.0;
+                    ortho_len.abs = 0.0;
+                    break;
+                }
+                ortho_len.abs = ortho_len.abs.max(ortho.abs);
+                start.abs += self.gap;
+            }
+            ortho_len
+        } else {
+            let mut ortho_len = Len::ZERO;
+            let ortho = !self.dir.axis;
+            for child in &self.children {
+                let len = ctx.len_axis(child, ortho);
+                // TODO: rel shouldn't do this, but no easy way before actually calculating pixels
+                if len.rel > 0.0 || len.rest > 0.0 {
+                    ortho_len.rest = 1.0;
+                    ortho_len.abs = 0.0;
+                    break;
+                }
+                ortho_len.abs = ortho_len.abs.max(len.abs);
+            }
+            ortho_len
+        }
+    }
+}
+
+pub struct SpanBuilder<State, const LEN: usize, Wa: WidgetArrLike<State, LEN, Tag>, Tag> {
+    pub children: Wa,
+    pub dir: Dir,
+    pub gap: f32,
+    _pd: PhantomData<(State, Tag)>,
+}
+
+impl<Rsc, const LEN: usize, Wa: WidgetArrLike<Rsc, LEN, Tag>, Tag> WidgetFnTrait<Rsc>
+    for SpanBuilder<Rsc, LEN, Wa, Tag>
+{
+    type Widget = Span;
+
+    #[track_caller]
+    fn run(self, rsc: &mut Rsc) -> Self::Widget {
+        Span {
+            children: self.children.add(rsc).arr.into_iter().collect(),
+            dir: self.dir,
+            gap: self.gap,
+        }
+    }
+}
+
+impl<State, const LEN: usize, Wa: WidgetArrLike<State, LEN, Tag>, Tag>
+    SpanBuilder<State, LEN, Wa, Tag>
+{
+    pub fn new(children: Wa, dir: Dir) -> Self {
+        Self {
+            children,
+            dir,
+            gap: 0.0,
+            _pd: PhantomData,
+        }
+    }
+
+    pub fn gap(mut self, gap: impl UiNum) -> Self {
+        self.gap = gap.to_f32();
+        self
+    }
+}
+
+impl std::ops::Deref for Span {
+    type Target = Vec<StrongWidget>;
+
+    fn deref(&self) -> &Self::Target {
+        &self.children
+    }
+}
+
+impl std::ops::DerefMut for Span {
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        &mut self.children
+    }
+}

iris/src/widget/position/stack.rs

@@ -0,0 +1,80 @@
+use std::marker::PhantomData;
+
+use crate::prelude::*;
+
+pub struct Stack {
+    pub children: Vec<StrongWidget>,
+    pub size: StackSize,
+}
+
+impl Widget for Stack {
+    fn draw(&mut self, painter: &mut Painter) {
+        let mut iter = self.children.iter();
+        if let Some(child) = iter.next() {
+            painter.child_layer();
+            painter.widget(child);
+        }
+        for child in iter {
+            painter.next_layer();
+            painter.widget(child);
+        }
+    }
+
+    fn desired_width(&mut self, ctx: &mut SizeCtx) -> Len {
+        match self.size {
+            StackSize::Default => Len::default(),
+            StackSize::Child(i) => ctx.width(&self.children[i]),
+        }
+    }
+
+    fn desired_height(&mut self, ctx: &mut SizeCtx) -> Len {
+        match self.size {
+            StackSize::Default => Len::default(),
+            StackSize::Child(i) => ctx.height(&self.children[i]),
+        }
+    }
+}
+
+#[derive(Default, Debug)]
+pub enum StackSize {
+    #[default]
+    Default,
+    Child(usize),
+}
+
+pub struct StackBuilder<State, const LEN: usize, Wa: WidgetArrLike<State, LEN, Tag>, Tag> {
+    pub children: Wa,
+    pub size: StackSize,
+    _pd: PhantomData<(State, Tag)>,
+}
+
+impl<Rsc, const LEN: usize, Wa: WidgetArrLike<Rsc, LEN, Tag>, Tag> WidgetFnTrait<Rsc>
+    for StackBuilder<Rsc, LEN, Wa, Tag>
+{
+    type Widget = Stack;
+
+    #[track_caller]
+    fn run(self, rsc: &mut Rsc) -> Self::Widget {
+        Stack {
+            children: self.children.add(rsc).arr.into_iter().collect(),
+            size: self.size,
+        }
+    }
+}
+
+impl<State, const LEN: usize, Wa: WidgetArrLike<State, LEN, Tag>, Tag>
+    StackBuilder<State, LEN, Wa, Tag>
+{
+    pub fn new(children: Wa) -> Self {
+        Self {
+            children,
+            size: StackSize::default(),
+            _pd: PhantomData,
+        }
+    }
+
+    pub fn size(mut self, size: StackSize) -> Self {
+        self.size = size;
+        self
+    }
+}

iris/src/widget/ptr.rs

@@ -0,0 +1,57 @@
+use crate::prelude::*;
+use std::marker::{Sized, Unsize};
+
+pub struct WidgetPtr {
+    pub inner: Option<StrongWidget>,
+}
+
+impl Widget for WidgetPtr {
+    fn draw(&mut self, painter: &mut Painter) {
+        if let Some(id) = &self.inner {
+            painter.widget(id);
+        }
+    }
+
+    fn desired_width(&mut self, ctx: &mut SizeCtx) -> Len {
+        if let Some(id) = &self.inner {
+            ctx.width(id)
+        } else {
+            Len::ZERO
+        }
+    }
+
+    fn desired_height(&mut self, ctx: &mut SizeCtx) -> Len {
+        if let Some(id) = &self.inner {
+            ctx.height(id)
+        } else {
+            Len::ZERO
+        }
+    }
+}
+
+impl WidgetPtr {
+    pub fn new() -> Self {
+        Self::default()
+    }
+    pub fn empty() -> Self {
+        Self {
+            inner: Default::default(),
+        }
+    }
+    pub fn set<W: ?Sized + Unsize<dyn Widget>>(&mut self, to: StrongWidget<W>) {
+        self.inner = Some(to)
+    }
+
+    pub fn replace<W: ?Sized + Unsize<dyn Widget>>(
+        &mut self,
+        to: StrongWidget<W>,
+    ) -> Option<StrongWidget> {
+        self.inner.replace(to)
+    }
+}
+
+impl Default for WidgetPtr {
+    fn default() -> Self {
+        Self::empty()
+    }
+}

iris/src/widget/rect.rs

@@ -0,0 +1,51 @@
+use crate::prelude::*;
+
+#[derive(Clone, Copy)]
+pub struct Rect {
+    pub color: UiColor,
+    pub radius: f32,
+    pub thickness: f32,
+    pub inner_radius: f32,
+}
+
+impl Rect {
+    pub fn new(color: UiColor) -> Self {
+        Self {
+            color,
+            radius: 0.0,
+            inner_radius: 0.0,
+            thickness: 0.0,
+        }
+    }
+    pub fn color(mut self, color: UiColor) -> Self {
+        self.color = color;
+        self
+    }
+    pub fn radius(mut self, radius: impl UiNum) -> Self {
+        self.radius = radius.to_f32();
+        self
+    }
+}
+
+impl Widget for Rect {
+    fn draw(&mut self, painter: &mut Painter) {
+        painter.primitive(RectPrimitive {
+            color: self.color,
+            radius: self.radius,
+            thickness: self.thickness,
+            inner_radius: self.inner_radius,
+        });
+    }
+
+    fn desired_width(&mut self, _: &mut SizeCtx) -> Len {
+        Len::rest(1)
+    }
+
+    fn desired_height(&mut self, _: &mut SizeCtx) -> Len {
+        Len::rest(1)
+    }
+}
+
+pub fn rect(color: UiColor) -> Rect {
+    Rect::new(color)
+}

iris/src/widget/text/build.rs

@@ -0,0 +1,147 @@
+use crate::prelude::*;
+use cosmic_text::{Attrs, Family, Metrics};
+use std::marker::{PhantomData, Sized};
+
+pub struct TextBuilder<State, O = TextOutput, H: WidgetOption<State> = ()> {
+    pub content: String,
+    pub attrs: TextAttrs,
+    pub hint: H,
+    pub output: O,
+    state: PhantomData<State>,
+}
+
+impl<State, O, H: WidgetOption<State>> TextBuilder<State, O, H> {
+    pub fn size(mut self, size: impl UiNum) -> Self {
+        self.attrs.font_size = size.to_f32();
+        self.attrs.line_height = self.attrs.font_size * LINE_HEIGHT_MULT;
+        self
+    }
+    pub fn color(mut self, color: UiColor) -> Self {
+        self.attrs.color = color;
+        self
+    }
+    pub fn family(mut self, family: Family<'static>) -> Self {
+        self.attrs.family = family;
+        self
+    }
+    pub fn line_height(mut self, height: f32) -> Self {
+        self.attrs.line_height = height;
+        self
+    }
+    pub fn text_align(mut self, align: impl Into<RegionAlign>) -> Self {
+        self.attrs.align = align.into();
+        self
+    }
+    pub fn center_text(mut self) -> Self {
+        self.attrs.align = Align::CENTER;
+        self
+    }
+    pub fn wrap(mut self, wrap: bool) -> Self {
+        self.attrs.wrap = wrap;
+        self
+    }
+    pub fn editable(self, mode: EditMode) -> TextBuilder<State, TextEditOutput, H> {
+        TextBuilder {
+            content: self.content,
+            attrs: self.attrs,
+            hint: self.hint,
+            output: TextEditOutput { mode },
+            state: PhantomData,
+        }
+    }
+}
+
+impl<Rsc: UiRsc, O> TextBuilder<Rsc, O> {
+    pub fn hint<W: WidgetLike<Rsc, Tag>, Tag>(
+        self,
+        hint: W,
+    ) -> TextBuilder<Rsc, O, impl WidgetOption<Rsc>> {
+        TextBuilder {
+            content: self.content,
+            attrs: self.attrs,
+            hint: move |rsc: &mut Rsc| Some(hint.add_strong(rsc).any()),
+            output: self.output,
+            state: PhantomData,
+        }
+    }
+}
+
+pub trait TextBuilderOutput<State>: Sized {
+    type Output;
+    fn run<H: WidgetOption<State>>(
+        state: &mut State,
+        builder: TextBuilder<State, Self, H>,
+    ) -> Self::Output;
+}
+
+pub struct TextOutput;
+impl<Rsc: UiRsc> TextBuilderOutput<Rsc> for TextOutput {
+    type Output = Text;
+
+    fn run<H: WidgetOption<Rsc>>(
+        state: &mut Rsc,
+        builder: TextBuilder<Rsc, Self, H>,
+    ) -> Self::Output {
+        let mut buf = TextBuffer::new_empty(Metrics::new(
+            builder.attrs.font_size,
+            builder.attrs.line_height,
+        ));
+        let hint = builder.hint.get(state);
+        let font_system = &mut state.ui_mut().text.font_system;
+        buf.set_text(font_system, &builder.content, &Attrs::new(), SHAPING, None);
+        let mut text = Text {
+            content: builder.content.into(),
+            view: TextView::new(buf, builder.attrs, hint),
+        };
+        text.content.changed = false;
+        builder.attrs.apply(font_system, &mut text.view.buf, None);
+        text
+    }
+}
+
+pub struct TextEditOutput {
+    mode: EditMode,
+}
+
+impl<State: UiRsc> TextBuilderOutput<State> for TextEditOutput {
+    type Output = TextEdit;
+
+    fn run<H: WidgetOption<State>>(
+        state: &mut State,
+        builder: TextBuilder<State, Self, H>,
+    ) -> Self::Output {
+        let buf = TextBuffer::new_empty(Metrics::new(
+            builder.attrs.font_size,
+            builder.attrs.line_height,
+        ));
+        let mut text = TextEdit::new(
+            TextView::new(buf, builder.attrs, builder.hint.get(state)),
+            builder.output.mode,
+        );
+        let font_system = &mut state.ui_mut().text.font_system;
+        text.buf
+            .set_text(font_system, &builder.content, &Attrs::new(), SHAPING, None);
+        builder.attrs.apply(font_system, &mut text.buf, None);
+        text
+    }
+}
+
+impl<State, O: TextBuilderOutput<State>, H: WidgetOption<State>> FnOnce<(&mut State,)>
+    for TextBuilder<State, O, H>
+{
+    type Output = O::Output;
+
+    extern "rust-call" fn call_once(self, args: (&mut State,)) -> Self::Output {
+        O::run(args.0, self)
+    }
+}
+
+pub fn wtext<State>(content: impl Into<String>) -> TextBuilder<State> {
+    TextBuilder {
+        content: content.into(),
+        attrs: TextAttrs::default(),
+        hint: (),
+        output: TextOutput,
+        state: PhantomData,
+    }
+}

iris/src/widget/text/edit.rs

@@ -0,0 +1,631 @@
+use crate::prelude::*;
+use cosmic_text::{Affinity, Attrs, Cursor, FontSystem, LayoutRun, Motion};
+use std::ops::{Deref, DerefMut};
+use unicode_segmentation::UnicodeSegmentation;
+use winit::{
+    event::KeyEvent,
+    keyboard::{Key, NamedKey},
+};
+
+pub struct TextEdit {
+    view: TextView,
+    selection: TextSelection,
+    history: Vec<(String, TextSelection)>,
+    double_hit: Option<Cursor>,
+    pub mode: EditMode,
+}
+
+#[derive(Clone, Copy, PartialEq)]
+pub enum EditMode {
+    SingleLine,
+    MultiLine,
+}
+
+impl TextEdit {
+    pub fn new(view: TextView, mode: EditMode) -> Self {
+        Self {
+            view,
+            selection: Default::default(),
+            history: Default::default(),
+            double_hit: None,
+            mode,
+        }
+    }
+    pub fn select_content(&self, start: Cursor, end: Cursor) -> String {
+        let (start, end) = sort_cursors(start, end);
+        let mut iter = self.buf.lines.iter().skip(start.line);
+        let first = iter.next().unwrap();
+        if start.line == end.line {
+            first.text()[start.index..end.index].to_string()
+        } else {
+            let mut str = first.text()[start.index..].to_string();
+            for _ in (start.line + 1)..end.line {
+                str = str + "\n" + iter.next().unwrap().text();
+            }
+            let last = iter.next().unwrap();
+            str = str + "\n" + &last.text()[..end.index];
+            str
+        }
+    }
+}
+
+impl Widget for TextEdit {
+    fn draw(&mut self, painter: &mut Painter) {
+        let base = painter.layer;
+        painter.child_layer();
+        self.view.draw(painter);
+        painter.layer = base;
+        let region = self.region();
+
+        let size = vec2(1, self.attrs.line_height);
+        match self.selection {
+            TextSelection::None => (),
+            TextSelection::Pos(cursor) => {
+                if let Some(offset) = cursor_pos(cursor, &self.buf) {
+                    painter.primitive_within(
+                        RectPrimitive::color(Color::WHITE),
+                        size.align(Align::TOP_LEFT).offset(offset).within(&region),
+                    );
+                }
+            }
+            TextSelection::Span { start, end } => {
+                let (start, end) = sort_cursors(start, end);
+                for (l, x, width) in iter_layout_lines(start, end, &self.buf) {
+                    let top_left = vec2(x, self.attrs.line_height * l as f32);
+                    painter.primitive_within(
+                        RectPrimitive::color(Color::SKY),
+                        size.with_x(width)
+                            .align(Align::TOP_LEFT)
+                            .offset(top_left)
+                            .within(&region),
+                    );
+                }
+                if let Some(end_offset) = cursor_pos(end, &self.buf) {
+                    painter.primitive_within(
+                        RectPrimitive::color(Color::WHITE),
+                        size.align(Align::TOP_LEFT)
+                            .offset(end_offset)
+                            .within(&region),
+                    );
+                }
+            }
+        }
+    }
+
+    fn desired_width(&mut self, ctx: &mut SizeCtx) -> Len {
+        self.view.desired_width(ctx)
+    }
+
+    fn desired_height(&mut self, ctx: &mut SizeCtx) -> Len {
+        self.view.desired_height(ctx)
+    }
+}
+
+/// provides top left + width
+fn iter_layout_lines(
+    start: Cursor,
+    end: Cursor,
+    buf: &TextBuffer,
+) -> impl Iterator<Item = (usize, f32, f32)> {
+    gen move {
+        let mut iter = buf.layout_runs().enumerate();
+        for (i, line) in iter.by_ref() {
+            if line.line_i == start.line
+                && let Some(start_x) = index_x(&line, start.index)
+            {
+                if start.line == end.line
+                    && let Some(end_x) = index_x(&line, end.index)
+                {
+                    yield (i, start_x, end_x - start_x);
+                    return;
+                }
+                yield (i, start_x, line.line_w - start_x);
+                break;
+            }
+        }
+        for (i, line) in iter {
+            if line.line_i > end.line {
+                return;
+            }
+            if line.line_i == end.line
+                && let Some(end_x) = index_x(&line, end.index)
+            {
+                yield (i, 0.0, end_x);
+                return;
+            }
+            yield (i, 0.0, line.line_w);
+        }
+    }
+}
+
+/// copied & modified from fn found in Editor in cosmic_text
+/// returns x pos of a (non layout) index within an layout run
+fn index_x(run: &LayoutRun, index: usize) -> Option<f32> {
+    for glyph in run.glyphs.iter() {
+        if index == glyph.start {
+            return Some(glyph.x);
+        } else if index > glyph.start && index < glyph.end {
+            // Guess x offset based on characters
+            let mut before = 0;
+            let mut total = 0;
+
+            let cluster = &run.text[glyph.start..glyph.end];
+            for (i, _) in cluster.grapheme_indices(true) {
+                if glyph.start + i < index {
+                    before += 1;
+                }
+                total += 1;
+            }
+
+            let offset = glyph.w * (before as f32) / (total as f32);
+            return Some(glyph.x + offset);
+        }
+    }
+    None
+}
+
+/// returns top of line segment where cursor should visually select
+fn cursor_pos(cursor: Cursor, buf: &TextBuffer) -> Option<Vec2> {
+    let mut prev = None;
+    for run in buf
+        .layout_runs()
+        .skip_while(|r| r.line_i < cursor.line)
+        .take_while(|r| r.line_i == cursor.line)
+    {
+        prev = Some(vec2(run.line_w, run.line_top));
+        if let Some(pos) = index_x(&run, cursor.index) {
+            return Some(vec2(pos, run.line_top));
+        }
+    }
+    prev
+}
+
+pub struct TextEditCtx<'a> {
+    pub text: &'a mut TextEdit,
+    pub font_system: &'a mut FontSystem,
+}
+
+impl<'a> TextEditCtx<'a> {
+    pub fn take(&mut self) -> String {
+        let text = self
+            .text
+            .buf
+            .lines
+            .drain(..)
+            .map(|l| l.into_text())
+            .collect::<Vec<_>>()
+            .join("\n");
+        self.text
+            .buf
+            .set_text(self.font_system, "", &Attrs::new(), SHAPING, None);
+        self.text.selection.clear();
+        text
+    }
+
+    pub fn set(&mut self, text: &str) {
+        let text = self.string(text);
+        self.text
+            .buf
+            .set_text(self.font_system, &text, &Attrs::new(), SHAPING, None);
+        self.text.selection.clear();
+    }
+
+    pub fn motion(&mut self, motion: Motion, select: bool) {
+        if let TextSelection::Pos(cursor) = self.text.selection
+            && let Some(new) = self.buf_motion(cursor, motion)
+        {
+            if select {
+                self.text.selection = TextSelection::Span {
+                    start: cursor,
+                    end: new,
+                };
+            } else {
+                self.text.selection = TextSelection::Pos(new);
+            }
+        } else if let TextSelection::Span { start, end } = self.text.selection {
+            if select {
+                if let Some(cursor) = self.buf_motion(end, motion) {
+                    self.text.selection = TextSelection::Span { start, end: cursor };
+                }
+            } else {
+                let (start, end) = sort_cursors(start, end);
+                let sel = &mut self.text.selection;
+                match motion {
+                    Motion::Left | Motion::LeftWord => *sel = TextSelection::Pos(start),
+                    Motion::Right | Motion::RightWord => *sel = TextSelection::Pos(end),
+                    _ => {
+                        if let Some(cursor) = self.buf_motion(end, motion) {
+                            self.text.selection = TextSelection::Pos(cursor);
+                        }
+                    }
+                }
+            }
+        }
+    }
+
+    pub fn replace(&mut self, len: usize, text: &str) {
+        let text = self.string(text);
+        for _ in 0..len {
+            self.delete(false);
+        }
+        self.insert_inner(&text, false);
+    }
+
+    fn string(&self, text: &str) -> String {
+        if self.text.mode == EditMode::SingleLine {
+            text.replace('\n', "")
+        } else {
+            text.to_string()
+        }
+    }
+
+    pub fn insert(&mut self, text: &str) {
+        let text = self.string(text);
+        let mut lines = text.split('\n');
+        let Some(first) = lines.next() else {
+            return;
+        };
+        self.insert_inner(first, true);
+        for line in lines {
+            self.newline();
+            self.insert_inner(line, true);
+        }
+    }
+
+    pub fn clear_span(&mut self) -> bool {
+        if let TextSelection::Span { start, end } = self.text.selection {
+            self.delete_between(start, end);
+            let (start, _) = sort_cursors(start, end);
+            self.text.selection = TextSelection::Pos(start);
+            true
+        } else {
+            false
+        }
+    }
+
+    pub fn delete_between(&mut self, start: Cursor, end: Cursor) {
+        let lines = &mut self.text.view.buf.lines;
+        let (start, end) = sort_cursors(start, end);
+        if start.line == end.line {
+            let line = &mut lines[start.line];
+            let text = line.text();
+            let text = text[..start.index].to_string() + &text[end.index..];
+            edit_line(line, text);
+        } else {
+            // start
+            let start_text = lines[start.line].text()[..start.index].to_string();
+            let end_text = &lines[end.line].text()[end.index..];
+            let text = start_text + end_text;
+            edit_line(&mut lines[start.line], text);
+        }
+        // between
+        let range = (start.line + 1)..=end.line;
+        if !range.is_empty() {
+            lines.splice(range, None);
+        }
+    }
+
+    fn insert_inner(&mut self, text: &str, mov: bool) {
+        self.clear_span();
+        if let TextSelection::Pos(cursor) = &mut self.text.selection {
+            let line = &mut self.text.view.buf.lines[cursor.line];
+            let mut line_text = line.text().to_string();
+            line_text.insert_str(cursor.index, text);
+            edit_line(line, line_text);
+            if mov {
+                for _ in 0..text.chars().count() {
+                    self.motion(Motion::Right, false);
+                }
+            }
+        }
+    }
+
+    pub fn newline(&mut self) {
+        if self.text.mode == EditMode::SingleLine {
+            return;
+        }
+        self.clear_span();
+        if let TextSelection::Pos(cursor) = &mut self.text.selection {
+            let lines = &mut self.text.view.buf.lines;
+            let line = &mut lines[cursor.line];
+            let new = line.split_off(cursor.index);
+            cursor.line += 1;
+            lines.insert(cursor.line, new);
+            cursor.index = 0;
+        }
+    }
+
+    pub fn backspace(&mut self, word: bool) {
+        if !self.clear_span()
+            && let TextSelection::Pos(cursor) = &mut self.text.selection
+            && (cursor.index != 0 || cursor.line != 0)
+        {
+            self.motion(if word { Motion::LeftWord } else { Motion::Left }, false);
+            self.delete(word);
+        }
+    }
+
+    pub fn delete(&mut self, word: bool) {
+        if !self.clear_span()
+            && let TextSelection::Pos(cursor) = &mut self.text.selection
+        {
+            if word {
+                let start = *cursor;
+                if let Some(end) = self.buf_motion(start, Motion::RightWord) {
+                    self.delete_between(start, end);
+                }
+            } else {
+                let lines = &mut self.text.view.buf.lines;
+                let line = &mut lines[cursor.line];
+                if cursor.index == line.text().len() {
+                    if cursor.line == lines.len() - 1 {
+                        return;
+                    }
+                    let add = lines.remove(cursor.line + 1).into_text();
+                    let line = &mut lines[cursor.line];
+                    let mut cur = line.text().to_string();
+                    cur.push_str(&add);
+                    edit_line(line, cur);
+                } else {
+                    let mut text = line.text().to_string();
+                    text.remove(cursor.index);
+                    edit_line(line, text);
+                }
+            }
+        }
+    }
+
+    fn buf_motion(&mut self, cursor: Cursor, motion: Motion) -> Option<Cursor> {
+        self.text
+            .buf
+            .cursor_motion(self.font_system, cursor, None, motion)
+            .map(|r| r.0)
+    }
+
+    pub fn select_word_at(&mut self, cursor: Cursor) {
+        if let (Some(start), Some(end)) = (
+            self.buf_motion(cursor, Motion::LeftWord),
+            self.buf_motion(cursor, Motion::RightWord),
+        ) {
+            self.text.selection = TextSelection::Span { start, end };
+        }
+    }
+
+    pub fn select_line_at(&mut self, cursor: Cursor) {
+        let end = self.text.buf.lines[cursor.line].text().len();
+        self.text.selection = TextSelection::Span {
+            start: Cursor::new(cursor.line, 0),
+            end: Cursor::new(cursor.line, end),
+        }
+    }
+
+    pub fn select(&mut self, pos: Vec2, size: Vec2, drag: bool, recent: bool) {
+        let pos = pos - self.text.region().top_left().to_abs(size);
+        let hit = self.text.buf.hit(pos.x, pos.y);
+        let sel = &mut self.text.selection;
+        match sel {
+            TextSelection::None => {
+                if !drag && let Some(hit) = hit {
+                    *sel = TextSelection::Pos(hit)
+                }
+            }
+            TextSelection::Pos(pos) => match (hit, drag) {
+                (None, false) => *sel = TextSelection::None,
+                (None, true) => (),
+                (Some(hit), false) => {
+                    if recent && hit == *pos {
+                        self.text.double_hit = Some(hit);
+                        return self.select_word_at(hit);
+                    } else {
+                        *pos = hit
+                    }
+                }
+                (Some(end), true) => *sel = TextSelection::Span { start: *pos, end },
+            },
+            TextSelection::Span { start, end } => match (hit, drag) {
+                (None, false) => *sel = TextSelection::None,
+                (None, true) => *sel = TextSelection::Pos(*start),
+                (Some(hit), false) => {
+                    if recent
+                        && let Some(double) = self.text.double_hit
+                        && double == hit
+                    {
+                        return self.select_line_at(hit);
+                    } else {
+                        *sel = TextSelection::Pos(hit)
+                    }
+                }
+                (Some(hit), true) => *end = hit,
+            },
+        }
+        if let TextSelection::Span { start, end } = sel
+            && start == end
+        {
+            *sel = TextSelection::Pos(*start);
+        }
+    }
+
+    pub fn deselect(&mut self) {
+        self.text.selection = TextSelection::None;
+    }
+
+    pub fn apply_event(&mut self, event: &KeyEvent, modifiers: &Modifiers) -> TextInputResult {
+        let old = (self.text.content(), self.text.selection);
+        let mut undo = false;
+        let res = self.apply_event_inner(event, modifiers, &mut undo);
+        if undo && let Some((old, selection)) = self.text.history.pop() {
+            self.set(&old);
+            self.text.selection = selection;
+        } else if self.text.content() != old.0 {
+            self.text.history.push(old);
+        }
+        res
+    }
+
+    fn apply_event_inner(
+        &mut self,
+        event: &KeyEvent,
+        modifiers: &Modifiers,
+        undo: &mut bool,
+    ) -> TextInputResult {
+        match &event.logical_key {
+            Key::Named(named) => match named {
+                NamedKey::Backspace => self.backspace(modifiers.control),
+                NamedKey::Delete => self.delete(modifiers.control),
+                NamedKey::Space => self.insert(" "),
+                NamedKey::Enter => {
+                    if modifiers.shift {
+                        self.newline();
+                    } else {
+                        return TextInputResult::Submit;
+                    }
+                }
+                NamedKey::ArrowRight => {
+                    if modifiers.control {
+                        self.motion(Motion::RightWord, modifiers.shift)
+                    } else {
+                        self.motion(Motion::Right, modifiers.shift)
+                    }
+                }
+                NamedKey::ArrowLeft => {
+                    if modifiers.control {
+                        self.motion(Motion::LeftWord, modifiers.shift)
+                    } else {
+                        self.motion(Motion::Left, modifiers.shift)
+                    }
+                }
+                NamedKey::ArrowUp => self.motion(Motion::Up, modifiers.shift),
+                NamedKey::ArrowDown => self.motion(Motion::Down, modifiers.shift),
+                NamedKey::Escape => {
+                    self.deselect();
+                    return TextInputResult::Unfocus;
+                }
+                _ => return TextInputResult::Unused,
+            },
+            Key::Character(text) => {
+                if modifiers.control {
+                    match text.as_str() {
+                        "v" => return TextInputResult::Paste,
+                        "c" => {
+                            if let TextSelection::Span { start, end } = self.text.selection {
+                                let content = self.text.select_content(start, end);
+                                return TextInputResult::Copy(content);
+                            }
+                        }
+                        "x" => {
+                            if let TextSelection::Span { start, end } = self.text.selection {
+                                let content = self.text.select_content(start, end);
+                                self.clear_span();
+                                return TextInputResult::Copy(content);
+                            }
+                        }
+                        "a" => {
+                            if !self.text.buf.lines[0].text().is_empty()
+                                || self.text.buf.lines.len() > 1
+                            {
+                                let lines = &self.text.buf.lines;
+                                let last_line = lines.len() - 1;
+                                let last_idx = lines[last_line].text().len();
+                                self.text.selection = TextSelection::Span {
+                                    start: Cursor::new(0, 0),
+                                    end: Cursor::new(last_line, last_idx),
+                                };
+                            }
+                        }
+                        "z" => {
+                            *undo = true;
+                        }
+                        _ => self.insert(text),
+                    }
+                } else {
+                    self.insert(text);
+                }
+            }
+            _ => return TextInputResult::Unused,
+        }
+        TextInputResult::Used
+    }
+}
+
+#[derive(Default)]
+pub struct Modifiers {
+    pub shift: bool,
+    pub control: bool,
+}
+
+impl Modifiers {
+    pub fn clear(&mut self) {
+        self.shift = false;
+        self.control = false;
+    }
+}
+
+pub enum TextInputResult {
+    Used,
+    Unused,
+    Unfocus,
+    Submit,
+    Copy(String),
+    Paste,
+}
+
+#[derive(Debug, Default, Clone, Copy)]
+pub enum TextSelection {
+    #[default]
+    None,
+    Pos(Cursor),
+    Span {
+        start: Cursor,
+        end: Cursor,
+    },
+}
+
+impl TextSelection {
+    pub fn clear(&mut self) {
+        match self {
+            TextSelection::None => (),
+            TextSelection::Pos(cursor) => {
+                cursor.line = 0;
+                cursor.index = 0;
+                cursor.affinity = Affinity::default();
+            }
+            TextSelection::Span { start: _, end: _ } => {
+                *self = TextSelection::None;
+            }
+        }
+    }
+}
+
+impl TextInputResult {
+    pub fn unfocus(&self) -> bool {
+        matches!(self, TextInputResult::Unfocus)
+    }
+}
+
+impl Deref for TextEdit {
+    type Target = TextView;
+
+    fn deref(&self) -> &Self::Target {
+        &self.view
+    }
+}
+
+impl DerefMut for TextEdit {
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        &mut self.view
+    }
+}
+
+pub trait TextEditable {
+    fn edit<'a>(&self, ui: &'a mut impl UiRsc) -> TextEditCtx<'a>;
+}
+
+impl<I: IdLike<Widget = TextEdit>> TextEditable for I {
+    fn edit<'a>(&self, ui: &'a mut impl UiRsc) -> TextEditCtx<'a> {
+        let ui = ui.ui_mut();
+        TextEditCtx {
+            text: ui.widgets.get_mut(self).unwrap(),
+            font_system: &mut ui.text.font_system,
+        }
+    }
+}

iris/src/widget/text/mod.rs

@@ -0,0 +1,203 @@
+mod build;
+mod edit;
+
+pub use build::*;
+pub use edit::*;
+use iris_core::util::MutDetect;
+
+use crate::prelude::*;
+use cosmic_text::{Attrs, BufferLine, Cursor, Metrics, Shaping};
+use std::ops::{Deref, DerefMut};
+
+pub const SHAPING: Shaping = Shaping::Advanced;
+
+pub struct Text {
+    pub content: MutDetect<String>,
+    view: TextView,
+}
+
+pub struct TextView {
+    pub attrs: MutDetect<TextAttrs>,
+    pub buf: MutDetect<TextBuffer>,
+    // cache
+    tex: Option<RenderedText>,
+    width: Option<f32>,
+    pub hint: Option<StrongWidget>,
+}
+
+impl TextView {
+    pub fn new(buf: TextBuffer, attrs: TextAttrs, hint: Option<StrongWidget>) -> Self {
+        Self {
+            attrs: attrs.into(),
+            buf: buf.into(),
+            tex: None,
+            width: None,
+            hint,
+        }
+    }
+
+    /// region where the text should be draw
+    /// does not include extra height or width from weird unicode
+    pub fn region(&self) -> UiRegion {
+        self.tex()
+            .map(|t| t.size)
+            .unwrap_or(Vec2::ZERO)
+            .align(self.align)
+    }
+
+    fn tex_region(&self, tex: &RenderedText) -> UiRegion {
+        let region = tex.size.align(self.align);
+        let dims = tex.handle.size();
+        let mut region = region.offset(tex.top_left_offset);
+        region.x.end = region.x.start + UiScalar::abs(dims.x);
+        region.y.end = region.y.start + UiScalar::abs(dims.y);
+        region
+    }
+
+    fn render(&mut self, ctx: &mut SizeCtx) -> RenderedText {
+        let width = if self.attrs.wrap {
+            Some(ctx.px_size().x)
+        } else {
+            None
+        };
+        if width == self.width
+            && let Some(tex) = &self.tex
+            && !self.attrs.changed
+            && !self.buf.changed
+        {
+            return tex.clone();
+        }
+        self.width = width;
+        let font_system = &mut ctx.text.font_system;
+        self.attrs.apply(font_system, &mut self.buf, width);
+        self.buf.shape_until_scroll(font_system, false);
+        let tex = ctx.draw_text(&mut self.buf, &self.attrs);
+        self.tex = Some(tex.clone());
+        self.attrs.changed = false;
+        self.buf.changed = false;
+        tex
+    }
+    pub fn tex(&self) -> Option<&RenderedText> {
+        self.tex.as_ref()
+    }
+    pub fn desired_width(&mut self, ctx: &mut SizeCtx) -> Len {
+        if let Some(hint) = &self.hint
+            && let [line] = &self.buf.lines[..]
+            && line.text().is_empty()
+        {
+            ctx.width(hint)
+        } else {
+            Len::abs(self.render(ctx).size.x)
+        }
+    }
+    pub fn desired_height(&mut self, ctx: &mut SizeCtx) -> Len {
+        if let Some(hint) = &self.hint
+            && let [line] = &self.buf.lines[..]
+            && line.text().is_empty()
+        {
+            ctx.height(hint)
+        } else {
+            Len::abs(self.render(ctx).size.y)
+        }
+    }
+    pub fn draw(&mut self, painter: &mut Painter) -> UiRegion {
+        let tex = self.render(&mut painter.size_ctx());
+        let region = self.tex_region(&tex);
+        if let Some(hint) = &self.hint
+            && let [line] = &self.buf.lines[..]
+            && line.text().is_empty()
+        {
+            painter.widget(hint);
+        } else {
+            painter.texture_within(&tex.handle, region);
+        }
+        region
+    }
+
+    pub fn content(&self) -> String {
+        self.buf
+            .lines
+            .iter()
+            .map(|l| l.text())
+            .collect::<Vec<_>>()
+            .join("\n")
+    }
+}
+
+impl Text {
+    pub fn new(content: impl Into<String>) -> Self {
+        let attrs = TextAttrs::default();
+        let buf = TextBuffer::new_empty(Metrics::new(attrs.font_size, attrs.line_height));
+        Self {
+            content: content.into().into(),
+            view: TextView::new(buf, attrs, None),
+        }
+    }
+    fn update_buf(&mut self, ctx: &mut SizeCtx) {
+        if self.content.changed {
+            self.content.changed = false;
+            self.view.buf.set_text(
+                &mut ctx.text.font_system,
+                &self.content,
+                &Attrs::new().family(self.view.attrs.family),
+                SHAPING,
+                None,
+            );
+        }
+    }
+}
+
+impl Widget for Text {
+    fn draw(&mut self, painter: &mut Painter) {
+        self.update_buf(&mut painter.size_ctx());
+        self.view.draw(painter);
+    }
+
+    fn desired_width(&mut self, ctx: &mut SizeCtx) -> Len {
+        self.update_buf(ctx);
+        self.view.desired_width(ctx)
+    }
+
+    fn desired_height(&mut self, ctx: &mut SizeCtx) -> Len {
+        self.update_buf(ctx);
+        self.view.desired_height(ctx)
+    }
+}
+
+pub fn sort_cursors(a: Cursor, b: Cursor) -> (Cursor, Cursor) {
+    let start = a.min(b);
+    let end = a.max(b);
+    (start, end)
+}
+
+pub fn edit_line(line: &mut BufferLine, text: String) {
+    line.set_text(text, line.ending(), line.attrs_list().clone());
+}
+
+impl Deref for Text {
+    type Target = TextAttrs;
+
+    fn deref(&self) -> &Self::Target {
+        &self.view
+    }
+}
+
+impl DerefMut for Text {
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        &mut self.view
+    }
+}
+
+impl Deref for TextView {
+    type Target = TextAttrs;
+
+    fn deref(&self) -> &Self::Target {
+        &self.attrs
+    }
+}
+
+impl DerefMut for TextView {
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        &mut self.attrs
+    }
+}

iris/src/widget/trait_fns.rs

@@ -0,0 +1,148 @@
+use super::*;
+use crate::prelude::*;
+
+// these methods should "not require any context" (require unit) because they're in core
+widget_trait! {
+    pub trait CoreWidget<Rsc: UiRsc + 'static>;
+
+    fn pad(self, padding: impl Into<Padding>) -> impl WidgetFn<Rsc, Pad> {
+        |state| Pad {
+            padding: padding.into(),
+            inner: self.add_strong(state),
+        }
+    }
+
+    fn align(self, align: impl Into<Align>) -> impl WidgetFn<Rsc, Aligned> {
+        move |state| Aligned {
+            inner: self.add_strong(state),
+            align: align.into(),
+        }
+    }
+
+    fn center(self) -> impl WidgetFn<Rsc, Aligned> {
+        self.align(Align::CENTER)
+    }
+
+    fn label(self, label: impl Into<String>) -> impl WidgetIdFn<Rsc, WL::Widget> {
+        |state| {
+            let id = self.add(state);
+            state.ui_mut().widgets.set_label(id, label.into());
+            id
+        }
+    }
+
+    fn sized(self, size: impl Into<Size>) -> impl WidgetFn<Rsc, Sized> {
+        let size = size.into();
+        move |state| Sized {
+            inner: self.add_strong(state),
+            x: Some(size.x),
+            y: Some(size.y),
+        }
+    }
+
+    fn max_width(self, len: impl Into<Len>) -> impl WidgetFn<Rsc, MaxSize> {
+        let len = len.into();
+        move |state| MaxSize {
+            inner: self.add_strong(state),
+            x: Some(len),
+            y: None,
+        }
+    }
+
+    fn max_height(self, len: impl Into<Len>) -> impl WidgetFn<Rsc, MaxSize> {
+        let len = len.into();
+        move |state| MaxSize {
+            inner: self.add_strong(state),
+            x: None,
+            y: Some(len),
+        }
+    }
+
+    fn width(self, len: impl Into<Len>) -> impl WidgetFn<Rsc, Sized> {
+        let len = len.into();
+        move |state| Sized {
+            inner: self.add_strong(state),
+            x: Some(len),
+            y: None,
+        }
+    }
+
+    fn height(self, len: impl Into<Len>) -> impl WidgetFn<Rsc, Sized> {
+        let len = len.into();
+        move |state| Sized {
+            inner: self.add_strong(state),
+            x: None,
+            y: Some(len),
+        }
+    }
+
+    fn offset(self, amt: impl Into<UiVec2>) -> impl WidgetFn<Rsc, Offset> {
+        move |state| Offset {
+            inner: self.add_strong(state),
+            amt: amt.into(),
+        }
+    }
+
+    fn scrollable(self) -> impl WidgetIdFn<Rsc, Scroll> where Rsc: HasEvents {
+        move |state| {
+            Scroll::new(self.add_strong(state), Axis::Y)
+                .on(CursorSense::Scroll, |ctx, rsc| {
+                    let delta = ctx.data.scroll_delta.y * 50.0;
+                    ctx.widget(rsc).scroll(delta);
+                })
+                .add(state)
+        }
+    }
+
+    fn masked(self) -> impl WidgetFn<Rsc, Masked> {
+        move |state| Masked {
+            inner: self.add_strong(state),
+        }
+    }
+
+    fn background<T>(self, w: impl WidgetLike<Rsc, T>) -> impl WidgetFn<Rsc, Stack> {
+        move |state| Stack {
+            children: vec![w.add_strong(state), self.add_strong(state)],
+            size: StackSize::Child(1),
+        }
+    }
+
+    fn foreground<T>(self, w: impl WidgetLike<Rsc, T>) -> impl WidgetFn<Rsc, Stack> {
+        move |state| Stack {
+            children: vec![self.add_strong(state), w.add_strong(state)],
+            size: StackSize::Child(0),
+        }
+    }
+
+    fn layer_offset(self, offset: usize) -> impl WidgetFn<Rsc, LayerOffset> {
+        move |state| LayerOffset {
+            inner: self.add_strong(state),
+            offset,
+        }
+    }
+
+    fn to_any(self) -> impl WidgetIdFn<Rsc> {
+        |state| self.add(state)
+    }
+
+    fn set_ptr(self, ptr: WeakWidget<WidgetPtr>, state: &mut Rsc) {
+        let id = self.add_strong(state);
+        state.ui_mut().widgets[ptr].inner = Some(id);
+    }
+}
+
+pub trait CoreWidgetArr<Rsc, const LEN: usize, Wa: WidgetArrLike<Rsc, LEN, Tag>, Tag> {
+    fn span(self, dir: Dir) -> SpanBuilder<Rsc, LEN, Wa, Tag>;
+    fn stack(self) -> StackBuilder<Rsc, LEN, Wa, Tag>;
+}
+
+impl<State, const LEN: usize, Wa: WidgetArrLike<State, LEN, Tag>, Tag>
+    CoreWidgetArr<State, LEN, Wa, Tag> for Wa
+{
+    fn span(self, dir: Dir) -> SpanBuilder<State, LEN, Wa, Tag> {
+        SpanBuilder::new(self, dir)
+    }
+    fn stack(self) -> StackBuilder<State, LEN, Wa, Tag> {
+        StackBuilder::new(self)
+    }
+}